From fb4a26fb21e3bada6dc8238ab00cbc1176dd9feb Mon Sep 17 00:00:00 2001
From: 2heal1 <TwoHeal@163.com>
Date: Thu, 7 May 2026 10:29:24 +0800
Subject: [PATCH 1/4] feat(runtime): add diagnostics milestone 1

---
 .changeset/safe-diagnostics-plugin.md         |    7 +
 MF_LOADING_OBSERVABILITY_ROADMAP.md           | 1047 +++++++++++++
 .../3005-runtime-host/cypress/e2e/app.cy.ts   |  136 ++
 .../3005-runtime-host/package.json            |    3 +-
 .../3005-runtime-host/src/App.tsx             |    8 +-
 .../3005-runtime-host/src/DiagnosticsDemo.tsx |  330 ++++
 .../3005-runtime-host/src/bootstrap.tsx       |   15 +-
 .../src/components/ButtonOldAnt.tsx           |    4 +-
 .../3005-runtime-host/src/diagnostics.ts      |   10 +
 .../3005-runtime-host/src/index.ts            |    2 +-
 .../3005-runtime-host/webpack.config.js       |    2 +
 apps/runtime-demo/README.md                   |   55 +-
 packages/diagnostics-plugin/.eslintrc.json    |   27 +
 packages/diagnostics-plugin/README.md         |  122 ++
 .../__tests__/diagnostics.spec.ts             |  774 +++++++++
 packages/diagnostics-plugin/package.json      |   52 +
 packages/diagnostics-plugin/src/index.ts      | 1383 +++++++++++++++++
 packages/diagnostics-plugin/src/node.ts       |  304 ++++
 packages/diagnostics-plugin/tsconfig.json     |   15 +
 packages/diagnostics-plugin/tsdown.config.ts  |   40 +
 packages/diagnostics-plugin/vitest.config.ts  |   19 +
 packages/runtime-core/__tests__/hooks.spec.ts |  149 ++
 .../__tests__/load-remote-diagnostics.spec.ts |   54 +
 .../__tests__/shared-diagnostics.spec.ts      |  166 ++
 packages/runtime-core/src/core.ts             |   12 +
 packages/runtime-core/src/index.ts            |    6 +-
 .../src/plugins/snapshot/SnapshotHandler.ts   |   28 +-
 packages/runtime-core/src/remote/index.ts     |   99 +-
 packages/runtime-core/src/shared/index.ts     |  496 ++++--
 packages/runtime-core/src/type/config.ts      |   11 +
 .../runtime-core/src/utils/hooks/asyncHook.ts |   13 +-
 .../src/utils/hooks/asyncWaterfallHooks.ts    |   27 +-
 .../runtime-core/src/utils/hooks/syncHook.ts  |    5 +-
 .../src/utils/hooks/syncWaterfallHook.ts      |    5 +-
 packages/runtime-core/src/utils/load.ts       |   20 +
 packages/runtime/src/index.ts                 |    1 +
 pnpm-lock.yaml                                |    9 +
 37 files changed, 5254 insertions(+), 202 deletions(-)
 create mode 100644 .changeset/safe-diagnostics-plugin.md
 create mode 100644 MF_LOADING_OBSERVABILITY_ROADMAP.md
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
 create mode 100644 packages/diagnostics-plugin/.eslintrc.json
 create mode 100644 packages/diagnostics-plugin/README.md
 create mode 100644 packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
 create mode 100644 packages/diagnostics-plugin/package.json
 create mode 100644 packages/diagnostics-plugin/src/index.ts
 create mode 100644 packages/diagnostics-plugin/src/node.ts
 create mode 100644 packages/diagnostics-plugin/tsconfig.json
 create mode 100644 packages/diagnostics-plugin/tsdown.config.ts
 create mode 100644 packages/diagnostics-plugin/vitest.config.ts
 create mode 100644 packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
 create mode 100644 packages/runtime-core/__tests__/shared-diagnostics.spec.ts

diff --git a/.changeset/safe-diagnostics-plugin.md b/.changeset/safe-diagnostics-plugin.md
new file mode 100644
index 00000000000..e04f332d00a
--- /dev/null
+++ b/.changeset/safe-diagnostics-plugin.md
@@ -0,0 +1,7 @@
+---
+"@module-federation/diagnostics-plugin": minor
+"@module-federation/runtime-core": minor
+"@module-federation/runtime": minor
+---
+
+Add an opt-in diagnostics plugin, a Node-specific diagnostics plugin export for file reports, remote and shared lifecycle hooks, console trace hints, safe browser/Node report outputs, shared/eager loading diagnostics, final loading outcome summaries for Module Federation loading reports, no-op return handling for observer hooks, and passive remote diagnostics through runtime load hooks.
diff --git a/MF_LOADING_OBSERVABILITY_ROADMAP.md b/MF_LOADING_OBSERVABILITY_ROADMAP.md
new file mode 100644
index 00000000000..8bb62ea6e22
--- /dev/null
+++ b/MF_LOADING_OBSERVABILITY_ROADMAP.md
@@ -0,0 +1,1047 @@
+# MF Loading Observability Roadmap
+
+## 背景
+
+Module Federation 的问题通常不是单点错误。一次加载可能同时经过 host 配置、remote 配置、manifest、remoteEntry、共享依赖、运行时插件和实际模块执行。现在的报错信息能给出错误码和部分上下文，但还不足以让人或 AI coding 快速判断问题属于哪一侧。
+
+这个方案的终极目标不是把报错文案写长，而是让 MF 加载过程本身变得可观测。报错报告应当从加载过程记录中生成，而不是在抛错点临时拼接一段孤立信息。
+
+## 目标
+
+- 让每一次 MF 加载都能留下安全、结构化、可读取的加载记录。
+- 让错误报告可以还原失败前后的关键路径。
+- 让 AI coding 能基于同一份事实数据判断下一步应该查哪里。
+- 让构建侧信息和运行时信息可以被关联起来分析。
+- 在默认情况下不引入新的数据泄露风险或调试后门。
+
+## 非目标
+
+- 不自动上传诊断数据。
+- 不采集业务数据、源码、远端响应内容、请求头、cookie 或 token。
+- 不把 AI 判断作为运行时行为的一部分。
+- 不让可观测逻辑影响 MF 正常加载结果。
+
+## 第一原则：安全
+
+所有可观测能力都必须遵守以下规则：
+
+- 默认不开启详细采集。
+- 默认不做公网回传。
+- 浏览器侧默认只保存在当前实例或当前页面内存中。
+- Node 侧只写本地诊断文件，且写入失败不能影响构建或运行。
+- URL 必须脱敏，默认移除 query 和 hash。
+- 禁止记录请求头、cookie、authorization、token、secret、session、完整请求参数。
+- 禁止记录 remote 返回内容、源码、模块源码、用户输入和业务数据。
+- 对外导出的报告必须是脱敏后的结果。
+- 全局暴露能力必须最小化，不能把内部状态无边界挂到根对象上。
+- 生产环境默认低噪声；详细诊断需要用户显式开启。
+
+## 现状判断
+
+当前已有一些基础：
+
+- 统一错误码和文档链接。
+- 部分运行时报错能携带 host 配置摘要。
+- Node 侧可以写 `.mf/diagnostics/latest.json`。
+- 部分 remoteEntry 加载错误已经区分了脚本加载失败、脚本执行失败、global 未注册。
+
+主要不足：
+
+- 浏览器侧没有稳定的结构化记录入口。
+- 只记录最近一次错误，不保留加载时间线。
+- 很多错误仍然只是字符串，无法自动判断责任方。
+- 构建信息和运行时错误没有形成稳定关联。
+- shared / eager / 版本匹配类问题缺少完整上下文。
+- AI 需要事实数据，但现在多数信息只存在于错误字符串里。
+
+## 总体设计
+
+整体分三层。
+
+### 1. 加载事件层
+
+工程代码负责记录 MF 加载过程中的事实事件。事件只记录白名单字段。
+
+典型事件：
+
+- `loadRemote:start`
+- `loadRemote:resolved`
+- `loadRemote:success`
+- `loadRemote:error`
+- `manifest:fetch:start`
+- `manifest:fetch:success`
+- `manifest:fetch:error`
+- `remoteEntry:load:start`
+- `remoteEntry:load:success`
+- `remoteEntry:load:error`
+- `remoteEntry:init:start`
+- `remoteEntry:init:success`
+- `remoteEntry:init:error`
+- `expose:get:start`
+- `expose:get:success`
+- `expose:get:error`
+- `share:resolve:start`
+- `share:resolve:success`
+- `share:resolve:miss`
+- `share:resolve:error`
+- `loadRemote:complete`
+
+事件字段建议：
+
+- `traceId`
+- `timestamp`
+- `phase`
+- `status`
+- `hostName`
+- `remoteName`
+- `requestId`
+- `expose`
+- `shareName`
+- `shareScope`
+- `expectedVersion`
+- `resolvedVersion`
+- `provider`
+- `sanitizedUrl`
+- `remoteType`
+- `entryGlobalName`
+- `duration`
+- `errorCode`
+- `errorName`
+- `errorMessage`
+- `ownerHint`
+- `startTime`
+- `endTime`
+- `cached`
+- `attempt`
+- `fallbackUsed`
+- `resultSummary`
+
+`ownerHint` 只能是工程规则给出的初步分类，例如：
+
+- `host`
+- `remote`
+- `network`
+- `manifest`
+- `shared`
+- `runtime-plugin`
+- `unknown`
+
+### 2. 诊断报告层
+
+工程代码基于事件生成事实报告。报告不是 AI 生成的，它应当是确定性的、可测试的、可复现的。
+
+报告包含：
+
+- 本次加载的概要
+- 加载时间线
+- 加载结果
+- 总耗时
+- 失败阶段
+- 原始错误
+- 脱敏后的上下文
+- 可能责任方
+- 可执行的检查建议
+- 关联的构建信息摘要
+
+这里的“可能责任方”和“检查建议”应由工程规则生成，只能基于已记录事实，不允许猜测未采集的信息。
+
+报告不只在失败时生成。成功加载也应当生成可选的 summary，用来回答：
+
+- remote 是否加载成功。
+- manifest 是否命中缓存。
+- remoteEntry 是否重复使用已有 global。
+- expose 是否获取成功。
+- shared 最终命中了哪个提供方和版本。
+- 是否走了 fallback 或 retry。
+- 每个阶段耗时多少。
+- 是否存在“成功但异常”的信号，例如耗时过长、版本命中不符合预期、使用了 fallback。
+
+### 3. AI coding 消费层
+
+AI 不负责生成事实报告。AI 负责读取工程报告，并基于报告做解释、归因、修复建议或代码修改。
+
+推荐边界：
+
+- 工程报告回答“发生了什么”。
+- AI 分析回答“这通常意味着什么、下一步怎么修”。
+- AI 输出必须引用报告里的事实，不应凭空补全缺失数据。
+
+## 报告是 AI 生成还是工程生成
+
+基础报告必须由工程手段生成。
+
+原因：
+
+- 工程生成的报告稳定、可测试、可在没有 AI 的环境里使用。
+- 工程报告可以严格执行脱敏和字段白名单。
+- 工程报告不会编造缺失信息。
+- AI coding 需要的是可靠事实输入，而不是另一个不确定输出。
+
+AI 可以在报告之上生成解释版报告，但它应该是第二层消费结果，不应该替代工程报告。
+
+建议分成两类：
+
+- 事实报告：工程生成，默认能力。
+- 分析报告：AI 基于事实报告生成，可选能力。
+
+## 只看记录的信息是否足够
+
+只看原始事件记录不够。
+
+原始记录是必要基础，但它通常太碎。人和 AI 都还需要一个归一化后的摘要，才能快速知道：
+
+- 哪一步失败
+- 失败前已经完成了哪些步骤
+- 哪些信息缺失
+- 应该优先检查 host、remote、网络、manifest 还是 shared
+
+因此需要同时保留两种产物：
+
+- 事件时间线：完整事实，用于深挖。
+- 诊断报告：从时间线聚合出来，用于快速定位。
+
+如果只保留报告，不保留事件，后续无法追溯细节。  
+如果只保留事件，不生成报告，AI 和人都需要重复做整理工作。
+
+## 加载结果可观测方案
+
+可观测不是只收集报错。成功加载也需要记录，因为很多问题不会直接抛错，例如加载慢、使用了 fallback、命中了非预期 shared 版本、remoteEntry 被缓存复用、manifest 内容和 host 预期不一致。
+
+### 成功事件要记录什么
+
+成功事件应当记录：
+
+- 本次 `traceId`。
+- 请求的 `requestId`。
+- 匹配到的 remote 名称。
+- expose 名称。
+- manifest URL 是否存在。
+- manifest 是否 fetch 成功。
+- manifest 是否来自缓存。
+- remoteEntry URL。
+- remoteEntry 类型。
+- remoteEntry 是否新加载。
+- remoteEntry 是否复用已有 global。
+- remoteEntry init 是否完成。
+- expose factory 是否获取成功。
+- expose module 是否执行完成。
+- shared 命中的 provider。
+- shared 命中的版本。
+- 是否使用 fallback。
+- 是否发生 retry。
+- 每个阶段耗时。
+- 总耗时。
+- 业务组件是否主动声明成功加载。
+
+这些信息都必须是结构化字段，不能只写在字符串里。
+
+### 成功报告
+
+成功报告是加载链路的整理版，不是错误报告。它应包含：
+
+- `traceId`
+- `status: "success"`
+- host 摘要
+- remote 摘要
+- expose 摘要
+- shared 命中摘要
+- 阶段耗时
+- 是否缓存命中
+- 是否 retry
+- 是否 fallback
+- 构建信息关联摘要
+
+成功报告默认不一定需要 console 输出。建议由插件配置控制：
+
+- `level: "error"` 只在失败时生成详细报告。
+- `level: "summary"` 记录成功摘要和失败报告。
+- `level: "verbose"` 记录完整成功和失败时间线。
+
+### 成功但需要关注的信号
+
+插件可以基于工程规则标记 warning，但不能改变加载结果：
+
+- remoteEntry 加载耗时超过阈值。
+- manifest 加载耗时超过阈值。
+- 使用了 retry 后才成功。
+- 使用了 fallback。
+- shared 命中 provider 与预期不一致。
+- shared 命中版本低于推荐版本。
+- remote manifest 的 buildVersion 与预期不一致。
+- expose 成功但来自非预期 remote。
+
+这些 warning 应进入报告，供 AI 判断是否需要继续排查。
+
+### AI 如何使用成功记录
+
+AI 看到成功记录后，可以回答：
+
+- 当前 MF 加载链路是否完整成功。
+- 慢在 manifest、remoteEntry、init、shared 还是 expose。
+- shared 实际用了谁。
+- remote 是否来自预期地址和构建版本。
+- 是否存在 fallback / retry / cache 复用。
+
+因此，AI coding 不只在报错时使用诊断文件，也可以在“页面能跑但行为不对”时读取最近一次成功 trace。
+
+### 业务组件成功加载事件
+
+runtime-core 和 diagnostics plugin 可以自动判断技术层成功，但不能判断业务组件是否真正完成业务加载。因此需要给业务暴露一个固定接口，由业务组件在合适时机主动调用。
+
+固定事件名：
+
+- `component:business-loaded`
+
+固定语义：
+
+- 业务组件已经完成自身定义的成功加载。
+- 这个事件由业务代码主动触发。
+- 这个事件不是 React mount，也不是 expose factory 执行成功。
+- 业务可以自定义什么时候调用，但事件名和基础字段必须固定。
+
+建议 API：
+
+```ts
+diagnostics.markComponentLoaded({
+  traceId,
+  requestId: 'remote/Button',
+  componentName: 'Button',
+});
+```
+
+事件字段：
+
+- `traceId`
+- `requestId`
+- `componentName`
+- `phase: "component"`
+- `eventName: "component:business-loaded"`
+- `status: "success"`
+- `timestamp`
+- `source: "business"`
+
+可选扩展字段：
+
+- `reason`
+- `duration`
+- `metadata`
+
+安全限制：
+
+- `metadata` 必须经过用户自定义 sanitize。
+- 不记录 props。
+- 不记录接口响应体。
+- 不记录用户输入。
+- 不记录业务数据明细。
+
+AI 看到这个事件后，才能判断：
+
+- MF 技术加载成功。
+- 组件挂载或渲染链路已完成。
+- 业务组件声明自己已成功加载。
+
+如果没有这个事件，AI 只能说“技术加载成功，但业务组件是否成功加载未声明”。
+
+## 安全数据策略
+
+允许记录：
+
+- host 名称
+- remote 名称
+- expose 请求名
+- shared 包名
+- shared 版本约束
+- 实际命中的 shared 版本
+- remoteEntry 类型
+- entryGlobalName
+- 脱敏后的 URL
+- 错误码
+- 错误名称
+- 脱敏后的错误消息
+- 阶段耗时
+
+禁止记录：
+
+- cookie
+- request headers
+- authorization
+- token
+- secret
+- session
+- 完整 query
+- hash
+- remote 响应体
+- 源码
+- 模块执行结果
+- 用户业务数据
+
+URL 脱敏规则：
+
+- 保留 protocol、host、pathname。
+- 默认删除 query 和 hash。
+- 对常见敏感字段做兜底过滤。
+- 如果 URL 无法解析，按字符串做保守清洗。
+
+## 能力形态和输出入口
+
+可观测能力应以 runtime plugin 形式提供，形态类似 `@module-federation/retry-plugin`。runtime-core 只提供必要 hook、事件上下文和安全策略，不内置完整收集器，也不默认保存诊断数据。
+
+建议新增独立插件：
+
+- `@module-federation/diagnostics-plugin`
+
+使用方式：
+
+```ts
+import { createInstance } from '@module-federation/runtime';
+import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
+
+const diagnostics = DiagnosticsPlugin({
+  level: 'error',
+  maxEvents: 100,
+  onReport(report) {
+    // 用户自行接入日志、监控或 AI coding 工具
+  },
+});
+
+const mf = createInstance({
+  name: 'host',
+  remotes: [],
+  plugins: [diagnostics.plugin],
+});
+
+diagnostics.getLatestReport();
+diagnostics.getEvents();
+```
+
+### 输出从哪里拿
+
+插件应提供多种可选输出入口，默认只在内存中保存：
+
+- 插件 controller：`diagnostics.getEvents()`、`diagnostics.getLatestReport()`、`diagnostics.clear()`。
+- 回调：`onEvent(event)`、`onReport(report)`。
+- Node 本地文件：通过 `@module-federation/diagnostics-plugin/node` 的 `DiagnosticsPlugin` 显式开启后写 `.mf/diagnostics/events.jsonl` 和 `.mf/diagnostics/latest.json`。
+- 浏览器只读全局入口：只有显式开启后才暴露，例如 `globalThis.__FEDERATION__.__DIAGNOSTICS__`。
+- thrown error 附带最小报告 id 或摘要，但不把完整报告塞进错误字符串。
+
+构建插件注入 runtime plugin 的场景不能拿到外部 controller，因此主要依赖 `onReport`、Node 文件或显式全局入口。
+
+### AI 自动感知和读取流程
+
+目标是让 AI coding 尽量不依赖用户手动复制完整报错。插件应在安全前提下给 AI 一个稳定的发现信号，再提供可读取的脱敏报告。
+
+Node / SSR / build 场景：
+
+- MF 加载失败时，console 打印固定格式的诊断提示。
+- 提示中包含 `traceId` 和诊断文件路径。
+- 插件写入 `.mf/diagnostics/latest.json`。
+- 插件追加 `.mf/diagnostics/events.jsonl`。
+- AI 从终端输出识别 `traceId`。
+- AI 读取 `latest.json`。
+- 如果 `latest.json` 不够，再按 `traceId` 去 `events.jsonl` 查完整事件时间线。
+
+推荐 console 格式：
+
+```txt
+[Module Federation] Diagnostic report generated
+traceId: mf-trace-xxx
+latest: .mf/diagnostics/latest.json
+events: .mf/diagnostics/events.jsonl
+```
+
+浏览器 dev 场景：
+
+- MF 加载失败时，console 打印固定格式的诊断提示。
+- AI 可以通过 CDP 或浏览器调试能力监听 console。
+- 如果启用了只读全局入口，AI 可以按 `traceId` 调用 `getReport(traceId)`。
+- 如果没有启用全局入口，console 只提示用户如何导出脱敏报告。
+
+推荐 console 格式：
+
+```txt
+[Module Federation] Diagnostic report generated
+traceId: mf-trace-xxx
+Run: __FEDERATION__.__DIAGNOSTICS__.getReport("mf-trace-xxx")
+```
+
+浏览器 prod 场景：
+
+- 默认不暴露全局报告入口。
+- 默认不写浏览器持久存储。
+- console 只输出最小错误码、`traceId` 和安全提示。
+- 完整报告只能通过用户显式开启的导出接口、`onReport` 上传到用户自己的系统，或用户主动导出。
+- AI 不应绕过页面安全边界读取完整报告。
+
+prod 推荐 console 格式：
+
+```txt
+[Module Federation] Diagnostic report available
+traceId: mf-trace-xxx
+Ask the application owner to export the sanitized diagnostic report.
+```
+
+### 诊断文件分工
+
+`.mf/diagnostics/latest.json` 是最近一次诊断报告。它是给人和 AI 快速读取的整理版结构，应包含：
+
+- `traceId`
+- host 摘要
+- remote 摘要
+- 失败阶段
+- 错误码
+- 初步责任方
+- 脱敏后的关键上下文
+- 建议检查项
+
+`.mf/diagnostics/events.jsonl` 是完整事件流水。一行一个 JSON，用来保存多次加载、多阶段事件和同一 `traceId` 下的完整时间线。
+
+AI 默认读取顺序：
+
+- 先读 `latest.json`。
+- 如果需要更多细节，再用 `traceId` 过滤 `events.jsonl`。
+
+### runtime-core 需要补什么
+
+runtime-core 只补底层能力：
+
+- 增加或复用最小生命周期 hook，例如 `afterLoadRemote`、`afterLoadEntry`、`afterLoadShare`、`errorLoadShare`。
+- 在主流程关键阶段暴露开始、成功、失败这类事实。
+- 给 hook 补齐必要的基础上下文，例如 `requestId`、`remoteInfo`、`shareInfo`。
+- 不在 runtime-core 里计算版本不匹配、missing provider、eager 边界这类诊断原因。
+- 对有返回值语义的 hook 采用“未返回内容即不干预”的规则，让诊断插件可以安全旁听 `onLoad`、`errorLoadRemote` 这类已有 hook。
+- 保证没有 diagnostics plugin 时行为完全不变。
+
+runtime-core 不负责：
+
+- 持久化报告。
+- 对外暴露全局调试对象。
+- 上传诊断数据。
+- 生成 AI 分析结论。
+- 保存完整事件历史。
+- 组装 shared 诊断报告字段。
+
+### 插件负责什么
+
+diagnostics plugin 负责：
+
+- 是否启用收集。
+- 事件过滤级别。
+- URL、错误消息和 stack 脱敏。
+- 事件缓存上限。
+- 报告聚合。
+- 从 `beforeRequest`、`onLoad`、`afterLoadRemote`、`errorLoadRemote` 旁听 remote 加载开始、成功、失败和结束，且不返回内容。
+- 从 `loadEntry`、`afterLoadEntry`、snapshot resolve hook 旁听 manifest、remoteEntry 这些阶段。
+- 从 runtime hook 的基础上下文推导 shared / eager 具体原因。
+- 输出到 callback、controller、Node 专用入口文件或显式全局入口。
+- 用户自定义 sanitize 规则。
+
+诊断插件可以注册 `errorLoadRemote` 这类已有 hook 做旁听，但必须遵守“不返回内容，不参与恢复”的约束。这样既能复用已有 hook，也不会影响 `@module-federation/retry-plugin` 或用户插件返回兜底结果。`loadEntryError`、`fetch` 这类更贴近重试控制的 hook 暂时不由 diagnostics plugin 接管。
+
+`errorLoadShare` 目前只作为 shared 诊断观察 hook，不默认接入 retry-plugin。shared miss、版本不匹配、eager 边界通常不是临时网络错误，默认重试容易掩盖真实配置问题。后续如果要支持 shared retry，应该作为独立可选能力，由用户明确指定可重试条件。
+
+## 安全配置和插件配置
+
+不建议把所有可观测选项都放进 runtime-core 顶层 `observability`。更合理的边界是：
+
+- `security.diagnostics`：安全策略，由 runtime-core 识别，作为所有诊断插件必须遵守的上限。
+- `DiagnosticsPlugin(options)`：通用功能配置，由插件控制收集、内存输出、回调和浏览器显式读取。
+- `@module-federation/diagnostics-plugin/node` 的 `DiagnosticsPlugin(options)`：Node 专用入口，额外提供本地文件输出。
+
+建议的 `security.diagnostics`：
+
+```ts
+createInstance({
+  name: 'host',
+  security: {
+    diagnostics: {
+      enabled: false,
+      console: true,
+      browserGlobal: false,
+      fileOutput: false,
+      redactUrlQuery: true,
+      redactUrlHash: true,
+      maxErrorStackLines: 5,
+      maxEvents: 100,
+      redactKeys: ['token', 'secret', 'authorization', 'cookie', 'session'],
+    },
+  },
+  plugins: [DiagnosticsPlugin()],
+});
+```
+
+建议的插件配置：
+
+```ts
+DiagnosticsPlugin({
+  level: 'error',
+  maxEvents: 100,
+  console: true,
+  browser: {
+    enabled: false,
+    scope: 'host',
+  },
+  onReport(report) {},
+});
+```
+
+建议的 Node 插件配置：
+
+```ts
+import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin/node';
+
+DiagnosticsPlugin({
+  level: 'error',
+  maxEvents: 100,
+  console: true,
+  directory: '.mf/diagnostics',
+  onReport(report) {},
+});
+```
+
+规则：
+
+- `security.diagnostics` 是上限，插件不能绕过。
+- 插件可以选择更严格，但不能比 `security.diagnostics` 更宽。
+- 如果 `security.diagnostics.enabled` 为 `false`，插件可以不收集，或只保留最小错误摘要。
+- 如果 `browserGlobal` 为 `false`，插件不能暴露全局读取入口。
+- 如果 `fileOutput` 为 `false`，插件不能写诊断文件。
+
+这样既能满足用户选择性添加和定制，也能保证安全边界由核心配置统一约束。
+
+## 运行时报错信息收集方案
+
+运行时报错信息收集不是简单保存 `Error.message`。它需要把错误发生时的加载阶段、调用上下文和已知配置一起保存下来。
+
+### 收集入口
+
+第一批应覆盖这些入口：
+
+- `loadRemote`
+- `getRemoteModuleAndOptions`
+- `getRemoteEntry`
+- `loadEntryScript`
+- `loadEntryNode`
+- `Module.getEntry`
+- `Module.init`
+- `Module.get`
+- `SharedHandler.loadShare`
+- `SharedHandler.loadShareSync`
+- `SharedHandler.initializeSharing`
+- `SnapshotHandler.getManifestJson`
+
+这些入口覆盖了 remote 解析、manifest 获取、remoteEntry 加载、remote 初始化、expose 获取和 shared 解析。
+
+### 运行时报错事件字段
+
+运行时报错事件应当至少包含：
+
+- `traceId`
+- `eventId`
+- `timestamp`
+- `phase`
+- `status: "error"`
+- `hostName`
+- `hostId`
+- `requestId`
+- `remoteName`
+- `remoteAlias`
+- `remoteType`
+- `entryGlobalName`
+- `sanitizedUrl`
+- `expose`
+- `shareName`
+- `shareScope`
+- `requiredVersion`
+- `availableVersions`
+- `selectedVersion`
+- `provider`
+- `from`
+- `lifecycle`
+- `errorCode`
+- `errorName`
+- `errorMessage`
+- `errorStack`
+- `ownerHint`
+- `retryable`
+
+`errorStack` 默认只保留当前错误栈的前几行，并且必须经过脱敏。生产环境可以只保留 `errorName` 和 `errorMessage`。
+
+### 错误分类规则
+
+工程侧应提供确定性的分类规则：
+
+- `RUNTIME-001`: remoteEntry 已加载但未注册到预期 global，优先指向 remote 产物或 `entryGlobalName` 配置。
+- `RUNTIME-002`: remoteEntry 接口不完整，优先指向 remote 产物。
+- `RUNTIME-003`: manifest 获取或解析失败，优先指向 manifest 地址、网络、manifest 内容结构。
+- `RUNTIME-004`: host 无法匹配 remote，优先指向 host remotes 配置或请求 id。
+- `RUNTIME-005`: 构建运行时同步消费 shared 失败，优先指向 eager / async boundary / shared 配置。
+- `RUNTIME-006`: 纯运行时同步消费 shared 失败，优先指向调用方式或 shared 未就绪。
+- `RUNTIME-008`: remoteEntry 资源加载失败，继续细分为 timeout、network、script execution、unknown。
+- `RUNTIME-011`: manifest 中缺 remoteEntry URL，优先指向 remote manifest 产物。
+- `RUNTIME-012`: shared getter 不可用，优先指向 `shared.import: false` 和 host 未提供对应依赖。
+
+### 运行时报告生成
+
+当错误发生时，工程代码应做三件事：
+
+- 记录一条脱敏后的 `error` 事件。
+- 把错误事件和同一 `traceId` 的前序事件聚合成事实报告。
+- 保留现有错误码、错误文案和文档链接，避免破坏用户已有排查路径。
+
+报告里不要写“AI 判断”。报告只写工程规则能确认的事实和初步分类。
+
+### 存储策略
+
+浏览器侧：
+
+- 默认不启用。
+- 启用后保存在实例内存中。
+- 只有 `exposeGlobal: true` 时才暴露只读入口。
+- 不写 localStorage、sessionStorage、IndexedDB。
+
+Node 侧：
+
+- 默认不启用详细事件。
+- 启用后可以写 `.mf/diagnostics/events.jsonl` 和 `.mf/diagnostics/latest.json`。
+- 文件写入失败不能影响运行。
+- 文件内容必须脱敏。
+
+## 构建信息收集方案
+
+构建信息的目标不是记录完整构建产物，而是生成一份可以和运行时报错关联的最小摘要。
+
+### 收集来源
+
+第一批应从这些位置收集：
+
+- Module Federation 插件原始配置摘要。
+- manifest 输出。
+- stats 输出。
+- normalized remotes。
+- normalized shared。
+- exposes 映射。
+- remoteEntry 文件名和类型。
+- plugin version。
+- bundler name。
+- build version。
+
+### 构建信息字段
+
+构建摘要建议包含：
+
+- `buildId`
+- `name`
+- `bundler`
+- `pluginVersion`
+- `buildVersion`
+- `remoteEntry`
+- `remoteEntryType`
+- `publicPathMode`
+- `remotes`
+- `exposes`
+- `shared`
+- `manifestFile`
+- `statsFile`
+
+`shared` 只保留诊断必要字段：
+
+- `name`
+- `version`
+- `requiredVersion`
+- `singleton`
+- `strictVersion`
+- `eager`
+- `shareScope`
+- `import`
+
+`remotes` 只保留：
+
+- `name`
+- `alias`
+- `entry`
+- `type`
+- `shareScope`
+
+`exposes` 只保留 expose key 和脱敏后的请求摘要，不记录源码内容。
+
+### 禁止收集的构建信息
+
+- 本地绝对路径。
+- 环境变量。
+- 源码内容。
+- loader 完整参数。
+- 插件完整 options 对象。
+- 远端响应内容。
+- 带 token 的 URL。
+- 私有 registry token。
+
+如果必须保留路径用于定位，只能保留相对项目根的路径，并需要确认不会泄露用户目录或内部机器信息。
+
+### 构建信息产物
+
+建议新增一个脱敏构建摘要产物：
+
+- `.mf/diagnostics/build-info.json`
+
+它应当可以由构建插件生成，也可以从 manifest / stats 中还原。生成失败不能影响构建。
+
+运行时报错报告可以通过以下字段关联构建信息：
+
+- host `name`
+- remote `name`
+- `buildVersion`
+- `pluginVersion`
+- `remoteEntry`
+- manifest `id`
+
+### 构建和运行时关联方式
+
+运行时加载 remote 时，优先从 manifest 获取 remote 构建摘要。如果没有 manifest，只记录 remoteEntry 层面的摘要。
+
+关联规则：
+
+- host 侧报告记录 host 构建摘要。
+- remote manifest 可用时，报告记录 remote 构建摘要。
+- shared 报错时，报告同时列出 host 提供摘要和 remote 需求摘要。
+- expose 报错时，报告关联 remote manifest 中的 exposes 摘要。
+
+这样 AI coding 可以判断：
+
+- host 是否配置了这个 remote。
+- remote manifest 是否声明了这个 expose。
+- host 和 remote 的 shared 版本条件是否能匹配。
+- 运行时加载的 remoteEntry 是否来自预期构建。
+
+## Roadmap
+
+### Milestone 1: 前置任务，诊断验证 Demo 和最小闭环
+
+状态：已完成。当前 demo、最小插件、运行时 hook、输出入口和验证测试已经形成第一阶段闭环。
+
+这一步要先于完整能力建设。它的目标不是做展示页面，而是先建立一个稳定、可重复的验证场景，保证后续每一次加事件、加报告字段、加插件输出，都能在同一套 demo 和测试里验证成功、失败和脱敏结果。
+
+实现边界：runtime-core 只负责主流程生命周期 hook，例如 remote 加载成功、失败、manifest / remoteEntry 基础状态和 shared 成功、失败；diagnostics plugin 负责整理事件、推导具体原因和最终加载结论，并输出报告。
+
+#### Demo 验证场景
+
+- [x] 新增或复用现有 runtime demo，建立一组专用 diagnostics host / remote 场景。
+- [x] demo 支持正常加载 remote 组件，并能触发成功加载事件。
+- [x] demo 支持 remoteEntry / manifest 地址错误场景。
+- [x] demo 支持 remoteEntry globalName 或 expose 不存在场景。
+- [x] demo 支持业务组件主动上报 `component:business-loaded`。
+- [x] demo 支持 shared miss、shared 版本不匹配、eager 配置错误场景。
+- [x] demo 提供稳定的按钮、路由或测试入口，方便 e2e 自动触发。
+- [x] demo 默认不暴露诊断信息，只有显式开启 diagnostics plugin 时才输出。
+- [x] demo 输出必须经过 URL 和错误信息脱敏。
+- [x] demo 作为后续 Phase 的固定验收入口，不为单个实现临时造一次性测试。
+
+#### 最小能力闭环
+
+- [x] 定义最小 `security.diagnostics` 配置和默认关闭行为。
+- [x] 定义最小事件数据结构。
+- [x] 定义最小报告数据结构。
+- [x] 在 runtime-core 增加最小 lifecycle hook 和必要上下文。
+- [x] 新增最小 `DiagnosticsPlugin`，先只支持内存输出和回调输出。
+- [x] 记录 `loadRemote` 成功和失败。
+- [x] 记录 manifest 获取成功和失败。
+- [x] 记录 remoteEntry 加载成功和失败。
+- [x] 生成最近一次 in-memory report。
+- [x] dev / Node 场景输出固定 console 提示，包含 `traceId`。
+- [x] 确认没有 diagnostics plugin 时现有行为完全不变。
+- [x] 确认 diagnostics 自身异常不会影响 MF 加载。
+- [x] 补充默认关闭、显式开启、URL 脱敏、成功 trace、失败 trace / report 的测试。
+
+#### Milestone 1 完成标准
+
+- [x] demo 能稳定跑通一次成功加载。
+- [x] demo 能稳定复现至少一种 remoteEntry / manifest 加载失败。
+- [x] 成功和失败都能生成可读取的脱敏 report。
+- [x] AI 或人能从 console 中拿到 `traceId`，再读取对应 report。
+- [x] 默认不启用 diagnostics 时，demo 和现有测试行为不变。
+- [x] 这一步完成后，再进入后续 Phase 0 - Phase 10 的完整能力建设。
+
+### Phase 0: 安全边界和数据模型
+
+- [ ] 定义 `security.diagnostics` 安全策略和默认值。
+- [ ] 定义 `DiagnosticsPlugin` 插件配置和默认值。
+- [ ] 定义事件字段白名单。
+- [ ] 定义 URL 和错误消息脱敏规则。
+- [ ] 定义事件时间线数据结构。
+- [ ] 定义诊断报告数据结构。
+- [ ] 定义运行时报错事件数据结构。
+- [ ] 定义构建信息摘要数据结构。
+- [ ] 明确浏览器和 Node 的存储边界。
+- [ ] 明确运行时报错和构建信息的字段白名单。
+- [ ] 明确运行时报错和构建信息的禁止字段。
+- [ ] 明确插件配置不能绕过 `security.diagnostics`。
+- [ ] 补充默认不开启、开启后脱敏的测试。
+
+### Phase 1: runtime-core 事件 hook 底座
+
+- [x] 在 runtime-core 中增加最小 lifecycle hook，供插件旁听主流程状态。
+- [x] 复用 `onLoad`、`errorLoadRemote`，供 diagnostics plugin 观察 remote 加载，不影响 retry / fallback。
+- [x] 给关键 hook 补齐 `phase`、`requestId`、`remoteInfo`、`shareInfo` 等必要上下文。
+- [x] 记录 `loadRemote` 开始、成功、失败。
+- [x] 记录 `loadRemote` complete 事件，用于统一收口成功和失败。
+- [ ] 记录 remote 匹配结果。
+- [x] 记录 manifest 获取开始、成功、失败。
+- [x] 记录 remoteEntry 加载开始、成功、失败。
+- [ ] 记录 remoteEntry init 开始、成功、失败。
+- [ ] 记录 expose 获取开始、成功、失败。
+- [ ] 记录阶段耗时和总耗时。
+- [x] 记录 cache、retry、fallback 的基础结果标记。
+- [x] 确认没有 diagnostics plugin 时行为完全不变。
+- [x] 确认 lifecycle hook 失败不会影响 MF 加载。
+- [x] 确认 diagnostics plugin 旁听 `errorLoadRemote` 时不接管返回路径。
+- [x] 补充 runtime-core 单测。
+
+### Phase 2: diagnostics plugin 输出能力
+
+- [x] 新建 `@module-federation/diagnostics-plugin`。
+- [x] 提供插件 controller：`getEvents()`、`getLatestReport()`、`clear()`。
+- [x] 提供 `onEvent` 和 `onReport` 回调。
+- [x] 支持内存输出。
+- [x] 通过 Node 专用入口支持显式开启的 Node 本地文件输出。
+- [x] 支持显式开启的浏览器只读全局入口。
+- [x] 确认插件输出受 `security.diagnostics` 约束。
+- [x] 补充插件配置和输出单测。
+
+### Phase 3: 加载成功信息收集
+
+- [x] 收集加载成功 summary。
+- [ ] 收集 manifest 成功、缓存命中和耗时。
+- [ ] 收集 remoteEntry 成功、新加载或复用已有 global。
+- [ ] 收集 remoteEntry init 成功和耗时。
+- [ ] 收集 expose factory 获取成功和耗时。
+- [ ] 收集 expose module 执行成功和耗时。
+- [ ] 收集 shared 命中的 provider、版本和 shareScope。
+- [ ] 收集 retry / fallback / cache 标记。
+- [x] 定义固定事件 `component:business-loaded`。
+- [x] 提供 `markComponentLoaded` 业务调用接口。
+- [x] 将业务组件成功加载事件关联到同一 `traceId`。
+- [ ] 确认业务 metadata 经过 sanitize 后才能进入报告。
+- [ ] 支持 `level: "summary"` 和 `level: "verbose"` 的成功记录策略。
+- [x] 补充成功链路单测。
+
+### Phase 4: 运行时报错信息收集
+
+- [ ] 接入统一运行时报错事件记录。
+- [ ] 收集错误码、错误名称、脱敏错误消息。
+- [ ] 收集当前加载阶段和生命周期。
+- [ ] 收集 host、remote、requestId、expose、shared 摘要。
+- [ ] 对错误栈做脱敏和长度限制。
+- [ ] 为 `RUNTIME-001` 增加 remoteEntry global 相关上下文。
+- [ ] 为 `RUNTIME-003` 增加 manifest URL、remote 名称、解析阶段上下文。
+- [ ] 为 `RUNTIME-004` 增加 host remotes 摘要和请求 id。
+- [ ] 为 `RUNTIME-008` 增加 timeout、network、script execution 分类。
+- [ ] 确认错误收集失败不会覆盖原始错误。
+- [ ] 补充运行时报错收集单测。
+
+### Phase 5: shared / eager 可观测
+
+- [x] 记录 shared 解析开始。
+- [x] 记录 host 当前提供的 shared 摘要。
+- [x] 记录最终命中的 shared 提供方和版本。
+- [x] 记录 shared miss。
+- [x] 记录 eager 相关同步加载失败。
+- [x] 标记 shared 问题的初步责任方。
+- [x] 确认 `errorLoadShare` 只做诊断观察，不默认接入 retry-plugin。
+- [x] 补充 shared、eager、strictVersion、singleton 场景测试。
+
+### Phase 6: 构建信息收集
+
+- [ ] 从构建插件配置生成脱敏配置摘要。
+- [ ] 从 manifest / stats 生成脱敏构建摘要。
+- [ ] 收集 bundler name、plugin version、build version。
+- [ ] 收集 remoteEntry 文件名、类型和 publicPath 模式。
+- [ ] 收集 remotes 摘要。
+- [ ] 收集 exposes 摘要。
+- [ ] 收集 shared 摘要。
+- [ ] 生成 `.mf/diagnostics/build-info.json`。
+- [ ] 确认构建信息生成失败不影响构建。
+- [ ] 补充构建信息脱敏测试。
+
+### Phase 7: 构建信息和运行时关联
+
+- [ ] 在 manifest / stats 中确认已有字段是否足够。
+- [ ] 补齐必要的 shared、exposes、remotes、插件版本、构建版本摘要。
+- [ ] 运行时报告关联 remote manifest 信息。
+- [ ] 构建侧错误也输出同一类诊断报告。
+- [ ] shared 报错时同时展示 host 提供摘要和 remote 需求摘要。
+- [ ] expose 报错时关联 remote manifest exposes 摘要。
+- [ ] remoteEntry 报错时关联 remoteEntry 类型、globalName 和构建版本。
+- [ ] 避免把本地绝对路径、源码、环境变量写入可导出报告。
+
+### Phase 8: 报告生成
+
+- [x] 从 trace 生成成功 summary。
+- [ ] 从 trace 生成事实报告。
+- [ ] 将现有 RUNTIME 错误接入报告。
+- [ ] 将 `RUNTIME-001` 报告关联 remoteEntry globalName。
+- [ ] 将 `RUNTIME-003` 报告关联 manifest URL 和 remote 名称。
+- [ ] 将 `RUNTIME-004` 报告关联 host remotes 列表摘要。
+- [ ] 将 `RUNTIME-005` / `RUNTIME-006` 报告关联 shared 和 eager 信息。
+- [ ] 将 `RUNTIME-008` 报告区分网络、超时、执行失败。
+- [ ] 保留原始错误码和现有文档链接。
+
+### Phase 9: AI coding 入口
+
+- [ ] 提供稳定的读取入口。
+- [x] Node / SSR / build 场景输出固定格式 console 提示。
+- [x] Node / SSR / build 场景写入 `.mf/diagnostics/latest.json`。
+- [x] Node / SSR / build 场景追加 `.mf/diagnostics/events.jsonl`。
+- [x] 浏览器 dev 场景输出可被 CDP 识别的固定格式 console 提示。
+- [x] 浏览器 dev 场景支持显式开启的只读全局入口。
+- [ ] 浏览器 prod 场景默认只输出最小错误码和 `traceId`。
+- [ ] 浏览器 prod 场景完整报告只允许通过显式导出或用户自有系统获取。
+- [ ] 明确 `latest.json` 和 `events.jsonl` 的格式和读取顺序。
+- [x] 提供最近一次加载报告。
+- [ ] 提供最近 N 次加载报告。
+- [x] 支持按 `traceId` 读取成功或失败报告。
+- [ ] 支持按 remote / expose / shared 查询最近加载记录。
+- [ ] 提供脱敏导出方法。
+- [x] Node 侧通过 Node 专用入口支持本地诊断文件。
+- [x] 浏览器侧支持显式开启的内存读取。
+- [ ] 给 AI 消费格式写示例。
+
+### Phase 10: 文档和场景验证
+
+- [ ] 文档说明如何开启安全可观测。
+- [ ] 文档说明导出的报告不包含哪些敏感信息。
+- [ ] 增加成功加载场景。
+- [ ] 增加成功但 retry 后恢复场景。
+- [ ] 增加成功但 fallback 生效场景。
+- [ ] 增加成功但 shared 命中非预期 provider 场景。
+- [x] 增加业务主动标记 `component:business-loaded` 场景。
+- [ ] 增加 remote URL 错误场景。
+- [ ] 增加 remoteEntry globalName 错误场景。
+- [ ] 增加 manifest 缺字段场景。
+- [ ] 增加 remoteEntry 自身执行错误场景。
+- [ ] 增加 host 未提供 shared 场景。
+- [ ] 增加 shared 版本不满足场景。
+- [ ] 增加 eager 配错场景。
+
+## 第一批建议落地范围
+
+第一批就是 Milestone 1，不直接做完整闭环。
+
+优先顺序是：
+
+- 先做 diagnostics demo，确保后续改动都有固定验证入口。
+- 再做最小安全配置、最小事件、最小报告和最小插件输出。
+- 先覆盖 remote / manifest / remoteEntry 的成功和失败。
+- 先保证默认关闭、显式开启、URL 脱敏、记录失败不影响加载。
+
+第一批完成后，再接 shared / eager、构建信息关联、浏览器生产环境导出等更完整能力。这样可以先把可验证底座稳定下来，避免一开始把诊断逻辑和所有错误点耦合在一起。
+
+## 验收标准
+
+- 默认不开启时，现有行为不变。
+- 有固定 demo 可以验证后续诊断能力。
+- 开启后可以读取脱敏后的加载事件。
+- 成功加载时可以读取加载 summary。
+- 失败报告可以指出失败阶段。
+- 报告不包含 query、hash、header、cookie、token、源码、remote 响应体。
+- trace 逻辑异常不会影响 MF 加载。
+- runtime-core 相关测试通过。
+- 构建通过。
diff --git a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
index 4383ea93ec1..0cd95166738 100644
--- a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
+++ b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
@@ -1,5 +1,8 @@
 import { getH1, getH3 } from '../support/app.po';
 
+const getDiagnosticsReader = (win: Cypress.AUTWindow) =>
+  (win as any).__FEDERATION__?.__DIAGNOSTICS__?.runtime_host;
+
 describe('3005-runtime-host/', () => {
   beforeEach(() => cy.visit('/'));
 
@@ -77,4 +80,137 @@ describe('3005-runtime-host/', () => {
       });
     });
   });
+
+  describe('diagnostics demo fixture', () => {
+    beforeEach(() => cy.visit('/diagnostics'));
+
+    it('should expose a successful remote loading scenario', () => {
+      cy.get('[data-testid="diagnostics-load-success"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('success');
+      cy.get('[data-testid="diagnostics-remote-result"]')
+        .find('button.test-remote2')
+        .contains('Button from antd@4.24.15');
+      cy.window().then((win) => {
+        const reader = getDiagnosticsReader(win);
+        expect(reader).to.exist;
+
+        const latestReport = reader.getLatestReport();
+        expect(latestReport.status).to.equal('success');
+        expect(latestReport.summary.runtimeLoaded).to.equal(true);
+        expect(latestReport.summary.loadCompleted).to.equal(true);
+        expect(latestReport.summary.componentLoaded).to.equal(false);
+        expect(latestReport.summary.outcome).to.equal('runtime-loaded');
+      });
+      cy.get('[data-testid="diagnostics-business-loaded"]').click();
+      cy.get('[data-testid="diagnostics-report"]').contains(
+        'component:business-loaded',
+      );
+      cy.window().then((win) => {
+        const reader = getDiagnosticsReader(win);
+        expect(reader).to.exist;
+
+        const latestReport = reader.getLatestReport();
+        expect(latestReport.status).to.equal('success');
+        expect(latestReport.summary.componentLoaded).to.equal(true);
+        expect(latestReport.summary.outcome).to.equal('component-loaded');
+        expect(reader.getReport(latestReport.traceId).traceId).to.equal(
+          latestReport.traceId,
+        );
+      });
+    });
+
+    it('should expose a failed remote loading scenario', () => {
+      cy.window().then((win) => {
+        cy.spy(win.console, 'warn').as('diagnosticsWarn');
+      });
+      cy.get('[data-testid="diagnostics-load-missing-expose"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
+      cy.get('[data-testid="diagnostics-report"]').contains(
+        'dynamic-remote/__missing_expose__',
+      );
+      cy.get('[data-testid="diagnostics-error-message"]').should(
+        'not.contain',
+        'token=',
+      );
+      cy.get('@diagnosticsWarn').should(
+        'have.been.calledWithMatch',
+        /Diagnostic report generated[\s\S]*traceId: mf-/,
+      );
+      cy.window().then((win) => {
+        const reader = getDiagnosticsReader(win);
+        const latestReport = reader.getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.traceId).to.match(/^mf-/);
+        expect(latestReport.summary.loadCompleted).to.equal(true);
+        expect(latestReport.summary.outcome).to.equal('failed');
+        expect(reader.getReport(latestReport.traceId).failedPhase).to.exist;
+      });
+    });
+
+    it('should expose a sanitized manifest failure scenario', () => {
+      cy.get('[data-testid="diagnostics-load-broken-manifest"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
+      cy.get('[data-testid="diagnostics-report"]').contains(
+        'diagnostics-broken-remote/Button',
+      );
+      cy.get('[data-testid="diagnostics-report"]')
+        .should('not.contain', 'demo-secret')
+        .should('not.contain', 'token=')
+        .should('not.contain', '#hash');
+      cy.get('[data-testid="diagnostics-error-message"]')
+        .contains('/diagnostics-missing/mf-manifest.json')
+        .should('not.contain', 'demo-secret')
+        .should('not.contain', 'token=')
+        .should('not.contain', '#hash');
+    });
+
+    it('should expose a shared miss diagnostic scenario', () => {
+      cy.window().then((win) => {
+        cy.spy(win.console, 'warn').as('diagnosticsWarn');
+      });
+      cy.get('[data-testid="diagnostics-shared-miss"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
+      cy.get('[data-testid="diagnostics-report"]')
+        .should('contain', 'diagnostics-missing-shared')
+        .should('contain', 'missing-provider');
+      cy.get('@diagnosticsWarn').should(
+        'have.been.calledWithMatch',
+        /Diagnostic report generated[\s\S]*traceId: mf-/,
+      );
+      cy.window().then((win) => {
+        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.shared.reason).to.equal('missing-provider');
+      });
+    });
+
+    it('should expose a shared version mismatch diagnostic scenario', () => {
+      cy.get('[data-testid="diagnostics-shared-version-mismatch"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
+      cy.get('[data-testid="diagnostics-report"]')
+        .should('contain', '"name": "react"')
+        .should('contain', '^99.0.0')
+        .should('contain', 'version-mismatch');
+      cy.window().then((win) => {
+        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.shared.reason).to.equal('version-mismatch');
+        expect(latestReport.shared.availableVersions).to.include('18.3.1');
+      });
+    });
+
+    it('should expose an eager config diagnostic scenario', () => {
+      cy.get('[data-testid="diagnostics-eager-config-error"]').click();
+      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
+      cy.get('[data-testid="diagnostics-report"]')
+        .should('contain', 'diagnostics-async-shared')
+        .should('contain', 'sync-async-boundary')
+        .should('contain', 'RUNTIME-005');
+      cy.window().then((win) => {
+        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.shared.reason).to.equal('sync-async-boundary');
+      });
+    });
+  });
 });
diff --git a/apps/runtime-demo/3005-runtime-host/package.json b/apps/runtime-demo/3005-runtime-host/package.json
index c4e4f70b641..177b17c26d6 100644
--- a/apps/runtime-demo/3005-runtime-host/package.json
+++ b/apps/runtime-demo/3005-runtime-host/package.json
@@ -4,6 +4,7 @@
   "version": "0.0.0",
   "devDependencies": {
     "@module-federation/core": "workspace:*",
+    "@module-federation/diagnostics-plugin": "workspace:*",
     "@module-federation/runtime": "workspace:*",
     "@module-federation/typescript": "workspace:*",
     "@module-federation/enhanced": "workspace:*",
@@ -26,7 +27,7 @@
     "serve": "NODE_OPTIONS=--max_old_space_size=4096 pnpm exec webpack-cli serve --config webpack.config.js --mode production --port 3005 --no-hot",
     "serve:development": "NODE_OPTIONS=--max_old_space_size=4096 pnpm exec webpack-cli serve --config webpack.config.js --mode development --port 3005",
     "serve:production": "NODE_OPTIONS=--max_old_space_size=4096 pnpm exec webpack-cli serve --config webpack.config.js --mode production --port 3005 --no-hot",
-    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --no-error-on-unmatched-pattern --ignore-pattern node_modules **/*.{ts,tsx,js,jsx}",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --no-error-on-unmatched-pattern --ignore-pattern node_modules src/**/*.{ts,tsx,js,jsx} cypress/**/*.{ts,tsx,js,jsx} cypress.config.ts webpack.config.js remotes.d.ts @mf-types/**/*.ts",
     "serve-static": "pnpm exec serve dist -l 3005 --cors",
     "e2e": "pnpm exec cypress run --project . --e2e --config baseUrl=http://127.0.0.1:3005 --browser chrome",
     "e2e:development": "pnpm exec cypress open --project . --e2e --config baseUrl=http://127.0.0.1:3005 --browser electron",
diff --git a/apps/runtime-demo/3005-runtime-host/src/App.tsx b/apps/runtime-demo/3005-runtime-host/src/App.tsx
index 2cf2933f74e..bbf64f1eba8 100644
--- a/apps/runtime-demo/3005-runtime-host/src/App.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/App.tsx
@@ -1,6 +1,6 @@
-import React, { lazy } from 'react';
-import { loadRemote } from '@module-federation/runtime';
+import React from 'react';
 import { Link, Routes, Route, BrowserRouter } from 'react-router-dom';
+import DiagnosticsDemo from './DiagnosticsDemo';
 import Root from './Root';
 import Remote1 from './Remote1';
 import Remote2 from './Remote2';
@@ -18,11 +18,15 @@ const App = () => (
       <li>
         <Link to={'/remote2'}>remote2</Link>
       </li>
+      <li>
+        <Link to={'/diagnostics'}>diagnostics</Link>
+      </li>
     </ul>
     <Routes>
       <Route path="/" element={<Root />} />
       <Route path="/remote1" element={<Remote1 />} />
       <Route path="/remote2" element={<Remote2 />} />
+      <Route path="/diagnostics" element={<DiagnosticsDemo />} />
     </Routes>
   </BrowserRouter>
 );
diff --git a/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx b/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
new file mode 100644
index 00000000000..d1d957c2edb
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
@@ -0,0 +1,330 @@
+import React, { useCallback, useState } from 'react';
+import {
+  loadRemote,
+  loadShare,
+  loadShareSync,
+  registerRemotes,
+} from '@module-federation/runtime';
+import { diagnostics } from './diagnostics';
+
+type LoadStatus = 'idle' | 'loading' | 'success' | 'error';
+
+type RemoteComponent = React.ComponentType<Record<string, never>>;
+
+const successRequest = 'dynamic-remote/ButtonOldAnt';
+const missingExposeRequest = 'dynamic-remote/__missing_expose__';
+const brokenManifestEntry =
+  'http://127.0.0.1:3005/diagnostics-missing/mf-manifest.json?token=demo-secret#hash';
+const brokenManifestRequest = 'diagnostics-broken-remote/Button';
+function sanitizeErrorMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+
+  return message
+    .replace(/https?:\/\/[^\s'"<>]+/g, (url) => {
+      try {
+        const parsedUrl = new URL(url);
+        return `${parsedUrl.origin}${parsedUrl.pathname}`;
+      } catch {
+        return '[redacted-url]';
+      }
+    })
+    .replace(
+      /\b(token|authorization|cookie|secret|password)=([^&\s]+)/gi,
+      '$1=[redacted]',
+    );
+}
+
+function resolveRemoteComponent(remoteModule: unknown): RemoteComponent | null {
+  if (typeof remoteModule === 'function') {
+    return remoteModule as RemoteComponent;
+  }
+
+  if (remoteModule && typeof remoteModule === 'object') {
+    const candidate = (remoteModule as { default?: unknown }).default;
+
+    if (typeof candidate === 'function') {
+      return candidate as RemoteComponent;
+    }
+  }
+
+  return null;
+}
+
+export default function DiagnosticsDemo() {
+  const [status, setStatus] = useState<LoadStatus>('idle');
+  const [errorMessage, setErrorMessage] = useState('');
+  const [remoteComponent, setRemoteComponent] =
+    useState<RemoteComponent | null>(null);
+  const [reportText, setReportText] = useState('null');
+
+  const refreshReport = useCallback(() => {
+    setReportText(
+      JSON.stringify(diagnostics.getLatestReport() ?? null, null, 2),
+    );
+  }, []);
+
+  const loadSuccessRemote = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const remoteModule = await loadRemote(successRequest);
+      const component = resolveRemoteComponent(remoteModule);
+
+      if (!component) {
+        throw new Error(`Remote module ${successRequest} has no component`);
+      }
+
+      setRemoteComponent(() => component);
+      setStatus('success');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadMissingExpose = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const remoteModule = await loadRemote(missingExposeRequest);
+
+      if (!remoteModule) {
+        throw new Error(`Remote module ${missingExposeRequest} returned empty`);
+      }
+
+      throw new Error(
+        `Remote module ${missingExposeRequest} unexpectedly loaded`,
+      );
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadBrokenManifest = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    registerRemotes(
+      [
+        {
+          name: 'diagnostics_broken_remote',
+          alias: 'diagnostics-broken-remote',
+          entry: brokenManifestEntry,
+        },
+      ],
+      { force: true },
+    );
+
+    try {
+      await loadRemote(brokenManifestRequest);
+      throw new Error(
+        `Remote module ${brokenManifestRequest} unexpectedly loaded`,
+      );
+    } catch (error) {
+      const message = sanitizeErrorMessage(`${brokenManifestEntry} ${error}`);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadSharedMiss = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const result = await loadShare('diagnostics-missing-shared', {
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['diagnostics-missing-scope'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+          },
+        },
+      });
+
+      if (result === false) {
+        throw new Error(
+          'Shared miss: diagnostics-missing-shared was not provided by host',
+        );
+      }
+
+      throw new Error('Shared miss scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadSharedVersionMismatch = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const result = await loadShare('react', {
+        customShareInfo: {
+          shareConfig: {
+            requiredVersion: '^99.0.0',
+            singleton: false,
+          },
+        },
+      });
+
+      if (result === false) {
+        throw new Error('Shared version mismatch: react needs ^99.0.0');
+      }
+
+      throw new Error('Shared version mismatch scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadEagerConfigError = useCallback(() => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      loadShareSync('diagnostics-async-shared', {
+        from: 'build',
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['default'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+            eager: false,
+            strictVersion: false,
+          },
+          get: () =>
+            Promise.resolve(() => ({
+              value: 'async shared should not be consumed synchronously',
+            })),
+        },
+      });
+
+      throw new Error('Eager config scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const markBusinessLoaded = useCallback(() => {
+    diagnostics.markComponentLoaded({
+      requestId: successRequest,
+      componentName: 'ButtonOldAnt',
+    });
+    refreshReport();
+  }, [refreshReport]);
+
+  const LoadedRemote = remoteComponent;
+
+  return (
+    <main>
+      <h2>Diagnostics Demo</h2>
+
+      <section>
+        <h3>Load Remote</h3>
+        <button
+          data-testid="diagnostics-load-success"
+          type="button"
+          onClick={loadSuccessRemote}
+        >
+          Load success remote
+        </button>
+        <button
+          data-testid="diagnostics-load-missing-expose"
+          type="button"
+          onClick={loadMissingExpose}
+        >
+          Load missing expose
+        </button>
+        <button
+          data-testid="diagnostics-load-broken-manifest"
+          type="button"
+          onClick={loadBrokenManifest}
+        >
+          Load broken manifest
+        </button>
+        <button
+          data-testid="diagnostics-business-loaded"
+          type="button"
+          onClick={markBusinessLoaded}
+        >
+          Mark business loaded
+        </button>
+      </section>
+
+      <section>
+        <h3>Shared / Eager Scenarios</h3>
+        <button
+          data-testid="diagnostics-shared-miss"
+          type="button"
+          onClick={loadSharedMiss}
+        >
+          Shared miss
+        </button>
+        <button
+          data-testid="diagnostics-shared-version-mismatch"
+          type="button"
+          onClick={loadSharedVersionMismatch}
+        >
+          Shared version mismatch
+        </button>
+        <button
+          data-testid="diagnostics-eager-config-error"
+          type="button"
+          onClick={loadEagerConfigError}
+        >
+          Eager config error
+        </button>
+      </section>
+
+      <section>
+        <h3>Status</h3>
+        <p data-testid="diagnostics-load-status">{status}</p>
+        {errorMessage ? (
+          <pre data-testid="diagnostics-error-message">{errorMessage}</pre>
+        ) : null}
+        {LoadedRemote ? (
+          <div data-testid="diagnostics-remote-result">
+            <LoadedRemote />
+          </div>
+        ) : null}
+      </section>
+
+      <section>
+        <h3>Report Fixture</h3>
+        <pre data-testid="diagnostics-report">{reportText}</pre>
+      </section>
+    </main>
+  );
+}
diff --git a/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx b/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
index 3f87d871a13..96f5759d42f 100644
--- a/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
@@ -1,13 +1,20 @@
 import React, { StrictMode } from 'react';
-import {
-  init,
-  registerGlobalPlugins,
-} from '@module-federation/enhanced/runtime';
+import { init } from '@module-federation/enhanced/runtime';
 import * as ReactDOM from 'react-dom/client';
 import App from './App';
+import { diagnostics } from './diagnostics';
 
 init({
   name: 'runtime_host',
+  security: {
+    diagnostics: {
+      enabled: true,
+      maxEvents: 100,
+      console: true,
+      browserGlobal: true,
+    },
+  },
+  plugins: [diagnostics.plugin],
   remotes: [
     {
       name: 'runtime_remote2',
diff --git a/apps/runtime-demo/3005-runtime-host/src/components/ButtonOldAnt.tsx b/apps/runtime-demo/3005-runtime-host/src/components/ButtonOldAnt.tsx
index c1552882ff5..bad5b1a4610 100644
--- a/apps/runtime-demo/3005-runtime-host/src/components/ButtonOldAnt.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/components/ButtonOldAnt.tsx
@@ -1,9 +1,7 @@
 import Button from 'antd/lib/button';
-import antdPackage from 'antd/package.json';
+import version from 'antd/lib/version';
 import stuff from './stuff.module.css';
 
-const { version } = antdPackage;
-
 export default function ButtonOldAnt() {
   return <Button className={stuff.test}>Button from antd@{version}</Button>;
 }
diff --git a/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts b/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
new file mode 100644
index 00000000000..8b6a5bab21d
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
@@ -0,0 +1,10 @@
+import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
+
+export const diagnostics = DiagnosticsPlugin({
+  level: 'verbose',
+  maxEvents: 100,
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
diff --git a/apps/runtime-demo/3005-runtime-host/src/index.ts b/apps/runtime-demo/3005-runtime-host/src/index.ts
index 51ffb285cfc..8cae17419e4 100644
--- a/apps/runtime-demo/3005-runtime-host/src/index.ts
+++ b/apps/runtime-demo/3005-runtime-host/src/index.ts
@@ -6,4 +6,4 @@ import customPlugin from './runtimePlugin';
 
 registerGlobalPlugins([customPlugin()]);
 
-require('./bootstrap');
+void import('./bootstrap');
diff --git a/apps/runtime-demo/3005-runtime-host/webpack.config.js b/apps/runtime-demo/3005-runtime-host/webpack.config.js
index dce5c186906..1b0615bd367 100644
--- a/apps/runtime-demo/3005-runtime-host/webpack.config.js
+++ b/apps/runtime-demo/3005-runtime-host/webpack.config.js
@@ -1,3 +1,5 @@
+/* eslint-env node */
+
 const path = require('path');
 const reactPath = path.dirname(require.resolve('react/package.json'));
 const reactDomPath = path.dirname(require.resolve('react-dom/package.json'));
diff --git a/apps/runtime-demo/README.md b/apps/runtime-demo/README.md
index 81cca8c5617..114d9c67de7 100644
--- a/apps/runtime-demo/README.md
+++ b/apps/runtime-demo/README.md
@@ -10,8 +10,61 @@ host declare remote2 in webpack.config.js, and use `@module-federation/runtime`
 
 # Running Demo
 
-Run `npm run app:runtime:dev` to start host, remote1, remote2
+Run `pnpm run app:runtime:dev` to start host, remote1, remote2.
 
 - host: [localhost:3005](http://localhost:3005/)
 - remote1: [localhost:3006](http://localhost:3006/)
 - remote2: [localhost:3007](http://localhost:3007/)
+
+## Diagnostics Demo
+
+The diagnostics fixture lives in the runtime host. The host explicitly enables
+`security.diagnostics` and installs `@module-federation/diagnostics-plugin` for
+this demo, so the report is generated by the runtime plugin instead of local UI
+state.
+
+- diagnostics page:
+  [localhost:3005/diagnostics](http://localhost:3005/diagnostics)
+
+Start the demo first:
+
+```bash
+pnpm run app:runtime:dev
+```
+
+Then open the diagnostics page and use these controls:
+
+- `Load success remote`: loads `dynamic-remote/ButtonOldAnt` from remote2. The
+  status should become `success`, the remote button should render, and the
+  report should include a completed `loadRemote` timeline with
+  `summary.outcome: "runtime-loaded"`. The same report is also available at
+  `window.__FEDERATION__.__DIAGNOSTICS__.runtime_host.getLatestReport()`.
+- `Load missing expose`: loads a missing expose from remote2. The status should
+  become `error`, and the report should include
+  `dynamic-remote/__missing_expose__`. The browser console should print a
+  diagnostic hint with a `traceId`.
+- `Load broken manifest`: loads a remote with a broken manifest URL. The status
+  should become `error`, and the shown error should keep the manifest pathname
+  while removing query, token, and hash data.
+- `Mark business loaded`: calls the diagnostics plugin's component success API,
+  and the report should include `component:business-loaded` with
+  `summary.outcome: "component-loaded"`.
+- `Shared miss`: triggers a missing shared provider report. The report should
+  include `diagnostics-missing-shared` and `missing-provider`.
+- `Shared version mismatch`: asks for an unsupported React version. The report
+  should include `react`, `^99.0.0`, the available version, and
+  `version-mismatch`.
+- `Eager config error`: synchronously consumes an async shared dependency. The
+  report should include `diagnostics-async-shared`, `RUNTIME-005`, and
+  `sync-async-boundary`.
+
+Run the automated verification:
+
+```bash
+pnpm run ci:local --only=e2e-runtime
+```
+
+This command installs the e2e dependencies if needed, builds the packages,
+starts the host and remotes, and runs the Cypress checks. The diagnostics
+fixture is covered by the `diagnostics demo fixture` tests in the runtime host
+e2e suite.
diff --git a/packages/diagnostics-plugin/.eslintrc.json b/packages/diagnostics-plugin/.eslintrc.json
new file mode 100644
index 00000000000..2c7d3866f19
--- /dev/null
+++ b/packages/diagnostics-plugin/.eslintrc.json
@@ -0,0 +1,27 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": [
+    "!**/*",
+    "**/vite.config.*.timestamp*",
+    "**/vitest.config.*.timestamp*"
+  ],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {}
+    }
+  ]
+}
diff --git a/packages/diagnostics-plugin/README.md b/packages/diagnostics-plugin/README.md
new file mode 100644
index 00000000000..4d50b8a8aa4
--- /dev/null
+++ b/packages/diagnostics-plugin/README.md
@@ -0,0 +1,122 @@
+# @module-federation/diagnostics-plugin
+
+Runtime diagnostics plugin for Module Federation loading flows.
+
+This package is currently the minimal diagnostics foundation. It records
+sanitized in-memory loading events only when `security.diagnostics.enabled` is
+set on the runtime instance.
+
+```ts
+import { createInstance } from '@module-federation/runtime';
+import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
+
+const diagnostics = DiagnosticsPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'host',
+  },
+});
+
+createInstance({
+  name: 'host',
+  security: {
+    diagnostics: {
+      enabled: true,
+      maxEvents: 100,
+      browserGlobal: true,
+    },
+  },
+  plugins: [diagnostics.plugin],
+  remotes: [],
+});
+
+const report = diagnostics.getLatestReport();
+```
+
+The plugin does not upload data or expose a browser global by default. Reports
+are kept in memory and URL query/hash data is removed before it is returned.
+The runtime only exposes the loading lifecycle hooks needed to know whether the
+main flow started, succeeded, or failed. This plugin listens to those hooks,
+derives detailed reasons like shared version mismatch or eager boundary issues,
+and exposes the final loading state through a small `summary` object:
+
+- `runtime-loaded`: Module Federation finished loading the remote module.
+- `component-loaded`: business code called `markComponentLoaded`.
+- `failed`: the load failed and `failedPhase` points to the first specific
+  failing phase.
+- `recovered`: loading hit an error but a fallback/recovery path returned a
+  result.
+
+For remote loading, the plugin listens to runtime lifecycle hooks such as
+`beforeRequest`, `onLoad`, `afterLoadRemote`, `errorLoadRemote`, `loadEntry`,
+`afterLoadEntry`, and snapshot resolve hooks. It does not return a value from
+observer hooks, so it does not change fallback or retry results from plugins
+such as `@module-federation/retry-plugin`.
+
+`errorLoadShare` is used only for diagnostics. Shared dependency miss, version
+mismatch, and eager boundary errors are not retried by the retry plugin by
+default because they are usually configuration or availability problems instead
+of transient network failures.
+
+Business code can mark its own success condition with a fixed event:
+
+```ts
+diagnostics.markComponentLoaded({
+  requestId: 'remote/Button',
+  componentName: 'Button',
+});
+```
+
+This records `component:business-loaded` on the same trace when possible.
+
+Optional outputs are gated twice:
+
+- Plugin options request the output.
+- `security.diagnostics` must allow the output.
+
+When both sides allow browser output, the report can be read from:
+
+```ts
+window.__FEDERATION__.__DIAGNOSTICS__.host.getLatestReport();
+window.__FEDERATION__.__DIAGNOSTICS__.host.getReport('mf-trace-id');
+```
+
+Node file output is provided by the Node-specific entry:
+
+```ts
+import { createInstance } from '@module-federation/runtime';
+import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin/node';
+
+const diagnostics = DiagnosticsPlugin({
+  level: 'verbose',
+  directory: '.mf/diagnostics',
+});
+
+createInstance({
+  name: 'host',
+  security: {
+    diagnostics: {
+      enabled: true,
+      fileOutput: true,
+    },
+  },
+  plugins: [diagnostics.plugin],
+  remotes: [],
+});
+```
+
+When both sides allow Node file output, the Node entry writes:
+
+- `.mf/diagnostics/latest.json`: the latest sanitized report.
+- `.mf/diagnostics/events.jsonl`: one sanitized event per line.
+
+On errors, the plugin prints a small console hint with the `traceId` and the
+available read path. The console hint is intentionally small and does not carry
+the full report. The default browser/runtime entry does not include Node file
+output code.
+
+Shared dependency reports include only diagnostic fields such as package name,
+share scope, requested version, available versions, selected provider, and a
+reason like `missing-provider`, `version-mismatch`, or `sync-async-boundary`.
+They do not include shared factories, module values, source, or business data.
diff --git a/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts b/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
new file mode 100644
index 00000000000..d2de09ff5ed
--- /dev/null
+++ b/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
@@ -0,0 +1,774 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { DiagnosticsPlugin } from '../src';
+import { DiagnosticsPlugin as DiagnosticsNode } from '../src/node';
+
+const enabledOrigin = {
+  options: {
+    name: 'host',
+    security: {
+      diagnostics: {
+        enabled: true,
+        maxEvents: 10,
+      },
+    },
+  },
+};
+
+const disabledOrigin = {
+  options: {
+    name: 'host',
+  },
+};
+
+const createShared = (overrides: Record<string, unknown> = {}) => ({
+  version: '18.3.1',
+  scope: ['default'],
+  from: 'host',
+  deps: [],
+  useIn: [],
+  strategy: 'loaded-first',
+  shareConfig: {
+    requiredVersion: '^18.0.0',
+    singleton: false,
+    strictVersion: false,
+    eager: false,
+  },
+  get: () => () => ({ value: 'shared' }),
+  ...overrides,
+});
+
+const emitRemoteLoaded = (
+  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  diagnostics.plugin.onLoad?.({
+    id: 'remote/Button',
+    pkgNameOrAlias: 'remote',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    options: {},
+    origin: enabledOrigin,
+    exposeModule: {},
+    exposeModuleFactory: undefined,
+    moduleInstance: {},
+    ...overrides,
+  } as any);
+
+const emitRemoteStart = (
+  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  diagnostics.plugin.beforeRequest?.({
+    id: 'remote/Button',
+    options: {},
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteComplete = (
+  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  diagnostics.plugin.afterLoadRemote?.({
+    id: 'remote/Button',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteError = (
+  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  diagnostics.plugin.errorLoadRemote?.({
+    id: 'remote/Button',
+    error: new Error('remote load failed'),
+    from: 'runtime',
+    lifecycle: 'onLoad',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitManifestError = (
+  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  diagnostics.plugin.errorLoadRemote?.({
+    id: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    error: new Error('token=demo-secret manifest failed'),
+    from: 'runtime',
+    lifecycle: 'afterResolve',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const waitForFile = async (filePath: string) => {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < 1000) {
+    if (fs.existsSync(filePath)) {
+      return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+
+  throw new Error(`Timed out waiting for ${filePath}`);
+};
+
+describe('DiagnosticsPlugin', () => {
+  it('does not record events unless security diagnostics is enabled', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
+
+    emitRemoteLoaded(diagnostics, {
+      origin: disabledOrigin,
+    });
+
+    expect(diagnostics.getEvents()).toHaveLength(0);
+    expect(diagnostics.getLatestReport()).toBeUndefined();
+  });
+
+  it('records a successful loadRemote report when enabled', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
+
+    emitRemoteStart(diagnostics);
+    emitRemoteLoaded(diagnostics);
+
+    const report = diagnostics.getLatestReport();
+    expect(report?.status).toBe('success');
+    expect(report?.requestId).toBe('remote/Button');
+    expect(report?.remote?.name).toBe('remote');
+    expect(report?.summary).toMatchObject({
+      runtimeLoaded: true,
+      loadCompleted: false,
+      componentLoaded: false,
+      outcome: 'runtime-loaded',
+      lastPhase: 'loadRemote',
+    });
+    expect(report?.events).toHaveLength(2);
+  });
+
+  it('records a complete loadRemote event as the final runtime outcome', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
+
+    emitRemoteStart(diagnostics);
+    emitRemoteLoaded(diagnostics);
+    emitRemoteComplete(diagnostics);
+
+    const report = diagnostics.getLatestReport();
+    expect(report?.status).toBe('success');
+    expect(report?.summary).toMatchObject({
+      runtimeLoaded: true,
+      loadCompleted: true,
+      componentLoaded: false,
+      outcome: 'runtime-loaded',
+      lastPhase: 'loadRemote',
+    });
+  });
+
+  it('records manifest and remoteEntry lifecycle hooks without diagnostic events', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+
+    diagnostics.plugin.beforeLoadRemoteSnapshot?.({
+      moduleInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    diagnostics.plugin.afterResolve?.({
+      id: 'remote/Button',
+      expose: './Button',
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    diagnostics.plugin.loadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+    diagnostics.plugin.afterLoadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+
+    expect(diagnostics.getEvents()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          phase: 'manifest',
+          status: 'start',
+          lifecycle: 'beforeLoadRemoteSnapshot',
+        }),
+        expect.objectContaining({
+          phase: 'manifest',
+          status: 'success',
+          lifecycle: 'afterResolve',
+        }),
+        expect.objectContaining({
+          phase: 'remoteEntry',
+          status: 'start',
+          lifecycle: 'loadEntry',
+        }),
+        expect.objectContaining({
+          phase: 'remoteEntry',
+          status: 'success',
+          lifecycle: 'afterLoadEntry',
+        }),
+      ]),
+    );
+  });
+
+  it('treats a recovered complete event as a recovered runtime outcome', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+
+    emitRemoteStart(diagnostics);
+    expect(emitRemoteError(diagnostics)).toBeUndefined();
+    emitRemoteComplete(diagnostics, {
+      error: new Error('remote load failed'),
+      recovered: true,
+    });
+
+    const report = diagnostics.getLatestReport();
+    expect(report?.summary).toMatchObject({
+      recovered: true,
+      runtimeLoaded: true,
+      loadCompleted: true,
+      outcome: 'recovered',
+    });
+  });
+
+  it('sanitizes urls and sensitive message fields', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+
+    emitManifestError(diagnostics, {
+      error: new Error(
+        'authorization=demo-secret failed at http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+      ),
+    });
+
+    const output = JSON.stringify(diagnostics.getLatestReport());
+    expect(output).toContain('http://localhost:3001/mf-manifest.json');
+    expect(output).not.toContain('demo-secret');
+    expect(output).not.toContain('token=');
+    expect(output).not.toContain('#hash');
+  });
+
+  it('keeps the first specific failed phase when loadRemote closes the trace', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+
+    emitRemoteStart(diagnostics, {
+      remote: {
+        name: 'remote',
+      },
+    });
+    emitManifestError(diagnostics, {
+      id: 'remote/Button',
+      remote: {
+        name: 'remote',
+      },
+      error: new Error('manifest failed'),
+    });
+    expect(emitRemoteError(diagnostics)).toBeUndefined();
+    emitRemoteComplete(diagnostics, {
+      remote: {
+        name: 'remote',
+      },
+      error: new Error('outer loadRemote failed'),
+    });
+
+    const report = diagnostics.getLatestReport();
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('manifest');
+    expect(report?.summary).toMatchObject({
+      loadCompleted: true,
+      runtimeLoaded: false,
+      componentLoaded: false,
+      outcome: 'failed',
+    });
+  });
+
+  it('records sanitized shared dependency diagnostics', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+
+    diagnostics.plugin.errorLoadShare?.({
+      pkgName: 'react',
+      shareInfo: {
+        version: '18.3.1',
+        from: 'remote',
+        scope: ['default'],
+        strategy: 'loaded-first',
+        shareConfig: {
+          requiredVersion: '^99.0.0',
+          singleton: true,
+          strictVersion: true,
+          eager: false,
+        },
+      },
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': createShared({
+              from: 'host?token=demo-secret',
+            }),
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+      error: new Error('token=demo-secret shared failed'),
+      recovered: true,
+    } as any);
+
+    const report = diagnostics.getLatestReport();
+    const output = JSON.stringify(report);
+
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('shared');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      shareScope: ['default'],
+      requiredVersion: '^99.0.0',
+      availableVersions: ['18.3.1'],
+      reason: 'version-mismatch',
+    });
+    expect(output).not.toContain('demo-secret');
+    expect(output).not.toContain('token=');
+  });
+
+  it('derives shared success details from loadShare hooks', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+    const shared = createShared();
+
+    diagnostics.plugin.beforeLoadShare?.({
+      pkgName: 'react',
+      shareInfo: shared,
+      shared: {},
+      origin: enabledOrigin,
+    });
+    diagnostics.plugin.afterLoadShare?.({
+      pkgName: 'react',
+      shareInfo: shared,
+      selectedShared: shared,
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': shared,
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+    });
+
+    const report = diagnostics.getLatestReport();
+
+    expect(report?.status).toBe('success');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      selectedVersion: '18.3.1',
+      provider: 'host',
+      availableVersions: ['18.3.1'],
+    });
+  });
+
+  it('derives shared version mismatch details from errorLoadShare', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+    const requestedShared = createShared({
+      version: '99.0.0',
+      from: 'remote',
+      shareConfig: {
+        requiredVersion: '^99.0.0',
+        singleton: false,
+        strictVersion: true,
+        eager: false,
+      },
+    });
+    const hostShared = createShared();
+
+    diagnostics.plugin.beforeLoadShare?.({
+      pkgName: 'react',
+      shareInfo: requestedShared,
+      shared: {},
+      origin: enabledOrigin,
+    });
+    diagnostics.plugin.errorLoadShare?.({
+      pkgName: 'react',
+      shareInfo: requestedShared,
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': hostShared,
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+      recovered: true,
+    });
+
+    const report = diagnostics.getLatestReport();
+
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('shared');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      requiredVersion: '^99.0.0',
+      availableVersions: ['18.3.1'],
+      reason: 'version-mismatch',
+    });
+  });
+
+  it('derives eager boundary details from loadShareSync failures', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
+    const asyncShared = createShared({
+      version: '1.0.0',
+      from: 'remote',
+      shareConfig: {
+        requiredVersion: '^1.0.0',
+        singleton: false,
+        strictVersion: false,
+        eager: false,
+      },
+      get: () => Promise.resolve(() => ({ value: 'async' })),
+    });
+
+    diagnostics.plugin.errorLoadShare?.({
+      pkgName: 'diagnostics-async-shared',
+      shareInfo: asyncShared,
+      shared: {},
+      shareScopeMap: {},
+      lifecycle: 'loadShareSync',
+      origin: enabledOrigin,
+      error: new Error('[ Federation Runtime ]: RUNTIME-005 shared failed'),
+    });
+
+    const report = diagnostics.getLatestReport();
+
+    expect(report?.status).toBe('error');
+    expect(report?.shared).toMatchObject({
+      name: 'diagnostics-async-shared',
+      requiredVersion: '^1.0.0',
+      reason: 'sync-async-boundary',
+    });
+    expect(report?.events.at(-1)?.message).toBe('shared:sync-async-boundary');
+  });
+
+  it('prints a minimal console hint with traceId on error', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+
+    try {
+      emitManifestError(diagnostics);
+
+      emitManifestError(diagnostics, {
+        error: new Error('token=demo-secret failed again'),
+      });
+
+      expect(warn).toHaveBeenCalledTimes(1);
+      const output = String(warn.mock.calls[0]?.[0]);
+      expect(output).toContain(
+        '[Module Federation] Diagnostic report generated',
+      );
+      expect(output).toContain('traceId: mf-');
+      expect(output).toContain('phase: manifest');
+      expect(output).toContain('read: diagnostics.getReport');
+      expect(output).not.toContain('demo-secret');
+      expect(output).not.toContain('token=');
+      expect(output).not.toContain('#hash');
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it('exposes a browser reader only when plugin and security both allow it', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: {
+          __DIAGNOSTICS__?: Record<string, unknown>;
+        };
+      }
+    ).__FEDERATION__;
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: {
+            __DIAGNOSTICS__?: Record<string, unknown>;
+          };
+        }
+      ).__FEDERATION__ = {};
+
+      const diagnostics = DiagnosticsPlugin({
+        level: 'verbose',
+        browser: {
+          enabled: true,
+          scope: 'host',
+        },
+      });
+
+      emitRemoteLoaded(diagnostics, {
+        origin: {
+          options: {
+            name: 'host',
+            security: {
+              diagnostics: {
+                enabled: true,
+                maxEvents: 10,
+                browserGlobal: true,
+              },
+            },
+          },
+        },
+      });
+
+      const reader = (
+        globalThis as {
+          __FEDERATION__?: {
+            __DIAGNOSTICS__?: Record<
+              string,
+              {
+                getLatestReport(): { traceId: string; events: unknown[] };
+                getReport(traceId: string): { events: unknown[] } | undefined;
+                getTraceIds(): string[];
+                clear?: unknown;
+              }
+            >;
+          };
+        }
+      ).__FEDERATION__?.__DIAGNOSTICS__?.host;
+
+      expect(reader).toBeDefined();
+      expect(reader?.clear).toBeUndefined();
+      expect(reader?.getTraceIds()).toHaveLength(1);
+
+      const latestReport = reader?.getLatestReport();
+      expect(latestReport?.traceId).toBeDefined();
+      latestReport?.events.pop();
+
+      expect(reader?.getLatestReport().events).toHaveLength(1);
+      expect(
+        reader?.getReport(latestReport?.traceId || '')?.events,
+      ).toHaveLength(1);
+    } finally {
+      if (originalFederation) {
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __DIAGNOSTICS__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__ = originalFederation;
+      } else {
+        delete (
+          globalThis as {
+            __FEDERATION__?: {
+              __DIAGNOSTICS__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__;
+      }
+    }
+  });
+
+  it('does not expose the browser reader when security blocks it', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: {
+          __DIAGNOSTICS__?: Record<string, unknown>;
+        };
+      }
+    ).__FEDERATION__;
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: {
+            __DIAGNOSTICS__?: Record<string, unknown>;
+          };
+        }
+      ).__FEDERATION__ = {};
+
+      const diagnostics = DiagnosticsPlugin({
+        level: 'verbose',
+        browser: {
+          enabled: true,
+          scope: 'host',
+        },
+      });
+
+      emitRemoteLoaded(diagnostics);
+
+      expect(
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __DIAGNOSTICS__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__?.__DIAGNOSTICS__,
+      ).toBeUndefined();
+    } finally {
+      if (originalFederation) {
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __DIAGNOSTICS__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__ = originalFederation;
+      } else {
+        delete (
+          globalThis as {
+            __FEDERATION__?: {
+              __DIAGNOSTICS__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__;
+      }
+    }
+  });
+
+  it('writes sanitized Node diagnostics files only when security allows it', async () => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'mf-diagnostics-'));
+    const latestFile = path.join(directory, 'latest.json');
+    const eventsFile = path.join(directory, 'events.jsonl');
+    const originalNonWebpackRequire = (
+      globalThis as {
+        __non_webpack_require__?: (id: string) => unknown;
+      }
+    ).__non_webpack_require__;
+
+    try {
+      (
+        globalThis as {
+          __non_webpack_require__?: (id: string) => unknown;
+        }
+      ).__non_webpack_require__ = (id: string) => {
+        if (id === 'node:fs' || id === 'fs') {
+          return fs;
+        }
+
+        if (id === 'node:path' || id === 'path') {
+          return path;
+        }
+
+        throw new Error(`Unsupported module: ${id}`);
+      };
+
+      const diagnostics = DiagnosticsNode({
+        level: 'verbose',
+        console: false,
+        directory,
+      });
+
+      emitManifestError(diagnostics, {
+        origin: {
+          options: {
+            name: 'host',
+            security: {
+              diagnostics: {
+                enabled: true,
+                maxEvents: 10,
+                fileOutput: true,
+              },
+            },
+          },
+        },
+        error: new Error('token=demo-secret manifest failed'),
+      });
+
+      await waitForFile(latestFile);
+      await waitForFile(eventsFile);
+
+      const latest = fs.readFileSync(latestFile, 'utf8');
+      const eventsOutput = fs.readFileSync(eventsFile, 'utf8');
+
+      expect(latest).toContain('"status": "error"');
+      expect(eventsOutput).toContain('"phase":"manifest"');
+      expect(`${latest}\n${eventsOutput}`).not.toContain('demo-secret');
+      expect(`${latest}\n${eventsOutput}`).not.toContain('token=');
+      expect(`${latest}\n${eventsOutput}`).not.toContain('#hash');
+    } finally {
+      if (originalNonWebpackRequire) {
+        (
+          globalThis as {
+            __non_webpack_require__?: (id: string) => unknown;
+          }
+        ).__non_webpack_require__ = originalNonWebpackRequire;
+      } else {
+        delete (
+          globalThis as {
+            __non_webpack_require__?: (id: string) => unknown;
+          }
+        ).__non_webpack_require__;
+      }
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('lets business code mark component loaded after runtime diagnostics starts', () => {
+    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
+
+    emitRemoteLoaded(diagnostics);
+
+    const componentEvent = diagnostics.markComponentLoaded({
+      requestId: 'remote/Button',
+      componentName: 'RemoteButton',
+    });
+    const report = diagnostics.getLatestReport();
+
+    expect(componentEvent?.phase).toBe('component');
+    expect(componentEvent?.eventName).toBe('component:business-loaded');
+    expect(componentEvent?.source).toBe('business');
+    expect(componentEvent?.componentName).toBe('RemoteButton');
+    expect(report?.summary.componentLoaded).toBe(true);
+    expect(report?.summary.outcome).toBe('component-loaded');
+    expect(JSON.stringify(report)).toContain('component:business-loaded');
+  });
+
+  it('does not let diagnostics callbacks affect loading', () => {
+    const diagnostics = DiagnosticsPlugin({
+      level: 'verbose',
+      onEvent: vi.fn(() => {
+        throw new Error('onEvent failed');
+      }),
+      onReport: vi.fn(() => {
+        throw new Error('onReport failed');
+      }),
+    });
+
+    expect(() => emitRemoteLoaded(diagnostics)).not.toThrow();
+
+    expect(diagnostics.getLatestReport()?.status).toBe('success');
+  });
+});
diff --git a/packages/diagnostics-plugin/package.json b/packages/diagnostics-plugin/package.json
new file mode 100644
index 00000000000..e67b4be73c6
--- /dev/null
+++ b/packages/diagnostics-plugin/package.json
@@ -0,0 +1,52 @@
+{
+  "name": "@module-federation/diagnostics-plugin",
+  "version": "2.4.0",
+  "author": "module-federation",
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/diagnostics-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/esm/node.js",
+      "require": "./dist/node.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "node": [
+        "./dist/node.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@module-federation/runtime": "workspace:*"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.ts && cp *.md dist",
+    "test": "vitest run -u -c vitest.config.ts",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.ts\" \"package.json\"",
+    "pre-release": "pnpm run test && pnpm run build"
+  }
+}
diff --git a/packages/diagnostics-plugin/src/index.ts b/packages/diagnostics-plugin/src/index.ts
new file mode 100644
index 00000000000..51f4d4d8f9e
--- /dev/null
+++ b/packages/diagnostics-plugin/src/index.ts
@@ -0,0 +1,1383 @@
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+
+export type DiagnosticsLevel = 'error' | 'summary' | 'verbose';
+export type DiagnosticsEventStatus = 'start' | 'success' | 'error' | 'complete';
+export type DiagnosticsReportStatus = 'pending' | 'success' | 'error';
+export type DiagnosticsEventSource = 'runtime' | 'business';
+export type DiagnosticsReportOutcome =
+  | 'pending'
+  | 'runtime-loaded'
+  | 'component-loaded'
+  | 'failed'
+  | 'recovered';
+
+export interface DiagnosticsRemoteInfo {
+  name: string;
+  alias?: string;
+  entry?: string;
+  entryGlobalName?: string;
+  type?: string;
+}
+
+export interface DiagnosticsSharedInfo {
+  name: string;
+  shareScope?: string[];
+  requiredVersion?: string | false;
+  selectedVersion?: string;
+  availableVersions?: string[];
+  provider?: string;
+  from?: string;
+  singleton?: boolean;
+  strictVersion?: boolean;
+  eager?: boolean;
+  strategy?: string;
+  loaded?: boolean;
+  loading?: boolean;
+  reason?: string;
+}
+
+export interface DiagnosticsEvent {
+  traceId: string;
+  timestamp: number;
+  phase: string;
+  status: DiagnosticsEventStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: DiagnosticsRemoteInfo;
+  shared?: DiagnosticsSharedInfo;
+  expose?: string;
+  sanitizedUrl?: string;
+  message?: string;
+  errorName?: string;
+  errorMessage?: string;
+  lifecycle?: string;
+  eventName?: string;
+  source?: DiagnosticsEventSource;
+  recovered?: boolean;
+  componentName?: string;
+}
+
+export interface DiagnosticsReport {
+  traceId: string;
+  status: DiagnosticsReportStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: DiagnosticsRemoteInfo;
+  shared?: DiagnosticsSharedInfo;
+  expose?: string;
+  startedAt: number;
+  updatedAt: number;
+  duration: number;
+  failedPhase?: string;
+  events: DiagnosticsEvent[];
+  summary: {
+    eventCount: number;
+    recovered: boolean;
+    loadCompleted: boolean;
+    runtimeLoaded: boolean;
+    componentLoaded: boolean;
+    outcome: DiagnosticsReportOutcome;
+    lastPhase?: string;
+  };
+}
+
+export interface DiagnosticsPluginOptions {
+  enabled?: boolean;
+  level?: DiagnosticsLevel;
+  maxEvents?: number;
+  console?: boolean;
+  browser?: {
+    enabled?: boolean;
+    scope?: string;
+  };
+  onEvent?: (
+    event: DiagnosticsEvent,
+    report: DiagnosticsReport,
+    context?: DiagnosticsEventContext,
+  ) => void;
+  onReport?: (
+    report: DiagnosticsReport,
+    context?: DiagnosticsEventContext,
+  ) => void;
+}
+
+export interface MarkComponentLoadedOptions {
+  traceId?: string;
+  requestId?: string;
+  componentName?: string;
+}
+
+export interface DiagnosticsController {
+  plugin: DiagnosticsRuntimePlugin;
+  getEvents(): DiagnosticsEvent[];
+  getTraceIds(): string[];
+  getLatestReport(): DiagnosticsReport | undefined;
+  getReport(traceId: string): DiagnosticsReport | undefined;
+  clear(): void;
+  markComponentLoaded(
+    options?: MarkComponentLoadedOptions,
+  ): DiagnosticsEvent | undefined;
+}
+
+export interface DiagnosticsRuntimeEventInput {
+  phase: string;
+  status: DiagnosticsEventStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: DiagnosticsRemoteInfo;
+  shared?: DiagnosticsSharedInfo;
+  expose?: string;
+  url?: string;
+  message?: string;
+  error?: unknown;
+  lifecycle?: string;
+  eventName?: string;
+  source?: DiagnosticsEventSource;
+  recovered?: boolean;
+  timestamp?: number;
+  traceId?: string;
+  componentName?: string;
+}
+
+export interface DiagnosticsRuntimeOrigin {
+  options?: {
+    name?: string;
+    security?: {
+      diagnostics?: {
+        enabled?: boolean;
+        maxEvents?: number;
+        console?: boolean;
+        browserGlobal?: boolean;
+        fileOutput?: boolean;
+      };
+    };
+  };
+}
+
+export interface DiagnosticsEventContext {
+  origin?: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRuntimeSharedConfig {
+  requiredVersion?: string | false;
+  singleton?: boolean;
+  strictVersion?: boolean;
+  eager?: boolean;
+}
+
+interface DiagnosticsRuntimeSharedSource {
+  version?: string;
+  scope?: string | string[];
+  from?: string;
+  loaded?: boolean;
+  loading?: unknown;
+  strategy?: string;
+  shareConfig?: DiagnosticsRuntimeSharedConfig;
+  get?: unknown;
+}
+
+interface DiagnosticsRuntimeRemoteSource {
+  name?: string;
+  alias?: string;
+  entry?: string;
+  entryGlobalName?: string;
+  type?: string;
+}
+
+interface DiagnosticsRemoteLoadArgs {
+  id: string;
+  expose?: string;
+  remote?: DiagnosticsRuntimeRemoteSource;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteBeforeRequestArgs {
+  id: string;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteAfterLoadArgs {
+  id: string;
+  expose?: string;
+  remote?: DiagnosticsRuntimeRemoteSource;
+  error?: unknown;
+  recovered?: boolean;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteSnapshotArgs {
+  moduleInfo?: DiagnosticsRuntimeRemoteSource;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteResolveArgs {
+  id: string;
+  expose?: string;
+  remote?: DiagnosticsRuntimeRemoteSource;
+  remoteInfo?: DiagnosticsRuntimeRemoteSource;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteErrorArgs {
+  id: string;
+  error: unknown;
+  lifecycle?: string;
+  remote?: DiagnosticsRuntimeRemoteSource;
+  expose?: string;
+  origin: DiagnosticsRuntimeOrigin;
+}
+
+interface DiagnosticsRemoteEntryLoadArgs {
+  origin: DiagnosticsRuntimeOrigin;
+  remoteInfo: DiagnosticsRuntimeRemoteSource;
+}
+
+interface DiagnosticsRemoteEntryAfterLoadArgs {
+  origin: DiagnosticsRuntimeOrigin;
+  remoteInfo: DiagnosticsRuntimeRemoteSource;
+  error?: unknown;
+  recovered?: boolean;
+}
+
+type DiagnosticsRuntimeShareScopeMap = Record<
+  string,
+  Record<string, Record<string, DiagnosticsRuntimeSharedSource | undefined>>
+>;
+
+interface DiagnosticsSharedLifecycleArgs {
+  pkgName: string;
+  shareInfo?: DiagnosticsRuntimeSharedSource;
+  selectedShared?: DiagnosticsRuntimeSharedSource;
+  shared?: Record<string, DiagnosticsRuntimeSharedSource[]>;
+  shareScopeMap?: DiagnosticsRuntimeShareScopeMap;
+  lifecycle?: 'loadShare' | 'loadShareSync';
+  origin: DiagnosticsRuntimeOrigin;
+  error?: unknown;
+  recovered?: boolean;
+}
+
+export type DiagnosticsRuntimePlugin = ModuleFederationRuntimePlugin;
+
+export interface DiagnosticsBrowserReader {
+  getEvents(): DiagnosticsEvent[];
+  getTraceIds(): string[];
+  getLatestReport(): DiagnosticsReport | undefined;
+  getReport(traceId: string): DiagnosticsReport | undefined;
+}
+
+interface FederationDiagnosticsGlobal {
+  __DIAGNOSTICS__?: Record<string, DiagnosticsBrowserReader>;
+}
+
+const DEFAULT_MAX_EVENTS = 100;
+const HARD_MAX_EVENTS = 1000;
+const COMPONENT_BUSINESS_LOADED_EVENT = 'component:business-loaded';
+const SENSITIVE_PAIR_PATTERN =
+  /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
+const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
+
+let traceCounter = 0;
+
+function normalizeMaxEvents(value: number | undefined, fallback: number) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return fallback;
+  }
+
+  return Math.max(1, Math.min(HARD_MAX_EVENTS, Math.floor(value)));
+}
+
+function sanitizeText(value: unknown, maxLength = 800): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const sanitized = String(value)
+    .replace(URL_PATTERN, (url) => sanitizeUrl(url) || '[redacted-url]')
+    .replace(SENSITIVE_PAIR_PATTERN, '[redacted]');
+
+  return sanitized.length > maxLength
+    ? `${sanitized.slice(0, maxLength)}...`
+    : sanitized;
+}
+
+function sanitizeRequestId(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (/^https?:\/\//i.test(value)) {
+    return sanitizeUrl(value);
+  }
+
+  return sanitizeText(value, 240);
+}
+
+function sanitizeUrl(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  try {
+    const base =
+      typeof window !== 'undefined' && window.location
+        ? window.location.origin
+        : 'http://localhost';
+    const parsedUrl = new URL(value, base);
+    const sanitized = `${parsedUrl.origin}${parsedUrl.pathname}`;
+
+    return /^https?:\/\//i.test(value) ? sanitized : parsedUrl.pathname;
+  } catch {
+    const [withoutHash] = value.split('#');
+    const [withoutQuery] = withoutHash.split('?');
+    return sanitizeText(withoutQuery, 240);
+  }
+}
+
+function sanitizeRemote(
+  remote: DiagnosticsRemoteInfo | undefined,
+): DiagnosticsRemoteInfo | undefined {
+  if (!remote || !remote.name) {
+    return undefined;
+  }
+
+  return {
+    name: remote.name,
+    alias: sanitizeText(remote.alias, 120),
+    entry: sanitizeUrl(remote.entry),
+    entryGlobalName: sanitizeText(remote.entryGlobalName, 120),
+    type: sanitizeText(remote.type, 80),
+  };
+}
+
+function createRemoteInfo(
+  remote: DiagnosticsRuntimeRemoteSource | undefined,
+): DiagnosticsRemoteInfo | undefined {
+  if (!remote?.name) {
+    return undefined;
+  }
+
+  return {
+    name: remote.name,
+    alias: remote.alias,
+    entry: remote.entry,
+    entryGlobalName: remote.entryGlobalName,
+    type: remote.type,
+  };
+}
+
+function isManifestUrl(value: string | undefined): boolean {
+  const sanitized = sanitizeUrl(value);
+
+  return Boolean(sanitized && /manifest.*\.json$/i.test(sanitized));
+}
+
+function normalizeSharedScope(value: string | string[] | undefined): string[] {
+  if (!value) {
+    return [];
+  }
+
+  return (Array.isArray(value) ? value : [value])
+    .map((scope) => sanitizeText(scope, 120))
+    .filter((scope): scope is string => Boolean(scope));
+}
+
+function getSharedScopes(
+  shareInfo: DiagnosticsRuntimeSharedSource | undefined,
+): string[] {
+  return normalizeSharedScope(shareInfo?.scope).length
+    ? normalizeSharedScope(shareInfo?.scope)
+    : ['default'];
+}
+
+function getAvailableSharedVersions(args: DiagnosticsSharedLifecycleArgs) {
+  const versions = new Set<string>();
+  const shareScopeMap = args.shareScopeMap || {};
+
+  getSharedScopes(args.shareInfo).forEach((scope) => {
+    Object.keys(shareScopeMap[scope]?.[args.pkgName] || {}).forEach(
+      (version) => {
+        versions.add(version);
+      },
+    );
+  });
+
+  return Array.from(versions);
+}
+
+function getSharedMissReason(args: DiagnosticsSharedLifecycleArgs) {
+  if (!args.shareInfo) {
+    return 'missing-config';
+  }
+
+  return getAvailableSharedVersions(args).length
+    ? 'version-mismatch'
+    : 'missing-provider';
+}
+
+function getSharedErrorReason(args: DiagnosticsSharedLifecycleArgs) {
+  if (args.recovered) {
+    return getSharedMissReason(args);
+  }
+
+  const errorInfo = getErrorInfo(args.error);
+  const errorMessage = errorInfo.errorMessage || '';
+
+  if (!args.shareInfo || /Cannot find shared/i.test(errorMessage)) {
+    return 'missing-config';
+  }
+
+  if (
+    args.lifecycle === 'loadShareSync' &&
+    typeof args.shareInfo.get === 'function' &&
+    /RUNTIME-00[56]/.test(errorMessage)
+  ) {
+    return 'sync-async-boundary';
+  }
+
+  if (
+    args.lifecycle === 'loadShareSync' &&
+    !args.shareInfo.get &&
+    /RUNTIME-006/.test(errorMessage)
+  ) {
+    return getSharedMissReason(args);
+  }
+
+  if (args.error) {
+    return 'load-error';
+  }
+
+  return undefined;
+}
+
+function createSharedInfo(
+  args: DiagnosticsSharedLifecycleArgs,
+  reason?: string,
+): DiagnosticsSharedInfo {
+  const shareConfig = args.shareInfo?.shareConfig;
+
+  return {
+    name: args.pkgName,
+    shareScope: getSharedScopes(args.shareInfo),
+    requiredVersion: shareConfig?.requiredVersion,
+    selectedVersion: args.selectedShared?.version,
+    availableVersions: getAvailableSharedVersions(args),
+    provider: args.selectedShared?.from,
+    from: args.shareInfo?.from,
+    singleton: shareConfig?.singleton,
+    strictVersion: shareConfig?.strictVersion,
+    eager: shareConfig?.eager,
+    strategy: args.shareInfo?.strategy,
+    loaded: args.selectedShared?.loaded,
+    loading: Boolean(args.selectedShared?.loading) || undefined,
+    reason,
+  };
+}
+
+function sanitizeShared(
+  shared: DiagnosticsSharedInfo | undefined,
+): DiagnosticsSharedInfo | undefined {
+  if (!shared || !shared.name) {
+    return undefined;
+  }
+
+  return {
+    name: sanitizeText(shared.name, 160) || 'unknown',
+    shareScope: normalizeSharedScope(shared.shareScope),
+    requiredVersion:
+      shared.requiredVersion === false
+        ? false
+        : sanitizeText(shared.requiredVersion, 120),
+    selectedVersion: sanitizeText(shared.selectedVersion, 120),
+    availableVersions: (shared.availableVersions || [])
+      .map((version) => sanitizeText(version, 120))
+      .filter((version): version is string => Boolean(version))
+      .slice(0, 20),
+    provider: sanitizeText(shared.provider, 160),
+    from: sanitizeText(shared.from, 160),
+    singleton: shared.singleton,
+    strictVersion: shared.strictVersion,
+    eager: shared.eager,
+    strategy: sanitizeText(shared.strategy, 80),
+    loaded: shared.loaded,
+    loading: shared.loading,
+    reason: sanitizeText(shared.reason, 120),
+  };
+}
+
+function normalizeEventSource(
+  value: DiagnosticsEventSource | undefined,
+): DiagnosticsEventSource | undefined {
+  return value === 'runtime' || value === 'business' ? value : undefined;
+}
+
+function getErrorInfo(error: unknown): {
+  errorName?: string;
+  errorMessage?: string;
+} {
+  if (!error) {
+    return {};
+  }
+
+  if (error instanceof Error) {
+    return {
+      errorName: sanitizeText(error.name, 120),
+      errorMessage: sanitizeText(error.message),
+    };
+  }
+
+  return {
+    errorMessage: sanitizeText(error),
+  };
+}
+
+function copyEvent(event: DiagnosticsEvent): DiagnosticsEvent {
+  return {
+    ...event,
+    remote: event.remote ? { ...event.remote } : undefined,
+    shared: event.shared
+      ? {
+          ...event.shared,
+          shareScope: event.shared.shareScope
+            ? [...event.shared.shareScope]
+            : undefined,
+          availableVersions: event.shared.availableVersions
+            ? [...event.shared.availableVersions]
+            : undefined,
+        }
+      : undefined,
+  };
+}
+
+function copyReport(report: DiagnosticsReport): DiagnosticsReport {
+  return {
+    ...report,
+    remote: report.remote ? { ...report.remote } : undefined,
+    shared: report.shared
+      ? {
+          ...report.shared,
+          shareScope: report.shared.shareScope
+            ? [...report.shared.shareScope]
+            : undefined,
+          availableVersions: report.shared.availableVersions
+            ? [...report.shared.availableVersions]
+            : undefined,
+        }
+      : undefined,
+    events: report.events.map(copyEvent),
+    summary: { ...report.summary },
+  };
+}
+
+function getFederationGlobal(): FederationDiagnosticsGlobal | undefined {
+  return (
+    globalThis as {
+      __FEDERATION__?: FederationDiagnosticsGlobal;
+    }
+  ).__FEDERATION__;
+}
+
+function normalizeScope(value: unknown) {
+  const sanitized = sanitizeText(value, 120);
+  const normalized = sanitized?.replace(/[^\w:@.-]+/g, '-');
+
+  return normalized || 'default';
+}
+
+function shouldRecordEvent(
+  level: DiagnosticsLevel,
+  event: DiagnosticsRuntimeEventInput,
+) {
+  if (level === 'verbose') {
+    return true;
+  }
+
+  if (level === 'summary') {
+    return event.status !== 'start';
+  }
+
+  return event.status === 'error' || Boolean(event.error);
+}
+
+function createTraceId(event: DiagnosticsRuntimeEventInput) {
+  traceCounter += 1;
+  const owner = event.remote?.name || event.phase || 'runtime';
+  const normalizedOwner = owner.replace(/[^a-z0-9]+/gi, '-').slice(0, 80);
+
+  return `mf-${normalizedOwner}-${Date.now().toString(36)}-${traceCounter.toString(
+    36,
+  )}`;
+}
+
+export function DiagnosticsPlugin(
+  options: DiagnosticsPluginOptions = {},
+): DiagnosticsController {
+  const level = options.level || 'summary';
+  const configuredMaxEvents = normalizeMaxEvents(
+    options.maxEvents,
+    DEFAULT_MAX_EVENTS,
+  );
+  const events: DiagnosticsEvent[] = [];
+  const reports = new Map<string, DiagnosticsReport>();
+  const traceByRequest = new Map<string, string>();
+  const traceByRemote = new Map<string, string>();
+  const consoleReportedTraceIds = new Set<string>();
+  let latestTraceId: string | undefined;
+  let runtimeDiagnosticsEnabled = false;
+  let effectiveMaxEvents = configuredMaxEvents;
+  let browserGlobalScope: string | undefined;
+  let lastRuntimeOrigin: DiagnosticsRuntimeOrigin | undefined;
+
+  const isEnabledForOrigin = (origin: DiagnosticsRuntimeOrigin) => {
+    if (options.enabled === false) {
+      return false;
+    }
+
+    const securityDiagnostics = origin.options?.security?.diagnostics;
+    if (securityDiagnostics?.enabled !== true) {
+      return false;
+    }
+
+    const securityMaxEvents = normalizeMaxEvents(
+      securityDiagnostics.maxEvents,
+      configuredMaxEvents,
+    );
+    effectiveMaxEvents = Math.min(configuredMaxEvents, securityMaxEvents);
+    runtimeDiagnosticsEnabled = true;
+    return true;
+  };
+
+  const resolveTraceId = (event: DiagnosticsRuntimeEventInput) => {
+    const sanitizedRequestId = sanitizeRequestId(event.requestId);
+
+    if (event.traceId && reports.has(event.traceId)) {
+      return event.traceId;
+    }
+
+    if (event.status === 'start' && event.phase === 'loadRemote') {
+      const traceId = event.traceId || createTraceId(event);
+      if (sanitizedRequestId) {
+        traceByRequest.set(sanitizedRequestId, traceId);
+      }
+      if (event.remote?.name) {
+        traceByRemote.set(event.remote.name, traceId);
+      }
+      return traceId;
+    }
+
+    if (sanitizedRequestId) {
+      const traceId = traceByRequest.get(sanitizedRequestId);
+      if (traceId) {
+        return traceId;
+      }
+    }
+
+    if (event.remote?.name) {
+      const traceId = traceByRemote.get(event.remote.name);
+      if (traceId) {
+        return traceId;
+      }
+    }
+
+    return event.traceId || createTraceId(event);
+  };
+
+  const normalizeEvent = (
+    event: DiagnosticsRuntimeEventInput,
+    traceId: string,
+    origin?: DiagnosticsRuntimeOrigin,
+  ): DiagnosticsEvent => {
+    const errorInfo = getErrorInfo(event.error);
+    const sanitizedRemote = sanitizeRemote(event.remote);
+    const sanitizedShared = sanitizeShared(event.shared);
+    const hostName =
+      sanitizeText(event.hostName, 120) ||
+      sanitizeText(origin?.options?.name, 120);
+    const message = sanitizeText(event.message) || errorInfo.errorMessage;
+
+    return {
+      traceId,
+      timestamp: event.timestamp || Date.now(),
+      phase: sanitizeText(event.phase, 120) || 'runtime',
+      status: event.status,
+      requestId: sanitizeRequestId(event.requestId),
+      hostName,
+      remote: sanitizedRemote,
+      shared: sanitizedShared,
+      expose: sanitizeText(event.expose, 240),
+      sanitizedUrl: sanitizeUrl(event.url || event.remote?.entry),
+      message,
+      errorName: errorInfo.errorName,
+      errorMessage: errorInfo.errorMessage,
+      lifecycle: sanitizeText(event.lifecycle, 120),
+      eventName: sanitizeText(event.eventName, 160),
+      source: normalizeEventSource(event.source),
+      recovered: event.recovered === true || undefined,
+      componentName: sanitizeText(event.componentName, 160),
+    };
+  };
+
+  const updateTraceMaps = (event: DiagnosticsEvent) => {
+    if (event.requestId) {
+      traceByRequest.set(event.requestId, event.traceId);
+    }
+
+    if (event.remote?.name) {
+      traceByRemote.set(event.remote.name, event.traceId);
+    }
+  };
+
+  const trimEvents = (report: DiagnosticsReport) => {
+    while (events.length > effectiveMaxEvents) {
+      events.shift();
+    }
+
+    while (report.events.length > effectiveMaxEvents) {
+      report.events.shift();
+    }
+  };
+
+  const getEventOutcome = (event: DiagnosticsEvent) => {
+    if (event.status === 'success') {
+      return 'success';
+    }
+
+    if (event.status === 'error') {
+      return 'error';
+    }
+
+    if (event.status === 'complete') {
+      if (event.recovered) {
+        return 'recovered';
+      }
+
+      if (event.errorName || event.errorMessage) {
+        return 'error';
+      }
+    }
+
+    return undefined;
+  };
+
+  const isLoadRemoteCompleteEvent = (event: DiagnosticsEvent) =>
+    event.phase === 'loadRemote' && event.status === 'complete';
+
+  const isRuntimeLoadedEvent = (event: DiagnosticsEvent) =>
+    event.phase === 'loadRemote' &&
+    (event.status === 'success' ||
+      (event.status === 'complete' && event.recovered));
+
+  const isComponentLoadedEvent = (event: DiagnosticsEvent) =>
+    event.status === 'success' &&
+    (event.eventName === COMPONENT_BUSINESS_LOADED_EVENT ||
+      (event.phase === 'component' &&
+        event.message === COMPONENT_BUSINESS_LOADED_EVENT));
+
+  const shouldReplaceFailedPhase = (
+    report: DiagnosticsReport,
+    event: DiagnosticsEvent,
+  ) => {
+    if (isLoadRemoteCompleteEvent(event) && report.failedPhase) {
+      return false;
+    }
+
+    if (!report.failedPhase) {
+      return true;
+    }
+
+    return report.failedPhase === 'loadRemote' && event.phase !== 'loadRemote';
+  };
+
+  const createReportSummary = (
+    report: DiagnosticsReport,
+  ): DiagnosticsReport['summary'] => {
+    const loadCompleted = report.events.some(isLoadRemoteCompleteEvent);
+    const runtimeLoaded = report.events.some(isRuntimeLoadedEvent);
+    const recovered = report.events.some((item) => item.recovered);
+    const componentLoaded = report.events.some(isComponentLoadedEvent);
+    const lastEvent = report.events[report.events.length - 1];
+    let outcome: DiagnosticsReportOutcome = 'pending';
+
+    if (componentLoaded) {
+      outcome = 'component-loaded';
+    } else if (recovered && runtimeLoaded) {
+      outcome = 'recovered';
+    } else if (report.status === 'error') {
+      outcome = 'failed';
+    } else if (runtimeLoaded) {
+      outcome = 'runtime-loaded';
+    }
+
+    return {
+      eventCount: report.events.length,
+      recovered,
+      loadCompleted,
+      runtimeLoaded,
+      componentLoaded,
+      outcome,
+      lastPhase: lastEvent?.phase,
+    };
+  };
+
+  const updateReport = (event: DiagnosticsEvent) => {
+    let report = reports.get(event.traceId);
+
+    if (!report) {
+      report = {
+        traceId: event.traceId,
+        status: event.status === 'error' ? 'error' : 'pending',
+        requestId: event.requestId,
+        hostName: event.hostName,
+        remote: event.remote ? { ...event.remote } : undefined,
+        shared: event.shared ? copyEvent(event).shared : undefined,
+        expose: event.expose,
+        startedAt: event.timestamp,
+        updatedAt: event.timestamp,
+        duration: 0,
+        failedPhase: event.status === 'error' ? event.phase : undefined,
+        events: [],
+        summary: {
+          eventCount: 0,
+          recovered: false,
+          loadCompleted: false,
+          runtimeLoaded: false,
+          componentLoaded: false,
+          outcome: 'pending',
+          lastPhase: undefined,
+        },
+      };
+      reports.set(event.traceId, report);
+    }
+
+    if (event.requestId) {
+      report.requestId = event.requestId;
+    }
+    if (event.hostName) {
+      report.hostName = event.hostName;
+    }
+    if (event.remote) {
+      report.remote = { ...event.remote };
+    }
+    if (event.shared) {
+      report.shared = copyEvent(event).shared;
+    }
+    if (event.expose) {
+      report.expose = event.expose;
+    }
+
+    report.events.push(event);
+    report.updatedAt = event.timestamp;
+    report.duration = Math.max(0, report.updatedAt - report.startedAt);
+
+    const eventOutcome = getEventOutcome(event);
+
+    if (eventOutcome === 'error') {
+      report.status = 'error';
+      if (shouldReplaceFailedPhase(report, event)) {
+        report.failedPhase = event.phase;
+      }
+    } else if (
+      (eventOutcome === 'success' || eventOutcome === 'recovered') &&
+      report.status !== 'error'
+    ) {
+      report.status = 'success';
+    }
+
+    report.summary = createReportSummary(report);
+
+    latestTraceId = event.traceId;
+    trimEvents(report);
+    return report;
+  };
+
+  const notifyEvent = (
+    event: DiagnosticsEvent,
+    report: DiagnosticsReport,
+    origin?: DiagnosticsRuntimeOrigin,
+  ) => {
+    try {
+      options.onEvent?.(copyEvent(event), copyReport(report), { origin });
+    } catch {
+      // Diagnostics callbacks must not affect Module Federation loading.
+    }
+  };
+
+  const notifyReport = (
+    report: DiagnosticsReport,
+    origin?: DiagnosticsRuntimeOrigin,
+  ) => {
+    if (report.events[report.events.length - 1]?.status === 'start') {
+      return;
+    }
+
+    try {
+      options.onReport?.(copyReport(report), { origin });
+    } catch {
+      // Diagnostics callbacks must not affect Module Federation loading.
+    }
+  };
+
+  const getEventsSnapshot = () => events.map(copyEvent);
+
+  const getTraceIdsSnapshot = () => Array.from(reports.keys());
+
+  const getLatestReportSnapshot = () => {
+    if (!latestTraceId) {
+      return undefined;
+    }
+
+    const report = reports.get(latestTraceId);
+    return report ? copyReport(report) : undefined;
+  };
+
+  const getReportSnapshot = (traceId: string) => {
+    const report = reports.get(traceId);
+    return report ? copyReport(report) : undefined;
+  };
+
+  const createBrowserReader = (): DiagnosticsBrowserReader => ({
+    getEvents: getEventsSnapshot,
+    getTraceIds: getTraceIdsSnapshot,
+    getLatestReport: getLatestReportSnapshot,
+    getReport: getReportSnapshot,
+  });
+
+  const shouldExposeBrowserGlobal = (origin?: DiagnosticsRuntimeOrigin) =>
+    options.browser?.enabled === true &&
+    origin?.options?.security?.diagnostics?.browserGlobal === true;
+
+  const ensureBrowserGlobal = (origin?: DiagnosticsRuntimeOrigin) => {
+    if (!shouldExposeBrowserGlobal(origin)) {
+      return;
+    }
+
+    const federationGlobal = getFederationGlobal();
+    if (!federationGlobal) {
+      return;
+    }
+
+    const scope = normalizeScope(
+      options.browser?.scope || origin?.options?.name || 'default',
+    );
+    const reader = createBrowserReader();
+
+    federationGlobal.__DIAGNOSTICS__ = federationGlobal.__DIAGNOSTICS__ || {};
+    browserGlobalScope = scope;
+
+    try {
+      Object.defineProperty(federationGlobal.__DIAGNOSTICS__, scope, {
+        value: reader,
+        configurable: true,
+        enumerable: true,
+      });
+    } catch {
+      federationGlobal.__DIAGNOSTICS__[scope] = reader;
+    }
+  };
+
+  const shouldUseConsole = (origin?: DiagnosticsRuntimeOrigin) =>
+    options.console !== false &&
+    origin?.options?.security?.diagnostics?.console !== false;
+
+  const getBrowserReadCommand = (traceId: string) => {
+    if (!browserGlobalScope) {
+      return undefined;
+    }
+
+    return `window.__FEDERATION__.__DIAGNOSTICS__[${JSON.stringify(
+      browserGlobalScope,
+    )}].getReport(${JSON.stringify(traceId)})`;
+  };
+
+  const emitConsoleHint = (
+    event: DiagnosticsEvent,
+    report: DiagnosticsReport,
+    origin?: DiagnosticsRuntimeOrigin,
+  ) => {
+    if (
+      getEventOutcome(event) !== 'error' ||
+      !shouldUseConsole(origin) ||
+      consoleReportedTraceIds.has(report.traceId)
+    ) {
+      return;
+    }
+
+    consoleReportedTraceIds.add(report.traceId);
+
+    const lines = [
+      '[Module Federation] Diagnostic report generated',
+      `traceId: ${report.traceId}`,
+      `phase: ${report.failedPhase || event.phase}`,
+    ];
+
+    if (report.requestId) {
+      lines.push(`requestId: ${report.requestId}`);
+    }
+    if (report.shared?.name) {
+      lines.push(`shared: ${report.shared.name}`);
+    }
+
+    const browserReadCommand = getBrowserReadCommand(report.traceId);
+    if (browserReadCommand) {
+      lines.push(`read: ${browserReadCommand}`);
+    } else {
+      lines.push(
+        `read: diagnostics.getReport(${JSON.stringify(report.traceId)})`,
+      );
+    }
+
+    try {
+      console.warn(lines.join('\n'));
+    } catch {
+      // Console output is best-effort diagnostics only.
+    }
+  };
+
+  const prepareOutputChannels = (origin: DiagnosticsRuntimeOrigin) => {
+    browserGlobalScope = undefined;
+    ensureBrowserGlobal(origin);
+  };
+
+  const prepareRuntimeOrigin = (origin: DiagnosticsRuntimeOrigin) => {
+    if (!isEnabledForOrigin(origin)) {
+      return false;
+    }
+
+    lastRuntimeOrigin = origin;
+    prepareOutputChannels(origin);
+    return true;
+  };
+
+  const recordEvent = (
+    input: DiagnosticsRuntimeEventInput,
+    origin?: DiagnosticsRuntimeOrigin,
+  ) => {
+    const traceId = resolveTraceId(input);
+
+    if (!shouldRecordEvent(level, input)) {
+      return undefined;
+    }
+
+    const event = normalizeEvent(input, traceId, origin);
+    updateTraceMaps(event);
+    events.push(event);
+    const report = updateReport(event);
+    emitConsoleHint(event, report, origin);
+    notifyEvent(event, report, origin);
+    notifyReport(report, origin);
+    return event;
+  };
+
+  const plugin: DiagnosticsRuntimePlugin = {
+    name: 'diagnostics-plugin',
+    beforeRequest(args) {
+      const requestArgs = args as DiagnosticsRemoteBeforeRequestArgs;
+      if (!prepareRuntimeOrigin(requestArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'start',
+          requestId: requestArgs.id,
+          lifecycle: 'beforeRequest',
+          message: 'remote:load-start',
+        },
+        requestArgs.origin,
+      );
+    },
+    beforeLoadRemoteSnapshot(args) {
+      const snapshotArgs = args as DiagnosticsRemoteSnapshotArgs;
+      if (!prepareRuntimeOrigin(snapshotArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(snapshotArgs.moduleInfo);
+      if (!isManifestUrl(remote?.entry)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'manifest',
+          status: 'start',
+          requestId: remote?.entry,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'beforeLoadRemoteSnapshot',
+          message: 'manifest:load-start',
+        },
+        snapshotArgs.origin,
+      );
+    },
+    afterResolve(args) {
+      const resolveArgs = args as DiagnosticsRemoteResolveArgs;
+      if (!prepareRuntimeOrigin(resolveArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(
+        resolveArgs.remoteInfo || resolveArgs.remote,
+      );
+      if (!isManifestUrl(remote?.entry)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'manifest',
+          status: 'success',
+          requestId: remote?.entry,
+          expose: resolveArgs.expose,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'afterResolve',
+          message: 'manifest:resolved',
+        },
+        resolveArgs.origin,
+      );
+    },
+    onLoad(args) {
+      const loadArgs = args as DiagnosticsRemoteLoadArgs;
+      if (!prepareRuntimeOrigin(loadArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'success',
+          requestId: loadArgs.id,
+          lifecycle: 'onLoad',
+          expose: loadArgs.expose,
+          remote: createRemoteInfo(loadArgs.remote),
+          message: 'remote:loaded',
+        },
+        loadArgs.origin,
+      );
+    },
+    errorLoadRemote(args) {
+      const errorArgs = args as DiagnosticsRemoteErrorArgs;
+      if (
+        !prepareRuntimeOrigin(errorArgs.origin) ||
+        (errorArgs.lifecycle !== 'onLoad' &&
+          errorArgs.lifecycle !== 'beforeRequest' &&
+          errorArgs.lifecycle !== 'afterResolve')
+      ) {
+        return undefined;
+      }
+
+      const isManifestError = errorArgs.lifecycle === 'afterResolve';
+      recordEvent(
+        {
+          phase: isManifestError ? 'manifest' : 'loadRemote',
+          status: 'error',
+          requestId: errorArgs.id,
+          lifecycle: errorArgs.lifecycle,
+          expose: errorArgs.expose,
+          remote: createRemoteInfo(errorArgs.remote),
+          url: isManifestError ? errorArgs.id : undefined,
+          message: isManifestError
+            ? 'manifest:failed'
+            : errorArgs.lifecycle
+              ? `remote:${errorArgs.lifecycle}:failed`
+              : 'remote:failed',
+          error: errorArgs.error,
+        },
+        errorArgs.origin,
+      );
+
+      return undefined;
+    },
+    afterLoadRemote(args) {
+      const loadArgs = args as DiagnosticsRemoteAfterLoadArgs;
+      if (!prepareRuntimeOrigin(loadArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'complete',
+          requestId: loadArgs.id,
+          lifecycle: 'afterLoadRemote',
+          expose: loadArgs.expose,
+          remote: createRemoteInfo(loadArgs.remote),
+          message: loadArgs.recovered
+            ? 'remote:load-recovered'
+            : loadArgs.error
+              ? 'remote:load-failed'
+              : 'remote:load-complete',
+          error: loadArgs.error,
+          recovered: loadArgs.recovered,
+        },
+        loadArgs.origin,
+      );
+    },
+    loadEntry(args) {
+      const entryArgs = args as DiagnosticsRemoteEntryLoadArgs;
+      if (!prepareRuntimeOrigin(entryArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(entryArgs.remoteInfo);
+      recordEvent(
+        {
+          phase: 'remoteEntry',
+          status: 'start',
+          requestId: remote?.name,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'loadEntry',
+          message: 'remoteEntry:load-start',
+        },
+        entryArgs.origin,
+      );
+    },
+    afterLoadEntry(args) {
+      const entryArgs = args as DiagnosticsRemoteEntryAfterLoadArgs;
+      if (!prepareRuntimeOrigin(entryArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(entryArgs.remoteInfo);
+      recordEvent(
+        {
+          phase: 'remoteEntry',
+          status: entryArgs.error ? 'error' : 'success',
+          requestId: remote?.name,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'afterLoadEntry',
+          message: entryArgs.error
+            ? 'remoteEntry:load-failed'
+            : entryArgs.recovered
+              ? 'remoteEntry:load-recovered'
+              : 'remoteEntry:loaded',
+          error: entryArgs.error,
+          recovered: entryArgs.recovered,
+        },
+        entryArgs.origin,
+      );
+    },
+    beforeLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return args;
+      }
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'start',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: 'loadShare',
+          shared: createSharedInfo(args),
+          message: 'shared:load-start',
+        },
+        args.origin,
+      );
+
+      return args;
+    },
+    afterLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'success',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: args.lifecycle,
+          shared: createSharedInfo(args),
+          message:
+            args.lifecycle === 'loadShareSync'
+              ? 'shared:resolved-sync'
+              : 'shared:resolved',
+        },
+        args.origin,
+      );
+    },
+    errorLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return;
+      }
+
+      const reason = getSharedErrorReason(args);
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'error',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: args.lifecycle,
+          shared: createSharedInfo(args, reason),
+          message: reason ? `shared:${reason}` : undefined,
+          error: args.error,
+          recovered: args.recovered,
+        },
+        args.origin,
+      );
+    },
+  } as DiagnosticsRuntimePlugin;
+
+  return {
+    plugin,
+    getEvents() {
+      return getEventsSnapshot();
+    },
+    getTraceIds() {
+      return getTraceIdsSnapshot();
+    },
+    getLatestReport() {
+      return getLatestReportSnapshot();
+    },
+    getReport(traceId: string) {
+      return getReportSnapshot(traceId);
+    },
+    clear() {
+      events.length = 0;
+      reports.clear();
+      traceByRequest.clear();
+      traceByRemote.clear();
+      consoleReportedTraceIds.clear();
+      latestTraceId = undefined;
+      runtimeDiagnosticsEnabled = false;
+      effectiveMaxEvents = configuredMaxEvents;
+      browserGlobalScope = undefined;
+      lastRuntimeOrigin = undefined;
+    },
+    markComponentLoaded(markOptions: MarkComponentLoadedOptions = {}) {
+      if (options.enabled === false || !runtimeDiagnosticsEnabled) {
+        return undefined;
+      }
+
+      const traceId =
+        markOptions.traceId ||
+        (markOptions.requestId
+          ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || '')
+          : undefined) ||
+        latestTraceId ||
+        createTraceId({
+          phase: 'component',
+          status: 'success',
+          requestId: markOptions.requestId,
+        });
+
+      return recordEvent(
+        {
+          traceId,
+          phase: 'component',
+          status: 'success',
+          requestId: markOptions.requestId,
+          componentName: markOptions.componentName,
+          eventName: COMPONENT_BUSINESS_LOADED_EVENT,
+          message: COMPONENT_BUSINESS_LOADED_EVENT,
+          source: 'business',
+        },
+        lastRuntimeOrigin,
+      );
+    },
+  };
+}
diff --git a/packages/diagnostics-plugin/src/node.ts b/packages/diagnostics-plugin/src/node.ts
new file mode 100644
index 00000000000..19f1da55e5a
--- /dev/null
+++ b/packages/diagnostics-plugin/src/node.ts
@@ -0,0 +1,304 @@
+import {
+  DiagnosticsPlugin as createBaseDiagnosticsPlugin,
+  type DiagnosticsController,
+  type DiagnosticsEvent,
+  type DiagnosticsEventContext,
+  type DiagnosticsPluginOptions,
+  type DiagnosticsReport,
+  type DiagnosticsRuntimeOrigin,
+} from './index';
+
+export interface DiagnosticsNodeOptions extends Omit<
+  DiagnosticsPluginOptions,
+  'browser'
+> {
+  directory?: string;
+  latestFile?: string;
+  eventsFile?: string;
+}
+
+interface NodeOutputModules {
+  fs: {
+    mkdirSync(path: string, options?: { recursive?: boolean }): void;
+    writeFileSync(path: string, data: string, encoding?: string): void;
+    appendFileSync(path: string, data: string, encoding?: string): void;
+  };
+  path: {
+    isAbsolute(path: string): boolean;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+  };
+}
+
+const DEFAULT_NODE_DIRECTORY = '.mf/diagnostics';
+const DEFAULT_LATEST_FILE = 'latest.json';
+const DEFAULT_EVENTS_FILE = 'events.jsonl';
+
+let nodeOutputModulesPromise:
+  | Promise<NodeOutputModules | undefined>
+  | undefined;
+
+declare const __non_webpack_require__: ((id: string) => unknown) | undefined;
+
+function getNodeProcess():
+  | { versions?: { node?: string }; cwd?: () => string }
+  | undefined {
+  return (
+    globalThis as {
+      process?: { versions?: { node?: string }; cwd?: () => string };
+    }
+  ).process;
+}
+
+function isNodeEnvironment() {
+  return Boolean(getNodeProcess()?.versions?.node);
+}
+
+export function getNativeNodeRequire(): ((id: string) => unknown) | undefined {
+  if (typeof __non_webpack_require__ === 'function') {
+    return __non_webpack_require__;
+  }
+
+  const globalRequire = (
+    globalThis as {
+      __non_webpack_require__?: (id: string) => unknown;
+    }
+  ).__non_webpack_require__;
+  if (typeof globalRequire === 'function') {
+    return globalRequire;
+  }
+
+  try {
+    return Function(
+      'return typeof require === "function" ? require : undefined',
+    )() as ((id: string) => unknown) | undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function getRuntimeImport():
+  | ((specifier: string) => Promise<Record<string, unknown>>)
+  | undefined {
+  try {
+    return Function('specifier', 'return import(specifier)') as (
+      specifier: string,
+    ) => Promise<Record<string, unknown>>;
+  } catch {
+    return undefined;
+  }
+}
+
+function unwrapDefaultExport<T>(moduleValue: T & { default?: T }) {
+  return moduleValue.default || moduleValue;
+}
+
+async function getNodeOutputModules(): Promise<NodeOutputModules | undefined> {
+  if (!isNodeEnvironment()) {
+    return undefined;
+  }
+
+  if (nodeOutputModulesPromise) {
+    return nodeOutputModulesPromise;
+  }
+
+  nodeOutputModulesPromise = (async () => {
+    const nativeRequire = getNativeNodeRequire();
+    if (nativeRequire) {
+      try {
+        const fs = nativeRequire('node:fs');
+        const path = nativeRequire('node:path');
+        return {
+          fs,
+          path,
+        } as NodeOutputModules;
+      } catch {
+        // Fall through to dynamic import for ESM-only Node environments.
+      }
+    }
+
+    const runtimeImport = getRuntimeImport();
+    if (!runtimeImport) {
+      return undefined;
+    }
+
+    try {
+      const [fsModule, pathModule] = await Promise.all([
+        runtimeImport('node:fs'),
+        runtimeImport('node:path'),
+      ]);
+
+      return {
+        fs: unwrapDefaultExport(fsModule),
+        path: unwrapDefaultExport(pathModule),
+      } as NodeOutputModules;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  return nodeOutputModulesPromise;
+}
+
+function getNodeOutputConfig(options: DiagnosticsNodeOptions) {
+  return {
+    directory: options.directory || DEFAULT_NODE_DIRECTORY,
+    latestFile: options.latestFile || DEFAULT_LATEST_FILE,
+    eventsFile: options.eventsFile || DEFAULT_EVENTS_FILE,
+  };
+}
+
+function shouldUseNodeOutput(
+  options: DiagnosticsNodeOptions,
+  origin?: DiagnosticsRuntimeOrigin,
+) {
+  return (
+    options.enabled !== false &&
+    origin?.options?.security?.diagnostics?.fileOutput === true &&
+    isNodeEnvironment()
+  );
+}
+
+function shouldUseConsole(
+  options: DiagnosticsNodeOptions,
+  origin?: DiagnosticsRuntimeOrigin,
+) {
+  return (
+    options.console !== false &&
+    origin?.options?.security?.diagnostics?.console !== false
+  );
+}
+
+function getNodeLatestPathForConsole(options: DiagnosticsNodeOptions) {
+  const config = getNodeOutputConfig(options);
+  return `${config.directory}/${config.latestFile}`;
+}
+
+function getNodeEventsPathForConsole(options: DiagnosticsNodeOptions) {
+  const config = getNodeOutputConfig(options);
+  return `${config.directory}/${config.eventsFile}`;
+}
+
+function isErrorEvent(event: DiagnosticsEvent) {
+  return (
+    event.status === 'error' ||
+    (event.status === 'complete' &&
+      Boolean(event.errorName || event.errorMessage))
+  );
+}
+
+async function writeNodeOutput(
+  options: DiagnosticsNodeOptions,
+  event: DiagnosticsEvent,
+  report: DiagnosticsReport,
+) {
+  const modules = await getNodeOutputModules();
+  if (!modules) {
+    return;
+  }
+
+  const config = getNodeOutputConfig(options);
+  const cwd = getNodeProcess()?.cwd?.() || '.';
+  const directory = modules.path.isAbsolute(config.directory)
+    ? config.directory
+    : modules.path.resolve(cwd, config.directory);
+  const latestFile = modules.path.join(directory, config.latestFile);
+  const eventsFile = modules.path.join(directory, config.eventsFile);
+
+  modules.fs.mkdirSync(directory, { recursive: true });
+  modules.fs.writeFileSync(
+    latestFile,
+    `${JSON.stringify(report, null, 2)}\n`,
+    'utf8',
+  );
+  modules.fs.appendFileSync(eventsFile, `${JSON.stringify(event)}\n`, 'utf8');
+}
+
+function emitNodeConsoleHint(
+  options: DiagnosticsNodeOptions,
+  event: DiagnosticsEvent,
+  report: DiagnosticsReport,
+  context: DiagnosticsEventContext | undefined,
+  reportedTraceIds: Set<string>,
+) {
+  if (
+    !isErrorEvent(event) ||
+    !shouldUseConsole(options, context?.origin) ||
+    reportedTraceIds.has(report.traceId)
+  ) {
+    return;
+  }
+
+  reportedTraceIds.add(report.traceId);
+
+  const lines = [
+    '[Module Federation] Diagnostic report generated',
+    `traceId: ${report.traceId}`,
+    `phase: ${report.failedPhase || event.phase}`,
+  ];
+
+  if (report.requestId) {
+    lines.push(`requestId: ${report.requestId}`);
+  }
+  if (report.shared?.name) {
+    lines.push(`shared: ${report.shared.name}`);
+  }
+
+  if (shouldUseNodeOutput(options, context?.origin)) {
+    lines.push(`latest: ${getNodeLatestPathForConsole(options)}`);
+    lines.push(`events: ${getNodeEventsPathForConsole(options)}`);
+  } else {
+    lines.push(
+      `read: diagnostics.getReport(${JSON.stringify(report.traceId)})`,
+    );
+  }
+
+  try {
+    console.warn(lines.join('\n'));
+  } catch {
+    // Console output is best-effort diagnostics only.
+  }
+}
+
+export function DiagnosticsPlugin(
+  options: DiagnosticsNodeOptions = {},
+): DiagnosticsController {
+  let nodeWriteQueue: Promise<void> = Promise.resolve();
+  const consoleReportedTraceIds = new Set<string>();
+  const diagnostics = createBaseDiagnosticsPlugin({
+    ...options,
+    console: false,
+    browser: undefined,
+    onEvent(event, report, context) {
+      if (shouldUseNodeOutput(options, context?.origin)) {
+        nodeWriteQueue = nodeWriteQueue
+          .catch(() => undefined)
+          .then(() => writeNodeOutput(options, event, report))
+          .catch(() => undefined);
+      }
+
+      emitNodeConsoleHint(
+        options,
+        event,
+        report,
+        context,
+        consoleReportedTraceIds,
+      );
+      options.onEvent?.(event, report, context);
+    },
+    onReport(report, context) {
+      options.onReport?.(report, context);
+    },
+  });
+
+  diagnostics.plugin.name = 'diagnostics-node-plugin';
+
+  const clear = diagnostics.clear;
+  diagnostics.clear = () => {
+    clear();
+    nodeWriteQueue = Promise.resolve();
+    consoleReportedTraceIds.clear();
+  };
+
+  return diagnostics;
+}
diff --git a/packages/diagnostics-plugin/tsconfig.json b/packages/diagnostics-plugin/tsconfig.json
new file mode 100644
index 00000000000..90b8d931e39
--- /dev/null
+++ b/packages/diagnostics-plugin/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "exclude": ["src/**/*.spec.ts", "src/**/*.test.ts"]
+}
diff --git a/packages/diagnostics-plugin/tsdown.config.ts b/packages/diagnostics-plugin/tsdown.config.ts
new file mode 100644
index 00000000000..ed6aed2906a
--- /dev/null
+++ b/packages/diagnostics-plugin/tsdown.config.ts
@@ -0,0 +1,40 @@
+import { defineConfig } from 'tsdown';
+
+const entry = {
+  index: 'src/index.ts',
+  node: 'src/node.ts',
+};
+
+const baseConfig = {
+  cwd: import.meta.dirname,
+  tsconfig: 'tsconfig.json',
+  clean: true,
+  entry,
+  external: ['@module-federation/runtime'],
+};
+
+export default defineConfig([
+  {
+    ...baseConfig,
+    name: 'diagnostics-plugin-cjs',
+    outDir: 'dist',
+    format: ['cjs'],
+    dts: {
+      resolver: 'tsc',
+    },
+    outExtensions: () => ({
+      js: '.js',
+      dts: '.d.ts',
+    }),
+  },
+  {
+    ...baseConfig,
+    name: 'diagnostics-plugin-esm',
+    outDir: 'dist/esm',
+    format: ['esm'],
+    dts: false,
+    outExtensions: () => ({
+      js: '.js',
+    }),
+  },
+]);
diff --git a/packages/diagnostics-plugin/vitest.config.ts b/packages/diagnostics-plugin/vitest.config.ts
new file mode 100644
index 00000000000..9d82a458863
--- /dev/null
+++ b/packages/diagnostics-plugin/vitest.config.ts
@@ -0,0 +1,19 @@
+import path from 'path';
+import { defineConfig } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  define: {
+    __DEV__: true,
+    __TEST__: true,
+    __BROWSER__: false,
+    __VERSION__: '"unknown"',
+  },
+  plugins: [tsconfigPaths()],
+  test: {
+    environment: 'node',
+    include: [path.resolve(__dirname, '__tests__/*.spec.ts')],
+    globals: true,
+    testTimeout: 10000,
+  },
+});
diff --git a/packages/runtime-core/__tests__/hooks.spec.ts b/packages/runtime-core/__tests__/hooks.spec.ts
index 57c8b75229c..4fbce5ab82f 100644
--- a/packages/runtime-core/__tests__/hooks.spec.ts
+++ b/packages/runtime-core/__tests__/hooks.spec.ts
@@ -3,6 +3,12 @@ import { ModuleFederation } from '../src/core';
 import { ModuleFederationRuntimePlugin } from '../src/type/plugin';
 import { mockStaticServer, removeScriptTags } from './mock/utils';
 import { addGlobalSnapshot } from '../src/global';
+import {
+  AsyncHook,
+  AsyncWaterfallHook,
+  SyncHook,
+  SyncWaterfallHook,
+} from '../src/utils/hooks';
 
 // eslint-disable-next-line max-lines-per-function
 describe('hooks', () => {
@@ -447,4 +453,147 @@ describe('hooks', () => {
     assert(loadEntryTestRes);
     expect(loadEntryTestRes).toBe('./testtest');
   });
+
+  it('sync hooks preserve previous returned value when later listeners return nothing', () => {
+    const hook = new SyncHook<[string], string | void>('sync-noop');
+    const calls: Array<string> = [];
+
+    hook.on((value) => {
+      calls.push(`first:${value}`);
+      return 'first-result';
+    });
+    hook.on((value) => {
+      calls.push(`second:${value}`);
+    });
+
+    expect(hook.emit('payload')).toBe('first-result');
+    expect(calls).toEqual(['first:payload', 'second:payload']);
+  });
+
+  it('sync hooks use the latest explicit returned value', () => {
+    const hook = new SyncHook<[string], string | void>('sync-override');
+
+    hook.on(() => 'first-result');
+    hook.on(() => 'second-result');
+
+    expect(hook.emit('payload')).toBe('second-result');
+  });
+
+  it('async hooks preserve previous returned value when later listeners return nothing', async () => {
+    const hook = new AsyncHook<[string], string | void | false>('async-noop');
+    const calls: Array<string> = [];
+
+    hook.on(async (value) => {
+      calls.push(`first:${value}`);
+      return 'first-result';
+    });
+    hook.on((value) => {
+      calls.push(`second:${value}`);
+    });
+
+    await expect(hook.emit('payload')).resolves.toBe('first-result');
+    expect(calls).toEqual(['first:payload', 'second:payload']);
+  });
+
+  it('async hooks use the latest explicit returned value', async () => {
+    const hook = new AsyncHook<[string], string | void | false>(
+      'async-override',
+    );
+
+    hook.on(async () => 'first-result');
+    hook.on(() => 'second-result');
+
+    await expect(hook.emit('payload')).resolves.toBe('second-result');
+  });
+
+  it('async hooks still abort when a listener returns false', async () => {
+    const hook = new AsyncHook<[string], string | void | false>('async-abort');
+    const calls: Array<string> = [];
+
+    hook.on(() => {
+      calls.push('first');
+      return 'first-result';
+    });
+    hook.on(() => {
+      calls.push('second');
+      return false;
+    });
+    hook.on(() => {
+      calls.push('third');
+      return 'third-result';
+    });
+
+    await expect(hook.emit('payload')).resolves.toBe(false);
+    expect(calls).toEqual(['first', 'second']);
+  });
+
+  it('sync waterfall hooks keep the current payload when observers return nothing', () => {
+    const hook = new SyncWaterfallHook<{ id: string; changed?: boolean }>(
+      'sync-waterfall-noop',
+    );
+
+    hook.on((args) => ({
+      ...args,
+      changed: true,
+    }));
+    hook.on(() => undefined);
+
+    expect(hook.emit({ id: 'remote/Button' })).toEqual({
+      id: 'remote/Button',
+      changed: true,
+    });
+  });
+
+  it('async waterfall hooks keep the current payload when observers return nothing', async () => {
+    const hook = new AsyncWaterfallHook<{ id: string; changed?: boolean }>(
+      'async-waterfall-noop',
+    );
+
+    hook.on(async (args) => ({
+      ...args,
+      changed: true,
+    }));
+    hook.on(() => undefined);
+
+    await expect(hook.emit({ id: 'remote/Button' })).resolves.toEqual({
+      id: 'remote/Button',
+      changed: true,
+    });
+  });
+
+  it('observer plugins do not clear errorLoadRemote fallback results', async () => {
+    let observedLifecycle: string | undefined;
+    const fallbackPlugin: ModuleFederationRuntimePlugin = {
+      name: 'fallback-plugin',
+      errorLoadRemote() {
+        return {
+          default: () => 'fallback component',
+        };
+      },
+    };
+    const observerPlugin: ModuleFederationRuntimePlugin = {
+      name: 'observer-plugin',
+      errorLoadRemote(args) {
+        observedLifecycle = args.lifecycle;
+      },
+    };
+    const GM = new ModuleFederation({
+      name: '@hooks/error-load-remote-fallback',
+      remotes: [],
+      plugins: [fallbackPlugin, observerPlugin],
+    });
+
+    const result = (await GM.remoteHandler.hooks.lifecycle.errorLoadRemote.emit(
+      {
+        id: '@demo/fallback/component',
+        error: new Error('load failed'),
+        from: 'runtime',
+        lifecycle: 'onLoad',
+        origin: GM,
+      },
+    )) as { default: () => string };
+
+    expect(result.default()).toBe('fallback component');
+    expect(observedLifecycle).toBe('onLoad');
+  });
 });
diff --git a/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts b/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
new file mode 100644
index 00000000000..5cba8a25931
--- /dev/null
+++ b/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ModuleFederation } from '../src/core';
+import { resetFederationGlobalInfo } from '../src/global';
+import type { ModuleFederationRuntimePlugin } from '../src/type';
+import { mockStaticServer, removeScriptTags } from './mock/utils';
+
+const createDiagnosticsRecorder = (
+  events: Array<Record<string, unknown>>,
+): ModuleFederationRuntimePlugin => ({
+  name: 'load-remote-diagnostics-test-plugin',
+  afterLoadRemote(args) {
+    events.push(args);
+  },
+});
+
+describe('loadRemote diagnostics', () => {
+  mockStaticServer({
+    baseDir: __dirname,
+    filterKeywords: [],
+    basename: 'http://localhost:1111/',
+  });
+
+  beforeEach(() => {
+    resetFederationGlobalInfo();
+    removeScriptTags();
+  });
+
+  it('emits an afterLoadRemote hook after a successful remote load', async () => {
+    const events: Array<Record<string, unknown>> = [];
+    const mf = new ModuleFederation({
+      name: 'load-remote-diagnostics-host',
+      remotes: [
+        {
+          name: '@demo/main',
+          entry:
+            'http://localhost:1111/resources/main/federation-manifest.json',
+        },
+      ],
+      plugins: [createDiagnosticsRecorder(events)],
+    });
+
+    const say = await mf.loadRemote<() => string>('@demo/main/say');
+
+    expect(say?.()).toBe('hello world');
+    expect(events).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: '@demo/main/say',
+          expose: './say',
+        }),
+      ]),
+    );
+  });
+});
diff --git a/packages/runtime-core/__tests__/shared-diagnostics.spec.ts b/packages/runtime-core/__tests__/shared-diagnostics.spec.ts
new file mode 100644
index 00000000000..c6a6088086c
--- /dev/null
+++ b/packages/runtime-core/__tests__/shared-diagnostics.spec.ts
@@ -0,0 +1,166 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { RUNTIME_005 } from '@module-federation/error-codes';
+import { ModuleFederation } from '../src/core';
+import { resetFederationGlobalInfo } from '../src/global';
+import type { ModuleFederationRuntimePlugin } from '../src/type';
+
+type SharedLifecycleEvent =
+  | { type: 'before'; pkgName: string }
+  | {
+      type: 'after';
+      pkgName: string;
+      lifecycle: string;
+      selectedVersion?: string;
+      provider?: string;
+    }
+  | {
+      type: 'error';
+      pkgName: string;
+      lifecycle: string;
+      recovered?: boolean;
+      availableVersions: string[];
+      error?: unknown;
+    };
+
+const createSharedLifecyclePlugin = (
+  events: SharedLifecycleEvent[],
+): ModuleFederationRuntimePlugin => ({
+  name: 'shared-lifecycle-test-plugin',
+  beforeLoadShare(args) {
+    events.push({
+      type: 'before',
+      pkgName: args.pkgName,
+    });
+    return args;
+  },
+  afterLoadShare(args) {
+    events.push({
+      type: 'after',
+      pkgName: args.pkgName,
+      lifecycle: args.lifecycle,
+      selectedVersion: args.selectedShared?.version,
+      provider: args.selectedShared?.from,
+    });
+  },
+  errorLoadShare(args) {
+    events.push({
+      type: 'error',
+      pkgName: args.pkgName,
+      lifecycle: args.lifecycle,
+      recovered: args.recovered,
+      availableVersions: Object.keys(
+        args.shareScopeMap.default?.[args.pkgName] || {},
+      ),
+      error: args.error,
+    });
+  },
+});
+
+describe('shared lifecycle hooks', () => {
+  beforeEach(() => {
+    resetFederationGlobalInfo();
+  });
+
+  it('emits beforeLoadShare and afterLoadShare for loadShare success', async () => {
+    const events: SharedLifecycleEvent[] = [];
+    const mf = new ModuleFederation({
+      name: 'shared-lifecycle-host',
+      remotes: [],
+      plugins: [createSharedLifecyclePlugin(events)],
+      shared: {
+        'diagnostics-shared': {
+          version: '1.0.0',
+          lib: () => ({ value: 'shared' }),
+        },
+      },
+    });
+
+    const factory = await mf.loadShare<{ value: string }>('diagnostics-shared');
+
+    expect(factory?.()).toEqual({ value: 'shared' });
+    expect(events).toEqual([
+      {
+        type: 'before',
+        pkgName: 'diagnostics-shared',
+      },
+      {
+        type: 'after',
+        pkgName: 'diagnostics-shared',
+        lifecycle: 'loadShare',
+        selectedVersion: '1.0.0',
+        provider: 'shared-lifecycle-host',
+      },
+    ]);
+  });
+
+  it('emits errorLoadShare when custom shared info cannot be matched', async () => {
+    const events: SharedLifecycleEvent[] = [];
+    const mf = new ModuleFederation({
+      name: 'shared-lifecycle-version-host',
+      remotes: [],
+      plugins: [createSharedLifecyclePlugin(events)],
+      shared: {
+        react: {
+          version: '18.3.1',
+          lib: () => ({ version: '18.3.1' }),
+        },
+      },
+    });
+
+    const result = await mf.loadShare('react', {
+      customShareInfo: {
+        shareConfig: {
+          requiredVersion: '^99.0.0',
+          singleton: false,
+        },
+      },
+    });
+
+    expect(result).toBe(false);
+    expect(events.at(-1)).toEqual({
+      type: 'error',
+      pkgName: 'react',
+      lifecycle: 'loadShare',
+      recovered: true,
+      availableVersions: ['18.3.1'],
+      error: undefined,
+    });
+  });
+
+  it('emits errorLoadShare for async shared consumed synchronously', () => {
+    const events: SharedLifecycleEvent[] = [];
+    const mf = new ModuleFederation({
+      name: 'shared-lifecycle-eager-host',
+      remotes: [],
+      plugins: [createSharedLifecyclePlugin(events)],
+      shared: {},
+    });
+
+    expect(() =>
+      mf.loadShareSync('diagnostics-async-shared', {
+        from: 'build',
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['default'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+            eager: false,
+            strictVersion: false,
+          },
+          get: () => Promise.resolve(() => ({ value: 'async' })),
+        },
+      }),
+    ).toThrow(RUNTIME_005);
+
+    const errorEvent = events.at(-1);
+    expect(errorEvent).toMatchObject({
+      type: 'error',
+      pkgName: 'diagnostics-async-shared',
+      lifecycle: 'loadShareSync',
+      recovered: undefined,
+      availableVersions: [],
+    });
+    expect(errorEvent?.error).toBeInstanceOf(Error);
+  });
+});
diff --git a/packages/runtime-core/src/core.ts b/packages/runtime-core/src/core.ts
index 80abc579a80..0df0e4e0a66 100644
--- a/packages/runtime-core/src/core.ts
+++ b/packages/runtime-core/src/core.ts
@@ -159,6 +159,18 @@ export class ModuleFederation {
       ],
       Promise<Promise<RemoteEntryExports | undefined> | undefined>
     >(),
+    afterLoadEntry: new AsyncHook<
+      [
+        {
+          origin: ModuleFederation;
+          remoteInfo: RemoteInfo;
+          remoteEntryExports?: RemoteEntryExports | false | void;
+          error?: unknown;
+          recovered?: boolean;
+        },
+      ],
+      void
+    >('afterLoadEntry'),
     getModuleFactory: new AsyncHook<
       [
         {
diff --git a/packages/runtime-core/src/index.ts b/packages/runtime-core/src/index.ts
index 5efa2c6fb47..da6bb27a4e2 100644
--- a/packages/runtime-core/src/index.ts
+++ b/packages/runtime-core/src/index.ts
@@ -15,7 +15,11 @@ export {
   getGlobalSnapshot,
   getInfoWithoutType,
 } from './global';
-export type { UserOptions, ModuleFederationRuntimePlugin } from './type';
+export type {
+  UserOptions,
+  ModuleFederationRuntimePlugin,
+  SecurityOptions,
+} from './type';
 export { assert, error } from './utils/logger';
 export { registerGlobalPlugins } from './global';
 export {
diff --git a/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts b/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
index d5a44bd946d..4a0b04e729b 100644
--- a/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
+++ b/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
@@ -81,6 +81,7 @@ export class SnapshotHandler {
         {
           options: Options;
           moduleInfo: Remote;
+          origin: ModuleFederation;
         },
       ],
       void
@@ -137,6 +138,7 @@ export class SnapshotHandler {
     await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
       options,
       moduleInfo,
+      origin: this.HostInstance,
     });
 
     let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
@@ -291,6 +293,7 @@ export class SnapshotHandler {
     extraOptions: Record<string, any>,
   ): Promise<ModuleInfo> {
     const getManifest = async (): Promise<Manifest> => {
+      const remoteInfo = getRemoteInfo(moduleInfo);
       let manifestJson: Manifest | undefined =
         this.manifestCache.get(manifestUrl);
       if (manifestJson) {
@@ -300,7 +303,7 @@ export class SnapshotHandler {
         let res = await this.loaderHook.lifecycle.fetch.emit(
           manifestUrl,
           {},
-          getRemoteInfo(moduleInfo),
+          remoteInfo,
         );
         if (!res || !(res instanceof Response)) {
           res = await fetch(manifestUrl, {});
@@ -314,6 +317,7 @@ export class SnapshotHandler {
               error: err,
               from: 'runtime',
               lifecycle: 'afterResolve',
+              remote: remoteInfo,
               origin: this.HostInstance,
             },
           )) as Manifest | undefined;
@@ -334,9 +338,29 @@ export class SnapshotHandler {
         }
       }
 
+      const missingRequiredFields = [
+        !manifestJson.metaData && 'metaData',
+        !manifestJson.exposes && 'exposes',
+        !manifestJson.shared && 'shared',
+      ].filter(Boolean);
+      if (missingRequiredFields.length > 0) {
+        await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit(
+          {
+            id: manifestUrl,
+            error: new Error(
+              `"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${missingRequiredFields.join(', ')}.`,
+            ),
+            from: 'runtime',
+            lifecycle: 'afterResolve',
+            remote: remoteInfo,
+            origin: this.HostInstance,
+          },
+        );
+      }
+
       assert(
         manifestJson.metaData && manifestJson.exposes && manifestJson.shared,
-        `"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${[!manifestJson.metaData && 'metaData', !manifestJson.exposes && 'exposes', !manifestJson.shared && 'shared'].filter(Boolean).join(', ')}.`,
+        `"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${missingRequiredFields.join(', ')}.`,
       );
       this.manifestCache.set(manifestUrl, manifestJson);
       return manifestJson;
diff --git a/packages/runtime-core/src/remote/index.ts b/packages/runtime-core/src/remote/index.ts
index f8eca7ea8c3..b981220a16e 100644
--- a/packages/runtime-core/src/remote/index.ts
+++ b/packages/runtime-core/src/remote/index.ts
@@ -91,6 +91,23 @@ export class RemoteHandler {
       ],
       void
     >('onLoad'),
+    afterLoadRemote: new AsyncHook<
+      [
+        {
+          id: string;
+          expose?: string;
+          remote?: RemoteInfo;
+          options?: {
+            loadFactory?: boolean;
+            from?: CallFrom;
+          };
+          error?: unknown;
+          recovered?: boolean;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterLoadRemote'),
     handlePreloadModule: new SyncHook<
       [
         {
@@ -116,6 +133,8 @@ export class RemoteHandler {
             | 'beforeLoadShare'
             | 'afterResolve'
             | 'onLoad';
+          remote?: RemoteInfo;
+          expose?: string;
           origin: ModuleFederation;
         },
       ],
@@ -153,12 +172,13 @@ export class RemoteHandler {
     loadEntry: new AsyncHook<
       [
         {
+          origin: ModuleFederation;
           loaderHook: ModuleFederation['loaderHook'];
           remoteInfo: RemoteInfo;
           remoteEntryExports?: RemoteEntryExports;
         },
       ],
-      Promise<RemoteEntryExports>
+      Promise<RemoteEntryExports | void> | RemoteEntryExports | void
     >(),
   });
 
@@ -199,6 +219,21 @@ export class RemoteHandler {
     options?: { loadFactory?: boolean; from: CallFrom },
   ): Promise<T | null> {
     const { host } = this;
+    const startMatchInfo = matchRemoteWithNameAndExpose(
+      host.options.remotes,
+      id,
+    );
+    let completeRequestId = id;
+    let completeExpose = startMatchInfo?.expose;
+    let completeRemote = startMatchInfo
+      ? getRemoteInfo(startMatchInfo.remote)
+      : undefined;
+    let afterLoadRemoteArgs:
+      | Parameters<
+          RemoteHandler['hooks']['lifecycle']['afterLoadRemote']['emit']
+        >[0]
+      | undefined;
+
     try {
       const { loadFactory = true } = options || {
         loadFactory: true,
@@ -221,6 +256,9 @@ export class RemoteHandler {
         id: idRes,
         remoteSnapshot,
       } = remoteMatchInfo;
+      completeRequestId = idRes;
+      completeExpose = expose;
+      completeRemote = getRemoteInfo(remote);
 
       const moduleOrFactory = (await module.get(
         idRes,
@@ -242,6 +280,14 @@ export class RemoteHandler {
       });
 
       this.setIdToRemoteMap(id, remoteMatchInfo);
+      afterLoadRemoteArgs = {
+        id: completeRequestId,
+        expose: completeExpose,
+        remote: completeRemote,
+        options,
+        origin: host,
+      };
+
       if (typeof moduleWrapper === 'function') {
         return moduleWrapper as T;
       }
@@ -250,19 +296,56 @@ export class RemoteHandler {
     } catch (error) {
       const { from = 'runtime' } = options || { from: 'runtime' };
 
-      const failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
-        id,
-        error,
-        from,
-        lifecycle: 'onLoad',
-        origin: host,
-      });
+      let failOver;
+      try {
+        failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
+          id,
+          error,
+          from,
+          lifecycle: 'onLoad',
+          expose: completeExpose,
+          remote: completeRemote,
+          origin: host,
+        });
+      } catch (hookError) {
+        afterLoadRemoteArgs = {
+          id: completeRequestId,
+          expose: completeExpose,
+          remote: completeRemote,
+          options,
+          error: hookError,
+          origin: host,
+        };
+        throw hookError;
+      }
 
       if (!failOver) {
+        afterLoadRemoteArgs = {
+          id: completeRequestId,
+          expose: completeExpose,
+          remote: completeRemote,
+          options,
+          error,
+          origin: host,
+        };
         throw error;
       }
 
+      afterLoadRemoteArgs = {
+        id: completeRequestId,
+        expose: completeExpose,
+        remote: completeRemote,
+        options,
+        error,
+        origin: host,
+        recovered: true,
+      };
+
       return failOver as T;
+    } finally {
+      if (afterLoadRemoteArgs) {
+        await this.hooks.lifecycle.afterLoadRemote.emit(afterLoadRemoteArgs);
+      }
     }
   }
 
diff --git a/packages/runtime-core/src/shared/index.ts b/packages/runtime-core/src/shared/index.ts
index 50b6b30d12a..07ca4d05942 100644
--- a/packages/runtime-core/src/shared/index.ts
+++ b/packages/runtime-core/src/shared/index.ts
@@ -23,6 +23,7 @@ import {
   AsyncHook,
   AsyncWaterfallHook,
   SyncWaterfallHook,
+  SyncHook,
 } from '../utils/hooks';
 import {
   formatShareConfigs,
@@ -33,7 +34,13 @@ import {
   shouldUseTreeShaking,
   addUseIn,
 } from '../utils/share';
-import { assert, error, addUniqueItem, optionsToMFContext } from '../utils';
+import {
+  assert,
+  error,
+  addUniqueItem,
+  optionsToMFContext,
+  warn,
+} from '../utils';
 import { DEFAULT_SCOPE } from '../constant';
 import { LoadRemoteMatch } from '../remote';
 import { createRemoteEntryInitOptions } from '../module';
@@ -56,6 +63,35 @@ export class SharedHandler {
     }>('beforeLoadShare'),
     // not used yet
     loadShare: new AsyncHook<[ModuleFederation, string, ShareInfos]>(),
+    afterLoadShare: new SyncHook<
+      [
+        {
+          pkgName: string;
+          shareInfo?: Partial<Shared>;
+          selectedShared?: Partial<Shared>;
+          shared: Options['shared'];
+          shareScopeMap: ShareScopeMap;
+          lifecycle: 'loadShare' | 'loadShareSync';
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterLoadShare'),
+    errorLoadShare: new SyncHook<
+      [
+        {
+          pkgName: string;
+          shareInfo?: Partial<Shared>;
+          shared: Options['shared'];
+          shareScopeMap: ShareScopeMap;
+          lifecycle: 'loadShare' | 'loadShareSync';
+          origin: ModuleFederation;
+          error?: unknown;
+          recovered?: boolean;
+        },
+      ],
+      void
+    >('errorLoadShare'),
     resolveShare: new SyncWaterfallHook<{
       shareScopeMap: ShareScopeMap;
       scope: string;
@@ -82,6 +118,61 @@ export class SharedHandler {
     this._setGlobalShareScopeMap(host.options);
   }
 
+  private emitAfterLoadShare({
+    lifecycle,
+    pkgName,
+    shareInfo,
+    selectedShared,
+  }: {
+    lifecycle: 'loadShare' | 'loadShareSync';
+    pkgName: string;
+    shareInfo?: Partial<Shared>;
+    selectedShared?: Partial<Shared>;
+  }): void {
+    try {
+      this.hooks.lifecycle.afterLoadShare.emit({
+        pkgName,
+        shareInfo,
+        selectedShared,
+        shared: this.host.options.shared,
+        shareScopeMap: this.shareScopeMap,
+        lifecycle,
+        origin: this.host,
+      });
+    } catch (error) {
+      warn(error);
+    }
+  }
+
+  private emitErrorLoadShare({
+    lifecycle,
+    pkgName,
+    shareInfo,
+    error,
+    recovered,
+  }: {
+    lifecycle: 'loadShare' | 'loadShareSync';
+    pkgName: string;
+    shareInfo?: Partial<Shared>;
+    error?: unknown;
+    recovered?: boolean;
+  }): void {
+    try {
+      this.hooks.lifecycle.errorLoadShare.emit({
+        pkgName,
+        shareInfo,
+        shared: this.host.options.shared,
+        shareScopeMap: this.shareScopeMap,
+        lifecycle,
+        origin: this.host,
+        error,
+        recovered,
+      });
+    } catch (hookError) {
+      warn(hookError);
+    }
+  }
+
   // register shared in shareScopeMap
   registerShared(globalOptions: Options, userOptions: UserOptions) {
     const { newShareInfos, allShareInfos } = formatShareConfigs(
@@ -138,117 +229,163 @@ export class SharedHandler {
       extraOptions,
       shareInfos: host.options.shared,
     });
+    let shareOptionsRes: Shared | undefined = shareOptions;
 
-    if (shareOptions?.scope) {
-      await Promise.all(
-        shareOptions.scope.map(async (shareScope) => {
-          await Promise.all(
-            this.initializeSharing(shareScope, {
-              strategy: shareOptions.strategy,
-            }),
-          );
-          return;
-        }),
-      );
-    }
-    const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
-      pkgName,
-      shareInfo: shareOptions,
-      shared: host.options.shared,
-      origin: host,
-    });
-
-    const { shareInfo: shareOptionsRes } = loadShareRes;
+    try {
+      if (shareOptions?.scope) {
+        await Promise.all(
+          shareOptions.scope.map(async (shareScope) => {
+            await Promise.all(
+              this.initializeSharing(shareScope, {
+                strategy: shareOptions.strategy,
+              }),
+            );
+            return;
+          }),
+        );
+      }
+      const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
+        pkgName,
+        shareInfo: shareOptions,
+        shared: host.options.shared,
+        origin: host,
+      });
 
-    // Assert that shareInfoRes exists, if not, throw an error
-    assert(
-      shareOptionsRes,
-      `Cannot find shared "${pkgName}" in host "${host.options.name}". Ensure the shared config for "${pkgName}" is declared in the federation plugin options and the host has been initialized before loading shares.`,
-    );
+      shareOptionsRes = loadShareRes.shareInfo;
 
-    const { shared: registeredShared, useTreesShaking } =
-      getRegisteredShare(
-        this.shareScopeMap,
-        pkgName,
+      // Assert that shareInfoRes exists, if not, throw an error
+      assert(
         shareOptionsRes,
-        this.hooks.lifecycle.resolveShare,
-      ) || {};
-
-    if (registeredShared) {
-      const targetShared = directShare(registeredShared, useTreesShaking);
-      if (targetShared.lib) {
-        addUseIn(targetShared, host.options.name);
-        return targetShared.lib as () => T;
-      } else if (targetShared.loading && !targetShared.loaded) {
-        const factory = await targetShared.loading;
-        targetShared.loaded = true;
-        if (!targetShared.lib) {
-          targetShared.lib = factory;
+        `Cannot find shared "${pkgName}" in host "${host.options.name}". Ensure the shared config for "${pkgName}" is declared in the federation plugin options and the host has been initialized before loading shares.`,
+      );
+      const resolvedShareOptions = shareOptionsRes;
+
+      const { shared: registeredShared, useTreesShaking } =
+        getRegisteredShare(
+          this.shareScopeMap,
+          pkgName,
+          shareOptionsRes,
+          this.hooks.lifecycle.resolveShare,
+        ) || {};
+
+      if (registeredShared) {
+        const targetShared = directShare(registeredShared, useTreesShaking);
+        if (targetShared.lib) {
+          addUseIn(targetShared, host.options.name);
+          this.emitAfterLoadShare({
+            lifecycle: 'loadShare',
+            pkgName,
+            shareInfo: resolvedShareOptions,
+            selectedShared: registeredShared,
+          });
+          return targetShared.lib as () => T;
+        } else if (targetShared.loading && !targetShared.loaded) {
+          const factory = await targetShared.loading;
+          targetShared.loaded = true;
+          if (!targetShared.lib) {
+            targetShared.lib = factory;
+          }
+          addUseIn(targetShared, host.options.name);
+          this.emitAfterLoadShare({
+            lifecycle: 'loadShare',
+            pkgName,
+            shareInfo: resolvedShareOptions,
+            selectedShared: registeredShared,
+          });
+          return factory;
+        } else {
+          const asyncLoadProcess = async () => {
+            const factory = await targetShared.get!();
+            addUseIn(targetShared, host.options.name);
+            targetShared.loaded = true;
+            targetShared.lib = factory;
+            return factory as () => T;
+          };
+          const loading = asyncLoadProcess();
+          this.setShared({
+            pkgName,
+            loaded: false,
+            shared: registeredShared,
+            from: host.options.name,
+            lib: null,
+            loading,
+            treeShaking: useTreesShaking
+              ? (targetShared as TreeShakingArgs)
+              : undefined,
+          });
+          const factory = await loading;
+          this.emitAfterLoadShare({
+            lifecycle: 'loadShare',
+            pkgName,
+            shareInfo: resolvedShareOptions,
+            selectedShared: registeredShared,
+          });
+          return factory;
         }
-        addUseIn(targetShared, host.options.name);
-        return factory;
       } else {
+        if (extraOptions?.customShareInfo) {
+          this.emitErrorLoadShare({
+            lifecycle: 'loadShare',
+            pkgName,
+            shareInfo: resolvedShareOptions,
+            recovered: true,
+          });
+          return false;
+        }
+        const _useTreeShaking = shouldUseTreeShaking(
+          resolvedShareOptions.treeShaking,
+        );
+        const targetShared = directShare(resolvedShareOptions, _useTreeShaking);
+
         const asyncLoadProcess = async () => {
           const factory = await targetShared.get!();
-          addUseIn(targetShared, host.options.name);
-          targetShared.loaded = true;
           targetShared.lib = factory;
+          targetShared.loaded = true;
+          addUseIn(targetShared, host.options.name);
+          const { shared: gShared, useTreesShaking: gUseTreeShaking } =
+            getRegisteredShare(
+              this.shareScopeMap,
+              pkgName,
+              resolvedShareOptions,
+              this.hooks.lifecycle.resolveShare,
+            ) || {};
+          if (gShared) {
+            const targetGShared = directShare(gShared, gUseTreeShaking);
+            targetGShared.lib = factory;
+            targetGShared.loaded = true;
+            gShared.from = resolvedShareOptions.from;
+          }
           return factory as () => T;
         };
         const loading = asyncLoadProcess();
         this.setShared({
           pkgName,
           loaded: false,
-          shared: registeredShared,
+          shared: resolvedShareOptions,
           from: host.options.name,
           lib: null,
           loading,
-          treeShaking: useTreesShaking
+          treeShaking: _useTreeShaking
             ? (targetShared as TreeShakingArgs)
             : undefined,
         });
-        return loading;
-      }
-    } else {
-      if (extraOptions?.customShareInfo) {
-        return false;
+        const factory = await loading;
+        this.emitAfterLoadShare({
+          lifecycle: 'loadShare',
+          pkgName,
+          shareInfo: resolvedShareOptions,
+          selectedShared: resolvedShareOptions,
+        });
+        return factory;
       }
-      const _useTreeShaking = shouldUseTreeShaking(shareOptionsRes.treeShaking);
-      const targetShared = directShare(shareOptionsRes, _useTreeShaking);
-
-      const asyncLoadProcess = async () => {
-        const factory = await targetShared.get!();
-        targetShared.lib = factory;
-        targetShared.loaded = true;
-        addUseIn(targetShared, host.options.name);
-        const { shared: gShared, useTreesShaking: gUseTreeShaking } =
-          getRegisteredShare(
-            this.shareScopeMap,
-            pkgName,
-            shareOptionsRes,
-            this.hooks.lifecycle.resolveShare,
-          ) || {};
-        if (gShared) {
-          const targetGShared = directShare(gShared, gUseTreeShaking);
-          targetGShared.lib = factory;
-          targetGShared.loaded = true;
-          gShared.from = shareOptionsRes.from;
-        }
-        return factory as () => T;
-      };
-      const loading = asyncLoadProcess();
-      this.setShared({
+    } catch (shareError) {
+      this.emitErrorLoadShare({
+        lifecycle: 'loadShare',
         pkgName,
-        loaded: false,
-        shared: shareOptionsRes,
-        from: host.options.name,
-        lib: null,
-        loading,
-        treeShaking: _useTreeShaking
-          ? (targetShared as TreeShakingArgs)
-          : undefined,
+        shareInfo: shareOptionsRes,
+        error: shareError,
       });
-      return loading;
+      throw shareError;
     }
   }
 
@@ -326,6 +463,7 @@ export class SharedHandler {
             error,
             from: 'runtime',
             lifecycle: 'beforeLoadShare',
+            remote: module.remoteInfo,
             origin: host,
           })) as RemoteEntryExports;
         if (!remoteEntryExports) {
@@ -381,93 +519,129 @@ export class SharedHandler {
       shareInfos: host.options.shared,
     });
 
-    if (shareOptions?.scope) {
-      shareOptions.scope.forEach((shareScope) => {
-        this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
-      });
-    }
-    const { shared: registeredShared, useTreesShaking } =
-      getRegisteredShare(
-        this.shareScopeMap,
-        pkgName,
-        shareOptions,
-        this.hooks.lifecycle.resolveShare,
-      ) || {};
-
-    if (registeredShared) {
-      if (typeof registeredShared.lib === 'function') {
-        addUseIn(registeredShared, host.options.name);
-        if (!registeredShared.loaded) {
-          registeredShared.loaded = true;
-          if (registeredShared.from === host.options.name) {
-            shareOptions.loaded = true;
-          }
-        }
-        return registeredShared.lib as () => T;
+    try {
+      if (shareOptions?.scope) {
+        shareOptions.scope.forEach((shareScope) => {
+          this.initializeSharing(shareScope, {
+            strategy: shareOptions.strategy,
+          });
+        });
       }
-      if (typeof registeredShared.get === 'function') {
-        const module = registeredShared.get();
-        if (!(module instanceof Promise)) {
+      const { shared: registeredShared } =
+        getRegisteredShare(
+          this.shareScopeMap,
+          pkgName,
+          shareOptions,
+          this.hooks.lifecycle.resolveShare,
+        ) || {};
+
+      if (registeredShared) {
+        if (typeof registeredShared.lib === 'function') {
           addUseIn(registeredShared, host.options.name);
-          this.setShared({
+          if (!registeredShared.loaded) {
+            registeredShared.loaded = true;
+            if (registeredShared.from === host.options.name) {
+              shareOptions.loaded = true;
+            }
+          }
+          this.emitAfterLoadShare({
+            lifecycle: 'loadShareSync',
             pkgName,
-            loaded: true,
-            from: host.options.name,
-            lib: module,
-            shared: registeredShared,
+            shareInfo: shareOptions,
+            selectedShared: registeredShared,
           });
-          return module;
+          return registeredShared.lib as () => T;
+        }
+        if (typeof registeredShared.get === 'function') {
+          const module = registeredShared.get();
+          if (!(module instanceof Promise)) {
+            addUseIn(registeredShared, host.options.name);
+            this.setShared({
+              pkgName,
+              loaded: true,
+              from: host.options.name,
+              lib: module,
+              shared: registeredShared,
+            });
+            this.emitAfterLoadShare({
+              lifecycle: 'loadShareSync',
+              pkgName,
+              shareInfo: shareOptions,
+              selectedShared: registeredShared,
+            });
+            return module;
+          }
         }
       }
-    }
 
-    if (shareOptions.lib) {
-      if (!shareOptions.loaded) {
-        shareOptions.loaded = true;
+      if (shareOptions.lib) {
+        if (!shareOptions.loaded) {
+          shareOptions.loaded = true;
+        }
+        this.emitAfterLoadShare({
+          lifecycle: 'loadShareSync',
+          pkgName,
+          shareInfo: shareOptions,
+          selectedShared: shareOptions,
+        });
+        return shareOptions.lib as () => T;
       }
-      return shareOptions.lib as () => T;
-    }
 
-    if (shareOptions.get) {
-      const module = shareOptions.get();
-
-      if (module instanceof Promise) {
-        const errorCode =
-          extraOptions?.from === 'build' ? RUNTIME_005 : RUNTIME_006;
-        error(
-          errorCode,
-          runtimeDescMap,
-          {
-            hostName: host.options.name,
-            sharedPkgName: pkgName,
-          },
-          undefined,
-          optionsToMFContext(host.options),
-        );
-      }
+      if (shareOptions.get) {
+        const module = shareOptions.get();
 
-      shareOptions.lib = module;
+        if (module instanceof Promise) {
+          const errorCode =
+            extraOptions?.from === 'build' ? RUNTIME_005 : RUNTIME_006;
+          error(
+            errorCode,
+            runtimeDescMap,
+            {
+              hostName: host.options.name,
+              sharedPkgName: pkgName,
+            },
+            undefined,
+            optionsToMFContext(host.options),
+          );
+        }
+
+        shareOptions.lib = module;
 
-      this.setShared({
+        this.setShared({
+          pkgName,
+          loaded: true,
+          from: host.options.name,
+          lib: shareOptions.lib,
+          shared: shareOptions,
+        });
+        this.emitAfterLoadShare({
+          lifecycle: 'loadShareSync',
+          pkgName,
+          shareInfo: shareOptions,
+          selectedShared: shareOptions,
+        });
+        return shareOptions.lib as () => T;
+      }
+
+      error(
+        RUNTIME_006,
+        runtimeDescMap,
+        {
+          hostName: host.options.name,
+          sharedPkgName: pkgName,
+        },
+        undefined,
+        optionsToMFContext(host.options),
+      );
+    } catch (shareError) {
+      this.emitErrorLoadShare({
+        lifecycle: 'loadShareSync',
         pkgName,
-        loaded: true,
-        from: host.options.name,
-        lib: shareOptions.lib,
-        shared: shareOptions,
+        shareInfo: shareOptions,
+        error: shareError,
       });
-      return shareOptions.lib as () => T;
+      throw shareError;
     }
-
-    error(
-      RUNTIME_006,
-      runtimeDescMap,
-      {
-        hostName: host.options.name,
-        sharedPkgName: pkgName,
-      },
-      undefined,
-      optionsToMFContext(host.options),
-    );
   }
 
   initShareScopeMap(
diff --git a/packages/runtime-core/src/type/config.ts b/packages/runtime-core/src/type/config.ts
index 98c6c357bbf..7f4c3a4fe39 100644
--- a/packages/runtime-core/src/type/config.ts
+++ b/packages/runtime-core/src/type/config.ts
@@ -122,6 +122,16 @@ export type ShareInfos = {
   [pkgName: string]: Shared[];
 };
 
+export interface SecurityOptions {
+  diagnostics?: {
+    enabled?: boolean;
+    maxEvents?: number;
+    console?: boolean;
+    browserGlobal?: boolean;
+    fileOutput?: boolean;
+  };
+}
+
 export interface Options {
   id?: string;
   name: string;
@@ -131,6 +141,7 @@ export interface Options {
   plugins: Array<ModuleFederationRuntimePlugin>;
   inBrowser: boolean;
   shareStrategy?: ShareStrategy;
+  security?: SecurityOptions;
 }
 
 export type UserOptions = Omit<
diff --git a/packages/runtime-core/src/utils/hooks/asyncHook.ts b/packages/runtime-core/src/utils/hooks/asyncHook.ts
index d9692b2d914..aad9fb182f6 100644
--- a/packages/runtime-core/src/utils/hooks/asyncHook.ts
+++ b/packages/runtime-core/src/utils/hooks/asyncHook.ts
@@ -13,17 +13,24 @@ export class AsyncHook<
     const ls = Array.from(this.listeners);
     if (ls.length > 0) {
       let i = 0;
-      const call = (prev?: any): any => {
+      const call = (prev?: unknown): unknown => {
         if (prev === false) {
           return false; // Abort process
         } else if (i < ls.length) {
-          return Promise.resolve(ls[i++].apply(null, data)).then(call);
+          return Promise.resolve(ls[i++].apply(null, data)).then((result) => {
+            if (result === undefined) {
+              return call(prev);
+            }
+            return call(result);
+          });
         } else {
           return prev;
         }
       };
       result = call();
     }
-    return Promise.resolve(result);
+    return Promise.resolve(result) as Promise<
+      void | false | ExternalEmitReturnType
+    >;
   }
 }
diff --git a/packages/runtime-core/src/utils/hooks/asyncWaterfallHooks.ts b/packages/runtime-core/src/utils/hooks/asyncWaterfallHooks.ts
index 3660d449444..43098a80c91 100644
--- a/packages/runtime-core/src/utils/hooks/asyncWaterfallHooks.ts
+++ b/packages/runtime-core/src/utils/hooks/asyncWaterfallHooks.ts
@@ -3,9 +3,9 @@ import { isObject } from '../tool';
 import { SyncHook } from './syncHook';
 import { checkReturnData } from './syncWaterfallHook';
 
-type CallbackReturnType<T> = T | Promise<T>;
+type CallbackReturnType<T> = T | void | Promise<T | void>;
 
-export class AsyncWaterfallHook<T extends Record<string, any>> extends SyncHook<
+export class AsyncWaterfallHook<T extends object> extends SyncHook<
   [T],
   CallbackReturnType<T>
 > {
@@ -23,26 +23,27 @@ export class AsyncWaterfallHook<T extends Record<string, any>> extends SyncHook<
 
     if (ls.length > 0) {
       let i = 0;
-      const processError = (e: any) => {
+      const processError = (e: unknown): T => {
         warn(e);
         this.onerror(e);
         return data;
       };
 
-      const call = (prevData: T): any => {
-        if (checkReturnData(data, prevData)) {
+      const call = (prevData?: T | Awaited<T> | void): T | Promise<T> => {
+        if (prevData !== undefined && checkReturnData(data, prevData)) {
           data = prevData as T;
-          if (i < ls.length) {
-            try {
-              return Promise.resolve(ls[i++](data)).then(call, processError);
-            } catch (e) {
-              return processError(e);
-            }
-          }
-        } else {
+        } else if (prevData !== undefined) {
           this.onerror(
             `A plugin returned an incorrect value for the "${this.type}" type.`,
           );
+          return data;
+        }
+        if (i < ls.length) {
+          try {
+            return Promise.resolve(ls[i++](data)).then(call, processError);
+          } catch (e) {
+            return processError(e);
+          }
         }
         return data;
       };
diff --git a/packages/runtime-core/src/utils/hooks/syncHook.ts b/packages/runtime-core/src/utils/hooks/syncHook.ts
index 17f6dadb8c9..dda3ab8f512 100644
--- a/packages/runtime-core/src/utils/hooks/syncHook.ts
+++ b/packages/runtime-core/src/utils/hooks/syncHook.ts
@@ -32,7 +32,10 @@ export class SyncHook<T, K> {
     if (this.listeners.size > 0) {
       // eslint-disable-next-line prefer-spread
       this.listeners.forEach((fn) => {
-        result = fn(...data);
+        const nextResult = fn(...data);
+        if (nextResult !== undefined) {
+          result = nextResult;
+        }
       });
     }
     return result;
diff --git a/packages/runtime-core/src/utils/hooks/syncWaterfallHook.ts b/packages/runtime-core/src/utils/hooks/syncWaterfallHook.ts
index f37be00302b..d5daa8a1105 100644
--- a/packages/runtime-core/src/utils/hooks/syncWaterfallHook.ts
+++ b/packages/runtime-core/src/utils/hooks/syncWaterfallHook.ts
@@ -20,7 +20,7 @@ export function checkReturnData(originalData: any, returnedData: any): boolean {
 
 export class SyncWaterfallHook<T extends Record<string, any>> extends SyncHook<
   [T],
-  T
+  T | void
 > {
   onerror: (errMsg: string | Error | unknown) => void = error;
 
@@ -36,6 +36,9 @@ export class SyncWaterfallHook<T extends Record<string, any>> extends SyncHook<
     for (const fn of this.listeners) {
       try {
         const tempData = fn(data);
+        if (tempData === undefined) {
+          continue;
+        }
         if (checkReturnData(data, tempData)) {
           data = tempData;
         } else {
diff --git a/packages/runtime-core/src/utils/load.ts b/packages/runtime-core/src/utils/load.ts
index 22be1e71bd3..4a642c57e6f 100644
--- a/packages/runtime-core/src/utils/load.ts
+++ b/packages/runtime-core/src/utils/load.ts
@@ -281,6 +281,7 @@ export async function getRemoteEntry(params: {
 
     globalLoading[uniqueKey] = loadEntryHook
       .emit({
+        origin,
         loaderHook,
         remoteInfo,
         remoteEntryExports,
@@ -304,6 +305,14 @@ export async function getRemoteEntry(params: {
             })
           : loadEntryNode({ remoteInfo, loaderHook });
       })
+      .then(async (res) => {
+        await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+          origin,
+          remoteInfo,
+          remoteEntryExports: res,
+        });
+        return res;
+      })
       .catch(async (err) => {
         const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
         // ScriptExecutionError means the script downloaded fine but its IIFE
@@ -333,9 +342,20 @@ export async function getRemoteEntry(params: {
             });
 
           if (RemoteEntryExports) {
+            await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+              origin,
+              remoteInfo,
+              remoteEntryExports: RemoteEntryExports,
+              recovered: true,
+            });
             return RemoteEntryExports;
           }
         }
+        await origin.loaderHook.lifecycle.afterLoadEntry.emit({
+          origin,
+          remoteInfo,
+          error: err,
+        });
         throw err;
       });
   }
diff --git a/packages/runtime/src/index.ts b/packages/runtime/src/index.ts
index 9519a4eca66..f14b4e992d3 100644
--- a/packages/runtime/src/index.ts
+++ b/packages/runtime/src/index.ts
@@ -18,6 +18,7 @@ export {
   registerGlobalPlugins,
   type ModuleFederationRuntimePlugin,
   type Federation,
+  type SecurityOptions,
 } from '@module-federation/runtime-core';
 
 export { ModuleFederation };
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6e13c22a0d9..4b4db01a270 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2437,6 +2437,9 @@ importers:
       '@module-federation/core':
         specifier: workspace:*
         version: link:../../../packages/core
+      '@module-federation/diagnostics-plugin':
+        specifier: workspace:*
+        version: link:../../../packages/diagnostics-plugin
       '@module-federation/dts-plugin':
         specifier: workspace:*
         version: link:../../../packages/dts-plugin
@@ -3209,6 +3212,12 @@ importers:
         specifier: ^0.2.1
         version: 0.2.1(@rsbuild/core@1.7.3)
 
+  packages/diagnostics-plugin:
+    devDependencies:
+      '@module-federation/runtime':
+        specifier: workspace:*
+        version: link:../runtime
+
   packages/dts-plugin:
     dependencies:
       '@module-federation/error-codes':

From 9b21865704eecb958f87d6eb472fd0f864f634b1 Mon Sep 17 00:00:00 2001
From: 2heal1 <TwoHeal@163.com>
Date: Sat, 9 May 2026 16:14:01 +0800
Subject: [PATCH 2/4] feat(observability): add mf loading observability

---
 .changeset/safe-diagnostics-plugin.md         |    7 -
 .changeset/safe-observability-plugin.md       |    8 +
 MF_LOADING_OBSERVABILITY_ROADMAP.md           | 1047 ------
 .../3005-runtime-host/cypress/e2e/app.cy.ts   |  602 +++-
 .../3005-runtime-host/package.json            |    2 +-
 .../3005-runtime-host/src/App.tsx             |   75 +-
 .../3005-runtime-host/src/DiagnosticsDemo.tsx |  330 --
 .../src/ObservabilityDemo.tsx                 | 1065 ++++++
 .../src/ObservabilityShowcase.tsx             |  475 +++
 .../3005-runtime-host/src/bootstrap.tsx       |   12 +-
 .../3005-runtime-host/src/diagnostics.ts      |   10 -
 .../src/observability-showcase.css            |  427 +++
 .../3005-runtime-host/src/observability.ts    |   10 +
 .../3005-runtime-host/tsconfig.app.json       |    8 +-
 .../3005-runtime-host/webpack.config.js       |  250 +-
 .../3006-runtime-remote/tsconfig.app.json     |    8 +-
 .../src/components/AnalyticsPanel.tsx         |   20 +
 .../src/components/ProfileCard.tsx            |   18 +
 .../3007-runtime-remote/tsconfig.app.json     |    8 +-
 .../3007-runtime-remote/webpack.config.js     |    4 +
 apps/runtime-demo/AGENTS.md                   |   80 +
 apps/runtime-demo/README.md                   |  116 +-
 apps/runtime-demo/skills/mf/SKILL.md          |   55 +
 .../skills/mf/reference/bridge-check.md       |   29 +
 .../mf/reference/browser-debug/long-chain.md  |   72 +
 .../mf/reference/browser-debug/setup.md       |  148 +
 .../reference/browser-debug/single-capture.md |   91 +
 .../skills/mf/reference/config-check.md       |   49 +
 .../skills/mf/reference/context.md            |   67 +
 apps/runtime-demo/skills/mf/reference/docs.md |   66 +
 .../skills/mf/reference/integrate.md          |  422 +++
 .../skills/mf/reference/module-info.md        |   50 +
 .../skills/mf/reference/observability.md      |  379 ++
 apps/runtime-demo/skills/mf/reference/perf.md |   64 +
 .../skills/mf/reference/runtime-error.md      |  165 +
 .../skills/mf/reference/shared-deps.md        |   37 +
 .../skills/mf/reference/type-check.md         |   87 +
 .../skills/mf/scripts/bridge-check.js         |   52 +
 .../skills/mf/scripts/browser-capture.mjs     |  897 +++++
 .../skills/mf/scripts/config-exposes-check.js |  178 +
 .../skills/mf/scripts/module-info.js          |  140 +
 .../skills/mf/scripts/performance-check.js    |   61 +
 .../skills/mf/scripts/shared-config-check.js  |  107 +
 .../skills/mf/scripts/type-check.js           |  202 ++
 apps/runtime-demo/typings/cssmodule.d.ts      |    6 +
 apps/runtime-demo/typings/image.d.ts          |   29 +
 apps/website-new/docs/en/ai/index.mdx         |   29 +-
 apps/website-new/docs/en/ai/skill.mdx         |   28 +
 .../docs/en/guide/runtime/runtime-hooks.mdx   |  255 +-
 .../docs/en/guide/runtime/runtime-plugins.mdx |    2 +
 .../docs/en/guide/troubleshooting/runtime.mdx |   59 +
 .../docs/en/plugin/plugins/_meta.json         |    2 +-
 .../plugin/plugins/observability-plugin.mdx   |  263 ++
 apps/website-new/docs/zh/ai/index.mdx         |   25 +-
 apps/website-new/docs/zh/ai/skill.mdx         |   38 +
 .../docs/zh/guide/runtime/runtime-hooks.mdx   |  255 +-
 .../docs/zh/guide/runtime/runtime-plugins.mdx |    2 +
 .../docs/zh/guide/troubleshooting/runtime.mdx |   59 +
 .../docs/zh/plugin/plugins/_meta.json         |    2 +-
 .../plugin/plugins/observability-plugin.mdx   |  392 ++
 apps/website-new/module-federation.config.ts  |    1 +
 packages/diagnostics-plugin/README.md         |  122 -
 .../__tests__/diagnostics.spec.ts             |  774 ----
 packages/diagnostics-plugin/src/index.ts      | 1383 -------
 packages/error-codes/src/MFContext.ts         |    2 +-
 packages/error-codes/src/desc.ts              |    6 +
 packages/error-codes/src/error-codes.ts       |    3 +
 .../.eslintrc.json                            |    0
 .../AI_TROUBLESHOOTING.md                     |  498 +++
 packages/observability-plugin/README.md       |  295 ++
 .../__tests__/observability.spec.ts           | 2451 +++++++++++++
 .../package.json                              |   15 +-
 packages/observability-plugin/src/build.ts    | 1557 ++++++++
 packages/observability-plugin/src/index.ts    | 3207 +++++++++++++++++
 .../src/node.ts                               |  124 +-
 .../tsconfig.json                             |    0
 .../tsdown.config.ts                          |    7 +-
 .../vitest.config.ts                          |    0
 .../__tests__/load-remote-diagnostics.spec.ts |  149 +-
 packages/runtime-core/__tests__/load.spec.ts  |   20 +-
 .../__tests__/resources/load/init-error.js    |   11 +
 packages/runtime-core/src/core.ts             |   81 +-
 packages/runtime-core/src/index.ts            |    6 +-
 packages/runtime-core/src/module/index.ts     |  241 +-
 .../src/plugins/snapshot/SnapshotHandler.ts   |   20 +-
 packages/runtime-core/src/remote/index.ts     |   51 +-
 packages/runtime-core/src/type/config.ts      |   11 -
 packages/runtime/src/index.ts                 |    1 -
 pnpm-lock.yaml                                |  838 ++---
 skills/README.md                              |    1 +
 skills/mf/SKILL.md                            |    9 +-
 skills/mf/reference/context.md                |    2 +-
 skills/mf/reference/observability.md          |  379 ++
 skills/mf/reference/runtime-error.md          |   22 +-
 skills/mf/reference/type-check.md             |    2 +-
 95 files changed, 17226 insertions(+), 4509 deletions(-)
 delete mode 100644 .changeset/safe-diagnostics-plugin.md
 create mode 100644 .changeset/safe-observability-plugin.md
 delete mode 100644 MF_LOADING_OBSERVABILITY_ROADMAP.md
 delete mode 100644 apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/ObservabilityDemo.tsx
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
 delete mode 100644 apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/observability-showcase.css
 create mode 100644 apps/runtime-demo/3005-runtime-host/src/observability.ts
 create mode 100644 apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
 create mode 100644 apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
 create mode 100644 apps/runtime-demo/AGENTS.md
 create mode 100644 apps/runtime-demo/skills/mf/SKILL.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/bridge-check.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/browser-debug/long-chain.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/browser-debug/setup.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/browser-debug/single-capture.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/config-check.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/context.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/docs.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/integrate.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/module-info.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/observability.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/perf.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/runtime-error.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/shared-deps.md
 create mode 100644 apps/runtime-demo/skills/mf/reference/type-check.md
 create mode 100644 apps/runtime-demo/skills/mf/scripts/bridge-check.js
 create mode 100644 apps/runtime-demo/skills/mf/scripts/browser-capture.mjs
 create mode 100644 apps/runtime-demo/skills/mf/scripts/config-exposes-check.js
 create mode 100644 apps/runtime-demo/skills/mf/scripts/module-info.js
 create mode 100644 apps/runtime-demo/skills/mf/scripts/performance-check.js
 create mode 100644 apps/runtime-demo/skills/mf/scripts/shared-config-check.js
 create mode 100644 apps/runtime-demo/skills/mf/scripts/type-check.js
 create mode 100644 apps/runtime-demo/typings/cssmodule.d.ts
 create mode 100644 apps/runtime-demo/typings/image.d.ts
 create mode 100644 apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
 create mode 100644 apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
 delete mode 100644 packages/diagnostics-plugin/README.md
 delete mode 100644 packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
 delete mode 100644 packages/diagnostics-plugin/src/index.ts
 rename packages/{diagnostics-plugin => observability-plugin}/.eslintrc.json (100%)
 create mode 100644 packages/observability-plugin/AI_TROUBLESHOOTING.md
 create mode 100644 packages/observability-plugin/README.md
 create mode 100644 packages/observability-plugin/__tests__/observability.spec.ts
 rename packages/{diagnostics-plugin => observability-plugin}/package.json (77%)
 create mode 100644 packages/observability-plugin/src/build.ts
 create mode 100644 packages/observability-plugin/src/index.ts
 rename packages/{diagnostics-plugin => observability-plugin}/src/node.ts (69%)
 rename packages/{diagnostics-plugin => observability-plugin}/tsconfig.json (100%)
 rename packages/{diagnostics-plugin => observability-plugin}/tsdown.config.ts (77%)
 rename packages/{diagnostics-plugin => observability-plugin}/vitest.config.ts (100%)
 create mode 100644 packages/runtime-core/__tests__/resources/load/init-error.js
 create mode 100644 skills/mf/reference/observability.md

diff --git a/.changeset/safe-diagnostics-plugin.md b/.changeset/safe-diagnostics-plugin.md
deleted file mode 100644
index e04f332d00a..00000000000
--- a/.changeset/safe-diagnostics-plugin.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@module-federation/diagnostics-plugin": minor
-"@module-federation/runtime-core": minor
-"@module-federation/runtime": minor
----
-
-Add an opt-in diagnostics plugin, a Node-specific diagnostics plugin export for file reports, remote and shared lifecycle hooks, console trace hints, safe browser/Node report outputs, shared/eager loading diagnostics, final loading outcome summaries for Module Federation loading reports, no-op return handling for observer hooks, and passive remote diagnostics through runtime load hooks.
diff --git a/.changeset/safe-observability-plugin.md b/.changeset/safe-observability-plugin.md
new file mode 100644
index 00000000000..701b96bb23c
--- /dev/null
+++ b/.changeset/safe-observability-plugin.md
@@ -0,0 +1,8 @@
+---
+"@module-federation/observability-plugin": minor
+"@module-federation/error-codes": minor
+"@module-federation/runtime-core": minor
+"@module-federation/runtime": minor
+---
+
+Add an opt-in observability plugin, a Node-specific export for file reports, a build-specific export for build summaries and build error reports, remote and shared lifecycle hooks, console trace hints, safe browser/Node report outputs, configurable error stack capture with explicit console raw-stack opt-ins, shared/eager loading evidence, final loading outcome summaries for Module Federation loading reports, deterministic fact reports for runtime and build failures, no-op return handling for observer hooks, detailed remote match/init/expose/factory phase events with phase durations, compact phase summaries, cache/retry/fallback markers, length-limited business component metadata, clipped moduleInfo evidence with preserved deployment locator fields for snapshot-dependent failures, normalized runtime error summaries with error codes, owner hints, retryability, and safe context, dedicated runtime error codes for invalid manifests, missing exposes, and remote container init failures, plus an AI troubleshooting guide for reading and fixing observability reports.
diff --git a/MF_LOADING_OBSERVABILITY_ROADMAP.md b/MF_LOADING_OBSERVABILITY_ROADMAP.md
deleted file mode 100644
index 8bb62ea6e22..00000000000
--- a/MF_LOADING_OBSERVABILITY_ROADMAP.md
+++ /dev/null
@@ -1,1047 +0,0 @@
-# MF Loading Observability Roadmap
-
-## 背景
-
-Module Federation 的问题通常不是单点错误。一次加载可能同时经过 host 配置、remote 配置、manifest、remoteEntry、共享依赖、运行时插件和实际模块执行。现在的报错信息能给出错误码和部分上下文，但还不足以让人或 AI coding 快速判断问题属于哪一侧。
-
-这个方案的终极目标不是把报错文案写长，而是让 MF 加载过程本身变得可观测。报错报告应当从加载过程记录中生成，而不是在抛错点临时拼接一段孤立信息。
-
-## 目标
-
-- 让每一次 MF 加载都能留下安全、结构化、可读取的加载记录。
-- 让错误报告可以还原失败前后的关键路径。
-- 让 AI coding 能基于同一份事实数据判断下一步应该查哪里。
-- 让构建侧信息和运行时信息可以被关联起来分析。
-- 在默认情况下不引入新的数据泄露风险或调试后门。
-
-## 非目标
-
-- 不自动上传诊断数据。
-- 不采集业务数据、源码、远端响应内容、请求头、cookie 或 token。
-- 不把 AI 判断作为运行时行为的一部分。
-- 不让可观测逻辑影响 MF 正常加载结果。
-
-## 第一原则：安全
-
-所有可观测能力都必须遵守以下规则：
-
-- 默认不开启详细采集。
-- 默认不做公网回传。
-- 浏览器侧默认只保存在当前实例或当前页面内存中。
-- Node 侧只写本地诊断文件，且写入失败不能影响构建或运行。
-- URL 必须脱敏，默认移除 query 和 hash。
-- 禁止记录请求头、cookie、authorization、token、secret、session、完整请求参数。
-- 禁止记录 remote 返回内容、源码、模块源码、用户输入和业务数据。
-- 对外导出的报告必须是脱敏后的结果。
-- 全局暴露能力必须最小化，不能把内部状态无边界挂到根对象上。
-- 生产环境默认低噪声；详细诊断需要用户显式开启。
-
-## 现状判断
-
-当前已有一些基础：
-
-- 统一错误码和文档链接。
-- 部分运行时报错能携带 host 配置摘要。
-- Node 侧可以写 `.mf/diagnostics/latest.json`。
-- 部分 remoteEntry 加载错误已经区分了脚本加载失败、脚本执行失败、global 未注册。
-
-主要不足：
-
-- 浏览器侧没有稳定的结构化记录入口。
-- 只记录最近一次错误，不保留加载时间线。
-- 很多错误仍然只是字符串，无法自动判断责任方。
-- 构建信息和运行时错误没有形成稳定关联。
-- shared / eager / 版本匹配类问题缺少完整上下文。
-- AI 需要事实数据，但现在多数信息只存在于错误字符串里。
-
-## 总体设计
-
-整体分三层。
-
-### 1. 加载事件层
-
-工程代码负责记录 MF 加载过程中的事实事件。事件只记录白名单字段。
-
-典型事件：
-
-- `loadRemote:start`
-- `loadRemote:resolved`
-- `loadRemote:success`
-- `loadRemote:error`
-- `manifest:fetch:start`
-- `manifest:fetch:success`
-- `manifest:fetch:error`
-- `remoteEntry:load:start`
-- `remoteEntry:load:success`
-- `remoteEntry:load:error`
-- `remoteEntry:init:start`
-- `remoteEntry:init:success`
-- `remoteEntry:init:error`
-- `expose:get:start`
-- `expose:get:success`
-- `expose:get:error`
-- `share:resolve:start`
-- `share:resolve:success`
-- `share:resolve:miss`
-- `share:resolve:error`
-- `loadRemote:complete`
-
-事件字段建议：
-
-- `traceId`
-- `timestamp`
-- `phase`
-- `status`
-- `hostName`
-- `remoteName`
-- `requestId`
-- `expose`
-- `shareName`
-- `shareScope`
-- `expectedVersion`
-- `resolvedVersion`
-- `provider`
-- `sanitizedUrl`
-- `remoteType`
-- `entryGlobalName`
-- `duration`
-- `errorCode`
-- `errorName`
-- `errorMessage`
-- `ownerHint`
-- `startTime`
-- `endTime`
-- `cached`
-- `attempt`
-- `fallbackUsed`
-- `resultSummary`
-
-`ownerHint` 只能是工程规则给出的初步分类，例如：
-
-- `host`
-- `remote`
-- `network`
-- `manifest`
-- `shared`
-- `runtime-plugin`
-- `unknown`
-
-### 2. 诊断报告层
-
-工程代码基于事件生成事实报告。报告不是 AI 生成的，它应当是确定性的、可测试的、可复现的。
-
-报告包含：
-
-- 本次加载的概要
-- 加载时间线
-- 加载结果
-- 总耗时
-- 失败阶段
-- 原始错误
-- 脱敏后的上下文
-- 可能责任方
-- 可执行的检查建议
-- 关联的构建信息摘要
-
-这里的“可能责任方”和“检查建议”应由工程规则生成，只能基于已记录事实，不允许猜测未采集的信息。
-
-报告不只在失败时生成。成功加载也应当生成可选的 summary，用来回答：
-
-- remote 是否加载成功。
-- manifest 是否命中缓存。
-- remoteEntry 是否重复使用已有 global。
-- expose 是否获取成功。
-- shared 最终命中了哪个提供方和版本。
-- 是否走了 fallback 或 retry。
-- 每个阶段耗时多少。
-- 是否存在“成功但异常”的信号，例如耗时过长、版本命中不符合预期、使用了 fallback。
-
-### 3. AI coding 消费层
-
-AI 不负责生成事实报告。AI 负责读取工程报告，并基于报告做解释、归因、修复建议或代码修改。
-
-推荐边界：
-
-- 工程报告回答“发生了什么”。
-- AI 分析回答“这通常意味着什么、下一步怎么修”。
-- AI 输出必须引用报告里的事实，不应凭空补全缺失数据。
-
-## 报告是 AI 生成还是工程生成
-
-基础报告必须由工程手段生成。
-
-原因：
-
-- 工程生成的报告稳定、可测试、可在没有 AI 的环境里使用。
-- 工程报告可以严格执行脱敏和字段白名单。
-- 工程报告不会编造缺失信息。
-- AI coding 需要的是可靠事实输入，而不是另一个不确定输出。
-
-AI 可以在报告之上生成解释版报告，但它应该是第二层消费结果，不应该替代工程报告。
-
-建议分成两类：
-
-- 事实报告：工程生成，默认能力。
-- 分析报告：AI 基于事实报告生成，可选能力。
-
-## 只看记录的信息是否足够
-
-只看原始事件记录不够。
-
-原始记录是必要基础，但它通常太碎。人和 AI 都还需要一个归一化后的摘要，才能快速知道：
-
-- 哪一步失败
-- 失败前已经完成了哪些步骤
-- 哪些信息缺失
-- 应该优先检查 host、remote、网络、manifest 还是 shared
-
-因此需要同时保留两种产物：
-
-- 事件时间线：完整事实，用于深挖。
-- 诊断报告：从时间线聚合出来，用于快速定位。
-
-如果只保留报告，不保留事件，后续无法追溯细节。  
-如果只保留事件，不生成报告，AI 和人都需要重复做整理工作。
-
-## 加载结果可观测方案
-
-可观测不是只收集报错。成功加载也需要记录，因为很多问题不会直接抛错，例如加载慢、使用了 fallback、命中了非预期 shared 版本、remoteEntry 被缓存复用、manifest 内容和 host 预期不一致。
-
-### 成功事件要记录什么
-
-成功事件应当记录：
-
-- 本次 `traceId`。
-- 请求的 `requestId`。
-- 匹配到的 remote 名称。
-- expose 名称。
-- manifest URL 是否存在。
-- manifest 是否 fetch 成功。
-- manifest 是否来自缓存。
-- remoteEntry URL。
-- remoteEntry 类型。
-- remoteEntry 是否新加载。
-- remoteEntry 是否复用已有 global。
-- remoteEntry init 是否完成。
-- expose factory 是否获取成功。
-- expose module 是否执行完成。
-- shared 命中的 provider。
-- shared 命中的版本。
-- 是否使用 fallback。
-- 是否发生 retry。
-- 每个阶段耗时。
-- 总耗时。
-- 业务组件是否主动声明成功加载。
-
-这些信息都必须是结构化字段，不能只写在字符串里。
-
-### 成功报告
-
-成功报告是加载链路的整理版，不是错误报告。它应包含：
-
-- `traceId`
-- `status: "success"`
-- host 摘要
-- remote 摘要
-- expose 摘要
-- shared 命中摘要
-- 阶段耗时
-- 是否缓存命中
-- 是否 retry
-- 是否 fallback
-- 构建信息关联摘要
-
-成功报告默认不一定需要 console 输出。建议由插件配置控制：
-
-- `level: "error"` 只在失败时生成详细报告。
-- `level: "summary"` 记录成功摘要和失败报告。
-- `level: "verbose"` 记录完整成功和失败时间线。
-
-### 成功但需要关注的信号
-
-插件可以基于工程规则标记 warning，但不能改变加载结果：
-
-- remoteEntry 加载耗时超过阈值。
-- manifest 加载耗时超过阈值。
-- 使用了 retry 后才成功。
-- 使用了 fallback。
-- shared 命中 provider 与预期不一致。
-- shared 命中版本低于推荐版本。
-- remote manifest 的 buildVersion 与预期不一致。
-- expose 成功但来自非预期 remote。
-
-这些 warning 应进入报告，供 AI 判断是否需要继续排查。
-
-### AI 如何使用成功记录
-
-AI 看到成功记录后，可以回答：
-
-- 当前 MF 加载链路是否完整成功。
-- 慢在 manifest、remoteEntry、init、shared 还是 expose。
-- shared 实际用了谁。
-- remote 是否来自预期地址和构建版本。
-- 是否存在 fallback / retry / cache 复用。
-
-因此，AI coding 不只在报错时使用诊断文件，也可以在“页面能跑但行为不对”时读取最近一次成功 trace。
-
-### 业务组件成功加载事件
-
-runtime-core 和 diagnostics plugin 可以自动判断技术层成功，但不能判断业务组件是否真正完成业务加载。因此需要给业务暴露一个固定接口，由业务组件在合适时机主动调用。
-
-固定事件名：
-
-- `component:business-loaded`
-
-固定语义：
-
-- 业务组件已经完成自身定义的成功加载。
-- 这个事件由业务代码主动触发。
-- 这个事件不是 React mount，也不是 expose factory 执行成功。
-- 业务可以自定义什么时候调用，但事件名和基础字段必须固定。
-
-建议 API：
-
-```ts
-diagnostics.markComponentLoaded({
-  traceId,
-  requestId: 'remote/Button',
-  componentName: 'Button',
-});
-```
-
-事件字段：
-
-- `traceId`
-- `requestId`
-- `componentName`
-- `phase: "component"`
-- `eventName: "component:business-loaded"`
-- `status: "success"`
-- `timestamp`
-- `source: "business"`
-
-可选扩展字段：
-
-- `reason`
-- `duration`
-- `metadata`
-
-安全限制：
-
-- `metadata` 必须经过用户自定义 sanitize。
-- 不记录 props。
-- 不记录接口响应体。
-- 不记录用户输入。
-- 不记录业务数据明细。
-
-AI 看到这个事件后，才能判断：
-
-- MF 技术加载成功。
-- 组件挂载或渲染链路已完成。
-- 业务组件声明自己已成功加载。
-
-如果没有这个事件，AI 只能说“技术加载成功，但业务组件是否成功加载未声明”。
-
-## 安全数据策略
-
-允许记录：
-
-- host 名称
-- remote 名称
-- expose 请求名
-- shared 包名
-- shared 版本约束
-- 实际命中的 shared 版本
-- remoteEntry 类型
-- entryGlobalName
-- 脱敏后的 URL
-- 错误码
-- 错误名称
-- 脱敏后的错误消息
-- 阶段耗时
-
-禁止记录：
-
-- cookie
-- request headers
-- authorization
-- token
-- secret
-- session
-- 完整 query
-- hash
-- remote 响应体
-- 源码
-- 模块执行结果
-- 用户业务数据
-
-URL 脱敏规则：
-
-- 保留 protocol、host、pathname。
-- 默认删除 query 和 hash。
-- 对常见敏感字段做兜底过滤。
-- 如果 URL 无法解析，按字符串做保守清洗。
-
-## 能力形态和输出入口
-
-可观测能力应以 runtime plugin 形式提供，形态类似 `@module-federation/retry-plugin`。runtime-core 只提供必要 hook、事件上下文和安全策略，不内置完整收集器，也不默认保存诊断数据。
-
-建议新增独立插件：
-
-- `@module-federation/diagnostics-plugin`
-
-使用方式：
-
-```ts
-import { createInstance } from '@module-federation/runtime';
-import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
-
-const diagnostics = DiagnosticsPlugin({
-  level: 'error',
-  maxEvents: 100,
-  onReport(report) {
-    // 用户自行接入日志、监控或 AI coding 工具
-  },
-});
-
-const mf = createInstance({
-  name: 'host',
-  remotes: [],
-  plugins: [diagnostics.plugin],
-});
-
-diagnostics.getLatestReport();
-diagnostics.getEvents();
-```
-
-### 输出从哪里拿
-
-插件应提供多种可选输出入口，默认只在内存中保存：
-
-- 插件 controller：`diagnostics.getEvents()`、`diagnostics.getLatestReport()`、`diagnostics.clear()`。
-- 回调：`onEvent(event)`、`onReport(report)`。
-- Node 本地文件：通过 `@module-federation/diagnostics-plugin/node` 的 `DiagnosticsPlugin` 显式开启后写 `.mf/diagnostics/events.jsonl` 和 `.mf/diagnostics/latest.json`。
-- 浏览器只读全局入口：只有显式开启后才暴露，例如 `globalThis.__FEDERATION__.__DIAGNOSTICS__`。
-- thrown error 附带最小报告 id 或摘要，但不把完整报告塞进错误字符串。
-
-构建插件注入 runtime plugin 的场景不能拿到外部 controller，因此主要依赖 `onReport`、Node 文件或显式全局入口。
-
-### AI 自动感知和读取流程
-
-目标是让 AI coding 尽量不依赖用户手动复制完整报错。插件应在安全前提下给 AI 一个稳定的发现信号，再提供可读取的脱敏报告。
-
-Node / SSR / build 场景：
-
-- MF 加载失败时，console 打印固定格式的诊断提示。
-- 提示中包含 `traceId` 和诊断文件路径。
-- 插件写入 `.mf/diagnostics/latest.json`。
-- 插件追加 `.mf/diagnostics/events.jsonl`。
-- AI 从终端输出识别 `traceId`。
-- AI 读取 `latest.json`。
-- 如果 `latest.json` 不够，再按 `traceId` 去 `events.jsonl` 查完整事件时间线。
-
-推荐 console 格式：
-
-```txt
-[Module Federation] Diagnostic report generated
-traceId: mf-trace-xxx
-latest: .mf/diagnostics/latest.json
-events: .mf/diagnostics/events.jsonl
-```
-
-浏览器 dev 场景：
-
-- MF 加载失败时，console 打印固定格式的诊断提示。
-- AI 可以通过 CDP 或浏览器调试能力监听 console。
-- 如果启用了只读全局入口，AI 可以按 `traceId` 调用 `getReport(traceId)`。
-- 如果没有启用全局入口，console 只提示用户如何导出脱敏报告。
-
-推荐 console 格式：
-
-```txt
-[Module Federation] Diagnostic report generated
-traceId: mf-trace-xxx
-Run: __FEDERATION__.__DIAGNOSTICS__.getReport("mf-trace-xxx")
-```
-
-浏览器 prod 场景：
-
-- 默认不暴露全局报告入口。
-- 默认不写浏览器持久存储。
-- console 只输出最小错误码、`traceId` 和安全提示。
-- 完整报告只能通过用户显式开启的导出接口、`onReport` 上传到用户自己的系统，或用户主动导出。
-- AI 不应绕过页面安全边界读取完整报告。
-
-prod 推荐 console 格式：
-
-```txt
-[Module Federation] Diagnostic report available
-traceId: mf-trace-xxx
-Ask the application owner to export the sanitized diagnostic report.
-```
-
-### 诊断文件分工
-
-`.mf/diagnostics/latest.json` 是最近一次诊断报告。它是给人和 AI 快速读取的整理版结构，应包含：
-
-- `traceId`
-- host 摘要
-- remote 摘要
-- 失败阶段
-- 错误码
-- 初步责任方
-- 脱敏后的关键上下文
-- 建议检查项
-
-`.mf/diagnostics/events.jsonl` 是完整事件流水。一行一个 JSON，用来保存多次加载、多阶段事件和同一 `traceId` 下的完整时间线。
-
-AI 默认读取顺序：
-
-- 先读 `latest.json`。
-- 如果需要更多细节，再用 `traceId` 过滤 `events.jsonl`。
-
-### runtime-core 需要补什么
-
-runtime-core 只补底层能力：
-
-- 增加或复用最小生命周期 hook，例如 `afterLoadRemote`、`afterLoadEntry`、`afterLoadShare`、`errorLoadShare`。
-- 在主流程关键阶段暴露开始、成功、失败这类事实。
-- 给 hook 补齐必要的基础上下文，例如 `requestId`、`remoteInfo`、`shareInfo`。
-- 不在 runtime-core 里计算版本不匹配、missing provider、eager 边界这类诊断原因。
-- 对有返回值语义的 hook 采用“未返回内容即不干预”的规则，让诊断插件可以安全旁听 `onLoad`、`errorLoadRemote` 这类已有 hook。
-- 保证没有 diagnostics plugin 时行为完全不变。
-
-runtime-core 不负责：
-
-- 持久化报告。
-- 对外暴露全局调试对象。
-- 上传诊断数据。
-- 生成 AI 分析结论。
-- 保存完整事件历史。
-- 组装 shared 诊断报告字段。
-
-### 插件负责什么
-
-diagnostics plugin 负责：
-
-- 是否启用收集。
-- 事件过滤级别。
-- URL、错误消息和 stack 脱敏。
-- 事件缓存上限。
-- 报告聚合。
-- 从 `beforeRequest`、`onLoad`、`afterLoadRemote`、`errorLoadRemote` 旁听 remote 加载开始、成功、失败和结束，且不返回内容。
-- 从 `loadEntry`、`afterLoadEntry`、snapshot resolve hook 旁听 manifest、remoteEntry 这些阶段。
-- 从 runtime hook 的基础上下文推导 shared / eager 具体原因。
-- 输出到 callback、controller、Node 专用入口文件或显式全局入口。
-- 用户自定义 sanitize 规则。
-
-诊断插件可以注册 `errorLoadRemote` 这类已有 hook 做旁听，但必须遵守“不返回内容，不参与恢复”的约束。这样既能复用已有 hook，也不会影响 `@module-federation/retry-plugin` 或用户插件返回兜底结果。`loadEntryError`、`fetch` 这类更贴近重试控制的 hook 暂时不由 diagnostics plugin 接管。
-
-`errorLoadShare` 目前只作为 shared 诊断观察 hook，不默认接入 retry-plugin。shared miss、版本不匹配、eager 边界通常不是临时网络错误，默认重试容易掩盖真实配置问题。后续如果要支持 shared retry，应该作为独立可选能力，由用户明确指定可重试条件。
-
-## 安全配置和插件配置
-
-不建议把所有可观测选项都放进 runtime-core 顶层 `observability`。更合理的边界是：
-
-- `security.diagnostics`：安全策略，由 runtime-core 识别，作为所有诊断插件必须遵守的上限。
-- `DiagnosticsPlugin(options)`：通用功能配置，由插件控制收集、内存输出、回调和浏览器显式读取。
-- `@module-federation/diagnostics-plugin/node` 的 `DiagnosticsPlugin(options)`：Node 专用入口，额外提供本地文件输出。
-
-建议的 `security.diagnostics`：
-
-```ts
-createInstance({
-  name: 'host',
-  security: {
-    diagnostics: {
-      enabled: false,
-      console: true,
-      browserGlobal: false,
-      fileOutput: false,
-      redactUrlQuery: true,
-      redactUrlHash: true,
-      maxErrorStackLines: 5,
-      maxEvents: 100,
-      redactKeys: ['token', 'secret', 'authorization', 'cookie', 'session'],
-    },
-  },
-  plugins: [DiagnosticsPlugin()],
-});
-```
-
-建议的插件配置：
-
-```ts
-DiagnosticsPlugin({
-  level: 'error',
-  maxEvents: 100,
-  console: true,
-  browser: {
-    enabled: false,
-    scope: 'host',
-  },
-  onReport(report) {},
-});
-```
-
-建议的 Node 插件配置：
-
-```ts
-import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin/node';
-
-DiagnosticsPlugin({
-  level: 'error',
-  maxEvents: 100,
-  console: true,
-  directory: '.mf/diagnostics',
-  onReport(report) {},
-});
-```
-
-规则：
-
-- `security.diagnostics` 是上限，插件不能绕过。
-- 插件可以选择更严格，但不能比 `security.diagnostics` 更宽。
-- 如果 `security.diagnostics.enabled` 为 `false`，插件可以不收集，或只保留最小错误摘要。
-- 如果 `browserGlobal` 为 `false`，插件不能暴露全局读取入口。
-- 如果 `fileOutput` 为 `false`，插件不能写诊断文件。
-
-这样既能满足用户选择性添加和定制，也能保证安全边界由核心配置统一约束。
-
-## 运行时报错信息收集方案
-
-运行时报错信息收集不是简单保存 `Error.message`。它需要把错误发生时的加载阶段、调用上下文和已知配置一起保存下来。
-
-### 收集入口
-
-第一批应覆盖这些入口：
-
-- `loadRemote`
-- `getRemoteModuleAndOptions`
-- `getRemoteEntry`
-- `loadEntryScript`
-- `loadEntryNode`
-- `Module.getEntry`
-- `Module.init`
-- `Module.get`
-- `SharedHandler.loadShare`
-- `SharedHandler.loadShareSync`
-- `SharedHandler.initializeSharing`
-- `SnapshotHandler.getManifestJson`
-
-这些入口覆盖了 remote 解析、manifest 获取、remoteEntry 加载、remote 初始化、expose 获取和 shared 解析。
-
-### 运行时报错事件字段
-
-运行时报错事件应当至少包含：
-
-- `traceId`
-- `eventId`
-- `timestamp`
-- `phase`
-- `status: "error"`
-- `hostName`
-- `hostId`
-- `requestId`
-- `remoteName`
-- `remoteAlias`
-- `remoteType`
-- `entryGlobalName`
-- `sanitizedUrl`
-- `expose`
-- `shareName`
-- `shareScope`
-- `requiredVersion`
-- `availableVersions`
-- `selectedVersion`
-- `provider`
-- `from`
-- `lifecycle`
-- `errorCode`
-- `errorName`
-- `errorMessage`
-- `errorStack`
-- `ownerHint`
-- `retryable`
-
-`errorStack` 默认只保留当前错误栈的前几行，并且必须经过脱敏。生产环境可以只保留 `errorName` 和 `errorMessage`。
-
-### 错误分类规则
-
-工程侧应提供确定性的分类规则：
-
-- `RUNTIME-001`: remoteEntry 已加载但未注册到预期 global，优先指向 remote 产物或 `entryGlobalName` 配置。
-- `RUNTIME-002`: remoteEntry 接口不完整，优先指向 remote 产物。
-- `RUNTIME-003`: manifest 获取或解析失败，优先指向 manifest 地址、网络、manifest 内容结构。
-- `RUNTIME-004`: host 无法匹配 remote，优先指向 host remotes 配置或请求 id。
-- `RUNTIME-005`: 构建运行时同步消费 shared 失败，优先指向 eager / async boundary / shared 配置。
-- `RUNTIME-006`: 纯运行时同步消费 shared 失败，优先指向调用方式或 shared 未就绪。
-- `RUNTIME-008`: remoteEntry 资源加载失败，继续细分为 timeout、network、script execution、unknown。
-- `RUNTIME-011`: manifest 中缺 remoteEntry URL，优先指向 remote manifest 产物。
-- `RUNTIME-012`: shared getter 不可用，优先指向 `shared.import: false` 和 host 未提供对应依赖。
-
-### 运行时报告生成
-
-当错误发生时，工程代码应做三件事：
-
-- 记录一条脱敏后的 `error` 事件。
-- 把错误事件和同一 `traceId` 的前序事件聚合成事实报告。
-- 保留现有错误码、错误文案和文档链接，避免破坏用户已有排查路径。
-
-报告里不要写“AI 判断”。报告只写工程规则能确认的事实和初步分类。
-
-### 存储策略
-
-浏览器侧：
-
-- 默认不启用。
-- 启用后保存在实例内存中。
-- 只有 `exposeGlobal: true` 时才暴露只读入口。
-- 不写 localStorage、sessionStorage、IndexedDB。
-
-Node 侧：
-
-- 默认不启用详细事件。
-- 启用后可以写 `.mf/diagnostics/events.jsonl` 和 `.mf/diagnostics/latest.json`。
-- 文件写入失败不能影响运行。
-- 文件内容必须脱敏。
-
-## 构建信息收集方案
-
-构建信息的目标不是记录完整构建产物，而是生成一份可以和运行时报错关联的最小摘要。
-
-### 收集来源
-
-第一批应从这些位置收集：
-
-- Module Federation 插件原始配置摘要。
-- manifest 输出。
-- stats 输出。
-- normalized remotes。
-- normalized shared。
-- exposes 映射。
-- remoteEntry 文件名和类型。
-- plugin version。
-- bundler name。
-- build version。
-
-### 构建信息字段
-
-构建摘要建议包含：
-
-- `buildId`
-- `name`
-- `bundler`
-- `pluginVersion`
-- `buildVersion`
-- `remoteEntry`
-- `remoteEntryType`
-- `publicPathMode`
-- `remotes`
-- `exposes`
-- `shared`
-- `manifestFile`
-- `statsFile`
-
-`shared` 只保留诊断必要字段：
-
-- `name`
-- `version`
-- `requiredVersion`
-- `singleton`
-- `strictVersion`
-- `eager`
-- `shareScope`
-- `import`
-
-`remotes` 只保留：
-
-- `name`
-- `alias`
-- `entry`
-- `type`
-- `shareScope`
-
-`exposes` 只保留 expose key 和脱敏后的请求摘要，不记录源码内容。
-
-### 禁止收集的构建信息
-
-- 本地绝对路径。
-- 环境变量。
-- 源码内容。
-- loader 完整参数。
-- 插件完整 options 对象。
-- 远端响应内容。
-- 带 token 的 URL。
-- 私有 registry token。
-
-如果必须保留路径用于定位，只能保留相对项目根的路径，并需要确认不会泄露用户目录或内部机器信息。
-
-### 构建信息产物
-
-建议新增一个脱敏构建摘要产物：
-
-- `.mf/diagnostics/build-info.json`
-
-它应当可以由构建插件生成，也可以从 manifest / stats 中还原。生成失败不能影响构建。
-
-运行时报错报告可以通过以下字段关联构建信息：
-
-- host `name`
-- remote `name`
-- `buildVersion`
-- `pluginVersion`
-- `remoteEntry`
-- manifest `id`
-
-### 构建和运行时关联方式
-
-运行时加载 remote 时，优先从 manifest 获取 remote 构建摘要。如果没有 manifest，只记录 remoteEntry 层面的摘要。
-
-关联规则：
-
-- host 侧报告记录 host 构建摘要。
-- remote manifest 可用时，报告记录 remote 构建摘要。
-- shared 报错时，报告同时列出 host 提供摘要和 remote 需求摘要。
-- expose 报错时，报告关联 remote manifest 中的 exposes 摘要。
-
-这样 AI coding 可以判断：
-
-- host 是否配置了这个 remote。
-- remote manifest 是否声明了这个 expose。
-- host 和 remote 的 shared 版本条件是否能匹配。
-- 运行时加载的 remoteEntry 是否来自预期构建。
-
-## Roadmap
-
-### Milestone 1: 前置任务，诊断验证 Demo 和最小闭环
-
-状态：已完成。当前 demo、最小插件、运行时 hook、输出入口和验证测试已经形成第一阶段闭环。
-
-这一步要先于完整能力建设。它的目标不是做展示页面，而是先建立一个稳定、可重复的验证场景，保证后续每一次加事件、加报告字段、加插件输出，都能在同一套 demo 和测试里验证成功、失败和脱敏结果。
-
-实现边界：runtime-core 只负责主流程生命周期 hook，例如 remote 加载成功、失败、manifest / remoteEntry 基础状态和 shared 成功、失败；diagnostics plugin 负责整理事件、推导具体原因和最终加载结论，并输出报告。
-
-#### Demo 验证场景
-
-- [x] 新增或复用现有 runtime demo，建立一组专用 diagnostics host / remote 场景。
-- [x] demo 支持正常加载 remote 组件，并能触发成功加载事件。
-- [x] demo 支持 remoteEntry / manifest 地址错误场景。
-- [x] demo 支持 remoteEntry globalName 或 expose 不存在场景。
-- [x] demo 支持业务组件主动上报 `component:business-loaded`。
-- [x] demo 支持 shared miss、shared 版本不匹配、eager 配置错误场景。
-- [x] demo 提供稳定的按钮、路由或测试入口，方便 e2e 自动触发。
-- [x] demo 默认不暴露诊断信息，只有显式开启 diagnostics plugin 时才输出。
-- [x] demo 输出必须经过 URL 和错误信息脱敏。
-- [x] demo 作为后续 Phase 的固定验收入口，不为单个实现临时造一次性测试。
-
-#### 最小能力闭环
-
-- [x] 定义最小 `security.diagnostics` 配置和默认关闭行为。
-- [x] 定义最小事件数据结构。
-- [x] 定义最小报告数据结构。
-- [x] 在 runtime-core 增加最小 lifecycle hook 和必要上下文。
-- [x] 新增最小 `DiagnosticsPlugin`，先只支持内存输出和回调输出。
-- [x] 记录 `loadRemote` 成功和失败。
-- [x] 记录 manifest 获取成功和失败。
-- [x] 记录 remoteEntry 加载成功和失败。
-- [x] 生成最近一次 in-memory report。
-- [x] dev / Node 场景输出固定 console 提示，包含 `traceId`。
-- [x] 确认没有 diagnostics plugin 时现有行为完全不变。
-- [x] 确认 diagnostics 自身异常不会影响 MF 加载。
-- [x] 补充默认关闭、显式开启、URL 脱敏、成功 trace、失败 trace / report 的测试。
-
-#### Milestone 1 完成标准
-
-- [x] demo 能稳定跑通一次成功加载。
-- [x] demo 能稳定复现至少一种 remoteEntry / manifest 加载失败。
-- [x] 成功和失败都能生成可读取的脱敏 report。
-- [x] AI 或人能从 console 中拿到 `traceId`，再读取对应 report。
-- [x] 默认不启用 diagnostics 时，demo 和现有测试行为不变。
-- [x] 这一步完成后，再进入后续 Phase 0 - Phase 10 的完整能力建设。
-
-### Phase 0: 安全边界和数据模型
-
-- [ ] 定义 `security.diagnostics` 安全策略和默认值。
-- [ ] 定义 `DiagnosticsPlugin` 插件配置和默认值。
-- [ ] 定义事件字段白名单。
-- [ ] 定义 URL 和错误消息脱敏规则。
-- [ ] 定义事件时间线数据结构。
-- [ ] 定义诊断报告数据结构。
-- [ ] 定义运行时报错事件数据结构。
-- [ ] 定义构建信息摘要数据结构。
-- [ ] 明确浏览器和 Node 的存储边界。
-- [ ] 明确运行时报错和构建信息的字段白名单。
-- [ ] 明确运行时报错和构建信息的禁止字段。
-- [ ] 明确插件配置不能绕过 `security.diagnostics`。
-- [ ] 补充默认不开启、开启后脱敏的测试。
-
-### Phase 1: runtime-core 事件 hook 底座
-
-- [x] 在 runtime-core 中增加最小 lifecycle hook，供插件旁听主流程状态。
-- [x] 复用 `onLoad`、`errorLoadRemote`，供 diagnostics plugin 观察 remote 加载，不影响 retry / fallback。
-- [x] 给关键 hook 补齐 `phase`、`requestId`、`remoteInfo`、`shareInfo` 等必要上下文。
-- [x] 记录 `loadRemote` 开始、成功、失败。
-- [x] 记录 `loadRemote` complete 事件，用于统一收口成功和失败。
-- [ ] 记录 remote 匹配结果。
-- [x] 记录 manifest 获取开始、成功、失败。
-- [x] 记录 remoteEntry 加载开始、成功、失败。
-- [ ] 记录 remoteEntry init 开始、成功、失败。
-- [ ] 记录 expose 获取开始、成功、失败。
-- [ ] 记录阶段耗时和总耗时。
-- [x] 记录 cache、retry、fallback 的基础结果标记。
-- [x] 确认没有 diagnostics plugin 时行为完全不变。
-- [x] 确认 lifecycle hook 失败不会影响 MF 加载。
-- [x] 确认 diagnostics plugin 旁听 `errorLoadRemote` 时不接管返回路径。
-- [x] 补充 runtime-core 单测。
-
-### Phase 2: diagnostics plugin 输出能力
-
-- [x] 新建 `@module-federation/diagnostics-plugin`。
-- [x] 提供插件 controller：`getEvents()`、`getLatestReport()`、`clear()`。
-- [x] 提供 `onEvent` 和 `onReport` 回调。
-- [x] 支持内存输出。
-- [x] 通过 Node 专用入口支持显式开启的 Node 本地文件输出。
-- [x] 支持显式开启的浏览器只读全局入口。
-- [x] 确认插件输出受 `security.diagnostics` 约束。
-- [x] 补充插件配置和输出单测。
-
-### Phase 3: 加载成功信息收集
-
-- [x] 收集加载成功 summary。
-- [ ] 收集 manifest 成功、缓存命中和耗时。
-- [ ] 收集 remoteEntry 成功、新加载或复用已有 global。
-- [ ] 收集 remoteEntry init 成功和耗时。
-- [ ] 收集 expose factory 获取成功和耗时。
-- [ ] 收集 expose module 执行成功和耗时。
-- [ ] 收集 shared 命中的 provider、版本和 shareScope。
-- [ ] 收集 retry / fallback / cache 标记。
-- [x] 定义固定事件 `component:business-loaded`。
-- [x] 提供 `markComponentLoaded` 业务调用接口。
-- [x] 将业务组件成功加载事件关联到同一 `traceId`。
-- [ ] 确认业务 metadata 经过 sanitize 后才能进入报告。
-- [ ] 支持 `level: "summary"` 和 `level: "verbose"` 的成功记录策略。
-- [x] 补充成功链路单测。
-
-### Phase 4: 运行时报错信息收集
-
-- [ ] 接入统一运行时报错事件记录。
-- [ ] 收集错误码、错误名称、脱敏错误消息。
-- [ ] 收集当前加载阶段和生命周期。
-- [ ] 收集 host、remote、requestId、expose、shared 摘要。
-- [ ] 对错误栈做脱敏和长度限制。
-- [ ] 为 `RUNTIME-001` 增加 remoteEntry global 相关上下文。
-- [ ] 为 `RUNTIME-003` 增加 manifest URL、remote 名称、解析阶段上下文。
-- [ ] 为 `RUNTIME-004` 增加 host remotes 摘要和请求 id。
-- [ ] 为 `RUNTIME-008` 增加 timeout、network、script execution 分类。
-- [ ] 确认错误收集失败不会覆盖原始错误。
-- [ ] 补充运行时报错收集单测。
-
-### Phase 5: shared / eager 可观测
-
-- [x] 记录 shared 解析开始。
-- [x] 记录 host 当前提供的 shared 摘要。
-- [x] 记录最终命中的 shared 提供方和版本。
-- [x] 记录 shared miss。
-- [x] 记录 eager 相关同步加载失败。
-- [x] 标记 shared 问题的初步责任方。
-- [x] 确认 `errorLoadShare` 只做诊断观察，不默认接入 retry-plugin。
-- [x] 补充 shared、eager、strictVersion、singleton 场景测试。
-
-### Phase 6: 构建信息收集
-
-- [ ] 从构建插件配置生成脱敏配置摘要。
-- [ ] 从 manifest / stats 生成脱敏构建摘要。
-- [ ] 收集 bundler name、plugin version、build version。
-- [ ] 收集 remoteEntry 文件名、类型和 publicPath 模式。
-- [ ] 收集 remotes 摘要。
-- [ ] 收集 exposes 摘要。
-- [ ] 收集 shared 摘要。
-- [ ] 生成 `.mf/diagnostics/build-info.json`。
-- [ ] 确认构建信息生成失败不影响构建。
-- [ ] 补充构建信息脱敏测试。
-
-### Phase 7: 构建信息和运行时关联
-
-- [ ] 在 manifest / stats 中确认已有字段是否足够。
-- [ ] 补齐必要的 shared、exposes、remotes、插件版本、构建版本摘要。
-- [ ] 运行时报告关联 remote manifest 信息。
-- [ ] 构建侧错误也输出同一类诊断报告。
-- [ ] shared 报错时同时展示 host 提供摘要和 remote 需求摘要。
-- [ ] expose 报错时关联 remote manifest exposes 摘要。
-- [ ] remoteEntry 报错时关联 remoteEntry 类型、globalName 和构建版本。
-- [ ] 避免把本地绝对路径、源码、环境变量写入可导出报告。
-
-### Phase 8: 报告生成
-
-- [x] 从 trace 生成成功 summary。
-- [ ] 从 trace 生成事实报告。
-- [ ] 将现有 RUNTIME 错误接入报告。
-- [ ] 将 `RUNTIME-001` 报告关联 remoteEntry globalName。
-- [ ] 将 `RUNTIME-003` 报告关联 manifest URL 和 remote 名称。
-- [ ] 将 `RUNTIME-004` 报告关联 host remotes 列表摘要。
-- [ ] 将 `RUNTIME-005` / `RUNTIME-006` 报告关联 shared 和 eager 信息。
-- [ ] 将 `RUNTIME-008` 报告区分网络、超时、执行失败。
-- [ ] 保留原始错误码和现有文档链接。
-
-### Phase 9: AI coding 入口
-
-- [ ] 提供稳定的读取入口。
-- [x] Node / SSR / build 场景输出固定格式 console 提示。
-- [x] Node / SSR / build 场景写入 `.mf/diagnostics/latest.json`。
-- [x] Node / SSR / build 场景追加 `.mf/diagnostics/events.jsonl`。
-- [x] 浏览器 dev 场景输出可被 CDP 识别的固定格式 console 提示。
-- [x] 浏览器 dev 场景支持显式开启的只读全局入口。
-- [ ] 浏览器 prod 场景默认只输出最小错误码和 `traceId`。
-- [ ] 浏览器 prod 场景完整报告只允许通过显式导出或用户自有系统获取。
-- [ ] 明确 `latest.json` 和 `events.jsonl` 的格式和读取顺序。
-- [x] 提供最近一次加载报告。
-- [ ] 提供最近 N 次加载报告。
-- [x] 支持按 `traceId` 读取成功或失败报告。
-- [ ] 支持按 remote / expose / shared 查询最近加载记录。
-- [ ] 提供脱敏导出方法。
-- [x] Node 侧通过 Node 专用入口支持本地诊断文件。
-- [x] 浏览器侧支持显式开启的内存读取。
-- [ ] 给 AI 消费格式写示例。
-
-### Phase 10: 文档和场景验证
-
-- [ ] 文档说明如何开启安全可观测。
-- [ ] 文档说明导出的报告不包含哪些敏感信息。
-- [ ] 增加成功加载场景。
-- [ ] 增加成功但 retry 后恢复场景。
-- [ ] 增加成功但 fallback 生效场景。
-- [ ] 增加成功但 shared 命中非预期 provider 场景。
-- [x] 增加业务主动标记 `component:business-loaded` 场景。
-- [ ] 增加 remote URL 错误场景。
-- [ ] 增加 remoteEntry globalName 错误场景。
-- [ ] 增加 manifest 缺字段场景。
-- [ ] 增加 remoteEntry 自身执行错误场景。
-- [ ] 增加 host 未提供 shared 场景。
-- [ ] 增加 shared 版本不满足场景。
-- [ ] 增加 eager 配错场景。
-
-## 第一批建议落地范围
-
-第一批就是 Milestone 1，不直接做完整闭环。
-
-优先顺序是：
-
-- 先做 diagnostics demo，确保后续改动都有固定验证入口。
-- 再做最小安全配置、最小事件、最小报告和最小插件输出。
-- 先覆盖 remote / manifest / remoteEntry 的成功和失败。
-- 先保证默认关闭、显式开启、URL 脱敏、记录失败不影响加载。
-
-第一批完成后，再接 shared / eager、构建信息关联、浏览器生产环境导出等更完整能力。这样可以先把可验证底座稳定下来，避免一开始把诊断逻辑和所有错误点耦合在一起。
-
-## 验收标准
-
-- 默认不开启时，现有行为不变。
-- 有固定 demo 可以验证后续诊断能力。
-- 开启后可以读取脱敏后的加载事件。
-- 成功加载时可以读取加载 summary。
-- 失败报告可以指出失败阶段。
-- 报告不包含 query、hash、header、cookie、token、源码、remote 响应体。
-- trace 逻辑异常不会影响 MF 加载。
-- runtime-core 相关测试通过。
-- 构建通过。
diff --git a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
index 0cd95166738..c77a8b5f8ba 100644
--- a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
+++ b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
@@ -1,7 +1,44 @@
 import { getH1, getH3 } from '../support/app.po';
 
-const getDiagnosticsReader = (win: Cypress.AUTWindow) =>
-  (win as any).__FEDERATION__?.__DIAGNOSTICS__?.runtime_host;
+const getObservabilityReader = (win: Cypress.AUTWindow) =>
+  (win as any).__FEDERATION__?.__OBSERVABILITY__?.runtime_host;
+
+type ObservabilityTestReport = {
+  traceId: string;
+  status?: string;
+  errorCode?: string;
+  requestId?: string;
+  summary: {
+    flags: {
+      cached?: boolean;
+    };
+    phases: {
+      remoteEntry?: {
+        cached?: boolean;
+      };
+    };
+  };
+  shared?: {
+    name?: string;
+    provider?: string;
+    reason?: string;
+    availableVersions?: string[];
+  };
+  events: Array<{
+    eventName?: string;
+    metadata?: Record<string, string>;
+  }>;
+};
+
+const ignoreExpectedObservabilityException = (expectedMessages: string[]) => {
+  cy.on('uncaught:exception', (error) => {
+    if (expectedMessages.some((message) => error.message.includes(message))) {
+      return false;
+    }
+
+    return undefined;
+  });
+};
 
 describe('3005-runtime-host/', () => {
   beforeEach(() => cy.visit('/'));
@@ -81,17 +118,51 @@ describe('3005-runtime-host/', () => {
     });
   });
 
-  describe('diagnostics demo fixture', () => {
-    beforeEach(() => cy.visit('/diagnostics'));
+  describe('observability demo fixture', () => {
+    beforeEach(() => {
+      cy.visit('/observability');
+    });
+
+    it('should emit build observability for the host config', () => {
+      cy.readFile('.mf/observability/build-info.json').then((buildInfo) => {
+        expect(buildInfo.source).to.equal('manifest');
+        expect(buildInfo.moduleFederation.name).to.equal('runtime_host');
+        expect(
+          buildInfo.moduleFederation.remotes.some(
+            (remote: { entry?: string; alias?: string }) =>
+              remote.alias === 'remote1' &&
+              remote.entry === 'http://127.0.0.1:3006/mf-manifest.json',
+          ),
+        ).to.equal(true);
+        expect(buildInfo.moduleFederation.exposes).to.deep.include({
+          name: 'Button',
+        });
+        expect(
+          buildInfo.moduleFederation.shared.some(
+            (shared: { name: string }) => shared.name === 'react',
+          ),
+        ).to.equal(true);
+        const reactShared = buildInfo.moduleFederation.shared.find(
+          (shared: { name: string }) => shared.name === 'react',
+        );
+        expect(reactShared).to.include({
+          name: 'react',
+          requiredVersion: '^18.2.0',
+          singleton: true,
+        });
+        expect(JSON.stringify(buildInfo)).not.to.contain('/Users/bytedance');
+        expect(JSON.stringify(buildInfo)).not.to.contain('token=');
+      });
+    });
 
     it('should expose a successful remote loading scenario', () => {
-      cy.get('[data-testid="diagnostics-load-success"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('success');
-      cy.get('[data-testid="diagnostics-remote-result"]')
+      cy.get('[data-testid="observability-load-success"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('success');
+      cy.get('[data-testid="observability-remote-result"]')
         .find('button.test-remote2')
         .contains('Button from antd@4.24.15');
       cy.window().then((win) => {
-        const reader = getDiagnosticsReader(win);
+        const reader = getObservabilityReader(win);
         expect(reader).to.exist;
 
         const latestReport = reader.getLatestReport();
@@ -100,19 +171,34 @@ describe('3005-runtime-host/', () => {
         expect(latestReport.summary.loadCompleted).to.equal(true);
         expect(latestReport.summary.componentLoaded).to.equal(false);
         expect(latestReport.summary.outcome).to.equal('runtime-loaded');
+        expect(latestReport.summary.phases.loadRemote.status).to.equal(
+          'complete',
+        );
+        expect(latestReport.diagnosis.status).to.equal('success');
+        expect(latestReport.diagnosis.outcome).to.equal('runtime-loaded');
+        expect(latestReport.diagnosis.facts.runtimeLoaded).to.equal(true);
+        expect(latestReport.summary.phases.remoteEntryInit.duration).to.be.a(
+          'number',
+        );
       });
-      cy.get('[data-testid="diagnostics-business-loaded"]').click();
-      cy.get('[data-testid="diagnostics-report"]').contains(
+      cy.get('[data-testid="observability-business-loaded"]').click();
+      cy.get('[data-testid="observability-report"]').contains(
         'component:business-loaded',
       );
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', '"route": "/observability?token=demo-secret#hash"')
+        .should('contain', 'token=demo-secret')
+        .should('contain', '#hash');
       cy.window().then((win) => {
-        const reader = getDiagnosticsReader(win);
+        const reader = getObservabilityReader(win);
         expect(reader).to.exist;
 
         const latestReport = reader.getLatestReport();
         expect(latestReport.status).to.equal('success');
         expect(latestReport.summary.componentLoaded).to.equal(true);
         expect(latestReport.summary.outcome).to.equal('component-loaded');
+        expect(latestReport.diagnosis.outcome).to.equal('component-loaded');
+        expect(latestReport.diagnosis.facts.componentLoaded).to.equal(true);
         expect(reader.getReport(latestReport.traceId).traceId).to.equal(
           latestReport.traceId,
         );
@@ -121,95 +207,507 @@ describe('3005-runtime-host/', () => {
 
     it('should expose a failed remote loading scenario', () => {
       cy.window().then((win) => {
-        cy.spy(win.console, 'warn').as('diagnosticsWarn');
+        cy.spy(win.console, 'error').as('observabilityError');
       });
-      cy.get('[data-testid="diagnostics-load-missing-expose"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
-      cy.get('[data-testid="diagnostics-report"]').contains(
+      cy.get('[data-testid="observability-load-missing-expose"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]').contains(
         'dynamic-remote/__missing_expose__',
       );
-      cy.get('[data-testid="diagnostics-error-message"]').should(
+      cy.get('[data-testid="observability-error-message"]').should(
         'not.contain',
         'token=',
       );
-      cy.get('@diagnosticsWarn').should(
+      cy.get('@observabilityError').should(
         'have.been.calledWithMatch',
-        /Diagnostic report generated[\s\S]*traceId: mf-/,
+        /Observability report generated[\s\S]*traceId: mf-/,
       );
       cy.window().then((win) => {
-        const reader = getDiagnosticsReader(win);
+        const reader = getObservabilityReader(win);
         const latestReport = reader.getLatestReport();
         expect(latestReport.status).to.equal('error');
         expect(latestReport.traceId).to.match(/^mf-/);
         expect(latestReport.summary.loadCompleted).to.equal(true);
         expect(latestReport.summary.outcome).to.equal('failed');
-        expect(reader.getReport(latestReport.traceId).failedPhase).to.exist;
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-expose',
+          ),
+        ).to.equal(true);
+        expect(reader.getReport(latestReport.traceId).failedPhase).to.equal(
+          'expose',
+        );
       });
     });
 
-    it('should expose a sanitized manifest failure scenario', () => {
-      cy.get('[data-testid="diagnostics-load-broken-manifest"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
-      cy.get('[data-testid="diagnostics-report"]').contains(
-        'diagnostics-broken-remote/Button',
+    it('should expose a manifest failure scenario', () => {
+      cy.get('[data-testid="observability-load-broken-manifest"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]').contains(
+        'observability-broken-remote/Button',
       );
-      cy.get('[data-testid="diagnostics-report"]')
-        .should('not.contain', 'demo-secret')
-        .should('not.contain', 'token=')
-        .should('not.contain', '#hash');
-      cy.get('[data-testid="diagnostics-error-message"]')
-        .contains('/diagnostics-missing/mf-manifest.json')
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'demo-secret')
+        .should('contain', 'token=')
+        .should('contain', '#hash')
+        .should('contain', 'RUNTIME-003')
+        .should('contain', '"ownerHint": "host"')
+        .should('contain', '"check-manifest-url"');
+      cy.get('[data-testid="observability-error-message"]')
+        .contains('/observability-missing/mf-manifest.json')
         .should('not.contain', 'demo-secret')
         .should('not.contain', 'token=')
         .should('not.contain', '#hash');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.diagnosis.facts.url).to.equal(
+          'http://127.0.0.1:3005/observability-missing/mf-manifest.json?token=demo-secret#hash',
+        );
+      });
     });
 
-    it('should expose a shared miss diagnostic scenario', () => {
+    it('should expose a remote URL failure scenario', () => {
+      cy.get('[data-testid="observability-load-remote-url-error"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-remote-url/Button')
+        .should(
+          'contain',
+          'http://127.0.0.1:3999/observability-remote-url/mf-manifest.json',
+        )
+        .should('contain', 'RUNTIME-003')
+        .should('contain', '"check-manifest-url"');
       cy.window().then((win) => {
-        cy.spy(win.console, 'warn').as('diagnosticsWarn');
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.failedPhase).to.equal('manifest');
+        expect(latestReport.diagnosis.facts.url).to.equal(
+          'http://127.0.0.1:3999/observability-remote-url/mf-manifest.json',
+        );
       });
-      cy.get('[data-testid="diagnostics-shared-miss"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
-      cy.get('[data-testid="diagnostics-report"]')
-        .should('contain', 'diagnostics-missing-shared')
+    });
+
+    it('should expose a retry recovered remote scenario', () => {
+      cy.get('[data-testid="observability-load-retry-recovered"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('success');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-retry-recovered/Button')
+        .should('contain', 'remoteEntry:load-recovered')
+        .should('contain', '"retried": true')
+        .should('contain', '"recovered": true');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('success');
+        expect(latestReport.summary.outcome).to.equal('recovered');
+        expect(latestReport.summary.flags.retried).to.equal(true);
+        expect(latestReport.summary.flags.fallback).to.equal(false);
+        expect(latestReport.summary.phases.remoteEntry.recovered).to.equal(
+          true,
+        );
+        expect(latestReport.diagnosis.warnings).to.include(
+          'Remote entry loading recovered after retry',
+        );
+      });
+    });
+
+    it('should expose a fallback recovered remote scenario', () => {
+      cy.get('[data-testid="observability-load-fallback-success"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('success');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'dynamic-remote/__observability_fallback__')
+        .should('contain', 'remote:load-recovered')
+        .should('contain', '"fallback": true')
+        .should('contain', '"outcome": "recovered"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('success');
+        expect(latestReport.failedPhase).to.equal('expose');
+        expect(latestReport.summary.outcome).to.equal('recovered');
+        expect(latestReport.summary.flags.fallback).to.equal(true);
+        expect(latestReport.summary.flags.recovered).to.equal(true);
+        expect(latestReport.summary.error.failedPhase).to.equal('expose');
+        expect(latestReport.diagnosis.warnings).to.include(
+          'Remote loading completed through fallback recovery',
+        );
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-expose',
+          ),
+        ).to.equal(true);
+      });
+    });
+
+    it('should expose a manifest missing fields scenario', () => {
+      ignoreExpectedObservabilityException(['RUNTIME-013']);
+      cy.get(
+        '[data-testid="observability-load-missing-fields-manifest"]',
+      ).click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-missing-fields/Button')
+        .should('contain', 'RUNTIME-013')
+        .should('contain', 'Missing required fields')
+        .should('contain', 'metaData')
+        .should('contain', 'exposes')
+        .should('contain', 'shared')
+        .should('contain', '"check-manifest-url"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.failedPhase).to.equal('manifest');
+        expect(latestReport.diagnosis.facts.url).to.equal(
+          'http://127.0.0.1:3005/observability-fixtures/missing-fields/mf-manifest.json',
+        );
+      });
+    });
+
+    it('should expose a remoteEntry globalName mismatch scenario', () => {
+      ignoreExpectedObservabilityException(['RUNTIME-001']);
+      cy.get('[data-testid="observability-load-wrong-global"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-wrong-global/Button')
+        .should('contain', 'RUNTIME-001')
+        .should('contain', 'observability_wrong_global_expected')
+        .should('contain', '"check-remote-global"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.failedPhase).to.equal('remoteEntry');
+        expect(latestReport.errorCode).to.equal('RUNTIME-001');
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-remote-global',
+          ),
+        ).to.equal(true);
+      });
+    });
+
+    it('should expose a remoteEntry execution error scenario', () => {
+      ignoreExpectedObservabilityException([
+        'observability remoteEntry execution failed',
+        'ScriptExecutionError',
+      ]);
+      cy.get(
+        '[data-testid="observability-load-remote-entry-execution-error"]',
+      ).click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-execution-error/Button')
+        .should('contain', 'RUNTIME-008')
+        .should('contain', 'ScriptExecutionError')
+        .should('contain', '"check-remote-entry"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.failedPhase).to.equal('remoteEntry');
+        expect(latestReport.errorCode).to.equal('RUNTIME-008');
+        expect(latestReport.diagnosis.facts.resourceErrorType).to.equal(
+          'script-execution',
+        );
+      });
+    });
+
+    it('should expose a snapshot match observability scenario', () => {
+      ignoreExpectedObservabilityException(['RUNTIME-007']);
+      cy.get('[data-testid="observability-load-snapshot-match-error"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-snapshot-miss/Button')
+        .should('contain', 'RUNTIME-007')
+        .should('contain', 'remote-snapshot')
+        .should('contain', 'observability-unrelated-snapshot')
+        .should('contain', '"check-module-info"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.errorCode).to.equal('RUNTIME-007');
+        expect(latestReport.ownerHint).to.equal('host');
+        expect(latestReport.moduleInfo.reason).to.equal('remote-snapshot');
+        expect(latestReport.moduleInfo.matchedCount).to.equal(0);
+        expect(latestReport.moduleInfo.availableNames).to.include(
+          'remote:observability-unrelated-snapshot',
+        );
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-module-info',
+          ),
+        ).to.equal(true);
+      });
+    });
+
+    it('should expose a shared miss observability scenario', () => {
+      cy.window().then((win) => {
+        cy.spy(win.console, 'error').as('observabilityError');
+      });
+      cy.get('[data-testid="observability-shared-miss"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-missing-shared')
         .should('contain', 'missing-provider');
-      cy.get('@diagnosticsWarn').should(
+      cy.get('@observabilityError').should(
         'have.been.calledWithMatch',
-        /Diagnostic report generated[\s\S]*traceId: mf-/,
+        /Observability report generated[\s\S]*traceId: mf-/,
       );
       cy.window().then((win) => {
-        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        const latestReport = getObservabilityReader(win).getLatestReport();
         expect(latestReport.status).to.equal('error');
         expect(latestReport.shared.reason).to.equal('missing-provider');
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-shared-provider',
+          ),
+        ).to.equal(true);
       });
     });
 
-    it('should expose a shared version mismatch diagnostic scenario', () => {
-      cy.get('[data-testid="diagnostics-shared-version-mismatch"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
-      cy.get('[data-testid="diagnostics-report"]')
+    it('should expose a shared version mismatch observability scenario', () => {
+      cy.get('[data-testid="observability-shared-version-mismatch"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
         .should('contain', '"name": "react"')
         .should('contain', '^99.0.0')
         .should('contain', 'version-mismatch');
       cy.window().then((win) => {
-        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        const latestReport = getObservabilityReader(win).getLatestReport();
         expect(latestReport.status).to.equal('error');
         expect(latestReport.shared.reason).to.equal('version-mismatch');
         expect(latestReport.shared.availableVersions).to.include('18.3.1');
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-shared-version',
+          ),
+        ).to.equal(true);
+      });
+    });
+
+    it('should expose a shared unexpected provider observability scenario', () => {
+      cy.get(
+        '[data-testid="observability-shared-unexpected-provider"]',
+      ).click();
+      cy.get('[data-testid="observability-load-status"]').contains('success');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-provider-choice')
+        .should('contain', '"provider": "runtime_remote2"')
+        .should('contain', '"selectedVersion": "2.0.0"')
+        .should('contain', 'shared:resolved');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('success');
+        expect(latestReport.shared.name).to.equal(
+          'observability-provider-choice',
+        );
+        expect(latestReport.shared.provider).to.equal('runtime_remote2');
+        expect(latestReport.shared.selectedVersion).to.equal('2.0.0');
+        expect(latestReport.summary.shared.provider).to.equal(
+          'runtime_remote2',
+        );
+        expect(latestReport.diagnosis.facts.provider).to.equal(
+          'runtime_remote2',
+        );
+      });
+    });
+
+    it('should expose a multi-consumer loading chain scenario', () => {
+      cy.get('[data-testid="observability-multi-consumer-chain"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('success');
+      cy.get('[data-testid="observability-multi-consumer-results"]')
+        .should('contain', 'checkout-page loaded')
+        .should('contain', 'analytics-page loaded')
+        .should('contain', 'checkout-page-repeat loaded')
+        .should(
+          'contain',
+          'observability-checkout-theme from observability_consumer_checkout@1.4.0',
+        )
+        .should(
+          'contain',
+          'observability-analytics-sdk from observability_consumer_analytics@1.2.0',
+        )
+        .should('contain', 'cached=true');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'multi-consumer-loading-chain')
+        .should('contain', 'dynamic-remote/ProfileCard')
+        .should('contain', 'dynamic-remote/AnalyticsPanel')
+        .should('contain', '"consumer": "checkout-page"')
+        .should('contain', '"consumer": "analytics-page"')
+        .should(
+          'contain',
+          '"sharedProvider": "observability_consumer_checkout"',
+        )
+        .should(
+          'contain',
+          '"sharedProvider": "observability_consumer_analytics"',
+        )
+        .should('contain', '"cached": true');
+      cy.window().then((win) => {
+        const reader = getObservabilityReader(win);
+        const reports = reader.getReports();
+        const profileReports = reader.findReports({
+          remote: 'runtime_remote2',
+          expose: 'ProfileCard',
+        });
+        const analyticsReports = reader.findReports({
+          remote: 'runtime_remote2',
+          expose: 'AnalyticsPanel',
+        });
+        const checkoutSharedReports = reader.findReports({
+          shared: 'observability-checkout-theme',
+        });
+        const analyticsSharedReports = reader.findReports({
+          shared: 'observability-analytics-sdk',
+        });
+        const cachedRemoteReport = (
+          profileReports as ObservabilityTestReport[]
+        ).find((report) => report.summary.flags.cached === true);
+        const checkoutComponentReport = (
+          profileReports as ObservabilityTestReport[]
+        ).find((report) =>
+          report.events.some(
+            (event) =>
+              event.eventName === 'component:business-loaded' &&
+              event.metadata?.consumer === 'checkout-page',
+          ),
+        );
+
+        expect(reports.length).to.be.greaterThan(4);
+        expect(profileReports.length).to.be.greaterThan(1);
+        expect(analyticsReports.length).to.equal(1);
+        expect(
+          (checkoutSharedReports[0] as ObservabilityTestReport).shared
+            ?.provider,
+        ).to.equal('observability_consumer_checkout');
+        expect(
+          (analyticsSharedReports[0] as ObservabilityTestReport).shared
+            ?.provider,
+        ).to.equal('observability_consumer_analytics');
+        expect(cachedRemoteReport?.summary.flags.cached).to.equal(true);
+        expect(
+          checkoutComponentReport?.events.some(
+            (event) =>
+              event.metadata?.sharedTraceId ===
+              (checkoutSharedReports[0] as ObservabilityTestReport).traceId,
+          ),
+        ).to.equal(true);
       });
     });
 
-    it('should expose an eager config diagnostic scenario', () => {
-      cy.get('[data-testid="diagnostics-eager-config-error"]').click();
-      cy.get('[data-testid="diagnostics-load-status"]').contains('error');
-      cy.get('[data-testid="diagnostics-report"]')
-        .should('contain', 'diagnostics-async-shared')
+    it('should expose an eager config observability scenario', () => {
+      cy.get('[data-testid="observability-eager-config-error"]').click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-async-shared')
         .should('contain', 'sync-async-boundary')
-        .should('contain', 'RUNTIME-005');
+        .should('contain', 'RUNTIME-005')
+        .should('contain', '"ownerHint": "shared"');
       cy.window().then((win) => {
-        const latestReport = getDiagnosticsReader(win).getLatestReport();
+        const latestReport = getObservabilityReader(win).getLatestReport();
         expect(latestReport.status).to.equal('error');
         expect(latestReport.shared.reason).to.equal('sync-async-boundary');
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-eager-config',
+          ),
+        ).to.equal(true);
+      });
+    });
+
+    it('should expose a runtime eager config observability scenario', () => {
+      cy.get(
+        '[data-testid="observability-runtime-eager-config-error"]',
+      ).click();
+      cy.get('[data-testid="observability-load-status"]').contains('error');
+      cy.get('[data-testid="observability-report"]')
+        .should('contain', 'observability-runtime-async-shared')
+        .should('contain', 'sync-async-boundary')
+        .should('contain', 'RUNTIME-006')
+        .should('contain', '"ownerHint": "shared"');
+      cy.window().then((win) => {
+        const latestReport = getObservabilityReader(win).getLatestReport();
+        expect(latestReport.status).to.equal('error');
+        expect(latestReport.errorCode).to.equal('RUNTIME-006');
+        expect(latestReport.shared.reason).to.equal('sync-async-boundary');
+        expect(
+          latestReport.diagnosis.actions.some(
+            (action: { id: string }) => action.id === 'check-eager-config',
+          ),
+        ).to.equal(true);
+      });
+    });
+  });
+
+  describe('observability showcase fixture', () => {
+    beforeEach(() => {
+      cy.visit('/observability-showcase');
+    });
+
+    it('should present a product page route flow for AI observability', () => {
+      cy.contains('Suggested prompt').should('not.exist');
+      cy.contains('AI-ready evidence').should('not.exist');
+      cy.contains('Show latest observability report').should('not.exist');
+      cy.get('[data-testid="observability-showcase-status"]').contains(
+        'success',
+      );
+      cy.get('[data-testid="remote2-profile-card"]').should(
+        'contain',
+        'ProfileCard',
+      );
+      cy.get('[data-testid="observability-showcase-load"]').click();
+      cy.location('pathname').should(
+        'equal',
+        '/observability-showcase/analytics',
+      );
+      cy.get('[data-testid="observability-showcase-status"]').contains(
+        'degraded',
+      );
+      cy.get('[data-testid="observability-showcase-fallback"]').should(
+        'contain',
+        'Limited analytics view',
+      );
+      cy.get('[data-testid="observability-showcase-message"]').should(
+        'contain',
+        'Some analytics details are temporarily unavailable',
+      );
+      cy.get('[data-testid="observability-showcase-shared"]').should(
+        'contain',
+        'Detailed analytics are temporarily limited',
+      );
+
+      cy.window().then((win) => {
+        const reports = getObservabilityReader(win).getReports();
+        const customerSdkReport = reports.find(
+          (report: ObservabilityTestReport) =>
+            report.shared?.name === 'observability-customer-sdk',
+        );
+
+        expect(
+          reports.some(
+            (report: ObservabilityTestReport) =>
+              report.requestId === 'dynamic-remote/ProfileCard',
+          ),
+        ).to.equal(true);
+        expect(
+          reports.some(
+            (report: ObservabilityTestReport) =>
+              report.requestId === 'dynamic-remote/AnalyticsPanel',
+          ),
+        ).to.equal(true);
+        expect(
+          reports.some(
+            (report: ObservabilityTestReport) =>
+              report.shared?.name === 'react',
+          ),
+        ).to.equal(true);
+        expect(
+          reports.some(
+            (report: ObservabilityTestReport) =>
+              report.shared?.name === 'observability-customer-sdk',
+          ),
+        ).to.equal(true);
+        expect(customerSdkReport?.status).to.equal('error');
+        expect(customerSdkReport?.shared?.reason).to.equal('version-mismatch');
+        expect(customerSdkReport?.shared?.availableVersions).to.include(
+          '2.1.0',
+        );
       });
     });
   });
diff --git a/apps/runtime-demo/3005-runtime-host/package.json b/apps/runtime-demo/3005-runtime-host/package.json
index 177b17c26d6..16b5a8ba8b9 100644
--- a/apps/runtime-demo/3005-runtime-host/package.json
+++ b/apps/runtime-demo/3005-runtime-host/package.json
@@ -4,7 +4,7 @@
   "version": "0.0.0",
   "devDependencies": {
     "@module-federation/core": "workspace:*",
-    "@module-federation/diagnostics-plugin": "workspace:*",
+    "@module-federation/observability-plugin": "workspace:*",
     "@module-federation/runtime": "workspace:*",
     "@module-federation/typescript": "workspace:*",
     "@module-federation/enhanced": "workspace:*",
diff --git a/apps/runtime-demo/3005-runtime-host/src/App.tsx b/apps/runtime-demo/3005-runtime-host/src/App.tsx
index bbf64f1eba8..5b3bcd1bc0e 100644
--- a/apps/runtime-demo/3005-runtime-host/src/App.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/App.tsx
@@ -1,33 +1,62 @@
 import React from 'react';
-import { Link, Routes, Route, BrowserRouter } from 'react-router-dom';
-import DiagnosticsDemo from './DiagnosticsDemo';
+import {
+  Link,
+  Routes,
+  Route,
+  BrowserRouter,
+  useLocation,
+} from 'react-router-dom';
+import ObservabilityDemo from './ObservabilityDemo';
+import ObservabilityShowcase from './ObservabilityShowcase';
 import Root from './Root';
 import Remote1 from './Remote1';
 import Remote2 from './Remote2';
 
+const AppRoutes = () => {
+  const location = useLocation();
+  const isShowcase = location.pathname.startsWith('/observability-showcase');
+
+  return (
+    <>
+      {!isShowcase ? (
+        <>
+          <h1>Runtime Demo</h1>
+          <ul>
+            <li>
+              <Link to={'/'}>Home</Link>
+            </li>
+            <li>
+              <Link to={'/remote1'}>remote1</Link>
+            </li>
+            <li>
+              <Link to={'/remote2'}>remote2</Link>
+            </li>
+            <li>
+              <Link to={'/observability'}>observability</Link>
+            </li>
+            <li>
+              <Link to={'/observability-showcase'}>observability showcase</Link>
+            </li>
+          </ul>
+        </>
+      ) : null}
+      <Routes>
+        <Route path="/" element={<Root />} />
+        <Route path="/remote1" element={<Remote1 />} />
+        <Route path="/remote2" element={<Remote2 />} />
+        <Route path="/observability" element={<ObservabilityDemo />} />
+        <Route
+          path="/observability-showcase/*"
+          element={<ObservabilityShowcase />}
+        />
+      </Routes>
+    </>
+  );
+};
+
 const App = () => (
   <BrowserRouter>
-    <h1>Runtime Demo</h1>
-    <ul>
-      <li>
-        <Link to={'/'}>Home</Link>
-      </li>
-      <li>
-        <Link to={'/remote1'}>remote1</Link>
-      </li>
-      <li>
-        <Link to={'/remote2'}>remote2</Link>
-      </li>
-      <li>
-        <Link to={'/diagnostics'}>diagnostics</Link>
-      </li>
-    </ul>
-    <Routes>
-      <Route path="/" element={<Root />} />
-      <Route path="/remote1" element={<Remote1 />} />
-      <Route path="/remote2" element={<Remote2 />} />
-      <Route path="/diagnostics" element={<DiagnosticsDemo />} />
-    </Routes>
+    <AppRoutes />
   </BrowserRouter>
 );
 
diff --git a/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx b/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
deleted file mode 100644
index d1d957c2edb..00000000000
--- a/apps/runtime-demo/3005-runtime-host/src/DiagnosticsDemo.tsx
+++ /dev/null
@@ -1,330 +0,0 @@
-import React, { useCallback, useState } from 'react';
-import {
-  loadRemote,
-  loadShare,
-  loadShareSync,
-  registerRemotes,
-} from '@module-federation/runtime';
-import { diagnostics } from './diagnostics';
-
-type LoadStatus = 'idle' | 'loading' | 'success' | 'error';
-
-type RemoteComponent = React.ComponentType<Record<string, never>>;
-
-const successRequest = 'dynamic-remote/ButtonOldAnt';
-const missingExposeRequest = 'dynamic-remote/__missing_expose__';
-const brokenManifestEntry =
-  'http://127.0.0.1:3005/diagnostics-missing/mf-manifest.json?token=demo-secret#hash';
-const brokenManifestRequest = 'diagnostics-broken-remote/Button';
-function sanitizeErrorMessage(error: unknown): string {
-  const message = error instanceof Error ? error.message : String(error);
-
-  return message
-    .replace(/https?:\/\/[^\s'"<>]+/g, (url) => {
-      try {
-        const parsedUrl = new URL(url);
-        return `${parsedUrl.origin}${parsedUrl.pathname}`;
-      } catch {
-        return '[redacted-url]';
-      }
-    })
-    .replace(
-      /\b(token|authorization|cookie|secret|password)=([^&\s]+)/gi,
-      '$1=[redacted]',
-    );
-}
-
-function resolveRemoteComponent(remoteModule: unknown): RemoteComponent | null {
-  if (typeof remoteModule === 'function') {
-    return remoteModule as RemoteComponent;
-  }
-
-  if (remoteModule && typeof remoteModule === 'object') {
-    const candidate = (remoteModule as { default?: unknown }).default;
-
-    if (typeof candidate === 'function') {
-      return candidate as RemoteComponent;
-    }
-  }
-
-  return null;
-}
-
-export default function DiagnosticsDemo() {
-  const [status, setStatus] = useState<LoadStatus>('idle');
-  const [errorMessage, setErrorMessage] = useState('');
-  const [remoteComponent, setRemoteComponent] =
-    useState<RemoteComponent | null>(null);
-  const [reportText, setReportText] = useState('null');
-
-  const refreshReport = useCallback(() => {
-    setReportText(
-      JSON.stringify(diagnostics.getLatestReport() ?? null, null, 2),
-    );
-  }, []);
-
-  const loadSuccessRemote = useCallback(async () => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    try {
-      const remoteModule = await loadRemote(successRequest);
-      const component = resolveRemoteComponent(remoteModule);
-
-      if (!component) {
-        throw new Error(`Remote module ${successRequest} has no component`);
-      }
-
-      setRemoteComponent(() => component);
-      setStatus('success');
-    } catch (error) {
-      const message = sanitizeErrorMessage(error);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const loadMissingExpose = useCallback(async () => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    try {
-      const remoteModule = await loadRemote(missingExposeRequest);
-
-      if (!remoteModule) {
-        throw new Error(`Remote module ${missingExposeRequest} returned empty`);
-      }
-
-      throw new Error(
-        `Remote module ${missingExposeRequest} unexpectedly loaded`,
-      );
-    } catch (error) {
-      const message = sanitizeErrorMessage(error);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const loadBrokenManifest = useCallback(async () => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    registerRemotes(
-      [
-        {
-          name: 'diagnostics_broken_remote',
-          alias: 'diagnostics-broken-remote',
-          entry: brokenManifestEntry,
-        },
-      ],
-      { force: true },
-    );
-
-    try {
-      await loadRemote(brokenManifestRequest);
-      throw new Error(
-        `Remote module ${brokenManifestRequest} unexpectedly loaded`,
-      );
-    } catch (error) {
-      const message = sanitizeErrorMessage(`${brokenManifestEntry} ${error}`);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const loadSharedMiss = useCallback(async () => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    try {
-      const result = await loadShare('diagnostics-missing-shared', {
-        customShareInfo: {
-          version: '1.0.0',
-          scope: ['diagnostics-missing-scope'],
-          shareConfig: {
-            requiredVersion: '^1.0.0',
-            singleton: false,
-          },
-        },
-      });
-
-      if (result === false) {
-        throw new Error(
-          'Shared miss: diagnostics-missing-shared was not provided by host',
-        );
-      }
-
-      throw new Error('Shared miss scenario unexpectedly loaded');
-    } catch (error) {
-      const message = sanitizeErrorMessage(error);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const loadSharedVersionMismatch = useCallback(async () => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    try {
-      const result = await loadShare('react', {
-        customShareInfo: {
-          shareConfig: {
-            requiredVersion: '^99.0.0',
-            singleton: false,
-          },
-        },
-      });
-
-      if (result === false) {
-        throw new Error('Shared version mismatch: react needs ^99.0.0');
-      }
-
-      throw new Error('Shared version mismatch scenario unexpectedly loaded');
-    } catch (error) {
-      const message = sanitizeErrorMessage(error);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const loadEagerConfigError = useCallback(() => {
-    setStatus('loading');
-    setErrorMessage('');
-    setRemoteComponent(null);
-
-    try {
-      loadShareSync('diagnostics-async-shared', {
-        from: 'build',
-        customShareInfo: {
-          version: '1.0.0',
-          scope: ['default'],
-          shareConfig: {
-            requiredVersion: '^1.0.0',
-            singleton: false,
-            eager: false,
-            strictVersion: false,
-          },
-          get: () =>
-            Promise.resolve(() => ({
-              value: 'async shared should not be consumed synchronously',
-            })),
-        },
-      });
-
-      throw new Error('Eager config scenario unexpectedly loaded');
-    } catch (error) {
-      const message = sanitizeErrorMessage(error);
-      setStatus('error');
-      setErrorMessage(message);
-    } finally {
-      refreshReport();
-    }
-  }, [refreshReport]);
-
-  const markBusinessLoaded = useCallback(() => {
-    diagnostics.markComponentLoaded({
-      requestId: successRequest,
-      componentName: 'ButtonOldAnt',
-    });
-    refreshReport();
-  }, [refreshReport]);
-
-  const LoadedRemote = remoteComponent;
-
-  return (
-    <main>
-      <h2>Diagnostics Demo</h2>
-
-      <section>
-        <h3>Load Remote</h3>
-        <button
-          data-testid="diagnostics-load-success"
-          type="button"
-          onClick={loadSuccessRemote}
-        >
-          Load success remote
-        </button>
-        <button
-          data-testid="diagnostics-load-missing-expose"
-          type="button"
-          onClick={loadMissingExpose}
-        >
-          Load missing expose
-        </button>
-        <button
-          data-testid="diagnostics-load-broken-manifest"
-          type="button"
-          onClick={loadBrokenManifest}
-        >
-          Load broken manifest
-        </button>
-        <button
-          data-testid="diagnostics-business-loaded"
-          type="button"
-          onClick={markBusinessLoaded}
-        >
-          Mark business loaded
-        </button>
-      </section>
-
-      <section>
-        <h3>Shared / Eager Scenarios</h3>
-        <button
-          data-testid="diagnostics-shared-miss"
-          type="button"
-          onClick={loadSharedMiss}
-        >
-          Shared miss
-        </button>
-        <button
-          data-testid="diagnostics-shared-version-mismatch"
-          type="button"
-          onClick={loadSharedVersionMismatch}
-        >
-          Shared version mismatch
-        </button>
-        <button
-          data-testid="diagnostics-eager-config-error"
-          type="button"
-          onClick={loadEagerConfigError}
-        >
-          Eager config error
-        </button>
-      </section>
-
-      <section>
-        <h3>Status</h3>
-        <p data-testid="diagnostics-load-status">{status}</p>
-        {errorMessage ? (
-          <pre data-testid="diagnostics-error-message">{errorMessage}</pre>
-        ) : null}
-        {LoadedRemote ? (
-          <div data-testid="diagnostics-remote-result">
-            <LoadedRemote />
-          </div>
-        ) : null}
-      </section>
-
-      <section>
-        <h3>Report Fixture</h3>
-        <pre data-testid="diagnostics-report">{reportText}</pre>
-      </section>
-    </main>
-  );
-}
diff --git a/apps/runtime-demo/3005-runtime-host/src/ObservabilityDemo.tsx b/apps/runtime-demo/3005-runtime-host/src/ObservabilityDemo.tsx
new file mode 100644
index 00000000000..4e4314221b1
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/ObservabilityDemo.tsx
@@ -0,0 +1,1065 @@
+import React, { useCallback, useState } from 'react';
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import {
+  createInstance,
+  getInstance,
+  loadRemote,
+  loadShare,
+  loadShareSync,
+  registerPlugins,
+  registerRemotes,
+} from '@module-federation/runtime';
+import { observability } from './observability';
+
+type LoadStatus = 'idle' | 'loading' | 'success' | 'error';
+
+type RemoteComponent = React.ComponentType<Record<string, never>>;
+
+const successRequest = 'dynamic-remote/ButtonOldAnt';
+const missingExposeRequest = 'dynamic-remote/__missing_expose__';
+const brokenManifestEntry =
+  'http://127.0.0.1:3005/observability-missing/mf-manifest.json?token=demo-secret#hash';
+const brokenManifestRequest = 'observability-broken-remote/Button';
+const remoteUrlErrorEntry =
+  'http://127.0.0.1:3999/observability-remote-url/mf-manifest.json';
+const remoteUrlErrorRequest = 'observability-remote-url/Button';
+const retryRecoveryRemoteName = 'observability_retry_recovered_remote';
+const retryRecoveryManifestEntry =
+  'http://127.0.0.1:3005/observability-fixtures/retry-recovered/mf-manifest.json';
+const retryRecoveryRequest = 'observability-retry-recovered/Button';
+const fallbackRequest = 'dynamic-remote/__observability_fallback__';
+const missingFieldsManifestEntry =
+  'http://127.0.0.1:3005/observability-fixtures/missing-fields/mf-manifest.json';
+const missingFieldsManifestRequest = 'observability-missing-fields/Button';
+const wrongGlobalManifestEntry =
+  'http://127.0.0.1:3005/observability-fixtures/wrong-global/mf-manifest.json';
+const wrongGlobalRequest = 'observability-wrong-global/Button';
+const executionErrorManifestEntry =
+  'http://127.0.0.1:3005/observability-fixtures/execution-error/mf-manifest.json';
+const executionErrorRequest = 'observability-execution-error/Button';
+const multiProducerRemoteName = 'runtime_remote2';
+const multiProducerAlias = 'dynamic-remote';
+const multiProducerManifestEntry = 'http://127.0.0.1:3007/mf-manifest.json';
+const snapshotMissRequest = 'observability-snapshot-miss/Button';
+const unexpectedProviderSharedName = 'observability-provider-choice';
+const unexpectedProviderSharedScope = 'observability-provider-scope';
+
+type RuntimeRemote = Parameters<typeof registerRemotes>[0][number];
+type RuntimeShareScope = Parameters<
+  NonNullable<ReturnType<typeof getInstance>>['initShareScopeMap']
+>[1];
+type SharedProviderValue = {
+  provider: string;
+  version: string;
+};
+
+interface MultiConsumerScenario {
+  consumer: string;
+  request: string;
+  expose: string;
+  componentName: string;
+  sharedName: string;
+  sharedScope: string;
+  requiredVersion: string;
+  hostVersion: string;
+  expectedProvider: string;
+}
+
+interface MultiConsumerResult {
+  consumer: string;
+  request: string;
+  expose: string;
+  sharedName: string;
+  sharedProvider: string;
+  sharedVersion: string;
+  sharedTraceId: string;
+  remoteTraceId: string;
+  remoteEntryCached: boolean;
+  manifestCached: boolean;
+  summaryCached: boolean;
+}
+
+interface RegisteredRemoteFailureScenario {
+  remote: RuntimeRemote;
+  request: string;
+  errorPrefix?: string;
+}
+
+const multiConsumerScenarios: MultiConsumerScenario[] = [
+  {
+    consumer: 'checkout-page',
+    request: `${multiProducerAlias}/ProfileCard`,
+    expose: './ProfileCard',
+    componentName: 'ProfileCard',
+    sharedName: 'observability-checkout-theme',
+    sharedScope: 'observability-checkout-scope',
+    requiredVersion: '^1.0.0',
+    hostVersion: '1.4.0',
+    expectedProvider: 'observability_consumer_checkout',
+  },
+  {
+    consumer: 'analytics-page',
+    request: `${multiProducerAlias}/AnalyticsPanel`,
+    expose: './AnalyticsPanel',
+    componentName: 'AnalyticsPanel',
+    sharedName: 'observability-analytics-sdk',
+    sharedScope: 'observability-analytics-scope',
+    requiredVersion: '^1.0.0',
+    hostVersion: '1.2.0',
+    expectedProvider: 'observability_consumer_analytics',
+  },
+  {
+    consumer: 'checkout-page-repeat',
+    request: `${multiProducerAlias}/ProfileCard`,
+    expose: './ProfileCard',
+    componentName: 'ProfileCard',
+    sharedName: 'observability-checkout-theme',
+    sharedScope: 'observability-checkout-scope',
+    requiredVersion: '^1.0.0',
+    hostVersion: '1.4.0',
+    expectedProvider: 'observability_consumer_checkout',
+  },
+];
+
+function sanitizeErrorMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+
+  return message
+    .replace(/https?:\/\/[^\s'"<>]+/g, (url) => {
+      try {
+        const parsedUrl = new URL(url);
+        return `${parsedUrl.origin}${parsedUrl.pathname}`;
+      } catch {
+        return '[redacted-url]';
+      }
+    })
+    .replace(
+      /\b(token|authorization|cookie|secret|password)=([^&\s]+)/gi,
+      '$1=[redacted]',
+    );
+}
+
+function resolveRemoteComponent(remoteModule: unknown): RemoteComponent | null {
+  if (typeof remoteModule === 'function') {
+    return remoteModule as RemoteComponent;
+  }
+
+  if (remoteModule && typeof remoteModule === 'object') {
+    const candidate = (remoteModule as { default?: unknown }).default;
+
+    if (typeof candidate === 'function') {
+      return candidate as RemoteComponent;
+    }
+  }
+
+  return null;
+}
+
+function createUnexpectedProviderShareScope(): RuntimeShareScope {
+  return {
+    [unexpectedProviderSharedName]: {
+      '1.0.0': {
+        version: '1.0.0',
+        get: () => () => ({
+          provider: 'runtime_host',
+          version: '1.0.0',
+        }),
+        lib: () => ({
+          provider: 'runtime_host',
+          version: '1.0.0',
+        }),
+        shareConfig: {
+          requiredVersion: false,
+          singleton: false,
+          eager: false,
+          strictVersion: false,
+        },
+        scope: [unexpectedProviderSharedScope],
+        useIn: ['runtime_host'],
+        from: 'runtime_host',
+        deps: [],
+        strategy: 'version-first',
+      },
+      '2.0.0': {
+        version: '2.0.0',
+        get: () => () => ({
+          provider: 'runtime_remote2',
+          version: '2.0.0',
+        }),
+        lib: () => ({
+          provider: 'runtime_remote2',
+          version: '2.0.0',
+        }),
+        shareConfig: {
+          requiredVersion: false,
+          singleton: false,
+          eager: false,
+          strictVersion: false,
+        },
+        scope: [unexpectedProviderSharedScope],
+        useIn: ['runtime_remote2'],
+        from: 'runtime_remote2',
+        deps: [],
+        strategy: 'version-first',
+      },
+    },
+  };
+}
+
+function ObservabilityFallbackRemote() {
+  return null;
+}
+
+const observabilityRetryRecoveryPlugin: ModuleFederationRuntimePlugin = {
+  name: 'observability-retry-recovery-plugin',
+  async loadEntryError({
+    getRemoteEntry,
+    origin,
+    remoteInfo,
+    remoteEntryExports,
+    globalLoading,
+    uniqueKey,
+  }) {
+    if (remoteInfo.name !== retryRecoveryRemoteName) {
+      return undefined;
+    }
+
+    delete globalLoading[uniqueKey];
+
+    return getRemoteEntry({
+      origin,
+      remoteInfo,
+      remoteEntryExports,
+      getEntryUrl: (url: string) => {
+        const separator = url.includes('?') ? '&' : '?';
+        return `${url}${separator}retryCount=1`;
+      },
+    });
+  },
+};
+
+const observabilityFallbackPlugin: ModuleFederationRuntimePlugin = {
+  name: 'observability-fallback-plugin',
+  async errorLoadRemote({ id, lifecycle }) {
+    if (id !== fallbackRequest || lifecycle !== 'onLoad') {
+      return undefined;
+    }
+
+    return {
+      default: ObservabilityFallbackRemote,
+    };
+  },
+};
+
+export default function ObservabilityDemo() {
+  const [status, setStatus] = useState<LoadStatus>('idle');
+  const [errorMessage, setErrorMessage] = useState('');
+  const [remoteComponent, setRemoteComponent] =
+    useState<RemoteComponent | null>(null);
+  const [multiConsumerResults, setMultiConsumerResults] = useState<
+    MultiConsumerResult[]
+  >([]);
+  const [reportText, setReportText] = useState('null');
+
+  const refreshReport = useCallback(() => {
+    setReportText(
+      JSON.stringify(observability.getLatestReport() ?? null, null, 2),
+    );
+  }, []);
+
+  const loadSuccessRemote = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const remoteModule = await loadRemote(successRequest);
+      const component = resolveRemoteComponent(remoteModule);
+
+      if (!component) {
+        throw new Error(`Remote module ${successRequest} has no component`);
+      }
+
+      setRemoteComponent(() => component);
+      setStatus('success');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadMissingExpose = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const remoteModule = await loadRemote(missingExposeRequest);
+
+      if (!remoteModule) {
+        throw new Error(`Remote module ${missingExposeRequest} returned empty`);
+      }
+
+      throw new Error(
+        `Remote module ${missingExposeRequest} unexpectedly loaded`,
+      );
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadRegisteredRemoteFailure = useCallback(
+    async (scenario: RegisteredRemoteFailureScenario) => {
+      setStatus('loading');
+      setErrorMessage('');
+      setRemoteComponent(null);
+
+      registerRemotes([scenario.remote], { force: true });
+
+      try {
+        await loadRemote(scenario.request);
+        throw new Error(
+          `Remote module ${scenario.request} unexpectedly loaded`,
+        );
+      } catch (error) {
+        const message = sanitizeErrorMessage(
+          `${scenario.errorPrefix || ''} ${error}`,
+        );
+        setStatus('error');
+        setErrorMessage(message);
+      } finally {
+        refreshReport();
+      }
+    },
+    [refreshReport],
+  );
+
+  const loadBrokenManifest = useCallback(async () => {
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_broken_remote',
+        alias: 'observability-broken-remote',
+        entry: brokenManifestEntry,
+      },
+      request: brokenManifestRequest,
+      errorPrefix: brokenManifestEntry,
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadRemoteUrlError = useCallback(async () => {
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_remote_url_remote',
+        alias: 'observability-remote-url',
+        entry: remoteUrlErrorEntry,
+      },
+      request: remoteUrlErrorRequest,
+      errorPrefix: remoteUrlErrorEntry,
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadRetryRecoveredRemote = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    registerPlugins([observabilityRetryRecoveryPlugin]);
+    registerRemotes(
+      [
+        {
+          name: retryRecoveryRemoteName,
+          alias: 'observability-retry-recovered',
+          entry: retryRecoveryManifestEntry,
+        },
+      ],
+      { force: true },
+    );
+
+    try {
+      const remoteModule = await loadRemote(retryRecoveryRequest);
+      const component = resolveRemoteComponent(remoteModule);
+
+      if (!component) {
+        throw new Error(
+          `Remote module ${retryRecoveryRequest} has no component`,
+        );
+      }
+
+      setRemoteComponent(() => component);
+      setStatus('success');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadFallbackRemote = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    registerPlugins([observabilityFallbackPlugin]);
+
+    try {
+      const remoteModule = await loadRemote(fallbackRequest);
+      const component = resolveRemoteComponent(remoteModule);
+
+      if (!component) {
+        throw new Error(`Remote module ${fallbackRequest} has no component`);
+      }
+
+      setRemoteComponent(() => component);
+      setStatus('success');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadMissingFieldsManifest = useCallback(async () => {
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_missing_fields_remote',
+        alias: 'observability-missing-fields',
+        entry: missingFieldsManifestEntry,
+      },
+      request: missingFieldsManifestRequest,
+      errorPrefix: missingFieldsManifestEntry,
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadWrongGlobalName = useCallback(async () => {
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_wrong_global_remote',
+        alias: 'observability-wrong-global',
+        entry: wrongGlobalManifestEntry,
+      },
+      request: wrongGlobalRequest,
+      errorPrefix: wrongGlobalManifestEntry,
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadRemoteEntryExecutionError = useCallback(async () => {
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_execution_error_remote',
+        alias: 'observability-execution-error',
+        entry: executionErrorManifestEntry,
+      },
+      request: executionErrorRequest,
+      errorPrefix: executionErrorManifestEntry,
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadSnapshotMatchError = useCallback(async () => {
+    const federation = (
+      globalThis as {
+        __FEDERATION__?: {
+          moduleInfo?: Record<string, unknown>;
+        };
+      }
+    ).__FEDERATION__;
+
+    if (federation) {
+      federation.moduleInfo = {
+        ...federation.moduleInfo,
+        'remote:observability-unrelated-snapshot': {
+          publicPath:
+            'http://127.0.0.1:3005/observability-fixtures/unrelated-snapshot/',
+          getPublicPath:
+            'function getPublicPath(){return "http://127.0.0.1:3005/observability-fixtures/unrelated-snapshot/";}',
+          remoteEntry:
+            'http://127.0.0.1:3005/observability-fixtures/unrelated-snapshot/remoteEntry.js',
+          globalName: 'observability_unrelated_snapshot',
+          modules: [{ moduleName: 'Button' }],
+          shared: [{ sharedName: 'react' }],
+        },
+      };
+    }
+
+    await loadRegisteredRemoteFailure({
+      remote: {
+        name: 'observability_snapshot_miss_remote',
+        alias: 'observability-snapshot-miss',
+        version: '1.0.0',
+      },
+      request: snapshotMissRequest,
+      errorPrefix: 'observability-snapshot-miss@1.0.0',
+    });
+  }, [loadRegisteredRemoteFailure]);
+
+  const loadSharedMiss = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const result = await loadShare('observability-missing-shared', {
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['observability-missing-scope'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+          },
+        },
+      });
+
+      if (result === false) {
+        throw new Error(
+          'Shared miss: observability-missing-shared was not provided by host',
+        );
+      }
+
+      throw new Error('Shared miss scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadSharedVersionMismatch = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const result = await loadShare('react', {
+        customShareInfo: {
+          shareConfig: {
+            requiredVersion: '^99.0.0',
+            singleton: false,
+          },
+        },
+      });
+
+      if (result === false) {
+        throw new Error('Shared version mismatch: react needs ^99.0.0');
+      }
+
+      throw new Error('Shared version mismatch scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadSharedUnexpectedProvider = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      const instance = getInstance();
+
+      if (!instance) {
+        throw new Error('Runtime instance is not initialized');
+      }
+
+      instance.initShareScopeMap(
+        unexpectedProviderSharedScope,
+        createUnexpectedProviderShareScope(),
+      );
+
+      const result = await loadShare<SharedProviderValue>(
+        unexpectedProviderSharedName,
+        {
+          customShareInfo: {
+            scope: [unexpectedProviderSharedScope],
+            shareConfig: {
+              requiredVersion: '^2.0.0',
+              singleton: false,
+              eager: false,
+              strictVersion: false,
+            },
+          },
+        },
+      );
+
+      if (result === false) {
+        throw new Error(
+          'Shared provider choice: observability-provider-choice was not resolved',
+        );
+      }
+
+      const sharedValue = result();
+
+      if (!sharedValue) {
+        throw new Error(
+          'Shared provider choice: observability-provider-choice returned empty',
+        );
+      }
+
+      setStatus('success');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const runMultiConsumerScenario = useCallback(
+    async (
+      runtimeInstance: ReturnType<typeof createInstance>,
+      scenario: MultiConsumerScenario,
+    ): Promise<MultiConsumerResult> => {
+      const sharedFactory =
+        await runtimeInstance.loadShare<SharedProviderValue>(
+          scenario.sharedName,
+          {
+            customShareInfo: {
+              scope: [scenario.sharedScope],
+              shareConfig: {
+                requiredVersion: scenario.requiredVersion,
+                singleton: false,
+                eager: false,
+                strictVersion: false,
+              },
+            },
+          },
+        );
+
+      if (sharedFactory === false) {
+        throw new Error(
+          `${scenario.consumer} could not resolve ${scenario.sharedName}`,
+        );
+      }
+
+      const sharedValue = sharedFactory();
+      const sharedReport = observability.getLatestReport();
+      const sharedTraceId = sharedReport?.traceId || '';
+
+      if (!sharedValue) {
+        throw new Error(
+          `${scenario.consumer} resolved an empty ${scenario.sharedName}`,
+        );
+      }
+
+      const remoteModule = await runtimeInstance.loadRemote(scenario.request);
+      const component = resolveRemoteComponent(remoteModule);
+
+      if (!component) {
+        throw new Error(`Remote module ${scenario.request} has no component`);
+      }
+
+      const remoteReportBeforeComponent = observability.getLatestReport();
+      const remoteTraceId = remoteReportBeforeComponent?.traceId || '';
+
+      observability.markComponentLoaded({
+        traceId: remoteTraceId,
+        requestId: scenario.request,
+        componentName: scenario.componentName,
+        metadata: {
+          consumer: scenario.consumer,
+          producer: multiProducerRemoteName,
+          expose: scenario.expose,
+          sharedName: scenario.sharedName,
+          sharedProvider: sharedValue.provider,
+          sharedVersion: sharedValue.version,
+          sharedTraceId,
+        },
+      });
+
+      const remoteReport = observability.getReport(remoteTraceId);
+
+      return {
+        consumer: scenario.consumer,
+        request: scenario.request,
+        expose: scenario.expose,
+        sharedName: scenario.sharedName,
+        sharedProvider: sharedValue.provider,
+        sharedVersion: sharedValue.version,
+        sharedTraceId,
+        remoteTraceId,
+        remoteEntryCached:
+          remoteReport?.summary.phases.remoteEntry?.cached === true,
+        manifestCached: remoteReport?.summary.phases.manifest?.cached === true,
+        summaryCached: remoteReport?.summary.flags.cached === true,
+      };
+    },
+    [],
+  );
+
+  const loadMultiConsumerChain = useCallback(async () => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+    setMultiConsumerResults([]);
+    observability.clear();
+
+    try {
+      const checkoutConsumer = createInstance({
+        name: 'observability_consumer_checkout',
+        version: '1.0.0',
+        plugins: [observability.plugin],
+        remotes: [
+          {
+            name: multiProducerRemoteName,
+            alias: multiProducerAlias,
+            entry: multiProducerManifestEntry,
+          },
+        ],
+        shared: {
+          'observability-checkout-theme': {
+            version: '1.4.0',
+            scope: ['observability-checkout-scope'],
+            lib: () => ({
+              provider: 'observability_consumer_checkout',
+              version: '1.4.0',
+            }),
+            shareConfig: {
+              requiredVersion: '^1.0.0',
+              singleton: false,
+              eager: false,
+              strictVersion: false,
+            },
+          },
+        },
+      });
+      const analyticsConsumer = createInstance({
+        name: 'observability_consumer_analytics',
+        version: '1.0.0',
+        plugins: [observability.plugin],
+        remotes: [
+          {
+            name: multiProducerRemoteName,
+            alias: multiProducerAlias,
+            entry: multiProducerManifestEntry,
+          },
+        ],
+        shared: {
+          'observability-analytics-sdk': {
+            version: '1.2.0',
+            scope: ['observability-analytics-scope'],
+            lib: () => ({
+              provider: 'observability_consumer_analytics',
+              version: '1.2.0',
+            }),
+            shareConfig: {
+              requiredVersion: '^1.0.0',
+              singleton: false,
+              eager: false,
+              strictVersion: false,
+            },
+          },
+        },
+      });
+      const consumerInstances: Record<
+        string,
+        ReturnType<typeof createInstance>
+      > = {
+        'checkout-page': checkoutConsumer,
+        'analytics-page': analyticsConsumer,
+        'checkout-page-repeat': checkoutConsumer,
+      };
+
+      const results: MultiConsumerResult[] = [];
+
+      for (const scenario of multiConsumerScenarios) {
+        const result = await runMultiConsumerScenario(
+          consumerInstances[scenario.consumer],
+          scenario,
+        );
+
+        if (result.sharedProvider !== scenario.expectedProvider) {
+          throw new Error(
+            `${scenario.consumer} expected ${scenario.expectedProvider} but used ${result.sharedProvider}`,
+          );
+        }
+
+        results.push(result);
+      }
+
+      setMultiConsumerResults(results);
+      setStatus('success');
+      setReportText(
+        JSON.stringify(
+          {
+            scenario: 'multi-consumer-loading-chain',
+            results,
+            reports: observability.getReports({ limit: 12 }),
+          },
+          null,
+          2,
+        ),
+      );
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+      refreshReport();
+    }
+  }, [refreshReport, runMultiConsumerScenario]);
+
+  const loadEagerConfigError = useCallback(() => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      loadShareSync('observability-async-shared', {
+        from: 'build',
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['default'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+            eager: false,
+            strictVersion: false,
+          },
+          get: () =>
+            Promise.resolve(() => ({
+              value: 'async shared should not be consumed synchronously',
+            })),
+        },
+      });
+
+      throw new Error('Eager config scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+
+  const loadRuntimeEagerConfigError = useCallback(() => {
+    setStatus('loading');
+    setErrorMessage('');
+    setRemoteComponent(null);
+
+    try {
+      loadShareSync('observability-runtime-async-shared', {
+        from: 'runtime',
+        customShareInfo: {
+          version: '1.0.0',
+          scope: ['default'],
+          shareConfig: {
+            requiredVersion: '^1.0.0',
+            singleton: false,
+            eager: false,
+            strictVersion: false,
+          },
+          get: () =>
+            Promise.resolve(() => ({
+              value:
+                'runtime async shared should not be consumed synchronously',
+            })),
+        },
+      });
+
+      throw new Error('Runtime eager config scenario unexpectedly loaded');
+    } catch (error) {
+      const message = sanitizeErrorMessage(error);
+      setStatus('error');
+      setErrorMessage(message);
+    } finally {
+      refreshReport();
+    }
+  }, [refreshReport]);
+  const markBusinessLoaded = useCallback(() => {
+    observability.markComponentLoaded({
+      requestId: successRequest,
+      componentName: 'ButtonOldAnt',
+      metadata: {
+        route: '/observability?token=demo-secret#hash',
+        rendered: true,
+      },
+    });
+    refreshReport();
+  }, [refreshReport]);
+
+  const LoadedRemote = remoteComponent;
+
+  return (
+    <main>
+      <h2>Observability Demo</h2>
+
+      <section>
+        <h3>Load Remote</h3>
+        <button
+          data-testid="observability-load-success"
+          type="button"
+          onClick={loadSuccessRemote}
+        >
+          Load success remote
+        </button>
+        <button
+          data-testid="observability-load-missing-expose"
+          type="button"
+          onClick={loadMissingExpose}
+        >
+          Load missing expose
+        </button>
+        <button
+          data-testid="observability-load-broken-manifest"
+          type="button"
+          onClick={loadBrokenManifest}
+        >
+          Load broken manifest
+        </button>
+        <button
+          data-testid="observability-load-remote-url-error"
+          type="button"
+          onClick={loadRemoteUrlError}
+        >
+          Load remote URL error
+        </button>
+        <button
+          data-testid="observability-load-retry-recovered"
+          type="button"
+          onClick={loadRetryRecoveredRemote}
+        >
+          Load retry recovered
+        </button>
+        <button
+          data-testid="observability-load-fallback-success"
+          type="button"
+          onClick={loadFallbackRemote}
+        >
+          Load fallback success
+        </button>
+        <button
+          data-testid="observability-load-missing-fields-manifest"
+          type="button"
+          onClick={loadMissingFieldsManifest}
+        >
+          Load manifest missing fields
+        </button>
+        <button
+          data-testid="observability-load-wrong-global"
+          type="button"
+          onClick={loadWrongGlobalName}
+        >
+          Load wrong globalName
+        </button>
+        <button
+          data-testid="observability-load-remote-entry-execution-error"
+          type="button"
+          onClick={loadRemoteEntryExecutionError}
+        >
+          Load remoteEntry execution error
+        </button>
+        <button
+          data-testid="observability-load-snapshot-match-error"
+          type="button"
+          onClick={loadSnapshotMatchError}
+        >
+          Load snapshot match error
+        </button>
+        <button
+          data-testid="observability-business-loaded"
+          type="button"
+          onClick={markBusinessLoaded}
+        >
+          Mark business loaded
+        </button>
+      </section>
+
+      <section>
+        <h3>Shared / Eager Scenarios</h3>
+        <button
+          data-testid="observability-shared-miss"
+          type="button"
+          onClick={loadSharedMiss}
+        >
+          Shared miss
+        </button>
+        <button
+          data-testid="observability-shared-version-mismatch"
+          type="button"
+          onClick={loadSharedVersionMismatch}
+        >
+          Shared version mismatch
+        </button>
+        <button
+          data-testid="observability-shared-unexpected-provider"
+          type="button"
+          onClick={loadSharedUnexpectedProvider}
+        >
+          Shared unexpected provider
+        </button>
+        <button
+          data-testid="observability-eager-config-error"
+          type="button"
+          onClick={loadEagerConfigError}
+        >
+          Eager config error
+        </button>
+        <button
+          data-testid="observability-runtime-eager-config-error"
+          type="button"
+          onClick={loadRuntimeEagerConfigError}
+        >
+          Runtime eager config error
+        </button>
+      </section>
+
+      <section>
+        <h3>Multi Consumer Loading Chain</h3>
+        <button
+          data-testid="observability-multi-consumer-chain"
+          type="button"
+          onClick={loadMultiConsumerChain}
+        >
+          Load multi-consumer chain
+        </button>
+        {multiConsumerResults.length ? (
+          <ul data-testid="observability-multi-consumer-results">
+            {multiConsumerResults.map((result) => (
+              <li key={`${result.consumer}-${result.request}`}>
+                {result.consumer} loaded {result.request} with{' '}
+                {result.sharedName} from {result.sharedProvider}@
+                {result.sharedVersion}; remoteTrace={result.remoteTraceId};
+                sharedTrace={result.sharedTraceId}; cached=
+                {String(result.summaryCached)}
+              </li>
+            ))}
+          </ul>
+        ) : null}
+      </section>
+
+      <section>
+        <h3>Status</h3>
+        <p data-testid="observability-load-status">{status}</p>
+        {errorMessage ? (
+          <pre data-testid="observability-error-message">{errorMessage}</pre>
+        ) : null}
+        {LoadedRemote ? (
+          <div data-testid="observability-remote-result">
+            <LoadedRemote />
+          </div>
+        ) : null}
+      </section>
+
+      <section>
+        <h3>Report Fixture</h3>
+        <pre data-testid="observability-report">{reportText}</pre>
+      </section>
+    </main>
+  );
+}
diff --git a/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx b/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
new file mode 100644
index 00000000000..034c4cb686b
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
@@ -0,0 +1,475 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { createInstance } from '@module-federation/runtime';
+import { useLocation, useNavigate } from 'react-router-dom';
+import { observability } from './observability';
+import './observability-showcase.css';
+
+type ShowcaseStatus = 'loading' | 'success' | 'degraded' | 'error';
+type ShowcaseRoute = 'profile' | 'analytics';
+type RemoteComponent = React.ComponentType<Record<string, unknown>>;
+type CustomerSdk = {
+  provider: string;
+  version: string;
+  feature: string;
+};
+type LoadResult = {
+  Component: RemoteComponent;
+  traceId: string;
+  shared: string[];
+  status?: ShowcaseStatus;
+  message?: string;
+};
+
+const producerName = 'runtime_remote2';
+const producerAlias = 'dynamic-remote';
+const producerManifest = 'http://127.0.0.1:3007/mf-manifest.json';
+const profileRequest = `${producerAlias}/ProfileCard`;
+const analyticsRequest = `${producerAlias}/AnalyticsPanel`;
+const analyticsConsumerName = 'observability_showcase_analytics_consumer';
+
+function getRoute(pathname: string): ShowcaseRoute {
+  return pathname.endsWith('/analytics') ? 'analytics' : 'profile';
+}
+
+function resolveRemoteComponent(remoteModule: unknown): RemoteComponent {
+  if (typeof remoteModule === 'function') {
+    return remoteModule as RemoteComponent;
+  }
+
+  if (remoteModule && typeof remoteModule === 'object') {
+    const candidate = (remoteModule as { default?: unknown }).default;
+
+    if (typeof candidate === 'function') {
+      return candidate as RemoteComponent;
+    }
+  }
+
+  throw new Error('Remote module did not return a React component');
+}
+
+function createSharedReact() {
+  return {
+    version: '18.3.1',
+    scope: ['default'],
+    lib: () => React,
+    shareConfig: {
+      requiredVersion: '^18.0.0',
+      singleton: true,
+      eager: false,
+      strictVersion: false,
+    },
+  };
+}
+
+function createConsumer(
+  name: string,
+  shared?: Parameters<typeof createInstance>[0]['shared'],
+) {
+  return createInstance({
+    name,
+    version: '1.0.0',
+    plugins: [observability.plugin],
+    remotes: [
+      {
+        name: producerName,
+        alias: producerAlias,
+        entry: producerManifest,
+      },
+    ],
+    shared: {
+      react: createSharedReact(),
+      ...(shared || {}),
+    },
+  });
+}
+
+async function loadProfileWidget() {
+  const consumer = createConsumer('observability_showcase_profile_consumer');
+  const remoteModule = await consumer.loadRemote(profileRequest);
+  const Component = resolveRemoteComponent(remoteModule);
+  const report = observability.getLatestReport();
+
+  if (report?.traceId) {
+    observability.markComponentLoaded({
+      traceId: report.traceId,
+      requestId: profileRequest,
+      componentName: 'ProfileCard',
+      metadata: {
+        route: 'profile',
+        consumer: 'observability_showcase_profile_consumer',
+        producer: producerName,
+        expose: './ProfileCard',
+      },
+    });
+  }
+
+  return {
+    Component,
+    traceId: report?.traceId || '',
+    shared: [] as string[],
+  } satisfies LoadResult;
+}
+
+async function loadAnalyticsWorkspace() {
+  const consumer = createConsumer(analyticsConsumerName, {
+    'observability-customer-sdk': {
+      version: '2.1.0',
+      scope: ['default'],
+      lib: () => ({
+        provider: analyticsConsumerName,
+        version: '2.1.0',
+        feature: 'customer-insights',
+      }),
+      shareConfig: {
+        requiredVersion: '^2.0.0',
+        singleton: false,
+        eager: false,
+        strictVersion: false,
+      },
+    },
+  });
+  const remoteModule = await consumer.loadRemote(analyticsRequest);
+  resolveRemoteComponent(remoteModule);
+
+  const reactFactory = await consumer.loadShare<typeof React>('react', {
+    customShareInfo: {
+      version: '18.3.1',
+      scope: ['default'],
+      shareConfig: {
+        requiredVersion: '^18.0.0',
+        singleton: true,
+        eager: false,
+        strictVersion: false,
+      },
+    },
+  });
+  const sdkFactory = await consumer.loadShare<CustomerSdk>(
+    'observability-customer-sdk',
+    {
+      customShareInfo: {
+        version: '2.1.0',
+        scope: ['default'],
+        shareConfig: {
+          requiredVersion: '^3.0.0',
+          singleton: false,
+          eager: false,
+          strictVersion: false,
+        },
+      },
+    },
+  );
+
+  if (reactFactory === false) {
+    throw new Error('React shared dependency was not resolved');
+  }
+
+  if (sdkFactory === false) {
+    throw new Error('Customer SDK shared dependency was not resolved');
+  }
+
+  const sdk = sdkFactory();
+  const Component = resolveRemoteComponent(remoteModule);
+  const report = observability.getLatestReport();
+
+  if (report?.traceId) {
+    observability.markComponentLoaded({
+      traceId: report.traceId,
+      requestId: analyticsRequest,
+      componentName: 'AnalyticsPanel',
+      metadata: {
+        route: 'analytics',
+        consumer: analyticsConsumerName,
+        producer: producerName,
+        expose: './AnalyticsPanel',
+        shared: ['react', 'observability-customer-sdk'],
+        customerSdkProvider: sdk.provider,
+        customerSdkVersion: sdk.version,
+      },
+    });
+  }
+
+  return {
+    Component,
+    traceId: report?.traceId || '',
+    shared: [
+      `react from ${analyticsConsumerName}@18.3.1`,
+      `observability-customer-sdk from ${sdk.provider}@${sdk.version}`,
+    ],
+  } satisfies LoadResult;
+}
+
+function AnalyticsFallback() {
+  return (
+    <section
+      className="customer-portal__remote-widget"
+      data-testid="observability-showcase-fallback"
+    >
+      <h3>Limited analytics view</h3>
+      <p>
+        Key account metrics are still available while detailed insights are
+        temporarily limited.
+      </p>
+      <div className="customer-portal__remote-meta">
+        <span>summary available</span>
+        <span>details limited</span>
+        <span>support reference ready</span>
+      </div>
+    </section>
+  );
+}
+
+function getLatestTraceId(): string {
+  return observability.getLatestReport()?.traceId ?? 'pending';
+}
+
+export default function ObservabilityShowcase() {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const route = useMemo(() => getRoute(location.pathname), [location.pathname]);
+  const [status, setStatus] = useState<ShowcaseStatus>('loading');
+  const [referenceId, setReferenceId] = useState('');
+  const [errorMessage, setErrorMessage] = useState('');
+  const [remoteComponent, setRemoteComponent] =
+    useState<RemoteComponent | null>(null);
+  const [sharedEvidence, setSharedEvidence] = useState<string[]>([]);
+
+  useEffect(() => {
+    let disposed = false;
+
+    setStatus('loading');
+    setReferenceId('');
+    setErrorMessage('');
+    setRemoteComponent(null);
+    setSharedEvidence([]);
+
+    const load =
+      route === 'analytics' ? loadAnalyticsWorkspace : loadProfileWidget;
+
+    load()
+      .then((result) => {
+        if (disposed) {
+          return;
+        }
+
+        setRemoteComponent(() => result.Component);
+        setSharedEvidence(result.shared);
+        setReferenceId(result.traceId || getLatestTraceId());
+        setErrorMessage(result.message || '');
+        setStatus(result.status || 'success');
+      })
+      .catch((error) => {
+        if (disposed) {
+          return;
+        }
+
+        const message = error instanceof Error ? error.message : String(error);
+
+        if (route === 'analytics') {
+          setRemoteComponent(() => AnalyticsFallback);
+          setSharedEvidence([
+            'Core account page is available',
+            'Detailed analytics are temporarily limited',
+          ]);
+          setErrorMessage(
+            'Some analytics details are temporarily unavailable.',
+          );
+          setReferenceId(getLatestTraceId());
+          setStatus('degraded');
+          return;
+        }
+
+        setErrorMessage(message);
+        setReferenceId(getLatestTraceId());
+        setStatus('error');
+      });
+
+    return () => {
+      disposed = true;
+    };
+  }, [route]);
+
+  const openAnalyticsWorkspace = useCallback(() => {
+    navigate('/observability-showcase/analytics');
+  }, [navigate]);
+
+  const isAnalytics = route === 'analytics';
+  const RemoteComponent = remoteComponent;
+
+  return (
+    <main className="customer-portal">
+      <aside className="customer-portal__sidebar">
+        <div className="customer-portal__brand">Customer Portal</div>
+        <nav className="customer-portal__nav" aria-label="Main navigation">
+          <a
+            className={`customer-portal__nav-item ${
+              !isAnalytics ? 'customer-portal__nav-item--active' : ''
+            }`}
+          >
+            Overview
+          </a>
+          <a className="customer-portal__nav-item">Accounts</a>
+          <a
+            className={`customer-portal__nav-item ${
+              isAnalytics ? 'customer-portal__nav-item--active' : ''
+            }`}
+          >
+            Insights
+          </a>
+          <a className="customer-portal__nav-item">Settings</a>
+        </nav>
+      </aside>
+
+      <section className="customer-portal__content">
+        <header className="customer-portal__header">
+          <div>
+            <p className="customer-portal__eyebrow">Enterprise account</p>
+            <h1>Acme Retail Group</h1>
+          </div>
+          <button type="button" className="customer-portal__secondary-button">
+            Export
+          </button>
+        </header>
+
+        <section
+          className="customer-portal__metrics"
+          aria-label="Account metrics"
+        >
+          <div>
+            <span>Contract value</span>
+            <strong>$1.42M</strong>
+          </div>
+          <div>
+            <span>Open requests</span>
+            <strong>18</strong>
+          </div>
+          <div>
+            <span>Health score</span>
+            <strong>82</strong>
+          </div>
+        </section>
+
+        <section className="customer-portal__workspace">
+          <div className="customer-portal__card customer-portal__card--profile">
+            <div className="customer-portal__card-header">
+              <div>
+                <p className="customer-portal__eyebrow">
+                  {isAnalytics ? 'Route: insights' : 'Route: overview'}
+                </p>
+                <h2>{isAnalytics ? 'Account analytics' : 'User profile'}</h2>
+              </div>
+              <span
+                className={`customer-portal__status customer-portal__status--${status}`}
+                data-testid="observability-showcase-status"
+              >
+                {status}
+              </span>
+            </div>
+
+            <div className="customer-portal__profile-shell">
+              {RemoteComponent ? (
+                <RemoteComponent />
+              ) : (
+                <>
+                  <div className="customer-portal__avatar">AR</div>
+                  <div>
+                    <strong>
+                      {status === 'loading'
+                        ? 'Loading remote component'
+                        : 'Remote component unavailable'}
+                    </strong>
+                    <span>
+                      {isAnalytics
+                        ? 'Loading the analytics expose from the producer.'
+                        : 'Loading the profile expose from the producer.'}
+                    </span>
+                  </div>
+                </>
+              )}
+            </div>
+
+            {status === 'error' ? (
+              <div
+                className="customer-portal__error"
+                data-testid="observability-showcase-message"
+              >
+                <strong>Remote widget is temporarily unavailable.</strong>
+                <span>
+                  {errorMessage || 'Share this reference with support:'}
+                  <code data-testid="observability-showcase-trace">
+                    {referenceId}
+                  </code>
+                </span>
+              </div>
+            ) : status === 'degraded' ? (
+              <div
+                className="customer-portal__fallback"
+                data-testid="observability-showcase-message"
+              >
+                <strong>Limited analytics view is active.</strong>
+                <span>
+                  {errorMessage}
+                  <code data-testid="observability-showcase-trace">
+                    {referenceId}
+                  </code>
+                </span>
+              </div>
+            ) : (
+              <div
+                className="customer-portal__hint"
+                data-testid="observability-showcase-message"
+              >
+                {isAnalytics
+                  ? 'This view loads a second expose and resolves React plus the customer SDK as shared dependencies.'
+                  : 'This view is loaded by createInstance when the page opens.'}
+                {referenceId ? (
+                  <code data-testid="observability-showcase-trace">
+                    {referenceId}
+                  </code>
+                ) : null}
+              </div>
+            )}
+
+            <button
+              type="button"
+              className="customer-portal__primary-button"
+              data-testid="observability-showcase-load"
+              onClick={openAnalyticsWorkspace}
+              disabled={status !== 'success' || isAnalytics}
+            >
+              Open Analytics Workspace
+            </button>
+
+            {sharedEvidence.length ? (
+              <ul
+                className="customer-portal__shared-list"
+                data-testid="observability-showcase-shared"
+              >
+                {sharedEvidence.map((item) => (
+                  <li key={item}>{item}</li>
+                ))}
+              </ul>
+            ) : null}
+          </div>
+
+          <div className="customer-portal__card">
+            <p className="customer-portal__eyebrow">Recent activity</p>
+            <ul className="customer-portal__activity">
+              <li>
+                <span>Profile expose loaded on overview route</span>
+                <time>09:12</time>
+              </li>
+              <li>
+                <span>Analytics expose waits for route navigation</span>
+                <time>Yesterday</time>
+              </li>
+              <li>
+                <span>Shared dependency evidence is kept in reports</span>
+                <time>May 6</time>
+              </li>
+            </ul>
+          </div>
+        </section>
+      </section>
+    </main>
+  );
+}
diff --git a/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx b/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
index 96f5759d42f..6f34b24294e 100644
--- a/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/bootstrap.tsx
@@ -2,19 +2,11 @@ import React, { StrictMode } from 'react';
 import { init } from '@module-federation/enhanced/runtime';
 import * as ReactDOM from 'react-dom/client';
 import App from './App';
-import { diagnostics } from './diagnostics';
+import { observability } from './observability';
 
 init({
   name: 'runtime_host',
-  security: {
-    diagnostics: {
-      enabled: true,
-      maxEvents: 100,
-      console: true,
-      browserGlobal: true,
-    },
-  },
-  plugins: [diagnostics.plugin],
+  plugins: [observability.plugin],
   remotes: [
     {
       name: 'runtime_remote2',
diff --git a/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts b/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
deleted file mode 100644
index 8b6a5bab21d..00000000000
--- a/apps/runtime-demo/3005-runtime-host/src/diagnostics.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
-
-export const diagnostics = DiagnosticsPlugin({
-  level: 'verbose',
-  maxEvents: 100,
-  browser: {
-    enabled: true,
-    scope: 'runtime_host',
-  },
-});
diff --git a/apps/runtime-demo/3005-runtime-host/src/observability-showcase.css b/apps/runtime-demo/3005-runtime-host/src/observability-showcase.css
new file mode 100644
index 00000000000..fb8682db229
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/observability-showcase.css
@@ -0,0 +1,427 @@
+.customer-portal {
+  display: grid;
+  grid-template-columns: 248px minmax(0, 1fr);
+  min-height: 100vh;
+  color: #1f2933;
+  background: #f4f6f8;
+  font-family:
+    Inter,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    'Segoe UI',
+    sans-serif;
+}
+
+.customer-portal *,
+.customer-portal *::before,
+.customer-portal *::after {
+  box-sizing: border-box;
+}
+
+.customer-portal__sidebar {
+  padding: 28px 18px;
+  border-right: 1px solid #dde4eb;
+  background: #ffffff;
+}
+
+.customer-portal__brand {
+  margin-bottom: 28px;
+  color: #111827;
+  font-size: 18px;
+  font-weight: 800;
+}
+
+.customer-portal__nav {
+  display: grid;
+  gap: 6px;
+}
+
+.customer-portal__nav-item {
+  padding: 10px 12px;
+  border-radius: 6px;
+  color: #536171;
+  font-size: 14px;
+  font-weight: 650;
+  text-decoration: none;
+}
+
+.customer-portal__nav-item--active {
+  color: #0f4c81;
+  background: #e8f2fb;
+}
+
+.customer-portal__content {
+  padding: 32px;
+}
+
+.customer-portal__header {
+  display: flex;
+  gap: 18px;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin: 0 0 24px;
+}
+
+.customer-portal__eyebrow {
+  margin: 0 0 8px;
+  color: #667789;
+  font-size: 12px;
+  font-weight: 800;
+  letter-spacing: 0;
+  text-transform: uppercase;
+}
+
+.customer-portal h1,
+.customer-portal h2 {
+  margin: 0;
+  color: #111827;
+  letter-spacing: 0;
+}
+
+.customer-portal h1 {
+  font-size: 34px;
+  line-height: 1.15;
+}
+
+.customer-portal h2 {
+  font-size: 22px;
+  line-height: 1.25;
+}
+
+.customer-portal__metrics {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 16px;
+  margin-bottom: 20px;
+}
+
+.customer-portal__metrics div,
+.customer-portal__card {
+  border: 1px solid #dde4eb;
+  border-radius: 8px;
+  background: #ffffff;
+  box-shadow: 0 10px 28px rgba(31, 41, 51, 0.06);
+}
+
+.customer-portal__metrics div {
+  padding: 18px;
+}
+
+.customer-portal__metrics span {
+  display: block;
+  margin-bottom: 8px;
+  color: #667789;
+  font-size: 13px;
+  font-weight: 650;
+}
+
+.customer-portal__metrics strong {
+  color: #111827;
+  font-size: 26px;
+}
+
+.customer-portal__workspace {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 360px;
+  gap: 20px;
+}
+
+.customer-portal__card {
+  padding: 22px;
+}
+
+.customer-portal__card--profile {
+  min-height: 430px;
+}
+
+.customer-portal__card-header {
+  display: flex;
+  gap: 16px;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.customer-portal__status {
+  min-width: 82px;
+  padding: 7px 11px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 800;
+  text-align: center;
+  text-transform: uppercase;
+}
+
+.customer-portal__status--ready {
+  color: #245275;
+  background: #e6f2fb;
+}
+
+.customer-portal__status--loading {
+  color: #7a4f00;
+  background: #fff3cf;
+}
+
+.customer-portal__status--success {
+  color: #0f6b45;
+  background: #ddf8eb;
+}
+
+.customer-portal__status--degraded {
+  color: #7a4f00;
+  background: #fff3cf;
+}
+
+.customer-portal__status--error {
+  color: #9f1d20;
+  background: #ffe3e3;
+}
+
+.customer-portal__profile-shell {
+  display: flex;
+  gap: 16px;
+  align-items: center;
+  min-height: 170px;
+  margin: 28px 0 18px;
+  padding: 24px;
+  border: 1px dashed #bac7d3;
+  border-radius: 8px;
+  background: #f8fafc;
+}
+
+.customer-portal__avatar {
+  display: grid;
+  width: 58px;
+  height: 58px;
+  border-radius: 50%;
+  color: #ffffff;
+  background: #0f4c81;
+  font-size: 18px;
+  font-weight: 800;
+  place-items: center;
+  flex: 0 0 auto;
+}
+
+.customer-portal__profile-shell strong {
+  display: block;
+  color: #111827;
+  font-size: 18px;
+  line-height: 1.35;
+}
+
+.customer-portal__profile-shell span {
+  display: block;
+  margin-top: 6px;
+  color: #667789;
+  font-size: 14px;
+  line-height: 1.55;
+}
+
+.customer-portal__remote-widget {
+  width: 100%;
+}
+
+.customer-portal__remote-widget h3 {
+  margin: 0 0 8px;
+  color: #111827;
+  font-size: 20px;
+  line-height: 1.25;
+}
+
+.customer-portal__remote-widget p {
+  margin: 0;
+  color: #667789;
+  font-size: 14px;
+  line-height: 1.55;
+}
+
+.customer-portal__remote-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 16px;
+}
+
+.customer-portal__remote-meta span {
+  margin: 0;
+  padding: 6px 9px;
+  border-radius: 6px;
+  color: #245275;
+  background: #e6f2fb;
+  font-size: 12px;
+  font-weight: 750;
+}
+
+.customer-portal__hint,
+.customer-portal__fallback,
+.customer-portal__error {
+  margin-bottom: 18px;
+  padding: 14px 16px;
+  border-radius: 8px;
+  font-size: 14px;
+  line-height: 1.6;
+}
+
+.customer-portal__hint {
+  color: #425466;
+  background: #f1f5f9;
+}
+
+.customer-portal__error {
+  color: #7a2222;
+  background: #fff0f0;
+}
+
+.customer-portal__fallback {
+  color: #6f4b00;
+  background: #fff6d9;
+}
+
+.customer-portal__error strong,
+.customer-portal__fallback strong,
+.customer-portal__fallback span,
+.customer-portal__error span {
+  display: block;
+}
+
+.customer-portal__hint code,
+.customer-portal__fallback code,
+.customer-portal__error code {
+  display: inline-block;
+  margin-left: 6px;
+  padding: 2px 6px;
+  border-radius: 4px;
+  color: #5d1f1f;
+  background: #ffe1e1;
+  font-family:
+    ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono',
+    monospace;
+  font-size: 13px;
+  overflow-wrap: anywhere;
+}
+
+.customer-portal__hint code {
+  color: #245275;
+  background: #dceefb;
+}
+
+.customer-portal__fallback code {
+  color: #6f4b00;
+  background: #ffedaf;
+}
+
+.customer-portal__shared-list {
+  display: grid;
+  gap: 8px;
+  margin: 16px 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.customer-portal__shared-list li {
+  padding: 10px 12px;
+  border: 1px solid #d7e5ef;
+  border-radius: 6px;
+  color: #245275;
+  background: #f4f9fd;
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.customer-portal__primary-button,
+.customer-portal__secondary-button {
+  min-height: 42px;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 800;
+  cursor: pointer;
+}
+
+.customer-portal__primary-button {
+  padding: 0 18px;
+  border: 0;
+  color: #ffffff;
+  background: #0f4c81;
+}
+
+.customer-portal__primary-button:hover {
+  background: #0b3e69;
+}
+
+.customer-portal__primary-button:disabled {
+  cursor: wait;
+  background: #8aa8c1;
+}
+
+.customer-portal__secondary-button {
+  padding: 0 16px;
+  border: 1px solid #c8d3de;
+  color: #334155;
+  background: #ffffff;
+}
+
+.customer-portal__activity {
+  display: grid;
+  gap: 14px;
+  margin: 8px 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.customer-portal__activity li {
+  display: flex;
+  gap: 12px;
+  justify-content: space-between;
+  padding-bottom: 14px;
+  border-bottom: 1px solid #eef2f6;
+  color: #273547;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.customer-portal__activity li:last-child {
+  padding-bottom: 0;
+  border-bottom: 0;
+}
+
+.customer-portal__activity time {
+  color: #76879a;
+  white-space: nowrap;
+}
+
+@media (max-width: 900px) {
+  .customer-portal {
+    grid-template-columns: 1fr;
+  }
+
+  .customer-portal__sidebar {
+    border-right: 0;
+    border-bottom: 1px solid #dde4eb;
+  }
+
+  .customer-portal__nav {
+    grid-template-columns: repeat(4, max-content);
+    overflow-x: auto;
+  }
+
+  .customer-portal__metrics,
+  .customer-portal__workspace {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 560px) {
+  .customer-portal__content {
+    padding: 20px;
+  }
+
+  .customer-portal__header,
+  .customer-portal__card-header {
+    display: grid;
+  }
+
+  .customer-portal h1 {
+    font-size: 28px;
+  }
+}
diff --git a/apps/runtime-demo/3005-runtime-host/src/observability.ts b/apps/runtime-demo/3005-runtime-host/src/observability.ts
new file mode 100644
index 00000000000..cff01684308
--- /dev/null
+++ b/apps/runtime-demo/3005-runtime-host/src/observability.ts
@@ -0,0 +1,10 @@
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+export const observability = ObservabilityPlugin({
+  level: 'verbose',
+  maxEvents: 100,
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
diff --git a/apps/runtime-demo/3005-runtime-host/tsconfig.app.json b/apps/runtime-demo/3005-runtime-host/tsconfig.app.json
index 8864b3d724f..af024f1690b 100644
--- a/apps/runtime-demo/3005-runtime-host/tsconfig.app.json
+++ b/apps/runtime-demo/3005-runtime-host/tsconfig.app.json
@@ -2,16 +2,12 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "../../../dist/out-tsc",
-    "types": [
-      "node",
-      "../../../typings/cssmodule.d.ts",
-      "../../../typings/image.d.ts"
-    ],
+    "types": ["node"],
     "paths": {
       "*": ["./@mf-types/*"]
     }
   },
-  "files": ["../../../typings/cssmodule.d.ts", "../../../typings/image.d.ts"],
+  "files": ["../typings/cssmodule.d.ts", "../typings/image.d.ts"],
   "exclude": [
     "jest.config.ts",
     "**/*.spec.ts",
diff --git a/apps/runtime-demo/3005-runtime-host/webpack.config.js b/apps/runtime-demo/3005-runtime-host/webpack.config.js
index 1b0615bd367..5f17e4b512f 100644
--- a/apps/runtime-demo/3005-runtime-host/webpack.config.js
+++ b/apps/runtime-demo/3005-runtime-host/webpack.config.js
@@ -9,11 +9,55 @@ const cssLoader = require.resolve('css-loader');
 const {
   ModuleFederationPlugin,
 } = require('@module-federation/enhanced/webpack');
+const {
+  ObservabilityBuildPlugin,
+} = require('@module-federation/observability-plugin/build');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
 
 module.exports = (_env, argv = {}) => {
   const isProduction = argv.mode === 'production';
   const sourcePath = path.resolve(__dirname, 'src');
+  const moduleFederationOptions = {
+    name: 'runtime_host',
+    experiments: { asyncStartup: true },
+    remotes: {
+      remote1: 'runtime_remote1@http://127.0.0.1:3006/mf-manifest.json',
+    },
+    filename: 'remoteEntry.js',
+    exposes: {
+      './Button': './src/Button.tsx',
+    },
+    dts: {
+      tsConfigPath: path.resolve(__dirname, 'tsconfig.app.json'),
+    },
+    shareStrategy: 'loaded-first',
+    shared: {
+      lodash: {
+        singleton: true,
+        requiredVersion: '^4.0.0',
+      },
+      antd: {
+        singleton: true,
+        requiredVersion: '^4.0.0',
+      },
+      react: {
+        singleton: true,
+        requiredVersion: '^18.2.0',
+      },
+      'react/': {
+        singleton: true,
+        requiredVersion: '^18.2.0',
+      },
+      'react-dom': {
+        singleton: true,
+        requiredVersion: '^18.2.0',
+      },
+      'react-dom/': {
+        singleton: true,
+        requiredVersion: '^18.2.0',
+      },
+    },
+  };
 
   return {
     mode: isProduction ? 'production' : 'development',
@@ -89,46 +133,9 @@ module.exports = (_env, argv = {}) => {
       ],
     },
     plugins: [
-      new ModuleFederationPlugin({
-        name: 'runtime_host',
-        experiments: { asyncStartup: true },
-        remotes: {
-          remote1: 'runtime_remote1@http://127.0.0.1:3006/mf-manifest.json',
-        },
-        filename: 'remoteEntry.js',
-        exposes: {
-          './Button': './src/Button.tsx',
-        },
-        dts: {
-          tsConfigPath: path.resolve(__dirname, 'tsconfig.app.json'),
-        },
-        shareStrategy: 'loaded-first',
-        shared: {
-          lodash: {
-            singleton: true,
-            requiredVersion: '^4.0.0',
-          },
-          antd: {
-            singleton: true,
-            requiredVersion: '^4.0.0',
-          },
-          react: {
-            singleton: true,
-            requiredVersion: '^18.2.0',
-          },
-          'react/': {
-            singleton: true,
-            requiredVersion: '^18.2.0',
-          },
-          'react-dom': {
-            singleton: true,
-            requiredVersion: '^18.2.0',
-          },
-          'react-dom/': {
-            singleton: true,
-            requiredVersion: '^18.2.0',
-          },
-        },
+      new ModuleFederationPlugin(moduleFederationOptions),
+      new ObservabilityBuildPlugin({
+        moduleFederation: moduleFederationOptions,
       }),
       new HtmlWebpackPlugin({
         template: path.resolve(__dirname, 'src/index.html'),
@@ -146,6 +153,169 @@ module.exports = (_env, argv = {}) => {
       devMiddleware: {
         writeToDisk: true,
       },
+      setupMiddlewares: (middlewares, devServer) => {
+        if (!devServer.app) {
+          return middlewares;
+        }
+
+        const sendJson = (response, body) => {
+          response.setHeader('Content-Type', 'application/json');
+          response.end(JSON.stringify(body));
+        };
+        const sendJs = (response, body) => {
+          response.setHeader('Content-Type', 'application/javascript');
+          response.end(body);
+        };
+        const createManifest = ({ name, globalName, publicPath }) => ({
+          id: name,
+          name,
+          metaData: {
+            name,
+            type: 'app',
+            buildInfo: {
+              buildVersion: 'observability-fixture',
+              buildName: name,
+            },
+            remoteEntry: {
+              name: 'remoteEntry.js',
+              path: '',
+              type: 'global',
+            },
+            types: {
+              path: '',
+              name: '',
+              zip: '',
+              api: '',
+            },
+            globalName,
+            pluginVersion: 'observability-fixture',
+            publicPath,
+          },
+          shared: [],
+          remotes: [],
+          exposes: [
+            {
+              id: `${name}:Button`,
+              name: 'Button',
+              assets: {
+                js: {
+                  sync: [],
+                  async: [],
+                },
+                css: {
+                  sync: [],
+                  async: [],
+                },
+              },
+              path: './Button',
+            },
+          ],
+        });
+
+        devServer.app.get(
+          '/observability-fixtures/missing-fields/mf-manifest.json',
+          (_request, response) => {
+            sendJson(response, {
+              id: 'observability_missing_fields_remote',
+              name: 'observability_missing_fields_remote',
+            });
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/retry-recovered/mf-manifest.json',
+          (_request, response) => {
+            sendJson(
+              response,
+              createManifest({
+                name: 'observability_retry_recovered_remote',
+                globalName: 'observability_retry_recovered_remote',
+                publicPath:
+                  'http://127.0.0.1:3005/observability-fixtures/retry-recovered/',
+              }),
+            );
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/retry-recovered/remoteEntry.js',
+          (request, response) => {
+            if (request.query.retryCount !== '1') {
+              response.statusCode = 503;
+              response.end('observability retry fixture failed before retry');
+              return;
+            }
+
+            sendJs(
+              response,
+              [
+                'window.observability_retry_recovered_remote = {',
+                '  init: function() {},',
+                '  get: function() {',
+                '    return Promise.resolve(function() {',
+                '      return { default: function ObservabilityRetryRecovered() { return null; } };',
+                '    });',
+                '  }',
+                '};',
+              ].join('\n'),
+            );
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/wrong-global/mf-manifest.json',
+          (_request, response) => {
+            sendJson(
+              response,
+              createManifest({
+                name: 'observability_wrong_global_remote',
+                globalName: 'observability_wrong_global_expected',
+                publicPath:
+                  'http://127.0.0.1:3005/observability-fixtures/wrong-global/',
+              }),
+            );
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/wrong-global/remoteEntry.js',
+          (_request, response) => {
+            sendJs(
+              response,
+              [
+                'window.observability_wrong_global_actual = {',
+                '  init: function() {},',
+                '  get: function() {',
+                '    return Promise.resolve(function() {',
+                '      return { default: function ObservabilityWrongGlobal() { return null; } };',
+                '    });',
+                '  }',
+                '};',
+              ].join('\n'),
+            );
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/execution-error/mf-manifest.json',
+          (_request, response) => {
+            sendJson(
+              response,
+              createManifest({
+                name: 'observability_execution_error_remote',
+                globalName: 'observability_execution_error_remote',
+                publicPath:
+                  'http://127.0.0.1:3005/observability-fixtures/execution-error/',
+              }),
+            );
+          },
+        );
+        devServer.app.get(
+          '/observability-fixtures/execution-error/remoteEntry.js',
+          (_request, response) => {
+            sendJs(
+              response,
+              "throw new Error('observability remoteEntry execution failed');",
+            );
+          },
+        );
+        return middlewares;
+      },
     },
     optimization: {
       runtimeChunk: false,
diff --git a/apps/runtime-demo/3006-runtime-remote/tsconfig.app.json b/apps/runtime-demo/3006-runtime-remote/tsconfig.app.json
index 9f647569f50..196facc7dcf 100644
--- a/apps/runtime-demo/3006-runtime-remote/tsconfig.app.json
+++ b/apps/runtime-demo/3006-runtime-remote/tsconfig.app.json
@@ -3,12 +3,8 @@
   "compilerOptions": {
     "composite": true,
     "declaration": true,
-    "types": [
-      "node",
-      "../../../typings/cssmodule.d.ts",
-      "../../../typings/image.d.ts"
-    ]
+    "types": ["node"]
   },
-  "files": ["../../../typings/cssmodule.d.ts", "../../../typings/image.d.ts"],
+  "files": ["../typings/cssmodule.d.ts", "../typings/image.d.ts"],
   "include": ["src/**/*"]
 }
diff --git a/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx b/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
new file mode 100644
index 00000000000..55355f372d4
--- /dev/null
+++ b/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
@@ -0,0 +1,20 @@
+export default function AnalyticsPanel() {
+  return (
+    <section
+      className="customer-portal__remote-widget"
+      data-testid="remote2-analytics-panel"
+    >
+      <h3>Expansion analytics</h3>
+      <p>
+        Analytics panel loaded from runtime_remote2/AnalyticsPanel after route
+        navigation.
+      </p>
+      <div className="customer-portal__remote-meta">
+        <span>producer: runtime_remote2</span>
+        <span>expose: AnalyticsPanel</span>
+        <span>shared: react</span>
+        <span>shared: observability-customer-sdk</span>
+      </div>
+    </section>
+  );
+}
diff --git a/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx b/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
new file mode 100644
index 00000000000..786d89ba900
--- /dev/null
+++ b/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
@@ -0,0 +1,18 @@
+export default function ProfileCard() {
+  return (
+    <section
+      className="customer-portal__remote-widget"
+      data-testid="remote2-profile-card"
+    >
+      <h3>Jordan Lee</h3>
+      <p>
+        Account owner profile loaded from runtime_remote2/ProfileCard when the
+        page opened.
+      </p>
+      <div className="customer-portal__remote-meta">
+        <span>producer: runtime_remote2</span>
+        <span>expose: ProfileCard</span>
+      </div>
+    </section>
+  );
+}
diff --git a/apps/runtime-demo/3007-runtime-remote/tsconfig.app.json b/apps/runtime-demo/3007-runtime-remote/tsconfig.app.json
index e02bdff676a..6d7c66b0018 100644
--- a/apps/runtime-demo/3007-runtime-remote/tsconfig.app.json
+++ b/apps/runtime-demo/3007-runtime-remote/tsconfig.app.json
@@ -2,13 +2,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "../../../dist/out-tsc",
-    "types": [
-      "node",
-      "../../../typings/cssmodule.d.ts",
-      "../../../typings/image.d.ts"
-    ]
+    "types": ["node"]
   },
-  "files": ["../../../typings/cssmodule.d.ts", "../../../typings/image.d.ts"],
+  "files": ["../typings/cssmodule.d.ts", "../typings/image.d.ts"],
   "exclude": [
     "jest.config.ts",
     "**/*.spec.ts",
diff --git a/apps/runtime-demo/3007-runtime-remote/webpack.config.js b/apps/runtime-demo/3007-runtime-remote/webpack.config.js
index c7aa170ed70..feff0c14c5f 100644
--- a/apps/runtime-demo/3007-runtime-remote/webpack.config.js
+++ b/apps/runtime-demo/3007-runtime-remote/webpack.config.js
@@ -1,3 +1,5 @@
+/* eslint-env node */
+
 const path = require('path');
 const reactPath = path.dirname(require.resolve('react/package.json'));
 const reactDomPath = path.dirname(require.resolve('react-dom/package.json'));
@@ -92,6 +94,8 @@ module.exports = (_env, argv = {}) => {
         filename: 'remoteEntry.js',
         exposes: {
           './ButtonOldAnt': './src/components/ButtonOldAnt',
+          './ProfileCard': './src/components/ProfileCard',
+          './AnalyticsPanel': './src/components/AnalyticsPanel',
         },
         shared: {
           lodash: {
diff --git a/apps/runtime-demo/AGENTS.md b/apps/runtime-demo/AGENTS.md
new file mode 100644
index 00000000000..8ce63645c5e
--- /dev/null
+++ b/apps/runtime-demo/AGENTS.md
@@ -0,0 +1,80 @@
+# Runtime Demo Agent Guide
+
+This directory has a local copy of the MF skill at `./skills/mf/SKILL.md`.
+When the user asks about Module Federation loading, shared dependencies,
+observability reports, trace IDs, or the runtime demo, read that skill first.
+For the showcase flow, use `./skills/mf/reference/observability.md`.
+
+## Showcase Task
+
+Use this flow when the user asks you to inspect the shared dependency loading
+state in the runtime demo:
+
+1. Start the demo from the repository root:
+
+```bash
+pnpm run app:runtime:dev
+```
+
+2. Open:
+
+```text
+http://localhost:3005/observability-showcase
+```
+
+3. Confirm the page renders the profile widget. This first view is loaded with
+   `createInstance` from `runtime_remote2/ProfileCard`.
+
+4. Click `Open Analytics Workspace`.
+
+5. Confirm the route changes to:
+
+```text
+http://localhost:3005/observability-showcase/analytics
+```
+
+6. Confirm the page shows a limited analytics view instead of crashing. Do not
+   treat the page copy as the root cause. This second view first tries to load
+   `runtime_remote2/AnalyticsPanel` with `createInstance`, then the
+   observability report shows `observability-customer-sdk` failed because the
+   route asks for `^3.0.0` but only `2.1.0` is available.
+
+7. Read the browser observability reports:
+
+```js
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getReports({ limit: 20 });
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
+  remote: 'runtime_remote2',
+});
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
+  shared: 'react',
+});
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
+  shared: 'observability-customer-sdk',
+});
+```
+
+8. Answer with:
+
+- which consumer loaded `ProfileCard`
+- which consumer loaded `AnalyticsPanel`
+- whether `react` was resolved
+- whether `observability-customer-sdk` failed
+- which version was required and which version was available
+- why the page did not crash and what limited view was rendered
+
+## Suggested User Prompt
+
+```text
+启动项目，访问 http://localhost:3005/observability-showcase，
+确认首屏远程组件是否加载成功。
+然后点击 Open Analytics Workspace，看下共享依赖加载情况。
+
+请说明：
+1. 首屏加载了哪个生产者的哪个 expose
+2. 点击后路由加载了哪个生产者的哪个 expose
+3. 第二个 expose 使用了哪些 shared
+4. 哪个 shared 加载失败了，原因是什么
+5. 页面为什么没有崩溃，显示了什么降级视图
+6. 观测报告里有哪些关键证据
+```
diff --git a/apps/runtime-demo/README.md b/apps/runtime-demo/README.md
index 114d9c67de7..aa7335c84c7 100644
--- a/apps/runtime-demo/README.md
+++ b/apps/runtime-demo/README.md
@@ -16,15 +16,20 @@ Run `pnpm run app:runtime:dev` to start host, remote1, remote2.
 - remote1: [localhost:3006](http://localhost:3006/)
 - remote2: [localhost:3007](http://localhost:3007/)
 
-## Diagnostics Demo
+## Observability Demo
 
-The diagnostics fixture lives in the runtime host. The host explicitly enables
-`security.diagnostics` and installs `@module-federation/diagnostics-plugin` for
-this demo, so the report is generated by the runtime plugin instead of local UI
-state.
+The observability fixture lives in the runtime host. The host explicitly enables
+`@module-federation/observability-plugin` for this demo, so the report is
+generated by the runtime plugin instead of local UI state.
+The host also installs `ObservabilityBuildPlugin`, so each build writes a
+build summary to `.mf/observability/build-info.json`. If a host build fails
+after the plugin runs, the build-side report is written to
+`.mf/observability/build-report.json`.
 
-- diagnostics page:
-  [localhost:3005/diagnostics](http://localhost:3005/diagnostics)
+- observability fixture page:
+  [localhost:3005/observability](http://localhost:3005/observability)
+- observability showcase:
+  [localhost:3005/observability-showcase](http://localhost:3005/observability-showcase)
 
 Start the demo first:
 
@@ -32,31 +37,100 @@ Start the demo first:
 pnpm run app:runtime:dev
 ```
 
-Then open the diagnostics page and use these controls:
+Then open the observability fixture page and use these controls:
+
+- `observability-showcase`: a clean recording page that looks like a normal
+  product page. Opening the page loads `runtime_remote2/ProfileCard` with
+  `createInstance`. Click `Open Analytics Workspace` to route to the analytics
+  view, which loads `runtime_remote2/AnalyticsPanel` with another
+  `createInstance`, resolves `react`, and then fails to resolve
+  `observability-customer-sdk` because the route asks for `^3.0.0` while only
+  `2.1.0` is available. The page renders a limited analytics view instead of
+  crashing, without exposing the low-level shared error in the UI. Use this page
+  to record an AI agent discovering which expose was attempted, which shared
+  dependency failed, why the limited view appeared, and what evidence exists in
+  the observability report. Use `/observability` for the full fixture matrix.
+
+- Build observability: after the host compiles, check
+  `apps/runtime-demo/3005-runtime-host/.mf/observability/build-info.json`. It
+  should include `runtime_host`, the remote manifest URL, `Button`, and shared
+  dependencies such as `react`, without local source paths.
+  A clean build should not leave a stale
+  `apps/runtime-demo/3005-runtime-host/.mf/observability/build-report.json`.
 
 - `Load success remote`: loads `dynamic-remote/ButtonOldAnt` from remote2. The
   status should become `success`, the remote button should render, and the
   report should include a completed `loadRemote` timeline with
-  `summary.outcome: "runtime-loaded"`. The same report is also available at
-  `window.__FEDERATION__.__DIAGNOSTICS__.runtime_host.getLatestReport()`.
+  `summary.outcome: "runtime-loaded"` and per-phase success facts under
+  `summary.phases`. The report should also include
+  `diagnosis.outcome: "runtime-loaded"`.
+  The same report is available at
+  `window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getLatestReport()`.
 - `Load missing expose`: loads a missing expose from remote2. The status should
   become `error`, and the report should include
-  `dynamic-remote/__missing_expose__`. The browser console should print a
-  diagnostic hint with a `traceId`.
+  `dynamic-remote/__missing_expose__` with `failedPhase: "expose"`. The
+  `diagnosis.actions` list should include a concrete expose check. The browser
+  console should print an observability hint with a `traceId`.
 - `Load broken manifest`: loads a remote with a broken manifest URL. The status
-  should become `error`, and the shown error should keep the manifest pathname
-  while removing query, token, and hash data.
-- `Mark business loaded`: calls the diagnostics plugin's component success API,
+  should become `error`. The report should include the original manifest URL,
+  `RUNTIME-003`, `ownerHint: "host"`, `diagnosis.facts.url`, and a manifest
+  check in `diagnosis.actions`.
+- `Load remote URL error`: registers a remote whose manifest URL points to an
+  unavailable server. The report should fail at `manifest` and include
+  `RUNTIME-003`, the original URL, and a manifest check.
+- `Load retry recovered`: serves a remoteEntry that fails on the first script
+  load and succeeds on retry. The report should be successful with
+  `summary.outcome: "recovered"`, `summary.flags.retried: true`, and a retry
+  recovery warning.
+- `Load fallback success`: loads a missing expose and lets the demo fallback
+  plugin return a fallback module. The report should be successful with
+  `summary.outcome: "recovered"`, keep the original expose failure under
+  `summary.error`, and set `summary.flags.fallback: true`.
+- `Load manifest missing fields`: serves a JSON manifest that misses required
+  fields. The report should fail at `manifest`, show the missing fields, and
+  include a manifest check.
+- `Load wrong globalName`: serves a manifest and remoteEntry where the
+  remoteEntry registers a different global name from the manifest. The report
+  should fail at `remoteEntry`, include `RUNTIME-001`, and include a remote
+  global check.
+- `Load remoteEntry execution error`: serves a remoteEntry that throws while it
+  is being executed. The report should fail at `remoteEntry`, include
+  `RUNTIME-008`, classify the resource error as script execution, and include a
+  remoteEntry check.
+- `Load snapshot match error`: registers a version-only remote that cannot be
+  matched from deployment `moduleInfo`. The report should include
+  `RUNTIME-007`, `moduleInfo.reason: "remote-snapshot"`, the clipped
+  `moduleInfo.availableNames`, and a moduleInfo check.
+- `Mark business loaded`: calls the observability plugin's component success API,
   and the report should include `component:business-loaded` with
-  `summary.outcome: "component-loaded"`.
+  `summary.outcome: "component-loaded"`. The demo also sends sample metadata
+  to verify that business-provided metadata stays visible in the report.
 - `Shared miss`: triggers a missing shared provider report. The report should
-  include `diagnostics-missing-shared` and `missing-provider`.
+  include `observability-missing-shared`, `missing-provider`, and shared
+  provider/version checks in `diagnosis.actions`.
 - `Shared version mismatch`: asks for an unsupported React version. The report
   should include `react`, `^99.0.0`, the available version, and
   `version-mismatch`.
+- `Shared unexpected provider`: resolves a shared dependency from a remote-like
+  provider even though the host provider is present. The report should be
+  successful and include `observability-provider-choice`,
+  `provider: "runtime_remote2"`, and `selectedVersion: "2.0.0"`.
+- `Load multi-consumer chain`: creates two runtime consumers with
+  `createInstance`, loads different exposes from the real `runtime_remote2`
+  remote on port 3007, and gives each consumer its own shared dependency. It
+  records the remote load report, shared dependency report, business component
+  success event, and repeated load cache evidence. Use this scenario when
+  validating whether an agent can answer who loaded which expose, which shared
+  provider was selected, and whether the producer load reused cached runtime
+  state.
 - `Eager config error`: synchronously consumes an async shared dependency. The
-  report should include `diagnostics-async-shared`, `RUNTIME-005`, and
-  `sync-async-boundary`.
+  report should include `observability-async-shared`, `RUNTIME-005`, and
+  `sync-async-boundary`, with `ownerHint: "shared"` and an eager config check
+  in `diagnosis.actions`.
+- `Runtime eager config error`: synchronously consumes an async shared
+  dependency from the pure runtime path. The report should include
+  `observability-runtime-async-shared`, `RUNTIME-006`, and
+  `sync-async-boundary`, with the same eager config check.
 
 Run the automated verification:
 
@@ -65,6 +139,6 @@ pnpm run ci:local --only=e2e-runtime
 ```
 
 This command installs the e2e dependencies if needed, builds the packages,
-starts the host and remotes, and runs the Cypress checks. The diagnostics
-fixture is covered by the `diagnostics demo fixture` tests in the runtime host
+starts the host and remotes, and runs the Cypress checks. The observability
+fixture is covered by the `observability demo fixture` tests in the runtime host
 e2e suite.
diff --git a/apps/runtime-demo/skills/mf/SKILL.md b/apps/runtime-demo/skills/mf/SKILL.md
new file mode 100644
index 00000000000..0c4b3415464
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: mf
+description: "All-in-one Module Federation skill. Use when the user asks anything about MF — concepts, configuration, runtime API, shared dependencies, type errors, runtime error code troubleshooting, observability, slow builds, Bridge integration, or adding MF to an existing project."
+argument-hint: <sub-command | natural-language-query> [args...]
+allowed-tools: Read Glob Bash(node *) Bash(npx tsc*) Bash(npx mf dts*) Bash(curl *) WebFetch Write Edit AskUserQuestion
+---
+
+# MF — Module Federation All-in-One Skill
+
+## Step 1: Identify the sub-skill
+
+Parse `$ARGUMENTS` and map to a reference file in the `reference/` directory (same directory as this file):
+
+| Sub-command (case-insensitive) | Aliases | Reference file |
+|---|---|---|
+| `docs` | `doc`, `help`, `?` | `reference/docs.md` |
+| `context` | `ctx`, `info`, `status` | `reference/context.md` |
+| `module-info` | `module`, `remote`, `manifest` | `reference/module-info.md` |
+| `integrate` | `init`, `setup`, `add` | `reference/integrate.md` |
+| `type-check` | `types`, `ts`, `dts` | `reference/type-check.md` |
+| `shared-deps` | `shared`, `deps`, `singleton` | `reference/shared-deps.md` |
+| `perf` | `performance`, `hmr`, `speed` | `reference/perf.md` |
+| `config-check` | `config`, `plugin`, `exposes` | `reference/config-check.md` |
+| `bridge-check` | `bridge`, `sub-app` | `reference/bridge-check.md` |
+| `runtime-error` | `runtime-code`, `runtime-008`, `runtime-001`, `remote-entry` | `reference/runtime-error.md` |
+| `observability` | `observe`, `trace`, `traceId`, `report`, `observability`, `debug-loading`, `telemetry`, `runtime-007`, `moduleInfo`, `snapshot` | `reference/observability.md` |
+
+**If no explicit sub-command is found**, detect intent from the full input:
+
+If the input contains an observability report, `traceId`, console `read:` command,
+`.mf/observability` file path, or asks how to observe, debug, trace, inspect, or
+upload Module Federation loading data, choose `reference/observability.md` even
+when the same input also contains a `RUNTIME-xxx` code.
+
+| Signal in input | Reference file |
+|---|---|
+| Question about MF concepts, API, configuration options | `reference/docs.md` |
+| "integrate", "add MF", "setup", "scaffold", "new project" | `reference/integrate.md` |
+| "type error", "TS error", "@mf-types", "dts", "typescript" | `reference/type-check.md` |
+| "shared", "singleton", "duplicate", "antd", "transformImport" | `reference/shared-deps.md` |
+| "slow", "HMR", "performance", "build speed", "ts-go" | `reference/perf.md` |
+| "plugin", "asyncStartup", "exposes key", "config" | `reference/config-check.md` |
+| "bridge", "sub-app", "export-app", "createRemoteAppComponent" | `reference/bridge-check.md` |
+| "RUNTIME-001", "RUNTIME-008", "runtime error code", "remote entry load failed", "ScriptNetworkError", "ScriptExecutionError", "container missing", "window[remoteEntryKey]" | `reference/runtime-error.md` |
+| "Observability report generated", "console.error", "traceId", "read:", "diagnosis", "ownerHint", "summary.phases", ".mf/observability", "build-report.json", "latest.json", "RUNTIME-007", "moduleInfo", "remote snapshot", "global snapshot", "snapshot match", "observability", "observe MF", "debug MF loading", "trace loading", "loading report", "telemetry", "onReport", "onEvent", "production report", "upload observability" | `reference/observability.md` |
+| "manifest", "remoteEntry URL", "module info", "publicPath" | `reference/module-info.md` |
+| "context", "what is configured", "MF role", "bundler" | `reference/context.md` |
+
+If still ambiguous, show the user the sub-command table above and ask them to pick.
+
+## Step 2: Load and execute the reference
+
+Read the matched file from the `reference/` directory (same directory as this SKILL.md).
+
+Execute all instructions in that file, passing the remaining arguments (everything after the sub-command token, or the full `$ARGUMENTS` if intent-detected) as `ARGS`.
diff --git a/apps/runtime-demo/skills/mf/reference/bridge-check.md b/apps/runtime-demo/skills/mf/reference/bridge-check.md
new file mode 100644
index 00000000000..915e683f86f
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/bridge-check.md
@@ -0,0 +1,29 @@
+# Sub-skill: bridge-check
+
+Check Module Federation Bridge usage: verify that producers correctly export `export-app`, and that consumers use the recommended Bridge API.
+
+## Step 1: Collect MFContext
+
+Read and follow the instructions in `./context.md`, passing ARGS as the project root.
+
+## Step 2: Run bridge check script
+
+Serialize MFContext to JSON and pass it to the check script:
+
+```bash
+node scripts/bridge-check.js --context '<MFContext-JSON>'
+```
+
+Process each item in the output `results` and `context.mfConfig`:
+
+**BRIDGE-USAGE · info — No export-app export found**
+- No key matching the `export-app` pattern found in `exposes`
+- If this project is a sub-app that should follow the Bridge spec, guide the user to:
+  1. Add `"./export-app": "./src/export-app.tsx"` to `exposes`
+  2. The exported module must return an object conforming to the Bridge spec (containing `render` and `destroy` methods)
+
+**BRIDGE-USAGE · info — Consumer API recommendation**
+- Advise consumers to use official Bridge APIs such as `createRemoteAppComponent`
+- Avoid directly concatenating remote URLs or manually calling `loadRemote`
+
+If `context.mfRole` is `host` (no exposes), skip the producer-side check and only provide consumer-side recommendations.
diff --git a/apps/runtime-demo/skills/mf/reference/browser-debug/long-chain.md b/apps/runtime-demo/skills/mf/reference/browser-debug/long-chain.md
new file mode 100644
index 00000000000..c6a78cae92e
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/browser-debug/long-chain.md
@@ -0,0 +1,72 @@
+# Long-Chain Capture
+
+Keep a tab alive across multiple steps — navigate, click through interactions, then capture.
+
+## Usage
+
+```bash
+# Step 1 — open tab, keep it alive
+TAB=$(node ../scripts/browser-capture.mjs "https://example.com" --keep-tab | jq -r .tabId)
+
+# Step 2 — click through the interaction chain (faster: domcontentloaded/none)
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --click "Profile" --action-wait domcontentloaded
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --click "Favorites" --action-wait none
+
+# Step 3 — final action, capture variables, close tab
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --click "Add" --vars __FEDERATION__ --action-wait networkidle --close
+```
+
+## Flags
+
+| Flag | Description |
+|---|---|
+| `--keep-tab` | Don't close tab after capture; outputs `tabId` in result |
+| `--tab-id <id>` | Attach to existing tab instead of navigating |
+| `--click "<text or selector>"` | Click an element; matching prefers CSS/interactive elements first |
+| `--fill "placeholder::text"` | Type into an input/textarea located by placeholder |
+| `--select "placeholder::value"` | Choose an option in a select located by placeholder |
+| `--action-wait <auto|networkidle|domcontentloaded|timeout|none>` | Wait strategy after click/fill/select (`auto` is default; use `networkidle` on the final step when strict consistency is needed) |
+| `--no-entries` | Exclude entries logs to speed up capture and reduce output size |
+| `--dump-dom` | Output page DOM structure (for identifying selectors) |
+| `--close` | Close the tab after this step |
+
+## Click matching
+
+Applied in order:
+1. If query starts with `#`, `.`, `[`, or contains `>` → CSS selector
+2. Strong interactive elements (`button`, `a`, role/button/tab/menuitem/option, submit/button inputs)
+3. Weak interactive elements (`div`/`span`/`li`) only when they look clickable (`cursor:pointer`, `onclick`, or focusable tabindex)
+4. Text match priority inside each layer: **exact** → **prefix** → **contains**
+
+## Fill (input/textarea)
+
+Locates the field by `placeholder` attribute, injects text using native value setter — compatible with React and Vue controlled inputs.
+
+```bash
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --fill "Enter keyword::Module Federation"
+```
+
+## Select (dropdown)
+
+Locates by `placeholder` attribute or default option text, then:
+- **Native `<select>`** — sets value directly and dispatches `change`
+- **Custom dropdown** — clicks the trigger to open, then clicks the matching option
+
+```bash
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --select "Select environment::Production"
+```
+
+## When element is not found
+
+Use `--dump-dom` to let Claude inspect the page and identify the correct selector:
+
+```bash
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --dump-dom
+# Claude analyzes the DOM, then:
+node ../scripts/browser-capture.mjs --tab-id "$TAB" --click "#profile-nav-btn"
+```
+
+## Tab lifecycle
+
+- New tab (no `--tab-id`) → auto-closes unless `--keep-tab`
+- Existing tab (`--tab-id`) → stays open unless `--close`
diff --git a/apps/runtime-demo/skills/mf/reference/browser-debug/setup.md b/apps/runtime-demo/skills/mf/reference/browser-debug/setup.md
new file mode 100644
index 00000000000..d19f366f464
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/browser-debug/setup.md
@@ -0,0 +1,148 @@
+# Browser Capture Setup
+
+One-time setup: create a debug Chrome profile that shares your real cookies/auth.
+
+---
+
+## Why a separate profile directory?
+
+Chrome **refuses** to enable remote debugging on the default profile directory
+(`~/Library/Application Support/Google/Chrome`) as a security measure:
+
+```
+DevTools remote debugging requires a non-default data directory.
+```
+
+The workaround: copy your real profile to a non-default path. Because macOS Chrome
+encrypts cookies using the system Keychain (`Chrome Safe Storage` key), a copied
+profile can still decrypt cookies — so you stay logged into all your sites.
+
+---
+
+## One-time setup (macOS)
+
+**Step 1 — See which profiles you have:**
+```bash
+node -e "
+const fs = require('fs');
+const base = process.env.HOME + '/Library/Application Support/Google/Chrome';
+const state = JSON.parse(fs.readFileSync(base + '/Local State', 'utf8'));
+const cache = state.profile.info_cache;
+const last  = state.profile.last_used;
+console.log('Available Chrome profiles:\n');
+Object.entries(cache).forEach(([dir, info]) => {
+  const tag = dir === last ? ' ← current' : '';
+  console.log('  ' + dir.padEnd(12) + info.name + tag);
+});
+console.log('\nDefault: ' + last);
+"
+```
+
+**Step 2 — Sync the chosen profile to the debug location:**
+```bash
+# Set PROFILE to the dir you want (default: current profile, usually "Default")
+PROFILE="Default"   # ← change to e.g. "Profile 1" if needed
+REAL="$HOME/Library/Application Support/Google/Chrome/$PROFILE"
+DEBUG_DIR="$HOME/Library/Application Support/Google/ChromeDebug"
+mkdir -p "$DEBUG_DIR"
+rsync -a --delete "$REAL/" "$DEBUG_DIR/Default/"
+echo "Debug profile ready: $DEBUG_DIR (sourced from $PROFILE)"
+```
+
+> **Note:** `rsync --delete` is incremental — fast after the first sync. Re-run any time
+> sessions have expired. The Keychain entry (`Chrome Safe Storage`) is shared, so
+> encrypted cookies still decrypt correctly from the copied profile.
+
+---
+
+## Launch with remote debugging
+
+```bash
+CHROME=$(find /Applications ~/Applications -name "Google Chrome" -path "*/MacOS/Google Chrome" 2>/dev/null | head -1)
+DEBUG_DIR="$HOME/Library/Application Support/Google/ChromeDebug"
+
+killall "Google Chrome" 2>/dev/null; sleep 1
+"$CHROME" --remote-debugging-port=9222 --user-data-dir="$DEBUG_DIR" &
+```
+
+**One-time alias** — add to `~/.zshrc`:
+```bash
+# Usage: chrome-debug [ProfileDir]   e.g. chrome-debug "Profile 1"
+chrome-debug() {
+  local PROFILE="${1:-Default}"
+  local REAL="$HOME/Library/Application Support/Google/Chrome/$PROFILE"
+  local DEBUG_DIR="$HOME/Library/Application Support/Google/ChromeDebug"
+  local CHROME=$(find /Applications ~/Applications -name "Google Chrome" -path "*/MacOS/Google Chrome" 2>/dev/null | head -1)
+  echo "Syncing profile: $PROFILE → $DEBUG_DIR"
+  mkdir -p "$DEBUG_DIR"
+  rsync -a --delete "$REAL/" "$DEBUG_DIR/Default/"
+  killall "Google Chrome" 2>/dev/null; sleep 1
+  "$CHROME" --remote-debugging-port=9222 --user-data-dir="$DEBUG_DIR" &
+  echo "Chrome launching with debug profile (port 9222)..."
+}
+```
+
+Then run (using current/default profile):
+```bash
+chrome-debug
+```
+
+Or pick a specific profile:
+```bash
+chrome-debug "Profile 1"
+```
+
+---
+
+## Verify
+
+```bash
+curl -s http://localhost:9222/json/version
+```
+
+Should return something like:
+```json
+{
+  "Browser": "Chrome/124.0.0.0",
+  "webSocketDebuggerUrl": "ws://localhost:9222/devtools/browser/..."
+}
+```
+
+---
+
+## Prerequisites
+
+- **Node.js 21+** — required for built-in WebSocket support
+
+## Usage
+
+```bash
+node ../scripts/browser-capture.mjs "<url>" [timeout_ms] [--vars var1,var2,...]
+```
+
+- Default timeout: 15 000ms
+- Script opens a new tab in your Chrome debug profile (inherits its cookies/auth), navigates to the URL, waits for network to settle, then returns logs as JSON
+- The tab is automatically closed after capture
+
+---
+
+## Troubleshooting
+
+**`DevTools remote debugging requires a non-default data directory`**
+→ Chrome blocks debugging on the default profile. Follow the one-time setup above to
+create `~/Library/Application Support/Google/ChromeDebug`.
+
+**Connection refused / port still closed**
+→ `open -na` silently reuses the existing Chrome process. Use the binary path approach above.
+
+**Cookies expired / not logged in after copying profile**
+→ Re-run the profile copy command to refresh it from your real profile.
+
+**`Node.js 21+ required` error**
+→ Upgrade Node.js: `nvm install 21 && nvm use 21` (or install from nodejs.org).
+
+**`PUT /json/new` fails (older Chrome)**
+→ Try downgrading to Node's `fetch` with `GET /json/new` — edit the `fetch(..., { method: 'PUT' })` line in `browser-capture.mjs` to remove the method option (defaults to GET).
+
+**Page loads but no logs captured**
+→ The page may have errored before CDP attached. Try increasing timeout, or check if the error only triggers on user interaction.
diff --git a/apps/runtime-demo/skills/mf/reference/browser-debug/single-capture.md b/apps/runtime-demo/skills/mf/reference/browser-debug/single-capture.md
new file mode 100644
index 00000000000..ac5cc34eb51
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/browser-debug/single-capture.md
@@ -0,0 +1,91 @@
+# Single Capture
+
+Navigate to a URL, collect logs + variables, tab auto-closes.
+
+## Usage
+
+```bash
+node ../scripts/browser-capture.mjs "<url>" [timeout_ms] [--vars var1,var2,...] [--wait-until auto|domcontentloaded|networkidle|timeout] [--action-wait auto|networkidle|domcontentloaded|timeout|none] [--no-entries]
+```
+
+Default `auto`:
+- Navigation phase prefers `domcontentloaded` (interaction/variable capture scenarios); pure log collection falls back to `networkidle`
+- When not explicitly specified, `networkidle` uses a shorter wait ceiling to avoid being slowed down by polling-heavy pages
+
+Increase timeout for slow pages or heavy SPAs:
+```bash
+node ../scripts/browser-capture.mjs "https://example.com/dashboard" 30000
+```
+
+Capture JavaScript variables:
+```bash
+node ../scripts/browser-capture.mjs "https://example.com" 20000 --vars __FEDERATION__,__NEXT_DATA__,featureFlags
+```
+
+Capture deep path variables:
+```bash
+node ../scripts/browser-capture.mjs "https://example.com" 20000 --vars __VMOK__.__INSTANCES__,window.__APP_STATE__.user
+```
+
+Performance-first capture (skip heavy entries and avoid long waits):
+```bash
+node ../scripts/browser-capture.mjs "https://example.com" 12000 --vars __VMOK__.__INSTANCES__ --action-wait none --no-entries
+```
+
+## Output format
+
+```json
+{
+  "url": "https://example.com/dashboard",
+  "capturedAt": "2026-03-20T10:00:05.123Z",
+  "actionWait": "networkidle",
+  "timings": {
+    "navigateMs": 1832,
+    "clickMs": null,
+    "fillMs": null,
+    "selectMs": null,
+    "evalMs": null,
+    "varsMs": 42,
+    "totalMs": 2051
+  },
+  "total": 42,
+  "errors": 3,
+  "warns": 5,
+  "variables": {
+    "__FEDERATION__": {
+      "exists": true,
+      "value": { "runtime": "webpack" },
+      "skippedPaths": [
+        { "path": "__FEDERATION__.snapshotHandler.HostInstance", "reason": "circular", "circularRef": "__FEDERATION__.snapshotHandler" },
+        { "path": "__FEDERATION__.moduleCache.init", "reason": "function", "detail": "init" }
+      ]
+    },
+    "__NEXT_DATA__": { "exists": false, "skippedPaths": [] }
+  },
+  "entries": [
+    { "t": "2026-03-20T10:00:01.234Z", "level": "error", "msg": "Cannot read properties of undefined (reading 'user')", "stack": "https://example.com/assets/app.js:1:84231" },
+    { "t": "2026-03-20T10:00:02.100Z", "level": "warn",  "msg": "[HTTP] 404 Not Found — https://api.example.com/user/profile", "stack": null }
+  ]
+}
+```
+
+## Performance tips
+
+- When only checking variables, add `--no-entries` to avoid excessive log volume.
+- When a stable selector is available, prefer an exact CSS selector to reduce click retries.
+
+## Log levels captured
+
+- `error` / `warn` / `log` / `info` / `debug` — from `console.*`
+- `error` — uncaught JS exceptions (includes stack trace when available)
+- `warn` / `error` — HTTP 4xx / 5xx responses
+- `error` — network failures (CORS, DNS, connection refused)
+- `warn` / `error` — browser-native entries (CSP violations, deprecations)
+
+## Variable serialization
+
+Non-serializable values are handled gracefully:
+- Circular references → `[Circular -> path]`
+- Functions → `[Function: name]`
+- Depth > 5 → `[max depth]`
+- `skippedPaths` records every property that could not be fully serialized
diff --git a/apps/runtime-demo/skills/mf/reference/config-check.md b/apps/runtime-demo/skills/mf/reference/config-check.md
new file mode 100644
index 00000000000..b8d84f13a84
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/config-check.md
@@ -0,0 +1,49 @@
+# Sub-skill: config-check
+
+Check Module Federation build configuration: verify correct MF plugin for the bundler, async entry configuration, exposes key format, and exposes path existence.
+
+## Step 1: Collect MFContext
+
+Read and follow the instructions in `./context.md`, passing ARGS as the project root.
+
+## Step 2: Run config check script
+
+Serialize MFContext to JSON and pass it to the check script:
+
+```bash
+node scripts/config-exposes-check.js --context '<MFContext-JSON>'
+```
+
+Process each item in the output `results` array:
+
+**CONFIG-PLUGIN · warning — incorrect or missing MF plugin**
+- Based on the detected bundler and installed packages, the recommended plugin is:
+  - Webpack only: `@module-federation/enhanced` or `@module-federation/enhanced/webpack`
+  - Rspack only: `@module-federation/enhanced/rspack` (recommended) or `@module-federation/rspack`
+  - Rsbuild: `@module-federation/rsbuild-plugin` (recommended), or the Rspack plugin
+  - Modern.js: `@module-federation/modern-js-v3` for `@modern-js/app-tools` ≥ 3.0.0, otherwise `@module-federation/modern-js`; falls back to Rspack/Webpack plugin based on the underlying bundler
+  - Next.js: `@module-federation/nextjs-mf`
+- Show the detected bundler, installed MF-related packages, and the recommended plugin
+
+**CONFIG-ASYNC-ENTRY · warning — async entry not configured (maps to RUNTIME-006)**
+- `experiments.asyncStartup = true` is not set in the bundler config
+- This setting is required by most bundler setups to avoid runtime initialization errors
+- Exception: not required when using `@module-federation/modern-js-v3` or `@module-federation/modern-js`
+- Note: Rspack requires version > 1.7.4 to support this option
+- Reference: https://module-federation.io/blog/hoisted-runtime.md
+- To check: read `bundler.configFile` from MFContext and look for `experiments.asyncStartup`
+
+**CONFIG-EXPOSES-KEY · warning — key does not start with `./`**
+- MF spec requires exposes keys to start with `./` (e.g., `"./Button"` not `"Button"`)
+- Inform the user of the specific key name and guide them to correct the format
+
+**CONFIG-EXPOSES-PATH · warning — path does not exist**
+- The file referenced by the exposes value does not exist in the project. Show the specific key and incorrect path.
+- The check must match the exact file extension (e.g., `.tsx` ≠ `.ts`)
+- Common causes:
+  1. Typo in file path
+  2. Wrong file extension
+  3. Incorrect relative path base (should be relative to project root)
+
+**When results is empty**
+- Inform the user that plugin selection, async entry config, and exposes passed all checks
diff --git a/apps/runtime-demo/skills/mf/reference/context.md b/apps/runtime-demo/skills/mf/reference/context.md
new file mode 100644
index 00000000000..eb72189f6e5
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/context.md
@@ -0,0 +1,67 @@
+# Sub-skill: context
+
+Collect the current project's Module Federation context (MFContext) from `ARGS` (defaults to the current working directory if empty), then output the aggregated summary.
+
+## 1. Basic Info
+
+Read `{projectRoot}/package.json` and extract:
+- `name`: project name
+- Merge `dependencies` + `devDependencies` into a full dependency map
+
+Detect the package manager (check files in order):
+- `pnpm-lock.yaml` → pnpm
+- `yarn.lock` → yarn
+- `package-lock.json` → npm
+
+## 2. Bundler & MF Config
+
+Find config files in the following priority order (`.ts` / `.mts` take precedence over `.js` / `.mjs` / `.cjs`):
+
+| Priority | Filename |
+|---|---|
+| 1 | `module-federation.config.{ts,mts,js,mjs,cjs}` |
+| 2 | `rsbuild.config.{ts,mts,js,mjs,cjs}` |
+| 3 | `rspack.config.{ts,mts,js,mjs,cjs}` |
+| 4 | `modern.config.{ts,mts,js,mjs,cjs}` |
+| 5 | `next.config.{ts,mts,js,mjs,cjs}` |
+| 6 | `webpack.config.{ts,js}` |
+
+Read the first matched file and extract the `remotes`, `exposes`, and `shared` fields. Determine the bundler from the filename (`rspack` / `rsbuild` / `webpack`).
+
+## 3. Determine MF Role
+
+| Condition | Role |
+|---|---|
+| Has `remotes` and `exposes` | `host+remote` |
+| Only `remotes` | `host` |
+| Only `exposes` | `remote` |
+| Neither | `unknown` |
+
+## 4. Recent Error Event (optional)
+
+Check if `.mf/observability/latest.json` exists; if so, read its contents.
+
+## 5. Build Artifacts (optional)
+
+Check if `dist/mf-manifest.json` and `dist/mf-stats.json` exist; if so, read them.
+
+---
+
+Aggregate the above information and output the MFContext summary in the following structure:
+
+```
+project:
+  name, packageManager, mfRole
+
+bundler:
+  name, configFile
+
+mfConfig:
+  remotes, exposes, shared
+
+dependencies:
+  (list installed packages related to MF and their versions)
+
+latestErrorEvent: (if present)
+buildArtifacts:   (if present)
+```
diff --git a/apps/runtime-demo/skills/mf/reference/docs.md b/apps/runtime-demo/skills/mf/reference/docs.md
new file mode 100644
index 00000000000..afd7cda4e50
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/docs.md
@@ -0,0 +1,66 @@
+# Sub-skill: docs
+
+Answer Module Federation questions by fetching only the relevant documentation pages — not the entire docs.
+
+Requires internet access to fetch documentation from module-federation.io.
+
+## Step 1: Fetch the documentation index
+
+```
+https://module-federation.io/llms.txt
+```
+
+The index is in this format:
+
+```
+## Section Name
+- [Page Title](/path/to/page.md): brief description of the page content
+```
+
+## Step 2: Identify the relevant page(s)
+
+Read the page descriptions in the index and select the 1–3 pages most relevant to the user's question. Use the quick topic map below to narrow down candidates before reading descriptions.
+
+**Quick topic map:**
+
+| User asks about | Look in section |
+|---|---|
+| What is MF / concepts / glossary / getting started | `Guide` → `start/` |
+| CLI, CSS isolation, type hints, data fetching, prefetch | `Guide` → `basic/` |
+| Runtime API, `loadRemote`, MF instance, runtime hooks | `Guide` → `runtime/` |
+| Build plugin setup for Webpack / Rspack / Rsbuild / Vite / Metro | `Guide` → `build-plugins/` |
+| Next.js / Modern.js / Angular / React integration | `Guide` → `framework/` or `Practice` → `frameworks/` |
+| React Bridge / Vue Bridge / cross-framework rendering | `Practice` → `bridge/` |
+| `name`, `filename`, `exposes`, `remotes`, `shared`, `dts`, `manifest`, `shareStrategy` | `Configuration` |
+| Runtime plugins, retry plugin, custom plugin | `Plugins` |
+| Performance, tree shaking, shared scopes | `Guide` → `performance/` or `Guide` → `advanced/` |
+| Debug mode, Chrome DevTool, global variables | `Guide` → `debug/` |
+| Error messages, build errors, type errors | `Guide` → `troubleshooting/` |
+| Monorepo, Nx | `Practice` → `monorepos/` |
+| Deployment, Zephyr | `Guide` → `deployment/` |
+
+## Step 3: Fetch the specific page(s)
+
+Construct the URL by removing the `.md` extension from the path in the index, then prepend the base URL:
+
+```
+https://module-federation.io{path_without_md_extension}
+```
+
+**Examples:**
+- `/guide/start/index.md` → `https://module-federation.io/guide/start/index`
+- `/configure/shared.md` → `https://module-federation.io/configure/shared`
+- `/guide/runtime/runtime-api.md` → `https://module-federation.io/guide/runtime/runtime-api`
+
+Fetch the page(s) and read the content.
+
+## Step 4: Answer the question
+
+Answer based on the fetched content. If the answer spans multiple pages (e.g., config + runtime), fetch both. Do not load more than 3 pages per question.
+
+## Important notes
+
+- Always fetch the index first — never guess page paths from memory
+- If the index descriptions are insufficient to identify the right page, fetch the most likely candidate and check its content
+- The docs cover MF 2.0 (`@module-federation/enhanced`) — this is different from the older Webpack 5 built-in Module Federation
+- Next.js support is deprecated; inform the user if they ask about it
diff --git a/apps/runtime-demo/skills/mf/reference/integrate.md b/apps/runtime-demo/skills/mf/reference/integrate.md
new file mode 100644
index 00000000000..cf24b6a5a0a
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/integrate.md
@@ -0,0 +1,422 @@
+# Sub-skill: integrate
+
+Integrate Module Federation into an existing project — add provider (exposes modules) or consumer (loads remote modules) configuration.
+
+## Step 1: Detect project
+
+Collect MFContext by reading and following the instructions in `./context.md`, passing ARGS as the project root.
+
+If no bundler can be detected (no `rsbuild.config`, `rspack.config`, `webpack.config`, `modern.config`, `next.config`, `vite.config` found), this is likely a new project. Tell the user:
+
+> This looks like a new project. Run the following command to scaffold a full Module Federation project:
+>
+> ```bash
+> npm create module-federation@latest
+> ```
+
+Then stop.
+
+If MF is already configured (MFContext shows existing `remotes` or `exposes`), inform the user what is already configured and ask if they want to add/modify the configuration or stop.
+
+---
+
+## Step 2: Gather parameters
+
+Ask the user the following questions (combine into one AskUserQuestion call):
+
+1. **Role** — What role should this app play?
+   - `consumer` — loads modules from remote apps (default)
+   - `provider` — exposes modules to other apps
+   - `both` — exposes modules and loads remote modules
+
+2. **App name** — What should the MF name be for this app?
+   - Suggest the `name` field from `package.json` (snake_case, no hyphens). Hyphens are not allowed in MF names.
+
+3. **Role-specific**:
+   - If **consumer** or **both**: Do you want to connect to the public demo provider to see MF working immediately, or configure your own remotes?
+     - `demo` — use the public demo provider (default for consumers)
+     - `custom` — I'll specify my own remote URLs
+   - If **provider** or **both**: What module(s) do you want to expose? Provide `key: path` pairs, e.g. `./Button: ./src/components/Button.tsx`. If unsure, use `'.' : './src/index'` as a default.
+
+---
+
+## Step 3: Build the MF config object
+
+Construct the MF config based on the gathered parameters:
+
+### Remote entries (for consumer / both)
+
+**Demo provider** (use when user chose `demo`):
+```ts
+remotes: {
+  'provider': 'rslib_provider@https://unpkg.com/module-federation-rslib-provider@latest/dist/mf/mf-manifest.json',
+},
+```
+
+The demo provider exposes a React component at `'provider'`. The user can import it in their app:
+```tsx
+import ProviderApp from 'provider';
+```
+
+**Custom remotes** (use when user chose `custom`):
+Ask the user to provide remote entries in the format `name: url`, then use them as-is.
+
+### Exposes (for provider / both)
+
+Use the entries provided by the user. Example:
+```ts
+exposes: {
+  './Button': './src/components/Button.tsx',
+},
+```
+
+### Shared deps
+
+Read `package.json` to check which frameworks are present. Set singletons accordingly:
+- If `react` + `react-dom` present: add both as `{ singleton: true }`
+- If `vue` present: add as `{ singleton: true }`
+- If both (rare): add all as singletons
+
+---
+
+## Step 4: Generate files
+
+Apply the correct pattern for the detected bundler:
+
+---
+
+### Rsbuild
+
+**Detected by**: `rsbuild.config.ts` / `rsbuild.config.js` in project root.
+
+#### 4a. Create `module-federation.config.ts`
+
+```ts
+import { createModuleFederationConfig } from '@module-federation/rsbuild-plugin';
+
+export default createModuleFederationConfig({
+  name: '<app-name>',
+  // exposes: { ... },        // provider / both only
+  // remotes: { ... },        // consumer / both only
+  shareStrategy: 'loaded-first',
+  shared: {
+    // react + react-dom or vue — from Step 3
+  },
+});
+```
+
+#### 4b. Modify `rsbuild.config.ts`
+
+```diff
++import { pluginModuleFederation } from '@module-federation/rsbuild-plugin';
++import moduleFederationConfig from './module-federation.config';
+
+ export default defineConfig({
+   plugins: [
+     pluginReact(),
++    pluginModuleFederation(moduleFederationConfig),
+   ],
+ });
+```
+
+#### 4c. Install
+
+```bash
+pnpm add @module-federation/rsbuild-plugin
+```
+
+---
+
+### Modern.js
+
+**Detected by**: `modern.config.ts` / `modern.config.js` in project root.
+
+#### 4a. Create `module-federation.config.ts`
+
+```ts
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+
+export default createModuleFederationConfig({
+  name: '<app-name>',
+  // exposes: { ... },        // provider / both only
+  // remotes: { ... },        // consumer / both only
+  shared: {
+    // react + react-dom or vue — from Step 3
+  },
+});
+```
+
+#### 4b. Modify `modern.config.ts`
+
+```diff
++import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+
+ export default defineConfig({
+   plugins: [
+     appTools(),
++    moduleFederationPlugin(),
+   ],
+ });
+```
+
+#### 4c. For consumer: add type paths
+
+Modify `tsconfig.json` to resolve remote types:
+
+```diff
+ {
+   "compilerOptions": {
++    "paths": {
++      "*": ["./@mf-types/*"]
++    }
+   }
+ }
+```
+
+#### 4d. Install
+
+```bash
+pnpm add @module-federation/modern-js-v3
+```
+
+---
+
+### Rspack
+
+**Detected by**: `rspack.config.ts` / `rspack.config.js` in project root.
+
+#### 4a. Modify `rspack.config.ts` / `rspack.config.js`
+
+```diff
++const { ModuleFederationPlugin } = require('@module-federation/enhanced/rspack');
+
+ module.exports = {
++  experiments: {
++    asyncStartup: true,
++  },
+   plugins: [
++    new ModuleFederationPlugin({
++      name: '<app-name>',
++      // exposes: { ... },   // provider / both only
++      // remotes: { ... },   // consumer / both only
++      shared: {
++        // from Step 3
++      },
++    }),
+   ],
+ };
+```
+
+> Note: `experiments.asyncStartup` requires Rspack > 1.7.4.
+
+#### 4b. Install
+
+```bash
+pnpm add @module-federation/enhanced
+```
+
+---
+
+### Webpack
+
+**Detected by**: `webpack.config.ts` / `webpack.config.js` in project root.
+
+#### 4a. Modify `webpack.config.js`
+
+```diff
++const { ModuleFederationPlugin } = require('@module-federation/enhanced/webpack');
+
+ module.exports = {
++  experiments: {
++    asyncStartup: true,
++  },
+   plugins: [
++    new ModuleFederationPlugin({
++      name: '<app-name>',
++      filename: 'remoteEntry.js',
++      // exposes: { ... },   // provider / both only
++      // remotes: { ... },   // consumer / both only
++      shared: {
++        // from Step 3
++      },
++    }),
+   ],
+ };
+```
+
+#### 4b. Install
+
+```bash
+pnpm add @module-federation/enhanced
+```
+
+---
+
+### Next.js
+
+**Detected by**: `next.config.ts` / `next.config.mjs` / `next.config.js` in project root.
+
+> **Deprecation warning**: `@module-federation/nextjs-mf` only supports Pages Router (not App Router) and is no longer actively maintained. For new projects, consider using Rsbuild or Modern.js instead.
+
+#### 4a. Modify `next.config.mjs`
+
+```diff
++import { NextFederationPlugin } from '@module-federation/nextjs-mf';
+
+ const nextConfig = {
+   webpack(config, options) {
++    config.plugins.push(
++      new NextFederationPlugin({
++        name: '<app-name>',
++        filename: 'static/chunks/remoteEntry.js',
++        // exposes: { ... },   // provider / both only
++        // remotes: {          // consumer / both only
++        //   remote: `remote@http://localhost:3001/static/${options.isServer ? 'ssr' : 'chunks'}/remoteEntry.js`,
++        // },
++        shared: {},
++        extraOptions: {
++          exposePages: true,
++          enableImageLoaderFix: true,
++          enableUrlLoaderFix: true,
++        },
++      })
++    );
+     return config;
+   },
+ };
+```
+
+#### 4b. Enable local Webpack
+
+Add to `.env.local`:
+```
+NEXT_PRIVATE_LOCAL_WEBPACK=true
+```
+
+#### 4c. Install
+
+```bash
+pnpm add @module-federation/nextjs-mf webpack -D
+```
+
+---
+
+### Vite
+
+**Detected by**: `vite.config.ts` / `vite.config.js` in project root.
+
+#### 4a. Modify `vite.config.ts`
+
+```diff
++import { federation } from '@module-federation/vite';
+
+ export default defineConfig({
+   plugins: [
++    federation({
++      name: '<app-name>',
++      // exposes: { ... },   // provider / both only
++      // remotes: { ... },   // consumer / both only
++      shared: {
++        // from Step 3
++      },
++    }),
+   ],
+ });
+```
+
+#### 4b. Install
+
+```bash
+pnpm add @module-federation/vite
+```
+
+---
+
+## Step 5: Auto-insert remote component (consumer / both only)
+
+Skip this step entirely for provider-only role.
+
+Ask the user:
+
+> Do you want me to automatically add the remote component to your app's entry so you can see it working right away?
+
+If the user says **no**, just show the code snippet as a reference and move on to Step 6.
+
+If the user says **yes**:
+
+### 5a. Locate the entry file
+
+Search for the entry component file in this priority order:
+
+| Bundler | Candidates (in order) |
+|---|---|
+| Rsbuild | `src/App.tsx`, `src/App.jsx`, `src/App.js` |
+| Modern.js | `src/routes/page.tsx`, `src/routes/page.jsx` |
+| Webpack / Rspack | `src/App.tsx`, `src/App.jsx`, `src/App.js`, `src/index.tsx`, `src/index.jsx` |
+| Next.js | `pages/index.tsx`, `pages/index.jsx`, `pages/index.js` |
+| Vite | `src/App.tsx`, `src/App.jsx`, `src/App.js` |
+
+Read the first file that exists. If none found, tell the user which file to modify manually and show the snippet — do not attempt blind writes.
+
+### 5b. Determine remote name and import path
+
+Use the remote name from the config generated in Step 4:
+- If demo provider: remote name is `provider`, import path is `'provider'`
+- If custom remotes: use the first remote name the user specified
+
+### 5c. Edit the entry file
+
+Add the import at the top of the file (after existing imports) and render the component inside the existing JSX return.
+
+**For React (Rsbuild / Rspack / Webpack / Vite)**
+
+Add import after the last existing import line:
+```tsx
+import ProviderApp from 'provider';
+```
+
+Insert `<ProviderApp />` inside the existing JSX return. Find a natural place — inside a `<div>`, after existing content. Do not restructure the component; just append the element.
+
+**For Modern.js** (`src/routes/page.tsx`)
+
+Same pattern — add import and render `<ProviderApp />` in the returned JSX.
+
+**For Next.js** (`pages/index.tsx`)
+
+Same pattern — add import and render `<ProviderApp />` in the returned JSX.
+
+### 5d. Add TypeScript declaration (if TypeScript project)
+
+Check if `tsconfig.json` exists. If it does, create `src/remote.d.ts` (or add to an existing `src/declarations.d.ts` / `src/env.d.ts` if present):
+
+```ts
+declare module '<remote-name>' {
+  const Component: React.ComponentType;
+  export default Component;
+}
+```
+
+Replace `<remote-name>` with the actual remote name (e.g., `provider`).
+
+### Provider: how to verify the exposed module
+
+Tell the user that after running the dev server, the manifest will be available at:
+- Rsbuild / Rspack / Webpack / Modern.js: `http://localhost:<port>/mf-manifest.json`
+- Next.js: `http://localhost:<port>/static/chunks/remoteEntry.js`
+
+Another app can reference this app as a remote using:
+```ts
+remotes: {
+  '<app-name>': '<app-name>@http://localhost:<port>/mf-manifest.json',
+},
+```
+
+---
+
+## Step 6: Summary
+
+Output a concise summary:
+- What files were created or modified
+- What packages were installed
+- How to start the dev server (use existing script from `package.json`)
+- Next steps (e.g., add more remotes, configure shared deps, set up type generation)
diff --git a/apps/runtime-demo/skills/mf/reference/module-info.md b/apps/runtime-demo/skills/mf/reference/module-info.md
new file mode 100644
index 00000000000..0f5bad0bd2e
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/module-info.md
@@ -0,0 +1,50 @@
+# Sub-skill: module-info
+
+Fetch metadata and manifest info for a remote Module Federation module — publicPath, remoteEntry, type file URLs, and the module's remotes/exposes/shared from its mf-manifest.json.
+
+Two modes:
+1. **Consumer mode** — inside a consumer project; pass only the remote name; entry URL is resolved from mfConfig.remotes
+2. **Standalone mode** — outside a consumer project; pass the remote name plus its remoteEntry URL directly
+
+## Step 1: Parse ARGS
+
+- First token → `<module-name>`
+- If a second token looks like a URL (starts with `http`) → `<remoteEntry-url>` (standalone mode); remaining tokens → `[project-root]`
+- Otherwise → `[project-root]` (consumer mode)
+
+## Step 2a — Consumer mode (no URL provided)
+
+Collect MFContext by reading and following the instructions in `./context.md`, passing `[project-root]` as the project root.
+
+Then run:
+
+```bash
+node scripts/module-info.js --context '<MFContext-JSON>' --module '<module-name>'
+```
+
+## Step 2b — Standalone mode (URL provided)
+
+Run with an empty context and the explicit URL:
+
+```bash
+node scripts/module-info.js --context '{}' --module '<module-name>' --url '<remoteEntry-url>'
+```
+
+## Step 3: Present the result
+
+| Field | Description |
+|---|---|
+| `publicPath` | Base URL of the remote |
+| `remoteEntry` | Full URL to `remoteEntry.js` |
+| `typesZip` | URL to `@mf-types.zip` |
+| `typesApi` | URL to `@mf-types.api` (shown only if present) |
+| `hasSsr` | Whether SSR build artifacts were detected |
+| `exposes` | Modules this remote exposes |
+| `remotes` | Remotes this module depends on |
+| `shared` | Shared dependencies declared by this module |
+
+If `result.error` is set, surface it directly and stop.
+
+## Step 4 (conditional)
+
+If the user explicitly asks to see the type declarations (e.g. "show me the types", "what types does it export"), fetch `result.typesZip` or `result.typesApi` and display the relevant type definitions.
diff --git a/apps/runtime-demo/skills/mf/reference/observability.md b/apps/runtime-demo/skills/mf/reference/observability.md
new file mode 100644
index 00000000000..4f1975ee937
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/observability.md
@@ -0,0 +1,379 @@
+# Sub-skill: observability
+
+Diagnose Module Federation loading reports produced by
+`@module-federation/observability-plugin`.
+
+Use this sub-skill when the user provides or mentions:
+
+- an observability `traceId`
+- a console line containing `Observability report generated`
+- a Module Federation `console.error` observability hint
+- a `read:` command
+- `.mf/observability/latest.json`
+- `.mf/observability/events.jsonl`
+- `.mf/observability/build-info.json`
+- `.mf/observability/build-report.json`
+- a request to observe, debug, trace, inspect, or upload Module Federation
+  loading data
+- production telemetry hooks such as `onReport` or `onEvent`
+- a report field such as `diagnosis`, `summary.phases`, `ownerHint`, or
+  `moduleInfo`
+
+## Runtime codes and plugin reports
+
+Runtime error codes are still the stable first signal. The observability plugin
+does not replace `RUNTIME-xxx`; it enriches the code with phase, moduleInfo,
+shared, and timeline evidence. Build evidence is written separately by the
+build observability plugin.
+
+`@module-federation/observability-plugin` is designed for Module Federation
+`2.5.0` and later. When recommending this plugin, recommend upgrading MF to
+`2.5.0+` at the same time.
+
+If the user only provides a `RUNTIME-xxx` code and no observability report, do not
+claim that a scan or report was read. Use the official runtime troubleshooting
+docs for the code, then recommend enabling `ObservabilityPlugin` when the current
+evidence is too thin to identify the owner or exact phase.
+
+If the app is not upgraded or does not use `@module-federation/observability-plugin`,
+this skill still works in error-code mode: diagnose from the error code,
+console text, URL, network evidence, and runtime/build config. Only ask for an
+observability report when the plugin is actually enabled or the user can enable
+it.
+
+If the user only knows that MF failed, but has no observability report and no
+accurate `RUNTIME-xxx` code or actionable console/network evidence, ask whether
+they can follow the recommended path: upgrade Module Federation to `2.5.0+` and
+enable `@module-federation/observability-plugin` to collect a report with loading
+phase, owner, shared, and moduleInfo evidence. If build evidence is needed, ask
+for the separate `.mf/observability/build-info.json` or
+`.mf/observability/build-report.json` file.
+
+## Step 1: Get the report
+
+Prefer the most direct source available.
+
+### Browser
+
+If the console hint includes a `read:` line, execute that command exactly in the
+browser console context:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReport('mf-...');
+```
+
+If the user only has the latest browser report, use:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getLatestReport();
+```
+
+For recent or filtered browser reports, use:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  remote: 'remote1',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  expose: './Button',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  shared: 'react',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].exportReport('mf-...');
+```
+
+If the browser global is disabled, ask for the app's observability controller or
+for the full report output pasted by the user.
+
+If the browser console only contains `traceId` and `errorCode`, treat it as
+production-safe output. Do not assume the full report is globally readable. Ask
+for an explicit `exportReport(traceId)` output, the app observability controller
+output, or the user's uploaded observability record.
+
+### Node or SSR
+
+Read `.mf/observability/latest.json` first. Use `.mf/observability/events.jsonl`
+only if multiple traces or event ordering are needed.
+
+`latest.json` is the formatted latest complete report. `events.jsonl` is an
+append-only stream where each line is one runtime event with its own `traceId`,
+`timestamp`, `phase`, `status`, context, and error fields when present.
+
+### Build
+
+Read `.mf/observability/build-report.json` for build failures and
+`.mf/observability/build-info.json` for successful build facts.
+
+## Step 2: Read fields in the required order
+
+Do not start from `events`.
+
+Reports omit `undefined` fields. Treat an absent optional field as "not observed
+or not relevant" unless a specific failure guide says that field must be
+present.
+
+Read:
+
+1. `diagnosis.status`
+2. `diagnosis.title`
+3. `diagnosis.ownerHint`
+4. `diagnosis.errorCode`
+5. `diagnosis.facts`
+6. `diagnosis.actions`
+7. `summary.outcome`
+8. `summary.error`
+9. `summary.phases`
+10. `summary.flags`
+11. `summary.shared`
+12. `build`
+13. `moduleInfo`
+14. `events`
+
+## Step 3: Decide the likely owner
+
+Use `diagnosis.ownerHint` first:
+
+- `host`: inspect host remotes, request id, manifest URL, and runtime call.
+- `remote`: inspect producer exposes, remoteEntry type/global, and exposed module
+  execution.
+- `shared`: inspect host and remote shared config, selected provider, versions,
+  shareScope, singleton, strictVersion, and eager.
+- `network`: inspect URL reachability, CORS, status code, response body, timeout,
+  CDN, gateway, or proxy.
+- `build`: inspect build-report, bundler output, and observability output path.
+- `unknown`: use `summary.phases` to find the first missing/error phase, then
+  inspect `events`.
+
+## Step 4: Follow diagnosis actions
+
+Treat `diagnosis.actions` as the prioritized checklist. For each action:
+
+1. inspect the referenced config or runtime fact
+2. compare it with `diagnosis.facts`
+3. compare it with `.mf/observability/build-info.json` when build evidence is needed
+4. make the smallest code/config fix
+5. verify with the failing app or targeted test
+
+## Step 5: Use build evidence correctly
+
+Runtime reports do not have `summary.build`.
+
+Runtime reports also do not embed build facts. If build evidence is needed,
+read `.mf/observability/build-info.json` or `.mf/observability/build-report.json`
+as a separate file and compare it with the runtime report.
+
+`moduleInfo` appears only for snapshot/moduleInfo dependent failures. It is a
+clipped view of `__FEDERATION__.moduleInfo`, not a full dump. Use only:
+
+- `entries[].name`
+- `entries[].publicPath`
+- `entries[].getPublicPath`
+- `entries[].remoteEntry`
+- `entries[].globalName`
+- `totalCount`
+- `matchedCount`
+- `availableNames`
+
+Large fields such as `modules`, `shared`, and assets are intentionally removed.
+The `publicPath`, `getPublicPath`, and `remoteEntry` locator fields preserve
+query/hash data and are only length-limited because deployment platforms often
+use those values to route a module.
+
+Do not describe `moduleInfo.availableNames` as a component list, expose list, or
+prefetch list. It is the clipped list of deployment-provided moduleInfo remote
+candidate keys that were available when no entry matched the failed remote.
+
+## Step 6: Common paths
+
+### Manifest failure / `RUNTIME-003`
+
+Check:
+
+- `diagnosis.facts.url`
+- `summary.phases.manifest`
+- `build.host.remotes`
+
+Fix wrong manifest URL, HTML shell responses, CORS, gateway routing, or stale
+query/hash assumptions.
+
+### Invalid manifest / `RUNTIME-013`
+
+Definition:
+
+`RUNTIME-013` means the manifest URL returned JSON, but the JSON is not a valid
+Module Federation manifest. It is different from `RUNTIME-003`, which means the
+manifest could not be fetched or parsed.
+
+Check:
+
+- `diagnosis.facts.url`
+- `diagnosis.facts.errorCode`
+- `summary.phases.manifest`
+- `diagnosis.facts.hostName`
+- manifest fields such as `metaData`, `exposes`, and `shared`
+
+When explaining this failure, say that the manifest response is reachable but
+structurally invalid or incomplete. Do not describe it as a remoteEntry network
+failure unless the report also contains network evidence.
+
+Fix wrong JSON responses, gateway/deployment rewrites, missing producer manifest
+output, or stale/incomplete manifest files.
+
+### Remote not matched / `RUNTIME-004`
+
+Check:
+
+- `diagnosis.facts.requestId`
+- host remotes in `.mf/observability/build-info.json` when available
+
+Fix remote name, alias, or host remote declaration.
+
+### Snapshot / moduleInfo failure / `RUNTIME-007`
+
+Definition:
+
+`RUNTIME-007` means the runtime failed while resolving a snapshot/moduleInfo
+remote. It is not a remoteEntry network failure, not an expose lookup failure,
+and not a React/component render failure unless another report field explicitly
+shows those later phases.
+
+Check:
+
+- `requestId`
+- `remote.name`
+- `remote.alias`
+- `remote.version`
+- `diagnosis.errorCode`
+- `diagnosis.facts.moduleInfoMatchedCount`
+- `diagnosis.facts.moduleInfoNames`
+- `moduleInfo.entries`
+- `moduleInfo.availableNames`
+- `build.host.remotes`
+
+When explaining this failure, say that the runtime could not match the requested
+remote name/alias/version against deployment-provided `__FEDERATION__.moduleInfo`.
+Do not say "available component list" unless the report explicitly refers to
+remote exposes. This failure usually happens before the remote URL, remoteEntry,
+or exposed component can be loaded.
+
+The first cause sentence must include the literal term `moduleInfo`. Do not
+replace it with "loadable source list", "available source list", "component
+list", or any other paraphrase.
+
+Use this wording:
+
+- "The requested remote did not match any deployment-provided moduleInfo entry."
+- "Check whether the deployment/platform moduleInfo injection contains the
+  requested remote name, alias, or version key."
+- "The component has not been reached yet; the failure is in remote snapshot
+  resolution."
+
+Avoid this wording:
+
+- "The component is missing from the available component list."
+- "The prefetch list does not contain the component."
+- "The expose is missing."
+- "The React component failed to render."
+- "The remoteEntry request failed."
+
+Only mention source files or demo setup code after report evidence. In real
+projects, first inspect the deployment/platform plugin or runtime registration
+that injects `__FEDERATION__.moduleInfo`; do not jump directly to editing the
+business component.
+
+Exclude likely causes when the report only shows a snapshot/moduleInfo failure:
+
+- remoteEntry URL/network/CORS failure
+- remoteEntry execution failure
+- exposed module key missing
+- shared dependency version/provider/eager failure
+- business component render failure
+
+Fix missing deployment-provided `__FEDERATION__.moduleInfo`, mismatched remote
+name/alias keys, or missing `publicPath` / `getPublicPath` in the injected
+moduleInfo.
+
+### Expose not found / `RUNTIME-014`
+
+Definition:
+
+`RUNTIME-014` means the remote entry loaded and initialized, but the requested
+expose was not exported by that remote.
+
+Check:
+
+- `diagnosis.facts.requestId`
+- `diagnosis.facts.remoteName`
+- `diagnosis.facts.expose`
+- producer `exposes` config or manifest `exposes`
+
+When explaining this failure, say that remote loading reached the expose lookup
+phase. Do not call it a manifest fetch failure, moduleInfo match failure,
+remoteEntry network failure, or shared dependency failure unless another report
+field explicitly shows that evidence.
+
+Fix the consumer request id, producer expose name, `./` prefix, case mismatch,
+alias mismatch, or stale producer deployment.
+
+### Remote init failure / `RUNTIME-015`
+
+Definition:
+
+`RUNTIME-015` means the remote entry loaded, but the remote container failed
+during `init`.
+
+Check:
+
+- `diagnosis.facts.remoteName`
+- `diagnosis.facts.remoteEntry`
+- `diagnosis.facts.entryGlobalName`
+- `summary.phases.remoteEntry`
+- original error text in `diagnosis.errorMessage` or `summary.error.errorMessage`
+- shared facts and build-side shared config when available
+
+When explaining this failure, say that the remote entry was reached and failed
+while initializing. If the original error points to shared config, classify the
+likely owner as shared/host+remote config; otherwise inspect producer init
+logic.
+
+Fix shared provider/version/scope/eager config, remoteEntry type/global mismatch,
+or producer code that throws during container initialization.
+
+### Shared or eager failure / `RUNTIME-005` / `RUNTIME-006`
+
+Check:
+
+- `summary.shared`
+- shared config in `.mf/observability/build-info.json` when available
+- `summary.error.lifecycle`
+
+Fix provider availability, version range, shareScope, singleton/strictVersion,
+eager, or async boundary.
+
+### RemoteEntry failure / `RUNTIME-008`
+
+Check:
+
+- `diagnosis.facts.resourceErrorType`
+- `diagnosis.facts.url`
+- `summary.phases.remoteEntry`
+- `.mf/observability/build-info.json` remoteEntry facts when available
+
+If the type is network/timeout, fix URL, CORS, routing, server, or timeout. If
+the type is script execution, inspect the producer exception and fix the remote
+build. Retry does not fix script execution failures.
+
+## Step 7: Final response shape
+
+When reporting back, keep it concrete:
+
+1. what report source was used
+2. likely owner
+3. the key evidence
+4. what was changed or what should be changed
+5. how it was verified
+
+If the report is missing, ask for the console `traceId`, optional `read:` line,
+or `.mf/observability/latest.json`.
diff --git a/apps/runtime-demo/skills/mf/reference/perf.md b/apps/runtime-demo/skills/mf/reference/perf.md
new file mode 100644
index 00000000000..a9d28a4a10a
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/perf.md
@@ -0,0 +1,64 @@
+# Sub-skill: perf
+
+Check Module Federation local development performance configuration: detect whether recommended performance optimization options are enabled to alleviate slow HMR and slow build speed.
+
+## Step 1: Collect MFContext
+
+Read and follow the instructions in `./context.md`, passing ARGS as the project root.
+
+## Step 2: Run performance check script
+
+Serialize MFContext to JSON and pass it to the check script:
+
+```bash
+node scripts/performance-check.js --context '<MFContext-JSON>'
+```
+
+Provide recommendations for each item in the output `results` and `context.bundler.name`:
+
+**PERF · info — `dev.disableAssetsAnalyze`** (applies to all projects)
+- Disabling bundle size analysis during local development significantly improves HMR speed
+- Add to the Rsbuild config:
+  ```js
+  dev: { disableAssetsAnalyze: true }
+  ```
+
+**PERF · info — Rspack `splitChunks` optimization** (shown only when `bundler.name` is `rspack` or `rsbuild`)
+- Setting `splitChunks.chunks` to `"async"` reduces initial bundle size and speeds up first-screen loading
+- Add to the build config:
+  ```js
+  output: { splitChunks: { chunks: 'async' } }
+  ```
+
+**PERF · info — TypeScript DTS optimization** (shown only when `typescript` dependency is detected)
+- If type generation (DTS) is the main bottleneck, options include:
+  1. Temporarily disable DTS: set `dts: false` in the `@module-federation/enhanced` config
+  2. Switch to `ts-go` for significantly faster type generation
+
+## Step 3: ts-go migration (interactive)
+
+After presenting the DTS recommendation, ask the user:
+
+> "Would you like me to automatically try switching to `ts-go` and verify compatibility?"
+
+If the user confirms, execute the following steps in order:
+
+1. **Backup** — copy the current generated type output directory (e.g. `@mf-types/`) to a timestamped backup path such as `@mf-types.bak.<timestamp>/`
+
+2. **Configure** — set `dts.generateTypes.compilerInstance = "tsgo"` in the Module Federation config
+
+3. **Install** — install the required package using the project's package manager from MFContext:
+   ```bash
+   pnpm add @typescript/native-preview --save-dev
+   ```
+
+4. **Regenerate** — run:
+   ```bash
+   npx mf dts
+   ```
+
+5. **Verify** — diff the newly generated type output against the backup:
+   - If the output is **identical**: inform the user that `ts-go` is compatible and the switch is safe; offer to remove the backup
+   - If the output **differs**: revert the config change, restore the backup, and explain clearly what differs (e.g. missing declarations, changed signatures) so the user can decide whether the difference is acceptable
+
+Webpack projects do not show Rspack-specific entries to avoid irrelevant suggestions.
diff --git a/apps/runtime-demo/skills/mf/reference/runtime-error.md b/apps/runtime-demo/skills/mf/reference/runtime-error.md
new file mode 100644
index 00000000000..a9326319772
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/runtime-error.md
@@ -0,0 +1,165 @@
+# Sub-skill: runtime-error
+
+Diagnose explicit Module Federation runtime error codes.
+
+This sub-skill is only for users who already have a clear runtime error code such as `RUNTIME-001` or `RUNTIME-008`.
+
+If ARGS includes an observability report, `traceId`, console `read:` command, or
+`.mf/observability` file path, stop here and follow `./observability.md` instead.
+
+Runtime error codes remain useful even when the observability plugin is not
+enabled. Do not tell the user that diagnosis requires
+`@module-federation/observability-plugin`. Use the error code, console text,
+network evidence, and runtime/build config first. Recommend the observability
+plugin only as an optional way to collect richer evidence when the code alone is
+not enough. The observability plugin is designed for Module Federation `2.5.0+`;
+when recommending it, ask whether the user can upgrade MF to `2.5.0` or later
+and enable the plugin.
+
+If ARGS only says that Module Federation failed, but does not include an
+accurate runtime error code, observability report, useful console details, network
+evidence, or config evidence, ask the user whether they can follow the
+recommended path: upgrade to Module Federation `2.5.0+` and use
+`@module-federation/observability-plugin` to collect an actionable report.
+
+## Step 1: Parse the runtime code first
+
+Extract the runtime code from ARGS.
+
+- If the code is `RUNTIME-001` or `RUNTIME-008`, continue with this sub-skill
+- If the code is any other `RUNTIME-xxx`, do **not** continue local diagnosis here. Instead, read and follow `./docs.md` and look up the corresponding runtime error code in the official troubleshooting docs
+- If there is no clear runtime code, ask the user for the exact code before proceeding
+
+## Step 2: Special handling for `RUNTIME-001` and `RUNTIME-008`
+
+These two codes need special handling because in versions **before `2.3.0`**, some remote entry failures may be reported imprecisely:
+
+- some real `runtime-008` cases may appear as `runtime-001`
+- older versions may hide the original browser exception detail
+
+The goal is to confirm whether the real problem is:
+
+1. `ScriptNetworkError` — the remote entry could not be downloaded
+2. `ScriptExecutionError` — the remote entry downloaded, but threw during execution
+3. legacy hidden execution error — old versions reported it as `runtime-001` / vague `runtime-008` because the browser detail was hidden
+
+## Step 3: Prefer automatic browser capture
+
+Prefer using the built-in browser capture helper inside `mf` to capture browser evidence automatically before asking the user to paste logs manually.
+
+### 3a. Check whether Chrome remote debugging is available
+
+Run:
+
+```bash
+curl -s http://localhost:9222/json/version
+```
+
+- If reachable: continue with automatic capture
+- If not reachable: follow `./browser-debug/setup.md`
+
+### 3b. Capture the failing page
+
+Use `../scripts/browser-capture.mjs` against the failing page URL.
+
+Prefer this baseline command first:
+
+```bash
+node ../scripts/browser-capture.mjs "<failing-page-url>" 20000 --vars __FEDERATION__,__webpack_require__,window.__FEDERATION__
+```
+
+If the page is noisy or polling heavily, prefer:
+
+```bash
+node ../scripts/browser-capture.mjs "<failing-page-url>" 15000 --vars __FEDERATION__,window.__FEDERATION__ --no-entries
+```
+
+If the error only happens after user interaction, follow `./browser-debug/long-chain.md`.
+
+## Step 4: Fallback when auto capture is unavailable
+
+If automatic capture cannot be used, ask the user to provide:
+
+1. The exact browser console error text
+2. The failing `remoteEntry` or manifest URL
+3. Whether opening that URL directly in the browser returns the file successfully
+4. Whether the Network panel shows a failed request, and the status code
+5. Whether the console contains the original exception text (`TypeError`, `SyntaxError`, etc.)
+
+## Step 5: Classify the result for `001` / `008`
+
+### Case A — `ScriptNetworkError`
+
+Treat it as network-layer load failure when any of the following is true:
+
+- browser capture shows network failure, CORS failure, timeout, DNS failure, or 4xx/5xx
+- opening the remote entry URL directly fails
+- the manifest `publicPath` / `remoteEntry` points to the wrong address
+
+Then guide the user to check:
+
+1. whether the URL is correct
+2. whether the resource is externally reachable
+3. whether CORS is configured correctly
+4. whether CDN or gateway routing is broken
+
+### Case B — `ScriptExecutionError`
+
+Treat it as download succeeded but execution failed when:
+
+- the remote entry request succeeds
+- browser capture shows a JS exception during script execution
+- the error contains original exception details such as `TypeError` or `SyntaxError`
+
+Then guide the user to check:
+
+1. browser compatibility of the producer build target
+2. whether the producer entry relies on globals that are not initialized
+3. whether the build artifact is incomplete or corrupted
+4. the exact failing line from the browser exception
+
+Retries do not fix this case.
+
+### Case C — legacy hidden execution error
+
+Treat it as a likely hidden execution error when:
+
+- the remote entry request succeeded
+- `window[remoteEntryKey]` is missing after the script loads
+- the browser console does not show a useful exception, or only shows a vague old runtime code
+- the project version is before `2.3.0`, or the user explicitly says the message lacks detail
+
+Then explain:
+
+- this may be an old-version reporting limitation rather than a true "URL is wrong" problem
+- the real cause is often still a script execution failure, but the old runtime did not expose enough browser detail
+
+## Step 6: Recover more detail for legacy cases
+
+For the legacy hidden-execution case, follow the same documentation approach used for `RUNTIME-001`:
+
+1. add a runtime plugin with `createScript` that sets `crossOrigin = 'anonymous'`
+2. if preload is used, also set `crossorigin` in `createLink`
+3. ensure the producer serves proper `Access-Control-Allow-Origin`
+4. ensure producer build output sets `output.crossOriginLoading = 'anonymous'`
+
+Use this only after confirming the server already supports CORS. Otherwise the script may fail to load entirely.
+
+## Step 7: Final conclusion template
+
+At the end, clearly state:
+
+1. whether the issue is:
+   - `ScriptNetworkError`
+   - `ScriptExecutionError`
+   - legacy hidden execution error
+2. what concrete evidence supports the conclusion
+3. what the next fix should be
+4. that `2.3.0+` improves raw runtime error categories, and the recommended observability path is upgrading to **`2.5.0+`** and enabling `@module-federation/observability-plugin`
+
+## Required final reminder
+
+Always end with this recommendation in plain language:
+
+- older versions may report this kind of problem with incomplete or misleading runtime codes
+- upgrading to **`2.5.0+`** and enabling `@module-federation/observability-plugin` gives a fuller loading report when the raw error code is not enough
diff --git a/apps/runtime-demo/skills/mf/reference/shared-deps.md b/apps/runtime-demo/skills/mf/reference/shared-deps.md
new file mode 100644
index 00000000000..22d8b5b3ce6
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/shared-deps.md
@@ -0,0 +1,37 @@
+# Sub-skill: shared-deps
+
+Check Module Federation shared dependency configuration: detect shared/externals conflicts, antd/arco transformImport blocking shared deps, and multiple versions of the same shared package in build artifacts.
+
+## Step 1: Collect MFContext
+
+Read and follow the instructions in `./context.md`, passing ARGS as the project root.
+
+## Step 2: Run shared config check script
+
+Serialize MFContext to JSON and pass it to the check script:
+
+```bash
+node scripts/shared-config-check.js --context '<MFContext-JSON>'
+```
+
+Process each item in the output `results` array:
+
+**SHARED-EXTERNALS-CONFLICT · warning — same library in both `shared` and `externals`**
+- `shared` and `externals` are not mutually exclusive in config, but the same library must not appear in both — it causes the module to be excluded from the bundle while also being declared as shared, leading to runtime failures
+- Show the conflicting library name and guide the user to remove it from one of the two configs
+
+**SHARED-TRANSFORM-IMPORT · warning — antd/arco UI library shared but `transformImport` is active**
+- `babel-plugin-import` (or the built-in `transformImport` in Modern.js / Rsbuild) rewrites import paths at build time, which prevents the shared dep from being recognized and causes sharing to fail silently
+- Fix:
+  - Modern.js / Rsbuild: set `source.transformImport = false` to disable the built-in behavior
+  - Other bundlers: remove `babel-plugin-import` from the Babel config
+- Show which UI library triggered the warning
+
+**SHARED-MULTI-VERSION · warning — multiple versions of the same shared package detected**
+- The build artifacts contain more than one version of a shared package, meaning the version negotiation failed and both host and remote are each bundling their own copy
+- Recommended fix: add an `alias` in the bundler config so all projects resolve to the same physical file
+- Show the detected versions
+
+**When results is empty**
+- Inform the user that no shared dependency conflicts were detected in this project
+- Remind them that a complete picture requires running the same check in both the host and every remote
diff --git a/apps/runtime-demo/skills/mf/reference/type-check.md b/apps/runtime-demo/skills/mf/reference/type-check.md
new file mode 100644
index 00000000000..d7a7e011f53
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/reference/type-check.md
@@ -0,0 +1,87 @@
+# Sub-skill: type-check
+
+Diagnose Module Federation type issues across three categories:
+1. Producer type file generation failures (TYPE-001)
+2. Consumer failing to pull remote types
+3. tsconfig not configured to consume remote types
+
+## Step 1: Collect MFContext
+
+Read and follow the instructions in `./context.md`, passing ARGS as the project root.
+
+## Step 2: Run type check script
+
+Serialize MFContext to JSON and pass it to the check script:
+
+```bash
+node scripts/type-check.js --context '<MFContext-JSON>'
+```
+
+Process each item in the output `results` array and follow the action plan based on the `scenario` field:
+
+---
+
+### Scenario: `TYPE_GENERATION_FAILED` (Problem 1 — Producer type files not generated)
+
+The producer failed to generate type files (TYPE-001 error).
+
+**If `enhancedVersion` > `2.0.1`** (result field `canReadDiagnostics: true`):
+1. Read `.mf/observability/latest.json` to get full error info and the temporary TS config path
+2. Use the temp TS config path with `npx tsc --project <tmp-tsconfig>` to reproduce errors
+3. Fix the TS errors revealed. Refer to FAQ: https://module-federation.io/guide/troubleshooting/type.md
+4. Offer `"skipLibCheck": true` as a temporary workaround if errors are complex
+
+**If `enhancedVersion` <= `2.0.1`** (result field `canReadDiagnostics: false`):
+1. Ask the user to run `npx mf dts` and paste the terminal output (which includes the temp TS config path)
+2. Or ask them to copy the error message that contains the temp TS config path
+3. Once the temp TS config path is known, run `npx tsc --project <tmp-tsconfig>` to reproduce and fix errors
+4. Offer `"skipLibCheck": true` as a temporary workaround
+
+---
+
+### Scenario: `TYPES_NOT_PULLED` (Problem 2 — Consumer not pulling remote types)
+
+The `@mf-types` folder is missing. Remote types have not been downloaded.
+
+1. Read and follow `./module-info.md` with the remote module name to retrieve the type file URL (`@mf-types.zip`)
+   - If **no URL returned**: the producer has not configured the type file URL or has not generated types. Guide them to enable `dts` in the `@module-federation/enhanced` plugin config, then revisit **Problem 1**
+   - If **URL found**: attempt to fetch it (or ask the user to verify in browser)
+     - **URL inaccessible**: try fetching the `remoteEntry` URL
+       - `remoteEntry` **unreachable**: producer deployment is broken or URL is misconfigured; ask user to verify deployment
+       - `remoteEntry` **reachable**: type file generation failed or wasn't deployed; ask user to provide local producer path and proceed to **Problem 1**
+     - **URL accessible**: types were generated and deployed; the issue is in tsconfig — proceed to **Problem 3**
+
+---
+
+### Scenario: `TSCONFIG_PATHS_MISSING` (Problem 3 — tsconfig not configured for remote types)
+
+The `@mf-types` folder exists but TypeScript cannot find the types because `tsconfig.json` is missing the `paths` mapping.
+
+1. Open `tsconfig.json` and add the following to `compilerOptions.paths`:
+   ```json
+   {
+     "compilerOptions": {
+       "paths": {
+         "*": ["./@mf-types/*"]
+       }
+     }
+   }
+   ```
+2. If `paths` already exists, merge the new entry without overwriting existing mappings
+3. After updating, run `npx tsc --noEmit` to verify the type errors are resolved
+
+---
+
+### Scenario: `ENV_INCOMPLETE` (Missing tsconfig or TypeScript)
+
+**TYPE-001 · warning — `tsconfig.json` missing**
+- `tsconfig.json` not found in the project root
+- Advise the user to create `tsconfig.json` and configure producer type paths in `paths`
+
+**TYPE-001 · warning — `typescript` dependency missing**
+- `typescript` not installed in `dependencies` / `devDependencies`
+- Prompt the user to install: `pnpm add -D typescript`
+
+---
+
+> This sub-skill performs configuration and dependency-level checks. It runs `npx tsc` only when guided by a valid temp TS config path. It never runs `tsc` blindly against the entire project.
diff --git a/apps/runtime-demo/skills/mf/scripts/bridge-check.js b/apps/runtime-demo/skills/mf/scripts/bridge-check.js
new file mode 100644
index 00000000000..6dbdbe0ea53
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/bridge-check.js
@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+function main(ctx) {
+  const results = [];
+
+  if (ctx.mfConfig && ctx.mfConfig.exposes) {
+    const hasExportApp = Object.keys(ctx.mfConfig.exposes).some((k) =>
+      /export-app/i.test(k),
+    );
+    if (!hasExportApp) {
+      results.push({
+        code: 'BRIDGE-USAGE',
+        severity: 'info',
+        message:
+          'No obvious export-app export found in exposes. Please verify that the producer exports the app entry following the Bridge spec.',
+        context: { exposesKeys: Object.keys(ctx.mfConfig.exposes) },
+      });
+    }
+  }
+
+  results.push({
+    code: 'BRIDGE-USAGE',
+    severity: 'info',
+    message:
+      'On the consumer side, prefer using official APIs such as createRemoteAppComponent instead of directly concatenating remote URLs.',
+    context: {},
+  });
+
+  process.stdout.write(
+    `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+  );
+}
+
+const args = parseArgs(process.argv);
+main(JSON.parse(args.context));
diff --git a/apps/runtime-demo/skills/mf/scripts/browser-capture.mjs b/apps/runtime-demo/skills/mf/scripts/browser-capture.mjs
new file mode 100644
index 00000000000..54e44fc9a66
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/browser-capture.mjs
@@ -0,0 +1,897 @@
+#!/usr/bin/env node
+// capture.mjs — collect browser logs + JS variables via Chrome DevTools Protocol
+//
+// New tab:      node capture.mjs <url> [timeout_ms] [--vars v1,v2] [--keep-tab] [--click "text"] [--dump-dom] [--action-wait auto|networkidle|domcontentloaded|timeout|none] [--no-entries]
+// Existing tab: node capture.mjs --tab-id <id> [--click "text"] [--fill "ph::text"] [--select "ph::value"] [--vars v1,v2] [--dump-dom] [--close] [--action-wait auto|networkidle|domcontentloaded|timeout|none]
+//
+// Long-chain example:
+//   TAB=$(node capture.mjs https://example.com --keep-tab | jq -r .tabId)
+//   node capture.mjs --tab-id $TAB --click "个人"
+//   node capture.mjs --tab-id $TAB --fill "搜索框placeholder::关键词"
+//   node capture.mjs --tab-id $TAB --select "请选择::选项A"
+//   node capture.mjs --tab-id $TAB --click "添加" --vars __FEDERATION__ --close
+
+const CDP_BASE = 'http://localhost:9222';
+const IDLE_MS = 500;
+
+// ── argument parsing ──────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+function flagVal(flag) {
+  const i = args.indexOf(flag);
+  return i !== -1 ? args[i + 1] : null;
+}
+
+const tabId = flagVal('--tab-id');
+const clickTarget = flagVal('--click');
+const fillArg = flagVal('--fill'); // "placeholder::text"
+const selectArg = flagVal('--select'); // "placeholder::value"
+const varNamesRaw = flagVal('--vars');
+const varNames = varNamesRaw
+  ? varNamesRaw
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean)
+  : [];
+const evalExpr = flagVal('--eval');
+const keepTab = args.includes('--keep-tab');
+const closeTab = args.includes('--close');
+const dumpDom = args.includes('--dump-dom');
+const noEntriesFlag = args.includes('--no-entries');
+const entriesLimitRaw = flagVal('--entries-limit');
+const entriesLimit = entriesLimitRaw ? Number(entriesLimitRaw) : null;
+const waitUntilRaw = flagVal('--wait-until');
+const actionWaitRaw = flagVal('--action-wait');
+const hasWaitUntilFlag = waitUntilRaw != null;
+const hasActionWaitFlag = actionWaitRaw != null;
+
+const parsedWaitUntil =
+  waitUntilRaw === 'domcontentloaded' ||
+  waitUntilRaw === 'networkidle' ||
+  waitUntilRaw === 'timeout' ||
+  waitUntilRaw === 'auto'
+    ? waitUntilRaw
+    : null;
+const parsedActionWait =
+  actionWaitRaw === 'networkidle' ||
+  actionWaitRaw === 'domcontentloaded' ||
+  actionWaitRaw === 'timeout' ||
+  actionWaitRaw === 'none' ||
+  actionWaitRaw === 'auto'
+    ? actionWaitRaw
+    : null;
+
+const disableEarlyStop = args.includes('--disable-early-stop');
+const followNewTab = !args.includes('--no-follow-new-tab');
+
+// positional args: skip flag names and their values
+const flagsWithValues = new Set([
+  '--tab-id',
+  '--click',
+  '--fill',
+  '--select',
+  '--vars',
+  '--eval',
+  '--wait-until',
+  '--action-wait',
+  '--entries-limit',
+]);
+const skipIdx = new Set();
+args.forEach((a, i) => {
+  if (flagsWithValues.has(a)) {
+    skipIdx.add(i);
+    skipIdx.add(i + 1);
+  }
+});
+const positional = args.filter(
+  (a, i) => !a.startsWith('--') && !skipIdx.has(i),
+);
+
+const targetUrl = positional[0] ?? null;
+const timeout = Number(positional[1] ?? 15_000);
+
+if (!targetUrl && !tabId) {
+  process.stderr.write(
+    'Usage:\n' +
+      '  node capture.mjs <url> [timeout_ms] [--vars v1,v2] [--keep-tab] [--click "text"] [--dump-dom] [--eval "expr"] [--wait-until auto|domcontentloaded|networkidle|timeout] [--action-wait auto|networkidle|domcontentloaded|timeout|none] [--no-entries] [--entries-limit N]\n' +
+      '  node capture.mjs --tab-id <id> [--click "text"] [--vars v1,v2] [--dump-dom] [--close] [--eval "expr"] [--action-wait auto|networkidle|domcontentloaded|timeout|none] [--no-follow-new-tab]\n',
+  );
+  process.exit(1);
+}
+
+if (!Number.isFinite(timeout) || timeout <= 0) {
+  process.stderr.write(
+    `Invalid timeout: ${String(positional[1])}. timeout_ms must be a positive number.\n`,
+  );
+  process.exit(1);
+}
+
+if (
+  entriesLimitRaw != null &&
+  (!Number.isInteger(entriesLimit) || entriesLimit <= 0)
+) {
+  process.stderr.write(
+    `Invalid --entries-limit: ${entriesLimitRaw}. It must be a positive integer.\n`,
+  );
+  process.exit(1);
+}
+
+if (waitUntilRaw != null && parsedWaitUntil == null) {
+  process.stderr.write(
+    `Invalid --wait-until: ${waitUntilRaw}. Valid values: auto, domcontentloaded, networkidle, timeout.\n`,
+  );
+  process.exit(1);
+}
+
+if (actionWaitRaw != null && parsedActionWait == null) {
+  process.stderr.write(
+    `Invalid --action-wait: ${actionWaitRaw}. Valid values: auto, networkidle, domcontentloaded, timeout, none.\n`,
+  );
+  process.exit(1);
+}
+
+const AUTO_NETWORKIDLE_MAX_MS = 6_000;
+const hasInteractionAction = Boolean(clickTarget || fillArg || selectArg);
+const hasPostActionCapture = Boolean(evalExpr || varNames.length || dumpDom);
+// Auto-enable --no-entries for pure interaction steps on an existing tab (click/fill/select
+// with no variable/eval/dom capture): entries are noise and slow down the chain.
+const noEntries =
+  noEntriesFlag ||
+  Boolean(tabId && hasInteractionAction && !hasPostActionCapture);
+const waitUntil = parsedWaitUntil ?? 'auto';
+const actionWait = parsedActionWait ?? 'auto';
+const effectiveWaitUntil =
+  waitUntil === 'auto' ? 'domcontentloaded' : waitUntil;
+const effectiveActionWait =
+  actionWait === 'auto'
+    ? hasInteractionAction
+      ? 'domcontentloaded'
+      : 'none'
+    : actionWait;
+const navigateWaitBudgetMs = hasWaitUntilFlag
+  ? timeout
+  : Math.min(timeout, AUTO_NETWORKIDLE_MAX_MS);
+const actionWaitBudgetMs = hasActionWaitFlag
+  ? timeout
+  : Math.min(timeout, AUTO_NETWORKIDLE_MAX_MS);
+
+if (typeof WebSocket === 'undefined') {
+  process.stderr.write(
+    'Node.js 21+ required (built-in WebSocket). Current: ' +
+      process.version +
+      '\n',
+  );
+  process.exit(1);
+}
+
+// ── CDP session ───────────────────────────────────────────────────────────────
+
+class Session {
+  #ws;
+  #nextId = 1;
+  #pending = new Map();
+  #listeners = new Map();
+
+  constructor(wsUrl) {
+    this.#ws = new WebSocket(wsUrl);
+    this.#ws.addEventListener('message', ({ data }) => {
+      const msg = JSON.parse(data);
+      if (msg.id != null) {
+        const p = this.#pending.get(msg.id);
+        this.#pending.delete(msg.id);
+        msg.error
+          ? p?.reject(new Error(msg.error.message))
+          : p?.resolve(msg.result);
+      }
+      if (msg.method)
+        this.#listeners.get(msg.method)?.forEach((fn) => fn(msg.params));
+    });
+  }
+
+  open() {
+    return new Promise((resolve, reject) => {
+      this.#ws.addEventListener('open', resolve, { once: true });
+      this.#ws.addEventListener(
+        'error',
+        (e) => reject(new Error(String(e.message ?? e))),
+        { once: true },
+      );
+    });
+  }
+
+  send(method, params = {}) {
+    const id = this.#nextId++;
+    this.#ws.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolve, reject) =>
+      this.#pending.set(id, { resolve, reject }),
+    );
+  }
+
+  on(event, fn) {
+    if (!this.#listeners.has(event)) this.#listeners.set(event, []);
+    this.#listeners.get(event).push(fn);
+  }
+
+  close() {
+    this.#ws.close();
+  }
+}
+
+// ── verify Chrome reachable ───────────────────────────────────────────────────
+
+try {
+  await fetch(`${CDP_BASE}/json/version`);
+} catch {
+  process.stderr.write(
+    'Cannot reach Chrome on port 9222.\n\n' +
+      'Quit Chrome and relaunch with remote debugging (macOS):\n' +
+      '  CHROME=$(find /Applications ~/Applications -name "Google Chrome" -path "*/MacOS/Google Chrome" 2>/dev/null | head -1)\n' +
+      '  killall "Google Chrome" 2>/dev/null; sleep 1\n' +
+      '  "$CHROME" --remote-debugging-port=9222 --user-data-dir="$HOME/Library/Application Support/Google/Chrome" &\n\n' +
+      'This uses your REAL Chrome profile — all cookies and login sessions are preserved.\n',
+  );
+  process.exit(1);
+}
+
+// ── get or create tab ─────────────────────────────────────────────────────────
+
+let tab;
+
+if (tabId) {
+  const tabs = await (await fetch(`${CDP_BASE}/json/list`)).json();
+  tab = tabs.find((t) => t.id === tabId);
+  if (!tab) {
+    process.stderr.write(`Tab not found: ${tabId}\nActive tabs:\n`);
+    tabs.forEach((t) => process.stderr.write(`  ${t.id}  ${t.url}\n`));
+    process.exit(1);
+  }
+  process.stderr.write(`Attaching to tab: ${tab.url}\n`);
+} else {
+  process.stderr.write(
+    `Navigating to ${targetUrl} (timeout: ${timeout / 1000}s)...\n`,
+  );
+  tab = await (await fetch(`${CDP_BASE}/json/new`, { method: 'PUT' })).json();
+}
+
+let session = new Session(tab.webSocketDebuggerUrl);
+await session.open();
+
+// ── log collection ────────────────────────────────────────────────────────────
+
+const logs = [];
+const stamp = () => new Date().toISOString();
+
+session.on('Runtime.consoleAPICalled', ({ type, args: a, stackTrace }) => {
+  const msg = a
+    .map((x) =>
+      x.type === 'string'
+        ? x.value
+        : x.description
+          ? x.description
+          : x.value != null
+            ? String(x.value)
+            : x.type,
+    )
+    .join(' ');
+  const f = stackTrace?.callFrames?.[0];
+  logs.push({
+    t: stamp(),
+    level: type === 'warning' ? 'warn' : type,
+    msg,
+    stack: f ? `${f.url}:${f.lineNumber + 1}:${f.columnNumber + 1}` : null,
+  });
+});
+
+session.on('Runtime.exceptionThrown', ({ exceptionDetails: ex }) => {
+  const msg = ex.exception?.description ?? ex.text ?? 'Unknown exception';
+  const f = ex.stackTrace?.callFrames?.[0];
+  logs.push({
+    t: stamp(),
+    level: 'error',
+    msg,
+    stack: f ? `${f.url}:${f.lineNumber + 1}` : null,
+  });
+});
+
+session.on('Network.responseReceived', ({ response }) => {
+  if (response.status < 400) return;
+  logs.push({
+    t: stamp(),
+    level: response.status >= 500 ? 'error' : 'warn',
+    msg: `[HTTP] ${response.status} ${response.statusText} — ${response.url}`,
+    stack: null,
+  });
+});
+
+const pendingUrls = new Map();
+session.on('Network.requestWillBeSent', ({ requestId, request }) =>
+  pendingUrls.set(requestId, request.url),
+);
+session.on(
+  'Network.loadingFailed',
+  ({ requestId, errorText, blockedReason, canceled }) => {
+    if (canceled) return;
+    logs.push({
+      t: stamp(),
+      level: 'error',
+      msg: `[network] ${blockedReason ?? errorText} — ${pendingUrls.get(requestId) ?? '?'}`,
+      stack: null,
+    });
+    pendingUrls.delete(requestId);
+  },
+);
+
+session.on('Log.entryAdded', ({ entry }) => {
+  if (entry.level === 'verbose') return;
+  logs.push({
+    t: stamp(),
+    level: entry.level === 'warning' ? 'warn' : entry.level,
+    msg: entry.text,
+    stack: entry.url ? `${entry.url}:${entry.lineNumber ?? 0}` : null,
+  });
+});
+
+// ── reusable network-idle waiter ──────────────────────────────────────────────
+
+let inflight = 0;
+let idleTimer = null;
+const idleCallbacks = new Set();
+let lastWait = { earlyStop: false, timedOut: false };
+
+function fireIdle() {
+  const cbs = [...idleCallbacks];
+  idleCallbacks.clear();
+  cbs.forEach((cb) => cb());
+}
+function scheduleIdle() {
+  if (inflight === 0 && idleCallbacks.size > 0) {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(fireIdle, IDLE_MS);
+  }
+}
+
+session.on('Network.requestWillBeSent', () => {
+  inflight++;
+  clearTimeout(idleTimer);
+  idleTimer = null;
+});
+session.on('Network.loadingFinished', () => {
+  inflight = Math.max(0, inflight - 1);
+  scheduleIdle();
+});
+session.on('Network.loadingFailed', () => {
+  inflight = Math.max(0, inflight - 1);
+  scheduleIdle();
+});
+
+function waitForNetworkIdle(maxMs = timeout) {
+  return new Promise((resolve) => {
+    let done = false;
+    const cb = () => {
+      if (done) return;
+      done = true;
+      lastWait = { earlyStop: true, timedOut: false };
+      resolve();
+    };
+    idleCallbacks.add(cb);
+    scheduleIdle();
+    setTimeout(() => {
+      if (done) return;
+      done = true;
+      lastWait = { earlyStop: false, timedOut: true };
+      resolve();
+    }, maxMs);
+  });
+}
+
+async function waitAfterAction(mode, maxMs = timeout) {
+  if (mode === 'none') {
+    lastWait = { earlyStop: true, timedOut: false };
+    return;
+  }
+  if (mode === 'networkidle') {
+    await waitForNetworkIdle(maxMs);
+    return;
+  }
+  if (mode === 'timeout') {
+    await new Promise((r) => setTimeout(r, maxMs));
+    lastWait = { earlyStop: false, timedOut: true };
+    return;
+  }
+  await new Promise((r) => setTimeout(r, Math.min(500, maxMs)));
+  lastWait = { earlyStop: true, timedOut: false };
+}
+
+// ── enable domains & navigate ─────────────────────────────────────────────────
+
+await Promise.all([
+  session.send('Runtime.enable'),
+  session.send('Network.enable'),
+  session.send('Log.enable'),
+  session.send('Page.enable'),
+]);
+
+const timings = {
+  navigateMs: null,
+  clickMs: null,
+  fillMs: null,
+  selectMs: null,
+  evalMs: null,
+  varsMs: null,
+  totalMs: null,
+};
+let tabTransition = null;
+const tStart = Date.now();
+
+if (!tabId && targetUrl) {
+  const navigateStart = Date.now();
+  const pageLoaded = new Promise((r) => session.on('Page.loadEventFired', r));
+  await session.send('Page.navigate', { url: targetUrl });
+  await pageLoaded;
+  if (!disableEarlyStop && effectiveWaitUntil === 'networkidle') {
+    await waitForNetworkIdle(navigateWaitBudgetMs);
+  } else if (effectiveWaitUntil === 'domcontentloaded') {
+    // do nothing extra
+  } else {
+    // timeout-only
+    await new Promise((r) => setTimeout(r, timeout));
+    lastWait = { earlyStop: false, timedOut: true };
+  }
+  timings.navigateMs = Date.now() - navigateStart;
+}
+
+// ── click element ─────────────────────────────────────────────────────────────
+
+let clickResult = null;
+
+if (clickTarget) {
+  const clickStart = Date.now();
+  process.stderr.write(`Clicking: \"${clickTarget}\"\\n`);
+
+  const beforeTabs = followNewTab
+    ? await (await fetch(`${CDP_BASE}/json/list`)).json()
+    : null;
+
+  const r = await session.send('Runtime.evaluate', {
+    expression: `(function(q) {
+      const toText = (node) => (node?.textContent || '').trim();
+      const byText = (nodes) => {
+        const exact = nodes.find(n => toText(n) === q);
+        if (exact) return { el: exact, matchType: 'exact' };
+        const prefix = nodes.find(n => toText(n).startsWith(q));
+        if (prefix) return { el: prefix, matchType: 'prefix' };
+        const contains = nodes.find(n => toText(n).includes(q));
+        if (contains) return { el: contains, matchType: 'contains' };
+        return null;
+      };
+
+      const isSelector = q.startsWith('#') || q.startsWith('.') || q.startsWith('[') || q.includes('>');
+      let el = null;
+      let matchStrategy = 'none';
+      let matchType = 'none';
+
+      if (isSelector) {
+        try {
+          el = document.querySelector(q);
+          if (el) {
+            matchStrategy = 'css';
+            matchType = 'selector';
+          }
+        } catch(e) {}
+      }
+
+      if (!el) {
+        const strongCandidates = Array.from(document.querySelectorAll(
+          'button, a, [role=button], [role=tab], [role=menuitem], [role=option], input[type=button], input[type=submit]'
+        ));
+        const hit = byText(strongCandidates);
+        if (hit) {
+          el = hit.el;
+          matchStrategy = 'interactive';
+          matchType = hit.matchType;
+        }
+      }
+
+      if (!el) {
+        const weakCandidates = Array.from(document.querySelectorAll('div, span, li')).filter(node => {
+          const hasOnclick = typeof node.onclick === 'function';
+          const tabIndex = node.getAttribute('tabindex');
+          const focusable = tabIndex !== null && Number(tabIndex) >= 0;
+          let pointer = false;
+          try { pointer = window.getComputedStyle(node).cursor === 'pointer'; } catch(e) {}
+          return hasOnclick || focusable || pointer;
+        });
+        const hit = byText(weakCandidates);
+        if (hit) {
+          el = hit.el;
+          matchStrategy = 'weak-interactive';
+          matchType = hit.matchType;
+        }
+      }
+
+      if (!el) return JSON.stringify({ found: false, tried: q, matchStrategy: 'none' });
+      el.scrollIntoView({ behavior: 'instant', block: 'center' });
+      el.click();
+      return JSON.stringify({
+        found: true,
+        tag: el.tagName.toLowerCase(),
+        text: toText(el).slice(0, 80),
+        id: el.id || null,
+        className: typeof el.className === 'string' ? el.className : null,
+        matchStrategy,
+        matchType,
+      });
+    })(${JSON.stringify(clickTarget)})`,
+    returnByValue: true,
+  });
+
+  clickResult = JSON.parse(r?.result?.value ?? '{\"found\":false}');
+
+  if (!clickResult.found) {
+    process.stderr.write(
+      `  Warning: element not found for \"${clickTarget}\"\\n`,
+    );
+  } else {
+    process.stderr.write(
+      `  Clicked: <${clickResult.tag}> \"${clickResult.text}\" (${clickResult.matchStrategy}/${clickResult.matchType})\\n`,
+    );
+    // wait briefly for click-triggered requests to start, then wait by action mode
+    await new Promise((r) => setTimeout(r, 200));
+    await waitAfterAction(effectiveActionWait, actionWaitBudgetMs);
+
+    // follow new tab if opened
+    if (followNewTab && beforeTabs) {
+      const beforeIds = new Set(beforeTabs.map((t) => t.id));
+      let newTarget = null;
+      const deadline = Date.now() + 3000;
+      while (Date.now() < deadline && !newTarget) {
+        const now = await (await fetch(`${CDP_BASE}/json/list`)).json();
+        newTarget = now.find(
+          (t) => !beforeIds.has(t.id) && (t.type === 'page' || !t.type),
+        );
+        if (!newTarget) await new Promise((r) => setTimeout(r, 250));
+      }
+      if (newTarget) {
+        // switch session to new tab
+        const fromTabId = tab.id;
+        const toTabId = newTarget.id;
+        session.close();
+        tab = newTarget;
+        session = new Session(tab.webSocketDebuggerUrl);
+        await session.open();
+        await Promise.all([
+          session.send('Runtime.enable'),
+          session.send('Network.enable'),
+          session.send('Log.enable'),
+          session.send('Page.enable'),
+        ]);
+        const readyState = await session.send('Runtime.evaluate', {
+          expression: 'document.readyState',
+          returnByValue: true,
+        });
+        tabTransition = {
+          fromTabId,
+          toTabId,
+          reason: 'new-tab-after-click',
+          readyState: readyState?.result?.value ?? null,
+        };
+        // annotate click result with tab switch
+        clickResult.switchedToNewTab = true;
+        clickResult.fromTabId = fromTabId;
+        clickResult.toTabId = toTabId;
+      }
+    }
+  }
+
+  timings.clickMs = Date.now() - clickStart;
+}
+
+// ── fill input (locate by placeholder) ───────────────────────────────────────
+
+let fillResult = null;
+
+if (fillArg) {
+  const fillStart = Date.now();
+  const sep = fillArg.indexOf('::');
+  const placeholder = sep !== -1 ? fillArg.slice(0, sep) : fillArg;
+  const text = sep !== -1 ? fillArg.slice(sep + 2) : '';
+  process.stderr.write(
+    `Filling: placeholder="${placeholder}" text="${text}"\n`,
+  );
+
+  const r = await session.send('Runtime.evaluate', {
+    expression: `(function(ph, txt) {
+      const el = document.querySelector('input[placeholder="' + ph + '"], textarea[placeholder="' + ph + '"]');
+      if (!el) return JSON.stringify({ found: false, tried: ph });
+      el.focus();
+      el.scrollIntoView({ behavior: 'instant', block: 'center' });
+      // React/Vue-compatible: use native setter to trigger synthetic events
+      const proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(proto, 'value').set;
+      setter.call(el, txt);
+      el.dispatchEvent(new Event('input',  { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return JSON.stringify({ found: true, tag: el.tagName.toLowerCase(), placeholder: el.placeholder });
+    })(${JSON.stringify(placeholder)}, ${JSON.stringify(text)})`,
+    returnByValue: true,
+  });
+
+  fillResult = JSON.parse(r?.result?.value ?? '{"found":false}');
+  if (!fillResult.found) {
+    process.stderr.write(
+      `  Warning: input not found for placeholder="${placeholder}"\n`,
+    );
+  } else {
+    process.stderr.write(
+      `  Filled: <${fillResult.tag}> placeholder="${fillResult.placeholder}"\n`,
+    );
+    await new Promise((r) => setTimeout(r, 200));
+    await waitAfterAction(effectiveActionWait, actionWaitBudgetMs);
+  }
+
+  timings.fillMs = Date.now() - fillStart;
+}
+
+// ── select option (locate by placeholder) ────────────────────────────────────
+
+let selectResult = null;
+
+if (selectArg) {
+  const selectStart = Date.now();
+  const sep = selectArg.indexOf('::');
+  const placeholder = sep !== -1 ? selectArg.slice(0, sep) : selectArg;
+  const value = sep !== -1 ? selectArg.slice(sep + 2) : '';
+  process.stderr.write(
+    `Selecting: placeholder="${placeholder}" value="${value}"\n`,
+  );
+
+  // Step 1: try native <select>, otherwise click the custom dropdown trigger
+  const r1 = await session.send('Runtime.evaluate', {
+    expression: `(function(ph, val) {
+      // native <select>: match by placeholder attr or first option text
+      const selects = Array.from(document.querySelectorAll('select'));
+      const nativeSel = selects.find(s =>
+        s.getAttribute('placeholder') === ph ||
+        (s.options[0] && s.options[0].text.trim() === ph)
+      );
+      if (nativeSel) {
+        const opt = Array.from(nativeSel.options).find(o => o.text.trim() === val || o.value === val);
+        if (!opt) return JSON.stringify({ found: false, reason: 'option not found', tried: val });
+        nativeSel.value = opt.value;
+        nativeSel.dispatchEvent(new Event('change', { bubbles: true }));
+        return JSON.stringify({ found: true, type: 'native', value: opt.value, text: opt.text.trim() });
+      }
+      // custom dropdown: find trigger by placeholder attr or visible placeholder text
+      let trigger = document.querySelector('[placeholder="' + ph + '"]');
+      if (!trigger) {
+        const candidates = Array.from(document.querySelectorAll(
+          '[role=combobox], [aria-haspopup], [class*=select], [class*=dropdown]'
+        ));
+        trigger = candidates.find(e => e.textContent.trim() === ph);
+      }
+      if (!trigger) return JSON.stringify({ found: false, reason: 'trigger not found', tried: ph });
+      trigger.scrollIntoView({ behavior: 'instant', block: 'center' });
+      trigger.click();
+      return JSON.stringify({ found: true, type: 'custom', step: 'trigger_clicked' });
+    })(${JSON.stringify(placeholder)}, ${JSON.stringify(value)})`,
+    returnByValue: true,
+  });
+
+  selectResult = JSON.parse(r1?.result?.value ?? '{"found":false}');
+
+  if (
+    selectResult.type === 'custom' &&
+    selectResult.step === 'trigger_clicked'
+  ) {
+    // Step 2: wait for dropdown to open, then click the matching option
+    await new Promise((r) => setTimeout(r, 300));
+    const r2 = await session.send('Runtime.evaluate', {
+      expression: `(function(val) {
+        const opts = Array.from(document.querySelectorAll(
+          'option, [role=option], [role=menuitem], [class*=option-item], [class*=dropdown-item]'
+        ));
+        const opt = opts.find(e => e.textContent.trim() === val)
+          ?? opts.find(e => e.textContent.trim().includes(val));
+        if (!opt) return JSON.stringify({ found: false, tried: val });
+        opt.click();
+        return JSON.stringify({ found: true, type: 'custom', text: opt.textContent.trim() });
+      })(${JSON.stringify(value)})`,
+      returnByValue: true,
+    });
+    selectResult = JSON.parse(r2?.result?.value ?? '{"found":false}');
+  }
+
+  if (!selectResult.found) {
+    process.stderr.write(
+      `  Warning: select target not found (${selectResult.reason ?? 'unknown'})\n`,
+    );
+  } else {
+    process.stderr.write(
+      `  Selected: [${selectResult.type}] "${selectResult.text ?? selectResult.value}"\n`,
+    );
+    await new Promise((r) => setTimeout(r, 200));
+    await waitAfterAction(effectiveActionWait, actionWaitBudgetMs);
+  }
+
+  timings.selectMs = Date.now() - selectStart;
+}
+
+// ── DOM dump (for Claude to identify selectors) ───────────────────────────────
+
+let domSnapshot = null;
+
+if (dumpDom) {
+  const r = await session.send('Runtime.evaluate', {
+    expression: `(function() {
+      function walk(el, depth) {
+        if (depth > 4) return null;
+        const tag = el.tagName?.toLowerCase();
+        if (!tag || ['script','style','svg','noscript','head'].includes(tag)) return null;
+        const text = el.children.length === 0 ? el.textContent.trim().slice(0, 120) : '';
+        const attrs = {};
+        if (el.id) attrs.id = el.id;
+        if (el.className && typeof el.className === 'string') {
+          const cls = el.className.split(' ').filter(Boolean);
+          if (cls.length) attrs.class = cls.slice(0, 4).join(' ');
+        }
+        const role = el.getAttribute('role'); if (role) attrs.role = role;
+        const children = Array.from(el.children).map(c => walk(c, depth + 1)).filter(Boolean);
+        if (!text && !children.length && !Object.keys(attrs).length) return null;
+        return { tag, ...(Object.keys(attrs).length ? { attrs } : {}), ...(text ? { text } : {}), ...(children.length ? { children } : {}) };
+      }
+      return JSON.stringify(walk(document.body, 0));
+    })()`,
+    returnByValue: true,
+  });
+  domSnapshot = JSON.parse(r?.result?.value ?? 'null');
+}
+
+// ── variable capture / eval ───────────────────────────────────────────────────
+
+let evalResult = null;
+if (evalExpr) {
+  const evalStart = Date.now();
+  process.stderr.write(`Evaluating expression: ${evalExpr}\n`);
+  try {
+    const r = await session.send('Runtime.evaluate', {
+      expression: evalExpr,
+      returnByValue: true,
+    });
+    evalResult = r?.result?.value ?? null;
+  } catch (e) {
+    evalResult = { error: String(e.message) };
+  }
+  timings.evalMs = Date.now() - evalStart;
+}
+
+const variables = {};
+
+if (varNames.length) {
+  const varsStart = Date.now();
+  process.stderr.write(`Capturing variables: ${varNames.join(', ')}\n`);
+
+  const safeSerializerSrc = `
+    (function captureVar(pathExpr) {
+      const skipped = [];
+      const seen = new WeakMap();
+
+      function safe(val, path, depth) {
+        if (depth > 5) { skipped.push({ path, reason: 'max_depth' }); return '[max depth]'; }
+        if (val === null || val === undefined) return val;
+        const t = typeof val;
+        if (t === 'boolean' || t === 'number' || t === 'string') return val;
+        if (t === 'bigint') return val.toString() + 'n';
+        if (t === 'symbol') return val.toString();
+        if (t === 'function') {
+          skipped.push({ path, reason: 'function', detail: val.name || 'anonymous' });
+          return '[Function: ' + (val.name || 'anonymous') + ']';
+        }
+        if (seen.has(val)) {
+          skipped.push({ path, reason: 'circular', circularRef: seen.get(val) });
+          return '[Circular -> ' + seen.get(val) + ']';
+        }
+        seen.set(val, path);
+        if (Array.isArray(val)) return val.map((v, i) => safe(v, path + '[' + i + ']', depth + 1));
+        const obj = {};
+        for (const k of Object.keys(val)) {
+          try { obj[k] = safe(val[k], path + '.' + k, depth + 1); }
+          catch (e) { skipped.push({ path: path + '.' + k, reason: 'error', detail: e.message }); obj[k] = '[Error: ' + e.message + ']'; }
+        }
+        return obj;
+      }
+
+      function normalizePath(path) {
+        return path
+          .replace(/\[(\d+)\]/g, '.$1')
+          .replace(/\[['\"]([^'\"]+)['\"]\]/g, '.$1');
+      }
+
+      function getByPath(root, path) {
+        if (Object.prototype.hasOwnProperty.call(root, path)) return root[path];
+        const normalized = normalizePath(path);
+        const parts = normalized.split('.').filter(Boolean);
+        let cur = root;
+        for (const part of parts) {
+          if (cur == null) return undefined;
+          cur = cur[part];
+        }
+        return cur;
+      }
+
+      let val;
+      try { val = getByPath(window, pathExpr); } catch(e) { return JSON.stringify({ exists: false, error: e.message, skippedPaths: [] }); }
+      if (val === undefined) return JSON.stringify({ exists: false, skippedPaths: [] });
+      return JSON.stringify({ exists: true, value: safe(val, pathExpr, 0), skippedPaths: skipped });
+    })
+  `;
+
+  for (const varName of varNames) {
+    try {
+      const r = await session.send('Runtime.evaluate', {
+        expression: `(${safeSerializerSrc})(${JSON.stringify(varName)})`,
+        returnByValue: true,
+      });
+      variables[varName] = r?.result?.value
+        ? JSON.parse(r.result.value)
+        : { exists: false, error: r?.result?.description ?? 'unknown' };
+    } catch (e) {
+      variables[varName] = { exists: false, error: String(e.message) };
+    }
+    process.stderr.write(
+      `  ${varName}: ${variables[varName].exists ? 'found' : 'not found'}${variables[varName].skippedPaths?.length ? ` (${variables[varName].skippedPaths.length} paths skipped)` : ''}\n`,
+    );
+  }
+
+  timings.varsMs = Date.now() - varsStart;
+}
+
+// ── close or keep tab ─────────────────────────────────────────────────────────
+// Default behaviour:
+//   new tab  (no --tab-id)  → close unless --keep-tab
+//   existing tab (--tab-id) → keep unless --close
+
+const shouldClose = closeTab || (!keepTab && !tabId);
+session.close();
+if (shouldClose) await fetch(`${CDP_BASE}/json/close/${tab.id}`);
+
+// ── output ────────────────────────────────────────────────────────────────────
+
+const elapsedMs = Date.now() - tStart;
+timings.totalMs = elapsedMs;
+const result = {
+  ...(keepTab || tabId ? { tabId: tab.id } : {}),
+  activeTabId: tab.id,
+  url: targetUrl ?? tab.url,
+  capturedAt: stamp(),
+  elapsedMs,
+  waitUntil: effectiveWaitUntil,
+  actionWait: effectiveActionWait,
+  requestedWaitUntil: waitUntil,
+  requestedActionWait: actionWait,
+  earlyStop: lastWait.earlyStop,
+  timedOut: lastWait.timedOut,
+  timings,
+  total: logs.length,
+  errors: logs.filter((l) => l.level === 'error').length,
+  warns: logs.filter((l) => l.level === 'warn').length,
+  ...(tabTransition ? { tabTransition } : {}),
+  ...(clickTarget ? { click: clickResult } : {}),
+  ...(fillArg ? { fill: fillResult } : {}),
+  ...(selectArg ? { select: selectResult } : {}),
+  ...(dumpDom ? { dom: domSnapshot } : {}),
+  ...(evalExpr ? { evalResult } : {}),
+  ...(varNames.length ? { variables } : {}),
+  ...(noEntries
+    ? {}
+    : {
+        entries: entriesLimit
+          ? logs.slice(Math.max(0, logs.length - entriesLimit))
+          : logs,
+      }),
+};
+
+process.stderr.write(
+  `Done: ${result.errors} errors, ${result.warns} warns, ${result.total} total\n`,
+);
+process.stdout.write(JSON.stringify(result, null, 2) + '\n');
diff --git a/apps/runtime-demo/skills/mf/scripts/config-exposes-check.js b/apps/runtime-demo/skills/mf/scripts/config-exposes-check.js
new file mode 100644
index 00000000000..30fe7ff6e90
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/config-exposes-check.js
@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+function checkPlugin(ctx, results) {
+  const bundler = (ctx.bundler && ctx.bundler.name) || '';
+  const configFile = (ctx.bundler && ctx.bundler.configFile) || '';
+  const deps = ctx.dependencies || {};
+
+  const hasModernJsV3 = !!deps['@module-federation/modern-js-v3'];
+  const hasModernJs = !!deps['@module-federation/modern-js'];
+  const hasNextMf = !!deps['@module-federation/nextjs-mf'];
+  const hasEnhanced = !!deps['@module-federation/enhanced'];
+  const hasRspackPlugin = !!deps['@module-federation/rspack'];
+  const hasRsbuildPlugin = !!deps['@module-federation/rsbuild-plugin'];
+
+  const isModernJs = configFile.includes('modern');
+  const isNextJs = !!deps['next'];
+
+  if (isNextJs) {
+    if (!hasNextMf) {
+      results.push({
+        code: 'CONFIG-PLUGIN',
+        severity: 'warning',
+        message:
+          'Next.js project detected but @module-federation/nextjs-mf is not installed.',
+        context: { bundler, recommended: '@module-federation/nextjs-mf' },
+      });
+    }
+    return;
+  }
+
+  if (isModernJs) {
+    const modernJsAppToolsVersion = deps['@modern-js/app-tools'] || '';
+    const major = parseInt(modernJsAppToolsVersion.replace(/[^0-9]/, ''), 10);
+    const recommended =
+      !isNaN(major) && major >= 3
+        ? '@module-federation/modern-js-v3'
+        : '@module-federation/modern-js';
+    if (!hasModernJsV3 && !hasModernJs) {
+      results.push({
+        code: 'CONFIG-PLUGIN',
+        severity: 'warning',
+        message: `Modern.js project detected but no MF plugin found. Recommended: ${recommended}.`,
+        context: { bundler, recommended },
+      });
+    }
+    return;
+  }
+
+  if (bundler === 'rsbuild') {
+    if (!hasRsbuildPlugin && !hasEnhanced && !hasRspackPlugin) {
+      results.push({
+        code: 'CONFIG-PLUGIN',
+        severity: 'warning',
+        message:
+          'Rsbuild project detected but no MF plugin found. Recommended: @module-federation/rsbuild-plugin.',
+        context: { bundler, recommended: '@module-federation/rsbuild-plugin' },
+      });
+    }
+    return;
+  }
+
+  if (bundler === 'rspack') {
+    if (!hasEnhanced && !hasRspackPlugin) {
+      results.push({
+        code: 'CONFIG-PLUGIN',
+        severity: 'warning',
+        message:
+          'Rspack project detected but no MF plugin found. Recommended: @module-federation/enhanced/rspack.',
+        context: { bundler, recommended: '@module-federation/enhanced/rspack' },
+      });
+    }
+    return;
+  }
+
+  if (bundler === 'webpack') {
+    if (!hasEnhanced) {
+      results.push({
+        code: 'CONFIG-PLUGIN',
+        severity: 'warning',
+        message:
+          'Webpack project detected but @module-federation/enhanced is not installed.',
+        context: { bundler, recommended: '@module-federation/enhanced' },
+      });
+    }
+    return;
+  }
+}
+
+function checkAsyncEntry(ctx, results) {
+  const deps = ctx.dependencies || {};
+  const configFile = (ctx.bundler && ctx.bundler.configFile) || '';
+
+  if (
+    deps['@module-federation/modern-js-v3'] ||
+    deps['@module-federation/modern-js']
+  ) {
+    return;
+  }
+
+  const mfConfig = ctx.mfConfig || {};
+  const experiments = mfConfig.experiments || {};
+
+  if (!experiments.asyncStartup) {
+    const bundler = (ctx.bundler && ctx.bundler.name) || '';
+    let note = 'Set `experiments.asyncStartup = true` in your bundler config.';
+    if (bundler === 'rspack') {
+      note += ' Note: Rspack requires version > 1.7.4 for this option.';
+    }
+    results.push({
+      code: 'CONFIG-ASYNC-ENTRY',
+      severity: 'warning',
+      message: `experiments.asyncStartup is not set. ${note} See: https://module-federation.io/blog/hoisted-runtime.md`,
+      context: { configFile },
+    });
+  }
+}
+
+function checkExposes(ctx, results) {
+  const projectRoot = ctx.project && ctx.project.root;
+  const exposes = (ctx.mfConfig && ctx.mfConfig.exposes) || {};
+
+  Object.entries(exposes).forEach(([key, value]) => {
+    if (!key.startsWith('./')) {
+      results.push({
+        code: 'CONFIG-EXPOSES-KEY',
+        severity: 'warning',
+        message: `exposes key "${key}" should start with "./"`,
+        context: { key },
+      });
+    }
+    const rel = typeof value === 'string' ? value : value && value.import;
+    if (!rel || typeof rel !== 'string') return;
+    if (projectRoot) {
+      const full = path.join(projectRoot, rel);
+      if (!fs.existsSync(full)) {
+        results.push({
+          code: 'CONFIG-EXPOSES-PATH',
+          severity: 'warning',
+          message: `The path referenced by exposes["${key}"] does not exist: ${rel} (check exact file extension)`,
+          context: { key, path: rel },
+        });
+      }
+    }
+  });
+}
+
+function main(ctx) {
+  const results = [];
+  checkPlugin(ctx, results);
+  checkAsyncEntry(ctx, results);
+  checkExposes(ctx, results);
+  process.stdout.write(
+    `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+  );
+}
+
+const args = parseArgs(process.argv);
+main(JSON.parse(args.context));
diff --git a/apps/runtime-demo/skills/mf/scripts/module-info.js b/apps/runtime-demo/skills/mf/scripts/module-info.js
new file mode 100644
index 00000000000..d0799095e56
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/module-info.js
@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const http = require('http');
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+function extractRemoteUrl(remoteValue) {
+  const raw =
+    typeof remoteValue === 'string'
+      ? remoteValue
+      : (remoteValue && remoteValue.external) || null;
+  if (!raw) return null;
+  const atIndex = raw.indexOf('@');
+  return atIndex >= 0 ? raw.slice(atIndex + 1) : raw;
+}
+
+function getPublicPath(remoteEntry) {
+  const lastSlash = remoteEntry.lastIndexOf('/');
+  return lastSlash >= 0
+    ? remoteEntry.slice(0, lastSlash + 1)
+    : `${remoteEntry}/`;
+}
+
+function fetchJson(url) {
+  return new Promise((resolve) => {
+    const client = url.startsWith('https') ? https : http;
+    client
+      .get(url, (res) => {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          try {
+            resolve({ ok: true, data: JSON.parse(data) });
+          } catch {
+            resolve({ ok: false, error: `Failed to parse JSON from ${url}` });
+          }
+        });
+      })
+      .on('error', (err) => {
+        resolve({ ok: false, error: err.message });
+      });
+  });
+}
+
+function extractManifestInfo(manifest) {
+  if (!manifest) return null;
+  return {
+    exposes: manifest.exposes || [],
+    remotes: manifest.remotes || [],
+    shared: manifest.shared || [],
+  };
+}
+
+async function main(ctx, moduleName, explicitUrl) {
+  let remoteEntry = explicitUrl || null;
+
+  if (!remoteEntry) {
+    const remotes = (ctx.mfConfig && ctx.mfConfig.remotes) || {};
+    const remoteValue = remotes[moduleName];
+    if (!remoteValue) {
+      process.stdout.write(
+        JSON.stringify(
+          {
+            error: `Remote "${moduleName}" not found in mfConfig.remotes`,
+            availableRemotes: Object.keys(remotes),
+          },
+          null,
+          2,
+        ) + '\n',
+      );
+      return;
+    }
+    remoteEntry = extractRemoteUrl(remoteValue);
+  }
+
+  if (!remoteEntry) {
+    process.stdout.write(
+      JSON.stringify(
+        { error: `Cannot resolve remoteEntry URL for "${moduleName}"` },
+        null,
+        2,
+      ) + '\n',
+    );
+    return;
+  }
+
+  const publicPath = getPublicPath(remoteEntry);
+  const typesZip = `${publicPath}@mf-types.zip`;
+
+  const manifestUrl = `${publicPath}mf-manifest.json`;
+  const manifestRes = await fetchJson(manifestUrl);
+  const manifest = manifestRes.ok
+    ? extractManifestInfo(manifestRes.data)
+    : null;
+
+  const hasSsr = manifestRes.ssrRemoteEntry;
+
+  const result = {
+    moduleName,
+    publicPath,
+    remoteEntry,
+    typesZip,
+    typesApi: null,
+    hasSsr,
+    manifest,
+    manifestError: manifestRes.ok ? undefined : manifestRes.error,
+  };
+
+  process.stdout.write(JSON.stringify({ result }, null, 2) + '\n');
+}
+
+const args = parseArgs(process.argv);
+
+if (!args.module) {
+  process.stderr.write('Error: --module <module-name> is required\n');
+  process.exit(1);
+}
+
+main(JSON.parse(args.context || '{}'), args.module, args.url || null).catch(
+  (err) => {
+    process.stderr.write(`Error: ${err.message}\n`);
+    process.exit(1);
+  },
+);
diff --git a/apps/runtime-demo/skills/mf/scripts/performance-check.js b/apps/runtime-demo/skills/mf/scripts/performance-check.js
new file mode 100644
index 00000000000..8fdc8155289
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/performance-check.js
@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+function main(ctx) {
+  const results = [];
+  const bundlerName = (ctx.bundler && ctx.bundler.name) || 'unknown';
+  const hasTypescript = Boolean(
+    ctx.dependencies && ctx.dependencies.typescript,
+  );
+
+  results.push({
+    code: 'PERF',
+    severity: 'info',
+    message:
+      'Enable dev.disableAssetsAnalyze during local development to reduce bundle analysis overhead and speed up HMR and builds.',
+    context: { bundler: bundlerName },
+  });
+
+  if (bundlerName === 'rspack' || bundlerName === 'rsbuild') {
+    results.push({
+      code: 'PERF',
+      severity: 'info',
+      message:
+        'Rspack/Rsbuild project detected. Setting splitChunks.chunks to "async" is recommended to reduce initial bundle size.',
+      context: { bundler: bundlerName },
+    });
+  }
+
+  if (hasTypescript) {
+    results.push({
+      code: 'PERF',
+      severity: 'info',
+      message:
+        'TypeScript dependency detected. If type generation (DTS) overhead is too high, consider disabling DTS or using ts-go to optimize the type-checking pipeline.',
+      context: { typescript: ctx.dependencies.typescript },
+    });
+  }
+
+  process.stdout.write(
+    `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+  );
+}
+
+const args = parseArgs(process.argv);
+main(JSON.parse(args.context));
diff --git a/apps/runtime-demo/skills/mf/scripts/shared-config-check.js b/apps/runtime-demo/skills/mf/scripts/shared-config-check.js
new file mode 100644
index 00000000000..dabd00f12b6
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/shared-config-check.js
@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+const UI_LIBS = ['antd', '@ant-design/pro', 'arco', '@arco-design/web-react'];
+
+function checkExternalsConflict(ctx, results) {
+  const shared = (ctx.mfConfig && ctx.mfConfig.shared) || {};
+  const externals = (ctx.mfConfig && ctx.mfConfig.externals) || {};
+  const sharedKeys = Object.keys(shared);
+  const externalKeys = Array.isArray(externals)
+    ? externals
+    : Object.keys(externals);
+
+  sharedKeys.forEach((name) => {
+    if (externalKeys.includes(name)) {
+      results.push({
+        code: 'SHARED-EXTERNALS-CONFLICT',
+        severity: 'warning',
+        message: `"${name}" is configured in both shared and externals. Remove it from one of the two to avoid runtime failures.`,
+        context: { name },
+      });
+    }
+  });
+}
+
+function checkTransformImport(ctx, results) {
+  const shared = (ctx.mfConfig && ctx.mfConfig.shared) || {};
+  const deps = ctx.dependencies || {};
+  const bundler = (ctx.bundler && ctx.bundler.name) || '';
+
+  const sharedUiLibs = Object.keys(shared).filter((name) =>
+    UI_LIBS.some((lib) => name === lib || name.startsWith(lib + '/')),
+  );
+  if (sharedUiLibs.length === 0) return;
+
+  const hasBabelPluginImport = !!deps['babel-plugin-import'];
+  const isModernOrRsbuild = bundler === 'rsbuild' || bundler === 'modernjs';
+
+  if (hasBabelPluginImport || isModernOrRsbuild) {
+    const fix = isModernOrRsbuild
+      ? 'Set `source.transformImport = false` in your Modern.js / Rsbuild config.'
+      : 'Remove `babel-plugin-import` from your Babel config.';
+    sharedUiLibs.forEach((name) => {
+      results.push({
+        code: 'SHARED-TRANSFORM-IMPORT',
+        severity: 'warning',
+        message: `"${name}" is in shared but transformImport / babel-plugin-import is active, which prevents sharing. ${fix}`,
+        context: { name, bundler },
+      });
+    });
+  }
+}
+
+function checkMultiVersion(ctx, results) {
+  const artifacts = ctx.buildArtifacts || {};
+  const manifest = artifacts.mfManifest;
+  if (!manifest) return;
+
+  const versionMap = {};
+  const exposes = manifest.exposes || [];
+  exposes.forEach((item) => {
+    const { name, version } = item;
+    if (!name || !version) return;
+    if (!versionMap[name]) versionMap[name] = new Set();
+    versionMap[name].add(version);
+  });
+
+  Object.entries(versionMap).forEach(([name, versions]) => {
+    if (versions.size > 1) {
+      results.push({
+        code: 'SHARED-MULTI-VERSION',
+        severity: 'warning',
+        message: `Shared package "${name}" has multiple versions in build artifacts: ${[...versions].join(', ')}. Add an alias in your bundler config to resolve to a single version.`,
+        context: { name, versions: [...versions] },
+      });
+    }
+  });
+}
+
+function main(ctx) {
+  const results = [];
+  checkExternalsConflict(ctx, results);
+  checkTransformImport(ctx, results);
+  checkMultiVersion(ctx, results);
+  process.stdout.write(
+    `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+  );
+}
+
+const args = parseArgs(process.argv);
+main(JSON.parse(args.context));
diff --git a/apps/runtime-demo/skills/mf/scripts/type-check.js b/apps/runtime-demo/skills/mf/scripts/type-check.js
new file mode 100644
index 00000000000..6c480d66ad3
--- /dev/null
+++ b/apps/runtime-demo/skills/mf/scripts/type-check.js
@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx >= 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        args[arg.slice(2)] = argv[i + 1] || '';
+        i++;
+      }
+    }
+  }
+  return args;
+}
+
+function semverGt(a, b) {
+  const aParts = a.split('.').map(Number);
+  const bParts = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const av = aParts[i] || 0;
+    const bv = bParts[i] || 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return false;
+}
+
+function stripVersionPrefix(version) {
+  return (version || '').replace(/^[\\^~]/, '');
+}
+
+function main(ctx) {
+  const projectRoot = ctx.project && ctx.project.root;
+  const results = [];
+
+  const tsconfigPath = projectRoot
+    ? path.join(projectRoot, 'tsconfig.json')
+    : null;
+
+  const hasTsconfig = tsconfigPath && fs.existsSync(tsconfigPath);
+  const hasTypescript = Boolean(
+    (ctx.dependencies && ctx.dependencies.typescript) ||
+    (ctx.devDependencies && ctx.devDependencies.typescript),
+  );
+
+  if (!hasTsconfig || !hasTypescript) {
+    if (!hasTsconfig) {
+      results.push({
+        code: 'TYPE-001',
+        severity: 'warning',
+        scenario: 'ENV_INCOMPLETE',
+        message:
+          'tsconfig.json not found in project root. Type consumption (e.g., producer type files) may not be correctly configured.',
+        context: { tsconfigPath },
+      });
+    }
+    if (!hasTypescript) {
+      results.push({
+        code: 'TYPE-001',
+        severity: 'warning',
+        scenario: 'ENV_INCOMPLETE',
+        message:
+          'typescript not found in dependencies/devDependencies. Skipping tsc; please verify the type generation workflow.',
+        context: {},
+      });
+    }
+
+    process.stdout.write(
+      `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+    );
+    return;
+  }
+
+  const mfTypesDir = path.join(projectRoot, '@mf-types');
+  const mfTypesExists = fs.existsSync(mfTypesDir);
+
+  if (!mfTypesExists) {
+    const diagnosticsPath = path.join(
+      projectRoot,
+      '.mf',
+      'diagnostics',
+      'latest.json',
+    );
+    const diagnosticsExists = fs.existsSync(diagnosticsPath);
+    let canReadDiagnostics = false;
+
+    if (diagnosticsExists) {
+      try {
+        JSON.parse(fs.readFileSync(diagnosticsPath, 'utf8'));
+        canReadDiagnostics = true;
+      } catch (e) {
+        canReadDiagnostics = false;
+      }
+    }
+
+    const rawEnhancedVersion =
+      ctx.dependencies && ctx.dependencies['@module-federation/enhanced'];
+    const enhancedVersion = stripVersionPrefix(rawEnhancedVersion);
+
+    if (enhancedVersion && semverGt(enhancedVersion, '2.0.1')) {
+      canReadDiagnostics = canReadDiagnostics || diagnosticsExists;
+    }
+
+    const typeGenFailedResult = {
+      code: 'TYPE-001',
+      severity: 'error',
+      scenario: 'TYPE_GENERATION_FAILED',
+      message:
+        '@mf-types directory not found. Type generation may have failed on the producer side.',
+      canReadDiagnostics,
+      context: {},
+    };
+
+    if (enhancedVersion) {
+      typeGenFailedResult.enhancedVersion = enhancedVersion;
+    }
+
+    if (diagnosticsExists) {
+      typeGenFailedResult.diagnosticsPath = diagnosticsPath;
+    }
+
+    results.push(typeGenFailedResult);
+
+    results.push({
+      code: 'TYPE-001',
+      severity: 'warning',
+      scenario: 'TYPES_NOT_PULLED',
+      message:
+        'Remote types have not been pulled. Run the appropriate pull-types command to fetch remote type definitions.',
+      context: {},
+    });
+  } else {
+    let tsconfig = null;
+    try {
+      tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+    } catch (e) {
+      results.push({
+        code: 'TYPE-001',
+        severity: 'warning',
+        scenario: 'ENV_INCOMPLETE',
+        message: `Failed to parse tsconfig.json: ${e.message}`,
+        context: { tsconfigPath },
+      });
+
+      process.stdout.write(
+        `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+      );
+      return;
+    }
+
+    const paths =
+      tsconfig && tsconfig.compilerOptions && tsconfig.compilerOptions.paths;
+
+    const wildcardPaths = paths && paths['*'];
+    const hasMfTypesPath =
+      Array.isArray(wildcardPaths) &&
+      wildcardPaths.some((p) => p === './@mf-types/*');
+
+    if (!hasMfTypesPath) {
+      results.push({
+        code: 'TYPE-001',
+        severity: 'warning',
+        scenario: 'TSCONFIG_PATHS_MISSING',
+        message:
+          'tsconfig.json compilerOptions.paths is missing the "@mf-types" entry. Add `"*": ["./@mf-types/*"]` under compilerOptions.paths to enable remote type resolution.',
+        context: { tsconfigPath },
+      });
+    } else {
+      results.push({
+        code: 'TYPE-001',
+        severity: 'info',
+        scenario: 'ENV_OK',
+        message:
+          'TypeScript environment and remote type configuration look correct.',
+        context: {},
+      });
+    }
+  }
+
+  process.stdout.write(
+    `${JSON.stringify({ context: ctx, results }, null, 2)}\n`,
+  );
+}
+
+const args = parseArgs(process.argv);
+
+let ctx;
+try {
+  ctx = JSON.parse(args.context);
+} catch (e) {
+  process.stderr.write(`Failed to parse --context argument: ${e.message}\n`);
+  process.exit(1);
+}
+
+main(ctx);
diff --git a/apps/runtime-demo/typings/cssmodule.d.ts b/apps/runtime-demo/typings/cssmodule.d.ts
new file mode 100644
index 00000000000..9df325d33dd
--- /dev/null
+++ b/apps/runtime-demo/typings/cssmodule.d.ts
@@ -0,0 +1,6 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css';
diff --git a/apps/runtime-demo/typings/image.d.ts b/apps/runtime-demo/typings/image.d.ts
new file mode 100644
index 00000000000..bef5a80f630
--- /dev/null
+++ b/apps/runtime-demo/typings/image.d.ts
@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpeg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.gif' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.webp' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.svg' {
+  const src: string;
+  export default src;
+}
diff --git a/apps/website-new/docs/en/ai/index.mdx b/apps/website-new/docs/en/ai/index.mdx
index dbf943ac741..e7e3d644b24 100644
--- a/apps/website-new/docs/en/ai/index.mdx
+++ b/apps/website-new/docs/en/ai/index.mdx
@@ -46,9 +46,34 @@ The `mf` skill does more than answer questions. It can also help your agent:
 - analyze type issues
 - check shared dependency conflicts
 - inspect remote module information
+- read observability reports and debug MF loading failures
 
 👉 [View Agent Skills documentation](./skill)
 
+## Observe and Debug MF Loading
+
+If you want an AI coding agent to debug Module Federation loading with concrete
+runtime facts, enable the [Observability Plugin](../plugin/plugins/observability-plugin)
+first.
+
+After a loading failure, the browser console will print a `traceId` and,
+in development, a `read:` command. Give that console hint to your agent:
+
+```text
+/mf observability
+I saw this Module Federation console error:
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+Please read the report and fix the issue.
+```
+
+For Node or SSR, ask the agent to read `.mf/observability/latest.json`. For
+production, upload reports with the plugin's `onReport` callback and give the
+uploaded report or trace ID to your agent.
+
 ## You Can Still Use This Without Installing Anything
 
 If you just want a lightweight version first, send this directly to your agent:
@@ -87,4 +112,6 @@ If you want to start using this workflow right away:
 
 1. Install `mf`
 2. Ask the question you care about most
-3. Open [Skills documentation](./skill) to see which sub-commands it supports
+3. Enable the [Observability Plugin](../plugin/plugins/observability-plugin) when
+   you need MF loading observability
+4. Open [Skills documentation](./skill) to see which sub-commands it supports
diff --git a/apps/website-new/docs/en/ai/skill.mdx b/apps/website-new/docs/en/ai/skill.mdx
index de915d9bc47..bba17e15232 100644
--- a/apps/website-new/docs/en/ai/skill.mdx
+++ b/apps/website-new/docs/en/ai/skill.mdx
@@ -40,6 +40,7 @@ With explicit sub-commands:
 /mf integrate
 /mf type-check
 /mf runtime-error RUNTIME-008
+/mf observability
 ```
 
 With natural language:
@@ -48,6 +49,7 @@ With natural language:
 /mf What's the difference between singleton and requiredVersion in shared?
 /mf Help me figure out why this project is not pulling remote types
 /mf Add Module Federation to the current project
+/mf I saw a Module Federation console error with traceId mf-...
 ```
 
 ## What `mf` supports
@@ -64,6 +66,7 @@ With natural language:
 | `config-check` | Troubleshoot config mistakes, missing files, and plugin mismatches |
 | `bridge-check` | Troubleshoot Bridge integration issues |
 | `runtime-error` | Troubleshoot explicit runtime error codes, especially `RUNTIME-001` and `RUNTIME-008` |
+| `observability` | Read observability reports, trace loading phases, and debug runtime/build loading failures |
 
 ## The most common workflows
 
@@ -96,10 +99,35 @@ If you already have a concrete problem:
 /mf shared-deps
 /mf config-check
 /mf runtime-error RUNTIME-008
+/mf observability
 ```
 
 At that point, the goal is not for you to manually investigate first. The goal is to let the agent start diagnosing immediately.
 
+### 4. Let the agent read MF observability
+
+For full loading observability, install the [Observability Plugin](../plugin/plugins/observability-plugin)
+in your app. When a browser console error prints a `traceId` and `read:`
+command, pass it to the skill:
+
+```text
+/mf observability
+I saw this Module Federation console error:
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+Please read the report and fix the issue.
+```
+
+For Node, SSR, or production uploads:
+
+```text
+/mf observability
+Read .mf/observability/latest.json and explain the likely owner and fix.
+```
+
 ## The one thing you really need to remember
 
 You do not need to read the docs first and then tell the agent what to do.
diff --git a/apps/website-new/docs/en/guide/runtime/runtime-hooks.mdx b/apps/website-new/docs/en/guide/runtime/runtime-hooks.mdx
index abf89363a3b..4cbcf0b06c8 100644
--- a/apps/website-new/docs/en/guide/runtime/runtime-hooks.mdx
+++ b/apps/website-new/docs/en/guide/runtime/runtime-hooks.mdx
@@ -1,5 +1,11 @@
 # Runtime Hooks
 
+## Hook return values
+
+For `SyncHook` and `AsyncHook`, returning `undefined` means the plugin only observes the event. It does not clear a value returned by an earlier plugin. A later plugin can still replace that value by returning another non-`undefined` value.
+
+For `SyncWaterfallHook` and `AsyncWaterfallHook`, return the full updated args object when you need to change the payload. Returning `undefined` keeps the current args and passes them to the next plugin.
+
 ## beforeInit
 
 `SyncWaterfallHook`
@@ -64,6 +70,28 @@ type BeforeRequestOptions ={
 }
 ```
 
+## afterMatchRemote
+
+`AsyncHook`
+
+Called after the runtime matches a `loadRemote` request to a configured remote. If matching fails, the hook is still called with `error`. It is useful for diagnostics, request tracing, and checking whether a failure happened before manifest or remoteEntry loading.
+
+* type
+
+```ts
+async function afterMatchRemote(args: AfterMatchRemoteOptions): Promise<void>
+
+type AfterMatchRemoteOptions ={
+  id: string;
+  options: ModuleFederationRuntimeOptions;
+  remote?: Remote;
+  expose?: string;
+  remoteInfo?: RemoteInfo;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
 ## afterResolve
 
 `AsyncWaterfallHook`
@@ -126,6 +154,33 @@ interface RemoteInfo {
 }
 ```
 
+## afterLoadRemote
+
+`AsyncHook`
+
+Called after a `loadRemote` request finishes. It runs for successful loads, failed loads, and loads recovered by `errorLoadRemote`. Use it to record the final remote loading status.
+
+`onLoad` runs before `afterLoadRemote` on a successful load. If a load fails and `errorLoadRemote` returns a fallback, `afterLoadRemote` receives the original `error` and `recovered: true`.
+
+* type
+
+```ts
+async function afterLoadRemote(args: AfterLoadRemoteOptions): Promise<void>
+
+type AfterLoadRemoteOptions ={
+  id: string;
+  expose?: string;
+  remote?: RemoteInfo;
+  options?: {
+    loadFactory?: boolean;
+    from?: 'build' | 'runtime';
+  };
+  error?: unknown;
+  recovered?: boolean;
+  origin: ModuleFederation;
+}
+```
+
 ## beforeInitContainer
 
 `AsyncWaterfallHook`
@@ -207,6 +262,8 @@ type ErrorLoadRemoteOptions ={
   options?: any;
   from: 'build' | 'runtime';
   lifecycle: 'beforeRequest' | 'beforeLoadShare' | 'afterResolve' | 'onLoad';
+  remote?: RemoteInfo;
+  expose?: string;
   origin: ModuleFederation;
 }
 ```
@@ -216,7 +273,9 @@ The `lifecycle` parameter indicates the stage where the error occurred:
 - `beforeRequest`: Error during initial request processing
 - `afterResolve`: Error during manifest loading (most common for network failures)
 - `onLoad`: Error during module loading and execution
-- `beforeLoadShare`: Error during shared dependency loading
+- `beforeLoadShare`: Error while loading a remoteEntry during shared dependency initialization
+
+If this hook returns a fallback module, the runtime uses that value to continue. If a diagnostics or logging plugin returns `undefined`, it does not clear a fallback returned by another plugin.
 
 * example
 
@@ -307,6 +366,51 @@ type BeforeLoadShareOptions ={
 }
 ```
 
+## afterLoadShare
+
+`SyncHook`
+
+Called after a shared dependency is successfully resolved by `loadShare` or `loadShareSync`. Use it to observe which provider and version were selected.
+
+* type
+
+```ts
+function afterLoadShare(args: AfterLoadShareOptions): void
+
+type AfterLoadShareOptions ={
+  pkgName: string;
+  shareInfo?: Partial<Shared>;
+  selectedShared?: Partial<Shared>;
+  shared: Options['shared'];
+  shareScopeMap: ShareScopeMap;
+  lifecycle: 'loadShare' | 'loadShareSync';
+  origin: ModuleFederation;
+}
+```
+
+## errorLoadShare
+
+`SyncHook`
+
+Called when shared dependency resolution fails or cannot select a valid shared dependency. It is useful for diagnostics around missing shared dependencies, version mismatch, and eager configuration errors.
+
+* type
+
+```ts
+function errorLoadShare(args: ErrorLoadShareOptions): void
+
+type ErrorLoadShareOptions ={
+  pkgName: string;
+  shareInfo?: Partial<Shared>;
+  shared: Options['shared'];
+  shareScopeMap: ShareScopeMap;
+  lifecycle: 'loadShare' | 'loadShareSync';
+  origin: ModuleFederation;
+  error?: unknown;
+  recovered?: boolean;
+}
+```
+
 ## initContainerShareScopeMap
 
 `SyncWaterfallHook`
@@ -459,6 +563,131 @@ interface PreloadAssets {
 
 `loaderHook` is used to intercept resource loading and module-factory resolution.
 
+## beforeInitRemote
+
+`AsyncHook`
+
+Called before initializing the remote container with `remoteEntry.init(...)`.
+
+* type
+
+```ts
+async function beforeInitRemote(args: BeforeInitRemoteOptions): Promise<void>
+
+type BeforeInitRemoteOptions ={
+  id?: string;
+  remoteInfo: RemoteInfo;
+  remoteSnapshot?: ModuleInfo;
+  origin: ModuleFederation;
+}
+```
+
+## afterInitRemote
+
+`AsyncHook`
+
+Called after remote container initialization succeeds or fails. When the remote was already initialized, `cached` is set to `true`.
+
+* type
+
+```ts
+async function afterInitRemote(args: AfterInitRemoteOptions): Promise<void>
+
+type AfterInitRemoteOptions ={
+  id?: string;
+  remoteInfo: RemoteInfo;
+  remoteSnapshot?: ModuleInfo;
+  remoteEntryExports?: RemoteEntryExports;
+  error?: unknown;
+  cached?: boolean;
+  origin: ModuleFederation;
+}
+```
+
+## beforeGetExpose
+
+`AsyncHook`
+
+Called before `remoteEntry.get(expose)`.
+
+* type
+
+```ts
+async function beforeGetExpose(args: BeforeGetExposeOptions): Promise<void>
+
+type BeforeGetExposeOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  remoteEntryExports: RemoteEntryExports;
+  origin: ModuleFederation;
+}
+```
+
+## afterGetExpose
+
+`AsyncHook`
+
+Called after `remoteEntry.get(expose)` succeeds or fails.
+
+* type
+
+```ts
+async function afterGetExpose(args: AfterGetExposeOptions): Promise<void>
+
+type AfterGetExposeOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  remoteEntryExports: RemoteEntryExports;
+  moduleFactory?: () => unknown | Promise<unknown>;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
+## beforeExecuteFactory
+
+`AsyncHook`
+
+Called before executing the exposed module factory. It is skipped when `loadRemote` is called with `loadFactory: false`.
+
+* type
+
+```ts
+async function beforeExecuteFactory(args: BeforeExecuteFactoryOptions): Promise<void>
+
+type BeforeExecuteFactoryOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  loadFactory: boolean;
+  origin: ModuleFederation;
+}
+```
+
+## afterExecuteFactory
+
+`AsyncHook`
+
+Called after the exposed module factory succeeds or fails. It is skipped when `loadRemote` is called with `loadFactory: false`.
+
+* type
+
+```ts
+async function afterExecuteFactory(args: AfterExecuteFactoryOptions): Promise<void>
+
+type AfterExecuteFactoryOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  loadFactory: boolean;
+  exposeModule?: unknown;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
 ## createScript
 
 `SyncHook`
@@ -473,6 +702,7 @@ function createScript(args: CreateScriptOptions): CreateScriptHookReturn
 type CreateScriptOptions ={
   url: string;
   attrs?: Record<string, any>;
+  remoteInfo?: RemoteInfo;
 }
 ```
 
@@ -506,7 +736,7 @@ The `fetch` function allows customizing the request that fetches the manifest JS
 - **Type**
 
 ```typescript
-function fetch(manifestUrl: string, requestInit: RequestInit): Promise<Response> | void | false;
+function fetch(manifestUrl: string, requestInit: RequestInit, remoteInfo?: RemoteInfo): Promise<Response> | void | false;
 ```
 
 - Example for including the credentials when fetching the manifest JSON:
@@ -542,6 +772,7 @@ function createLink(args: CreateLinkOptions): HTMLLinkElement | void
 type CreateLinkOptions ={
   url: string;
   attrs?: Record<string, any>;
+  remoteInfo?: RemoteInfo;
 }
 ```
 
@@ -566,6 +797,26 @@ type LoadEntryErrorOptions ={
 }
 ```
 
+## afterLoadEntry
+
+`AsyncHook`
+
+Called after loading a remoteEntry succeeds, fails, or is recovered by `loadEntryError`.
+
+* type
+
+```ts
+async function afterLoadEntry(args: AfterLoadEntryOptions): Promise<void>
+
+type AfterLoadEntryOptions ={
+  origin: ModuleFederation;
+  remoteInfo: RemoteInfo;
+  remoteEntryExports?: RemoteEntryExports | false | void;
+  error?: unknown;
+  recovered?: boolean;
+}
+```
+
 ## getModuleFactory
 
 `AsyncHook`
diff --git a/apps/website-new/docs/en/guide/runtime/runtime-plugins.mdx b/apps/website-new/docs/en/guide/runtime/runtime-plugins.mdx
index 5f8e28996b2..fef89ae300a 100644
--- a/apps/website-new/docs/en/guide/runtime/runtime-plugins.mdx
+++ b/apps/website-new/docs/en/guide/runtime/runtime-plugins.mdx
@@ -129,6 +129,8 @@ const mf = createInstance({
 | Customize injected scripts and links | `createScript`, `createLink` | You need to add attributes like `crossorigin`, timeouts, or custom script/link elements. When available, `remoteInfo` is provided so you can apply per-remote policy. |
 | Align or rewrite share scopes before remote init | `beforeInitContainer`, `initContainerShareScopeMap` | You need to change which share scope a remote initializes against |
 | Override the shared winner | `resolveShare` | You want to force a different shared implementation than the runtime would normally pick |
+| Observe remote load status | `afterMatchRemote`, `afterLoadRemote` | You need request tracing or final success/failure status for `loadRemote` |
+| Observe shared dependency status | `afterLoadShare`, `errorLoadShare` | You need to diagnose missing shared dependencies, version mismatch, or eager configuration errors |
 | Recover from load failures | `errorLoadRemote` | You need fallback modules, offline behavior, or layered recovery |
 | Implement a new remote loading strategy | `loadEntry` | You want to fully customize how a remote entry is loaded or support a new remote type |
 
diff --git a/apps/website-new/docs/en/guide/troubleshooting/runtime.mdx b/apps/website-new/docs/en/guide/troubleshooting/runtime.mdx
index eec6b4ff9bd..68e02ac73b5 100644
--- a/apps/website-new/docs/en/guide/troubleshooting/runtime.mdx
+++ b/apps/website-new/docs/en/guide/troubleshooting/runtime.mdx
@@ -20,6 +20,9 @@ This page collects runtime-related error codes and common troubleshooting guidan
 - [RUNTIME-009](#runtime-009)
 - [RUNTIME-010](#runtime-010)
 - [RUNTIME-012](#runtime-012)
+- [RUNTIME-013](#runtime-013)
+- [RUNTIME-014](#runtime-014)
+- [RUNTIME-015](#runtime-015)
 
 ## RUNTIME-001
 
@@ -352,6 +355,62 @@ When `loadShare` returns `false` — meaning the remote did not provide the shar
 
    Make sure the shared module name and version range are consistent between the host and all remotes, so a match can be found and the fallback is never reached with an empty `getter`.
 
+## RUNTIME-013
+
+<ErrorCodeTitle code='RUNTIME-013'/>
+
+### Reason
+
+The manifest can be reached and parsed as JSON, but it is not a valid Module Federation manifest.
+
+The most common case is that required fields such as `metaData`, `exposes`, or `shared` are missing. This usually means the URL returned the wrong JSON, a gateway returned incomplete data, or the producer did not emit a valid MF manifest.
+
+### Solution
+
+1. Open the manifestUrl from the error message directly and confirm that it returns an MF manifest, not another business JSON response or an empty object
+2. Check that manifest output is enabled in the producer and that the build artifact contains `metaData`, `exposes`, and `shared`
+3. Check whether a gateway, deployment platform, or proxy rewrote the manifest response
+4. If the observability plugin is enabled, start from `diagnosis.facts.url` and `diagnosis.actions`
+
+## RUNTIME-014
+
+<ErrorCodeTitle code='RUNTIME-014'/>
+
+### Reason
+
+The producer entry was loaded and initialized, but the producer did not export the requested expose.
+
+Common causes include:
+
+1. The expose name requested by the consumer is wrong
+2. The producer build config does not declare this expose
+3. The `./` prefix, letter case, or alias does not match
+4. The consumer is using an old build artifact and the latest producer expose has not been deployed
+
+### Solution
+
+1. Compare the consumer `loadRemote('remote/expose')` request with the producer `exposes` config
+2. Check whether the expose needs the `./` prefix, and verify that the case matches exactly
+3. If loading through manifest, check whether the manifest `exposes` list contains the module
+4. If the observability plugin is enabled, inspect `diagnosis.facts.expose` and the related `check-expose` action
+
+## RUNTIME-015
+
+<ErrorCodeTitle code='RUNTIME-015'/>
+
+### Reason
+
+The producer entry was loaded, but container initialization failed.
+
+This usually happens while the producer runs `init`, for example because shared dependency initialization failed, shareScope data did not match expectations, or the producer entry threw an internal error.
+
+### Solution
+
+1. Read the original error in the message; it points to the actual failure thrown during `init`
+2. Check shared config between the host and producer, especially shareScope, singleton, strictVersion, requiredVersion, and eager
+3. Confirm that the producer remoteEntry type and global name match the consumer config
+4. If the observability plugin is enabled, inspect `summary.phases.remoteEntry`, `diagnosis.facts`, and the `check-shared-provider` action
+
 ## Common Issues (No Error Code)
 
 ### Warning: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
diff --git a/apps/website-new/docs/en/plugin/plugins/_meta.json b/apps/website-new/docs/en/plugin/plugins/_meta.json
index 124735d30d1..0316025bb9c 100644
--- a/apps/website-new/docs/en/plugin/plugins/_meta.json
+++ b/apps/website-new/docs/en/plugin/plugins/_meta.json
@@ -1 +1 @@
-["index", "retry-plugin", "building-custom-retry-plugin"]
+["index", "retry-plugin", "observability-plugin", "building-custom-retry-plugin"]
diff --git a/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx b/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
new file mode 100644
index 00000000000..24f9835d940
--- /dev/null
+++ b/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
@@ -0,0 +1,263 @@
+---
+title: Observability Plugin
+description: Observe Module Federation loading, collect runtime and build reports, and give humans or AI agents enough facts to debug failures.
+---
+
+# Observability Plugin
+
+The Observability Plugin makes Module Federation loading observable. It records
+runtime loading events, summarizes the final result, prints a stable
+`traceId` when loading fails, and can correlate runtime failures with build
+information.
+
+The plugin is designed for Module Federation `2.5.0` and later. If a project is
+on an older MF version, runtime error codes still help with basic
+troubleshooting, but the richer report and loading observability workflow
+requires upgrading to `2.5.0+` and enabling this plugin.
+
+Use it when you want to answer questions such as:
+
+- Did this remote load successfully?
+- Which phase failed: manifest, remoteEntry, init, expose, factory, or shared?
+- Did the load recover through retry or fallback?
+- Which shared dependency provider and version were selected?
+- What report should I give to a human or AI coding agent?
+
+## Install
+
+```bash
+npm install @module-federation/observability-plugin
+```
+
+## Browser Runtime
+
+Use the default entry in browser runtime code.
+
+```ts title="mf-runtime.ts"
+import { createInstance } from '@module-federation/runtime';
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+export const observability = ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
+
+export const mf = createInstance({
+  name: 'runtime_host',
+  remotes: [
+    {
+      name: 'remote1',
+      entry: 'https://example.com/mf-manifest.json',
+    },
+  ],
+  plugins: [observability.plugin],
+});
+```
+
+When a Module Federation load fails, the plugin prints a compact
+`console.error` hint:
+
+```text
+[Module Federation] Observability report generated
+traceId: mf-...
+phase: manifest
+errorCode: RUNTIME-003
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+```
+
+Run the `read:` command in the browser console to get the full report.
+
+You can also read reports directly:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getLatestReport();
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getReport('mf-...');
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
+  remote: 'remote1',
+});
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.exportReport('mf-...');
+```
+
+## Production Runtime
+
+In production, avoid exposing a public browser reader by default. Keep console
+output small and upload reports through your own system.
+
+```ts title="mf-runtime.ts"
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+export const observability = ObservabilityPlugin({
+  level: 'summary',
+  browser: {
+    mode: 'production',
+  },
+  onReport(report) {
+    if (report.status === 'error' || report.summary.outcome === 'recovered') {
+      navigator.sendBeacon(
+        '/api/mf-observability',
+        JSON.stringify({
+          traceId: report.traceId,
+          status: report.status,
+          diagnosis: report.diagnosis,
+          summary: report.summary,
+          remote: report.remote,
+          shared: report.shared,
+          moduleInfo: report.moduleInfo,
+        }),
+      );
+    }
+  },
+});
+```
+
+In production browser mode, the console hint only contains `traceId` and known
+`errorCode`. The full report should come from `onReport`, `exportReport()`, or
+your own telemetry backend.
+
+## Node or SSR Runtime
+
+Use the Node entry when you want local report files.
+
+```ts title="mf-node-runtime.ts"
+import { createInstance } from '@module-federation/runtime';
+import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
+
+const observability = ObservabilityPlugin({
+  level: 'verbose',
+  fileOutput: true,
+  directory: '.mf/observability',
+});
+
+createInstance({
+  name: 'node_host',
+  remotes: [],
+  plugins: [observability.plugin],
+});
+```
+
+The Node entry writes:
+
+- `.mf/observability/latest.json`: latest complete report
+- `.mf/observability/events.jsonl`: event stream for multiple traces
+
+Read `latest.json` first. Use `events.jsonl` only when you need ordering or
+multiple traces.
+
+## Build Observability
+
+Add the build plugin next to your Module Federation build plugin when you want
+separate build-side evidence.
+
+```js title="webpack.config.js"
+const {
+  ModuleFederationPlugin,
+} = require('@module-federation/enhanced/webpack');
+const {
+  ObservabilityBuildPlugin,
+} = require('@module-federation/observability-plugin/build');
+
+const moduleFederationOptions = {
+  name: 'runtime_host',
+  remotes: {
+    remote1: 'remote1@https://example.com/mf-manifest.json',
+  },
+  exposes: {
+    './Button': './src/Button',
+  },
+  shared: {
+    react: { singleton: true, requiredVersion: '^18.0.0' },
+  },
+};
+
+module.exports = {
+  plugins: [
+    new ModuleFederationPlugin(moduleFederationOptions),
+    new ObservabilityBuildPlugin({
+      moduleFederation: moduleFederationOptions,
+    }),
+  ],
+};
+```
+
+Build observability can write:
+
+- `.mf/observability/build-info.json`
+- `.mf/observability/build-report.json`
+
+Runtime reports do not embed these files. When debugging needs build evidence,
+read the build file separately and compare it with the runtime report.
+
+## Mark Business Success
+
+Module Federation can know that a remote module loaded. It cannot always know
+that your business component finished its own rendering or data loading. Call
+`markComponentLoaded` when your application considers the component ready.
+
+```ts
+observability.markComponentLoaded({
+  requestId: 'remote1/Button',
+  componentName: 'Button',
+  metadata: {
+    route: '/dashboard',
+  },
+});
+```
+
+The report will include `component:business-loaded` and
+`summary.outcome: "component-loaded"`.
+
+## Use With the `mf` Skill
+
+Install the skill:
+
+```bash
+npx skills add module-federation/core --skill mf -y
+```
+
+When the console prints an observability hint, ask your agent:
+
+```text
+/mf observability
+I saw this Module Federation console error:
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+Please read the report and fix the issue.
+```
+
+If you are in Node or SSR, give the agent the file path instead:
+
+```text
+/mf observability
+Read .mf/observability/latest.json and explain the likely owner and fix.
+```
+
+If your production app uploads reports, give the uploaded report or `traceId`
+to the agent:
+
+```text
+/mf observability
+Here is the uploaded report for traceId mf-...
+Tell me whether this is a host, remote, shared, network, or build issue.
+```
+
+## What the AI Reads First
+
+The skill reads fields in this order:
+
+1. `diagnosis`
+2. `summary`
+3. `moduleInfo`
+4. `events`
+
+If build-side evidence is needed, read `.mf/observability/build-info.json` or
+`.mf/observability/build-report.json` as a separate file.
+
+Reports omit `undefined` fields. If a field is absent, treat it as not observed
+or not relevant for this trace.
diff --git a/apps/website-new/docs/zh/ai/index.mdx b/apps/website-new/docs/zh/ai/index.mdx
index a517ce323c4..3505c8a4acb 100644
--- a/apps/website-new/docs/zh/ai/index.mdx
+++ b/apps/website-new/docs/zh/ai/index.mdx
@@ -46,9 +46,31 @@ npx skills add module-federation/core --skill mf -y
 - 帮你分析类型问题
 - 帮你看共享依赖冲突
 - 帮你分析远端模块信息
+- 帮你读取观测报告并排查 MF 加载失败
 
 👉 [查看 Agent Skills 详细说明](./skill)
 
+## 观测和调试 MF 加载
+
+如果你希望 AI coding agent 基于真实运行时信息排查 Module Federation
+加载问题，需要先接入 [观测插件](../plugin/plugins/observability-plugin)。
+`/mf observability` 这个 skill 负责帮你接入、读取和分析报告；真正的运行时证据由观测插件采集。
+
+加载失败后，浏览器控制台会打印 `traceId`，开发环境还会打印 `read:` 命令。把这段提示交给 Agent：
+
+```text
+/mf observability
+我看到了这条 Module Federation console error：
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+请读取报告并帮我修复问题。
+```
+
+如果是 Node 或 SSR，让 Agent 读取 `.mf/observability/latest.json`。如果是生产环境，建议通过插件的 `onReport` 回调把报告上传到自己的系统，然后把上传报告或 traceId 交给 Agent。
+
 ## 不装 Skill 也能先用
 
 如果你只是临时问一下，也可以直接把下面这句话发给你的 Agent：
@@ -87,4 +109,5 @@ https://module-federation.io/guide/basic/runtime.md
 
 1. 先装 `mf`
 2. 问一个你当前最关心的问题
-3. 再看 [Skills 说明](./skill)，了解它支持哪些子命令
+3. 需要 MF 加载可观测时，先接入 [观测插件](../plugin/plugins/observability-plugin)
+4. 再看 [Skills 说明](./skill)，了解它支持哪些子命令
diff --git a/apps/website-new/docs/zh/ai/skill.mdx b/apps/website-new/docs/zh/ai/skill.mdx
index b67d6c58f2d..ac0678583c5 100644
--- a/apps/website-new/docs/zh/ai/skill.mdx
+++ b/apps/website-new/docs/zh/ai/skill.mdx
@@ -40,6 +40,7 @@ https://github.com/module-federation/core/tree/main/skills/mf
 /mf integrate
 /mf type-check
 /mf runtime-error RUNTIME-008
+/mf observability 帮我接入观测插件，记录 MF 加载过程
 ```
 
 直接写自然语言：
@@ -48,6 +49,8 @@ https://github.com/module-federation/core/tree/main/skills/mf
 /mf shared 里的 singleton 和 requiredVersion 有什么区别？
 /mf 帮我看看这个项目为什么 remote types 没拉下来
 /mf 帮我把 Module Federation 接到当前项目里
+/mf 我想让 AI 能看见 MF remote 和 shared 的加载状态，应该怎么接
+/mf 我看到 Module Federation console error，traceId 是 mf-...
 ```
 
 ## `mf` 目前支持什么
@@ -64,6 +67,7 @@ https://github.com/module-federation/core/tree/main/skills/mf
 | `config-check` | 排查配置错误、暴露路径错误、插件不匹配 |
 | `bridge-check` | 排查 Bridge 接入问题 |
 | `runtime-error` | 排查明确的运行时报错码，尤其是 `RUNTIME-001` / `RUNTIME-008` |
+| `observability` | 配合观测插件记录 MF 加载过程，读取观测报告，排查运行时和构建加载问题 |
 
 ## 最常用的几类场景
 
@@ -96,10 +100,44 @@ https://github.com/module-federation/core/tree/main/skills/mf
 /mf shared-deps
 /mf config-check
 /mf runtime-error RUNTIME-008
+/mf observability
 ```
 
 这时候重点不是你自己查，而是让 Agent 直接开始定位。
 
+### 4. 让 Agent 分析 MF 加载过程
+
+如果你希望 AI 不只是“看到报错”，而是能知道 MF 的 remote、shared、组件加载状态在哪里成功、在哪里失败，可以用 `observability` 子命令。
+
+要读取真实的 MF 加载报告，需要先接入 [观测插件](../plugin/plugins/observability-plugin)。观测插件会把 MF 加载过程整理成报告，包括加载成功、加载失败、错误原因、`traceId` 和读取方式；skill 负责帮你接入、读取和分析这些信息，再判断问题更可能在宿主、远端、共享依赖、构建配置还是部署地址。
+
+如果你还没有接入观测插件，可以先这样问：
+
+```text
+/mf observability
+帮我看当前项目怎么接入观测插件，记录 MF 加载过程。
+```
+
+接入后，如果你看到浏览器控制台打印了 `traceId` 和 `read:` 命令，再把它交给 skill：
+
+```text
+/mf observability
+我看到了这条 Module Federation console error：
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+请读取报告并帮我修复问题。
+```
+
+这里的“报告”不是让你手动整理出来的长日志，而是观测插件生成的结构化结果。浏览器里通常通过控制台里的 `read:` 命令读取；Node、SSR 或生产环境上报场景，可以让 Agent 读取文件或你们自己上报系统里的报告：
+
+```text
+/mf observability
+请读取 .mf/observability/latest.json，告诉我可能是谁的问题，以及应该怎么修。
+```
+
 ## 你真正需要记住的只有一件事
 
 不是你自己先读文档、再告诉 Agent 该怎么办。
diff --git a/apps/website-new/docs/zh/guide/runtime/runtime-hooks.mdx b/apps/website-new/docs/zh/guide/runtime/runtime-hooks.mdx
index 7522fddf814..c50e5d8e773 100644
--- a/apps/website-new/docs/zh/guide/runtime/runtime-hooks.mdx
+++ b/apps/website-new/docs/zh/guide/runtime/runtime-hooks.mdx
@@ -1,5 +1,11 @@
 # Runtime Hooks
 
+## Hook 返回值
+
+对于 `SyncHook` 和 `AsyncHook`，返回 `undefined` 表示插件只观察事件，不会清空前一个插件已经返回的结果。后续插件如果返回新的非 `undefined` 值，仍然可以替换这个结果。
+
+对于 `SyncWaterfallHook` 和 `AsyncWaterfallHook`，需要改写参数时返回完整的新 args 对象；返回 `undefined` 会保留当前 args，并继续传给下一个插件。
+
 ## beforeInit
 
 `SyncWaterfallHook`
@@ -64,6 +70,28 @@ type BeforeRequestOptions ={
 }
 ```
 
+## afterMatchRemote
+
+`AsyncHook`
+
+在 runtime 把一次 `loadRemote` 请求匹配到具体 remote 之后触发。如果匹配失败，也会带着 `error` 触发。适合用于诊断、链路追踪，以及判断问题是否发生在 manifest 或 remoteEntry 加载之前。
+
+* type
+
+```ts
+async function afterMatchRemote(args: AfterMatchRemoteOptions): Promise<void>
+
+type AfterMatchRemoteOptions ={
+  id: string;
+  options: ModuleFederationRuntimeOptions;
+  remote?: Remote;
+  expose?: string;
+  remoteInfo?: RemoteInfo;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
 ## afterResolve
 
 `AsyncWaterfallHook`
@@ -128,6 +156,33 @@ interface RemoteInfo {
 }
 ```
 
+## afterLoadRemote
+
+`AsyncHook`
+
+在一次 `loadRemote` 请求结束后触发。加载成功、加载失败、以及通过 `errorLoadRemote` 兜底恢复的场景都会触发。适合记录 remote 加载的最终状态。
+
+成功加载时，`onLoad` 会先于 `afterLoadRemote` 触发。如果加载失败后由 `errorLoadRemote` 返回兜底结果，`afterLoadRemote` 会带上原始 `error` 和 `recovered: true`。
+
+* type
+
+```ts
+async function afterLoadRemote(args: AfterLoadRemoteOptions): Promise<void>
+
+type AfterLoadRemoteOptions ={
+  id: string;
+  expose?: string;
+  remote?: RemoteInfo;
+  options?: {
+    loadFactory?: boolean;
+    from?: 'build' | 'runtime';
+  };
+  error?: unknown;
+  recovered?: boolean;
+  origin: ModuleFederation;
+}
+```
+
 ## beforeInitContainer
 
 `AsyncWaterfallHook`
@@ -209,6 +264,8 @@ type ErrorLoadRemoteOptions ={
   options?: any;
   from: 'build' | 'runtime';
   lifecycle: 'beforeRequest' | 'beforeLoadShare' | 'afterResolve' | 'onLoad';
+  remote?: RemoteInfo;
+  expose?: string;
   origin: ModuleFederation;
 }
 ```
@@ -218,7 +275,9 @@ type ErrorLoadRemoteOptions ={
 - `beforeRequest`: 处理 remote 请求参数阶段出错
 - `afterResolve`: 解析/拉取 manifest 阶段出错（常见于网络异常）
 - `onLoad`: 加载 exposes 模块阶段出错
-- `beforeLoadShare`: 加载 shared 依赖阶段出错
+- `beforeLoadShare`: shared 初始化过程中加载 remoteEntry 出错
+
+如果这个 hook 返回兜底模块，runtime 会使用这个值继续执行。如果诊断或日志插件返回 `undefined`，不会清空其他插件已经返回的兜底结果。
 
 * example
 
@@ -275,6 +334,51 @@ type BeforeLoadShareOptions ={
 }
 ```
 
+## afterLoadShare
+
+`SyncHook`
+
+在 `loadShare` 或 `loadShareSync` 成功解析 shared 依赖后触发。适合观察最终选中了哪个提供方和版本。
+
+* type
+
+```ts
+function afterLoadShare(args: AfterLoadShareOptions): void
+
+type AfterLoadShareOptions ={
+  pkgName: string;
+  shareInfo?: Partial<Shared>;
+  selectedShared?: Partial<Shared>;
+  shared: Options['shared'];
+  shareScopeMap: ShareScopeMap;
+  lifecycle: 'loadShare' | 'loadShareSync';
+  origin: ModuleFederation;
+}
+```
+
+## errorLoadShare
+
+`SyncHook`
+
+在 shared 依赖解析失败，或者无法选中可用 shared 依赖时触发。适合诊断 shared 缺失、版本不匹配、eager 配置错误等问题。
+
+* type
+
+```ts
+function errorLoadShare(args: ErrorLoadShareOptions): void
+
+type ErrorLoadShareOptions ={
+  pkgName: string;
+  shareInfo?: Partial<Shared>;
+  shared: Options['shared'];
+  shareScopeMap: ShareScopeMap;
+  lifecycle: 'loadShare' | 'loadShareSync';
+  origin: ModuleFederation;
+  error?: unknown;
+  recovered?: boolean;
+}
+```
+
 ## initContainerShareScopeMap
 
 `SyncWaterfallHook`
@@ -427,6 +531,131 @@ interface PreloadAssets {
 
 `loaderHook` 用于拦截资源加载与工厂获取流程。
 
+## beforeInitRemote
+
+`AsyncHook`
+
+在调用 `remoteEntry.init(...)` 初始化 remote 容器之前触发。
+
+* type
+
+```ts
+async function beforeInitRemote(args: BeforeInitRemoteOptions): Promise<void>
+
+type BeforeInitRemoteOptions ={
+  id?: string;
+  remoteInfo: RemoteInfo;
+  remoteSnapshot?: ModuleInfo;
+  origin: ModuleFederation;
+}
+```
+
+## afterInitRemote
+
+`AsyncHook`
+
+在 remote 容器初始化成功或失败后触发。如果 remote 已经初始化过，会带上 `cached: true`。
+
+* type
+
+```ts
+async function afterInitRemote(args: AfterInitRemoteOptions): Promise<void>
+
+type AfterInitRemoteOptions ={
+  id?: string;
+  remoteInfo: RemoteInfo;
+  remoteSnapshot?: ModuleInfo;
+  remoteEntryExports?: RemoteEntryExports;
+  error?: unknown;
+  cached?: boolean;
+  origin: ModuleFederation;
+}
+```
+
+## beforeGetExpose
+
+`AsyncHook`
+
+在调用 `remoteEntry.get(expose)` 之前触发。
+
+* type
+
+```ts
+async function beforeGetExpose(args: BeforeGetExposeOptions): Promise<void>
+
+type BeforeGetExposeOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  remoteEntryExports: RemoteEntryExports;
+  origin: ModuleFederation;
+}
+```
+
+## afterGetExpose
+
+`AsyncHook`
+
+在 `remoteEntry.get(expose)` 成功或失败后触发。
+
+* type
+
+```ts
+async function afterGetExpose(args: AfterGetExposeOptions): Promise<void>
+
+type AfterGetExposeOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  remoteEntryExports: RemoteEntryExports;
+  moduleFactory?: () => unknown | Promise<unknown>;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
+## beforeExecuteFactory
+
+`AsyncHook`
+
+在执行 exposed module factory 之前触发。`loadRemote` 使用 `loadFactory: false` 时不会触发。
+
+* type
+
+```ts
+async function beforeExecuteFactory(args: BeforeExecuteFactoryOptions): Promise<void>
+
+type BeforeExecuteFactoryOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  loadFactory: boolean;
+  origin: ModuleFederation;
+}
+```
+
+## afterExecuteFactory
+
+`AsyncHook`
+
+在 exposed module factory 执行成功或失败后触发。`loadRemote` 使用 `loadFactory: false` 时不会触发。
+
+* type
+
+```ts
+async function afterExecuteFactory(args: AfterExecuteFactoryOptions): Promise<void>
+
+type AfterExecuteFactoryOptions ={
+  id: string;
+  expose: string;
+  moduleInfo: RemoteInfo;
+  loadFactory: boolean;
+  exposeModule?: unknown;
+  error?: unknown;
+  origin: ModuleFederation;
+}
+```
+
 ## createScript
 
 `SyncHook`
@@ -441,6 +670,7 @@ function createScript(args: CreateScriptOptions): CreateScriptHookReturn
 type CreateScriptOptions ={
   url: string;
   attrs?: Record<string, any>;
+  remoteInfo?: RemoteInfo;
 }
 ```
 
@@ -474,7 +704,7 @@ const changeScriptAttributePlugin: () => ModuleFederationRuntimePlugin =
 - **Type**
 
 ```typescript
-function fetch(manifestUrl: string, requestInit: RequestInit): Promise<Response> | void | false;
+function fetch(manifestUrl: string, requestInit: RequestInit, remoteInfo?: RemoteInfo): Promise<Response> | void | false;
 ```
 
 - 示例：在获取清单（manifest）JSON 时包含凭证：
@@ -510,6 +740,7 @@ function createLink(args: CreateLinkOptions): HTMLLinkElement | void
 type CreateLinkOptions ={
   url: string;
   attrs?: Record<string, any>;
+  remoteInfo?: RemoteInfo;
 }
 ```
 
@@ -534,6 +765,26 @@ type LoadEntryErrorOptions ={
 }
 ```
 
+## afterLoadEntry
+
+`AsyncHook`
+
+在 remoteEntry 加载成功、失败，或被 `loadEntryError` 恢复之后触发。
+
+* type
+
+```ts
+async function afterLoadEntry(args: AfterLoadEntryOptions): Promise<void>
+
+type AfterLoadEntryOptions ={
+  origin: ModuleFederation;
+  remoteInfo: RemoteInfo;
+  remoteEntryExports?: RemoteEntryExports | false | void;
+  error?: unknown;
+  recovered?: boolean;
+}
+```
+
 ## getModuleFactory
 
 `AsyncHook`
diff --git a/apps/website-new/docs/zh/guide/runtime/runtime-plugins.mdx b/apps/website-new/docs/zh/guide/runtime/runtime-plugins.mdx
index 4d20c38d747..55ee0d28bd4 100644
--- a/apps/website-new/docs/zh/guide/runtime/runtime-plugins.mdx
+++ b/apps/website-new/docs/zh/guide/runtime/runtime-plugins.mdx
@@ -133,6 +133,8 @@ const mf = createInstance({
 | 自定义 script / link 注入 | `createScript`、`createLink` | 需要加 `crossorigin`、timeout、特殊 script/link 属性；在具备 remote 上下文时会额外提供 `remoteInfo`，便于按 remote 做策略 |
 | 在 remote init 前对齐 / 改写共享池 | `beforeInitContainer`、`initContainerShareScopeMap` | 需要控制 remote 初始化时使用哪个 share scope |
 | 改写 shared 最终命中结果 | `resolveShare` | 需要强制命中某个 shared，而不是用 runtime 默认选择 |
+| 观测 remote 加载状态 | `afterMatchRemote`、`afterLoadRemote` | 需要记录 `loadRemote` 的请求链路或最终成功/失败状态 |
+| 观测 shared 依赖状态 | `afterLoadShare`、`errorLoadShare` | 需要诊断 shared 缺失、版本不匹配、eager 配置错误等问题 |
 | 加载失败时兜底 | `errorLoadRemote` | 需要离线兜底、fallback module、分层恢复策略 |
 | 扩展新的 remote 加载方式 | `loadEntry` | 需要完整接管 remote entry 加载过程，或实现新的 remote 类型 |
 
diff --git a/apps/website-new/docs/zh/guide/troubleshooting/runtime.mdx b/apps/website-new/docs/zh/guide/troubleshooting/runtime.mdx
index 47f32ef96bc..71aba60ee17 100644
--- a/apps/website-new/docs/zh/guide/troubleshooting/runtime.mdx
+++ b/apps/website-new/docs/zh/guide/troubleshooting/runtime.mdx
@@ -20,6 +20,9 @@ import { Tab, Tabs } from '@theme';
 - [RUNTIME-009](#runtime-009)
 - [RUNTIME-010](#runtime-010)
 - [RUNTIME-012](#runtime-012)
+- [RUNTIME-013](#runtime-013)
+- [RUNTIME-014](#runtime-014)
+- [RUNTIME-015](#runtime-015)
 
 ## RUNTIME-001
 
@@ -349,6 +352,62 @@ ScriptExecutionError 表示脚本已成功下载，重试不会解决此类问
 
    确保宿主与子应用配置的共享模块名称、版本范围一致，避免因无法匹配而导致回退到空的 `getter`。
 
+## RUNTIME-013
+
+<ErrorCodeTitle code='RUNTIME-013'/>
+
+### 原因
+
+manifest 可以访问并解析为 JSON，但它不是有效的 Module Federation manifest。
+
+最常见的情况是返回内容缺少必要字段，例如 `metaData`、`exposes` 或 `shared`。这通常说明访问到了错误的 JSON、网关返回了不完整数据，或生产者没有产出正确的 MF manifest。
+
+### 解决方法
+
+1. 直接打开错误信息里的 manifestUrl，确认返回内容是 MF manifest，而不是其他业务 JSON 或空对象
+2. 检查生产者是否开启了 manifest 输出，并确认构建产物里包含 `metaData`、`exposes`、`shared`
+3. 检查网关、部署平台或代理规则是否改写了 manifest 响应
+4. 如果使用观测插件，优先查看报告中的 `diagnosis.facts.url` 和 `diagnosis.actions`
+
+## RUNTIME-014
+
+<ErrorCodeTitle code='RUNTIME-014'/>
+
+### 原因
+
+生产者入口已经加载并初始化，但生产者没有导出本次请求的 expose。
+
+常见原因包括：
+
+1. 消费者请求的 expose 名称写错
+2. 生产者构建配置中没有声明这个 expose
+3. `./` 前缀、大小写或别名不一致
+4. 消费者使用了旧的构建产物，生产者最新 expose 还没有部署
+
+### 解决方法
+
+1. 对比消费者的 `loadRemote('remote/expose')` 请求和生产者的 `exposes` 配置
+2. 检查 expose 是否需要带 `./`，并确认大小写完全一致
+3. 如果通过 manifest 加载，查看 manifest 中 `exposes` 列表是否包含该模块
+4. 如果使用观测插件，查看报告里的 `diagnosis.facts.expose` 和相关 `check-expose` 建议
+
+## RUNTIME-015
+
+<ErrorCodeTitle code='RUNTIME-015'/>
+
+### 原因
+
+生产者入口文件已经加载，但在初始化容器时失败。
+
+这类问题通常发生在生产者执行 `init` 时，例如共享依赖初始化异常、shareScope 数据不符合预期，或生产者入口文件内部逻辑抛错。
+
+### 解决方法
+
+1. 查看错误信息里的原始异常，它会说明 `init` 过程中真正抛出的错误
+2. 检查消费者和生产者的 shared 配置，尤其是 shareScope、singleton、strictVersion、requiredVersion 和 eager
+3. 确认生产者的 remoteEntry 类型和全局名与消费者配置一致
+4. 如果使用观测插件，查看 `summary.phases.remoteEntry`、`diagnosis.facts` 和 `check-shared-provider` 建议
+
 ## 常见问题（无错误码）
 
 ### Warning: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
diff --git a/apps/website-new/docs/zh/plugin/plugins/_meta.json b/apps/website-new/docs/zh/plugin/plugins/_meta.json
index 1f1c967c866..5d7d71f5ddc 100644
--- a/apps/website-new/docs/zh/plugin/plugins/_meta.json
+++ b/apps/website-new/docs/zh/plugin/plugins/_meta.json
@@ -1 +1 @@
-["retry-plugin"]
+["retry-plugin", "observability-plugin"]
diff --git a/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx b/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
new file mode 100644
index 00000000000..f6bdb2aa551
--- /dev/null
+++ b/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
@@ -0,0 +1,392 @@
+---
+title: 观测插件
+description: 观测 Module Federation 加载过程，收集运行时和构建侧信息，并给人或 AI 足够的信息定位问题。
+---
+
+# 观测插件
+
+观测插件用于让 Module Federation 加载过程可观测。它会记录运行时加载事件，整理最终加载结果，并在加载失败时打印稳定的 `traceId`。构建侧信息由构建观测插件单独写出。
+
+该插件面向 Module Federation `2.5.0` 及以上版本。如果项目还在更早的 MF
+版本，仍然可以先用运行时错误码做基础排查；但更完整的报告和加载观测链路需要升级到
+`2.5.0+` 并启用这个插件。
+
+它适合回答这些问题：
+
+- 这个 remote 是否真的加载成功？
+- 失败发生在 manifest、remoteEntry、init、expose、factory 还是 shared？
+- 这次加载是否通过 retry 或 fallback 恢复了？
+- 这次命中了哪个 shared provider 和版本？
+- 应该把哪份报告交给人或 AI coding agent 排查？
+
+## 安装
+
+```bash
+npm install @module-federation/observability-plugin
+```
+
+## Browser
+
+浏览器运行时使用默认入口。开发环境和生产环境的接入方式一样，区别只在于传给 `ObservabilityPlugin` 的参数。
+
+import { Tab, Tabs } from '@theme';
+
+<Tabs>
+  <Tab label="Build Plugin（使用构建插件）">
+  如果应用已经通过构建插件注册 Module Federation，推荐用 `runtimePlugins` 注入观测插件。
+
+  先创建一个运行时插件文件：
+
+  ```ts title="mf-observability-runtime-plugin.ts"
+  import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+  import type {
+    ObservabilityPluginOptions,
+    ObservabilityController,
+  } from '@module-federation/observability-plugin';
+
+  let observability: ObservabilityController | undefined;
+
+  export function getObservability() {
+    return observability;
+  }
+
+  export default function mfObservabilityRuntimePlugin(
+    options: ObservabilityPluginOptions = {},
+  ) {
+    observability = ObservabilityPlugin(options);
+
+    return observability.plugin;
+  }
+  ```
+
+  然后在 Module Federation 构建配置中注入它：
+
+  ```ts title="module-federation.config.ts"
+  import path from 'node:path';
+
+  export default {
+    name: 'runtime_host',
+    remotes: {
+      remote1: 'remote1@https://example.com/mf-manifest.json',
+    },
+    runtimePlugins: [
+      [
+        path.resolve(__dirname, './mf-observability-runtime-plugin.ts'),
+        {
+          level: 'verbose',
+          browser: {
+            enabled: true,
+            scope: 'runtime_host',
+          },
+        },
+      ],
+    ],
+  };
+  ```
+
+  如果业务代码需要主动标记组件加载成功，可以从同一个插件文件导入 `getObservability()`。
+
+  ```ts
+  import { getObservability } from './mf-observability-runtime-plugin';
+
+  getObservability()?.markComponentLoaded({
+    requestId: 'remote1/Button',
+    componentName: 'Button',
+  });
+  ```
+  </Tab>
+
+  <Tab label="Pure Runtime（未使用构建插件）">
+  如果没有使用构建插件，可以在创建 runtime 实例时直接注册观测插件。
+
+  ```ts title="mf-runtime.ts"
+  import { createInstance } from '@module-federation/runtime';
+  import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+  export const observability = ObservabilityPlugin({
+    level: 'verbose',
+    browser: {
+      enabled: true,
+      scope: 'runtime_host',
+    },
+  });
+
+  export const mf = createInstance({
+    name: 'runtime_host',
+    remotes: [
+      {
+        name: 'remote1',
+        entry: 'https://example.com/mf-manifest.json',
+      },
+    ],
+    plugins: [observability.plugin],
+  });
+  ```
+  </Tab>
+</Tabs>
+
+## 开发和生产参数
+
+当 Module Federation 加载失败时，插件会打印一条简短的 `console.error`：
+
+```text
+[Module Federation] Observability report generated
+traceId: mf-...
+phase: manifest
+errorCode: RUNTIME-003
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+```
+
+在浏览器控制台执行 `read:` 后面的命令，就能拿到完整报告。
+
+也可以直接读取：
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getLatestReport();
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getReport('mf-...');
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
+  remote: 'remote1',
+});
+window.__FEDERATION__.__OBSERVABILITY__.runtime_host.exportReport('mf-...');
+```
+
+开发环境通常打开浏览器读取入口，方便人或 AI coding agent 直接读取报告：
+
+```ts title="mf-runtime.ts"
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+export const observability = ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
+```
+
+生产环境仍然使用同一个插件，只是参数更保守：console 只保留 `traceId` 和已知 `errorCode`，完整报告通过业务自己的系统上报。
+
+```ts title="mf-runtime.ts"
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+export const observability = ObservabilityPlugin({
+  level: 'summary',
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+    mode: 'production',
+  },
+  onReport(report) {
+    if (report.status === 'error' || report.summary.outcome === 'recovered') {
+      navigator.sendBeacon(
+        '/api/mf-observability',
+        JSON.stringify({
+          traceId: report.traceId,
+          status: report.status,
+          diagnosis: report.diagnosis,
+          summary: report.summary,
+          remote: report.remote,
+          shared: report.shared,
+          moduleInfo: report.moduleInfo,
+        }),
+      );
+    }
+  },
+});
+```
+
+生产环境浏览器模式下，console 只包含 `traceId` 和已知 `errorCode`。完整报告应通过 `onReport`、`exportReport()` 或业务自己的上报系统获取。
+
+## Browser 参数
+
+`ObservabilityPlugin(options)` 支持以下参数：
+
+| 参数 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | 是否启用观测插件。关闭后不记录事件、不生成报告。 |
+| `level` | `'summary' \| 'verbose'` | `'summary'` | 报告详细程度。`summary` 保留摘要和关键事件，`verbose` 保留完整事件时间线。 |
+| `maxEvents` | `number` | 内置上限 | 单个插件实例最多保留的事件数量，避免长时间运行时无限增长。 |
+| `console` | `boolean` | `true` | 加载失败时是否打印 `console.error` 提示。 |
+| `printRawStack` | `boolean` | `false` | 是否把原始错误栈打印到 console。默认关闭，避免生产环境输出过多细节。 |
+| `stackTrace.enabled` | `boolean` | `true` | 是否在报告中保存裁剪后的错误栈。 |
+| `stackTrace.maxLines` | `number` | 内置上限 | 错误栈最多保留多少行。 |
+| `stackTrace.maxLength` | `number` | 内置上限 | 错误栈最多保留多少字符。 |
+| `browser.enabled` | `boolean` | `false` | 是否把读取入口挂到 `window.__FEDERATION__.__OBSERVABILITY__`。 |
+| `browser.scope` | `string` | host 名称 | 浏览器读取入口的命名空间，例如 `runtime_host`。 |
+| `browser.mode` | `'development' \| 'production'` | `'development'` | 浏览器输出模式。生产模式下 console 只输出最小提示。 |
+| `onEvent` | `(event, report, context) => void` | `undefined` | 每次记录观测事件时触发，适合接入自定义日志系统。 |
+| `onReport` | `(report, context) => void` | `undefined` | 报告更新时触发，生产环境常用它上传失败或恢复报告。 |
+| `onRawError` | `(error, context) => void` | `undefined` | 捕获原始错误对象时触发，适合接入业务自己的错误系统。 |
+
+生产环境推荐至少设置：
+
+```ts
+ObservabilityPlugin({
+  level: 'summary',
+  browser: {
+    mode: 'production',
+  },
+  onReport(report) {
+    // 上传到业务自己的系统
+  },
+});
+```
+
+## Node 或 SSR 运行时
+
+需要本地观测文件时，使用 Node 专用入口。
+
+```ts title="mf-node-runtime.ts"
+import { createInstance } from '@module-federation/runtime';
+import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
+
+const observability = ObservabilityPlugin({
+  level: 'verbose',
+  fileOutput: true,
+  directory: '.mf/observability',
+});
+
+createInstance({
+  name: 'node_host',
+  remotes: [],
+  plugins: [observability.plugin],
+});
+```
+
+Node 入口会写：
+
+- `.mf/observability/latest.json`：最近一次完整报告
+- `.mf/observability/events.jsonl`：多次 trace 的事件流水
+
+优先读 `latest.json`。只有需要查看事件顺序或多条 trace 时，再读 `events.jsonl`。
+
+Node 入口继承运行时参数，并额外支持：
+
+| 参数 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `fileOutput` | `boolean` | `false` | 是否写出本地观测文件。 |
+| `directory` | `string` | `'.mf/observability'` | 观测文件输出目录。 |
+| `latestFile` | `string` | `'latest.json'` | 最近一次完整报告的文件名。 |
+| `eventsFile` | `string` | `'events.jsonl'` | 事件流水文件名。 |
+
+## 构建观测
+
+如果希望保留构建侧证据，把构建观测插件放到 Module Federation 构建插件旁边。
+
+```js title="webpack.config.js"
+const {
+  ModuleFederationPlugin,
+} = require('@module-federation/enhanced/webpack');
+const {
+  ObservabilityBuildPlugin,
+} = require('@module-federation/observability-plugin/build');
+
+const moduleFederationOptions = {
+  name: 'runtime_host',
+  remotes: {
+    remote1: 'remote1@https://example.com/mf-manifest.json',
+  },
+  exposes: {
+    './Button': './src/Button',
+  },
+  shared: {
+    react: { singleton: true, requiredVersion: '^18.0.0' },
+  },
+};
+
+module.exports = {
+  plugins: [
+    new ModuleFederationPlugin(moduleFederationOptions),
+    new ObservabilityBuildPlugin({
+      moduleFederation: moduleFederationOptions,
+    }),
+  ],
+};
+```
+
+构建观测可以写出：
+
+- `.mf/observability/build-info.json`
+- `.mf/observability/build-report.json`
+
+运行时报告不会内嵌这两个文件。排查时如果需要构建侧证据，单独读取构建文件，再和运行时报告对照。
+
+`ObservabilityBuildPlugin(options)` 支持以下参数：
+
+| 参数 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | 是否启用构建观测插件。 |
+| `outputFile` | `string` | `'.mf/observability/build-info.json'` | 成功构建时写出的构建信息文件。 |
+| `errorReport` | `false \| object` | `{}` | 构建失败时是否写出构建错误观测报告。设为 `false` 可关闭。 |
+| `errorReport.outputFile` | `string` | `'.mf/observability/build-report.json'` | 构建错误观测报告文件路径。 |
+| `cwd` | `string` | 编译上下文 | 输出文件的相对目录基准。 |
+| `bundler` | `string` | 自动识别 | 手动指定 bundler 名称。 |
+| `bundlerVersion` | `string` | 自动识别 | 手动指定 bundler 版本。 |
+| `pluginVersion` | `string` | 自动识别 | 手动指定 Module Federation 构建插件版本。 |
+| `moduleFederation` | `unknown` | 自动读取 | 显式传入 Module Federation 配置，便于构建观测采集 remotes、exposes、shared 等信息。 |
+
+## 标记业务组件成功
+
+Module Federation 能知道 remote module 是否加载完成，但不一定能知道业务组件自己的渲染、请求或初始化是否完成。业务认为组件可用时，可以主动标记。
+
+```ts
+observability.markComponentLoaded({
+  requestId: 'remote1/Button',
+  componentName: 'Button',
+  metadata: {
+    route: '/dashboard',
+  },
+});
+```
+
+报告里会出现 `component:business-loaded`，并且 `summary.outcome` 会变成 `"component-loaded"`。
+
+## 配合 `mf` Skill 使用
+
+安装 skill：
+
+```bash
+npx skills add module-federation/core --skill mf -y
+```
+
+当控制台打印观测提示时，把这段交给 Agent：
+
+```text
+/mf observability
+我看到了这条 Module Federation console error：
+
+[Module Federation] Observability report generated
+traceId: mf-...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+
+请读取报告并帮我修复问题。
+```
+
+如果是 Node 或 SSR，把文件路径交给 Agent：
+
+```text
+/mf observability
+请读取 .mf/observability/latest.json，告诉我可能是谁的问题，以及应该怎么修。
+```
+
+如果生产环境已经把报告上传到自己的系统，把上传后的报告或 `traceId` 交给 Agent：
+
+```text
+/mf observability
+这是 traceId mf-... 对应的上传报告。
+帮我判断这是 host、remote、shared、network 还是 build 的问题。
+```
+
+## AI 优先读什么
+
+skill 会按这个顺序读报告：
+
+1. `diagnosis`
+2. `summary`
+3. `moduleInfo`
+4. `events`
+
+如果需要构建侧证据，再单独读取 `.mf/observability/build-info.json` 或 `.mf/observability/build-report.json`。
+
+报告会省略 `undefined` 字段。字段不存在时，表示这次没有观察到，或者这次加载不相关。
diff --git a/apps/website-new/module-federation.config.ts b/apps/website-new/module-federation.config.ts
index d61a6eb7981..8f2cd16eb08 100644
--- a/apps/website-new/module-federation.config.ts
+++ b/apps/website-new/module-federation.config.ts
@@ -58,6 +58,7 @@ const exposes = {
   // plugin
   [`./plugin-introduce-${LANGUAGE}`]: `./docs/${LANGUAGE}/plugin/dev/index.mdx`,
   [`./plugin-retry-${LANGUAGE}`]: `./docs/${LANGUAGE}/plugin/plugins/retry-plugin.mdx`,
+  [`./plugin-observability-${LANGUAGE}`]: `./docs/${LANGUAGE}/plugin/plugins/observability-plugin.mdx`,
 
   // blog
   [`./error-load-remote-${LANGUAGE}`]: `./docs/${LANGUAGE}/blog/error-load-remote.mdx`,
diff --git a/packages/diagnostics-plugin/README.md b/packages/diagnostics-plugin/README.md
deleted file mode 100644
index 4d50b8a8aa4..00000000000
--- a/packages/diagnostics-plugin/README.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# @module-federation/diagnostics-plugin
-
-Runtime diagnostics plugin for Module Federation loading flows.
-
-This package is currently the minimal diagnostics foundation. It records
-sanitized in-memory loading events only when `security.diagnostics.enabled` is
-set on the runtime instance.
-
-```ts
-import { createInstance } from '@module-federation/runtime';
-import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin';
-
-const diagnostics = DiagnosticsPlugin({
-  level: 'verbose',
-  browser: {
-    enabled: true,
-    scope: 'host',
-  },
-});
-
-createInstance({
-  name: 'host',
-  security: {
-    diagnostics: {
-      enabled: true,
-      maxEvents: 100,
-      browserGlobal: true,
-    },
-  },
-  plugins: [diagnostics.plugin],
-  remotes: [],
-});
-
-const report = diagnostics.getLatestReport();
-```
-
-The plugin does not upload data or expose a browser global by default. Reports
-are kept in memory and URL query/hash data is removed before it is returned.
-The runtime only exposes the loading lifecycle hooks needed to know whether the
-main flow started, succeeded, or failed. This plugin listens to those hooks,
-derives detailed reasons like shared version mismatch or eager boundary issues,
-and exposes the final loading state through a small `summary` object:
-
-- `runtime-loaded`: Module Federation finished loading the remote module.
-- `component-loaded`: business code called `markComponentLoaded`.
-- `failed`: the load failed and `failedPhase` points to the first specific
-  failing phase.
-- `recovered`: loading hit an error but a fallback/recovery path returned a
-  result.
-
-For remote loading, the plugin listens to runtime lifecycle hooks such as
-`beforeRequest`, `onLoad`, `afterLoadRemote`, `errorLoadRemote`, `loadEntry`,
-`afterLoadEntry`, and snapshot resolve hooks. It does not return a value from
-observer hooks, so it does not change fallback or retry results from plugins
-such as `@module-federation/retry-plugin`.
-
-`errorLoadShare` is used only for diagnostics. Shared dependency miss, version
-mismatch, and eager boundary errors are not retried by the retry plugin by
-default because they are usually configuration or availability problems instead
-of transient network failures.
-
-Business code can mark its own success condition with a fixed event:
-
-```ts
-diagnostics.markComponentLoaded({
-  requestId: 'remote/Button',
-  componentName: 'Button',
-});
-```
-
-This records `component:business-loaded` on the same trace when possible.
-
-Optional outputs are gated twice:
-
-- Plugin options request the output.
-- `security.diagnostics` must allow the output.
-
-When both sides allow browser output, the report can be read from:
-
-```ts
-window.__FEDERATION__.__DIAGNOSTICS__.host.getLatestReport();
-window.__FEDERATION__.__DIAGNOSTICS__.host.getReport('mf-trace-id');
-```
-
-Node file output is provided by the Node-specific entry:
-
-```ts
-import { createInstance } from '@module-federation/runtime';
-import { DiagnosticsPlugin } from '@module-federation/diagnostics-plugin/node';
-
-const diagnostics = DiagnosticsPlugin({
-  level: 'verbose',
-  directory: '.mf/diagnostics',
-});
-
-createInstance({
-  name: 'host',
-  security: {
-    diagnostics: {
-      enabled: true,
-      fileOutput: true,
-    },
-  },
-  plugins: [diagnostics.plugin],
-  remotes: [],
-});
-```
-
-When both sides allow Node file output, the Node entry writes:
-
-- `.mf/diagnostics/latest.json`: the latest sanitized report.
-- `.mf/diagnostics/events.jsonl`: one sanitized event per line.
-
-On errors, the plugin prints a small console hint with the `traceId` and the
-available read path. The console hint is intentionally small and does not carry
-the full report. The default browser/runtime entry does not include Node file
-output code.
-
-Shared dependency reports include only diagnostic fields such as package name,
-share scope, requested version, available versions, selected provider, and a
-reason like `missing-provider`, `version-mismatch`, or `sync-async-boundary`.
-They do not include shared factories, module values, source, or business data.
diff --git a/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts b/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
deleted file mode 100644
index d2de09ff5ed..00000000000
--- a/packages/diagnostics-plugin/__tests__/diagnostics.spec.ts
+++ /dev/null
@@ -1,774 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, expect, it, vi } from 'vitest';
-import { DiagnosticsPlugin } from '../src';
-import { DiagnosticsPlugin as DiagnosticsNode } from '../src/node';
-
-const enabledOrigin = {
-  options: {
-    name: 'host',
-    security: {
-      diagnostics: {
-        enabled: true,
-        maxEvents: 10,
-      },
-    },
-  },
-};
-
-const disabledOrigin = {
-  options: {
-    name: 'host',
-  },
-};
-
-const createShared = (overrides: Record<string, unknown> = {}) => ({
-  version: '18.3.1',
-  scope: ['default'],
-  from: 'host',
-  deps: [],
-  useIn: [],
-  strategy: 'loaded-first',
-  shareConfig: {
-    requiredVersion: '^18.0.0',
-    singleton: false,
-    strictVersion: false,
-    eager: false,
-  },
-  get: () => () => ({ value: 'shared' }),
-  ...overrides,
-});
-
-const emitRemoteLoaded = (
-  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
-  overrides: Record<string, unknown> = {},
-) =>
-  diagnostics.plugin.onLoad?.({
-    id: 'remote/Button',
-    pkgNameOrAlias: 'remote',
-    expose: './Button',
-    remote: {
-      name: 'remote',
-      entry: 'http://localhost:3001/mf-manifest.json',
-    },
-    options: {},
-    origin: enabledOrigin,
-    exposeModule: {},
-    exposeModuleFactory: undefined,
-    moduleInstance: {},
-    ...overrides,
-  } as any);
-
-const emitRemoteStart = (
-  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
-  overrides: Record<string, unknown> = {},
-) =>
-  diagnostics.plugin.beforeRequest?.({
-    id: 'remote/Button',
-    options: {},
-    origin: enabledOrigin,
-    ...overrides,
-  } as any);
-
-const emitRemoteComplete = (
-  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
-  overrides: Record<string, unknown> = {},
-) =>
-  diagnostics.plugin.afterLoadRemote?.({
-    id: 'remote/Button',
-    expose: './Button',
-    remote: {
-      name: 'remote',
-      entry: 'http://localhost:3001/mf-manifest.json',
-    },
-    origin: enabledOrigin,
-    ...overrides,
-  } as any);
-
-const emitRemoteError = (
-  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
-  overrides: Record<string, unknown> = {},
-) =>
-  diagnostics.plugin.errorLoadRemote?.({
-    id: 'remote/Button',
-    error: new Error('remote load failed'),
-    from: 'runtime',
-    lifecycle: 'onLoad',
-    expose: './Button',
-    remote: {
-      name: 'remote',
-      entry: 'http://localhost:3001/mf-manifest.json',
-    },
-    origin: enabledOrigin,
-    ...overrides,
-  } as any);
-
-const emitManifestError = (
-  diagnostics: ReturnType<typeof DiagnosticsPlugin>,
-  overrides: Record<string, unknown> = {},
-) =>
-  diagnostics.plugin.errorLoadRemote?.({
-    id: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
-    error: new Error('token=demo-secret manifest failed'),
-    from: 'runtime',
-    lifecycle: 'afterResolve',
-    remote: {
-      name: 'remote',
-      entry: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
-    },
-    origin: enabledOrigin,
-    ...overrides,
-  } as any);
-
-const waitForFile = async (filePath: string) => {
-  const startedAt = Date.now();
-
-  while (Date.now() - startedAt < 1000) {
-    if (fs.existsSync(filePath)) {
-      return;
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-
-  throw new Error(`Timed out waiting for ${filePath}`);
-};
-
-describe('DiagnosticsPlugin', () => {
-  it('does not record events unless security diagnostics is enabled', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
-
-    emitRemoteLoaded(diagnostics, {
-      origin: disabledOrigin,
-    });
-
-    expect(diagnostics.getEvents()).toHaveLength(0);
-    expect(diagnostics.getLatestReport()).toBeUndefined();
-  });
-
-  it('records a successful loadRemote report when enabled', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
-
-    emitRemoteStart(diagnostics);
-    emitRemoteLoaded(diagnostics);
-
-    const report = diagnostics.getLatestReport();
-    expect(report?.status).toBe('success');
-    expect(report?.requestId).toBe('remote/Button');
-    expect(report?.remote?.name).toBe('remote');
-    expect(report?.summary).toMatchObject({
-      runtimeLoaded: true,
-      loadCompleted: false,
-      componentLoaded: false,
-      outcome: 'runtime-loaded',
-      lastPhase: 'loadRemote',
-    });
-    expect(report?.events).toHaveLength(2);
-  });
-
-  it('records a complete loadRemote event as the final runtime outcome', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
-
-    emitRemoteStart(diagnostics);
-    emitRemoteLoaded(diagnostics);
-    emitRemoteComplete(diagnostics);
-
-    const report = diagnostics.getLatestReport();
-    expect(report?.status).toBe('success');
-    expect(report?.summary).toMatchObject({
-      runtimeLoaded: true,
-      loadCompleted: true,
-      componentLoaded: false,
-      outcome: 'runtime-loaded',
-      lastPhase: 'loadRemote',
-    });
-  });
-
-  it('records manifest and remoteEntry lifecycle hooks without diagnostic events', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-
-    diagnostics.plugin.beforeLoadRemoteSnapshot?.({
-      moduleInfo: {
-        name: 'remote',
-        entry: 'http://localhost:3001/mf-manifest.json',
-      },
-      origin: enabledOrigin,
-    } as any);
-    diagnostics.plugin.afterResolve?.({
-      id: 'remote/Button',
-      expose: './Button',
-      remoteInfo: {
-        name: 'remote',
-        entry: 'http://localhost:3001/mf-manifest.json',
-      },
-      origin: enabledOrigin,
-    } as any);
-    diagnostics.plugin.loadEntry?.({
-      remoteInfo: {
-        name: 'remote',
-        entry: 'http://localhost:3001/remoteEntry.js',
-      },
-      origin: enabledOrigin,
-    } as any);
-    diagnostics.plugin.afterLoadEntry?.({
-      remoteInfo: {
-        name: 'remote',
-        entry: 'http://localhost:3001/remoteEntry.js',
-      },
-      origin: enabledOrigin,
-    } as any);
-
-    expect(diagnostics.getEvents()).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          phase: 'manifest',
-          status: 'start',
-          lifecycle: 'beforeLoadRemoteSnapshot',
-        }),
-        expect.objectContaining({
-          phase: 'manifest',
-          status: 'success',
-          lifecycle: 'afterResolve',
-        }),
-        expect.objectContaining({
-          phase: 'remoteEntry',
-          status: 'start',
-          lifecycle: 'loadEntry',
-        }),
-        expect.objectContaining({
-          phase: 'remoteEntry',
-          status: 'success',
-          lifecycle: 'afterLoadEntry',
-        }),
-      ]),
-    );
-  });
-
-  it('treats a recovered complete event as a recovered runtime outcome', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-
-    emitRemoteStart(diagnostics);
-    expect(emitRemoteError(diagnostics)).toBeUndefined();
-    emitRemoteComplete(diagnostics, {
-      error: new Error('remote load failed'),
-      recovered: true,
-    });
-
-    const report = diagnostics.getLatestReport();
-    expect(report?.summary).toMatchObject({
-      recovered: true,
-      runtimeLoaded: true,
-      loadCompleted: true,
-      outcome: 'recovered',
-    });
-  });
-
-  it('sanitizes urls and sensitive message fields', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-
-    emitManifestError(diagnostics, {
-      error: new Error(
-        'authorization=demo-secret failed at http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
-      ),
-    });
-
-    const output = JSON.stringify(diagnostics.getLatestReport());
-    expect(output).toContain('http://localhost:3001/mf-manifest.json');
-    expect(output).not.toContain('demo-secret');
-    expect(output).not.toContain('token=');
-    expect(output).not.toContain('#hash');
-  });
-
-  it('keeps the first specific failed phase when loadRemote closes the trace', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-
-    emitRemoteStart(diagnostics, {
-      remote: {
-        name: 'remote',
-      },
-    });
-    emitManifestError(diagnostics, {
-      id: 'remote/Button',
-      remote: {
-        name: 'remote',
-      },
-      error: new Error('manifest failed'),
-    });
-    expect(emitRemoteError(diagnostics)).toBeUndefined();
-    emitRemoteComplete(diagnostics, {
-      remote: {
-        name: 'remote',
-      },
-      error: new Error('outer loadRemote failed'),
-    });
-
-    const report = diagnostics.getLatestReport();
-    expect(report?.status).toBe('error');
-    expect(report?.failedPhase).toBe('manifest');
-    expect(report?.summary).toMatchObject({
-      loadCompleted: true,
-      runtimeLoaded: false,
-      componentLoaded: false,
-      outcome: 'failed',
-    });
-  });
-
-  it('records sanitized shared dependency diagnostics', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-
-    diagnostics.plugin.errorLoadShare?.({
-      pkgName: 'react',
-      shareInfo: {
-        version: '18.3.1',
-        from: 'remote',
-        scope: ['default'],
-        strategy: 'loaded-first',
-        shareConfig: {
-          requiredVersion: '^99.0.0',
-          singleton: true,
-          strictVersion: true,
-          eager: false,
-        },
-      },
-      shared: {},
-      shareScopeMap: {
-        default: {
-          react: {
-            '18.3.1': createShared({
-              from: 'host?token=demo-secret',
-            }),
-          },
-        },
-      },
-      lifecycle: 'loadShare',
-      origin: enabledOrigin,
-      error: new Error('token=demo-secret shared failed'),
-      recovered: true,
-    } as any);
-
-    const report = diagnostics.getLatestReport();
-    const output = JSON.stringify(report);
-
-    expect(report?.status).toBe('error');
-    expect(report?.failedPhase).toBe('shared');
-    expect(report?.shared).toMatchObject({
-      name: 'react',
-      shareScope: ['default'],
-      requiredVersion: '^99.0.0',
-      availableVersions: ['18.3.1'],
-      reason: 'version-mismatch',
-    });
-    expect(output).not.toContain('demo-secret');
-    expect(output).not.toContain('token=');
-  });
-
-  it('derives shared success details from loadShare hooks', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-    const shared = createShared();
-
-    diagnostics.plugin.beforeLoadShare?.({
-      pkgName: 'react',
-      shareInfo: shared,
-      shared: {},
-      origin: enabledOrigin,
-    });
-    diagnostics.plugin.afterLoadShare?.({
-      pkgName: 'react',
-      shareInfo: shared,
-      selectedShared: shared,
-      shared: {},
-      shareScopeMap: {
-        default: {
-          react: {
-            '18.3.1': shared,
-          },
-        },
-      },
-      lifecycle: 'loadShare',
-      origin: enabledOrigin,
-    });
-
-    const report = diagnostics.getLatestReport();
-
-    expect(report?.status).toBe('success');
-    expect(report?.shared).toMatchObject({
-      name: 'react',
-      selectedVersion: '18.3.1',
-      provider: 'host',
-      availableVersions: ['18.3.1'],
-    });
-  });
-
-  it('derives shared version mismatch details from errorLoadShare', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-    const requestedShared = createShared({
-      version: '99.0.0',
-      from: 'remote',
-      shareConfig: {
-        requiredVersion: '^99.0.0',
-        singleton: false,
-        strictVersion: true,
-        eager: false,
-      },
-    });
-    const hostShared = createShared();
-
-    diagnostics.plugin.beforeLoadShare?.({
-      pkgName: 'react',
-      shareInfo: requestedShared,
-      shared: {},
-      origin: enabledOrigin,
-    });
-    diagnostics.plugin.errorLoadShare?.({
-      pkgName: 'react',
-      shareInfo: requestedShared,
-      shared: {},
-      shareScopeMap: {
-        default: {
-          react: {
-            '18.3.1': hostShared,
-          },
-        },
-      },
-      lifecycle: 'loadShare',
-      origin: enabledOrigin,
-      recovered: true,
-    });
-
-    const report = diagnostics.getLatestReport();
-
-    expect(report?.status).toBe('error');
-    expect(report?.failedPhase).toBe('shared');
-    expect(report?.shared).toMatchObject({
-      name: 'react',
-      requiredVersion: '^99.0.0',
-      availableVersions: ['18.3.1'],
-      reason: 'version-mismatch',
-    });
-  });
-
-  it('derives eager boundary details from loadShareSync failures', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose', console: false });
-    const asyncShared = createShared({
-      version: '1.0.0',
-      from: 'remote',
-      shareConfig: {
-        requiredVersion: '^1.0.0',
-        singleton: false,
-        strictVersion: false,
-        eager: false,
-      },
-      get: () => Promise.resolve(() => ({ value: 'async' })),
-    });
-
-    diagnostics.plugin.errorLoadShare?.({
-      pkgName: 'diagnostics-async-shared',
-      shareInfo: asyncShared,
-      shared: {},
-      shareScopeMap: {},
-      lifecycle: 'loadShareSync',
-      origin: enabledOrigin,
-      error: new Error('[ Federation Runtime ]: RUNTIME-005 shared failed'),
-    });
-
-    const report = diagnostics.getLatestReport();
-
-    expect(report?.status).toBe('error');
-    expect(report?.shared).toMatchObject({
-      name: 'diagnostics-async-shared',
-      requiredVersion: '^1.0.0',
-      reason: 'sync-async-boundary',
-    });
-    expect(report?.events.at(-1)?.message).toBe('shared:sync-async-boundary');
-  });
-
-  it('prints a minimal console hint with traceId on error', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-
-    try {
-      emitManifestError(diagnostics);
-
-      emitManifestError(diagnostics, {
-        error: new Error('token=demo-secret failed again'),
-      });
-
-      expect(warn).toHaveBeenCalledTimes(1);
-      const output = String(warn.mock.calls[0]?.[0]);
-      expect(output).toContain(
-        '[Module Federation] Diagnostic report generated',
-      );
-      expect(output).toContain('traceId: mf-');
-      expect(output).toContain('phase: manifest');
-      expect(output).toContain('read: diagnostics.getReport');
-      expect(output).not.toContain('demo-secret');
-      expect(output).not.toContain('token=');
-      expect(output).not.toContain('#hash');
-    } finally {
-      warn.mockRestore();
-    }
-  });
-
-  it('exposes a browser reader only when plugin and security both allow it', () => {
-    const originalFederation = (
-      globalThis as {
-        __FEDERATION__?: {
-          __DIAGNOSTICS__?: Record<string, unknown>;
-        };
-      }
-    ).__FEDERATION__;
-
-    try {
-      (
-        globalThis as {
-          __FEDERATION__?: {
-            __DIAGNOSTICS__?: Record<string, unknown>;
-          };
-        }
-      ).__FEDERATION__ = {};
-
-      const diagnostics = DiagnosticsPlugin({
-        level: 'verbose',
-        browser: {
-          enabled: true,
-          scope: 'host',
-        },
-      });
-
-      emitRemoteLoaded(diagnostics, {
-        origin: {
-          options: {
-            name: 'host',
-            security: {
-              diagnostics: {
-                enabled: true,
-                maxEvents: 10,
-                browserGlobal: true,
-              },
-            },
-          },
-        },
-      });
-
-      const reader = (
-        globalThis as {
-          __FEDERATION__?: {
-            __DIAGNOSTICS__?: Record<
-              string,
-              {
-                getLatestReport(): { traceId: string; events: unknown[] };
-                getReport(traceId: string): { events: unknown[] } | undefined;
-                getTraceIds(): string[];
-                clear?: unknown;
-              }
-            >;
-          };
-        }
-      ).__FEDERATION__?.__DIAGNOSTICS__?.host;
-
-      expect(reader).toBeDefined();
-      expect(reader?.clear).toBeUndefined();
-      expect(reader?.getTraceIds()).toHaveLength(1);
-
-      const latestReport = reader?.getLatestReport();
-      expect(latestReport?.traceId).toBeDefined();
-      latestReport?.events.pop();
-
-      expect(reader?.getLatestReport().events).toHaveLength(1);
-      expect(
-        reader?.getReport(latestReport?.traceId || '')?.events,
-      ).toHaveLength(1);
-    } finally {
-      if (originalFederation) {
-        (
-          globalThis as {
-            __FEDERATION__?: {
-              __DIAGNOSTICS__?: Record<string, unknown>;
-            };
-          }
-        ).__FEDERATION__ = originalFederation;
-      } else {
-        delete (
-          globalThis as {
-            __FEDERATION__?: {
-              __DIAGNOSTICS__?: Record<string, unknown>;
-            };
-          }
-        ).__FEDERATION__;
-      }
-    }
-  });
-
-  it('does not expose the browser reader when security blocks it', () => {
-    const originalFederation = (
-      globalThis as {
-        __FEDERATION__?: {
-          __DIAGNOSTICS__?: Record<string, unknown>;
-        };
-      }
-    ).__FEDERATION__;
-
-    try {
-      (
-        globalThis as {
-          __FEDERATION__?: {
-            __DIAGNOSTICS__?: Record<string, unknown>;
-          };
-        }
-      ).__FEDERATION__ = {};
-
-      const diagnostics = DiagnosticsPlugin({
-        level: 'verbose',
-        browser: {
-          enabled: true,
-          scope: 'host',
-        },
-      });
-
-      emitRemoteLoaded(diagnostics);
-
-      expect(
-        (
-          globalThis as {
-            __FEDERATION__?: {
-              __DIAGNOSTICS__?: Record<string, unknown>;
-            };
-          }
-        ).__FEDERATION__?.__DIAGNOSTICS__,
-      ).toBeUndefined();
-    } finally {
-      if (originalFederation) {
-        (
-          globalThis as {
-            __FEDERATION__?: {
-              __DIAGNOSTICS__?: Record<string, unknown>;
-            };
-          }
-        ).__FEDERATION__ = originalFederation;
-      } else {
-        delete (
-          globalThis as {
-            __FEDERATION__?: {
-              __DIAGNOSTICS__?: Record<string, unknown>;
-            };
-          }
-        ).__FEDERATION__;
-      }
-    }
-  });
-
-  it('writes sanitized Node diagnostics files only when security allows it', async () => {
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'mf-diagnostics-'));
-    const latestFile = path.join(directory, 'latest.json');
-    const eventsFile = path.join(directory, 'events.jsonl');
-    const originalNonWebpackRequire = (
-      globalThis as {
-        __non_webpack_require__?: (id: string) => unknown;
-      }
-    ).__non_webpack_require__;
-
-    try {
-      (
-        globalThis as {
-          __non_webpack_require__?: (id: string) => unknown;
-        }
-      ).__non_webpack_require__ = (id: string) => {
-        if (id === 'node:fs' || id === 'fs') {
-          return fs;
-        }
-
-        if (id === 'node:path' || id === 'path') {
-          return path;
-        }
-
-        throw new Error(`Unsupported module: ${id}`);
-      };
-
-      const diagnostics = DiagnosticsNode({
-        level: 'verbose',
-        console: false,
-        directory,
-      });
-
-      emitManifestError(diagnostics, {
-        origin: {
-          options: {
-            name: 'host',
-            security: {
-              diagnostics: {
-                enabled: true,
-                maxEvents: 10,
-                fileOutput: true,
-              },
-            },
-          },
-        },
-        error: new Error('token=demo-secret manifest failed'),
-      });
-
-      await waitForFile(latestFile);
-      await waitForFile(eventsFile);
-
-      const latest = fs.readFileSync(latestFile, 'utf8');
-      const eventsOutput = fs.readFileSync(eventsFile, 'utf8');
-
-      expect(latest).toContain('"status": "error"');
-      expect(eventsOutput).toContain('"phase":"manifest"');
-      expect(`${latest}\n${eventsOutput}`).not.toContain('demo-secret');
-      expect(`${latest}\n${eventsOutput}`).not.toContain('token=');
-      expect(`${latest}\n${eventsOutput}`).not.toContain('#hash');
-    } finally {
-      if (originalNonWebpackRequire) {
-        (
-          globalThis as {
-            __non_webpack_require__?: (id: string) => unknown;
-          }
-        ).__non_webpack_require__ = originalNonWebpackRequire;
-      } else {
-        delete (
-          globalThis as {
-            __non_webpack_require__?: (id: string) => unknown;
-          }
-        ).__non_webpack_require__;
-      }
-      fs.rmSync(directory, { recursive: true, force: true });
-    }
-  });
-
-  it('lets business code mark component loaded after runtime diagnostics starts', () => {
-    const diagnostics = DiagnosticsPlugin({ level: 'verbose' });
-
-    emitRemoteLoaded(diagnostics);
-
-    const componentEvent = diagnostics.markComponentLoaded({
-      requestId: 'remote/Button',
-      componentName: 'RemoteButton',
-    });
-    const report = diagnostics.getLatestReport();
-
-    expect(componentEvent?.phase).toBe('component');
-    expect(componentEvent?.eventName).toBe('component:business-loaded');
-    expect(componentEvent?.source).toBe('business');
-    expect(componentEvent?.componentName).toBe('RemoteButton');
-    expect(report?.summary.componentLoaded).toBe(true);
-    expect(report?.summary.outcome).toBe('component-loaded');
-    expect(JSON.stringify(report)).toContain('component:business-loaded');
-  });
-
-  it('does not let diagnostics callbacks affect loading', () => {
-    const diagnostics = DiagnosticsPlugin({
-      level: 'verbose',
-      onEvent: vi.fn(() => {
-        throw new Error('onEvent failed');
-      }),
-      onReport: vi.fn(() => {
-        throw new Error('onReport failed');
-      }),
-    });
-
-    expect(() => emitRemoteLoaded(diagnostics)).not.toThrow();
-
-    expect(diagnostics.getLatestReport()?.status).toBe('success');
-  });
-});
diff --git a/packages/diagnostics-plugin/src/index.ts b/packages/diagnostics-plugin/src/index.ts
deleted file mode 100644
index 51f4d4d8f9e..00000000000
--- a/packages/diagnostics-plugin/src/index.ts
+++ /dev/null
@@ -1,1383 +0,0 @@
-import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-
-export type DiagnosticsLevel = 'error' | 'summary' | 'verbose';
-export type DiagnosticsEventStatus = 'start' | 'success' | 'error' | 'complete';
-export type DiagnosticsReportStatus = 'pending' | 'success' | 'error';
-export type DiagnosticsEventSource = 'runtime' | 'business';
-export type DiagnosticsReportOutcome =
-  | 'pending'
-  | 'runtime-loaded'
-  | 'component-loaded'
-  | 'failed'
-  | 'recovered';
-
-export interface DiagnosticsRemoteInfo {
-  name: string;
-  alias?: string;
-  entry?: string;
-  entryGlobalName?: string;
-  type?: string;
-}
-
-export interface DiagnosticsSharedInfo {
-  name: string;
-  shareScope?: string[];
-  requiredVersion?: string | false;
-  selectedVersion?: string;
-  availableVersions?: string[];
-  provider?: string;
-  from?: string;
-  singleton?: boolean;
-  strictVersion?: boolean;
-  eager?: boolean;
-  strategy?: string;
-  loaded?: boolean;
-  loading?: boolean;
-  reason?: string;
-}
-
-export interface DiagnosticsEvent {
-  traceId: string;
-  timestamp: number;
-  phase: string;
-  status: DiagnosticsEventStatus;
-  requestId?: string;
-  hostName?: string;
-  remote?: DiagnosticsRemoteInfo;
-  shared?: DiagnosticsSharedInfo;
-  expose?: string;
-  sanitizedUrl?: string;
-  message?: string;
-  errorName?: string;
-  errorMessage?: string;
-  lifecycle?: string;
-  eventName?: string;
-  source?: DiagnosticsEventSource;
-  recovered?: boolean;
-  componentName?: string;
-}
-
-export interface DiagnosticsReport {
-  traceId: string;
-  status: DiagnosticsReportStatus;
-  requestId?: string;
-  hostName?: string;
-  remote?: DiagnosticsRemoteInfo;
-  shared?: DiagnosticsSharedInfo;
-  expose?: string;
-  startedAt: number;
-  updatedAt: number;
-  duration: number;
-  failedPhase?: string;
-  events: DiagnosticsEvent[];
-  summary: {
-    eventCount: number;
-    recovered: boolean;
-    loadCompleted: boolean;
-    runtimeLoaded: boolean;
-    componentLoaded: boolean;
-    outcome: DiagnosticsReportOutcome;
-    lastPhase?: string;
-  };
-}
-
-export interface DiagnosticsPluginOptions {
-  enabled?: boolean;
-  level?: DiagnosticsLevel;
-  maxEvents?: number;
-  console?: boolean;
-  browser?: {
-    enabled?: boolean;
-    scope?: string;
-  };
-  onEvent?: (
-    event: DiagnosticsEvent,
-    report: DiagnosticsReport,
-    context?: DiagnosticsEventContext,
-  ) => void;
-  onReport?: (
-    report: DiagnosticsReport,
-    context?: DiagnosticsEventContext,
-  ) => void;
-}
-
-export interface MarkComponentLoadedOptions {
-  traceId?: string;
-  requestId?: string;
-  componentName?: string;
-}
-
-export interface DiagnosticsController {
-  plugin: DiagnosticsRuntimePlugin;
-  getEvents(): DiagnosticsEvent[];
-  getTraceIds(): string[];
-  getLatestReport(): DiagnosticsReport | undefined;
-  getReport(traceId: string): DiagnosticsReport | undefined;
-  clear(): void;
-  markComponentLoaded(
-    options?: MarkComponentLoadedOptions,
-  ): DiagnosticsEvent | undefined;
-}
-
-export interface DiagnosticsRuntimeEventInput {
-  phase: string;
-  status: DiagnosticsEventStatus;
-  requestId?: string;
-  hostName?: string;
-  remote?: DiagnosticsRemoteInfo;
-  shared?: DiagnosticsSharedInfo;
-  expose?: string;
-  url?: string;
-  message?: string;
-  error?: unknown;
-  lifecycle?: string;
-  eventName?: string;
-  source?: DiagnosticsEventSource;
-  recovered?: boolean;
-  timestamp?: number;
-  traceId?: string;
-  componentName?: string;
-}
-
-export interface DiagnosticsRuntimeOrigin {
-  options?: {
-    name?: string;
-    security?: {
-      diagnostics?: {
-        enabled?: boolean;
-        maxEvents?: number;
-        console?: boolean;
-        browserGlobal?: boolean;
-        fileOutput?: boolean;
-      };
-    };
-  };
-}
-
-export interface DiagnosticsEventContext {
-  origin?: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRuntimeSharedConfig {
-  requiredVersion?: string | false;
-  singleton?: boolean;
-  strictVersion?: boolean;
-  eager?: boolean;
-}
-
-interface DiagnosticsRuntimeSharedSource {
-  version?: string;
-  scope?: string | string[];
-  from?: string;
-  loaded?: boolean;
-  loading?: unknown;
-  strategy?: string;
-  shareConfig?: DiagnosticsRuntimeSharedConfig;
-  get?: unknown;
-}
-
-interface DiagnosticsRuntimeRemoteSource {
-  name?: string;
-  alias?: string;
-  entry?: string;
-  entryGlobalName?: string;
-  type?: string;
-}
-
-interface DiagnosticsRemoteLoadArgs {
-  id: string;
-  expose?: string;
-  remote?: DiagnosticsRuntimeRemoteSource;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteBeforeRequestArgs {
-  id: string;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteAfterLoadArgs {
-  id: string;
-  expose?: string;
-  remote?: DiagnosticsRuntimeRemoteSource;
-  error?: unknown;
-  recovered?: boolean;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteSnapshotArgs {
-  moduleInfo?: DiagnosticsRuntimeRemoteSource;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteResolveArgs {
-  id: string;
-  expose?: string;
-  remote?: DiagnosticsRuntimeRemoteSource;
-  remoteInfo?: DiagnosticsRuntimeRemoteSource;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteErrorArgs {
-  id: string;
-  error: unknown;
-  lifecycle?: string;
-  remote?: DiagnosticsRuntimeRemoteSource;
-  expose?: string;
-  origin: DiagnosticsRuntimeOrigin;
-}
-
-interface DiagnosticsRemoteEntryLoadArgs {
-  origin: DiagnosticsRuntimeOrigin;
-  remoteInfo: DiagnosticsRuntimeRemoteSource;
-}
-
-interface DiagnosticsRemoteEntryAfterLoadArgs {
-  origin: DiagnosticsRuntimeOrigin;
-  remoteInfo: DiagnosticsRuntimeRemoteSource;
-  error?: unknown;
-  recovered?: boolean;
-}
-
-type DiagnosticsRuntimeShareScopeMap = Record<
-  string,
-  Record<string, Record<string, DiagnosticsRuntimeSharedSource | undefined>>
->;
-
-interface DiagnosticsSharedLifecycleArgs {
-  pkgName: string;
-  shareInfo?: DiagnosticsRuntimeSharedSource;
-  selectedShared?: DiagnosticsRuntimeSharedSource;
-  shared?: Record<string, DiagnosticsRuntimeSharedSource[]>;
-  shareScopeMap?: DiagnosticsRuntimeShareScopeMap;
-  lifecycle?: 'loadShare' | 'loadShareSync';
-  origin: DiagnosticsRuntimeOrigin;
-  error?: unknown;
-  recovered?: boolean;
-}
-
-export type DiagnosticsRuntimePlugin = ModuleFederationRuntimePlugin;
-
-export interface DiagnosticsBrowserReader {
-  getEvents(): DiagnosticsEvent[];
-  getTraceIds(): string[];
-  getLatestReport(): DiagnosticsReport | undefined;
-  getReport(traceId: string): DiagnosticsReport | undefined;
-}
-
-interface FederationDiagnosticsGlobal {
-  __DIAGNOSTICS__?: Record<string, DiagnosticsBrowserReader>;
-}
-
-const DEFAULT_MAX_EVENTS = 100;
-const HARD_MAX_EVENTS = 1000;
-const COMPONENT_BUSINESS_LOADED_EVENT = 'component:business-loaded';
-const SENSITIVE_PAIR_PATTERN =
-  /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
-const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
-
-let traceCounter = 0;
-
-function normalizeMaxEvents(value: number | undefined, fallback: number) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    return fallback;
-  }
-
-  return Math.max(1, Math.min(HARD_MAX_EVENTS, Math.floor(value)));
-}
-
-function sanitizeText(value: unknown, maxLength = 800): string | undefined {
-  if (value === undefined || value === null) {
-    return undefined;
-  }
-
-  const sanitized = String(value)
-    .replace(URL_PATTERN, (url) => sanitizeUrl(url) || '[redacted-url]')
-    .replace(SENSITIVE_PAIR_PATTERN, '[redacted]');
-
-  return sanitized.length > maxLength
-    ? `${sanitized.slice(0, maxLength)}...`
-    : sanitized;
-}
-
-function sanitizeRequestId(value: string | undefined): string | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  if (/^https?:\/\//i.test(value)) {
-    return sanitizeUrl(value);
-  }
-
-  return sanitizeText(value, 240);
-}
-
-function sanitizeUrl(value: string | undefined): string | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  try {
-    const base =
-      typeof window !== 'undefined' && window.location
-        ? window.location.origin
-        : 'http://localhost';
-    const parsedUrl = new URL(value, base);
-    const sanitized = `${parsedUrl.origin}${parsedUrl.pathname}`;
-
-    return /^https?:\/\//i.test(value) ? sanitized : parsedUrl.pathname;
-  } catch {
-    const [withoutHash] = value.split('#');
-    const [withoutQuery] = withoutHash.split('?');
-    return sanitizeText(withoutQuery, 240);
-  }
-}
-
-function sanitizeRemote(
-  remote: DiagnosticsRemoteInfo | undefined,
-): DiagnosticsRemoteInfo | undefined {
-  if (!remote || !remote.name) {
-    return undefined;
-  }
-
-  return {
-    name: remote.name,
-    alias: sanitizeText(remote.alias, 120),
-    entry: sanitizeUrl(remote.entry),
-    entryGlobalName: sanitizeText(remote.entryGlobalName, 120),
-    type: sanitizeText(remote.type, 80),
-  };
-}
-
-function createRemoteInfo(
-  remote: DiagnosticsRuntimeRemoteSource | undefined,
-): DiagnosticsRemoteInfo | undefined {
-  if (!remote?.name) {
-    return undefined;
-  }
-
-  return {
-    name: remote.name,
-    alias: remote.alias,
-    entry: remote.entry,
-    entryGlobalName: remote.entryGlobalName,
-    type: remote.type,
-  };
-}
-
-function isManifestUrl(value: string | undefined): boolean {
-  const sanitized = sanitizeUrl(value);
-
-  return Boolean(sanitized && /manifest.*\.json$/i.test(sanitized));
-}
-
-function normalizeSharedScope(value: string | string[] | undefined): string[] {
-  if (!value) {
-    return [];
-  }
-
-  return (Array.isArray(value) ? value : [value])
-    .map((scope) => sanitizeText(scope, 120))
-    .filter((scope): scope is string => Boolean(scope));
-}
-
-function getSharedScopes(
-  shareInfo: DiagnosticsRuntimeSharedSource | undefined,
-): string[] {
-  return normalizeSharedScope(shareInfo?.scope).length
-    ? normalizeSharedScope(shareInfo?.scope)
-    : ['default'];
-}
-
-function getAvailableSharedVersions(args: DiagnosticsSharedLifecycleArgs) {
-  const versions = new Set<string>();
-  const shareScopeMap = args.shareScopeMap || {};
-
-  getSharedScopes(args.shareInfo).forEach((scope) => {
-    Object.keys(shareScopeMap[scope]?.[args.pkgName] || {}).forEach(
-      (version) => {
-        versions.add(version);
-      },
-    );
-  });
-
-  return Array.from(versions);
-}
-
-function getSharedMissReason(args: DiagnosticsSharedLifecycleArgs) {
-  if (!args.shareInfo) {
-    return 'missing-config';
-  }
-
-  return getAvailableSharedVersions(args).length
-    ? 'version-mismatch'
-    : 'missing-provider';
-}
-
-function getSharedErrorReason(args: DiagnosticsSharedLifecycleArgs) {
-  if (args.recovered) {
-    return getSharedMissReason(args);
-  }
-
-  const errorInfo = getErrorInfo(args.error);
-  const errorMessage = errorInfo.errorMessage || '';
-
-  if (!args.shareInfo || /Cannot find shared/i.test(errorMessage)) {
-    return 'missing-config';
-  }
-
-  if (
-    args.lifecycle === 'loadShareSync' &&
-    typeof args.shareInfo.get === 'function' &&
-    /RUNTIME-00[56]/.test(errorMessage)
-  ) {
-    return 'sync-async-boundary';
-  }
-
-  if (
-    args.lifecycle === 'loadShareSync' &&
-    !args.shareInfo.get &&
-    /RUNTIME-006/.test(errorMessage)
-  ) {
-    return getSharedMissReason(args);
-  }
-
-  if (args.error) {
-    return 'load-error';
-  }
-
-  return undefined;
-}
-
-function createSharedInfo(
-  args: DiagnosticsSharedLifecycleArgs,
-  reason?: string,
-): DiagnosticsSharedInfo {
-  const shareConfig = args.shareInfo?.shareConfig;
-
-  return {
-    name: args.pkgName,
-    shareScope: getSharedScopes(args.shareInfo),
-    requiredVersion: shareConfig?.requiredVersion,
-    selectedVersion: args.selectedShared?.version,
-    availableVersions: getAvailableSharedVersions(args),
-    provider: args.selectedShared?.from,
-    from: args.shareInfo?.from,
-    singleton: shareConfig?.singleton,
-    strictVersion: shareConfig?.strictVersion,
-    eager: shareConfig?.eager,
-    strategy: args.shareInfo?.strategy,
-    loaded: args.selectedShared?.loaded,
-    loading: Boolean(args.selectedShared?.loading) || undefined,
-    reason,
-  };
-}
-
-function sanitizeShared(
-  shared: DiagnosticsSharedInfo | undefined,
-): DiagnosticsSharedInfo | undefined {
-  if (!shared || !shared.name) {
-    return undefined;
-  }
-
-  return {
-    name: sanitizeText(shared.name, 160) || 'unknown',
-    shareScope: normalizeSharedScope(shared.shareScope),
-    requiredVersion:
-      shared.requiredVersion === false
-        ? false
-        : sanitizeText(shared.requiredVersion, 120),
-    selectedVersion: sanitizeText(shared.selectedVersion, 120),
-    availableVersions: (shared.availableVersions || [])
-      .map((version) => sanitizeText(version, 120))
-      .filter((version): version is string => Boolean(version))
-      .slice(0, 20),
-    provider: sanitizeText(shared.provider, 160),
-    from: sanitizeText(shared.from, 160),
-    singleton: shared.singleton,
-    strictVersion: shared.strictVersion,
-    eager: shared.eager,
-    strategy: sanitizeText(shared.strategy, 80),
-    loaded: shared.loaded,
-    loading: shared.loading,
-    reason: sanitizeText(shared.reason, 120),
-  };
-}
-
-function normalizeEventSource(
-  value: DiagnosticsEventSource | undefined,
-): DiagnosticsEventSource | undefined {
-  return value === 'runtime' || value === 'business' ? value : undefined;
-}
-
-function getErrorInfo(error: unknown): {
-  errorName?: string;
-  errorMessage?: string;
-} {
-  if (!error) {
-    return {};
-  }
-
-  if (error instanceof Error) {
-    return {
-      errorName: sanitizeText(error.name, 120),
-      errorMessage: sanitizeText(error.message),
-    };
-  }
-
-  return {
-    errorMessage: sanitizeText(error),
-  };
-}
-
-function copyEvent(event: DiagnosticsEvent): DiagnosticsEvent {
-  return {
-    ...event,
-    remote: event.remote ? { ...event.remote } : undefined,
-    shared: event.shared
-      ? {
-          ...event.shared,
-          shareScope: event.shared.shareScope
-            ? [...event.shared.shareScope]
-            : undefined,
-          availableVersions: event.shared.availableVersions
-            ? [...event.shared.availableVersions]
-            : undefined,
-        }
-      : undefined,
-  };
-}
-
-function copyReport(report: DiagnosticsReport): DiagnosticsReport {
-  return {
-    ...report,
-    remote: report.remote ? { ...report.remote } : undefined,
-    shared: report.shared
-      ? {
-          ...report.shared,
-          shareScope: report.shared.shareScope
-            ? [...report.shared.shareScope]
-            : undefined,
-          availableVersions: report.shared.availableVersions
-            ? [...report.shared.availableVersions]
-            : undefined,
-        }
-      : undefined,
-    events: report.events.map(copyEvent),
-    summary: { ...report.summary },
-  };
-}
-
-function getFederationGlobal(): FederationDiagnosticsGlobal | undefined {
-  return (
-    globalThis as {
-      __FEDERATION__?: FederationDiagnosticsGlobal;
-    }
-  ).__FEDERATION__;
-}
-
-function normalizeScope(value: unknown) {
-  const sanitized = sanitizeText(value, 120);
-  const normalized = sanitized?.replace(/[^\w:@.-]+/g, '-');
-
-  return normalized || 'default';
-}
-
-function shouldRecordEvent(
-  level: DiagnosticsLevel,
-  event: DiagnosticsRuntimeEventInput,
-) {
-  if (level === 'verbose') {
-    return true;
-  }
-
-  if (level === 'summary') {
-    return event.status !== 'start';
-  }
-
-  return event.status === 'error' || Boolean(event.error);
-}
-
-function createTraceId(event: DiagnosticsRuntimeEventInput) {
-  traceCounter += 1;
-  const owner = event.remote?.name || event.phase || 'runtime';
-  const normalizedOwner = owner.replace(/[^a-z0-9]+/gi, '-').slice(0, 80);
-
-  return `mf-${normalizedOwner}-${Date.now().toString(36)}-${traceCounter.toString(
-    36,
-  )}`;
-}
-
-export function DiagnosticsPlugin(
-  options: DiagnosticsPluginOptions = {},
-): DiagnosticsController {
-  const level = options.level || 'summary';
-  const configuredMaxEvents = normalizeMaxEvents(
-    options.maxEvents,
-    DEFAULT_MAX_EVENTS,
-  );
-  const events: DiagnosticsEvent[] = [];
-  const reports = new Map<string, DiagnosticsReport>();
-  const traceByRequest = new Map<string, string>();
-  const traceByRemote = new Map<string, string>();
-  const consoleReportedTraceIds = new Set<string>();
-  let latestTraceId: string | undefined;
-  let runtimeDiagnosticsEnabled = false;
-  let effectiveMaxEvents = configuredMaxEvents;
-  let browserGlobalScope: string | undefined;
-  let lastRuntimeOrigin: DiagnosticsRuntimeOrigin | undefined;
-
-  const isEnabledForOrigin = (origin: DiagnosticsRuntimeOrigin) => {
-    if (options.enabled === false) {
-      return false;
-    }
-
-    const securityDiagnostics = origin.options?.security?.diagnostics;
-    if (securityDiagnostics?.enabled !== true) {
-      return false;
-    }
-
-    const securityMaxEvents = normalizeMaxEvents(
-      securityDiagnostics.maxEvents,
-      configuredMaxEvents,
-    );
-    effectiveMaxEvents = Math.min(configuredMaxEvents, securityMaxEvents);
-    runtimeDiagnosticsEnabled = true;
-    return true;
-  };
-
-  const resolveTraceId = (event: DiagnosticsRuntimeEventInput) => {
-    const sanitizedRequestId = sanitizeRequestId(event.requestId);
-
-    if (event.traceId && reports.has(event.traceId)) {
-      return event.traceId;
-    }
-
-    if (event.status === 'start' && event.phase === 'loadRemote') {
-      const traceId = event.traceId || createTraceId(event);
-      if (sanitizedRequestId) {
-        traceByRequest.set(sanitizedRequestId, traceId);
-      }
-      if (event.remote?.name) {
-        traceByRemote.set(event.remote.name, traceId);
-      }
-      return traceId;
-    }
-
-    if (sanitizedRequestId) {
-      const traceId = traceByRequest.get(sanitizedRequestId);
-      if (traceId) {
-        return traceId;
-      }
-    }
-
-    if (event.remote?.name) {
-      const traceId = traceByRemote.get(event.remote.name);
-      if (traceId) {
-        return traceId;
-      }
-    }
-
-    return event.traceId || createTraceId(event);
-  };
-
-  const normalizeEvent = (
-    event: DiagnosticsRuntimeEventInput,
-    traceId: string,
-    origin?: DiagnosticsRuntimeOrigin,
-  ): DiagnosticsEvent => {
-    const errorInfo = getErrorInfo(event.error);
-    const sanitizedRemote = sanitizeRemote(event.remote);
-    const sanitizedShared = sanitizeShared(event.shared);
-    const hostName =
-      sanitizeText(event.hostName, 120) ||
-      sanitizeText(origin?.options?.name, 120);
-    const message = sanitizeText(event.message) || errorInfo.errorMessage;
-
-    return {
-      traceId,
-      timestamp: event.timestamp || Date.now(),
-      phase: sanitizeText(event.phase, 120) || 'runtime',
-      status: event.status,
-      requestId: sanitizeRequestId(event.requestId),
-      hostName,
-      remote: sanitizedRemote,
-      shared: sanitizedShared,
-      expose: sanitizeText(event.expose, 240),
-      sanitizedUrl: sanitizeUrl(event.url || event.remote?.entry),
-      message,
-      errorName: errorInfo.errorName,
-      errorMessage: errorInfo.errorMessage,
-      lifecycle: sanitizeText(event.lifecycle, 120),
-      eventName: sanitizeText(event.eventName, 160),
-      source: normalizeEventSource(event.source),
-      recovered: event.recovered === true || undefined,
-      componentName: sanitizeText(event.componentName, 160),
-    };
-  };
-
-  const updateTraceMaps = (event: DiagnosticsEvent) => {
-    if (event.requestId) {
-      traceByRequest.set(event.requestId, event.traceId);
-    }
-
-    if (event.remote?.name) {
-      traceByRemote.set(event.remote.name, event.traceId);
-    }
-  };
-
-  const trimEvents = (report: DiagnosticsReport) => {
-    while (events.length > effectiveMaxEvents) {
-      events.shift();
-    }
-
-    while (report.events.length > effectiveMaxEvents) {
-      report.events.shift();
-    }
-  };
-
-  const getEventOutcome = (event: DiagnosticsEvent) => {
-    if (event.status === 'success') {
-      return 'success';
-    }
-
-    if (event.status === 'error') {
-      return 'error';
-    }
-
-    if (event.status === 'complete') {
-      if (event.recovered) {
-        return 'recovered';
-      }
-
-      if (event.errorName || event.errorMessage) {
-        return 'error';
-      }
-    }
-
-    return undefined;
-  };
-
-  const isLoadRemoteCompleteEvent = (event: DiagnosticsEvent) =>
-    event.phase === 'loadRemote' && event.status === 'complete';
-
-  const isRuntimeLoadedEvent = (event: DiagnosticsEvent) =>
-    event.phase === 'loadRemote' &&
-    (event.status === 'success' ||
-      (event.status === 'complete' && event.recovered));
-
-  const isComponentLoadedEvent = (event: DiagnosticsEvent) =>
-    event.status === 'success' &&
-    (event.eventName === COMPONENT_BUSINESS_LOADED_EVENT ||
-      (event.phase === 'component' &&
-        event.message === COMPONENT_BUSINESS_LOADED_EVENT));
-
-  const shouldReplaceFailedPhase = (
-    report: DiagnosticsReport,
-    event: DiagnosticsEvent,
-  ) => {
-    if (isLoadRemoteCompleteEvent(event) && report.failedPhase) {
-      return false;
-    }
-
-    if (!report.failedPhase) {
-      return true;
-    }
-
-    return report.failedPhase === 'loadRemote' && event.phase !== 'loadRemote';
-  };
-
-  const createReportSummary = (
-    report: DiagnosticsReport,
-  ): DiagnosticsReport['summary'] => {
-    const loadCompleted = report.events.some(isLoadRemoteCompleteEvent);
-    const runtimeLoaded = report.events.some(isRuntimeLoadedEvent);
-    const recovered = report.events.some((item) => item.recovered);
-    const componentLoaded = report.events.some(isComponentLoadedEvent);
-    const lastEvent = report.events[report.events.length - 1];
-    let outcome: DiagnosticsReportOutcome = 'pending';
-
-    if (componentLoaded) {
-      outcome = 'component-loaded';
-    } else if (recovered && runtimeLoaded) {
-      outcome = 'recovered';
-    } else if (report.status === 'error') {
-      outcome = 'failed';
-    } else if (runtimeLoaded) {
-      outcome = 'runtime-loaded';
-    }
-
-    return {
-      eventCount: report.events.length,
-      recovered,
-      loadCompleted,
-      runtimeLoaded,
-      componentLoaded,
-      outcome,
-      lastPhase: lastEvent?.phase,
-    };
-  };
-
-  const updateReport = (event: DiagnosticsEvent) => {
-    let report = reports.get(event.traceId);
-
-    if (!report) {
-      report = {
-        traceId: event.traceId,
-        status: event.status === 'error' ? 'error' : 'pending',
-        requestId: event.requestId,
-        hostName: event.hostName,
-        remote: event.remote ? { ...event.remote } : undefined,
-        shared: event.shared ? copyEvent(event).shared : undefined,
-        expose: event.expose,
-        startedAt: event.timestamp,
-        updatedAt: event.timestamp,
-        duration: 0,
-        failedPhase: event.status === 'error' ? event.phase : undefined,
-        events: [],
-        summary: {
-          eventCount: 0,
-          recovered: false,
-          loadCompleted: false,
-          runtimeLoaded: false,
-          componentLoaded: false,
-          outcome: 'pending',
-          lastPhase: undefined,
-        },
-      };
-      reports.set(event.traceId, report);
-    }
-
-    if (event.requestId) {
-      report.requestId = event.requestId;
-    }
-    if (event.hostName) {
-      report.hostName = event.hostName;
-    }
-    if (event.remote) {
-      report.remote = { ...event.remote };
-    }
-    if (event.shared) {
-      report.shared = copyEvent(event).shared;
-    }
-    if (event.expose) {
-      report.expose = event.expose;
-    }
-
-    report.events.push(event);
-    report.updatedAt = event.timestamp;
-    report.duration = Math.max(0, report.updatedAt - report.startedAt);
-
-    const eventOutcome = getEventOutcome(event);
-
-    if (eventOutcome === 'error') {
-      report.status = 'error';
-      if (shouldReplaceFailedPhase(report, event)) {
-        report.failedPhase = event.phase;
-      }
-    } else if (
-      (eventOutcome === 'success' || eventOutcome === 'recovered') &&
-      report.status !== 'error'
-    ) {
-      report.status = 'success';
-    }
-
-    report.summary = createReportSummary(report);
-
-    latestTraceId = event.traceId;
-    trimEvents(report);
-    return report;
-  };
-
-  const notifyEvent = (
-    event: DiagnosticsEvent,
-    report: DiagnosticsReport,
-    origin?: DiagnosticsRuntimeOrigin,
-  ) => {
-    try {
-      options.onEvent?.(copyEvent(event), copyReport(report), { origin });
-    } catch {
-      // Diagnostics callbacks must not affect Module Federation loading.
-    }
-  };
-
-  const notifyReport = (
-    report: DiagnosticsReport,
-    origin?: DiagnosticsRuntimeOrigin,
-  ) => {
-    if (report.events[report.events.length - 1]?.status === 'start') {
-      return;
-    }
-
-    try {
-      options.onReport?.(copyReport(report), { origin });
-    } catch {
-      // Diagnostics callbacks must not affect Module Federation loading.
-    }
-  };
-
-  const getEventsSnapshot = () => events.map(copyEvent);
-
-  const getTraceIdsSnapshot = () => Array.from(reports.keys());
-
-  const getLatestReportSnapshot = () => {
-    if (!latestTraceId) {
-      return undefined;
-    }
-
-    const report = reports.get(latestTraceId);
-    return report ? copyReport(report) : undefined;
-  };
-
-  const getReportSnapshot = (traceId: string) => {
-    const report = reports.get(traceId);
-    return report ? copyReport(report) : undefined;
-  };
-
-  const createBrowserReader = (): DiagnosticsBrowserReader => ({
-    getEvents: getEventsSnapshot,
-    getTraceIds: getTraceIdsSnapshot,
-    getLatestReport: getLatestReportSnapshot,
-    getReport: getReportSnapshot,
-  });
-
-  const shouldExposeBrowserGlobal = (origin?: DiagnosticsRuntimeOrigin) =>
-    options.browser?.enabled === true &&
-    origin?.options?.security?.diagnostics?.browserGlobal === true;
-
-  const ensureBrowserGlobal = (origin?: DiagnosticsRuntimeOrigin) => {
-    if (!shouldExposeBrowserGlobal(origin)) {
-      return;
-    }
-
-    const federationGlobal = getFederationGlobal();
-    if (!federationGlobal) {
-      return;
-    }
-
-    const scope = normalizeScope(
-      options.browser?.scope || origin?.options?.name || 'default',
-    );
-    const reader = createBrowserReader();
-
-    federationGlobal.__DIAGNOSTICS__ = federationGlobal.__DIAGNOSTICS__ || {};
-    browserGlobalScope = scope;
-
-    try {
-      Object.defineProperty(federationGlobal.__DIAGNOSTICS__, scope, {
-        value: reader,
-        configurable: true,
-        enumerable: true,
-      });
-    } catch {
-      federationGlobal.__DIAGNOSTICS__[scope] = reader;
-    }
-  };
-
-  const shouldUseConsole = (origin?: DiagnosticsRuntimeOrigin) =>
-    options.console !== false &&
-    origin?.options?.security?.diagnostics?.console !== false;
-
-  const getBrowserReadCommand = (traceId: string) => {
-    if (!browserGlobalScope) {
-      return undefined;
-    }
-
-    return `window.__FEDERATION__.__DIAGNOSTICS__[${JSON.stringify(
-      browserGlobalScope,
-    )}].getReport(${JSON.stringify(traceId)})`;
-  };
-
-  const emitConsoleHint = (
-    event: DiagnosticsEvent,
-    report: DiagnosticsReport,
-    origin?: DiagnosticsRuntimeOrigin,
-  ) => {
-    if (
-      getEventOutcome(event) !== 'error' ||
-      !shouldUseConsole(origin) ||
-      consoleReportedTraceIds.has(report.traceId)
-    ) {
-      return;
-    }
-
-    consoleReportedTraceIds.add(report.traceId);
-
-    const lines = [
-      '[Module Federation] Diagnostic report generated',
-      `traceId: ${report.traceId}`,
-      `phase: ${report.failedPhase || event.phase}`,
-    ];
-
-    if (report.requestId) {
-      lines.push(`requestId: ${report.requestId}`);
-    }
-    if (report.shared?.name) {
-      lines.push(`shared: ${report.shared.name}`);
-    }
-
-    const browserReadCommand = getBrowserReadCommand(report.traceId);
-    if (browserReadCommand) {
-      lines.push(`read: ${browserReadCommand}`);
-    } else {
-      lines.push(
-        `read: diagnostics.getReport(${JSON.stringify(report.traceId)})`,
-      );
-    }
-
-    try {
-      console.warn(lines.join('\n'));
-    } catch {
-      // Console output is best-effort diagnostics only.
-    }
-  };
-
-  const prepareOutputChannels = (origin: DiagnosticsRuntimeOrigin) => {
-    browserGlobalScope = undefined;
-    ensureBrowserGlobal(origin);
-  };
-
-  const prepareRuntimeOrigin = (origin: DiagnosticsRuntimeOrigin) => {
-    if (!isEnabledForOrigin(origin)) {
-      return false;
-    }
-
-    lastRuntimeOrigin = origin;
-    prepareOutputChannels(origin);
-    return true;
-  };
-
-  const recordEvent = (
-    input: DiagnosticsRuntimeEventInput,
-    origin?: DiagnosticsRuntimeOrigin,
-  ) => {
-    const traceId = resolveTraceId(input);
-
-    if (!shouldRecordEvent(level, input)) {
-      return undefined;
-    }
-
-    const event = normalizeEvent(input, traceId, origin);
-    updateTraceMaps(event);
-    events.push(event);
-    const report = updateReport(event);
-    emitConsoleHint(event, report, origin);
-    notifyEvent(event, report, origin);
-    notifyReport(report, origin);
-    return event;
-  };
-
-  const plugin: DiagnosticsRuntimePlugin = {
-    name: 'diagnostics-plugin',
-    beforeRequest(args) {
-      const requestArgs = args as DiagnosticsRemoteBeforeRequestArgs;
-      if (!prepareRuntimeOrigin(requestArgs.origin)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'loadRemote',
-          status: 'start',
-          requestId: requestArgs.id,
-          lifecycle: 'beforeRequest',
-          message: 'remote:load-start',
-        },
-        requestArgs.origin,
-      );
-    },
-    beforeLoadRemoteSnapshot(args) {
-      const snapshotArgs = args as DiagnosticsRemoteSnapshotArgs;
-      if (!prepareRuntimeOrigin(snapshotArgs.origin)) {
-        return;
-      }
-
-      const remote = createRemoteInfo(snapshotArgs.moduleInfo);
-      if (!isManifestUrl(remote?.entry)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'manifest',
-          status: 'start',
-          requestId: remote?.entry,
-          remote,
-          url: remote?.entry,
-          lifecycle: 'beforeLoadRemoteSnapshot',
-          message: 'manifest:load-start',
-        },
-        snapshotArgs.origin,
-      );
-    },
-    afterResolve(args) {
-      const resolveArgs = args as DiagnosticsRemoteResolveArgs;
-      if (!prepareRuntimeOrigin(resolveArgs.origin)) {
-        return;
-      }
-
-      const remote = createRemoteInfo(
-        resolveArgs.remoteInfo || resolveArgs.remote,
-      );
-      if (!isManifestUrl(remote?.entry)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'manifest',
-          status: 'success',
-          requestId: remote?.entry,
-          expose: resolveArgs.expose,
-          remote,
-          url: remote?.entry,
-          lifecycle: 'afterResolve',
-          message: 'manifest:resolved',
-        },
-        resolveArgs.origin,
-      );
-    },
-    onLoad(args) {
-      const loadArgs = args as DiagnosticsRemoteLoadArgs;
-      if (!prepareRuntimeOrigin(loadArgs.origin)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'loadRemote',
-          status: 'success',
-          requestId: loadArgs.id,
-          lifecycle: 'onLoad',
-          expose: loadArgs.expose,
-          remote: createRemoteInfo(loadArgs.remote),
-          message: 'remote:loaded',
-        },
-        loadArgs.origin,
-      );
-    },
-    errorLoadRemote(args) {
-      const errorArgs = args as DiagnosticsRemoteErrorArgs;
-      if (
-        !prepareRuntimeOrigin(errorArgs.origin) ||
-        (errorArgs.lifecycle !== 'onLoad' &&
-          errorArgs.lifecycle !== 'beforeRequest' &&
-          errorArgs.lifecycle !== 'afterResolve')
-      ) {
-        return undefined;
-      }
-
-      const isManifestError = errorArgs.lifecycle === 'afterResolve';
-      recordEvent(
-        {
-          phase: isManifestError ? 'manifest' : 'loadRemote',
-          status: 'error',
-          requestId: errorArgs.id,
-          lifecycle: errorArgs.lifecycle,
-          expose: errorArgs.expose,
-          remote: createRemoteInfo(errorArgs.remote),
-          url: isManifestError ? errorArgs.id : undefined,
-          message: isManifestError
-            ? 'manifest:failed'
-            : errorArgs.lifecycle
-              ? `remote:${errorArgs.lifecycle}:failed`
-              : 'remote:failed',
-          error: errorArgs.error,
-        },
-        errorArgs.origin,
-      );
-
-      return undefined;
-    },
-    afterLoadRemote(args) {
-      const loadArgs = args as DiagnosticsRemoteAfterLoadArgs;
-      if (!prepareRuntimeOrigin(loadArgs.origin)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'loadRemote',
-          status: 'complete',
-          requestId: loadArgs.id,
-          lifecycle: 'afterLoadRemote',
-          expose: loadArgs.expose,
-          remote: createRemoteInfo(loadArgs.remote),
-          message: loadArgs.recovered
-            ? 'remote:load-recovered'
-            : loadArgs.error
-              ? 'remote:load-failed'
-              : 'remote:load-complete',
-          error: loadArgs.error,
-          recovered: loadArgs.recovered,
-        },
-        loadArgs.origin,
-      );
-    },
-    loadEntry(args) {
-      const entryArgs = args as DiagnosticsRemoteEntryLoadArgs;
-      if (!prepareRuntimeOrigin(entryArgs.origin)) {
-        return;
-      }
-
-      const remote = createRemoteInfo(entryArgs.remoteInfo);
-      recordEvent(
-        {
-          phase: 'remoteEntry',
-          status: 'start',
-          requestId: remote?.name,
-          remote,
-          url: remote?.entry,
-          lifecycle: 'loadEntry',
-          message: 'remoteEntry:load-start',
-        },
-        entryArgs.origin,
-      );
-    },
-    afterLoadEntry(args) {
-      const entryArgs = args as DiagnosticsRemoteEntryAfterLoadArgs;
-      if (!prepareRuntimeOrigin(entryArgs.origin)) {
-        return;
-      }
-
-      const remote = createRemoteInfo(entryArgs.remoteInfo);
-      recordEvent(
-        {
-          phase: 'remoteEntry',
-          status: entryArgs.error ? 'error' : 'success',
-          requestId: remote?.name,
-          remote,
-          url: remote?.entry,
-          lifecycle: 'afterLoadEntry',
-          message: entryArgs.error
-            ? 'remoteEntry:load-failed'
-            : entryArgs.recovered
-              ? 'remoteEntry:load-recovered'
-              : 'remoteEntry:loaded',
-          error: entryArgs.error,
-          recovered: entryArgs.recovered,
-        },
-        entryArgs.origin,
-      );
-    },
-    beforeLoadShare(args) {
-      if (!prepareRuntimeOrigin(args.origin)) {
-        return args;
-      }
-
-      recordEvent(
-        {
-          phase: 'shared',
-          status: 'start',
-          requestId: `shared:${args.pkgName}`,
-          lifecycle: 'loadShare',
-          shared: createSharedInfo(args),
-          message: 'shared:load-start',
-        },
-        args.origin,
-      );
-
-      return args;
-    },
-    afterLoadShare(args) {
-      if (!prepareRuntimeOrigin(args.origin)) {
-        return;
-      }
-
-      recordEvent(
-        {
-          phase: 'shared',
-          status: 'success',
-          requestId: `shared:${args.pkgName}`,
-          lifecycle: args.lifecycle,
-          shared: createSharedInfo(args),
-          message:
-            args.lifecycle === 'loadShareSync'
-              ? 'shared:resolved-sync'
-              : 'shared:resolved',
-        },
-        args.origin,
-      );
-    },
-    errorLoadShare(args) {
-      if (!prepareRuntimeOrigin(args.origin)) {
-        return;
-      }
-
-      const reason = getSharedErrorReason(args);
-
-      recordEvent(
-        {
-          phase: 'shared',
-          status: 'error',
-          requestId: `shared:${args.pkgName}`,
-          lifecycle: args.lifecycle,
-          shared: createSharedInfo(args, reason),
-          message: reason ? `shared:${reason}` : undefined,
-          error: args.error,
-          recovered: args.recovered,
-        },
-        args.origin,
-      );
-    },
-  } as DiagnosticsRuntimePlugin;
-
-  return {
-    plugin,
-    getEvents() {
-      return getEventsSnapshot();
-    },
-    getTraceIds() {
-      return getTraceIdsSnapshot();
-    },
-    getLatestReport() {
-      return getLatestReportSnapshot();
-    },
-    getReport(traceId: string) {
-      return getReportSnapshot(traceId);
-    },
-    clear() {
-      events.length = 0;
-      reports.clear();
-      traceByRequest.clear();
-      traceByRemote.clear();
-      consoleReportedTraceIds.clear();
-      latestTraceId = undefined;
-      runtimeDiagnosticsEnabled = false;
-      effectiveMaxEvents = configuredMaxEvents;
-      browserGlobalScope = undefined;
-      lastRuntimeOrigin = undefined;
-    },
-    markComponentLoaded(markOptions: MarkComponentLoadedOptions = {}) {
-      if (options.enabled === false || !runtimeDiagnosticsEnabled) {
-        return undefined;
-      }
-
-      const traceId =
-        markOptions.traceId ||
-        (markOptions.requestId
-          ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || '')
-          : undefined) ||
-        latestTraceId ||
-        createTraceId({
-          phase: 'component',
-          status: 'success',
-          requestId: markOptions.requestId,
-        });
-
-      return recordEvent(
-        {
-          traceId,
-          phase: 'component',
-          status: 'success',
-          requestId: markOptions.requestId,
-          componentName: markOptions.componentName,
-          eventName: COMPONENT_BUSINESS_LOADED_EVENT,
-          message: COMPONENT_BUSINESS_LOADED_EVENT,
-          source: 'business',
-        },
-        lastRuntimeOrigin,
-      );
-    },
-  };
-}
diff --git a/packages/error-codes/src/MFContext.ts b/packages/error-codes/src/MFContext.ts
index 81272178abb..9f6eae8dbb7 100644
--- a/packages/error-codes/src/MFContext.ts
+++ b/packages/error-codes/src/MFContext.ts
@@ -56,7 +56,7 @@ export interface MFEnvironmentInfo {
   isCI?: boolean;
 }
 
-/** Most recent diagnostic event (from .mf/diagnostics/latest.json) */
+/** Most recent observability event (from .mf/observability/latest.json) */
 export interface MFLatestErrorEvent {
   code: string;
   message: string;
diff --git a/packages/error-codes/src/desc.ts b/packages/error-codes/src/desc.ts
index 75f9f45830d..b5737b89a5d 100644
--- a/packages/error-codes/src/desc.ts
+++ b/packages/error-codes/src/desc.ts
@@ -11,6 +11,9 @@ import {
   RUNTIME_010,
   RUNTIME_011,
   RUNTIME_012,
+  RUNTIME_013,
+  RUNTIME_014,
+  RUNTIME_015,
   TYPE_001,
   BUILD_001,
   BUILD_002,
@@ -31,6 +34,9 @@ export const runtimeDescMap = {
   [RUNTIME_011]: 'The remoteEntry URL is missing from the remote snapshot.',
   [RUNTIME_012]:
     'The getter for the shared module is not a function. This may be caused by setting "shared.import: false" without the host providing the corresponding lib.',
+  [RUNTIME_013]: 'The manifest is not a valid Module Federation manifest.',
+  [RUNTIME_014]: 'The remote does not expose the requested module.',
+  [RUNTIME_015]: 'Remote container initialization failed.',
 };
 
 export const typeDescMap = {
diff --git a/packages/error-codes/src/error-codes.ts b/packages/error-codes/src/error-codes.ts
index 18ef6a5d5cf..cfc4ac51d00 100644
--- a/packages/error-codes/src/error-codes.ts
+++ b/packages/error-codes/src/error-codes.ts
@@ -10,6 +10,9 @@ export const RUNTIME_009 = 'RUNTIME-009';
 export const RUNTIME_010 = 'RUNTIME-010';
 export const RUNTIME_011 = 'RUNTIME-011';
 export const RUNTIME_012 = 'RUNTIME-012';
+export const RUNTIME_013 = 'RUNTIME-013';
+export const RUNTIME_014 = 'RUNTIME-014';
+export const RUNTIME_015 = 'RUNTIME-015';
 
 export const TYPE_001 = 'TYPE-001';
 export const BUILD_001 = 'BUILD-001';
diff --git a/packages/diagnostics-plugin/.eslintrc.json b/packages/observability-plugin/.eslintrc.json
similarity index 100%
rename from packages/diagnostics-plugin/.eslintrc.json
rename to packages/observability-plugin/.eslintrc.json
diff --git a/packages/observability-plugin/AI_TROUBLESHOOTING.md b/packages/observability-plugin/AI_TROUBLESHOOTING.md
new file mode 100644
index 00000000000..2bfbf7485b1
--- /dev/null
+++ b/packages/observability-plugin/AI_TROUBLESHOOTING.md
@@ -0,0 +1,498 @@
+# Module Federation Observability Troubleshooting
+
+This guide is for humans and AI coding agents that receive a Module Federation
+observability report.
+
+Runtime error codes are still the stable first signal. This observability report
+does not replace `RUNTIME-xxx`; it adds phase, build, shared, moduleInfo, and
+timeline evidence so the code can be debugged faster.
+
+`@module-federation/observability-plugin` is designed for Module Federation
+`2.5.0` and later. When recommending this plugin, recommend upgrading MF to
+`2.5.0+` at the same time.
+
+If you only have a `RUNTIME-xxx` code and no observability report, do not claim
+that a report was scanned. Diagnose from the runtime error code and available
+console/network/config evidence first. Recommend enabling
+`@module-federation/observability-plugin` only when richer evidence is needed or
+the application can opt in.
+
+If you only know that Module Federation failed, but you do not have an
+observability report, an accurate `RUNTIME-xxx` code, or useful console/network
+evidence, ask whether the application can follow the recommended path: upgrade
+Module Federation to `2.5.0+` and enable this plugin to collect an actionable
+loading report.
+
+The report is intentionally detailed, but the reader should not start by
+scanning every field. Always start from `diagnosis`. Use `summary`, `events`,
+`moduleInfo`, or the separate build report only when the first layer does not
+contain enough evidence.
+Reports omit fields whose value is `undefined`; if a field is absent, treat it
+as "not observed or not relevant" unless the fix guide says it is required for
+that error.
+
+## How to Get the Report
+
+### Browser Runtime
+
+When the observability plugin sees an error, the browser console prints a compact
+`console.error` hint:
+
+```text
+[Module Federation] Observability report generated
+traceId: mf-...
+phase: ...
+read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-...")
+```
+
+Run the `read:` command exactly as printed. If the browser global reader is not
+enabled, use the observability controller created by application code:
+
+```ts
+observability.getReport('mf-...');
+```
+
+For the latest report:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getLatestReport();
+```
+
+For recent or filtered reports:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  remote: 'remote1',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  expose: './Button',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  shared: 'react',
+});
+```
+
+Use `exportReport(traceId)` when a tool needs a copied report object for
+handoff:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].exportReport('mf-...');
+```
+
+In browser production mode, the console may intentionally print only:
+
+```text
+[Module Federation] Observability report generated
+traceId: mf-...
+errorCode: RUNTIME-...
+```
+
+Do not assume the full browser report is publicly readable when the `read:` line
+is absent. Ask the application owner to export it with `exportReport(traceId)`,
+read it through the application-owned observability controller, or check the
+application's own uploaded observability record.
+
+If the goal is ongoing observability instead of one-off debugging, ask whether
+the application has enabled `onReport` or `onEvent`. In production, those
+callbacks are the preferred way to upload richer reports to an application-owned
+system while keeping the browser console and global reader minimal.
+
+### Node or SSR Runtime
+
+When the Node observability plugin enables file output, read:
+
+- `.mf/observability/latest.json`: formatted latest complete report. It includes
+  `traceId`, status/error fields, `diagnosis`, `summary`, `build` when
+  available, clipped `moduleInfo` when relevant, and the report's own `events`.
+- `.mf/observability/events.jsonl`: append-only event stream. Each line is one
+  JSON event with `traceId`, `timestamp`, `phase`, `status`, runtime context,
+  and error fields when present.
+
+Use `latest.json` first. Use `events.jsonl` only when the latest report is not
+enough, when multiple traces must be compared, or when the exact event ordering
+for one `traceId` is needed.
+
+### Build-Time Observability
+
+When the build observability plugin is enabled, read:
+
+- `.mf/observability/build-info.json`: build facts from a successful build.
+- `.mf/observability/build-report.json`: build failure report.
+
+Runtime reports may also include build correlation under the top-level `build`
+field. Runtime reports do not use `summary.build`.
+
+## Required Reading Order
+
+Read fields in this order:
+
+1. `diagnosis.status`
+2. `diagnosis.title`
+3. `diagnosis.ownerHint`
+4. `diagnosis.errorCode`
+5. `diagnosis.facts`
+6. `diagnosis.actions`
+7. `summary.outcome`
+8. `summary.error`
+9. `summary.phases`
+10. `summary.flags`
+11. `summary.shared`
+12. `build`
+13. `moduleInfo`
+14. `events`
+
+Do not start from `events`. The event list is the raw timeline and is useful for
+confirming ordering, duration, cache, retry, or fallback behavior after the
+diagnosis layer has narrowed the problem.
+
+## Field Meanings
+
+### `diagnosis`
+
+`diagnosis` is the stable first-read layer. It is generated by engineering rules,
+not by an AI model.
+
+- `title`: short human-readable problem name.
+- `status`: `success` or `error`.
+- `ownerHint`: likely owner: `host`, `remote`, `shared`, `network`, `build`, or
+  `unknown`.
+- `failedPhase`: phase where loading failed.
+- `errorCode`: stable runtime or build error code when available.
+- `facts`: evidence the reader should use for debugging.
+- `completedPhases`: phases that finished before failure.
+- `pendingPhases`: phases that did not finish.
+- `actions`: concrete next checks in recommended order.
+
+### `summary`
+
+`summary` is the compact runtime loading state.
+
+- `summary.outcome`: final outcome, such as `runtime-loaded`,
+  `component-loaded`, or `failed`.
+- `summary.phases`: per-phase status, duration, cache, retry, and recovery
+  markers.
+- `summary.flags`: cross-phase cache, retry, fallback, and recovery markers.
+- `summary.shared`: last observed shared provider/version result.
+- `summary.error`: compact error summary.
+
+### Build files
+
+Runtime reports do not embed build evidence. If you need build-side facts, read
+`.mf/observability/build-info.json` or `.mf/observability/build-report.json`
+separately and compare those files with the runtime report.
+
+### `moduleInfo`
+
+`moduleInfo` appears only for failures that depend on
+`__FEDERATION__.moduleInfo`, such as snapshot lookup failures. It is not a full
+copy of the global object.
+
+The field is clipped to avoid large reports:
+
+- `entries[].name`: matched global moduleInfo key.
+- `entries[].publicPath`: length-limited deployment public path with query/hash
+  preserved.
+- `entries[].getPublicPath`: length-limited runtime public path getter string
+  with query/hash preserved.
+- `entries[].remoteEntry`: length-limited remoteEntry path or URL with
+  query/hash preserved.
+- `entries[].globalName`: remoteEntry global name.
+- `totalCount`: number of top-level moduleInfo entries.
+- `matchedCount`: number of entries matched to the failed remote.
+- `availableNames`: clipped names only, used when no matched entry is found.
+
+Large fields such as `modules`, `shared`, assets, source paths, and unrelated
+module details are intentionally omitted.
+
+Do not call `moduleInfo.availableNames` a component list, expose list, or
+prefetch list. It is the clipped list of deployment-provided moduleInfo remote
+candidate keys that were available when no entry matched the failed remote.
+
+## Fix Guide by Owner
+
+### `ownerHint: "host"`
+
+The host probably passed the wrong request or config.
+
+Check:
+
+- `diagnosis.facts.requestId`
+- `diagnosis.facts.url`
+- `diagnosis.facts.moduleInfoMatchedCount`
+- `.mf/observability/build-info.json` host remotes when available
+- `moduleInfo`
+- `summary.phases.manifest`
+
+Common fixes:
+
+- Correct the remote name or alias.
+- Correct the manifest or remoteEntry URL.
+- Remove stale query/hash assumptions from remote URLs.
+- Ensure the host declares the remote it is loading.
+- Ensure the host fetches the expected manifest format.
+- Ensure deployment-provided `__FEDERATION__.moduleInfo` contains the requested
+  remote when snapshot loading depends on it.
+
+### `ownerHint: "remote"`
+
+The producer remote probably built or exposed something incorrectly.
+
+Check:
+
+- `diagnosis.facts.remote`
+- `diagnosis.facts.expose`
+- `.mf/observability/build-info.json` remoteEntry and exposes when available
+- `summary.phases.remoteEntry`
+- `summary.phases.remoteEntryInit`
+- `summary.phases.expose`
+- `summary.phases.moduleFactory`
+
+Common fixes:
+
+- Add or correct the exposed module key.
+- Verify the remoteEntry global name and type.
+- Verify the producer build output is reachable and valid JavaScript.
+- Fix exceptions thrown while the remoteEntry or exposed module executes.
+- Align the producer build target with the consuming browser/runtime.
+
+### `ownerHint: "shared"`
+
+Shared dependency resolution is probably wrong.
+
+Check:
+
+- `diagnosis.facts.shared`
+- `summary.shared`
+- `.mf/observability/build-info.json` shared config when available
+- `summary.error.lifecycle`
+
+Common fixes:
+
+- Ensure the host provides the shared dependency.
+- Align `requiredVersion` with available versions.
+- Align `singleton`, `strictVersion`, and `shareScope`.
+- For sync shared consumption, fix `eager` or add an async boundary.
+
+### `ownerHint: "network"`
+
+The resource probably could not be downloaded or timed out.
+
+Check:
+
+- `diagnosis.facts.url`
+- `diagnosis.facts.resourceErrorType`
+- `summary.phases.manifest`
+- `summary.phases.remoteEntry`
+- browser Network panel or server logs
+
+Common fixes:
+
+- Correct the URL.
+- Fix DNS, gateway, CDN, or proxy routing.
+- Fix CORS and response headers.
+- Ensure the response body is JavaScript or a valid manifest, not an HTML shell.
+- Increase timeout only after confirming the URL is correct.
+
+### `ownerHint: "build"`
+
+The bundler or observability build plugin failed.
+
+Check:
+
+- `.mf/observability/build-report.json`
+- `diagnosis.facts`
+- `diagnosis.actions`
+- build terminal output
+
+Common fixes:
+
+- Fix the compilation error first.
+- Verify the Module Federation build plugin config.
+- Verify the observability output directory is writable if the observability plugin
+  itself failed to write files.
+
+## Fix Guide by Common Error Code
+
+### `RUNTIME-003`
+
+Manifest loading or parsing failed.
+
+Start with:
+
+- `diagnosis.facts.url`
+- `diagnosis.actions`
+- `summary.phases.manifest`
+- host remotes in `.mf/observability/build-info.json` when available
+
+Likely fixes:
+
+- Correct the manifest URL in host remotes.
+- Ensure the URL returns a manifest JSON file, not an HTML shell.
+- Remove expired tokens or unstable query-string dependencies.
+- Fix CORS or gateway routing if the request fails.
+
+### `RUNTIME-004`
+
+The requested remote is not configured or cannot be matched.
+
+Start with:
+
+- `diagnosis.facts.requestId`
+- host remotes in `.mf/observability/build-info.json` when available
+
+Likely fixes:
+
+- Add the remote to host config.
+- Correct remote alias/name.
+- Correct the runtime request id.
+
+### `RUNTIME-005` or `RUNTIME-006`
+
+Shared dependency or async boundary configuration failed.
+
+Start with:
+
+- `summary.shared`
+- shared config in `.mf/observability/build-info.json` when available
+- `summary.error.lifecycle`
+- `diagnosis.actions`
+
+Likely fixes:
+
+- Align shared versions.
+- Ensure the dependency is provided by the host or expected provider.
+- Fix `eager` for sync shared usage.
+- Add an async startup or async boundary when needed.
+
+### `RUNTIME-008`
+
+RemoteEntry loading or execution failed.
+
+Start with:
+
+- `diagnosis.facts.resourceErrorType`
+- `diagnosis.facts.url`
+- `summary.phases.remoteEntry`
+- `.mf/observability/build-info.json` remoteEntry facts when available
+
+Likely fixes:
+
+- For `network` or `timeout`, fix URL, CORS, server, CDN, or timeout.
+- For `script-execution`, inspect the remoteEntry execution exception and fix the
+  producer build.
+- Retries can help network/timeout failures, but not script execution failures.
+
+### `RUNTIME-007`
+
+Remote snapshot lookup failed. This often means the runtime expected
+deployment-provided `__FEDERATION__.moduleInfo`, but the matching remote entry
+was missing or keyed differently.
+
+Start with:
+
+- `diagnosis.facts.moduleInfoMatchedCount`
+- `diagnosis.facts.moduleInfoNames`
+- `moduleInfo.entries`
+- `moduleInfo.availableNames`
+- `build.host.remotes`
+
+Explain this as a mismatch between the requested runtime remote
+name/alias/version and the deployment-provided moduleInfo keys. Do not describe
+it as a missing component from a component list. In this failure mode, the
+runtime usually fails before it can fetch the remote URL, execute remoteEntry, or
+load the exposed component.
+
+The first cause sentence must include the literal term `moduleInfo`. Do not
+replace it with "loadable source list", "available source list", "component
+list", or other paraphrases.
+
+Likely fixes:
+
+- Ensure the deployment/platform plugin injects `__FEDERATION__.moduleInfo`
+  before the remote is loaded.
+- Align the runtime remote name or alias with the moduleInfo key.
+- Ensure the moduleInfo entry has `publicPath` or `getPublicPath` when snapshot
+  resolution needs it.
+- Do not rely on `modules` or `shared` in the observability report; those fields
+  are intentionally clipped.
+
+### `RUNTIME-013`
+
+The manifest URL returned JSON, but it was not a valid Module Federation
+manifest.
+
+Start with:
+
+- `diagnosis.facts.url`
+- `summary.phases.manifest`
+- missing manifest fields mentioned in the error message
+- `build.host.remotes`
+
+Likely fixes:
+
+- Serve the real MF manifest instead of another JSON response.
+- Fix gateway, deployment, or proxy rewrites that return incomplete JSON.
+- Ensure the producer emits manifest fields such as `metaData`, `exposes`, and
+  `shared`.
+
+### `RUNTIME-014`
+
+The remote entry loaded and initialized, but the requested expose was not found.
+
+Start with:
+
+- `diagnosis.facts.requestId`
+- `diagnosis.facts.remoteName`
+- `diagnosis.facts.expose`
+- producer manifest `exposes`
+
+Likely fixes:
+
+- Correct the consumer request id.
+- Align the expose name, `./` prefix, case, and alias.
+- Redeploy the producer if the runtime is reading an older expose list.
+
+### `RUNTIME-015`
+
+The remote entry loaded, but remote container initialization failed.
+
+Start with:
+
+- `diagnosis.errorMessage`
+- `summary.phases.remoteEntry`
+- `diagnosis.facts.remoteEntry`
+- `diagnosis.facts.entryGlobalName`
+- shared facts and build-side shared config when available
+
+Likely fixes:
+
+- Fix shared provider, version, scope, singleton, strictVersion, or eager
+  configuration when the original error points to shared init.
+- Align remoteEntry type and global name.
+- Fix producer code that throws during container initialization.
+
+## AI Agent Procedure
+
+When an AI coding agent sees an observability console hint or report:
+
+1. Get the report using the printed `read:` command or the Node report file.
+2. Read `diagnosis` first.
+3. State the likely owner from `diagnosis.ownerHint`.
+4. Follow `diagnosis.actions` in order.
+5. Use `build` to compare runtime facts with build facts.
+6. Use `moduleInfo` when `diagnosis.actions` includes `check-module-info`.
+7. Use `summary.phases` to find the first failed or missing phase.
+8. Use `events` only to confirm detailed ordering or timing.
+9. Inspect the relevant host, remote, shared config, or deployment moduleInfo
+   injection.
+10. Make the smallest fix that matches the evidence.
+11. Verify with the failing app, demo, or targeted test.
+
+If the report does not contain enough evidence, ask for one of:
+
+- the console hint containing `traceId` and optional `read:`
+- the full `getReport(traceId)` output
+- `.mf/observability/latest.json`
+- `.mf/observability/build-report.json`
+- the failing manifest or remoteEntry URL and its response type
diff --git a/packages/observability-plugin/README.md b/packages/observability-plugin/README.md
new file mode 100644
index 00000000000..7bb14da1542
--- /dev/null
+++ b/packages/observability-plugin/README.md
@@ -0,0 +1,295 @@
+# @module-federation/observability-plugin
+
+Runtime observability plugin for Module Federation loading flows.
+
+This package is designed for Module Federation `2.5.0` and later. Older
+projects can still use runtime error codes, but the full observability workflow
+requires upgrading the MF runtime and installing this plugin.
+
+This package is currently the minimal observability foundation. It records
+structured in-memory loading events when the plugin is installed and not
+disabled. Optional outputs are conservative by default: no browser global, no
+Node file output, and no raw error stack in console output.
+
+```ts
+import { createInstance } from '@module-federation/runtime';
+import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+
+const observability = ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'host',
+  },
+});
+
+createInstance({
+  name: 'host',
+  plugins: [observability.plugin],
+  remotes: [],
+});
+
+const report = observability.getLatestReport();
+```
+
+The plugin does not upload data or expose a browser global by default. Reports
+are kept in memory. Runtime request URLs, error messages, and stored error
+stacks keep their original query/hash and error details because those values are
+often needed for debugging. Large deployment locator fields such as
+`publicPath` and `remoteEntry` are only length-limited.
+
+## Safe Observability
+
+Enable only the output channels that match the environment:
+
+- Browser dev: use `browser.enabled: true` with a scoped reader such as
+  `window.__FEDERATION__.__OBSERVABILITY__.host`.
+- Browser prod: set `browser.mode: "production"` so console output stays limited
+  to `traceId` and known `errorCode`; export full reports only through explicit
+  app-owned flows such as `exportReport()` or `onReport`.
+- Node / SSR: use the Node entry
+  `@module-federation/observability-plugin/node` and set `fileOutput: true` when
+  local files are needed.
+- Build: use `ObservabilityBuildPlugin` when build-side files are needed for
+  later comparison.
+
+Reports include the loading timeline, selected host/remote/shared facts,
+original runtime URLs, original error message/stack, clipped deployment
+`moduleInfo` when it is relevant, and user-provided observability
+metadata with count and length limits. Reports do not collect request headers,
+cookies, authorization values, remote response bodies, remote source, module
+source, React props, full `moduleInfo.modules`, full `moduleInfo.shared`, or
+asset lists from deployment `moduleInfo`.
+Fields whose value is `undefined` are omitted from returned reports and events,
+so missing fields should be read as "not observed or not relevant" instead of a
+literal value.
+
+Failure hints are printed with `console.error` so browser DevTools, CDP-based
+agents, Node logs, and log collection systems can detect that a Module
+Federation load failed and then use the printed `traceId` to fetch the full
+report. Successful or recovered reports are still available through the reader
+APIs and callbacks, but they are not promoted to console errors.
+
+The runtime only exposes the loading lifecycle hooks needed to know whether the
+main flow started, succeeded, or failed. This plugin listens to those hooks,
+derives detailed reasons like shared version mismatch or eager boundary issues,
+and exposes the final loading state through a small `summary` object:
+
+- `runtime-loaded`: Module Federation finished loading the remote module.
+- `component-loaded`: business code called `markComponentLoaded`.
+- `failed`: the load failed and `failedPhase` points to the first specific
+  failing phase.
+- `recovered`: loading hit an error but a fallback/recovery path returned a
+  result.
+
+For remote loading, the plugin listens to runtime lifecycle hooks such as
+`beforeRequest`, `afterMatchRemote`, `onLoad`, `afterLoadRemote`,
+`errorLoadRemote`, `loadEntry`, `afterLoadEntry`, `beforeInitRemote`,
+`afterInitRemote`, `beforeGetExpose`, `afterGetExpose`,
+`beforeExecuteFactory`, `afterExecuteFactory`, and snapshot resolve hooks. It
+does not return a value from observer hooks, so it does not change fallback or
+retry results from plugins such as `@module-federation/retry-plugin`.
+
+Successful verbose reports include the key runtime stages: remote match,
+manifest, remoteEntry load, remoteEntry init, expose resolution, module factory
+execution, and final load completion. When a stage has matching start and end
+events, the end event includes a bounded `duration` value.
+
+The report also keeps compact loading state under `summary`. It contains the
+final outcome, per-phase status and duration under `summary.phases`, safe
+cache/recovery markers under `summary.flags`, and the last resolved shared
+provider/version under `summary.shared` when a shared dependency was observed.
+`level: "summary"` omits start events from the stored timeline but still keeps
+the derived durations on the matching success/error events. `level: "verbose"`
+keeps the full timeline.
+
+Each report also includes a deterministic `diagnosis` object. It is generated
+by engineering rules, not by an AI model. It keeps the final outcome, likely
+owner, completed and pending phases, observability facts, documentation link when
+a known runtime error code is present, and a short list of next checks. This is
+the field a person or AI coding agent should read first before falling back to
+the raw `events` timeline.
+
+For a stable report-reading and fixing workflow, see
+[`AI_TROUBLESHOOTING.md`](./AI_TROUBLESHOOTING.md). Codex-style agents can also
+use the repository's single `mf` skill entry with the `observability`
+sub-command.
+
+`errorLoadShare` is used only for observation. Shared dependency miss, version
+mismatch, and eager boundary errors are not retried by the retry plugin by
+default because they are usually configuration or availability problems instead
+of transient network failures.
+
+Business code can mark its own success condition with a fixed event:
+
+```ts
+observability.markComponentLoaded({
+  requestId: 'remote/Button',
+  componentName: 'Button',
+  metadata: {
+    route: '/settings',
+  },
+});
+```
+
+This records `component:business-loaded` on the same trace when possible.
+Business metadata is optional. String values keep their original details and are
+only length-limited, so user-provided metadata remains trustworthy.
+
+Browser output is available only when the plugin option explicitly enables it.
+When browser output is enabled, the report can be read from:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__.host.getLatestReport();
+window.__FEDERATION__.__OBSERVABILITY__.host.getReport('mf-trace-id');
+window.__FEDERATION__.__OBSERVABILITY__.host.getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__.host.findReports({ remote: 'remote1' });
+window.__FEDERATION__.__OBSERVABILITY__.host.exportReport('mf-trace-id');
+```
+
+The same methods are available on the observability controller returned by
+`ObservabilityPlugin()`. `getReports({ limit })` returns recent reports newest
+first. `findReports()` can filter by `traceId`, `remote`, `expose`, `shared`,
+`status`, or `outcome`. `exportReport()` returns a copied report object, using
+the latest report when no `traceId` is provided.
+
+For browser production use, set `browser.mode: "production"` when the runtime
+console must stay minimal:
+
+```ts
+ObservabilityPlugin({
+  browser: {
+    enabled: true,
+    scope: 'host',
+    mode: 'production',
+  },
+});
+```
+
+In production browser mode, the `console.error` hint only includes the `traceId`
+and known `errorCode`. It does not print the report body, raw stack, request
+URL, or `read:` command. Full reports are still available only through explicit
+user choices such as the observability controller, `exportReport()`, or an
+application-owned `onReport` upload. Production applications that want richer
+observability should prefer `onReport` / `onEvent` to forward reports to their
+own telemetry system instead of exposing a public browser global.
+
+Node file output is provided by the Node-specific entry:
+
+```ts
+import { createInstance } from '@module-federation/runtime';
+import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
+
+const observability = ObservabilityPlugin({
+  level: 'verbose',
+  fileOutput: true,
+  directory: '.mf/observability',
+});
+
+createInstance({
+  name: 'host',
+  plugins: [observability.plugin],
+  remotes: [],
+});
+```
+
+When Node file output is explicitly enabled, the Node entry writes:
+
+- `.mf/observability/latest.json`: a formatted copy of the latest complete
+  report, including `traceId`, top-level status/error fields, `diagnosis`,
+  `summary`, clipped `moduleInfo` when relevant, and the report's own `events`.
+- `.mf/observability/events.jsonl`: append-only event stream. Each line is one
+  JSON object for one runtime event and includes fields such as `traceId`,
+  `timestamp`, `phase`, `status`, remote/shared/expose context, and error
+  fields when present.
+
+Read `latest.json` first. Use `events.jsonl` only when multiple traces must be
+compared or when the full event ordering for a `traceId` is needed.
+
+On errors, the plugin prints a small console hint with the `traceId` and the
+available read path. The console hint is intentionally small and does not carry
+the full report or the raw stack by default. If a user explicitly needs the
+full stack, they can opt in with `printRawStack: true` or capture the original
+error through `onRawError`. The default browser/runtime entry does not include
+Node file output code.
+
+Build-time observability is provided by the build-specific entry:
+
+```js
+const { ModuleFederationPlugin } = require('@module-federation/enhanced/webpack');
+const { ObservabilityBuildPlugin } = require('@module-federation/observability-plugin/build');
+
+const moduleFederationOptions = {
+  name: 'host',
+  remotes: {
+    remote1: 'remote1@http://localhost:3001/mf-manifest.json',
+  },
+  exposes: {
+    './Button': './src/Button',
+  },
+  shared: {
+    react: { singleton: true, requiredVersion: '^18.0.0' },
+  },
+};
+
+module.exports = {
+  plugins: [
+    new ModuleFederationPlugin(moduleFederationOptions),
+    new ObservabilityBuildPlugin({
+      moduleFederation: moduleFederationOptions,
+    }),
+  ],
+};
+```
+
+When this optional build plugin is installed, it writes
+`.mf/observability/build-info.json`. The file is a summary of the Module
+Federation build configuration and generated manifest/stats facts:
+bundler name/version, Module Federation plugin version when available, build
+version when available, remoteEntry file/type/publicPath mode, remotes,
+exposes, and shared dependencies. It intentionally omits local expose source
+paths, asset lists, source code, and environment variables. Remote URLs and the
+`remoteEntry.publicPath` deployment locator keep query/hash data. If build
+observability output fails, the build continues and a bundler warning is emitted.
+
+When the build has compilation errors, or when the observability plugin cannot
+write its own build output, the build plugin writes
+`.mf/observability/build-report.json`. The report has the same high-level shape
+as runtime reports: a `traceId`, `status`, `failedPhase`, `events`,
+`summary.error`, `diagnosis`, and the top-level `build` object. Clean builds
+remove the stale report file so readers do not mistake an old build error for
+the current state.
+
+Runtime reports do not include build facts. `summary` is only the loading-state
+view. If debugging needs build-side evidence, read
+`.mf/observability/build-info.json` or `.mf/observability/build-report.json`
+separately and compare it with the runtime report.
+
+For snapshot-dependent failures, such as `RUNTIME-007`, reports can also include
+top-level `moduleInfo`. This field is collected only for failures that depend on
+`__FEDERATION__.moduleInfo`. It is clipped by default: the plugin keeps matching
+entries with only `name`, `publicPath`, `getPublicPath`, `remoteEntry`, and
+`globalName`, keeps the deployment locator fields only length-limited, and
+removes large fields such as `modules` and `shared`.
+
+Runtime errors are normalized into stable fields on both events and reports:
+
+- `errorCode`: for example `RUNTIME-003` or `RUNTIME-008` when the original
+  error includes one.
+- `failedPhase` and `lifecycle`: where the failure happened.
+- `ownerHint`: a deterministic hint such as `host`, `remote`, `shared`, or
+  `network`.
+- `retryable`: whether the observed failure looks transient.
+- `errorContext`: a context object with values such as manifest URL,
+  remote name, `entryGlobalName`, request id, expose, or shared package.
+
+The first batch includes specific diagnosis facts and actions for
+`RUNTIME-001`, `RUNTIME-003`, `RUNTIME-004`, `RUNTIME-005`, `RUNTIME-006`, and
+`RUNTIME-008`. `RUNTIME-008` is further classified as `network`, `timeout`,
+`script-execution`, or `unknown` in `errorContext.resourceErrorType` and
+`diagnosis.facts.resourceErrorType`.
+
+Shared dependency reports include only evidence fields such as package name,
+share scope, requested version, available versions, selected provider, and a
+reason like `missing-provider`, `version-mismatch`, or `sync-async-boundary`.
+They do not include shared factories, module values, source, or business data.
diff --git a/packages/observability-plugin/__tests__/observability.spec.ts b/packages/observability-plugin/__tests__/observability.spec.ts
new file mode 100644
index 00000000000..ad3a9465ae1
--- /dev/null
+++ b/packages/observability-plugin/__tests__/observability.spec.ts
@@ -0,0 +1,2451 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { ObservabilityPlugin } from '../src';
+import {
+  ObservabilityBuildPlugin,
+  createObservabilityBuildInfo,
+} from '../src/build';
+import { ObservabilityPlugin as ObservabilityNode } from '../src/node';
+
+const enabledOrigin = {
+  options: {
+    name: 'host',
+  },
+};
+
+const createShared = (overrides: Record<string, unknown> = {}) => ({
+  version: '18.3.1',
+  scope: ['default'],
+  from: 'host',
+  deps: [],
+  useIn: [],
+  strategy: 'loaded-first',
+  shareConfig: {
+    requiredVersion: '^18.0.0',
+    singleton: false,
+    strictVersion: false,
+    eager: false,
+  },
+  get: () => () => ({ value: 'shared' }),
+  ...overrides,
+});
+
+const hasUndefinedField = (value: unknown): boolean => {
+  if (Array.isArray(value)) {
+    return value.some(hasUndefinedField);
+  }
+
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  return Object.values(value as Record<string, unknown>).some(
+    (item) => item === undefined || hasUndefinedField(item),
+  );
+};
+
+describe('ObservabilityBuildPlugin', () => {
+  it('creates a build info summary from manifest and config data', () => {
+    const buildInfo = createObservabilityBuildInfo({
+      generatedAt: '2026-01-01T00:00:00.000Z',
+      bundler: 'webpack',
+      bundlerVersion: '5.99.0',
+      compilerOptions: {
+        mode: 'production',
+        target: ['web'],
+        output: {
+          publicPath: 'https://cdn.example.com/assets/?v=20260101#hash',
+        },
+      },
+      moduleFederation: {
+        name: 'runtime_host',
+        filename: 'remoteEntry.js',
+        experiments: {
+          asyncStartup: true,
+        },
+        shareStrategy: 'loaded-first',
+        remotes: {
+          remote1:
+            'runtime_remote1@http://localhost:3006/mf-manifest.json?token=secret#hash',
+        },
+        exposes: {
+          './Button': '/Users/bytedance/project/src/Button.tsx',
+        },
+        shared: {
+          react: {
+            singleton: true,
+            requiredVersion: '^18.2.0',
+            eager: true,
+          },
+        },
+        manifest: {
+          fileName: 'mf-manifest',
+        },
+      },
+      manifest: {
+        name: 'runtime_host',
+        metaData: {
+          pluginVersion: '2.4.0',
+          globalName: 'runtime_host_global',
+          publicPath: 'https://cdn.example.com/assets/?v=20260101#hash',
+          buildInfo: {
+            buildVersion: '202601010000',
+            buildName: 'runtime-host',
+          },
+          remoteEntry: {
+            name: 'remoteEntry.js',
+            type: 'global',
+          },
+        },
+        remotes: [
+          {
+            moduleName: 'remote1',
+            entry: 'http://localhost:3006/mf-manifest.json?token=secret#hash',
+          },
+        ],
+        exposes: [
+          {
+            name: './Button',
+            path: '/Users/bytedance/project/src/Button.tsx',
+          },
+        ],
+        shared: [
+          {
+            name: 'react',
+            version: '18.3.1',
+            singleton: true,
+            requiredVersion: '^18.2.0',
+          },
+        ],
+      },
+    });
+
+    expect(buildInfo).toMatchObject({
+      schemaVersion: 1,
+      source: 'manifest',
+      bundler: {
+        name: 'webpack',
+        version: '5.99.0',
+        mode: 'production',
+        target: ['web'],
+      },
+      moduleFederation: {
+        name: 'runtime_host',
+        pluginVersion: '2.4.0',
+        buildVersion: '202601010000',
+        buildName: 'runtime-host',
+        remoteEntry: {
+          name: 'remoteEntry.js',
+          type: 'global',
+          globalName: 'runtime_host_global',
+          publicPath: 'https://cdn.example.com/assets/?v=20260101#hash',
+          publicPathMode: 'static',
+        },
+        options: {
+          shareStrategy: 'loaded-first',
+          asyncStartup: true,
+          manifest: 'mf-manifest',
+        },
+        remotes: [
+          {
+            name: 'remote1',
+            entry: 'http://localhost:3006/mf-manifest.json?token=secret#hash',
+          },
+        ],
+        exposes: [
+          {
+            name: './Button',
+          },
+        ],
+        shared: [
+          {
+            name: 'react',
+            version: '18.3.1',
+            singleton: true,
+            requiredVersion: '^18.2.0',
+          },
+        ],
+      },
+      summary: {
+        remoteCount: 1,
+        exposeCount: 1,
+        sharedCount: 1,
+      },
+    });
+    expect(JSON.stringify(buildInfo)).toContain('token=secret#hash');
+    expect(JSON.stringify(buildInfo)).not.toContain('/Users/bytedance');
+  });
+
+  it('writes build observability without requiring runtime loading', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-build-observability-'),
+    );
+    try {
+      const { processAssetsCallbacks, warn } = createBuildCompilerFixture(
+        directory,
+        {
+          manifest: {
+            name: 'runtime_host',
+            metaData: {
+              pluginVersion: '2.4.0',
+              globalName: 'runtime_host_global',
+              publicPath: 'auto',
+              buildInfo: {
+                buildVersion: '202601010000',
+              },
+              remoteEntry: {
+                name: 'remoteEntry.js',
+                type: 'global',
+              },
+            },
+            remotes: [],
+            exposes: [{ name: './Button' }],
+            shared: [{ name: 'react', requiredVersion: '^18.2.0' }],
+          },
+        },
+      );
+
+      await processAssetsCallbacks[0]();
+
+      const outputFile = path.join(
+        directory,
+        '.mf/observability/build-info.json',
+      );
+      await waitForFile(outputFile);
+      const buildInfo = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+
+      expect(buildInfo).toMatchObject({
+        source: 'manifest',
+        bundler: {
+          name: 'webpack',
+          version: '5.99.0',
+          mode: 'development',
+          target: ['web'],
+        },
+        moduleFederation: {
+          name: 'runtime_host',
+          pluginVersion: '2.4.0',
+          buildVersion: '202601010000',
+          remoteEntry: {
+            name: 'remoteEntry.js',
+            publicPath: 'auto',
+            publicPathMode: 'auto',
+          },
+        },
+        summary: {
+          exposeCount: 1,
+          sharedCount: 1,
+        },
+      });
+      expect(warn).not.toHaveBeenCalled();
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('does not fail the build when observability file output fails', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-build-observability-'),
+    );
+    try {
+      const blocker = path.join(directory, 'blocker');
+      fs.writeFileSync(blocker, 'not a directory', 'utf8');
+      const { processAssetsCallbacks, warn } = createBuildCompilerFixture(
+        directory,
+        {
+          outputFile: path.join(blocker, 'build-info.json'),
+        },
+      );
+
+      await expect(processAssetsCallbacks[0]()).resolves.toBeUndefined();
+
+      expect(warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to write build observability'),
+      );
+      const report = JSON.parse(
+        fs.readFileSync(
+          path.join(directory, '.mf/observability/build-report.json'),
+          'utf8',
+        ),
+      );
+      expect(report).toMatchObject({
+        source: 'build',
+        status: 'error',
+        failedPhase: 'observability-output',
+        summary: {
+          outcome: 'failed',
+          error: {
+            failedPhase: 'observability-output',
+            ownerHint: 'build',
+            retryable: false,
+          },
+        },
+        diagnosis: {
+          status: 'error',
+          outcome: 'failed',
+          ownerHint: 'build',
+          failedPhase: 'observability-output',
+          actions: [
+            expect.objectContaining({
+              id: 'check-observability-output',
+              ownerHint: 'build',
+            }),
+          ],
+          facts: expect.objectContaining({
+            failedPhase: 'observability-output',
+            ownerHint: 'build',
+            mfName: 'runtime_host',
+          }),
+        },
+      });
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('writes a build report for compilation errors', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-build-observability-'),
+    );
+    try {
+      const error = new Error(
+        '[ Federation Build ] remoteEntry failed #BUILD-001 token=demo-secret http://localhost:3001/remoteEntry.js?token=demo-secret#hash',
+      );
+      error.stack = [
+        'Error: token=demo-secret remoteEntry failed',
+        '    at build (/Users/bytedance/private/webpack.config.js:1:1)',
+        '    at remote (http://localhost:3001/remoteEntry.js?token=demo-secret#hash:1:1)',
+      ].join('\n');
+
+      const { processAssetsCallbacks, warn } = createBuildCompilerFixture(
+        directory,
+        {
+          errors: [error],
+        },
+      );
+
+      await processAssetsCallbacks[0]();
+
+      const report = JSON.parse(
+        fs.readFileSync(
+          path.join(directory, '.mf/observability/build-report.json'),
+          'utf8',
+        ),
+      );
+      expect(report).toMatchObject({
+        schemaVersion: 1,
+        source: 'build',
+        status: 'error',
+        failedPhase: 'compilation',
+        build: {
+          moduleFederation: {
+            name: 'runtime_host',
+          },
+        },
+        summary: {
+          outcome: 'failed',
+          error: {
+            errorCode: 'BUILD-001',
+            failedPhase: 'compilation',
+            ownerHint: 'remote',
+            retryable: false,
+          },
+        },
+        diagnosis: {
+          title: 'Module Federation build failed',
+          status: 'error',
+          outcome: 'failed',
+          ownerHint: 'remote',
+          failedPhase: 'compilation',
+          errorCode: 'BUILD-001',
+          facts: expect.objectContaining({
+            failedPhase: 'compilation',
+            remoteCount: 1,
+            exposeCount: 1,
+            sharedCount: 1,
+            remotes: 'remote1',
+            exposes: './Button',
+            shared: 'react',
+          }),
+          actions: [
+            expect.objectContaining({
+              id: 'inspect-build-errors',
+              ownerHint: 'remote',
+            }),
+            expect.objectContaining({
+              id: 'check-remote-config',
+              ownerHint: 'remote',
+            }),
+          ],
+        },
+      });
+      expect(JSON.stringify(report)).toContain('demo-secret');
+      expect(JSON.stringify(report)).toContain('token=');
+      expect(JSON.stringify(report)).toContain('#hash');
+      expect(JSON.stringify(report)).toContain('/Users/bytedance');
+      expect(warn).not.toHaveBeenCalled();
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('removes stale build reports after a clean build', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-build-observability-'),
+    );
+    try {
+      const reportFile = path.join(
+        directory,
+        '.mf/observability/build-report.json',
+      );
+      fs.mkdirSync(path.dirname(reportFile), { recursive: true });
+      fs.writeFileSync(reportFile, '{"status":"error"}', 'utf8');
+
+      const { processAssetsCallbacks } = createBuildCompilerFixture(directory);
+
+      await processAssetsCallbacks[0]();
+
+      expect(fs.existsSync(reportFile)).toBe(false);
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+});
+
+const emitRemoteLoaded = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.onLoad?.({
+    id: 'remote/Button',
+    pkgNameOrAlias: 'remote',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    options: {},
+    origin: enabledOrigin,
+    exposeModule: {},
+    exposeModuleFactory: undefined,
+    moduleInstance: {},
+    ...overrides,
+  } as any);
+
+const emitRemoteStart = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.beforeRequest?.({
+    id: 'remote/Button',
+    options: {},
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteComplete = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.afterLoadRemote?.({
+    id: 'remote/Button',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteMatch = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.afterMatchRemote?.({
+    id: 'remote/Button',
+    expose: './Button',
+    remoteInfo: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteInit = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.afterInitRemote?.({
+    id: 'remote/Button',
+    remoteInfo: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitExposePhase = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  hookName: 'beforeGetExpose' | 'afterGetExpose',
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin[hookName]?.({
+    id: 'remote/Button',
+    expose: './Button',
+    moduleInfo: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitFactoryPhase = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  hookName: 'beforeExecuteFactory' | 'afterExecuteFactory',
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin[hookName]?.({
+    id: 'remote/Button',
+    expose: './Button',
+    moduleInfo: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    loadFactory: true,
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitRemoteError = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.errorLoadRemote?.({
+    id: 'remote/Button',
+    error: new Error('remote load failed'),
+    from: 'runtime',
+    lifecycle: 'onLoad',
+    expose: './Button',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const emitManifestError = (
+  observability: ReturnType<typeof ObservabilityPlugin>,
+  overrides: Record<string, unknown> = {},
+) =>
+  observability.plugin.errorLoadRemote?.({
+    id: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    error: new Error('token=demo-secret manifest failed'),
+    from: 'runtime',
+    lifecycle: 'afterResolve',
+    remote: {
+      name: 'remote',
+      entry: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    },
+    origin: enabledOrigin,
+    ...overrides,
+  } as any);
+
+const waitForFile = async (filePath: string) => {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < 1000) {
+    if (fs.existsSync(filePath)) {
+      return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+
+  throw new Error(`Timed out waiting for ${filePath}`);
+};
+
+const createBuildCompilerFixture = (
+  tempDir: string,
+  options: {
+    manifest?: Record<string, unknown>;
+    stats?: Record<string, unknown>;
+    moduleFederation?: Record<string, unknown>;
+    outputFile?: string;
+    errorReport?:
+      | false
+      | {
+          outputFile?: string;
+        };
+    errors?: unknown[];
+  } = {},
+) => {
+  const processAssetsCallbacks: Array<() => Promise<void>> = [];
+  const emittedAssets: Record<string, { source(): string }> = {};
+  const warn = vi.fn();
+  const compilation = {
+    constructor: {
+      PROCESS_ASSETS_STAGE_REPORT: 5000,
+    },
+    getAsset: (assetName: string) => {
+      if (assetName === 'mf-manifest.json' && options.manifest) {
+        return {
+          source: {
+            source: () => JSON.stringify(options.manifest),
+          },
+        };
+      }
+      if (assetName === 'mf-stats.json' && options.stats) {
+        return {
+          source: {
+            source: () => JSON.stringify(options.stats),
+          },
+        };
+      }
+      return undefined;
+    },
+    emitAsset: (name: string, source: { source(): string }) => {
+      emittedAssets[name] = source;
+    },
+    errors: options.errors || [],
+    hooks: {
+      processAssets: {
+        tapPromise: (
+          _options: { name: string; stage?: number },
+          callback: () => Promise<void>,
+        ) => {
+          processAssetsCallbacks.push(callback);
+        },
+      },
+    },
+  };
+  const moduleFederation = options.moduleFederation || {
+    name: 'runtime_host',
+    remotes: {
+      remote1:
+        'runtime_remote1@http://localhost:3006/mf-manifest.json?token=secret#hash',
+    },
+    exposes: {
+      './Button': '/Users/bytedance/project/src/Button.tsx',
+    },
+    shared: {
+      react: {
+        singleton: true,
+        requiredVersion: '^18.2.0',
+      },
+    },
+  };
+  const compiler = {
+    context: tempDir,
+    options: {
+      context: tempDir,
+      mode: 'development',
+      target: 'web',
+      output: {
+        publicPath: 'auto',
+      },
+      plugins: [
+        {
+          name: 'ModuleFederationPlugin',
+          _options: moduleFederation,
+        },
+      ],
+    },
+    webpack: {
+      version: '5.99.0',
+      sources: {
+        RawSource: class RawSource {
+          private readonly value: string;
+
+          constructor(value: string) {
+            this.value = value;
+          }
+
+          source() {
+            return this.value;
+          }
+        },
+      },
+      Compilation: {
+        PROCESS_ASSETS_STAGE_REPORT: 5000,
+      },
+    },
+    hooks: {
+      thisCompilation: {
+        tap: (
+          _name: string,
+          callback: (receivedCompilation: typeof compilation) => void,
+        ) => {
+          callback(compilation);
+        },
+      },
+    },
+    getInfrastructureLogger: () => ({
+      warn,
+    }),
+  };
+
+  new ObservabilityBuildPlugin({
+    outputFile: options.outputFile,
+    errorReport: options.errorReport,
+  }).apply(compiler);
+
+  return {
+    processAssetsCallbacks,
+    warn,
+  };
+};
+
+describe('ObservabilityPlugin', () => {
+  it('does not record events when the plugin is disabled', () => {
+    const observability = ObservabilityPlugin({
+      enabled: false,
+      level: 'verbose',
+    });
+
+    emitRemoteLoaded(observability);
+
+    expect(observability.getEvents()).toHaveLength(0);
+    expect(observability.getLatestReport()).toBeUndefined();
+  });
+
+  it('records a successful loadRemote report when enabled', () => {
+    const observability = ObservabilityPlugin({ level: 'verbose' });
+
+    emitRemoteStart(observability);
+    emitRemoteLoaded(observability);
+
+    const report = observability.getLatestReport();
+    expect(report?.status).toBe('success');
+    expect(report?.requestId).toBe('remote/Button');
+    expect(report?.remote?.name).toBe('remote');
+    expect(report?.summary).toMatchObject({
+      runtimeLoaded: true,
+      loadCompleted: false,
+      componentLoaded: false,
+      outcome: 'runtime-loaded',
+      lastPhase: 'loadRemote',
+    });
+    expect(report?.summary.phases.loadRemote).toMatchObject({
+      status: 'success',
+      duration: expect.any(Number),
+    });
+    expect(report?.diagnosis).toMatchObject({
+      title: 'Remote loaded successfully',
+      status: 'success',
+      outcome: 'runtime-loaded',
+      ownerHint: 'remote',
+      facts: expect.objectContaining({
+        requestId: 'remote/Button',
+        remoteName: 'remote',
+        runtimeLoaded: true,
+        componentLoaded: false,
+      }),
+      completedPhases: ['loadRemote'],
+      actions: [],
+    });
+    expect(report?.events).toHaveLength(2);
+  });
+
+  it('omits undefined fields from public snapshots', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+    });
+
+    emitRemoteStart(observability);
+    emitRemoteLoaded(observability);
+
+    const report = observability.getLatestReport();
+    const events = observability.getEvents();
+
+    expect(report).toBeDefined();
+    expect(hasUndefinedField(report)).toBe(false);
+    expect(hasUndefinedField(events)).toBe(false);
+  });
+
+  it('records a complete loadRemote event as the final runtime outcome', () => {
+    const observability = ObservabilityPlugin({ level: 'verbose' });
+
+    emitRemoteStart(observability);
+    emitRemoteLoaded(observability);
+    emitRemoteComplete(observability);
+
+    const report = observability.getLatestReport();
+    expect(report?.status).toBe('success');
+    expect(report?.summary).toMatchObject({
+      runtimeLoaded: true,
+      loadCompleted: true,
+      componentLoaded: false,
+      outcome: 'runtime-loaded',
+      lastPhase: 'loadRemote',
+    });
+  });
+
+  it('records manifest and remoteEntry lifecycle hooks without observability events', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    observability.plugin.beforeLoadRemoteSnapshot?.({
+      moduleInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterResolve?.({
+      id: 'remote/Button',
+      expose: './Button',
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.loadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterLoadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+
+    expect(observability.getEvents()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          phase: 'manifest',
+          status: 'start',
+          lifecycle: 'beforeLoadRemoteSnapshot',
+        }),
+        expect.objectContaining({
+          phase: 'manifest',
+          status: 'success',
+          lifecycle: 'afterResolve',
+        }),
+        expect.objectContaining({
+          phase: 'remoteEntry',
+          status: 'start',
+          lifecycle: 'loadEntry',
+        }),
+        expect.objectContaining({
+          phase: 'remoteEntry',
+          status: 'success',
+          lifecycle: 'afterLoadEntry',
+        }),
+      ]),
+    );
+  });
+
+  it('does not attach global moduleInfo for unrelated runtime failures', () => {
+    const originalFederation = (globalThis as any).__FEDERATION__;
+
+    try {
+      (globalThis as any).__FEDERATION__ = {
+        moduleInfo: {
+          'remote:http://localhost:3001/mf-manifest.json': {
+            publicPath: 'https://cdn.example.com/remote/',
+            modules: [{ moduleName: 'Button' }],
+            shared: [{ sharedName: 'react' }],
+          },
+        },
+      };
+
+      const observability = ObservabilityPlugin({
+        level: 'verbose',
+        console: false,
+      });
+
+      emitRemoteStart(observability);
+      emitManifestError(observability, {
+        error: new Error(
+          '[ Federation Runtime ]: Failed to get manifest. #RUNTIME-003',
+        ),
+      });
+
+      expect(observability.getLatestReport()?.moduleInfo).toBeUndefined();
+    } finally {
+      if (originalFederation) {
+        (globalThis as any).__FEDERATION__ = originalFederation;
+      } else {
+        delete (globalThis as any).__FEDERATION__;
+      }
+    }
+  });
+
+  it('attaches clipped global moduleInfo only for snapshot dependent failures', () => {
+    const originalFederation = (globalThis as any).__FEDERATION__;
+
+    try {
+      (globalThis as any).__FEDERATION__ = {
+        moduleInfo: {
+          'remote:http://localhost:3001/mf-manifest.json?token=secret#hash': {
+            publicPath: 'https://cdn.example.com/remote/?v=20260508#hash',
+            getPublicPath:
+              'return "https://cdn.example.com/remote/?v=20260508#hash";',
+            remoteEntry:
+              'https://cdn.example.com/remote/remoteEntry.js?v=20260508#hash',
+            globalName: 'remote_global',
+            modules: [{ moduleName: 'Button', assets: { js: ['large.js'] } }],
+            shared: [{ sharedName: 'react', assets: { js: ['large.js'] } }],
+          },
+          unrelated: {
+            publicPath: 'https://cdn.example.com/unrelated/',
+            modules: [{ moduleName: 'Unused' }],
+            shared: [{ sharedName: 'react' }],
+          },
+        },
+      };
+
+      const observability = ObservabilityPlugin({
+        level: 'verbose',
+        console: false,
+      });
+
+      emitRemoteStart(observability);
+      emitRemoteError(observability, {
+        error: new Error(
+          '[ Federation Runtime ]: Failed to get remote snapshot. #RUNTIME-007',
+        ),
+      });
+
+      const report = observability.getLatestReport();
+
+      expect(report?.ownerHint).toBe('host');
+      expect(report?.diagnosis?.title).toBe(
+        'Deployment moduleInfo did not match the requested remote',
+      );
+      expect(report?.moduleInfo).toMatchObject({
+        reason: 'remote-snapshot',
+        clipped: true,
+        totalCount: 2,
+        matchedCount: 1,
+        entries: [
+          {
+            name: 'remote:http://localhost:3001/mf-manifest.json?token=secret#hash',
+            publicPath: 'https://cdn.example.com/remote/?v=20260508#hash',
+            getPublicPath:
+              'return "https://cdn.example.com/remote/?v=20260508#hash";',
+            remoteEntry:
+              'https://cdn.example.com/remote/remoteEntry.js?v=20260508#hash',
+            globalName: 'remote_global',
+          },
+        ],
+      });
+      expect(report?.diagnosis?.facts).toMatchObject({
+        moduleInfoReason: 'remote-snapshot',
+        moduleInfoTotalCount: 2,
+        moduleInfoMatchedCount: 1,
+        moduleInfoNames:
+          'remote:http://localhost:3001/mf-manifest.json?token=secret#hash',
+      });
+      expect(report?.diagnosis?.actions).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 'check-module-info',
+            ownerHint: 'host',
+          }),
+        ]),
+      );
+      expect(JSON.stringify(report?.moduleInfo)).not.toContain('modules');
+      expect(JSON.stringify(report?.moduleInfo)).not.toContain('shared');
+      expect(JSON.stringify(report?.moduleInfo)).toContain('secret');
+      expect(JSON.stringify(report?.moduleInfo)).toContain('token=');
+    } finally {
+      if (originalFederation) {
+        (globalThis as any).__FEDERATION__ = originalFederation;
+      } else {
+        delete (globalThis as any).__FEDERATION__;
+      }
+    }
+  });
+
+  it('treats a recovered complete event as a recovered runtime outcome', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    emitRemoteStart(observability);
+    expect(emitRemoteError(observability)).toBeUndefined();
+    emitRemoteComplete(observability, {
+      error: new Error('remote load failed'),
+      recovered: true,
+    });
+
+    const report = observability.getLatestReport();
+    expect(report?.status).toBe('success');
+    expect(report?.failedPhase).toBe('loadRemote');
+    expect(report?.summary).toMatchObject({
+      recovered: true,
+      runtimeLoaded: true,
+      loadCompleted: true,
+      outcome: 'recovered',
+      error: {
+        failedPhase: 'loadRemote',
+      },
+    });
+    expect(report?.summary.flags).toMatchObject({
+      fallback: true,
+      recovered: true,
+    });
+  });
+
+  it('keeps summary level compact while preserving phase durations', () => {
+    const observability = ObservabilityPlugin({
+      level: 'summary',
+      console: false,
+    });
+
+    emitRemoteStart(observability);
+    emitExposePhase(observability, 'beforeGetExpose');
+    emitExposePhase(observability, 'afterGetExpose');
+
+    const report = observability.getLatestReport();
+
+    expect(report?.events.map((event) => event.status)).toEqual(['success']);
+    expect(report?.events[0]).toMatchObject({
+      phase: 'expose',
+      status: 'success',
+      duration: expect.any(Number),
+    });
+    expect(report?.summary.phases.expose).toMatchObject({
+      status: 'success',
+      duration: expect.any(Number),
+    });
+  });
+
+  it('preserves urls and error message fields for observability', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    emitManifestError(observability, {
+      error: new Error(
+        'authorization=demo-secret failed at http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+      ),
+    });
+
+    const output = JSON.stringify(observability.getLatestReport());
+    expect(output).toContain(
+      'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    );
+    expect(output).toContain('demo-secret');
+    expect(output).toContain('token=');
+    expect(output).toContain('#hash');
+  });
+
+  it('keeps the first specific failed phase when loadRemote closes the trace', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    emitRemoteStart(observability, {
+      remote: {
+        name: 'remote',
+      },
+    });
+    emitManifestError(observability, {
+      id: 'remote/Button',
+      remote: {
+        name: 'remote',
+      },
+      error: new Error('manifest failed'),
+    });
+    expect(emitRemoteError(observability)).toBeUndefined();
+    emitRemoteComplete(observability, {
+      remote: {
+        name: 'remote',
+      },
+      error: new Error('outer loadRemote failed'),
+    });
+
+    const report = observability.getLatestReport();
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('manifest');
+    expect(report?.summary).toMatchObject({
+      loadCompleted: true,
+      runtimeLoaded: false,
+      componentLoaded: false,
+      outcome: 'failed',
+    });
+  });
+
+  it('records runtime error code and manifest context for RUNTIME-003', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const error = new Error(
+      [
+        '[ Federation Runtime ]: Failed to get manifest. #RUNTIME-003',
+        'args: {"manifestUrl":"http://localhost:3001/mf-manifest.json?token=demo-secret#hash","moduleName":"remote"}',
+        'Original Error Message:',
+        ' NetworkError: token=demo-secret failed',
+      ].join('\n'),
+    );
+
+    emitRemoteStart(observability);
+    emitManifestError(observability, { error });
+
+    const report = observability.getLatestReport();
+    const event = report?.events.find((item) => item.phase === 'manifest');
+    const output = JSON.stringify(report);
+
+    expect(event).toMatchObject({
+      status: 'error',
+      errorCode: 'RUNTIME-003',
+      ownerHint: 'host',
+      retryable: true,
+      sanitizedUrl:
+        'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+      errorContext: expect.objectContaining({
+        lifecycle: 'afterResolve',
+        remoteName: 'remote',
+        url: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+      }),
+    });
+    expect(report).toMatchObject({
+      status: 'error',
+      failedPhase: 'manifest',
+      errorCode: 'RUNTIME-003',
+      ownerHint: 'host',
+      retryable: true,
+      summary: {
+        error: expect.objectContaining({
+          errorCode: 'RUNTIME-003',
+          failedPhase: 'manifest',
+          lifecycle: 'afterResolve',
+          ownerHint: 'host',
+          retryable: true,
+        }),
+      },
+      diagnosis: {
+        title: 'Manifest could not be loaded',
+        status: 'error',
+        outcome: 'failed',
+        ownerHint: 'host',
+        failedPhase: 'manifest',
+        errorCode: 'RUNTIME-003',
+        docLink: expect.stringContaining('/guide/troubleshooting/runtime'),
+        facts: expect.objectContaining({
+          errorCode: 'RUNTIME-003',
+          failedPhase: 'manifest',
+          remoteName: 'remote',
+          url: 'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+          retryable: true,
+        }),
+        actions: [
+          expect.objectContaining({
+            id: 'check-manifest-url',
+            ownerHint: 'host',
+          }),
+          expect.objectContaining({
+            id: 'check-network',
+            ownerHint: 'network',
+          }),
+        ],
+      },
+    });
+    expect(output).toContain('demo-secret');
+    expect(output).toContain('token=');
+    expect(output).toContain('#hash');
+  });
+
+  it('records host remote summary for RUNTIME-004 match failures', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    emitRemoteStart(observability, {
+      id: 'missing/Button',
+    });
+    observability.plugin.afterMatchRemote?.({
+      id: 'missing/Button',
+      options: {
+        name: 'host',
+        remotes: [
+          {
+            name: 'remote',
+            alias: 'known-remote',
+            entry: 'http://localhost:3001/mf-manifest.json',
+          },
+        ],
+      },
+      origin: enabledOrigin,
+      error: new Error(
+        '[ Federation Runtime ]: Failed to locate remote. #RUNTIME-004',
+      ),
+    } as any);
+
+    const report = observability.getLatestReport();
+
+    expect(report).toMatchObject({
+      status: 'error',
+      failedPhase: 'matchRemote',
+      requestId: 'missing/Button',
+      errorCode: 'RUNTIME-004',
+      ownerHint: 'host',
+      retryable: false,
+      errorContext: expect.objectContaining({
+        requestId: 'missing/Button',
+        hostRemotes: 'known-remote',
+      }),
+      diagnosis: {
+        title: 'Remote was not found in host remotes',
+        ownerHint: 'host',
+        errorCode: 'RUNTIME-004',
+        facts: expect.objectContaining({
+          requestId: 'missing/Button',
+          hostRemotes: 'known-remote',
+        }),
+        actions: [
+          expect.objectContaining({
+            id: 'check-host-remotes',
+            ownerHint: 'host',
+          }),
+        ],
+      },
+    });
+  });
+
+  it('records remoteEntry global context for RUNTIME-001', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    observability.plugin.loadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js?token=demo-secret',
+        entryGlobalName: 'remote_global',
+        type: 'global',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterLoadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js?token=demo-secret',
+        entryGlobalName: 'remote_global',
+        type: 'global',
+      },
+      origin: enabledOrigin,
+      error: new Error(
+        '[ Federation Runtime ]: Failed to get remoteEntry exports. #RUNTIME-001',
+      ),
+    } as any);
+
+    const report = observability.getLatestReport();
+    const output = JSON.stringify(report);
+
+    expect(report).toMatchObject({
+      status: 'error',
+      failedPhase: 'remoteEntry',
+      errorCode: 'RUNTIME-001',
+      ownerHint: 'remote',
+      retryable: false,
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js?token=demo-secret',
+        entryGlobalName: 'remote_global',
+        type: 'global',
+      },
+      errorContext: expect.objectContaining({
+        remoteName: 'remote',
+        entryGlobalName: 'remote_global',
+        url: 'http://localhost:3001/remoteEntry.js?token=demo-secret',
+      }),
+      diagnosis: {
+        title: 'Remote entry global was not registered',
+        ownerHint: 'remote',
+        errorCode: 'RUNTIME-001',
+        facts: expect.objectContaining({
+          remoteName: 'remote',
+          remoteEntry: 'http://localhost:3001/remoteEntry.js?token=demo-secret',
+          entryGlobalName: 'remote_global',
+        }),
+        actions: [
+          expect.objectContaining({
+            id: 'check-remote-global',
+            ownerHint: 'remote',
+          }),
+          expect.objectContaining({
+            id: 'check-remote-entry',
+            ownerHint: 'remote',
+          }),
+        ],
+      },
+    });
+    expect(output).toContain('demo-secret');
+    expect(output).toContain('token=');
+  });
+
+  it('classifies RUNTIME-008 remoteEntry resource failures', () => {
+    const createReportForError = (error: Error) => {
+      const observability = ObservabilityPlugin({
+        level: 'verbose',
+        console: false,
+      });
+
+      observability.plugin.afterLoadEntry?.({
+        remoteInfo: {
+          name: 'remote',
+          entry: 'http://localhost:3001/remoteEntry.js',
+        },
+        origin: enabledOrigin,
+        error,
+      } as any);
+
+      return observability.getLatestReport();
+    };
+
+    const networkReport = createReportForError(
+      new Error(
+        '[ Federation Runtime ]: Failed to load script resources. #RUNTIME-008\nOriginal Error Message:\n ScriptNetworkError: 404',
+      ),
+    );
+    const timeoutReport = createReportForError(
+      new Error(
+        '[ Federation Runtime ]: Failed to load script resources. #RUNTIME-008\nOriginal Error Message:\n timeout loading remoteEntry',
+      ),
+    );
+    const executionReport = createReportForError(
+      new Error(
+        '[ Federation Runtime ]: Failed to load script resources. #RUNTIME-008\nOriginal Error Message:\n ScriptExecutionError: boom',
+      ),
+    );
+
+    expect(networkReport).toMatchObject({
+      errorCode: 'RUNTIME-008',
+      ownerHint: 'network',
+      retryable: true,
+      errorContext: expect.objectContaining({
+        resourceErrorType: 'network',
+      }),
+      diagnosis: {
+        title: 'Remote entry failed because of a network error',
+        ownerHint: 'network',
+        facts: expect.objectContaining({
+          resourceErrorType: 'network',
+        }),
+        actions: [
+          expect.objectContaining({
+            id: 'check-network',
+            ownerHint: 'network',
+          }),
+          expect.objectContaining({
+            id: 'check-remote-entry',
+            ownerHint: 'network',
+          }),
+        ],
+      },
+    });
+    expect(timeoutReport).toMatchObject({
+      errorCode: 'RUNTIME-008',
+      ownerHint: 'network',
+      retryable: true,
+      errorContext: expect.objectContaining({
+        resourceErrorType: 'timeout',
+      }),
+      diagnosis: {
+        title: 'Remote entry request timed out',
+        facts: expect.objectContaining({
+          resourceErrorType: 'timeout',
+        }),
+      },
+    });
+    expect(executionReport).toMatchObject({
+      errorCode: 'RUNTIME-008',
+      ownerHint: 'remote',
+      retryable: false,
+      errorContext: expect.objectContaining({
+        resourceErrorType: 'script-execution',
+      }),
+      diagnosis: {
+        title: 'Remote entry loaded but failed during execution',
+        ownerHint: 'remote',
+        facts: expect.objectContaining({
+          resourceErrorType: 'script-execution',
+        }),
+        actions: [
+          expect.objectContaining({
+            id: 'check-remote-entry',
+            ownerHint: 'remote',
+          }),
+        ],
+      },
+    });
+  });
+
+  it('records detailed remote phases and keeps expose as the failed phase', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const exposeError = new Error('remote expose missing');
+
+    emitRemoteStart(observability);
+    emitRemoteMatch(observability);
+    observability.plugin.beforeInitRemote?.({
+      id: 'remote/Button',
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    emitRemoteInit(observability);
+    emitExposePhase(observability, 'beforeGetExpose');
+    emitExposePhase(observability, 'afterGetExpose', {
+      error: exposeError,
+    });
+    expect(
+      emitRemoteError(observability, { error: exposeError }),
+    ).toBeUndefined();
+    emitRemoteComplete(observability, {
+      error: exposeError,
+    });
+
+    const report = observability.getLatestReport();
+    const phases = report?.events.map((event) => event.phase);
+    const exposeEvent = report?.events.find(
+      (event) => event.lifecycle === 'afterGetExpose',
+    );
+
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('expose');
+    expect(phases).toEqual(
+      expect.arrayContaining([
+        'matchRemote',
+        'remoteEntryInit',
+        'expose',
+        'loadRemote',
+      ]),
+    );
+    expect(exposeEvent).toMatchObject({
+      status: 'error',
+      requestId: 'remote/Button',
+      expose: './Button',
+      errorMessage: 'remote expose missing',
+      duration: expect.any(Number),
+    });
+  });
+
+  it('records factory execution success with a phase duration', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    emitRemoteStart(observability);
+    emitFactoryPhase(observability, 'beforeExecuteFactory');
+    emitFactoryPhase(observability, 'afterExecuteFactory');
+
+    const report = observability.getLatestReport();
+    const factoryEvent = report?.events.find(
+      (event) => event.lifecycle === 'afterExecuteFactory',
+    );
+
+    expect(report?.status).toBe('success');
+    expect(factoryEvent).toMatchObject({
+      phase: 'moduleFactory',
+      status: 'success',
+      duration: expect.any(Number),
+    });
+    expect(report?.summary.phases.moduleFactory).toMatchObject({
+      status: 'success',
+      duration: expect.any(Number),
+    });
+  });
+
+  it('reads recent reports, filters by observability fields, and exports copies', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(1000);
+      emitRemoteLoaded(observability);
+      const buttonTraceId = observability.getLatestReport()?.traceId || '';
+
+      vi.setSystemTime(2000);
+      emitRemoteLoaded(observability, {
+        id: 'catalog/Card',
+        expose: './Card',
+        remote: {
+          name: 'catalog',
+          alias: 'catalogRemote',
+          entry: 'http://localhost:3002/mf-manifest.json?env=dev',
+        },
+      });
+      const cardTraceId = observability.getLatestReport()?.traceId || '';
+
+      vi.setSystemTime(3000);
+      observability.plugin.errorLoadShare?.({
+        pkgName: 'react',
+        shareInfo: createShared({
+          shareConfig: {
+            requiredVersion: '^99.0.0',
+            singleton: true,
+            strictVersion: true,
+            eager: false,
+          },
+        }),
+        shared: {
+          react: [
+            createShared({
+              version: '18.3.1',
+            }),
+          ],
+        },
+        lifecycle: 'loadShare',
+        origin: enabledOrigin,
+        error: new Error('react version mismatch'),
+      } as any);
+
+      expect(observability.getReports()).toHaveLength(3);
+      expect(
+        observability.getReports({ limit: 2 }).map((report) => report.traceId),
+      ).toEqual([observability.getLatestReport()?.traceId, cardTraceId]);
+
+      expect(observability.findReports({ remote: 'catalog' })).toHaveLength(1);
+      expect(
+        observability.findReports({ remote: 'catalogRemote' })[0],
+      ).toMatchObject({
+        traceId: cardTraceId,
+        expose: './Card',
+      });
+      expect(observability.findReports({ expose: 'Card' })[0]?.traceId).toBe(
+        cardTraceId,
+      );
+      expect(observability.findReports({ shared: 'react' })[0]).toMatchObject({
+        status: 'error',
+        shared: {
+          name: 'react',
+        },
+      });
+      expect(observability.findReports({ status: 'error' })).toHaveLength(1);
+      expect(observability.findReports({ outcome: 'failed' })).toHaveLength(1);
+
+      const exported = observability.exportReport(buttonTraceId);
+      expect(exported?.traceId).toBe(buttonTraceId);
+      exported?.events.pop();
+      expect(observability.getReport(buttonTraceId)?.events).toHaveLength(1);
+      expect(observability.exportReport()?.traceId).toBe(
+        observability.getLatestReport()?.traceId,
+      );
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('summarizes successful manifest, remoteEntry, cache, and retry recovery facts', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    observability.plugin.beforeLoadRemoteSnapshot?.({
+      moduleInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterResolve?.({
+      id: 'remote/Button',
+      expose: './Button',
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.loadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterLoadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+      recovered: true,
+    } as any);
+
+    const report = observability.getLatestReport();
+
+    expect(report?.summary.phases.manifest).toMatchObject({
+      status: 'success',
+      duration: expect.any(Number),
+    });
+    expect(report?.summary.phases.remoteEntry).toMatchObject({
+      status: 'success',
+      duration: expect.any(Number),
+      recovered: true,
+    });
+    expect(report?.summary.flags).toMatchObject({
+      retried: true,
+      recovered: true,
+    });
+
+    observability.plugin.beforeLoadRemoteSnapshot?.({
+      moduleInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterResolve?.({
+      id: 'remote/Button',
+      expose: './Button',
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.loadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+    observability.plugin.afterLoadEntry?.({
+      remoteInfo: {
+        name: 'remote',
+        entry: 'http://localhost:3001/remoteEntry.js',
+      },
+      origin: enabledOrigin,
+    } as any);
+
+    const cachedReport = observability.getLatestReport();
+
+    expect(cachedReport?.summary.flags.cached).toBe(true);
+    expect(cachedReport?.summary.phases.manifest.cached).toBe(true);
+    expect(cachedReport?.summary.phases.remoteEntry.cached).toBe(true);
+  });
+
+  it('records shared dependency observability', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    observability.plugin.errorLoadShare?.({
+      pkgName: 'react',
+      shareInfo: {
+        version: '18.3.1',
+        from: 'remote',
+        scope: ['default'],
+        strategy: 'loaded-first',
+        shareConfig: {
+          requiredVersion: '^99.0.0',
+          singleton: true,
+          strictVersion: true,
+          eager: false,
+        },
+      },
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': createShared({
+              from: 'host?token=demo-secret',
+            }),
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+      error: new Error('token=demo-secret shared failed'),
+      recovered: true,
+    } as any);
+
+    const report = observability.getLatestReport();
+    const output = JSON.stringify(report);
+
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('shared');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      shareScope: ['default'],
+      requiredVersion: '^99.0.0',
+      availableVersions: ['18.3.1'],
+      reason: 'version-mismatch',
+    });
+    expect(output).toContain('demo-secret');
+    expect(output).toContain('token=');
+  });
+
+  it('derives shared success details from loadShare hooks', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const shared = createShared();
+
+    observability.plugin.beforeLoadShare?.({
+      pkgName: 'react',
+      shareInfo: shared,
+      shared: {},
+      origin: enabledOrigin,
+    });
+    observability.plugin.afterLoadShare?.({
+      pkgName: 'react',
+      shareInfo: shared,
+      selectedShared: shared,
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': shared,
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+    });
+
+    const report = observability.getLatestReport();
+
+    expect(report?.status).toBe('success');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      selectedVersion: '18.3.1',
+      provider: 'host',
+      availableVersions: ['18.3.1'],
+    });
+    expect(report?.summary.shared).toMatchObject({
+      name: 'react',
+      selectedVersion: '18.3.1',
+      provider: 'host',
+      shareScope: ['default'],
+    });
+  });
+
+  it('derives shared version mismatch details from errorLoadShare', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const requestedShared = createShared({
+      version: '99.0.0',
+      from: 'remote',
+      shareConfig: {
+        requiredVersion: '^99.0.0',
+        singleton: false,
+        strictVersion: true,
+        eager: false,
+      },
+    });
+    const hostShared = createShared();
+
+    observability.plugin.beforeLoadShare?.({
+      pkgName: 'react',
+      shareInfo: requestedShared,
+      shared: {},
+      origin: enabledOrigin,
+    });
+    observability.plugin.errorLoadShare?.({
+      pkgName: 'react',
+      shareInfo: requestedShared,
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '18.3.1': hostShared,
+          },
+        },
+      },
+      lifecycle: 'loadShare',
+      origin: enabledOrigin,
+      recovered: true,
+    });
+
+    const report = observability.getLatestReport();
+
+    expect(report?.status).toBe('error');
+    expect(report?.failedPhase).toBe('shared');
+    expect(report?.shared).toMatchObject({
+      name: 'react',
+      requiredVersion: '^99.0.0',
+      availableVersions: ['18.3.1'],
+      reason: 'version-mismatch',
+    });
+  });
+
+  it('derives eager boundary details from loadShareSync failures', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const asyncShared = createShared({
+      version: '1.0.0',
+      from: 'remote',
+      shareConfig: {
+        requiredVersion: '^1.0.0',
+        singleton: false,
+        strictVersion: false,
+        eager: false,
+      },
+      get: () => Promise.resolve(() => ({ value: 'async' })),
+    });
+
+    observability.plugin.errorLoadShare?.({
+      pkgName: 'observability-async-shared',
+      shareInfo: asyncShared,
+      shared: {},
+      shareScopeMap: {},
+      lifecycle: 'loadShareSync',
+      origin: enabledOrigin,
+      error: new Error('[ Federation Runtime ]: RUNTIME-005 shared failed'),
+    });
+
+    const report = observability.getLatestReport();
+
+    expect(report?.status).toBe('error');
+    expect(report?.shared).toMatchObject({
+      name: 'observability-async-shared',
+      requiredVersion: '^1.0.0',
+      reason: 'sync-async-boundary',
+    });
+    expect(report?.diagnosis).toMatchObject({
+      title: 'Shared dependency could not be resolved',
+      ownerHint: 'shared',
+      errorCode: 'RUNTIME-005',
+      facts: expect.objectContaining({
+        shareName: 'observability-async-shared',
+        requiredVersion: '^1.0.0',
+        eager: false,
+        sharedReason: 'sync-async-boundary',
+      }),
+      actions: [
+        expect.objectContaining({
+          id: 'check-shared-provider',
+          ownerHint: 'shared',
+        }),
+        expect.objectContaining({
+          id: 'check-shared-version',
+          ownerHint: 'shared',
+        }),
+        expect.objectContaining({
+          id: 'check-eager-config',
+          ownerHint: 'shared',
+        }),
+      ],
+    });
+    expect(report?.events.at(-1)?.message).toBe('shared:sync-async-boundary');
+  });
+
+  it('reports pure runtime shared failures with available shared versions', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+
+    observability.plugin.errorLoadShare?.({
+      pkgName: 'react',
+      shareInfo: createShared({
+        version: '18.0.0',
+        shareConfig: {
+          requiredVersion: '^18.0.0',
+          singleton: true,
+          strictVersion: true,
+          eager: true,
+        },
+        get: undefined,
+      }),
+      shared: {},
+      shareScopeMap: {
+        default: {
+          react: {
+            '17.0.2': createShared({
+              version: '17.0.2',
+              from: 'host',
+            }),
+          },
+        },
+      },
+      lifecycle: 'loadShareSync',
+      origin: enabledOrigin,
+      error: new Error('[ Federation Runtime ]: RUNTIME-006 shared failed'),
+    });
+
+    const report = observability.getLatestReport();
+
+    expect(report?.diagnosis).toMatchObject({
+      title: 'Shared dependency could not be resolved',
+      ownerHint: 'shared',
+      errorCode: 'RUNTIME-006',
+      facts: expect.objectContaining({
+        shareName: 'react',
+        requiredVersion: '^18.0.0',
+        availableVersions: '17.0.2',
+        eager: true,
+        sharedReason: 'version-mismatch',
+      }),
+      actions: [
+        expect.objectContaining({
+          id: 'check-shared-provider',
+          ownerHint: 'shared',
+        }),
+        expect.objectContaining({
+          id: 'check-shared-version',
+          ownerHint: 'shared',
+        }),
+        expect.objectContaining({
+          id: 'check-eager-config',
+          ownerHint: 'shared',
+        }),
+      ],
+    });
+  });
+
+  it('prints a minimal console hint with traceId on error', () => {
+    const observability = ObservabilityPlugin({ level: 'verbose' });
+    const error = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+
+    try {
+      emitManifestError(observability, {
+        error: new Error(
+          '[ Federation Runtime ]: Failed to get manifest. #RUNTIME-003',
+        ),
+      });
+
+      emitManifestError(observability, {
+        error: new Error('token=demo-secret failed again'),
+      });
+
+      expect(error).toHaveBeenCalledTimes(1);
+      const output = String(error.mock.calls[0]?.[0]);
+      expect(output).toContain(
+        '[Module Federation] Observability report generated',
+      );
+      expect(output).toContain('traceId: mf-');
+      expect(output).toContain('phase: manifest');
+      expect(output).toContain('errorCode:');
+      expect(output).toContain('read: observability.getReport');
+      expect(output).toContain('demo-secret');
+      expect(output).toContain('token=');
+      expect(output).toContain('#hash');
+      expect(output).not.toContain('rawStack:');
+      expect(output).not.toContain('/Users/bytedance/private');
+    } finally {
+      error.mockRestore();
+    }
+  });
+
+  it('prints only traceId and errorCode for browser production console hints', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      browser: {
+        enabled: true,
+        mode: 'production',
+        scope: 'runtime_host',
+      },
+    });
+    const error = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+
+    try {
+      emitManifestError(observability, {
+        error: new Error(
+          '[ Federation Runtime ]: Failed to get manifest. #RUNTIME-003',
+        ),
+      });
+
+      expect(error).toHaveBeenCalledTimes(1);
+      const output = String(error.mock.calls[0]?.[0]);
+      expect(output).toContain(
+        '[Module Federation] Observability report generated',
+      );
+      expect(output).toContain('traceId: mf-');
+      expect(output).toContain('errorCode: RUNTIME-003');
+      expect(output).not.toContain('phase:');
+      expect(output).not.toContain('requestId:');
+      expect(output).not.toContain('read:');
+      expect(output).not.toContain('rawStack:');
+      expect(output).not.toContain('demo-secret');
+      expect(output).not.toContain('mf-manifest.json');
+    } finally {
+      error.mockRestore();
+    }
+  });
+
+  it('stores the original error stack by default', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+    });
+    const error = new Error('token=demo-secret manifest failed');
+    error.stack = [
+      'Error: token=demo-secret manifest failed',
+      '    at load (/Users/bytedance/private/app.ts:1:2)',
+      '    at fetch (http://localhost:3001/mf-manifest.json?token=demo-secret#hash:1:2)',
+      '    at extra (/tmp/secret.ts:1:1)',
+      '    at more (/private/var/tmp/more.ts:1:1)',
+      '    at ignored (/home/demo/ignored.ts:1:1)',
+    ].join('\n');
+
+    emitManifestError(observability, { error });
+
+    const report = observability.getLatestReport();
+    const stack = report?.errorStack || '';
+
+    expect(stack).toContain('Error: token=demo-secret manifest failed');
+    expect(stack).toContain('/Users/bytedance/private/app.ts');
+    expect(stack).toContain(
+      'http://localhost:3001/mf-manifest.json?token=demo-secret#hash',
+    );
+    expect(stack.split('\n')).toHaveLength(6);
+    expect(stack).toContain('demo-secret');
+    expect(stack).toContain('token=');
+    expect(stack).toContain('#hash');
+  });
+
+  it('prints the raw stack only when explicitly allowed', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      printRawStack: true,
+    });
+    const errorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+    const error = new Error('raw stack enabled');
+    error.stack = [
+      'Error: raw stack enabled',
+      '    at raw (/Users/bytedance/raw.ts:1:1)',
+    ].join('\n');
+
+    try {
+      emitManifestError(observability, { error });
+
+      const output = String(errorSpy.mock.calls[0]?.[0]);
+      expect(output).toContain('rawStack:');
+      expect(output).toContain('/Users/bytedance/raw.ts');
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('passes raw errors to explicit callbacks without affecting loading', () => {
+    const rawError = new Error('raw callback');
+    const onRawError = vi.fn(() => {
+      throw new Error('ignored callback failure');
+    });
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+      onRawError,
+    });
+
+    expect(() =>
+      emitManifestError(observability, { error: rawError }),
+    ).not.toThrow();
+
+    expect(onRawError).toHaveBeenCalledTimes(1);
+    expect(onRawError).toHaveBeenCalledWith(
+      rawError,
+      expect.objectContaining({
+        origin: enabledOrigin,
+        event: expect.objectContaining({
+          errorMessage: 'raw callback',
+          errorStack: expect.any(String),
+        }),
+        report: expect.objectContaining({
+          status: 'error',
+          errorStack: expect.any(String),
+        }),
+      }),
+    );
+    expect(observability.getLatestReport()?.status).toBe('error');
+  });
+
+  it('exposes a browser reader only when plugin options allow it', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: {
+          __OBSERVABILITY__?: Record<string, unknown>;
+        };
+      }
+    ).__FEDERATION__;
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: {
+            __OBSERVABILITY__?: Record<string, unknown>;
+          };
+        }
+      ).__FEDERATION__ = {};
+
+      const observability = ObservabilityPlugin({
+        level: 'verbose',
+        browser: {
+          enabled: true,
+          scope: 'host',
+        },
+      });
+
+      emitRemoteLoaded(observability, {
+        origin: {
+          options: {
+            name: 'host',
+          },
+        },
+      });
+
+      const reader = (
+        globalThis as {
+          __FEDERATION__?: {
+            __OBSERVABILITY__?: Record<
+              string,
+              {
+                getLatestReport(): { traceId: string; events: unknown[] };
+                getReport(traceId: string): { events: unknown[] } | undefined;
+                getReports(options?: {
+                  limit?: number;
+                }): { events: unknown[] }[];
+                findReports(query?: {
+                  remote?: string;
+                }): { events: unknown[] }[];
+                exportReport(
+                  traceId?: string,
+                ): { events: unknown[] } | undefined;
+                getTraceIds(): string[];
+                clear?: unknown;
+              }
+            >;
+          };
+        }
+      ).__FEDERATION__?.__OBSERVABILITY__?.host;
+
+      expect(reader).toBeDefined();
+      expect(reader?.clear).toBeUndefined();
+      expect(reader?.getTraceIds()).toHaveLength(1);
+
+      const latestReport = reader?.getLatestReport();
+      expect(latestReport?.traceId).toBeDefined();
+      latestReport?.events.pop();
+
+      expect(reader?.getLatestReport().events).toHaveLength(1);
+      expect(
+        reader?.getReport(latestReport?.traceId || '')?.events,
+      ).toHaveLength(1);
+      expect(reader?.getReports({ limit: 1 })).toHaveLength(1);
+      expect(reader?.findReports({ remote: 'remote' })).toHaveLength(1);
+      expect(
+        reader?.exportReport(latestReport?.traceId || '')?.events,
+      ).toHaveLength(1);
+    } finally {
+      if (originalFederation) {
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __OBSERVABILITY__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__ = originalFederation;
+      } else {
+        delete (
+          globalThis as {
+            __FEDERATION__?: {
+              __OBSERVABILITY__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__;
+      }
+    }
+  });
+
+  it('does not expose the browser reader by default', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: {
+          __OBSERVABILITY__?: Record<string, unknown>;
+        };
+      }
+    ).__FEDERATION__;
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: {
+            __OBSERVABILITY__?: Record<string, unknown>;
+          };
+        }
+      ).__FEDERATION__ = {};
+
+      const observability = ObservabilityPlugin({ level: 'verbose' });
+
+      emitRemoteLoaded(observability);
+
+      expect(
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __OBSERVABILITY__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__?.__OBSERVABILITY__,
+      ).toBeUndefined();
+    } finally {
+      if (originalFederation) {
+        (
+          globalThis as {
+            __FEDERATION__?: {
+              __OBSERVABILITY__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__ = originalFederation;
+      } else {
+        delete (
+          globalThis as {
+            __FEDERATION__?: {
+              __OBSERVABILITY__?: Record<string, unknown>;
+            };
+          }
+        ).__FEDERATION__;
+      }
+    }
+  });
+
+  it('does not write Node observability files by default', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-observability-'),
+    );
+    const latestFile = path.join(directory, 'latest.json');
+    const eventsFile = path.join(directory, 'events.jsonl');
+    const observability = ObservabilityNode({
+      level: 'verbose',
+      console: false,
+      directory,
+    });
+
+    try {
+      emitManifestError(observability);
+      await new Promise((resolve) => setTimeout(resolve, 20));
+
+      expect(fs.existsSync(latestFile)).toBe(false);
+      expect(fs.existsSync(eventsFile)).toBe(false);
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('prints raw stacks from the Node entry only when explicitly allowed', () => {
+    const observability = ObservabilityNode({
+      level: 'verbose',
+      printRawStack: true,
+    });
+    const errorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+    const error = new Error('node raw stack enabled');
+    error.stack = [
+      'Error: node raw stack enabled',
+      '    at raw (/Users/bytedance/node-raw.ts:1:1)',
+    ].join('\n');
+
+    try {
+      emitManifestError(observability, { error });
+
+      const output = String(errorSpy.mock.calls[0]?.[0]);
+      expect(output).toContain('rawStack:');
+      expect(output).toContain('/Users/bytedance/node-raw.ts');
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('writes Node observability files only when plugin options allow it', async () => {
+    const directory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'mf-observability-'),
+    );
+    const latestFile = path.join(directory, 'latest.json');
+    const eventsFile = path.join(directory, 'events.jsonl');
+    const originalNonWebpackRequire = (
+      globalThis as {
+        __non_webpack_require__?: (id: string) => unknown;
+      }
+    ).__non_webpack_require__;
+
+    try {
+      (
+        globalThis as {
+          __non_webpack_require__?: (id: string) => unknown;
+        }
+      ).__non_webpack_require__ = (id: string) => {
+        if (id === 'node:fs' || id === 'fs') {
+          return fs;
+        }
+
+        if (id === 'node:path' || id === 'path') {
+          return path;
+        }
+
+        throw new Error(`Unsupported module: ${id}`);
+      };
+
+      const observability = ObservabilityNode({
+        level: 'verbose',
+        console: false,
+        fileOutput: true,
+        directory,
+      });
+
+      emitManifestError(observability, {
+        origin: {
+          options: {
+            name: 'host',
+          },
+        },
+        error: new Error('token=demo-secret manifest failed'),
+      });
+
+      await waitForFile(latestFile);
+      await waitForFile(eventsFile);
+
+      const latest = fs.readFileSync(latestFile, 'utf8');
+      const eventsOutput = fs.readFileSync(eventsFile, 'utf8');
+
+      expect(latest).toContain('"status": "error"');
+      expect(eventsOutput).toContain('"phase":"manifest"');
+      expect(`${latest}\n${eventsOutput}`).toContain('demo-secret');
+      expect(`${latest}\n${eventsOutput}`).toContain('token=');
+      expect(`${latest}\n${eventsOutput}`).toContain('#hash');
+    } finally {
+      if (originalNonWebpackRequire) {
+        (
+          globalThis as {
+            __non_webpack_require__?: (id: string) => unknown;
+          }
+        ).__non_webpack_require__ = originalNonWebpackRequire;
+      } else {
+        delete (
+          globalThis as {
+            __non_webpack_require__?: (id: string) => unknown;
+          }
+        ).__non_webpack_require__;
+      }
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('lets business code mark component loaded after runtime observability starts', () => {
+    const observability = ObservabilityPlugin({ level: 'verbose' });
+
+    emitRemoteLoaded(observability);
+
+    const componentEvent = observability.markComponentLoaded({
+      requestId: 'remote/Button',
+      componentName: 'RemoteButton',
+      metadata: {
+        route: '/account?token=demo-secret',
+        renderMs: 12,
+        ready: true,
+        token: 'demo-secret',
+      },
+    });
+    const report = observability.getLatestReport();
+
+    expect(componentEvent?.phase).toBe('component');
+    expect(componentEvent?.eventName).toBe('component:business-loaded');
+    expect(componentEvent?.source).toBe('business');
+    expect(componentEvent?.componentName).toBe('RemoteButton');
+    expect(componentEvent?.metadata).toMatchObject({
+      route: '/account?token=demo-secret',
+      renderMs: 12,
+      ready: true,
+      token: 'demo-secret',
+    });
+    expect(report?.summary.componentLoaded).toBe(true);
+    expect(report?.summary.outcome).toBe('component-loaded');
+    expect(report?.diagnosis).toMatchObject({
+      title: 'Business component loaded',
+      status: 'success',
+      outcome: 'component-loaded',
+      facts: expect.objectContaining({
+        componentName: 'RemoteButton',
+        componentLoaded: true,
+      }),
+    });
+    expect(JSON.stringify(report)).toContain('component:business-loaded');
+    expect(JSON.stringify(report)).toContain('demo-secret');
+    expect(JSON.stringify(report)).toContain('token=');
+  });
+
+  it('does not let observability callbacks affect loading', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      onEvent: vi.fn(() => {
+        throw new Error('onEvent failed');
+      }),
+      onReport: vi.fn(() => {
+        throw new Error('onReport failed');
+      }),
+    });
+
+    expect(() => emitRemoteLoaded(observability)).not.toThrow();
+
+    expect(observability.getLatestReport()?.status).toBe('success');
+  });
+
+  it('does not let observability callbacks affect error collection', () => {
+    const observability = ObservabilityPlugin({
+      level: 'verbose',
+      console: false,
+      onEvent: vi.fn(() => {
+        throw new Error('onEvent failed');
+      }),
+      onReport: vi.fn(() => {
+        throw new Error('onReport failed');
+      }),
+      onRawError: vi.fn(() => {
+        throw new Error('onRawError failed');
+      }),
+    });
+
+    expect(() =>
+      emitRemoteError(observability, {
+        error: new Error(
+          '[ Federation Runtime ]: Failed to load script resources. #RUNTIME-008',
+        ),
+      }),
+    ).not.toThrow();
+
+    expect(observability.getLatestReport()).toMatchObject({
+      status: 'error',
+      errorCode: 'RUNTIME-008',
+    });
+  });
+});
diff --git a/packages/diagnostics-plugin/package.json b/packages/observability-plugin/package.json
similarity index 77%
rename from packages/diagnostics-plugin/package.json
rename to packages/observability-plugin/package.json
index e67b4be73c6..ef1bfa7e0f1 100644
--- a/packages/diagnostics-plugin/package.json
+++ b/packages/observability-plugin/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@module-federation/diagnostics-plugin",
+  "name": "@module-federation/observability-plugin",
   "version": "2.4.0",
   "author": "module-federation",
   "main": "./dist/index.js",
@@ -9,14 +9,15 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/module-federation/core.git",
-    "directory": "packages/diagnostics-plugin"
+    "directory": "packages/observability-plugin"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
     "dist/",
-    "README.md"
+    "README.md",
+    "AI_TROUBLESHOOTING.md"
   ],
   "exports": {
     ".": {
@@ -28,6 +29,11 @@
       "types": "./dist/node.d.ts",
       "import": "./dist/esm/node.js",
       "require": "./dist/node.js"
+    },
+    "./build": {
+      "types": "./dist/build.d.ts",
+      "import": "./dist/esm/build.js",
+      "require": "./dist/build.js"
     }
   },
   "typesVersions": {
@@ -37,6 +43,9 @@
       ],
       "node": [
         "./dist/node.d.ts"
+      ],
+      "build": [
+        "./dist/build.d.ts"
       ]
     }
   },
diff --git a/packages/observability-plugin/src/build.ts b/packages/observability-plugin/src/build.ts
new file mode 100644
index 00000000000..a6cf22eb92e
--- /dev/null
+++ b/packages/observability-plugin/src/build.ts
@@ -0,0 +1,1557 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type ObservabilityBuildInfoSource = 'config' | 'stats' | 'manifest';
+export type ObservabilityBuildPublicPathMode =
+  | 'auto'
+  | 'static'
+  | 'runtime-getter'
+  | 'unknown';
+export type ObservabilityBuildReportPhase =
+  | 'compilation'
+  | 'observability-output';
+export type ObservabilityBuildOwnerHint =
+  | 'host'
+  | 'remote'
+  | 'shared'
+  | 'build'
+  | 'unknown';
+export type ObservabilityBuildMetadata = Record<
+  string,
+  string | number | boolean
+>;
+
+export interface ObservabilityBuildRemote {
+  name?: string;
+  alias?: string;
+  entry?: string;
+  type?: string;
+  shareScope?: string | string[];
+}
+
+export interface ObservabilityBuildExpose {
+  name: string;
+}
+
+export interface ObservabilityBuildShared {
+  name: string;
+  shareScope?: string | string[];
+  version?: string;
+  requiredVersion?: string | false;
+  singleton?: boolean;
+  strictVersion?: boolean;
+  eager?: boolean;
+}
+
+export interface ObservabilityBuildInfo {
+  schemaVersion: 1;
+  generatedAt: string;
+  source: ObservabilityBuildInfoSource;
+  bundler: {
+    name: string;
+    version?: string;
+    mode?: string;
+    target?: string[];
+  };
+  moduleFederation: {
+    name?: string;
+    pluginVersion?: string;
+    buildVersion?: string;
+    buildName?: string;
+    remoteEntry?: {
+      name?: string;
+      type?: string;
+      globalName?: string;
+      publicPath?: string;
+      publicPathMode: ObservabilityBuildPublicPathMode;
+    };
+    options: {
+      shareStrategy?: string;
+      shareScope?: string | string[];
+      asyncStartup?: boolean;
+      manifest?: boolean | string;
+      dts?: boolean;
+    };
+    remotes: ObservabilityBuildRemote[];
+    exposes: ObservabilityBuildExpose[];
+    shared: ObservabilityBuildShared[];
+  };
+  summary: {
+    remoteCount: number;
+    exposeCount: number;
+    sharedCount: number;
+  };
+}
+
+export interface ObservabilityBuildErrorSummary {
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  failedPhase: ObservabilityBuildReportPhase;
+  ownerHint: ObservabilityBuildOwnerHint;
+  retryable: false;
+  context?: Record<string, string | number | boolean>;
+}
+
+export interface ObservabilityBuildAction {
+  id: string;
+  ownerHint?: ObservabilityBuildOwnerHint;
+  title: string;
+  detail?: string;
+}
+
+export interface ObservabilityBuildFactReport {
+  title: string;
+  outcome: 'failed';
+  status: 'error';
+  ownerHint: ObservabilityBuildOwnerHint;
+  failedPhase: ObservabilityBuildReportPhase;
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  facts: ObservabilityBuildMetadata;
+  completedPhases: string[];
+  pendingPhases: string[];
+  actions: ObservabilityBuildAction[];
+}
+
+export interface ObservabilityBuildEvent extends ObservabilityBuildErrorSummary {
+  traceId: string;
+  timestamp: number;
+  phase: 'build';
+  status: 'error';
+  lifecycle: ObservabilityBuildReportPhase;
+  errorStack?: string;
+}
+
+export interface ObservabilityBuildReport {
+  schemaVersion: 1;
+  traceId: string;
+  source: 'build';
+  status: 'error';
+  startedAt: number;
+  updatedAt: number;
+  duration: number;
+  failedPhase: ObservabilityBuildReportPhase;
+  build: ObservabilityBuildInfo;
+  events: ObservabilityBuildEvent[];
+  summary: {
+    eventCount: number;
+    outcome: 'failed';
+    error?: ObservabilityBuildErrorSummary;
+    errors: ObservabilityBuildErrorSummary[];
+  };
+  diagnosis: ObservabilityBuildFactReport;
+}
+
+export interface CreateObservabilityBuildInfoOptions {
+  moduleFederation?: unknown;
+  manifest?: unknown;
+  stats?: unknown;
+  compilerOptions?: Record<string, unknown>;
+  bundler?: string;
+  bundlerVersion?: string;
+  pluginVersion?: string;
+  generatedAt?: string;
+}
+
+export interface ObservabilityBuildPluginOptions {
+  enabled?: boolean;
+  outputFile?: string;
+  errorReport?:
+    | false
+    | {
+        outputFile?: string;
+      };
+  cwd?: string;
+  bundler?: string;
+  bundlerVersion?: string;
+  pluginVersion?: string;
+  moduleFederation?: unknown;
+}
+
+interface CompilerLike {
+  context?: string;
+  options?: Record<string, unknown>;
+  webpack?: {
+    version?: string;
+    rspackVersion?: string;
+    sources?: {
+      RawSource?: new (value: string) => unknown;
+    };
+    Compilation?: {
+      PROCESS_ASSETS_STAGE_REPORT?: number;
+      PROCESS_ASSETS_STAGE_SUMMARIZE?: number;
+    };
+  };
+  hooks?: {
+    thisCompilation?: {
+      tap(name: string, callback: (compilation: CompilationLike) => void): void;
+    };
+  };
+  getInfrastructureLogger?: (name: string) => {
+    warn?: (message: string) => void;
+  };
+}
+
+interface CompilationLike {
+  constructor?: {
+    PROCESS_ASSETS_STAGE_REPORT?: number;
+    PROCESS_ASSETS_STAGE_SUMMARIZE?: number;
+  };
+  hooks?: {
+    processAssets?: {
+      tapPromise(
+        options: { name: string; stage?: number },
+        callback: () => Promise<void>,
+      ): void;
+    };
+  };
+  getAsset?: (name: string) =>
+    | {
+        source?: unknown;
+      }
+    | undefined;
+  emitAsset?: (name: string, source: unknown) => void;
+  assets?: Record<string, unknown>;
+  errors?: unknown[];
+}
+
+const PLUGIN_NAME = 'ObservabilityBuildPlugin';
+const DEFAULT_OUTPUT_FILE = '.mf/observability/build-info.json';
+const DEFAULT_REPORT_FILE = '.mf/observability/build-report.json';
+const DEFAULT_MANIFEST_FILE = 'mf-manifest.json';
+const DEFAULT_STATS_FILE = 'mf-stats.json';
+const ERROR_CODE_PATTERN = /\b(?:RUNTIME|TYPE|BUILD)-\d{3}\b/;
+const MAX_BUILD_FACT_KEYS = 50;
+const SENSITIVE_PAIR_PATTERN =
+  /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
+const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
+const ABSOLUTE_PATH_PATTERN =
+  /(?:file:\/\/)?(?:\/(?:Users|private|var|tmp|home|workspace|opt|usr)\/[^\s)]+|[A-Za-z]:\\[^\s)]+)/g;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function getRecord(value: unknown): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined;
+}
+
+function getString(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function getBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function sanitizeText(value: unknown, maxLength = 240): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const sanitized = String(value)
+    .replace(URL_PATTERN, (url) => sanitizeUrl(url) || '[redacted-url]')
+    .replace(ABSOLUTE_PATH_PATTERN, '[redacted-path]')
+    .replace(SENSITIVE_PAIR_PATTERN, '[redacted]');
+
+  return sanitized.length > maxLength
+    ? `${sanitized.slice(0, maxLength)}...`
+    : sanitized;
+}
+
+function getRawText(value: unknown): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  return String(value);
+}
+
+function clipText(value: unknown, maxLength = 320): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const sanitized = String(value);
+
+  return sanitized.length > maxLength
+    ? `${sanitized.slice(0, maxLength)}...`
+    : sanitized;
+}
+
+function sanitizeStack(value: unknown): string | undefined {
+  const stack = getString(value);
+  if (!stack) {
+    return undefined;
+  }
+
+  return stack;
+}
+
+function extractErrorCode(value: unknown): string | undefined {
+  return sanitizeText(String(value ?? '').match(ERROR_CODE_PATTERN)?.[0], 40);
+}
+
+function sanitizeUrl(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  try {
+    const parsedUrl = new URL(value, 'http://localhost');
+    const sanitized = `${parsedUrl.origin}${parsedUrl.pathname}`;
+
+    return /^https?:\/\//i.test(value) ? sanitized : parsedUrl.pathname;
+  } catch {
+    const [withoutHash] = value.split('#');
+    const [withoutQuery] = withoutHash.split('?');
+    return sanitizeText(withoutQuery, 320);
+  }
+}
+
+function sanitizeRemoteEntry(value: unknown): string | undefined {
+  const raw = getString(value);
+  if (!raw) {
+    return undefined;
+  }
+
+  const atIndex = raw.lastIndexOf('@');
+  if (atIndex > 0) {
+    const remoteName = sanitizeText(raw.slice(0, atIndex), 120);
+    const entry = clipText(raw.slice(atIndex + 1), 320);
+    if (remoteName && entry) {
+      return `${remoteName}@${entry}`;
+    }
+    return entry || remoteName;
+  }
+
+  return clipText(raw, 320);
+}
+
+function sanitizePublicPath(value: unknown): string | undefined {
+  const raw = getString(value);
+  if (!raw) {
+    return undefined;
+  }
+
+  return clipText(raw, 320);
+}
+
+function getSanitizedString(value: unknown, maxLength = 160) {
+  return sanitizeText(value, maxLength);
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    const sanitized = getSanitizedString(value);
+    return sanitized ? [sanitized] : undefined;
+  }
+
+  const values = value
+    .map((item) => getSanitizedString(item))
+    .filter((item): item is string => Boolean(item));
+
+  return values.length ? values.slice(0, 20) : undefined;
+}
+
+function normalizeShareScope(value: unknown): string | string[] | undefined {
+  if (Array.isArray(value)) {
+    const scopes = normalizeStringArray(value);
+    return scopes?.length ? scopes : undefined;
+  }
+
+  return getSanitizedString(value);
+}
+
+function normalizeRequiredVersion(value: unknown): string | false | undefined {
+  if (value === false) {
+    return false;
+  }
+
+  return getSanitizedString(value, 120);
+}
+
+function normalizeManifestOption(value: unknown): boolean | string | undefined {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  const manifestOptions = getRecord(value);
+  if (!manifestOptions) {
+    return undefined;
+  }
+
+  return getSanitizedString(manifestOptions['fileName'], 120) || true;
+}
+
+function getManifestFileName(manifestOption: unknown) {
+  const manifestOptions = getRecord(manifestOption);
+  const filePath = getString(manifestOptions?.['filePath']) || '';
+  const fileName = getString(manifestOptions?.['fileName']);
+  const manifestFile = fileName
+    ? addJsonExtension(fileName)
+    : DEFAULT_MANIFEST_FILE;
+  const statsFile = fileName
+    ? insertSuffix(addJsonExtension(fileName), '-stats')
+    : DEFAULT_STATS_FILE;
+
+  return {
+    manifestFileName: joinAssetPath(filePath, manifestFile),
+    statsFileName: joinAssetPath(filePath, statsFile),
+  };
+}
+
+function addJsonExtension(fileName: string) {
+  return /\.json$/i.test(fileName) ? fileName : `${fileName}.json`;
+}
+
+function insertSuffix(fileName: string, suffix: string) {
+  return fileName.replace(/\.json$/i, `${suffix}.json`);
+}
+
+function joinAssetPath(filePath: string, fileName: string) {
+  if (!filePath) {
+    return fileName;
+  }
+
+  return `${filePath.replace(/\\/g, '/').replace(/\/+$/g, '')}/${fileName}`;
+}
+
+function getSourceText(source: unknown): string | undefined {
+  if (source === undefined || source === null) {
+    return undefined;
+  }
+
+  if (typeof source === 'string') {
+    return source;
+  }
+
+  if (typeof source === 'function') {
+    try {
+      return getSourceText(source());
+    } catch {
+      return undefined;
+    }
+  }
+
+  const sourceRecord = getRecord(source);
+  const sourceFn = sourceRecord?.['source'];
+  if (typeof sourceFn === 'function') {
+    try {
+      return getSourceText(sourceFn.call(source));
+    } catch {
+      return undefined;
+    }
+  }
+
+  return String(source);
+}
+
+function readAssetText(
+  compilation: CompilationLike,
+  fileName: string,
+): string | undefined {
+  const asset = compilation.getAsset?.(fileName);
+  const assetSource = asset ? getSourceText(asset.source) : undefined;
+  if (assetSource !== undefined) {
+    return assetSource;
+  }
+
+  const legacyAsset = compilation.assets?.[fileName];
+  return getSourceText(legacyAsset);
+}
+
+function readJsonAsset(
+  compilation: CompilationLike,
+  fileName: string,
+): Record<string, unknown> | undefined {
+  const text = readAssetText(compilation, fileName);
+  if (!text) {
+    return undefined;
+  }
+
+  try {
+    return getRecord(JSON.parse(text));
+  } catch {
+    return undefined;
+  }
+}
+
+function getRemoteParts(value: unknown) {
+  const raw = getString(value);
+  if (!raw) {
+    return {};
+  }
+
+  const atIndex = raw.lastIndexOf('@');
+  if (atIndex > 0) {
+    return {
+      name: getSanitizedString(raw.slice(0, atIndex), 120),
+      entry: sanitizeRemoteEntry(raw.slice(atIndex + 1)),
+    };
+  }
+
+  return {
+    entry: sanitizeRemoteEntry(raw),
+  };
+}
+
+function normalizeRemoteFromConfig(
+  alias: string | undefined,
+  value: unknown,
+): ObservabilityBuildRemote | undefined {
+  const remote: ObservabilityBuildRemote = {
+    alias: getSanitizedString(alias, 120),
+  };
+
+  if (typeof value === 'string') {
+    const parts = getRemoteParts(value);
+    remote.name = parts.name || remote.alias;
+    remote.entry = parts.entry;
+    return remote.name || remote.entry ? remote : undefined;
+  }
+
+  if (Array.isArray(value)) {
+    const firstValue = value.find(
+      (item) => typeof item === 'string' || isRecord(item),
+    );
+    return normalizeRemoteFromConfig(alias, firstValue);
+  }
+
+  const remoteOptions = getRecord(value);
+  if (!remoteOptions) {
+    return remote.alias ? remote : undefined;
+  }
+
+  const entryValue =
+    remoteOptions['entry'] ||
+    remoteOptions['external'] ||
+    remoteOptions['version'];
+  const parts = getRemoteParts(entryValue);
+
+  remote.name =
+    getSanitizedString(remoteOptions['name'], 120) ||
+    getSanitizedString(remoteOptions['federationContainerName'], 120) ||
+    parts.name ||
+    remote.alias;
+  remote.alias =
+    getSanitizedString(remoteOptions['alias'], 120) || remote.alias;
+  remote.entry = parts.entry || sanitizeRemoteEntry(entryValue);
+  remote.type = getSanitizedString(remoteOptions['type'], 80);
+  remote.shareScope = normalizeShareScope(remoteOptions['shareScope']);
+
+  return remote.name || remote.entry ? remote : undefined;
+}
+
+function normalizeRemoteFromManifest(
+  value: unknown,
+): ObservabilityBuildRemote | undefined {
+  const remoteOptions = getRecord(value);
+  if (!remoteOptions) {
+    return undefined;
+  }
+
+  const entryValue = remoteOptions['entry'] || remoteOptions['version'];
+  const remote: ObservabilityBuildRemote = {
+    name:
+      getSanitizedString(remoteOptions['moduleName'], 120) ||
+      getSanitizedString(remoteOptions['name'], 120) ||
+      getSanitizedString(remoteOptions['federationContainerName'], 120),
+    alias: getSanitizedString(remoteOptions['alias'], 120),
+    entry: sanitizeRemoteEntry(entryValue),
+    type: getSanitizedString(remoteOptions['type'], 80),
+    shareScope: normalizeShareScope(remoteOptions['shareScope']),
+  };
+
+  return remote.name || remote.entry ? remote : undefined;
+}
+
+function normalizeConfigRemotes(value: unknown): ObservabilityBuildRemote[] {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => normalizeRemoteFromConfig(undefined, item))
+      .filter((item): item is ObservabilityBuildRemote => Boolean(item));
+  }
+
+  const remotes = getRecord(value);
+  if (!remotes) {
+    return [];
+  }
+
+  return Object.entries(remotes)
+    .map(([alias, remote]) => normalizeRemoteFromConfig(alias, remote))
+    .filter((remote): remote is ObservabilityBuildRemote => Boolean(remote));
+}
+
+function normalizeManifestRemotes(value: unknown): ObservabilityBuildRemote[] {
+  return (Array.isArray(value) ? value : [])
+    .map(normalizeRemoteFromManifest)
+    .filter((remote): remote is ObservabilityBuildRemote => Boolean(remote));
+}
+
+function normalizeConfigExposes(value: unknown): ObservabilityBuildExpose[] {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) =>
+        typeof item === 'string'
+          ? getSanitizedString(item, 160)
+          : getSanitizedString(getRecord(item)?.['name'], 160),
+      )
+      .filter((name): name is string => Boolean(name))
+      .map((name) => ({ name }));
+  }
+
+  const exposes = getRecord(value);
+  if (!exposes) {
+    return [];
+  }
+
+  return Object.keys(exposes)
+    .map((name) => getSanitizedString(name, 160))
+    .filter((name): name is string => Boolean(name))
+    .map((name) => ({ name }));
+}
+
+function normalizeManifestExposes(value: unknown): ObservabilityBuildExpose[] {
+  return (Array.isArray(value) ? value : [])
+    .map((item) => {
+      const expose = getRecord(item);
+      return (
+        getSanitizedString(expose?.['name'], 160) ||
+        getSanitizedString(expose?.['id'], 160)
+      );
+    })
+    .filter((name): name is string => Boolean(name))
+    .map((name) => ({ name }));
+}
+
+function normalizeSharedFromRecord(
+  name: string | undefined,
+  value: unknown,
+): ObservabilityBuildShared | undefined {
+  const sharedOptions = getRecord(value);
+  if (!sharedOptions) {
+    const sharedName =
+      name ||
+      (typeof value === 'string' ? getSanitizedString(value, 160) : undefined);
+    return sharedName ? { name: sharedName } : undefined;
+  }
+
+  const sharedName =
+    getSanitizedString(sharedOptions['name'], 160) ||
+    getSanitizedString(sharedOptions['shareKey'], 160) ||
+    name;
+
+  if (!sharedName) {
+    return undefined;
+  }
+
+  return {
+    name: sharedName,
+    shareScope: normalizeShareScope(sharedOptions['shareScope']),
+    version: getSanitizedString(sharedOptions['version'], 120),
+    requiredVersion: normalizeRequiredVersion(sharedOptions['requiredVersion']),
+    singleton: getBoolean(sharedOptions['singleton']),
+    strictVersion: getBoolean(sharedOptions['strictVersion']),
+    eager: getBoolean(sharedOptions['eager']),
+  };
+}
+
+function normalizeConfigShared(value: unknown): ObservabilityBuildShared[] {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => normalizeSharedFromRecord(undefined, item))
+      .filter((shared): shared is ObservabilityBuildShared => Boolean(shared));
+  }
+
+  const shared = getRecord(value);
+  if (!shared) {
+    return [];
+  }
+
+  return Object.entries(shared)
+    .map(([name, sharedOptions]) =>
+      normalizeSharedFromRecord(getSanitizedString(name, 160), sharedOptions),
+    )
+    .filter((item): item is ObservabilityBuildShared => Boolean(item));
+}
+
+function normalizeManifestShared(value: unknown): ObservabilityBuildShared[] {
+  return (Array.isArray(value) ? value : [])
+    .map((item) => {
+      const sharedOptions = getRecord(item);
+      return normalizeSharedFromRecord(
+        getSanitizedString(sharedOptions?.['name'], 160) ||
+          getSanitizedString(sharedOptions?.['id'], 160),
+        sharedOptions,
+      );
+    })
+    .filter((shared): shared is ObservabilityBuildShared => Boolean(shared));
+}
+
+function getPublicPathInfo(
+  metaData: Record<string, unknown> | undefined,
+  compilerOptions: Record<string, unknown> | undefined,
+) {
+  const outputOptions = getRecord(compilerOptions?.['output']);
+  const getPublicPath = metaData?.['getPublicPath'];
+  const publicPath = metaData?.['publicPath'] || outputOptions?.['publicPath'];
+
+  if (getPublicPath) {
+    return {
+      mode: 'runtime-getter' as const,
+      value: undefined,
+    };
+  }
+
+  const sanitizedPublicPath = sanitizePublicPath(publicPath);
+  if (publicPath === 'auto') {
+    return {
+      mode: 'auto' as const,
+      value: 'auto',
+    };
+  }
+
+  if (sanitizedPublicPath) {
+    return {
+      mode: 'static' as const,
+      value: sanitizedPublicPath,
+    };
+  }
+
+  return {
+    mode: 'unknown' as const,
+    value: undefined,
+  };
+}
+
+function normalizeTarget(value: unknown): string[] | undefined {
+  return normalizeStringArray(value);
+}
+
+function getManifestSource(
+  manifest: Record<string, unknown> | undefined,
+  stats: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  return manifest || stats;
+}
+
+function getMetaData(
+  manifest: Record<string, unknown> | undefined,
+  stats: Record<string, unknown> | undefined,
+) {
+  return (
+    getRecord(manifest?.['metaData']) ||
+    getRecord(stats?.['metaData']) ||
+    undefined
+  );
+}
+
+function getBuildInfo(metaData: Record<string, unknown> | undefined) {
+  return getRecord(metaData?.['buildInfo']);
+}
+
+function getSource(
+  manifest: Record<string, unknown> | undefined,
+  stats: Record<string, unknown> | undefined,
+): ObservabilityBuildInfoSource {
+  if (manifest) {
+    return 'manifest';
+  }
+  if (stats) {
+    return 'stats';
+  }
+  return 'config';
+}
+
+function getConfigOptions(moduleFederation: unknown) {
+  return getRecord(moduleFederation) || {};
+}
+
+function getRemoteEntryType(
+  moduleFederation: Record<string, unknown>,
+  metaData: Record<string, unknown> | undefined,
+) {
+  const remoteEntry = getRecord(metaData?.['remoteEntry']);
+  const library = getRecord(moduleFederation['library']);
+
+  return (
+    getSanitizedString(remoteEntry?.['type'], 80) ||
+    getSanitizedString(library?.['type'], 80)
+  );
+}
+
+function getRemoteEntryName(
+  moduleFederation: Record<string, unknown>,
+  metaData: Record<string, unknown> | undefined,
+) {
+  const remoteEntry = getRecord(metaData?.['remoteEntry']);
+
+  return (
+    getSanitizedString(remoteEntry?.['name'], 160) ||
+    getSanitizedString(moduleFederation['filename'], 160)
+  );
+}
+
+function getGlobalName(
+  moduleFederation: Record<string, unknown>,
+  metaData: Record<string, unknown> | undefined,
+) {
+  const library = getRecord(moduleFederation['library']);
+
+  return (
+    getSanitizedString(metaData?.['globalName'], 160) ||
+    getSanitizedString(library?.['name'], 160)
+  );
+}
+
+function getBundlerName(
+  inputBundler: string | undefined,
+  compilerOptions: Record<string, unknown> | undefined,
+) {
+  return (
+    getSanitizedString(inputBundler, 80) ||
+    getSanitizedString(compilerOptions?.['name'], 80) ||
+    'unknown'
+  );
+}
+
+function getBundlerVersion(
+  inputVersion: string | undefined,
+  compilerOptions: Record<string, unknown> | undefined,
+) {
+  return (
+    getSanitizedString(inputVersion, 80) ||
+    getSanitizedString(compilerOptions?.['webpackVersion'], 80)
+  );
+}
+
+function getDtsOption(value: unknown) {
+  if (value === false) {
+    return false;
+  }
+  if (value === undefined) {
+    return undefined;
+  }
+  return true;
+}
+
+function getAsyncStartup(moduleFederation: Record<string, unknown>) {
+  const experiments = getRecord(moduleFederation['experiments']);
+  return getBoolean(experiments?.['asyncStartup']);
+}
+
+function uniqueByName<T extends { name?: string }>(items: T[]): T[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    const key = item.name || JSON.stringify(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+export function createObservabilityBuildInfo(
+  input: CreateObservabilityBuildInfoOptions,
+): ObservabilityBuildInfo {
+  const moduleFederation = getConfigOptions(input.moduleFederation);
+  const manifest = getRecord(input.manifest);
+  const stats = getRecord(input.stats);
+  const manifestSource = getManifestSource(manifest, stats);
+  const metaData = getMetaData(manifest, stats);
+  const buildInfo = getBuildInfo(metaData);
+  const publicPath = getPublicPathInfo(metaData, input.compilerOptions);
+  const manifestRemotes = normalizeManifestRemotes(manifestSource?.['remotes']);
+  const manifestExposes = normalizeManifestExposes(manifestSource?.['exposes']);
+  const manifestShared = normalizeManifestShared(manifestSource?.['shared']);
+  const remotes = uniqueByName(
+    manifestRemotes.length
+      ? manifestRemotes
+      : normalizeConfigRemotes(moduleFederation['remotes']),
+  );
+  const exposes = uniqueByName(
+    manifestExposes.length
+      ? manifestExposes
+      : normalizeConfigExposes(moduleFederation['exposes']),
+  );
+  const shared = uniqueByName(
+    manifestShared.length
+      ? manifestShared
+      : normalizeConfigShared(moduleFederation['shared']),
+  );
+
+  return {
+    schemaVersion: 1,
+    generatedAt: input.generatedAt || new Date().toISOString(),
+    source: getSource(manifest, stats),
+    bundler: {
+      name: getBundlerName(input.bundler, input.compilerOptions),
+      version: getBundlerVersion(input.bundlerVersion, input.compilerOptions),
+      mode: getSanitizedString(input.compilerOptions?.['mode'], 80),
+      target: normalizeTarget(input.compilerOptions?.['target']),
+    },
+    moduleFederation: {
+      name:
+        getSanitizedString(manifestSource?.['name'], 160) ||
+        getSanitizedString(metaData?.['name'], 160) ||
+        getSanitizedString(moduleFederation['name'], 160),
+      pluginVersion:
+        getSanitizedString(metaData?.['pluginVersion'], 80) ||
+        getSanitizedString(input.pluginVersion, 80),
+      buildVersion: getSanitizedString(buildInfo?.['buildVersion'], 160),
+      buildName: getSanitizedString(buildInfo?.['buildName'], 160),
+      remoteEntry: {
+        name: getRemoteEntryName(moduleFederation, metaData),
+        type: getRemoteEntryType(moduleFederation, metaData),
+        globalName: getGlobalName(moduleFederation, metaData),
+        publicPath: publicPath.value,
+        publicPathMode: publicPath.mode,
+      },
+      options: {
+        shareStrategy: getSanitizedString(
+          moduleFederation['shareStrategy'],
+          80,
+        ),
+        shareScope: normalizeShareScope(moduleFederation['shareScope']),
+        asyncStartup: getAsyncStartup(moduleFederation),
+        manifest: normalizeManifestOption(moduleFederation['manifest']),
+        dts: getDtsOption(moduleFederation['dts']),
+      },
+      remotes,
+      exposes,
+      shared,
+    },
+    summary: {
+      remoteCount: remotes.length,
+      exposeCount: exposes.length,
+      sharedCount: shared.length,
+    },
+  };
+}
+
+function getErrorRecord(error: unknown): Record<string, unknown> | undefined {
+  return getRecord(error);
+}
+
+function getErrorName(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return getSanitizedString(error.name, 120);
+  }
+
+  const errorRecord = getErrorRecord(error);
+  const constructorName =
+    typeof error === 'object' && error !== null
+      ? getSanitizedString(
+          (error as { constructor?: { name?: unknown } }).constructor?.name,
+          120,
+        )
+      : undefined;
+  return getSanitizedString(errorRecord?.['name'], 120) || constructorName;
+}
+
+function getErrorMessage(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return getRawText(error.message);
+  }
+
+  const errorRecord = getErrorRecord(error);
+  return getRawText(errorRecord?.['message']) || getRawText(error);
+}
+
+function getErrorStack(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return sanitizeStack(error.stack);
+  }
+
+  return sanitizeStack(getErrorRecord(error)?.['stack']);
+}
+
+function getBuildOwnerHint(
+  error: unknown,
+  phase: ObservabilityBuildReportPhase,
+): ObservabilityBuildOwnerHint {
+  if (phase === 'observability-output') {
+    return 'build';
+  }
+
+  const text = `${getErrorName(error) || ''}\n${getErrorMessage(error) || ''}\n${
+    getErrorStack(error) || ''
+  }`;
+
+  if (/shared|shareScope|singleton|strictVersion|eager/i.test(text)) {
+    return 'shared';
+  }
+  if (/remote|manifest|remoteEntry|expose|container/i.test(text)) {
+    return 'remote';
+  }
+  if (/host|ModuleFederationPlugin|federation/i.test(text)) {
+    return 'host';
+  }
+
+  return 'build';
+}
+
+function createBuildErrorEvent(
+  traceId: string,
+  error: unknown,
+  phase: ObservabilityBuildReportPhase,
+): ObservabilityBuildEvent {
+  const timestamp = Date.now();
+  const errorName = getErrorName(error);
+  const errorMessage = getErrorMessage(error);
+  const errorStack = getErrorStack(error);
+  const errorCode = extractErrorCode(
+    `${errorName || ''}\n${errorMessage || ''}\n${errorStack || ''}`,
+  );
+
+  return {
+    traceId,
+    timestamp,
+    phase: 'build',
+    status: 'error',
+    lifecycle: phase,
+    failedPhase: phase,
+    errorCode,
+    errorName,
+    errorMessage,
+    errorStack,
+    ownerHint: getBuildOwnerHint(error, phase),
+    retryable: false,
+    context: {
+      lifecycle: phase,
+    },
+  };
+}
+
+function copyBuildErrorSummary(
+  event: ObservabilityBuildEvent,
+): ObservabilityBuildErrorSummary {
+  return {
+    errorCode: event.errorCode,
+    errorName: event.errorName,
+    errorMessage: event.errorMessage,
+    failedPhase: event.failedPhase,
+    ownerHint: event.ownerHint,
+    retryable: event.retryable,
+    context: event.context ? { ...event.context } : undefined,
+  };
+}
+
+function createBuildFacts(
+  buildInfo: ObservabilityBuildInfo,
+  phase: ObservabilityBuildReportPhase,
+  primaryError: ObservabilityBuildErrorSummary | undefined,
+): ObservabilityBuildMetadata {
+  const facts: Record<string, unknown> = {};
+  const addFact = (key: string, value: unknown) => {
+    if (value === undefined || value === null || value === '') {
+      return;
+    }
+
+    facts[key] = Array.isArray(value) ? value.join(',') : value;
+  };
+
+  addFact('source', 'build');
+  addFact('status', 'error');
+  addFact('outcome', 'failed');
+  addFact('failedPhase', phase);
+  addFact('errorCode', primaryError?.errorCode);
+  addFact('errorName', primaryError?.errorName);
+  addFact('ownerHint', primaryError?.ownerHint);
+  addFact('retryable', primaryError?.retryable);
+  addFact('bundlerName', buildInfo.bundler.name);
+  addFact('bundlerVersion', buildInfo.bundler.version);
+  addFact('buildMode', buildInfo.bundler.mode);
+  addFact('buildTarget', buildInfo.bundler.target);
+  addFact('mfName', buildInfo.moduleFederation.name);
+  addFact('pluginVersion', buildInfo.moduleFederation.pluginVersion);
+  addFact('buildVersion', buildInfo.moduleFederation.buildVersion);
+  addFact('buildName', buildInfo.moduleFederation.buildName);
+  addFact('remoteEntryName', buildInfo.moduleFederation.remoteEntry?.name);
+  addFact('remoteEntryType', buildInfo.moduleFederation.remoteEntry?.type);
+  addFact(
+    'remoteEntryGlobalName',
+    buildInfo.moduleFederation.remoteEntry?.globalName,
+  );
+  addFact(
+    'publicPathMode',
+    buildInfo.moduleFederation.remoteEntry?.publicPathMode,
+  );
+  addFact('remoteCount', buildInfo.summary.remoteCount);
+  addFact('exposeCount', buildInfo.summary.exposeCount);
+  addFact('sharedCount', buildInfo.summary.sharedCount);
+  addFact(
+    'remotes',
+    buildInfo.moduleFederation.remotes
+      .map((remote) => remote.alias || remote.name || remote.entry)
+      .filter((value): value is string => Boolean(value)),
+  );
+  addFact(
+    'exposes',
+    buildInfo.moduleFederation.exposes.map((expose) => expose.name),
+  );
+  addFact(
+    'shared',
+    buildInfo.moduleFederation.shared.map((shared) => shared.name),
+  );
+  addFact(
+    'eagerShared',
+    buildInfo.moduleFederation.shared
+      .filter((shared) => shared.eager)
+      .map((shared) => shared.name),
+  );
+
+  return Object.entries(facts)
+    .slice(0, MAX_BUILD_FACT_KEYS)
+    .reduce<ObservabilityBuildMetadata>((memo, [key, value]) => {
+      const sanitizedKey = sanitizeText(key, 80);
+      if (!sanitizedKey) {
+        return memo;
+      }
+
+      if (typeof value === 'boolean') {
+        memo[sanitizedKey] = value;
+        return memo;
+      }
+
+      if (typeof value === 'number') {
+        if (Number.isFinite(value)) {
+          memo[sanitizedKey] = value;
+        }
+        return memo;
+      }
+
+      const sanitizedValue = clipText(value, 240);
+      if (sanitizedValue) {
+        memo[sanitizedKey] = sanitizedValue;
+      }
+
+      return memo;
+    }, {});
+}
+
+function createBuildActions(
+  phase: ObservabilityBuildReportPhase,
+  ownerHint: ObservabilityBuildOwnerHint,
+): ObservabilityBuildAction[] {
+  const actions: ObservabilityBuildAction[] = [];
+  const pushAction = (
+    id: string,
+    title: string,
+    hint: ObservabilityBuildOwnerHint = ownerHint,
+  ) => {
+    actions.push({
+      id,
+      ownerHint: hint,
+      title,
+    });
+  };
+
+  if (phase === 'observability-output') {
+    pushAction(
+      'check-observability-output',
+      'Check observability output path permissions and filesystem availability',
+      'build',
+    );
+    return actions;
+  }
+
+  pushAction(
+    'inspect-build-errors',
+    'Inspect the sanitized build error list for the first failing build phase',
+    ownerHint,
+  );
+
+  if (ownerHint === 'shared') {
+    pushAction(
+      'check-shared-config',
+      'Check shared dependency configuration, versions, and eager settings',
+      'shared',
+    );
+  } else if (ownerHint === 'remote') {
+    pushAction(
+      'check-remote-config',
+      'Check remoteEntry, remotes, exposes, and manifest build output',
+      'remote',
+    );
+  } else {
+    pushAction(
+      'check-module-federation-config',
+      'Check host Module Federation configuration and build options',
+      ownerHint === 'host' ? 'host' : 'build',
+    );
+  }
+
+  return actions;
+}
+
+function createBuildFactReport(
+  buildInfo: ObservabilityBuildInfo,
+  phase: ObservabilityBuildReportPhase,
+  primaryError: ObservabilityBuildErrorSummary | undefined,
+): ObservabilityBuildFactReport {
+  const ownerHint = primaryError?.ownerHint || 'build';
+
+  return {
+    title:
+      phase === 'observability-output'
+        ? 'Build observability output failed'
+        : 'Module Federation build failed',
+    outcome: 'failed',
+    status: 'error',
+    ownerHint,
+    failedPhase: phase,
+    errorCode: primaryError?.errorCode,
+    errorName: primaryError?.errorName,
+    errorMessage: primaryError?.errorMessage,
+    facts: createBuildFacts(buildInfo, phase, primaryError),
+    completedPhases:
+      phase === 'compilation' ? ['build-info'] : ['build-report'],
+    pendingPhases: [],
+    actions: createBuildActions(phase, ownerHint),
+  };
+}
+
+function createBuildReport(
+  buildInfo: ObservabilityBuildInfo,
+  errors: unknown[],
+  phase: ObservabilityBuildReportPhase,
+  startedAt: number,
+): ObservabilityBuildReport | undefined {
+  const sanitizedErrors = errors.filter((error) => error !== undefined);
+  if (!sanitizedErrors.length) {
+    return undefined;
+  }
+
+  const traceId = `mf-build-${Date.now().toString(36)}`;
+  const events = sanitizedErrors
+    .slice(0, 20)
+    .map((error) => createBuildErrorEvent(traceId, error, phase));
+  const updatedAt = events[events.length - 1]?.timestamp || Date.now();
+  const errorsSummary = events.map(copyBuildErrorSummary);
+  const primaryError = errorsSummary[0];
+
+  return {
+    schemaVersion: 1,
+    traceId,
+    source: 'build',
+    status: 'error',
+    startedAt,
+    updatedAt,
+    duration: Math.max(0, updatedAt - startedAt),
+    failedPhase: phase,
+    build: buildInfo,
+    events,
+    summary: {
+      eventCount: events.length,
+      outcome: 'failed',
+      error: primaryError,
+      errors: errorsSummary,
+    },
+    diagnosis: createBuildFactReport(buildInfo, phase, primaryError),
+  };
+}
+
+function getModuleFederationOptions(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+): unknown {
+  if (options.moduleFederation) {
+    return options.moduleFederation;
+  }
+
+  const plugins = compiler.options?.['plugins'];
+  if (!Array.isArray(plugins)) {
+    return undefined;
+  }
+
+  for (const plugin of plugins) {
+    const pluginRecord = getRecord(plugin);
+    if (!pluginRecord) {
+      continue;
+    }
+
+    const pluginName = getSanitizedString(pluginRecord['name'], 120);
+    if (pluginName !== 'ModuleFederationPlugin') {
+      continue;
+    }
+
+    return pluginRecord['_options'] || pluginRecord['options'];
+  }
+
+  return undefined;
+}
+
+function getCompilerOptions(compiler: CompilerLike) {
+  return compiler.options || {};
+}
+
+function getBundlerFromCompiler(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  if (options.bundler) {
+    return options.bundler;
+  }
+
+  if (compiler.webpack?.rspackVersion) {
+    return 'rspack';
+  }
+
+  return 'webpack';
+}
+
+function getBundlerVersionFromCompiler(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  return options.bundlerVersion || compiler.webpack?.version;
+}
+
+function getProcessAssetsStage(
+  compiler: CompilerLike,
+  compilation: CompilationLike,
+) {
+  return (
+    compilation.constructor?.PROCESS_ASSETS_STAGE_REPORT ||
+    compiler.webpack?.Compilation?.PROCESS_ASSETS_STAGE_REPORT ||
+    compilation.constructor?.PROCESS_ASSETS_STAGE_SUMMARIZE ||
+    compiler.webpack?.Compilation?.PROCESS_ASSETS_STAGE_SUMMARIZE
+  );
+}
+
+function getOutputFile(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  return getResolvedOutputFile(options.outputFile || DEFAULT_OUTPUT_FILE, {
+    cwd: options.cwd,
+    compiler,
+  });
+}
+
+function getResolvedOutputFile(
+  outputFile: string,
+  {
+    cwd: configuredCwd,
+    compiler,
+  }: {
+    cwd?: string;
+    compiler: CompilerLike;
+  },
+) {
+  const cwd =
+    configuredCwd ||
+    getString(compiler.options?.['context']) ||
+    compiler.context ||
+    process.cwd();
+
+  return path.isAbsolute(outputFile)
+    ? outputFile
+    : path.resolve(cwd, outputFile);
+}
+
+function getBuildReportOutputFile(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  const reportOptions = options.errorReport;
+  const outputFile =
+    reportOptions === false
+      ? undefined
+      : reportOptions?.outputFile || DEFAULT_REPORT_FILE;
+
+  return outputFile
+    ? getResolvedOutputFile(outputFile, { cwd: options.cwd, compiler })
+    : undefined;
+}
+
+function writeBuildInfo(
+  buildInfo: ObservabilityBuildInfo,
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  const outputFile = getOutputFile(options, compiler);
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+  fs.writeFileSync(
+    outputFile,
+    `${JSON.stringify(buildInfo, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+function writeBuildReport(
+  report: ObservabilityBuildReport,
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  const outputFile = getBuildReportOutputFile(options, compiler);
+  if (!outputFile) {
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+  fs.writeFileSync(outputFile, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+}
+
+function removeStaleBuildReport(
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  const outputFile = getBuildReportOutputFile(options, compiler);
+  if (!outputFile || !fs.existsSync(outputFile)) {
+    return;
+  }
+
+  fs.rmSync(outputFile, { force: true });
+}
+
+function warn(
+  compiler: CompilerLike,
+  error: unknown,
+  action = 'write build observability',
+) {
+  const message =
+    getRawText(error instanceof Error ? error.message : String(error)) ||
+    'unknown error';
+  const logger = compiler.getInfrastructureLogger?.(PLUGIN_NAME);
+  logger?.warn?.(`[${PLUGIN_NAME}] Failed to ${action}: ${message}`);
+}
+
+function writeBuildReportSafely(
+  report: ObservabilityBuildReport | undefined,
+  options: ObservabilityBuildPluginOptions,
+  compiler: CompilerLike,
+) {
+  if (!report) {
+    return;
+  }
+
+  try {
+    writeBuildReport(report, options, compiler);
+  } catch (error) {
+    warn(compiler, error, 'write build observability report');
+  }
+}
+
+export class ObservabilityBuildPlugin {
+  readonly name = PLUGIN_NAME;
+  private readonly options: ObservabilityBuildPluginOptions;
+
+  constructor(options: ObservabilityBuildPluginOptions = {}) {
+    this.options = options;
+  }
+
+  apply(compiler: CompilerLike): void {
+    if (this.options.enabled === false) {
+      return;
+    }
+
+    compiler.hooks?.thisCompilation?.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks?.processAssets?.tapPromise(
+        {
+          name: PLUGIN_NAME,
+          stage: getProcessAssetsStage(compiler, compilation),
+        },
+        async () => {
+          const startedAt = Date.now();
+          try {
+            const moduleFederation = getModuleFederationOptions(
+              this.options,
+              compiler,
+            );
+            const fileNames = getManifestFileName(
+              getRecord(moduleFederation)?.['manifest'],
+            );
+            const manifest = readJsonAsset(
+              compilation,
+              fileNames.manifestFileName,
+            );
+            const stats = readJsonAsset(compilation, fileNames.statsFileName);
+            const buildInfo = createObservabilityBuildInfo({
+              moduleFederation,
+              manifest,
+              stats,
+              compilerOptions: getCompilerOptions(compiler),
+              bundler: getBundlerFromCompiler(this.options, compiler),
+              bundlerVersion: getBundlerVersionFromCompiler(
+                this.options,
+                compiler,
+              ),
+              pluginVersion: this.options.pluginVersion,
+            });
+            let observabilityOutputFailed = false;
+
+            try {
+              writeBuildInfo(buildInfo, this.options, compiler);
+            } catch (error) {
+              observabilityOutputFailed = true;
+              warn(compiler, error);
+              writeBuildReportSafely(
+                createBuildReport(
+                  buildInfo,
+                  [error],
+                  'observability-output',
+                  startedAt,
+                ),
+                this.options,
+                compiler,
+              );
+            }
+
+            const compilationErrors = compilation.errors || [];
+            if (compilationErrors.length) {
+              writeBuildReportSafely(
+                createBuildReport(
+                  buildInfo,
+                  compilationErrors,
+                  'compilation',
+                  startedAt,
+                ),
+                this.options,
+                compiler,
+              );
+            } else if (!observabilityOutputFailed) {
+              try {
+                removeStaleBuildReport(this.options, compiler);
+              } catch (error) {
+                warn(
+                  compiler,
+                  error,
+                  'remove stale build observability report',
+                );
+              }
+            }
+          } catch (error) {
+            const fallbackBuildInfo = createObservabilityBuildInfo({
+              moduleFederation: this.options.moduleFederation,
+              compilerOptions: getCompilerOptions(compiler),
+              bundler: getBundlerFromCompiler(this.options, compiler),
+              bundlerVersion: getBundlerVersionFromCompiler(
+                this.options,
+                compiler,
+              ),
+              pluginVersion: this.options.pluginVersion,
+            });
+
+            warn(compiler, error);
+            writeBuildReportSafely(
+              createBuildReport(
+                fallbackBuildInfo,
+                [error],
+                'observability-output',
+                startedAt,
+              ),
+              this.options,
+              compiler,
+            );
+          }
+        },
+      );
+    });
+  }
+}
diff --git a/packages/observability-plugin/src/index.ts b/packages/observability-plugin/src/index.ts
new file mode 100644
index 00000000000..8ec0410abca
--- /dev/null
+++ b/packages/observability-plugin/src/index.ts
@@ -0,0 +1,3207 @@
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+
+export type ObservabilityLevel = 'error' | 'summary' | 'verbose';
+export type ObservabilityEventStatus =
+  | 'start'
+  | 'success'
+  | 'error'
+  | 'complete';
+export type ObservabilityReportStatus = 'pending' | 'success' | 'error';
+export type ObservabilityEventSource = 'runtime' | 'business';
+export type ObservabilityBrowserMode = 'development' | 'production';
+export type ObservabilityReportOutcome =
+  | 'pending'
+  | 'runtime-loaded'
+  | 'component-loaded'
+  | 'failed'
+  | 'recovered';
+export type ObservabilityOwnerHint =
+  | 'host'
+  | 'remote'
+  | 'shared'
+  | 'network'
+  | 'runtime'
+  | 'unknown';
+export type ObservabilityMetadataValue = string | number | boolean;
+export type ObservabilityMetadata = Record<string, ObservabilityMetadataValue>;
+
+export interface ObservabilityModuleInfoEntry {
+  name: string;
+  publicPath?: string;
+  getPublicPath?: string;
+  remoteEntry?: string;
+  globalName?: string;
+}
+
+export interface ObservabilityModuleInfoSummary {
+  reason: string;
+  clipped: true;
+  totalCount: number;
+  matchedCount: number;
+  entries: ObservabilityModuleInfoEntry[];
+  availableNames?: string[];
+}
+
+export interface ObservabilityPhaseSummary {
+  status: ObservabilityEventStatus;
+  duration?: number;
+  cached?: boolean;
+  recovered?: boolean;
+  lifecycle?: string;
+}
+
+export interface ObservabilitySharedSummary {
+  name: string;
+  provider?: string;
+  selectedVersion?: string;
+  shareScope?: string[];
+}
+
+export interface ObservabilityReportFlags {
+  cached: boolean;
+  retried: boolean;
+  fallback: boolean;
+  recovered: boolean;
+}
+
+export interface ObservabilityPhaseCollection {
+  phases: Record<string, ObservabilityPhaseSummary>;
+  shared?: ObservabilitySharedSummary;
+  flags: ObservabilityReportFlags;
+}
+
+export interface ObservabilityErrorSummary {
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  failedPhase?: string;
+  lifecycle?: string;
+  ownerHint?: ObservabilityOwnerHint;
+  retryable?: boolean;
+  context?: ObservabilityMetadata;
+}
+
+export type ObservabilityActionId =
+  | 'check-manifest-url'
+  | 'check-remote-entry'
+  | 'check-remote-global'
+  | 'check-host-remotes'
+  | 'check-shared-provider'
+  | 'check-shared-version'
+  | 'check-eager-config'
+  | 'check-network'
+  | 'check-expose'
+  | 'check-module-info'
+  | 'inspect-runtime-events';
+
+export interface ObservabilityAction {
+  id: ObservabilityActionId | string;
+  ownerHint?: ObservabilityOwnerHint;
+  title: string;
+  detail?: string;
+}
+
+export interface ObservabilityFactReport {
+  title: string;
+  outcome: ObservabilityReportOutcome;
+  status: ObservabilityReportStatus;
+  ownerHint: ObservabilityOwnerHint;
+  failedPhase?: string;
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  docLink?: string;
+  facts: ObservabilityMetadata;
+  completedPhases: string[];
+  pendingPhases: string[];
+  warnings?: string[];
+  actions: ObservabilityAction[];
+}
+
+export interface ObservabilityRemoteInfo {
+  name: string;
+  alias?: string;
+  entry?: string;
+  entryGlobalName?: string;
+  type?: string;
+}
+
+export interface ObservabilitySharedInfo {
+  name: string;
+  shareScope?: string[];
+  requiredVersion?: string | false;
+  selectedVersion?: string;
+  availableVersions?: string[];
+  provider?: string;
+  from?: string;
+  singleton?: boolean;
+  strictVersion?: boolean;
+  eager?: boolean;
+  strategy?: string;
+  loaded?: boolean;
+  loading?: boolean;
+  reason?: string;
+}
+
+export interface ObservabilityEvent {
+  traceId: string;
+  timestamp: number;
+  phase: string;
+  status: ObservabilityEventStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: ObservabilityRemoteInfo;
+  shared?: ObservabilitySharedInfo;
+  expose?: string;
+  sanitizedUrl?: string;
+  message?: string;
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  errorStack?: string;
+  ownerHint?: ObservabilityOwnerHint;
+  retryable?: boolean;
+  errorContext?: ObservabilityMetadata;
+  duration?: number;
+  lifecycle?: string;
+  eventName?: string;
+  source?: ObservabilityEventSource;
+  recovered?: boolean;
+  cached?: boolean;
+  componentName?: string;
+  metadata?: ObservabilityMetadata;
+}
+
+export interface ObservabilityReport {
+  traceId: string;
+  status: ObservabilityReportStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: ObservabilityRemoteInfo;
+  shared?: ObservabilitySharedInfo;
+  expose?: string;
+  sanitizedUrl?: string;
+  startedAt: number;
+  updatedAt: number;
+  duration: number;
+  failedPhase?: string;
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  errorStack?: string;
+  ownerHint?: ObservabilityOwnerHint;
+  retryable?: boolean;
+  errorContext?: ObservabilityMetadata;
+  moduleInfo?: ObservabilityModuleInfoSummary;
+  events: ObservabilityEvent[];
+  summary: {
+    eventCount: number;
+    recovered: boolean;
+    loadCompleted: boolean;
+    runtimeLoaded: boolean;
+    componentLoaded: boolean;
+    outcome: ObservabilityReportOutcome;
+    lastPhase?: string;
+    phases: Record<string, ObservabilityPhaseSummary>;
+    shared?: ObservabilitySharedSummary;
+    flags: ObservabilityReportFlags;
+    error?: ObservabilityErrorSummary;
+  };
+  diagnosis?: ObservabilityFactReport;
+}
+
+export interface ObservabilityPluginOptions {
+  enabled?: boolean;
+  level?: ObservabilityLevel;
+  maxEvents?: number;
+  console?: boolean;
+  printRawStack?: boolean;
+  stackTrace?: {
+    enabled?: boolean;
+    maxLines?: number;
+    maxLength?: number;
+  };
+  browser?: {
+    enabled?: boolean;
+    scope?: string;
+    mode?: ObservabilityBrowserMode;
+  };
+  onEvent?: (
+    event: ObservabilityEvent,
+    report: ObservabilityReport,
+    context?: ObservabilityEventContext,
+  ) => void;
+  onReport?: (
+    report: ObservabilityReport,
+    context?: ObservabilityEventContext,
+  ) => void;
+  onRawError?: (error: unknown, context: ObservabilityRawErrorContext) => void;
+}
+
+export interface ObservabilityReportListOptions {
+  limit?: number;
+}
+
+export interface ObservabilityReportQuery extends ObservabilityReportListOptions {
+  traceId?: string;
+  remote?: string;
+  expose?: string;
+  shared?: string;
+  status?: ObservabilityReportStatus;
+  outcome?: ObservabilityReportOutcome;
+}
+
+export interface MarkComponentLoadedOptions {
+  traceId?: string;
+  requestId?: string;
+  componentName?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ObservabilityController {
+  plugin: ObservabilityRuntimePlugin;
+  getEvents(): ObservabilityEvent[];
+  getTraceIds(): string[];
+  getReports(options?: ObservabilityReportListOptions): ObservabilityReport[];
+  findReports(query?: ObservabilityReportQuery): ObservabilityReport[];
+  getLatestReport(): ObservabilityReport | undefined;
+  getReport(traceId: string): ObservabilityReport | undefined;
+  exportReport(traceId?: string): ObservabilityReport | undefined;
+  clear(): void;
+  markComponentLoaded(
+    options?: MarkComponentLoadedOptions,
+  ): ObservabilityEvent | undefined;
+}
+
+export interface ObservabilityRuntimeEventInput {
+  phase: string;
+  status: ObservabilityEventStatus;
+  requestId?: string;
+  hostName?: string;
+  remote?: ObservabilityRemoteInfo;
+  shared?: ObservabilitySharedInfo;
+  expose?: string;
+  url?: string;
+  message?: string;
+  error?: unknown;
+  errorContext?: Record<string, unknown>;
+  duration?: number;
+  lifecycle?: string;
+  eventName?: string;
+  source?: ObservabilityEventSource;
+  recovered?: boolean;
+  timestamp?: number;
+  traceId?: string;
+  cached?: boolean;
+  componentName?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ObservabilityRuntimeOrigin {
+  options?: {
+    name?: string;
+  };
+}
+
+export interface ObservabilityEventContext {
+  origin?: ObservabilityRuntimeOrigin;
+}
+
+export interface ObservabilityRawErrorContext extends ObservabilityEventContext {
+  event: ObservabilityEvent;
+  report: ObservabilityReport;
+}
+
+interface ObservabilityRuntimeSharedConfig {
+  requiredVersion?: string | false;
+  singleton?: boolean;
+  strictVersion?: boolean;
+  eager?: boolean;
+}
+
+interface ObservabilityRuntimeSharedSource {
+  version?: string;
+  scope?: string | string[];
+  from?: string;
+  loaded?: boolean;
+  loading?: unknown;
+  strategy?: string;
+  shareConfig?: ObservabilityRuntimeSharedConfig;
+  get?: unknown;
+}
+
+interface ObservabilityRuntimeRemoteSource {
+  name?: string;
+  alias?: string;
+  entry?: string;
+  entryGlobalName?: string;
+  type?: string;
+}
+
+interface ObservabilityRuntimeOptions {
+  name?: string;
+  remotes?: ObservabilityRuntimeRemoteSource[];
+}
+
+interface ObservabilityRemoteLoadArgs {
+  id: string;
+  expose?: string;
+  remote?: ObservabilityRuntimeRemoteSource;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteBeforeRequestArgs {
+  id: string;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteAfterLoadArgs {
+  id: string;
+  expose?: string;
+  remote?: ObservabilityRuntimeRemoteSource;
+  error?: unknown;
+  recovered?: boolean;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteMatchArgs {
+  id: string;
+  options?: ObservabilityRuntimeOptions;
+  expose?: string;
+  remote?: ObservabilityRuntimeRemoteSource;
+  remoteInfo?: ObservabilityRuntimeRemoteSource;
+  error?: unknown;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteSnapshotArgs {
+  moduleInfo?: ObservabilityRuntimeRemoteSource;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteSnapshotLoadArgs {
+  moduleInfo?: ObservabilityRuntimeRemoteSource;
+  manifestJson?: unknown;
+  manifestUrl?: string;
+  from?: 'global' | 'manifest';
+}
+
+interface ObservabilityRemoteResolveArgs {
+  id: string;
+  expose?: string;
+  remote?: ObservabilityRuntimeRemoteSource;
+  remoteInfo?: ObservabilityRuntimeRemoteSource;
+  cached?: boolean;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteErrorArgs {
+  id: string;
+  error: unknown;
+  lifecycle?: string;
+  remote?: ObservabilityRuntimeRemoteSource;
+  expose?: string;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteEntryLoadArgs {
+  origin: ObservabilityRuntimeOrigin;
+  remoteInfo: ObservabilityRuntimeRemoteSource;
+}
+
+interface ObservabilityRemoteEntryAfterLoadArgs {
+  origin: ObservabilityRuntimeOrigin;
+  remoteInfo: ObservabilityRuntimeRemoteSource;
+  error?: unknown;
+  recovered?: boolean;
+  cached?: boolean;
+}
+
+interface ObservabilityRemoteInitArgs {
+  id?: string;
+  remoteInfo: ObservabilityRuntimeRemoteSource;
+  error?: unknown;
+  cached?: boolean;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteExposeArgs {
+  id: string;
+  expose: string;
+  moduleInfo: ObservabilityRuntimeRemoteSource;
+  error?: unknown;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+interface ObservabilityRemoteFactoryArgs {
+  id: string;
+  expose: string;
+  moduleInfo: ObservabilityRuntimeRemoteSource;
+  loadFactory: boolean;
+  error?: unknown;
+  origin: ObservabilityRuntimeOrigin;
+}
+
+type ObservabilityRuntimeShareScopeMap = Record<
+  string,
+  Record<string, Record<string, ObservabilityRuntimeSharedSource | undefined>>
+>;
+
+interface ObservabilitySharedLifecycleArgs {
+  pkgName: string;
+  shareInfo?: ObservabilityRuntimeSharedSource;
+  selectedShared?: ObservabilityRuntimeSharedSource;
+  shared?: Record<string, ObservabilityRuntimeSharedSource[]>;
+  shareScopeMap?: ObservabilityRuntimeShareScopeMap;
+  lifecycle?: 'loadShare' | 'loadShareSync';
+  origin: ObservabilityRuntimeOrigin;
+  error?: unknown;
+  recovered?: boolean;
+}
+
+export type ObservabilityRuntimePlugin = ModuleFederationRuntimePlugin;
+
+export interface ObservabilityBrowserReader {
+  getEvents(): ObservabilityEvent[];
+  getTraceIds(): string[];
+  getReports(options?: ObservabilityReportListOptions): ObservabilityReport[];
+  findReports(query?: ObservabilityReportQuery): ObservabilityReport[];
+  getLatestReport(): ObservabilityReport | undefined;
+  getReport(traceId: string): ObservabilityReport | undefined;
+  exportReport(traceId?: string): ObservabilityReport | undefined;
+}
+
+interface FederationObservabilityGlobal {
+  __OBSERVABILITY__?: Record<string, ObservabilityBrowserReader>;
+  moduleInfo?: Record<string, unknown>;
+}
+
+const DEFAULT_MAX_EVENTS = 100;
+const HARD_MAX_EVENTS = 1000;
+const COMPONENT_BUSINESS_LOADED_EVENT = 'component:business-loaded';
+const SENSITIVE_PAIR_PATTERN =
+  /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
+const ERROR_CODE_PATTERN = /\b(?:RUNTIME|TYPE|BUILD)-\d{3}\b/;
+const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
+const DIAGNOSTIC_DOC_LINK_PATTERN =
+  /https?:\/\/module-federation\.io\/guide\/troubleshooting\/[^\s'"<>]+/i;
+const RUNTIME_DOC_LINK =
+  'https://module-federation.io/guide/troubleshooting/runtime';
+const ABSOLUTE_PATH_PATTERN =
+  /(?:file:\/\/)?(?:\/(?:Users|private|var|tmp|home|workspace|opt|usr)\/[^\s)]+|[A-Za-z]:\\[^\s)]+)/g;
+const MAX_METADATA_KEYS = 20;
+const MAX_FACT_KEYS = 50;
+const MAX_BUILD_ITEMS = 50;
+const MAX_MODULE_INFO_ENTRIES = 20;
+const HARD_MAX_REPORT_QUERY_LIMIT = 1000;
+
+let traceCounter = 0;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function normalizeMaxEvents(value: number | undefined, fallback: number) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return fallback;
+  }
+
+  return Math.max(1, Math.min(HARD_MAX_EVENTS, Math.floor(value)));
+}
+
+function normalizeQueryLimit(value: number | undefined): number | undefined {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return undefined;
+  }
+
+  return Math.max(1, Math.min(HARD_MAX_REPORT_QUERY_LIMIT, Math.floor(value)));
+}
+
+function sanitizeText(value: unknown, maxLength = 800): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const sanitized = String(value)
+    .replace(URL_PATTERN, (url) => sanitizeUrl(url) || '[redacted-url]')
+    .replace(SENSITIVE_PAIR_PATTERN, '[redacted]');
+
+  return sanitized.length > maxLength
+    ? `${sanitized.slice(0, maxLength)}...`
+    : sanitized;
+}
+
+function getRawText(value: unknown): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  return String(value);
+}
+
+function clipText(value: unknown, maxLength = 320): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const sanitized = String(value);
+
+  return sanitized.length > maxLength
+    ? `${sanitized.slice(0, maxLength)}...`
+    : sanitized;
+}
+
+function clipObservabilityMetadata(
+  metadata: Record<string, unknown> | undefined,
+  maxKeys = MAX_METADATA_KEYS,
+): ObservabilityMetadata | undefined {
+  if (!metadata || typeof metadata !== 'object') {
+    return undefined;
+  }
+
+  const clipped: ObservabilityMetadata = {};
+
+  Object.entries(metadata)
+    .slice(0, maxKeys)
+    .forEach(([rawKey, rawValue]) => {
+      const key = clipText(rawKey, 80);
+
+      if (!key || rawValue === undefined || rawValue === null) {
+        return;
+      }
+
+      if (typeof rawValue === 'boolean') {
+        clipped[key] = rawValue;
+        return;
+      }
+
+      if (typeof rawValue === 'number') {
+        if (Number.isFinite(rawValue)) {
+          clipped[key] = rawValue;
+        }
+        return;
+      }
+
+      const value = clipText(rawValue, 240);
+      if (value) {
+        clipped[key] = value;
+      }
+    });
+
+  return Object.keys(clipped).length ? clipped : undefined;
+}
+
+function clipMetadata(
+  metadata: Record<string, unknown> | undefined,
+  maxKeys = MAX_METADATA_KEYS,
+): ObservabilityMetadata | undefined {
+  if (!metadata || typeof metadata !== 'object') {
+    return undefined;
+  }
+
+  const clipped: ObservabilityMetadata = {};
+
+  Object.entries(metadata)
+    .slice(0, maxKeys)
+    .forEach(([rawKey, rawValue]) => {
+      const key = sanitizeText(rawKey, 80);
+
+      if (!key || rawValue === undefined || rawValue === null) {
+        return;
+      }
+
+      if (typeof rawValue === 'boolean') {
+        clipped[key] = rawValue;
+        return;
+      }
+
+      if (typeof rawValue === 'number') {
+        if (Number.isFinite(rawValue)) {
+          clipped[key] = rawValue;
+        }
+        return;
+      }
+
+      const value = clipText(rawValue, 240);
+      if (value) {
+        clipped[key] = value;
+      }
+    });
+
+  return Object.keys(clipped).length ? clipped : undefined;
+}
+
+function sanitizeStack(
+  stack: string | undefined,
+  options: ObservabilityPluginOptions['stackTrace'],
+): string | undefined {
+  if (!stack || options?.enabled === false) {
+    return undefined;
+  }
+
+  return stack;
+}
+
+function getRawStack(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+
+  return undefined;
+}
+
+function sanitizeRequestId(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  return clipText(value, 240);
+}
+
+function sanitizeUrl(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  try {
+    const base =
+      typeof window !== 'undefined' && window.location
+        ? window.location.origin
+        : 'http://localhost';
+    const parsedUrl = new URL(value, base);
+    const sanitized = `${parsedUrl.origin}${parsedUrl.pathname}`;
+
+    return /^https?:\/\//i.test(value) ? sanitized : parsedUrl.pathname;
+  } catch {
+    const [withoutHash] = value.split('#');
+    const [withoutQuery] = withoutHash.split('?');
+    return sanitizeText(withoutQuery, 240);
+  }
+}
+
+function sanitizeRemote(
+  remote: ObservabilityRemoteInfo | undefined,
+): ObservabilityRemoteInfo | undefined {
+  if (!remote || !remote.name) {
+    return undefined;
+  }
+
+  return {
+    name: remote.name,
+    alias: sanitizeText(remote.alias, 120),
+    entry: clipText(remote.entry, 320),
+    entryGlobalName: sanitizeText(remote.entryGlobalName, 120),
+    type: sanitizeText(remote.type, 80),
+  };
+}
+
+function createRemoteInfo(
+  remote: ObservabilityRuntimeRemoteSource | undefined,
+): ObservabilityRemoteInfo | undefined {
+  if (!remote?.name) {
+    return undefined;
+  }
+
+  return {
+    name: remote.name,
+    alias: remote.alias,
+    entry: remote.entry,
+    entryGlobalName: remote.entryGlobalName,
+    type: remote.type,
+  };
+}
+
+function isManifestUrl(value: string | undefined): boolean {
+  const sanitized = sanitizeUrl(value);
+
+  return Boolean(sanitized && /manifest.*\.json$/i.test(sanitized));
+}
+
+function normalizeSharedScope(value: string | string[] | undefined): string[] {
+  if (!value) {
+    return [];
+  }
+
+  return (Array.isArray(value) ? value : [value])
+    .map((scope) => sanitizeText(scope, 120))
+    .filter((scope): scope is string => Boolean(scope));
+}
+
+function getSharedScopes(
+  shareInfo: ObservabilityRuntimeSharedSource | undefined,
+): string[] {
+  return normalizeSharedScope(shareInfo?.scope).length
+    ? normalizeSharedScope(shareInfo?.scope)
+    : ['default'];
+}
+
+function getAvailableSharedVersions(args: ObservabilitySharedLifecycleArgs) {
+  const versions = new Set<string>();
+  const shareScopeMap = args.shareScopeMap || {};
+
+  getSharedScopes(args.shareInfo).forEach((scope) => {
+    Object.keys(shareScopeMap[scope]?.[args.pkgName] || {}).forEach(
+      (version) => {
+        versions.add(version);
+      },
+    );
+  });
+
+  return Array.from(versions);
+}
+
+function getSharedMissReason(args: ObservabilitySharedLifecycleArgs) {
+  if (!args.shareInfo) {
+    return 'missing-config';
+  }
+
+  return getAvailableSharedVersions(args).length
+    ? 'version-mismatch'
+    : 'missing-provider';
+}
+
+function getSharedErrorReason(args: ObservabilitySharedLifecycleArgs) {
+  if (args.recovered) {
+    return getSharedMissReason(args);
+  }
+
+  const errorInfo = getErrorInfo(args.error, { enabled: false });
+  const errorMessage = errorInfo.errorMessage || '';
+
+  if (!args.shareInfo || /Cannot find shared/i.test(errorMessage)) {
+    return 'missing-config';
+  }
+
+  if (
+    args.lifecycle === 'loadShareSync' &&
+    typeof args.shareInfo.get === 'function' &&
+    /RUNTIME-00[56]/.test(errorMessage)
+  ) {
+    return 'sync-async-boundary';
+  }
+
+  if (
+    args.lifecycle === 'loadShareSync' &&
+    !args.shareInfo.get &&
+    /RUNTIME-006/.test(errorMessage)
+  ) {
+    return getSharedMissReason(args);
+  }
+
+  if (args.error) {
+    return 'load-error';
+  }
+
+  return undefined;
+}
+
+function createSharedInfo(
+  args: ObservabilitySharedLifecycleArgs,
+  reason?: string,
+): ObservabilitySharedInfo {
+  const shareConfig = args.shareInfo?.shareConfig;
+
+  return {
+    name: args.pkgName,
+    shareScope: getSharedScopes(args.shareInfo),
+    requiredVersion: shareConfig?.requiredVersion,
+    selectedVersion: args.selectedShared?.version,
+    availableVersions: getAvailableSharedVersions(args),
+    provider: args.selectedShared?.from,
+    from: args.shareInfo?.from,
+    singleton: shareConfig?.singleton,
+    strictVersion: shareConfig?.strictVersion,
+    eager: shareConfig?.eager,
+    strategy: args.shareInfo?.strategy,
+    loaded: args.selectedShared?.loaded,
+    loading: Boolean(args.selectedShared?.loading) || undefined,
+    reason,
+  };
+}
+
+function sanitizeShared(
+  shared: ObservabilitySharedInfo | undefined,
+): ObservabilitySharedInfo | undefined {
+  if (!shared || !shared.name) {
+    return undefined;
+  }
+
+  return {
+    name: sanitizeText(shared.name, 160) || 'unknown',
+    shareScope: normalizeSharedScope(shared.shareScope),
+    requiredVersion:
+      shared.requiredVersion === false
+        ? false
+        : sanitizeText(shared.requiredVersion, 120),
+    selectedVersion: sanitizeText(shared.selectedVersion, 120),
+    availableVersions: (shared.availableVersions || [])
+      .map((version) => sanitizeText(version, 120))
+      .filter((version): version is string => Boolean(version))
+      .slice(0, 20),
+    provider: sanitizeText(shared.provider, 160),
+    from: sanitizeText(shared.from, 160),
+    singleton: shared.singleton,
+    strictVersion: shared.strictVersion,
+    eager: shared.eager,
+    strategy: sanitizeText(shared.strategy, 80),
+    loaded: shared.loaded,
+    loading: shared.loading,
+    reason: sanitizeText(shared.reason, 120),
+  };
+}
+
+function normalizeEventSource(
+  value: ObservabilityEventSource | undefined,
+): ObservabilityEventSource | undefined {
+  return value === 'runtime' || value === 'business' ? value : undefined;
+}
+
+function extractErrorCode(value: unknown): string | undefined {
+  const matched = String(value ?? '').match(ERROR_CODE_PATTERN)?.[0];
+  return matched ? sanitizeText(matched, 40) : undefined;
+}
+
+function getErrorInfo(
+  error: unknown,
+  stackTraceOptions?: ObservabilityPluginOptions['stackTrace'],
+): {
+  errorCode?: string;
+  errorName?: string;
+  errorMessage?: string;
+  errorStack?: string;
+} {
+  if (!error) {
+    return {};
+  }
+
+  if (error instanceof Error) {
+    return {
+      errorCode: extractErrorCode(
+        `${error.name}\n${error.message}\n${error.stack || ''}`,
+      ),
+      errorName: getRawText(error.name),
+      errorMessage: getRawText(error.message),
+      errorStack: sanitizeStack(error.stack, stackTraceOptions),
+    };
+  }
+
+  return {
+    errorCode: extractErrorCode(error),
+    errorMessage: getRawText(error),
+  };
+}
+
+function omitUndefinedFields<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map((item) => omitUndefinedFields(item)) as T;
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  const cleanValue: Record<string, unknown> = {};
+
+  Object.entries(value as Record<string, unknown>).forEach(([key, item]) => {
+    if (item === undefined) {
+      return;
+    }
+
+    cleanValue[key] = omitUndefinedFields(item);
+  });
+
+  return cleanValue as T;
+}
+
+function copyEvent(event: ObservabilityEvent): ObservabilityEvent {
+  return omitUndefinedFields({
+    ...event,
+    remote: event.remote ? { ...event.remote } : undefined,
+    shared: event.shared
+      ? {
+          ...event.shared,
+          shareScope: event.shared.shareScope
+            ? [...event.shared.shareScope]
+            : undefined,
+          availableVersions: event.shared.availableVersions
+            ? [...event.shared.availableVersions]
+            : undefined,
+        }
+      : undefined,
+    errorContext: event.errorContext ? { ...event.errorContext } : undefined,
+    metadata: event.metadata ? { ...event.metadata } : undefined,
+  });
+}
+
+function copySummary(
+  summary: ObservabilityReport['summary'],
+): ObservabilityReport['summary'] {
+  return {
+    ...summary,
+    phases: Object.entries(summary.phases).reduce<
+      Record<string, ObservabilityPhaseSummary>
+    >((memo, [phase, phaseSummary]) => {
+      memo[phase] = { ...phaseSummary };
+      return memo;
+    }, {}),
+    shared: summary.shared
+      ? {
+          ...summary.shared,
+          shareScope: summary.shared.shareScope
+            ? [...summary.shared.shareScope]
+            : undefined,
+        }
+      : undefined,
+    flags: { ...summary.flags },
+    error: summary.error
+      ? {
+          ...summary.error,
+          context: summary.error.context
+            ? { ...summary.error.context }
+            : undefined,
+        }
+      : undefined,
+  };
+}
+
+function copyFactReport(
+  diagnosis: ObservabilityFactReport | undefined,
+): ObservabilityFactReport | undefined {
+  if (!diagnosis) {
+    return undefined;
+  }
+
+  return {
+    ...diagnosis,
+    facts: { ...diagnosis.facts },
+    completedPhases: [...diagnosis.completedPhases],
+    pendingPhases: [...diagnosis.pendingPhases],
+    warnings: diagnosis.warnings ? [...diagnosis.warnings] : undefined,
+    actions: diagnosis.actions.map((action) => ({ ...action })),
+  };
+}
+
+function copyModuleInfoSummary(
+  moduleInfo: ObservabilityModuleInfoSummary | undefined,
+): ObservabilityModuleInfoSummary | undefined {
+  if (!moduleInfo) {
+    return undefined;
+  }
+
+  return {
+    ...moduleInfo,
+    entries: moduleInfo.entries.map((entry) => ({ ...entry })),
+    availableNames: moduleInfo.availableNames
+      ? [...moduleInfo.availableNames]
+      : undefined,
+  };
+}
+
+function copyReport(report: ObservabilityReport): ObservabilityReport {
+  return omitUndefinedFields({
+    ...report,
+    remote: report.remote ? { ...report.remote } : undefined,
+    shared: report.shared
+      ? {
+          ...report.shared,
+          shareScope: report.shared.shareScope
+            ? [...report.shared.shareScope]
+            : undefined,
+          availableVersions: report.shared.availableVersions
+            ? [...report.shared.availableVersions]
+            : undefined,
+        }
+      : undefined,
+    errorContext: report.errorContext ? { ...report.errorContext } : undefined,
+    moduleInfo: copyModuleInfoSummary(report.moduleInfo),
+    events: report.events.map(copyEvent),
+    summary: copySummary(report.summary),
+    diagnosis: copyFactReport(report.diagnosis),
+  });
+}
+
+function getFederationGlobal(): FederationObservabilityGlobal | undefined {
+  return (
+    globalThis as {
+      __FEDERATION__?: FederationObservabilityGlobal;
+    }
+  ).__FEDERATION__;
+}
+
+function normalizeScope(value: unknown) {
+  const sanitized = sanitizeText(value, 120);
+  const normalized = sanitized?.replace(/[^\w:@.-]+/g, '-');
+
+  return normalized || 'default';
+}
+
+function shouldRecordEvent(
+  level: ObservabilityLevel,
+  event: ObservabilityRuntimeEventInput,
+) {
+  if (level === 'verbose') {
+    return true;
+  }
+
+  if (level === 'summary') {
+    return event.status !== 'start';
+  }
+
+  return event.status === 'error' || Boolean(event.error);
+}
+
+function createTraceId(event: ObservabilityRuntimeEventInput) {
+  traceCounter += 1;
+  const owner = event.remote?.name || event.phase || 'runtime';
+  const normalizedOwner = owner.replace(/[^a-z0-9]+/gi, '-').slice(0, 80);
+
+  return `mf-${normalizedOwner}-${Date.now().toString(36)}-${traceCounter.toString(
+    36,
+  )}`;
+}
+
+function getPhaseDurationKey(event: ObservabilityEvent) {
+  const exposeKey =
+    event.phase === 'expose' || event.phase === 'moduleFactory'
+      ? event.expose || ''
+      : '';
+
+  return [
+    event.traceId,
+    event.phase,
+    event.requestId || event.remote?.name || event.shared?.name || '',
+    exposeKey,
+  ].join('|');
+}
+
+function getRemoteEntryKey(
+  remote: ObservabilityRemoteInfo | undefined,
+): string | undefined {
+  if (!remote?.name) {
+    return undefined;
+  }
+
+  return [remote.name, remote.entryGlobalName || '', remote.entry || ''].join(
+    '|',
+  );
+}
+
+function getHostRemotesSummary(
+  options: ObservabilityRuntimeOptions | undefined,
+): string | undefined {
+  const remotes = (options?.remotes || [])
+    .map((remote) => clipText(remote.alias || remote.name || remote.entry, 120))
+    .filter((remote): remote is string => Boolean(remote))
+    .slice(0, 20);
+
+  return remotes.length ? remotes.join(',') : undefined;
+}
+
+function sanitizeModuleInfoPath(value: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  return clipText(value, 320);
+}
+
+function sanitizeModuleInfoGetPublicPath(value: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  return clipText(value, 500);
+}
+
+function sanitizeModuleInfoRemoteEntry(value: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  return clipText(value, 320);
+}
+
+function createClippedModuleInfoEntry(
+  rawName: string,
+  rawValue: unknown,
+): ObservabilityModuleInfoEntry | undefined {
+  const name = clipText(rawName, 240);
+  if (!name) {
+    return undefined;
+  }
+
+  const value = isRecord(rawValue) ? rawValue : {};
+
+  return {
+    name,
+    publicPath: sanitizeModuleInfoPath(value['publicPath']),
+    getPublicPath: sanitizeModuleInfoGetPublicPath(value['getPublicPath']),
+    remoteEntry: sanitizeModuleInfoRemoteEntry(value['remoteEntry']),
+    globalName: sanitizeText(value['globalName'], 160),
+  };
+}
+
+function normalizeModuleInfoLookupValue(value: unknown): string | undefined {
+  if (typeof value !== 'string' || !value) {
+    return undefined;
+  }
+
+  const sanitized =
+    /^https?:\/\//i.test(value) || value.startsWith('/')
+      ? sanitizeUrl(value)
+      : sanitizeText(value, 240);
+
+  return sanitized?.toLowerCase();
+}
+
+function getModuleInfoLookupValues(report: ObservabilityReport): Set<string> {
+  return new Set(
+    [
+      report.requestId?.split('/')[0],
+      report.remote?.name,
+      report.remote?.alias,
+      report.remote?.entry,
+      report.remote?.entryGlobalName,
+      report.sanitizedUrl,
+      report.errorContext?.['remoteName'],
+      report.errorContext?.['remoteAlias'],
+      report.errorContext?.['url'],
+      report.summary.error?.context?.['remoteName'],
+      report.summary.error?.context?.['remoteAlias'],
+      report.summary.error?.context?.['url'],
+    ]
+      .map(normalizeModuleInfoLookupValue)
+      .filter((value): value is string => Boolean(value)),
+  );
+}
+
+function matchesModuleInfoLookup(
+  entry: ObservabilityModuleInfoEntry,
+  lookupValues: Set<string>,
+): boolean {
+  if (!lookupValues.size) {
+    return false;
+  }
+
+  const entryValues = [
+    entry.name,
+    entry.publicPath,
+    entry.getPublicPath,
+    entry.remoteEntry,
+    entry.globalName,
+  ]
+    .map(normalizeModuleInfoLookupValue)
+    .filter((value): value is string => Boolean(value));
+
+  return entryValues.some((entryValue) =>
+    Array.from(lookupValues).some(
+      (lookupValue) =>
+        entryValue === lookupValue ||
+        entryValue.startsWith(`${lookupValue}:`) ||
+        entryValue.includes(`:${lookupValue}`) ||
+        (lookupValue.startsWith('http') && entryValue.includes(lookupValue)),
+    ),
+  );
+}
+
+function getModuleInfoCaptureReason(
+  report: ObservabilityReport,
+): string | undefined {
+  const text = [
+    report.errorCode,
+    report.errorName,
+    report.errorMessage,
+    report.summary.error?.errorCode,
+    report.summary.error?.errorName,
+    report.summary.error?.errorMessage,
+    ...report.events.flatMap((event) => [
+      event.errorCode,
+      event.errorName,
+      event.errorMessage,
+      event.message,
+      event.lifecycle,
+    ]),
+  ].join('\n');
+
+  if (/RUNTIME-007/.test(text)) {
+    return 'remote-snapshot';
+  }
+  if (/RUNTIME-011/.test(text)) {
+    return 'remote-entry-missing-in-snapshot';
+  }
+  if (/moduleInfo|module info/i.test(text)) {
+    return 'module-info';
+  }
+  if (/remote snapshot|global snapshot|snapshot/i.test(text)) {
+    return 'remote-snapshot';
+  }
+
+  return undefined;
+}
+
+function createModuleInfoSummary(
+  report: ObservabilityReport,
+): ObservabilityModuleInfoSummary | undefined {
+  const reason = getModuleInfoCaptureReason(report);
+  if (!reason) {
+    return undefined;
+  }
+
+  const moduleInfo = getFederationGlobal()?.moduleInfo;
+  const rawEntries = isRecord(moduleInfo) ? Object.entries(moduleInfo) : [];
+  const clippedEntries = rawEntries
+    .map(([name, value]) => createClippedModuleInfoEntry(name, value))
+    .filter((entry): entry is ObservabilityModuleInfoEntry => Boolean(entry));
+  const lookupValues = getModuleInfoLookupValues(report);
+  const matchedEntries = clippedEntries.filter((entry) =>
+    matchesModuleInfoLookup(entry, lookupValues),
+  );
+
+  return {
+    reason,
+    clipped: true,
+    totalCount: rawEntries.length,
+    matchedCount: matchedEntries.length,
+    entries: matchedEntries.slice(0, MAX_MODULE_INFO_ENTRIES),
+    availableNames: matchedEntries.length
+      ? undefined
+      : clippedEntries
+          .map((entry) => entry.name)
+          .slice(0, MAX_MODULE_INFO_ENTRIES),
+  };
+}
+
+function getResourceErrorType(
+  event: Pick<
+    ObservabilityEvent,
+    'errorCode' | 'errorMessage' | 'message' | 'lifecycle'
+  >,
+): string | undefined {
+  const text = `${event.errorMessage || ''}\n${event.message || ''}`;
+
+  if (!event.errorCode && !text) {
+    return undefined;
+  }
+
+  if (/ScriptExecutionError/i.test(text)) {
+    return 'script-execution';
+  }
+
+  if (/timeout|timed out/i.test(text)) {
+    return 'timeout';
+  }
+
+  if (
+    /ScriptNetworkError|NetworkError|Failed to fetch|Request failed|ERR_|404|CORS/i.test(
+      text,
+    )
+  ) {
+    return 'network';
+  }
+
+  return event.errorCode === 'RUNTIME-008' ? 'unknown' : undefined;
+}
+
+function getOwnerHint(
+  event: Pick<
+    ObservabilityEvent,
+    | 'errorCode'
+    | 'phase'
+    | 'shared'
+    | 'remote'
+    | 'errorMessage'
+    | 'message'
+    | 'lifecycle'
+  >,
+): ObservabilityOwnerHint | undefined {
+  const resourceErrorType = getResourceErrorType(event);
+
+  switch (event.errorCode) {
+    case 'RUNTIME-001':
+    case 'RUNTIME-002':
+    case 'RUNTIME-011':
+    case 'RUNTIME-013':
+    case 'RUNTIME-014':
+    case 'RUNTIME-015':
+      return 'remote';
+    case 'RUNTIME-003':
+    case 'RUNTIME-004':
+    case 'RUNTIME-007':
+      return 'host';
+    case 'RUNTIME-005':
+    case 'RUNTIME-006':
+    case 'RUNTIME-012':
+      return 'shared';
+    case 'RUNTIME-008':
+      return resourceErrorType === 'network' || resourceErrorType === 'timeout'
+        ? 'network'
+        : 'remote';
+    default:
+      if (event.shared) {
+        return 'shared';
+      }
+      if (event.remote) {
+        return 'remote';
+      }
+      if (event.phase === 'manifest' || event.phase === 'matchRemote') {
+        return 'host';
+      }
+      return event.errorCode ? 'runtime' : undefined;
+  }
+}
+
+function getRetryable(
+  event: Pick<
+    ObservabilityEvent,
+    'errorCode' | 'errorMessage' | 'message' | 'lifecycle'
+  >,
+): boolean | undefined {
+  const resourceErrorType = getResourceErrorType(event);
+
+  if (event.errorCode === 'RUNTIME-008') {
+    return resourceErrorType === 'network' || resourceErrorType === 'timeout';
+  }
+
+  if (event.errorCode === 'RUNTIME-003') {
+    const text = `${event.errorMessage || ''}\n${event.message || ''}`;
+    return /NetworkError|Failed to fetch|Request failed|timeout|timed out/i.test(
+      text,
+    );
+  }
+
+  if (
+    event.errorCode &&
+    [
+      'RUNTIME-001',
+      'RUNTIME-002',
+      'RUNTIME-004',
+      'RUNTIME-005',
+      'RUNTIME-006',
+      'RUNTIME-011',
+      'RUNTIME-012',
+      'RUNTIME-013',
+      'RUNTIME-014',
+      'RUNTIME-015',
+    ].includes(event.errorCode)
+  ) {
+    return false;
+  }
+
+  return undefined;
+}
+
+function createErrorContext(
+  event: ObservabilityEvent,
+  inputContext?: Record<string, unknown>,
+): ObservabilityMetadata | undefined {
+  const context: Record<string, unknown> = {
+    ...inputContext,
+  };
+
+  if (event.lifecycle) {
+    context.lifecycle = event.lifecycle;
+  }
+  if (event.requestId) {
+    context.requestId = event.requestId;
+  }
+  if (event.remote?.name) {
+    context.remoteName = event.remote.name;
+  }
+  if (event.remote?.alias) {
+    context.remoteAlias = event.remote.alias;
+  }
+  if (event.remote?.type) {
+    context.remoteType = event.remote.type;
+  }
+  if (event.remote?.entryGlobalName) {
+    context.entryGlobalName = event.remote.entryGlobalName;
+  }
+  if (event.sanitizedUrl) {
+    context.url = event.sanitizedUrl;
+  }
+  if (event.expose) {
+    context.expose = event.expose;
+  }
+  if (event.shared?.name) {
+    context.shareName = event.shared.name;
+  }
+  if (event.shared?.requiredVersion) {
+    context.requiredVersion = event.shared.requiredVersion;
+  }
+  if (event.shared?.selectedVersion) {
+    context.selectedVersion = event.shared.selectedVersion;
+  }
+  if (event.shared?.provider) {
+    context.provider = event.shared.provider;
+  }
+
+  const resourceErrorType = getResourceErrorType(event);
+  if (resourceErrorType) {
+    context.resourceErrorType = resourceErrorType;
+  }
+
+  return clipObservabilityMetadata(context);
+}
+
+export function ObservabilityPlugin(
+  options: ObservabilityPluginOptions = {},
+): ObservabilityController {
+  const level = options.level || 'summary';
+  const configuredMaxEvents = normalizeMaxEvents(
+    options.maxEvents,
+    DEFAULT_MAX_EVENTS,
+  );
+  const events: ObservabilityEvent[] = [];
+  const reports = new Map<string, ObservabilityReport>();
+  const traceByRequest = new Map<string, string>();
+  const traceByRemote = new Map<string, string>();
+  const phaseStartTimes = new Map<string, number>();
+  const seenManifestUrls = new Set<string>();
+  const seenRemoteEntryKeys = new Set<string>();
+  const consoleReportedTraceIds = new Set<string>();
+  let latestTraceId: string | undefined;
+  let runtimeObservabilityEnabled = false;
+  let effectiveMaxEvents = configuredMaxEvents;
+  let browserGlobalScope: string | undefined;
+  let lastRuntimeOrigin: ObservabilityRuntimeOrigin | undefined;
+
+  const isEnabled = () => {
+    if (options.enabled === false) {
+      return false;
+    }
+
+    runtimeObservabilityEnabled = true;
+    return true;
+  };
+
+  const resolveTraceId = (event: ObservabilityRuntimeEventInput) => {
+    const sanitizedRequestId = sanitizeRequestId(event.requestId);
+
+    if (event.traceId && reports.has(event.traceId)) {
+      return event.traceId;
+    }
+
+    if (event.status === 'start' && event.phase === 'loadRemote') {
+      const traceId = event.traceId || createTraceId(event);
+      if (sanitizedRequestId) {
+        traceByRequest.set(sanitizedRequestId, traceId);
+      }
+      if (event.remote?.name) {
+        traceByRemote.set(event.remote.name, traceId);
+      }
+      return traceId;
+    }
+
+    if (sanitizedRequestId) {
+      const traceId = traceByRequest.get(sanitizedRequestId);
+      if (traceId) {
+        return traceId;
+      }
+    }
+
+    if (event.remote?.name) {
+      const traceId = traceByRemote.get(event.remote.name);
+      if (traceId) {
+        return traceId;
+      }
+    }
+
+    return event.traceId || createTraceId(event);
+  };
+
+  const normalizeEvent = (
+    event: ObservabilityRuntimeEventInput,
+    traceId: string,
+    origin?: ObservabilityRuntimeOrigin,
+  ): ObservabilityEvent => {
+    const errorInfo = getErrorInfo(event.error, options.stackTrace);
+    const sanitizedRemote = sanitizeRemote(event.remote);
+    const sanitizedShared = sanitizeShared(event.shared);
+    const hostName =
+      sanitizeText(event.hostName, 120) ||
+      sanitizeText(origin?.options?.name, 120);
+    const message = getRawText(event.message) || errorInfo.errorMessage;
+
+    const normalizedEvent: ObservabilityEvent = {
+      traceId,
+      timestamp: event.timestamp || Date.now(),
+      phase: sanitizeText(event.phase, 120) || 'runtime',
+      status: event.status,
+      requestId: sanitizeRequestId(event.requestId),
+      hostName,
+      remote: sanitizedRemote,
+      shared: sanitizedShared,
+      expose: sanitizeText(event.expose, 240),
+      sanitizedUrl: clipText(event.url || event.remote?.entry, 320),
+      message,
+      errorCode: errorInfo.errorCode,
+      errorName: errorInfo.errorName,
+      errorMessage: errorInfo.errorMessage,
+      errorStack: errorInfo.errorStack,
+      duration:
+        typeof event.duration === 'number' && Number.isFinite(event.duration)
+          ? Math.max(0, event.duration)
+          : undefined,
+      lifecycle: sanitizeText(event.lifecycle, 120),
+      eventName: sanitizeText(event.eventName, 160),
+      source: normalizeEventSource(event.source),
+      recovered: event.recovered === true || undefined,
+      cached: event.cached === true || undefined,
+      componentName: sanitizeText(event.componentName, 160),
+      metadata: clipObservabilityMetadata(event.metadata),
+    };
+
+    if (normalizedEvent.status === 'error' || event.error) {
+      normalizedEvent.ownerHint = getOwnerHint(normalizedEvent);
+      normalizedEvent.retryable = getRetryable(normalizedEvent);
+      normalizedEvent.errorContext = createErrorContext(
+        normalizedEvent,
+        event.errorContext,
+      );
+    }
+
+    return normalizedEvent;
+  };
+
+  const applyPhaseDuration = (event: ObservabilityEvent) => {
+    const key = getPhaseDurationKey(event);
+
+    if (event.status === 'start') {
+      phaseStartTimes.set(key, event.timestamp);
+      return;
+    }
+
+    if (event.duration !== undefined) {
+      return;
+    }
+
+    const startedAt = phaseStartTimes.get(key);
+    if (startedAt === undefined) {
+      return;
+    }
+
+    event.duration = Math.max(0, event.timestamp - startedAt);
+    phaseStartTimes.delete(key);
+  };
+
+  const updateTraceMaps = (event: ObservabilityEvent) => {
+    if (event.requestId) {
+      traceByRequest.set(event.requestId, event.traceId);
+    }
+
+    if (event.remote?.name) {
+      traceByRemote.set(event.remote.name, event.traceId);
+    }
+  };
+
+  const trimEvents = (report: ObservabilityReport) => {
+    while (events.length > effectiveMaxEvents) {
+      events.shift();
+    }
+
+    while (report.events.length > effectiveMaxEvents) {
+      report.events.shift();
+    }
+  };
+
+  const getEventOutcome = (event: ObservabilityEvent) => {
+    if (event.status === 'success') {
+      return 'success';
+    }
+
+    if (event.status === 'error') {
+      return 'error';
+    }
+
+    if (event.status === 'complete') {
+      if (event.recovered) {
+        return 'recovered';
+      }
+
+      if (event.errorName || event.errorMessage) {
+        return 'error';
+      }
+    }
+
+    return undefined;
+  };
+
+  const isLoadRemoteCompleteEvent = (event: ObservabilityEvent) =>
+    event.phase === 'loadRemote' && event.status === 'complete';
+
+  const isRuntimeLoadedEvent = (event: ObservabilityEvent) =>
+    event.phase === 'loadRemote' &&
+    (event.status === 'success' ||
+      (event.status === 'complete' && event.recovered));
+
+  const isComponentLoadedEvent = (event: ObservabilityEvent) =>
+    event.status === 'success' &&
+    (event.eventName === COMPONENT_BUSINESS_LOADED_EVENT ||
+      (event.phase === 'component' &&
+        event.message === COMPONENT_BUSINESS_LOADED_EVENT));
+
+  const shouldReplaceFailedPhase = (
+    report: ObservabilityReport,
+    event: ObservabilityEvent,
+  ) => {
+    if (isLoadRemoteCompleteEvent(event) && report.failedPhase) {
+      return false;
+    }
+
+    if (!report.failedPhase) {
+      return true;
+    }
+
+    return report.failedPhase === 'loadRemote' && event.phase !== 'loadRemote';
+  };
+
+  const createEmptyPhaseCollection = (): ObservabilityPhaseCollection => ({
+    phases: {},
+    flags: {
+      cached: false,
+      retried: false,
+      fallback: false,
+      recovered: false,
+    },
+  });
+
+  const createPhaseCollection = (
+    eventsForReport: ObservabilityEvent[],
+  ): ObservabilityPhaseCollection => {
+    const collection = createEmptyPhaseCollection();
+
+    eventsForReport.forEach((event) => {
+      const phase = event.phase;
+      const phaseSummary =
+        collection.phases[phase] ||
+        ({
+          status: event.status,
+        } satisfies ObservabilityPhaseSummary);
+
+      if (event.status !== 'start') {
+        phaseSummary.status = event.status;
+      }
+      if (event.duration !== undefined) {
+        phaseSummary.duration = event.duration;
+      }
+      if (event.cached) {
+        phaseSummary.cached = true;
+        collection.flags.cached = true;
+      }
+      if (event.recovered) {
+        phaseSummary.recovered = true;
+        collection.flags.recovered = true;
+      }
+      if (event.lifecycle) {
+        phaseSummary.lifecycle = event.lifecycle;
+      }
+
+      collection.phases[phase] = phaseSummary;
+
+      if (event.phase === 'remoteEntry' && event.recovered) {
+        collection.flags.retried = true;
+      }
+      if (
+        event.phase === 'loadRemote' &&
+        event.status === 'complete' &&
+        event.recovered
+      ) {
+        collection.flags.fallback = true;
+      }
+      if (event.shared?.selectedVersion || event.shared?.provider) {
+        collection.shared = {
+          name: event.shared.name,
+          provider: event.shared.provider,
+          selectedVersion: event.shared.selectedVersion,
+          shareScope: event.shared.shareScope
+            ? [...event.shared.shareScope]
+            : undefined,
+        };
+      }
+    });
+
+    return collection;
+  };
+
+  const createErrorSummary = (
+    eventsForReport: ObservabilityEvent[],
+    failedPhase?: string,
+  ): ObservabilityErrorSummary | undefined => {
+    const errorEvent =
+      eventsForReport.find(
+        (event) => event.status === 'error' && event.phase === failedPhase,
+      ) ||
+      eventsForReport.find((event) => event.status === 'error') ||
+      eventsForReport.find(
+        (event) => event.status === 'complete' && event.errorMessage,
+      );
+
+    if (!errorEvent) {
+      return undefined;
+    }
+
+    return {
+      errorCode: errorEvent.errorCode,
+      errorName: errorEvent.errorName,
+      errorMessage: errorEvent.errorMessage,
+      failedPhase: failedPhase || errorEvent.phase,
+      lifecycle: errorEvent.lifecycle,
+      ownerHint: errorEvent.ownerHint,
+      retryable: errorEvent.retryable,
+      context: errorEvent.errorContext
+        ? { ...errorEvent.errorContext }
+        : undefined,
+    };
+  };
+
+  const createReportSummary = (
+    report: ObservabilityReport,
+  ): ObservabilityReport['summary'] => {
+    const loadCompleted = report.events.some(isLoadRemoteCompleteEvent);
+    const runtimeLoaded = report.events.some(isRuntimeLoadedEvent);
+    const recovered = report.events.some((item) => item.recovered);
+    const componentLoaded = report.events.some(isComponentLoadedEvent);
+    const lastEvent = report.events[report.events.length - 1];
+    let outcome: ObservabilityReportOutcome = 'pending';
+
+    if (componentLoaded) {
+      outcome = 'component-loaded';
+    } else if (recovered && runtimeLoaded) {
+      outcome = 'recovered';
+    } else if (report.status === 'error') {
+      outcome = 'failed';
+    } else if (runtimeLoaded) {
+      outcome = 'runtime-loaded';
+    }
+
+    const phaseCollection = createPhaseCollection(report.events);
+
+    return {
+      eventCount: report.events.length,
+      recovered,
+      loadCompleted,
+      runtimeLoaded,
+      componentLoaded,
+      outcome,
+      lastPhase: lastEvent?.phase,
+      phases: phaseCollection.phases,
+      shared: phaseCollection.shared,
+      flags: phaseCollection.flags,
+      error: createErrorSummary(report.events, report.failedPhase),
+    };
+  };
+
+  const refreshModuleInfoSummary = (report: ObservabilityReport) => {
+    const moduleInfo = createModuleInfoSummary(report);
+    if (moduleInfo) {
+      report.moduleInfo = moduleInfo;
+    }
+  };
+
+  const getReportContext = (
+    report: ObservabilityReport,
+  ): ObservabilityMetadata | undefined =>
+    report.summary.error?.context || report.errorContext;
+
+  const getContextText = (
+    context: ObservabilityMetadata | undefined,
+    key: string,
+  ): string | undefined => {
+    const value = context?.[key];
+    return typeof value === 'string' && value ? value : undefined;
+  };
+
+  const getDiagnosisOwnerHint = (
+    report: ObservabilityReport,
+  ): ObservabilityOwnerHint =>
+    report.summary.error?.ownerHint ||
+    report.ownerHint ||
+    (report.shared ? 'shared' : report.remote ? 'remote' : 'unknown');
+
+  const getDiagnosisResourceErrorType = (
+    report: ObservabilityReport,
+  ): string | undefined =>
+    getContextText(getReportContext(report), 'resourceErrorType') ||
+    getResourceErrorType({
+      errorCode: report.errorCode,
+      errorMessage: report.errorMessage,
+      message: report.events.at(-1)?.message,
+      lifecycle: report.summary.error?.lifecycle,
+    });
+
+  const getDiagnosisDocLink = (
+    report: ObservabilityReport,
+  ): string | undefined => {
+    const text = [
+      report.errorMessage,
+      report.errorStack,
+      ...report.events.flatMap((event) => [
+        event.errorMessage,
+        event.errorStack,
+        event.message,
+      ]),
+    ]
+      .filter((item): item is string => Boolean(item))
+      .join('\n');
+    const matched = text.match(DIAGNOSTIC_DOC_LINK_PATTERN)?.[0];
+    const docLink = sanitizeText(matched, 240);
+
+    if (docLink) {
+      return docLink;
+    }
+
+    return report.errorCode?.startsWith('RUNTIME-')
+      ? RUNTIME_DOC_LINK
+      : undefined;
+  };
+
+  const getDiagnosisTitle = (report: ObservabilityReport) => {
+    if (report.status !== 'error') {
+      if (report.summary.componentLoaded) {
+        return 'Business component loaded';
+      }
+      if (report.summary.runtimeLoaded) {
+        return 'Remote loaded successfully';
+      }
+      return 'Remote loading is pending';
+    }
+
+    switch (report.errorCode) {
+      case 'RUNTIME-001':
+        return 'Remote entry global was not registered';
+      case 'RUNTIME-003':
+        return 'Manifest could not be loaded';
+      case 'RUNTIME-004':
+        return 'Remote was not found in host remotes';
+      case 'RUNTIME-007':
+        return 'Deployment moduleInfo did not match the requested remote';
+      case 'RUNTIME-013':
+        return 'Manifest is not a valid Module Federation manifest';
+      case 'RUNTIME-014':
+        return 'Requested expose was not found in the remote';
+      case 'RUNTIME-015':
+        return 'Remote container initialization failed';
+      case 'RUNTIME-005':
+      case 'RUNTIME-006':
+        return 'Shared dependency could not be resolved';
+      case 'RUNTIME-008': {
+        const resourceErrorType = getDiagnosisResourceErrorType(report);
+        if (resourceErrorType === 'network') {
+          return 'Remote entry failed because of a network error';
+        }
+        if (resourceErrorType === 'timeout') {
+          return 'Remote entry request timed out';
+        }
+        if (resourceErrorType === 'script-execution') {
+          return 'Remote entry loaded but failed during execution';
+        }
+        return 'Remote entry resource could not be loaded';
+      }
+      default:
+        if (report.failedPhase === 'shared' || report.shared) {
+          return 'Shared dependency could not be resolved';
+        }
+        return report.failedPhase
+          ? `Module Federation failed at ${report.failedPhase}`
+          : 'Module Federation loading failed';
+    }
+  };
+
+  const getCompletedPhases = (report: ObservabilityReport) =>
+    Array.from(
+      new Set(
+        report.events
+          .filter(
+            (event) =>
+              event.status === 'success' || event.status === 'complete',
+          )
+          .map((event) => event.phase),
+      ),
+    );
+
+  const getPendingPhases = (report: ObservabilityReport) => {
+    const started = new Set<string>();
+    const ended = new Set<string>();
+
+    report.events.forEach((event) => {
+      if (event.status === 'start') {
+        started.add(event.phase);
+        return;
+      }
+
+      ended.add(event.phase);
+    });
+
+    return Array.from(started).filter((phase) => !ended.has(phase));
+  };
+
+  const createDiagnosisFacts = (
+    report: ObservabilityReport,
+    ownerHint: ObservabilityOwnerHint,
+  ): ObservabilityMetadata => {
+    const context = getReportContext(report);
+    const facts: Record<string, unknown> = {};
+    const addFact = (key: string, value: unknown) => {
+      if (value === undefined || value === null || value === '') {
+        return;
+      }
+
+      facts[key] = Array.isArray(value) ? value.join(',') : value;
+    };
+
+    addFact('traceId', report.traceId);
+    addFact('status', report.status);
+    addFact('outcome', report.summary.outcome);
+    addFact('errorCode', report.errorCode || report.summary.error?.errorCode);
+    addFact(
+      'failedPhase',
+      report.failedPhase || report.summary.error?.failedPhase,
+    );
+    addFact('lifecycle', report.summary.error?.lifecycle);
+    addFact('ownerHint', ownerHint);
+    addFact('retryable', report.retryable ?? report.summary.error?.retryable);
+    addFact('requestId', report.requestId);
+    addFact('hostName', report.hostName);
+    addFact('remoteName', report.remote?.name);
+    addFact('remoteAlias', report.remote?.alias);
+    addFact('remoteEntry', report.remote?.entry);
+    addFact('entryGlobalName', report.remote?.entryGlobalName);
+    addFact('remoteType', report.remote?.type);
+    addFact('url', report.sanitizedUrl || getContextText(context, 'url'));
+    addFact('expose', report.expose);
+    addFact('hostRemotes', getContextText(context, 'hostRemotes'));
+    addFact('resourceErrorType', getDiagnosisResourceErrorType(report));
+    addFact('shareName', report.shared?.name);
+    addFact('shareScope', report.shared?.shareScope);
+    addFact('requiredVersion', report.shared?.requiredVersion);
+    addFact('selectedVersion', report.shared?.selectedVersion);
+    addFact('availableVersions', report.shared?.availableVersions);
+    addFact('provider', report.shared?.provider);
+    addFact('sharedFrom', report.shared?.from);
+    addFact('singleton', report.shared?.singleton);
+    addFact('strictVersion', report.shared?.strictVersion);
+    addFact('eager', report.shared?.eager);
+    addFact('sharedReason', report.shared?.reason);
+    addFact(
+      'componentName',
+      report.events.find(isComponentLoadedEvent)?.componentName,
+    );
+    addFact('moduleInfoReason', report.moduleInfo?.reason);
+    addFact('moduleInfoTotalCount', report.moduleInfo?.totalCount);
+    addFact('moduleInfoMatchedCount', report.moduleInfo?.matchedCount);
+    addFact(
+      'moduleInfoNames',
+      report.moduleInfo?.entries.length
+        ? report.moduleInfo.entries.map((entry) => entry.name)
+        : report.moduleInfo?.availableNames,
+    );
+    addFact('cached', report.summary.flags.cached);
+    addFact('retried', report.summary.flags.retried);
+    addFact('fallback', report.summary.flags.fallback);
+    addFact('recovered', report.summary.recovered);
+    addFact('loadCompleted', report.summary.loadCompleted);
+    addFact('runtimeLoaded', report.summary.runtimeLoaded);
+    addFact('componentLoaded', report.summary.componentLoaded);
+
+    return clipMetadata(facts, MAX_FACT_KEYS) || {};
+  };
+
+  const createDiagnosisWarnings = (report: ObservabilityReport) => {
+    const warnings: string[] = [];
+
+    if (report.status === 'error' && !report.errorCode) {
+      warnings.push('No known Module Federation error code was captured');
+    }
+    if (report.summary.flags.retried) {
+      warnings.push('Remote entry loading recovered after retry');
+    }
+    if (report.summary.flags.fallback) {
+      warnings.push('Remote loading completed through fallback recovery');
+    }
+    if (report.summary.runtimeLoaded && !report.summary.componentLoaded) {
+      warnings.push('Business component readiness signal was not recorded');
+    }
+    if (report.moduleInfo && report.moduleInfo.matchedCount === 0) {
+      warnings.push(
+        'No matching clipped moduleInfo entry was found for the failed remote',
+      );
+    }
+
+    return warnings;
+  };
+
+  const createDiagnosisActions = (
+    report: ObservabilityReport,
+    ownerHint: ObservabilityOwnerHint,
+  ): ObservabilityAction[] => {
+    const actions: ObservabilityAction[] = [];
+    const pushAction = (
+      id: ObservabilityActionId,
+      title: string,
+      hint: ObservabilityOwnerHint = ownerHint,
+      detail?: string,
+    ) => {
+      actions.push({
+        id,
+        ownerHint: hint,
+        title,
+        detail,
+      });
+    };
+
+    if (report.status !== 'error' && !report.summary.error) {
+      return actions;
+    }
+
+    switch (report.errorCode) {
+      case 'RUNTIME-001':
+        pushAction(
+          'check-remote-global',
+          'Check the remote global name against the remoteEntry build output',
+          'remote',
+        );
+        pushAction(
+          'check-remote-entry',
+          'Check that remoteEntry registers the expected container',
+          'remote',
+        );
+        break;
+      case 'RUNTIME-003':
+        pushAction(
+          'check-manifest-url',
+          'Check the manifest URL and manifest JSON response',
+          'host',
+        );
+        pushAction(
+          'check-network',
+          'Check network availability, CORS, and timeout for the manifest',
+          'network',
+        );
+        break;
+      case 'RUNTIME-013':
+        pushAction(
+          'check-manifest-url',
+          'Check that the manifest response is valid Module Federation JSON',
+          'remote',
+        );
+        break;
+      case 'RUNTIME-004':
+        pushAction(
+          'check-host-remotes',
+          'Check that the requested remote exists in host remotes',
+          'host',
+        );
+        break;
+      case 'RUNTIME-007':
+        pushAction(
+          'check-module-info',
+          'Check deployment-provided __FEDERATION__.moduleInfo for the requested remote',
+          'host',
+        );
+        pushAction(
+          'check-host-remotes',
+          'Check that the runtime remote name or alias matches moduleInfo',
+          'host',
+        );
+        break;
+      case 'RUNTIME-014':
+        pushAction(
+          'check-expose',
+          'Check that the requested expose exists in the remote build output',
+          'remote',
+        );
+        break;
+      case 'RUNTIME-015':
+        pushAction(
+          'check-remote-entry',
+          'Check the error thrown during remoteEntry init',
+          'remote',
+        );
+        pushAction(
+          'check-shared-provider',
+          'Check share scope initialization data passed to the remote',
+          'shared',
+        );
+        break;
+      case 'RUNTIME-005':
+      case 'RUNTIME-006':
+        pushAction(
+          'check-shared-provider',
+          'Check that a compatible shared provider is available',
+          'shared',
+        );
+        pushAction(
+          'check-shared-version',
+          'Compare requested shared version with available versions',
+          'shared',
+        );
+        if (
+          report.summary.error?.lifecycle === 'loadShareSync' ||
+          report.shared?.reason === 'sync-async-boundary' ||
+          report.shared?.eager === false
+        ) {
+          pushAction(
+            'check-eager-config',
+            'Check eager configuration or add an async boundary before sync shared consumption',
+            'shared',
+          );
+        }
+        break;
+      case 'RUNTIME-008': {
+        const resourceErrorType = getDiagnosisResourceErrorType(report);
+        if (
+          resourceErrorType === 'network' ||
+          resourceErrorType === 'timeout'
+        ) {
+          pushAction(
+            'check-network',
+            'Check remoteEntry URL, CORS, status code, and timeout',
+            'network',
+          );
+        }
+        pushAction(
+          'check-remote-entry',
+          resourceErrorType === 'script-execution'
+            ? 'Check remoteEntry execution errors in the remote build output'
+            : 'Check that remoteEntry is reachable and serves JavaScript',
+          resourceErrorType === 'network' || resourceErrorType === 'timeout'
+            ? 'network'
+            : 'remote',
+        );
+        break;
+      }
+      default:
+        if (report.failedPhase === 'manifest') {
+          pushAction(
+            'check-manifest-url',
+            'Check manifest loading and parsing',
+            'host',
+          );
+        }
+        if (report.failedPhase === 'remoteEntry') {
+          pushAction(
+            'check-remote-entry',
+            'Check remoteEntry loading and initialization',
+            'remote',
+          );
+        }
+        if (report.failedPhase === 'expose') {
+          pushAction(
+            'check-expose',
+            'Check that the requested expose exists in the remote',
+            'remote',
+          );
+        }
+        if (report.failedPhase === 'shared') {
+          pushAction(
+            'check-shared-provider',
+            'Check shared dependency resolution',
+            'shared',
+          );
+          if (
+            report.shared?.requiredVersion !== undefined ||
+            report.shared?.availableVersions?.length ||
+            report.shared?.reason === 'version-mismatch'
+          ) {
+            pushAction(
+              'check-shared-version',
+              'Compare requested shared version with available versions',
+              'shared',
+            );
+          }
+          if (
+            report.summary.error?.lifecycle === 'loadShareSync' ||
+            report.shared?.reason === 'sync-async-boundary' ||
+            report.shared?.eager === false
+          ) {
+            pushAction(
+              'check-eager-config',
+              'Check eager configuration or add an async boundary before sync shared consumption',
+              'shared',
+            );
+          }
+        }
+    }
+
+    if (
+      report.moduleInfo &&
+      !actions.some((action) => action.id === 'check-module-info')
+    ) {
+      pushAction(
+        'check-module-info',
+        'Check deployment-provided __FEDERATION__.moduleInfo for the requested remote',
+        'host',
+      );
+    }
+
+    if (!actions.length) {
+      pushAction(
+        'inspect-runtime-events',
+        'Inspect the ordered observability events for the failed phase',
+        ownerHint,
+      );
+    }
+
+    return actions;
+  };
+
+  const createFactReport = (
+    report: ObservabilityReport,
+  ): ObservabilityFactReport => {
+    const ownerHint = getDiagnosisOwnerHint(report);
+    const warnings = createDiagnosisWarnings(report);
+
+    return {
+      title: getDiagnosisTitle(report),
+      outcome: report.summary.outcome,
+      status: report.status,
+      ownerHint,
+      failedPhase: report.failedPhase || report.summary.error?.failedPhase,
+      errorCode: report.errorCode || report.summary.error?.errorCode,
+      errorName: report.errorName || report.summary.error?.errorName,
+      errorMessage: report.errorMessage || report.summary.error?.errorMessage,
+      docLink: getDiagnosisDocLink(report),
+      facts: createDiagnosisFacts(report, ownerHint),
+      completedPhases: getCompletedPhases(report),
+      pendingPhases: getPendingPhases(report),
+      warnings: warnings.length ? warnings : undefined,
+      actions: createDiagnosisActions(report, ownerHint),
+    };
+  };
+
+  const refreshReportDerivedFields = (report: ObservabilityReport) => {
+    report.summary = createReportSummary(report);
+    refreshModuleInfoSummary(report);
+    report.diagnosis = createFactReport(report);
+  };
+
+  const updateReport = (event: ObservabilityEvent) => {
+    let report = reports.get(event.traceId);
+
+    if (!report) {
+      report = {
+        traceId: event.traceId,
+        status: event.status === 'error' ? 'error' : 'pending',
+        requestId: event.requestId,
+        hostName: event.hostName,
+        remote: event.remote ? { ...event.remote } : undefined,
+        shared: event.shared ? copyEvent(event).shared : undefined,
+        expose: event.expose,
+        sanitizedUrl: event.sanitizedUrl,
+        startedAt: event.timestamp,
+        updatedAt: event.timestamp,
+        duration: 0,
+        failedPhase: event.status === 'error' ? event.phase : undefined,
+        errorCode: event.errorCode,
+        errorName: event.errorName,
+        errorMessage: event.errorMessage,
+        errorStack: event.errorStack,
+        ownerHint: event.ownerHint,
+        retryable: event.retryable,
+        errorContext: event.errorContext
+          ? { ...event.errorContext }
+          : undefined,
+        events: [],
+        summary: {
+          eventCount: 0,
+          recovered: false,
+          loadCompleted: false,
+          runtimeLoaded: false,
+          componentLoaded: false,
+          outcome: 'pending',
+          lastPhase: undefined,
+          phases: {},
+          shared: undefined,
+          flags: createEmptyPhaseCollection().flags,
+          error: undefined,
+        },
+      };
+      reports.set(event.traceId, report);
+    }
+
+    if (event.requestId) {
+      report.requestId = event.requestId;
+    }
+    if (event.hostName) {
+      report.hostName = event.hostName;
+    }
+    if (event.remote) {
+      report.remote = { ...event.remote };
+    }
+    if (event.shared) {
+      report.shared = copyEvent(event).shared;
+    }
+    if (event.expose) {
+      report.expose = event.expose;
+    }
+    if (event.sanitizedUrl) {
+      report.sanitizedUrl = event.sanitizedUrl;
+    }
+    if (event.errorStack) {
+      report.errorStack = event.errorStack;
+    }
+    if (event.errorCode) {
+      report.errorCode = event.errorCode;
+    }
+    if (event.errorName) {
+      report.errorName = event.errorName;
+    }
+    if (event.errorMessage) {
+      report.errorMessage = event.errorMessage;
+    }
+    if (event.ownerHint) {
+      report.ownerHint = event.ownerHint;
+    }
+    if (event.retryable !== undefined) {
+      report.retryable = event.retryable;
+    }
+    if (event.errorContext) {
+      report.errorContext = { ...event.errorContext };
+    }
+
+    report.events.push(event);
+    report.updatedAt = event.timestamp;
+    report.duration = Math.max(0, report.updatedAt - report.startedAt);
+
+    const eventOutcome = getEventOutcome(event);
+
+    if (eventOutcome === 'error') {
+      report.status = 'error';
+      if (shouldReplaceFailedPhase(report, event)) {
+        report.failedPhase = event.phase;
+      }
+    } else if (eventOutcome === 'recovered') {
+      report.status = 'success';
+    } else if (eventOutcome === 'success' && report.status !== 'error') {
+      report.status = 'success';
+    }
+
+    refreshReportDerivedFields(report);
+
+    latestTraceId = event.traceId;
+    trimEvents(report);
+    return report;
+  };
+
+  const notifyEvent = (
+    event: ObservabilityEvent,
+    report: ObservabilityReport,
+    origin?: ObservabilityRuntimeOrigin,
+  ) => {
+    try {
+      options.onEvent?.(copyEvent(event), copyReport(report), { origin });
+    } catch {
+      // Observability callbacks must not affect Module Federation loading.
+    }
+  };
+
+  const notifyReport = (
+    report: ObservabilityReport,
+    origin?: ObservabilityRuntimeOrigin,
+  ) => {
+    if (report.events[report.events.length - 1]?.status === 'start') {
+      return;
+    }
+
+    try {
+      options.onReport?.(copyReport(report), { origin });
+    } catch {
+      // Observability callbacks must not affect Module Federation loading.
+    }
+  };
+
+  const notifyRawError = (
+    errorValue: unknown,
+    event: ObservabilityEvent,
+    report: ObservabilityReport,
+    origin?: ObservabilityRuntimeOrigin,
+  ) => {
+    if (!errorValue || !options.onRawError) {
+      return;
+    }
+
+    try {
+      options.onRawError(errorValue, {
+        origin,
+        event: copyEvent(event),
+        report: copyReport(report),
+      });
+    } catch {
+      // Raw error callbacks must not affect Module Federation loading.
+    }
+  };
+
+  const getEventsSnapshot = () => events.map(copyEvent);
+
+  const getTraceIdsSnapshot = () => Array.from(reports.keys());
+
+  const getReportTimeline = () =>
+    Array.from(reports.values()).sort((left, right) => {
+      if (right.updatedAt !== left.updatedAt) {
+        return right.updatedAt - left.updatedAt;
+      }
+
+      return right.startedAt - left.startedAt;
+    });
+
+  const matchesReportValue = (
+    value: string | undefined,
+    expected: string | undefined,
+  ) => {
+    if (!value || !expected) {
+      return false;
+    }
+
+    const normalizedValue = value.toLowerCase();
+    const normalizedExpected = expected.toLowerCase();
+
+    return (
+      normalizedValue === normalizedExpected ||
+      normalizedValue.includes(normalizedExpected)
+    );
+  };
+
+  const matchesReportQuery = (
+    report: ObservabilityReport,
+    query: ObservabilityReportQuery,
+  ) => {
+    if (query.traceId && report.traceId !== query.traceId) {
+      return false;
+    }
+    if (query.status && report.status !== query.status) {
+      return false;
+    }
+    if (query.outcome && report.summary.outcome !== query.outcome) {
+      return false;
+    }
+    if (
+      query.remote &&
+      ![
+        report.remote?.name,
+        report.remote?.alias,
+        report.remote?.entry,
+        report.requestId,
+        report.sanitizedUrl,
+      ].some((value) => matchesReportValue(value, query.remote))
+    ) {
+      return false;
+    }
+    if (
+      query.expose &&
+      ![report.expose, report.requestId].some((value) =>
+        matchesReportValue(value, query.expose),
+      )
+    ) {
+      return false;
+    }
+    if (
+      query.shared &&
+      ![report.shared?.name].some((value) =>
+        matchesReportValue(value, query.shared),
+      )
+    ) {
+      return false;
+    }
+
+    return true;
+  };
+
+  const getReportsSnapshot = (options: ObservabilityReportListOptions = {}) => {
+    const limit = normalizeQueryLimit(options.limit);
+    const timeline = getReportTimeline();
+
+    return (limit ? timeline.slice(0, limit) : timeline).map(copyReport);
+  };
+
+  const findReportsSnapshot = (query: ObservabilityReportQuery = {}) => {
+    const limit = normalizeQueryLimit(query.limit);
+    const matchedReports = getReportTimeline().filter((report) =>
+      matchesReportQuery(report, query),
+    );
+
+    return (limit ? matchedReports.slice(0, limit) : matchedReports).map(
+      copyReport,
+    );
+  };
+
+  const getLatestReportSnapshot = () => {
+    if (!latestTraceId) {
+      return undefined;
+    }
+
+    const report = reports.get(latestTraceId);
+    return report ? copyReport(report) : undefined;
+  };
+
+  const getReportSnapshot = (traceId: string) => {
+    const report = reports.get(traceId);
+    return report ? copyReport(report) : undefined;
+  };
+
+  const exportReportSnapshot = (traceId?: string) =>
+    traceId ? getReportSnapshot(traceId) : getLatestReportSnapshot();
+
+  const createBrowserReader = (): ObservabilityBrowserReader => ({
+    getEvents: getEventsSnapshot,
+    getTraceIds: getTraceIdsSnapshot,
+    getReports: getReportsSnapshot,
+    findReports: findReportsSnapshot,
+    getLatestReport: getLatestReportSnapshot,
+    getReport: getReportSnapshot,
+    exportReport: exportReportSnapshot,
+  });
+
+  const shouldExposeBrowserGlobal = () => options.browser?.enabled === true;
+
+  const ensureBrowserGlobal = (origin?: ObservabilityRuntimeOrigin) => {
+    if (!shouldExposeBrowserGlobal()) {
+      return;
+    }
+
+    const federationGlobal = getFederationGlobal();
+    if (!federationGlobal) {
+      return;
+    }
+
+    const scope = normalizeScope(
+      options.browser?.scope || origin?.options?.name || 'default',
+    );
+    const reader = createBrowserReader();
+
+    const readers = federationGlobal.__OBSERVABILITY__ || {};
+    federationGlobal.__OBSERVABILITY__ = readers;
+    browserGlobalScope = scope;
+
+    try {
+      Object.defineProperty(readers, scope, {
+        value: reader,
+        configurable: true,
+        enumerable: true,
+      });
+    } catch {
+      readers[scope] = reader;
+    }
+  };
+
+  const shouldUseConsole = () => options.console !== false;
+
+  const shouldUseMinimalBrowserConsole = () =>
+    options.browser?.mode === 'production';
+
+  const getBrowserReadCommand = (traceId: string) => {
+    if (!browserGlobalScope) {
+      return undefined;
+    }
+
+    return `window.__FEDERATION__.__OBSERVABILITY__[${JSON.stringify(
+      browserGlobalScope,
+    )}].getReport(${JSON.stringify(traceId)})`;
+  };
+
+  const emitConsoleHint = (
+    event: ObservabilityEvent,
+    report: ObservabilityReport,
+    rawError?: unknown,
+  ) => {
+    if (
+      getEventOutcome(event) !== 'error' ||
+      !shouldUseConsole() ||
+      consoleReportedTraceIds.has(report.traceId)
+    ) {
+      return;
+    }
+
+    consoleReportedTraceIds.add(report.traceId);
+
+    if (shouldUseMinimalBrowserConsole()) {
+      const lines = [
+        '[Module Federation] Observability report generated',
+        `traceId: ${report.traceId}`,
+      ];
+
+      if (report.errorCode) {
+        lines.push(`errorCode: ${report.errorCode}`);
+      }
+
+      try {
+        console.error(lines.join('\n'));
+      } catch {
+        // Console output is best-effort observability only.
+      }
+      return;
+    }
+
+    const lines = [
+      '[Module Federation] Observability report generated',
+      `traceId: ${report.traceId}`,
+      `phase: ${report.failedPhase || event.phase}`,
+    ];
+
+    if (report.requestId) {
+      lines.push(`requestId: ${report.requestId}`);
+    }
+    if (report.errorCode) {
+      lines.push(`errorCode: ${report.errorCode}`);
+    }
+    if (report.shared?.name) {
+      lines.push(`shared: ${report.shared.name}`);
+    }
+
+    const browserReadCommand = getBrowserReadCommand(report.traceId);
+    if (browserReadCommand) {
+      lines.push(`read: ${browserReadCommand}`);
+    } else {
+      lines.push(
+        `read: observability.getReport(${JSON.stringify(report.traceId)})`,
+      );
+    }
+
+    const rawStack = getRawStack(rawError);
+    if (options.printRawStack === true && rawStack) {
+      lines.push('rawStack:', rawStack);
+    }
+
+    try {
+      console.error(lines.join('\n'));
+    } catch {
+      // Console output is best-effort observability only.
+    }
+  };
+
+  const prepareOutputChannels = (origin: ObservabilityRuntimeOrigin) => {
+    browserGlobalScope = undefined;
+    ensureBrowserGlobal(origin);
+  };
+
+  const prepareRuntimeOrigin = (origin: ObservabilityRuntimeOrigin) => {
+    if (!isEnabled()) {
+      return false;
+    }
+
+    lastRuntimeOrigin = origin;
+    prepareOutputChannels(origin);
+    return true;
+  };
+
+  const recordEvent = (
+    input: ObservabilityRuntimeEventInput,
+    origin?: ObservabilityRuntimeOrigin,
+  ) => {
+    const traceId = resolveTraceId(input);
+    const event = normalizeEvent(input, traceId, origin);
+    applyPhaseDuration(event);
+    updateTraceMaps(event);
+
+    if (!shouldRecordEvent(level, input)) {
+      return undefined;
+    }
+
+    events.push(event);
+    const report = updateReport(event);
+    emitConsoleHint(event, report, input.error);
+    notifyRawError(input.error, event, report, origin);
+    notifyEvent(event, report, origin);
+    notifyReport(report, origin);
+    return event;
+  };
+
+  const plugin: ObservabilityRuntimePlugin = {
+    name: 'observability-plugin',
+    beforeRequest(args) {
+      const requestArgs = args as ObservabilityRemoteBeforeRequestArgs;
+      if (!prepareRuntimeOrigin(requestArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'start',
+          requestId: requestArgs.id,
+          lifecycle: 'beforeRequest',
+          message: 'remote:load-start',
+        },
+        requestArgs.origin,
+      );
+    },
+    afterMatchRemote(args) {
+      const matchArgs = args as ObservabilityRemoteMatchArgs;
+      if (!prepareRuntimeOrigin(matchArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(matchArgs.remoteInfo || matchArgs.remote);
+      const hostRemotes = getHostRemotesSummary(matchArgs.options);
+      recordEvent(
+        {
+          phase: 'matchRemote',
+          status: matchArgs.error ? 'error' : 'success',
+          requestId: matchArgs.id,
+          lifecycle: 'afterMatchRemote',
+          expose: matchArgs.expose,
+          remote,
+          message: matchArgs.error ? 'remote:match-failed' : 'remote:matched',
+          error: matchArgs.error,
+          errorContext: hostRemotes
+            ? {
+                hostRemotes,
+              }
+            : undefined,
+        },
+        matchArgs.origin,
+      );
+    },
+    beforeLoadRemoteSnapshot(args) {
+      const snapshotArgs = args as ObservabilityRemoteSnapshotArgs;
+      if (!prepareRuntimeOrigin(snapshotArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(snapshotArgs.moduleInfo);
+      if (!isManifestUrl(remote?.entry)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'manifest',
+          status: 'start',
+          requestId: remote?.entry,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'beforeLoadRemoteSnapshot',
+          message: 'manifest:load-start',
+        },
+        snapshotArgs.origin,
+      );
+    },
+    loadRemoteSnapshot(args) {
+      if (options.enabled === false) {
+        return undefined;
+      }
+      return undefined;
+    },
+    afterResolve(args) {
+      const resolveArgs = args as ObservabilityRemoteResolveArgs;
+      if (!prepareRuntimeOrigin(resolveArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(
+        resolveArgs.remoteInfo || resolveArgs.remote,
+      );
+      if (!isManifestUrl(remote?.entry)) {
+        return;
+      }
+      const manifestUrl = sanitizeUrl(remote?.entry);
+      const cached =
+        resolveArgs.cached === true ||
+        Boolean(manifestUrl && seenManifestUrls.has(manifestUrl));
+
+      recordEvent(
+        {
+          phase: 'manifest',
+          status: 'success',
+          requestId: remote?.entry,
+          expose: resolveArgs.expose,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'afterResolve',
+          message: 'manifest:resolved',
+          cached,
+        },
+        resolveArgs.origin,
+      );
+      if (manifestUrl) {
+        seenManifestUrls.add(manifestUrl);
+      }
+    },
+    onLoad(args) {
+      const loadArgs = args as ObservabilityRemoteLoadArgs;
+      if (!prepareRuntimeOrigin(loadArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'success',
+          requestId: loadArgs.id,
+          lifecycle: 'onLoad',
+          expose: loadArgs.expose,
+          remote: createRemoteInfo(loadArgs.remote),
+          message: 'remote:loaded',
+        },
+        loadArgs.origin,
+      );
+    },
+    errorLoadRemote(args) {
+      const errorArgs = args as ObservabilityRemoteErrorArgs;
+      if (
+        !prepareRuntimeOrigin(errorArgs.origin) ||
+        (errorArgs.lifecycle !== 'onLoad' &&
+          errorArgs.lifecycle !== 'beforeRequest' &&
+          errorArgs.lifecycle !== 'afterResolve')
+      ) {
+        return undefined;
+      }
+
+      const isManifestError = errorArgs.lifecycle === 'afterResolve';
+      recordEvent(
+        {
+          phase: isManifestError ? 'manifest' : 'loadRemote',
+          status: 'error',
+          requestId: errorArgs.id,
+          lifecycle: errorArgs.lifecycle,
+          expose: errorArgs.expose,
+          remote: createRemoteInfo(errorArgs.remote),
+          url: isManifestError ? errorArgs.id : undefined,
+          message: isManifestError
+            ? 'manifest:failed'
+            : errorArgs.lifecycle
+              ? `remote:${errorArgs.lifecycle}:failed`
+              : 'remote:failed',
+          error: errorArgs.error,
+        },
+        errorArgs.origin,
+      );
+
+      return undefined;
+    },
+    afterLoadRemote(args) {
+      const loadArgs = args as ObservabilityRemoteAfterLoadArgs;
+      if (!prepareRuntimeOrigin(loadArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'loadRemote',
+          status: 'complete',
+          requestId: loadArgs.id,
+          lifecycle: 'afterLoadRemote',
+          expose: loadArgs.expose,
+          remote: createRemoteInfo(loadArgs.remote),
+          message: loadArgs.recovered
+            ? 'remote:load-recovered'
+            : loadArgs.error
+              ? 'remote:load-failed'
+              : 'remote:load-complete',
+          error: loadArgs.error,
+          recovered: loadArgs.recovered,
+        },
+        loadArgs.origin,
+      );
+    },
+    loadEntry(args) {
+      const entryArgs = args as ObservabilityRemoteEntryLoadArgs;
+      if (!prepareRuntimeOrigin(entryArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(entryArgs.remoteInfo);
+      recordEvent(
+        {
+          phase: 'remoteEntry',
+          status: 'start',
+          requestId: remote?.name,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'loadEntry',
+          message: 'remoteEntry:load-start',
+        },
+        entryArgs.origin,
+      );
+    },
+    afterLoadEntry(args) {
+      const entryArgs = args as ObservabilityRemoteEntryAfterLoadArgs;
+      if (!prepareRuntimeOrigin(entryArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(entryArgs.remoteInfo);
+      const remoteEntryKey = getRemoteEntryKey(sanitizeRemote(remote));
+      const cached =
+        entryArgs.cached === true ||
+        Boolean(remoteEntryKey && seenRemoteEntryKeys.has(remoteEntryKey));
+      recordEvent(
+        {
+          phase: 'remoteEntry',
+          status: entryArgs.error ? 'error' : 'success',
+          requestId: remote?.name,
+          remote,
+          url: remote?.entry,
+          lifecycle: 'afterLoadEntry',
+          message: entryArgs.error
+            ? 'remoteEntry:load-failed'
+            : entryArgs.recovered
+              ? 'remoteEntry:load-recovered'
+              : 'remoteEntry:loaded',
+          error: entryArgs.error,
+          recovered: entryArgs.recovered,
+          cached,
+        },
+        entryArgs.origin,
+      );
+      if (!entryArgs.error && remoteEntryKey) {
+        seenRemoteEntryKeys.add(remoteEntryKey);
+      }
+    },
+    beforeInitRemote(args) {
+      const initArgs = args as ObservabilityRemoteInitArgs;
+      if (!prepareRuntimeOrigin(initArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(initArgs.remoteInfo);
+      recordEvent(
+        {
+          phase: 'remoteEntryInit',
+          status: 'start',
+          requestId: initArgs.id || remote?.name,
+          remote,
+          lifecycle: 'beforeInitRemote',
+          message: 'remoteEntry:init-start',
+        },
+        initArgs.origin,
+      );
+    },
+    afterInitRemote(args) {
+      const initArgs = args as ObservabilityRemoteInitArgs;
+      if (!prepareRuntimeOrigin(initArgs.origin)) {
+        return;
+      }
+
+      const remote = createRemoteInfo(initArgs.remoteInfo);
+      recordEvent(
+        {
+          phase: 'remoteEntryInit',
+          status: initArgs.error ? 'error' : 'success',
+          requestId: initArgs.id || remote?.name,
+          remote,
+          lifecycle: 'afterInitRemote',
+          message: initArgs.error
+            ? 'remoteEntry:init-failed'
+            : initArgs.cached
+              ? 'remoteEntry:init-reused'
+              : 'remoteEntry:initialized',
+          error: initArgs.error,
+          cached: initArgs.cached,
+        },
+        initArgs.origin,
+      );
+    },
+    beforeGetExpose(args) {
+      const exposeArgs = args as ObservabilityRemoteExposeArgs;
+      if (!prepareRuntimeOrigin(exposeArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'expose',
+          status: 'start',
+          requestId: exposeArgs.id,
+          expose: exposeArgs.expose,
+          remote: createRemoteInfo(exposeArgs.moduleInfo),
+          lifecycle: 'beforeGetExpose',
+          message: 'expose:get-start',
+        },
+        exposeArgs.origin,
+      );
+    },
+    afterGetExpose(args) {
+      const exposeArgs = args as ObservabilityRemoteExposeArgs;
+      if (!prepareRuntimeOrigin(exposeArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'expose',
+          status: exposeArgs.error ? 'error' : 'success',
+          requestId: exposeArgs.id,
+          expose: exposeArgs.expose,
+          remote: createRemoteInfo(exposeArgs.moduleInfo),
+          lifecycle: 'afterGetExpose',
+          message: exposeArgs.error ? 'expose:get-failed' : 'expose:resolved',
+          error: exposeArgs.error,
+        },
+        exposeArgs.origin,
+      );
+    },
+    beforeExecuteFactory(args) {
+      const factoryArgs = args as ObservabilityRemoteFactoryArgs;
+      if (!prepareRuntimeOrigin(factoryArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'moduleFactory',
+          status: 'start',
+          requestId: factoryArgs.id,
+          expose: factoryArgs.expose,
+          remote: createRemoteInfo(factoryArgs.moduleInfo),
+          lifecycle: 'beforeExecuteFactory',
+          message: 'moduleFactory:execute-start',
+        },
+        factoryArgs.origin,
+      );
+    },
+    afterExecuteFactory(args) {
+      const factoryArgs = args as ObservabilityRemoteFactoryArgs;
+      if (!prepareRuntimeOrigin(factoryArgs.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'moduleFactory',
+          status: factoryArgs.error ? 'error' : 'success',
+          requestId: factoryArgs.id,
+          expose: factoryArgs.expose,
+          remote: createRemoteInfo(factoryArgs.moduleInfo),
+          lifecycle: 'afterExecuteFactory',
+          message: factoryArgs.error
+            ? 'moduleFactory:execute-failed'
+            : 'moduleFactory:executed',
+          error: factoryArgs.error,
+        },
+        factoryArgs.origin,
+      );
+    },
+    beforeLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return args;
+      }
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'start',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: 'loadShare',
+          shared: createSharedInfo(args),
+          message: 'shared:load-start',
+        },
+        args.origin,
+      );
+
+      return args;
+    },
+    afterLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return;
+      }
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'success',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: args.lifecycle,
+          shared: createSharedInfo(args),
+          message:
+            args.lifecycle === 'loadShareSync'
+              ? 'shared:resolved-sync'
+              : 'shared:resolved',
+        },
+        args.origin,
+      );
+    },
+    errorLoadShare(args) {
+      if (!prepareRuntimeOrigin(args.origin)) {
+        return;
+      }
+
+      const reason = getSharedErrorReason(args);
+
+      recordEvent(
+        {
+          phase: 'shared',
+          status: 'error',
+          requestId: `shared:${args.pkgName}`,
+          lifecycle: args.lifecycle,
+          shared: createSharedInfo(args, reason),
+          message: reason ? `shared:${reason}` : undefined,
+          error: args.error,
+          recovered: args.recovered,
+        },
+        args.origin,
+      );
+    },
+  } as ObservabilityRuntimePlugin;
+
+  return {
+    plugin,
+    getEvents() {
+      return getEventsSnapshot();
+    },
+    getTraceIds() {
+      return getTraceIdsSnapshot();
+    },
+    getReports(options?: ObservabilityReportListOptions) {
+      return getReportsSnapshot(options);
+    },
+    findReports(query?: ObservabilityReportQuery) {
+      return findReportsSnapshot(query);
+    },
+    getLatestReport() {
+      return getLatestReportSnapshot();
+    },
+    getReport(traceId: string) {
+      return getReportSnapshot(traceId);
+    },
+    exportReport(traceId?: string) {
+      return exportReportSnapshot(traceId);
+    },
+    clear() {
+      events.length = 0;
+      reports.clear();
+      traceByRequest.clear();
+      traceByRemote.clear();
+      phaseStartTimes.clear();
+      seenManifestUrls.clear();
+      seenRemoteEntryKeys.clear();
+      consoleReportedTraceIds.clear();
+      latestTraceId = undefined;
+      runtimeObservabilityEnabled = false;
+      effectiveMaxEvents = configuredMaxEvents;
+      browserGlobalScope = undefined;
+      lastRuntimeOrigin = undefined;
+    },
+    markComponentLoaded(markOptions: MarkComponentLoadedOptions = {}) {
+      if (options.enabled === false || !runtimeObservabilityEnabled) {
+        return undefined;
+      }
+
+      const traceId =
+        markOptions.traceId ||
+        (markOptions.requestId
+          ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || '')
+          : undefined) ||
+        latestTraceId ||
+        createTraceId({
+          phase: 'component',
+          status: 'success',
+          requestId: markOptions.requestId,
+        });
+
+      return recordEvent(
+        {
+          traceId,
+          phase: 'component',
+          status: 'success',
+          requestId: markOptions.requestId,
+          componentName: markOptions.componentName,
+          metadata: markOptions.metadata,
+          eventName: COMPONENT_BUSINESS_LOADED_EVENT,
+          message: COMPONENT_BUSINESS_LOADED_EVENT,
+          source: 'business',
+        },
+        lastRuntimeOrigin,
+      );
+    },
+  };
+}
diff --git a/packages/diagnostics-plugin/src/node.ts b/packages/observability-plugin/src/node.ts
similarity index 69%
rename from packages/diagnostics-plugin/src/node.ts
rename to packages/observability-plugin/src/node.ts
index 19f1da55e5a..7d74deef2ff 100644
--- a/packages/diagnostics-plugin/src/node.ts
+++ b/packages/observability-plugin/src/node.ts
@@ -1,17 +1,17 @@
 import {
-  DiagnosticsPlugin as createBaseDiagnosticsPlugin,
-  type DiagnosticsController,
-  type DiagnosticsEvent,
-  type DiagnosticsEventContext,
-  type DiagnosticsPluginOptions,
-  type DiagnosticsReport,
-  type DiagnosticsRuntimeOrigin,
+  ObservabilityPlugin as createBaseObservabilityPlugin,
+  type ObservabilityController,
+  type ObservabilityEvent,
+  type ObservabilityEventContext,
+  type ObservabilityPluginOptions,
+  type ObservabilityReport,
 } from './index';
 
-export interface DiagnosticsNodeOptions extends Omit<
-  DiagnosticsPluginOptions,
+export interface ObservabilityNodeOptions extends Omit<
+  ObservabilityPluginOptions,
   'browser'
 > {
+  fileOutput?: boolean;
   directory?: string;
   latestFile?: string;
   eventsFile?: string;
@@ -30,7 +30,7 @@ interface NodeOutputModules {
   };
 }
 
-const DEFAULT_NODE_DIRECTORY = '.mf/diagnostics';
+const DEFAULT_NODE_DIRECTORY = '.mf/observability';
 const DEFAULT_LATEST_FILE = 'latest.json';
 const DEFAULT_EVENTS_FILE = 'events.jsonl';
 
@@ -140,7 +140,7 @@ async function getNodeOutputModules(): Promise<NodeOutputModules | undefined> {
   return nodeOutputModulesPromise;
 }
 
-function getNodeOutputConfig(options: DiagnosticsNodeOptions) {
+function getNodeOutputConfig(options: ObservabilityNodeOptions) {
   return {
     directory: options.directory || DEFAULT_NODE_DIRECTORY,
     latestFile: options.latestFile || DEFAULT_LATEST_FILE,
@@ -148,38 +148,29 @@ function getNodeOutputConfig(options: DiagnosticsNodeOptions) {
   };
 }
 
-function shouldUseNodeOutput(
-  options: DiagnosticsNodeOptions,
-  origin?: DiagnosticsRuntimeOrigin,
-) {
+function shouldUseNodeOutput(options: ObservabilityNodeOptions) {
   return (
     options.enabled !== false &&
-    origin?.options?.security?.diagnostics?.fileOutput === true &&
+    options.fileOutput === true &&
     isNodeEnvironment()
   );
 }
 
-function shouldUseConsole(
-  options: DiagnosticsNodeOptions,
-  origin?: DiagnosticsRuntimeOrigin,
-) {
-  return (
-    options.console !== false &&
-    origin?.options?.security?.diagnostics?.console !== false
-  );
+function shouldUseConsole(options: ObservabilityNodeOptions) {
+  return options.console !== false;
 }
 
-function getNodeLatestPathForConsole(options: DiagnosticsNodeOptions) {
+function getNodeLatestPathForConsole(options: ObservabilityNodeOptions) {
   const config = getNodeOutputConfig(options);
   return `${config.directory}/${config.latestFile}`;
 }
 
-function getNodeEventsPathForConsole(options: DiagnosticsNodeOptions) {
+function getNodeEventsPathForConsole(options: ObservabilityNodeOptions) {
   const config = getNodeOutputConfig(options);
   return `${config.directory}/${config.eventsFile}`;
 }
 
-function isErrorEvent(event: DiagnosticsEvent) {
+function isErrorEvent(event: ObservabilityEvent) {
   return (
     event.status === 'error' ||
     (event.status === 'complete' &&
@@ -187,10 +178,18 @@ function isErrorEvent(event: DiagnosticsEvent) {
   );
 }
 
+function getRawStack(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+
+  return undefined;
+}
+
 async function writeNodeOutput(
-  options: DiagnosticsNodeOptions,
-  event: DiagnosticsEvent,
-  report: DiagnosticsReport,
+  options: ObservabilityNodeOptions,
+  event: ObservabilityEvent,
+  report: ObservabilityReport,
 ) {
   const modules = await getNodeOutputModules();
   if (!modules) {
@@ -215,15 +214,16 @@ async function writeNodeOutput(
 }
 
 function emitNodeConsoleHint(
-  options: DiagnosticsNodeOptions,
-  event: DiagnosticsEvent,
-  report: DiagnosticsReport,
-  context: DiagnosticsEventContext | undefined,
+  options: ObservabilityNodeOptions,
+  event: ObservabilityEvent,
+  report: ObservabilityReport,
+  context: ObservabilityEventContext | undefined,
   reportedTraceIds: Set<string>,
+  rawStack?: string,
 ) {
   if (
     !isErrorEvent(event) ||
-    !shouldUseConsole(options, context?.origin) ||
+    !shouldUseConsole(options) ||
     reportedTraceIds.has(report.traceId)
   ) {
     return;
@@ -232,7 +232,7 @@ function emitNodeConsoleHint(
   reportedTraceIds.add(report.traceId);
 
   const lines = [
-    '[Module Federation] Diagnostic report generated',
+    '[Module Federation] Observability report generated',
     `traceId: ${report.traceId}`,
     `phase: ${report.failedPhase || event.phase}`,
   ];
@@ -240,37 +240,53 @@ function emitNodeConsoleHint(
   if (report.requestId) {
     lines.push(`requestId: ${report.requestId}`);
   }
+  if (report.errorCode) {
+    lines.push(`errorCode: ${report.errorCode}`);
+  }
   if (report.shared?.name) {
     lines.push(`shared: ${report.shared.name}`);
   }
 
-  if (shouldUseNodeOutput(options, context?.origin)) {
+  if (shouldUseNodeOutput(options)) {
     lines.push(`latest: ${getNodeLatestPathForConsole(options)}`);
     lines.push(`events: ${getNodeEventsPathForConsole(options)}`);
   } else {
     lines.push(
-      `read: diagnostics.getReport(${JSON.stringify(report.traceId)})`,
+      `read: observability.getReport(${JSON.stringify(report.traceId)})`,
     );
   }
 
+  if (options.printRawStack === true && rawStack) {
+    lines.push('rawStack:', rawStack);
+  }
+
   try {
-    console.warn(lines.join('\n'));
+    console.error(lines.join('\n'));
   } catch {
-    // Console output is best-effort diagnostics only.
+    // Console output is best-effort observability only.
   }
 }
 
-export function DiagnosticsPlugin(
-  options: DiagnosticsNodeOptions = {},
-): DiagnosticsController {
+export function ObservabilityPlugin(
+  options: ObservabilityNodeOptions = {},
+): ObservabilityController {
   let nodeWriteQueue: Promise<void> = Promise.resolve();
   const consoleReportedTraceIds = new Set<string>();
-  const diagnostics = createBaseDiagnosticsPlugin({
+  const rawStackByTraceId = new Map<string, string>();
+  const observability = createBaseObservabilityPlugin({
     ...options,
     console: false,
     browser: undefined,
+    onRawError(error, context) {
+      const rawStack = getRawStack(error);
+      if (rawStack) {
+        rawStackByTraceId.set(context.report.traceId, rawStack);
+      }
+
+      options.onRawError?.(error, context);
+    },
     onEvent(event, report, context) {
-      if (shouldUseNodeOutput(options, context?.origin)) {
+      if (shouldUseNodeOutput(options)) {
         nodeWriteQueue = nodeWriteQueue
           .catch(() => undefined)
           .then(() => writeNodeOutput(options, event, report))
@@ -283,22 +299,30 @@ export function DiagnosticsPlugin(
         report,
         context,
         consoleReportedTraceIds,
+        rawStackByTraceId.get(report.traceId),
       );
-      options.onEvent?.(event, report, context);
+      try {
+        options.onEvent?.(event, report, context);
+      } finally {
+        if (isErrorEvent(event)) {
+          rawStackByTraceId.delete(report.traceId);
+        }
+      }
     },
     onReport(report, context) {
       options.onReport?.(report, context);
     },
   });
 
-  diagnostics.plugin.name = 'diagnostics-node-plugin';
+  observability.plugin.name = 'observability-node-plugin';
 
-  const clear = diagnostics.clear;
-  diagnostics.clear = () => {
+  const clear = observability.clear;
+  observability.clear = () => {
     clear();
     nodeWriteQueue = Promise.resolve();
     consoleReportedTraceIds.clear();
+    rawStackByTraceId.clear();
   };
 
-  return diagnostics;
+  return observability;
 }
diff --git a/packages/diagnostics-plugin/tsconfig.json b/packages/observability-plugin/tsconfig.json
similarity index 100%
rename from packages/diagnostics-plugin/tsconfig.json
rename to packages/observability-plugin/tsconfig.json
diff --git a/packages/diagnostics-plugin/tsdown.config.ts b/packages/observability-plugin/tsdown.config.ts
similarity index 77%
rename from packages/diagnostics-plugin/tsdown.config.ts
rename to packages/observability-plugin/tsdown.config.ts
index ed6aed2906a..f90b3e14619 100644
--- a/packages/diagnostics-plugin/tsdown.config.ts
+++ b/packages/observability-plugin/tsdown.config.ts
@@ -3,6 +3,7 @@ import { defineConfig } from 'tsdown';
 const entry = {
   index: 'src/index.ts',
   node: 'src/node.ts',
+  build: 'src/build.ts',
 };
 
 const baseConfig = {
@@ -10,13 +11,13 @@ const baseConfig = {
   tsconfig: 'tsconfig.json',
   clean: true,
   entry,
-  external: ['@module-federation/runtime'],
+  external: ['@module-federation/runtime', 'node:fs', 'node:path'],
 };
 
 export default defineConfig([
   {
     ...baseConfig,
-    name: 'diagnostics-plugin-cjs',
+    name: 'observability-plugin-cjs',
     outDir: 'dist',
     format: ['cjs'],
     dts: {
@@ -29,7 +30,7 @@ export default defineConfig([
   },
   {
     ...baseConfig,
-    name: 'diagnostics-plugin-esm',
+    name: 'observability-plugin-esm',
     outDir: 'dist/esm',
     format: ['esm'],
     dts: false,
diff --git a/packages/diagnostics-plugin/vitest.config.ts b/packages/observability-plugin/vitest.config.ts
similarity index 100%
rename from packages/diagnostics-plugin/vitest.config.ts
rename to packages/observability-plugin/vitest.config.ts
diff --git a/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts b/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
index 5cba8a25931..820f0d08d9e 100644
--- a/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
+++ b/packages/runtime-core/__tests__/load-remote-diagnostics.spec.ts
@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it } from 'vitest';
+import { RUNTIME_014 } from '@module-federation/error-codes';
 import { ModuleFederation } from '../src/core';
 import { resetFederationGlobalInfo } from '../src/global';
 import type { ModuleFederationRuntimePlugin } from '../src/type';
@@ -8,8 +9,70 @@ const createDiagnosticsRecorder = (
   events: Array<Record<string, unknown>>,
 ): ModuleFederationRuntimePlugin => ({
   name: 'load-remote-diagnostics-test-plugin',
+  afterMatchRemote(args) {
+    events.push({
+      type: 'afterMatchRemote',
+      id: args.id,
+      expose: args.expose,
+      remote: args.remoteInfo,
+      error: args.error,
+    });
+  },
+  beforeInitRemote(args) {
+    events.push({
+      type: 'beforeInitRemote',
+      id: args.id,
+      remote: args.remoteInfo,
+    });
+  },
+  afterInitRemote(args) {
+    events.push({
+      type: 'afterInitRemote',
+      id: args.id,
+      remote: args.remoteInfo,
+      error: args.error,
+      cached: args.cached,
+    });
+  },
+  beforeGetExpose(args) {
+    events.push({
+      type: 'beforeGetExpose',
+      id: args.id,
+      expose: args.expose,
+      remote: args.moduleInfo,
+    });
+  },
+  afterGetExpose(args) {
+    events.push({
+      type: 'afterGetExpose',
+      id: args.id,
+      expose: args.expose,
+      remote: args.moduleInfo,
+      error: args.error,
+    });
+  },
+  beforeExecuteFactory(args) {
+    events.push({
+      type: 'beforeExecuteFactory',
+      id: args.id,
+      expose: args.expose,
+      remote: args.moduleInfo,
+    });
+  },
+  afterExecuteFactory(args) {
+    events.push({
+      type: 'afterExecuteFactory',
+      id: args.id,
+      expose: args.expose,
+      remote: args.moduleInfo,
+      error: args.error,
+    });
+  },
   afterLoadRemote(args) {
-    events.push(args);
+    events.push({
+      type: 'afterLoadRemote',
+      ...args,
+    });
   },
 });
 
@@ -45,10 +108,94 @@ describe('loadRemote diagnostics', () => {
     expect(events).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
+          type: 'afterLoadRemote',
           id: '@demo/main/say',
           expose: './say',
         }),
       ]),
     );
+
+    expect(events.map((event) => event.type)).toEqual([
+      'afterMatchRemote',
+      'beforeInitRemote',
+      'afterInitRemote',
+      'beforeGetExpose',
+      'afterGetExpose',
+      'beforeExecuteFactory',
+      'afterExecuteFactory',
+      'afterLoadRemote',
+    ]);
+    expect(events).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: 'afterMatchRemote',
+          id: '@demo/main/say',
+          expose: './say',
+        }),
+        expect.objectContaining({
+          type: 'afterInitRemote',
+          error: undefined,
+        }),
+        expect.objectContaining({
+          type: 'afterGetExpose',
+          id: '@demo/main/say',
+          expose: './say',
+          error: undefined,
+        }),
+        expect.objectContaining({
+          type: 'afterExecuteFactory',
+          id: '@demo/main/say',
+          expose: './say',
+          error: undefined,
+        }),
+      ]),
+    );
+  });
+
+  it('emits the expose phase before a missing expose bubbles to loadRemote', async () => {
+    const events: Array<Record<string, unknown>> = [];
+    const mf = new ModuleFederation({
+      name: 'load-remote-diagnostics-host',
+      remotes: [
+        {
+          name: '@demo/main',
+          entry:
+            'http://localhost:1111/resources/main/federation-manifest.json',
+        },
+      ],
+      plugins: [createDiagnosticsRecorder(events)],
+    });
+
+    await expect(
+      mf.loadRemote<() => string>('@demo/main/__missing__'),
+    ).rejects.toThrow(RUNTIME_014);
+
+    expect(events).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: 'afterGetExpose',
+          id: '@demo/main/__missing__',
+          expose: './__missing__',
+          error: expect.any(Error),
+        }),
+        expect.objectContaining({
+          type: 'afterLoadRemote',
+          id: '@demo/main/__missing__',
+          expose: './__missing__',
+          error: expect.any(Error),
+        }),
+      ]),
+    );
+
+    const afterGetExposeError = events.find(
+      (event) => event.type === 'afterGetExpose',
+    )?.error;
+    expect(afterGetExposeError).toBeInstanceOf(Error);
+    expect(String((afterGetExposeError as Error).message)).toContain(
+      'availableExposes',
+    );
+    expect(String((afterGetExposeError as Error).message)).toContain(
+      'shared-button',
+    );
   });
 });
diff --git a/packages/runtime-core/__tests__/load.spec.ts b/packages/runtime-core/__tests__/load.spec.ts
index 258b0b721c2..39435ab5a5e 100644
--- a/packages/runtime-core/__tests__/load.spec.ts
+++ b/packages/runtime-core/__tests__/load.spec.ts
@@ -2,7 +2,11 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { getRemoteEntry, getRemoteInfo } from '../src/utils/load';
 import { ModuleFederation } from '../src/core';
 import { resetFederationGlobalInfo } from '../src/global';
-import { RUNTIME_001, RUNTIME_008 } from '@module-federation/error-codes';
+import {
+  RUNTIME_001,
+  RUNTIME_008,
+  RUNTIME_015,
+} from '@module-federation/error-codes';
 import { mockStaticServer, removeScriptTags } from './mock/utils';
 
 // All fixture URLs are served via two complementary mechanisms both pointing to __tests__/:
@@ -92,4 +96,18 @@ describe('getRemoteEntry - script load error discrimination', () => {
       }),
     );
   });
+
+  it('remote container init failure is reported as RUNTIME_015 with the original error', async () => {
+    const entry = `${BASE}/init-error.js`;
+    const mf = new ModuleFederation({
+      name: 'test-host',
+      remotes: [{ name: 'remote', entry }],
+    });
+
+    const err = await mf.loadRemote('remote/Button').catch((e) => e);
+
+    expect(err.message).toContain(RUNTIME_015);
+    expect(err.message).toContain('remote init failed');
+    expect(err.message).toContain('remoteEntryUrl');
+  });
 });
diff --git a/packages/runtime-core/__tests__/resources/load/init-error.js b/packages/runtime-core/__tests__/resources/load/init-error.js
new file mode 100644
index 00000000000..18616880509
--- /dev/null
+++ b/packages/runtime-core/__tests__/resources/load/init-error.js
@@ -0,0 +1,11 @@
+// Script that registers a remote whose container init fails.
+globalThis['remote'] = {
+  get: function () {
+    return function () {
+      return 'unused';
+    };
+  },
+  init: function () {
+    throw new Error('remote init failed');
+  },
+};
diff --git a/packages/runtime-core/src/core.ts b/packages/runtime-core/src/core.ts
index 0df0e4e0a66..7e0f064c346 100644
--- a/packages/runtime-core/src/core.ts
+++ b/packages/runtime-core/src/core.ts
@@ -24,7 +24,7 @@ import {
   RUNTIME_010,
   runtimeDescMap,
 } from '@module-federation/error-codes';
-import { Module } from './module';
+import { Module, type RemoteModuleFactory } from './module';
 import {
   AsyncHook,
   AsyncWaterfallHook,
@@ -171,6 +171,83 @@ export class ModuleFederation {
       ],
       void
     >('afterLoadEntry'),
+    beforeInitRemote: new AsyncHook<
+      [
+        {
+          id?: string;
+          remoteInfo: RemoteInfo;
+          remoteSnapshot?: ModuleInfo;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('beforeInitRemote'),
+    afterInitRemote: new AsyncHook<
+      [
+        {
+          id?: string;
+          remoteInfo: RemoteInfo;
+          remoteSnapshot?: ModuleInfo;
+          remoteEntryExports?: RemoteEntryExports;
+          error?: unknown;
+          cached?: boolean;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterInitRemote'),
+    beforeGetExpose: new AsyncHook<
+      [
+        {
+          id: string;
+          expose: string;
+          moduleInfo: RemoteInfo;
+          remoteEntryExports: RemoteEntryExports;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('beforeGetExpose'),
+    afterGetExpose: new AsyncHook<
+      [
+        {
+          id: string;
+          expose: string;
+          moduleInfo: RemoteInfo;
+          remoteEntryExports: RemoteEntryExports;
+          moduleFactory?: RemoteModuleFactory;
+          error?: unknown;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterGetExpose'),
+    beforeExecuteFactory: new AsyncHook<
+      [
+        {
+          id: string;
+          expose: string;
+          moduleInfo: RemoteInfo;
+          loadFactory: boolean;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('beforeExecuteFactory'),
+    afterExecuteFactory: new AsyncHook<
+      [
+        {
+          id: string;
+          expose: string;
+          moduleInfo: RemoteInfo;
+          loadFactory: boolean;
+          exposeModule?: unknown;
+          error?: unknown;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterExecuteFactory'),
     getModuleFactory: new AsyncHook<
       [
         {
@@ -179,7 +256,7 @@ export class ModuleFederation {
           moduleInfo: RemoteInfo;
         },
       ],
-      Promise<(() => Promise<Module>) | undefined>
+      RemoteModuleFactory | Promise<RemoteModuleFactory | undefined> | undefined
     >(),
   });
   bridgeHook = new PluginSystem({
diff --git a/packages/runtime-core/src/index.ts b/packages/runtime-core/src/index.ts
index da6bb27a4e2..5efa2c6fb47 100644
--- a/packages/runtime-core/src/index.ts
+++ b/packages/runtime-core/src/index.ts
@@ -15,11 +15,7 @@ export {
   getGlobalSnapshot,
   getInfoWithoutType,
 } from './global';
-export type {
-  UserOptions,
-  ModuleFederationRuntimePlugin,
-  SecurityOptions,
-} from './type';
+export type { UserOptions, ModuleFederationRuntimePlugin } from './type';
 export { assert, error } from './utils/logger';
 export { registerGlobalPlugins } from './global';
 export {
diff --git a/packages/runtime-core/src/module/index.ts b/packages/runtime-core/src/module/index.ts
index b687761cf6a..10dbb090d53 100644
--- a/packages/runtime-core/src/module/index.ts
+++ b/packages/runtime-core/src/module/index.ts
@@ -1,5 +1,4 @@
 import {
-  getFMId,
   assert,
   error,
   processModuleAlias,
@@ -8,7 +7,8 @@ import {
 import { safeToString, ModuleInfo } from '@module-federation/sdk';
 import {
   RUNTIME_002,
-  RUNTIME_008,
+  RUNTIME_014,
+  RUNTIME_015,
   runtimeDescMap,
 } from '@module-federation/error-codes';
 import { getRemoteEntry } from '../utils/load';
@@ -21,6 +21,25 @@ import {
 } from '../type';
 
 export type ModuleOptions = ConstructorParameters<typeof Module>[0];
+export type RemoteModuleFactory = () => unknown | Promise<unknown>;
+
+function getAvailableExposeNames(
+  remoteSnapshot?: ModuleInfo,
+): string | undefined {
+  if (
+    !remoteSnapshot ||
+    !('modules' in remoteSnapshot) ||
+    !Array.isArray(remoteSnapshot.modules)
+  ) {
+    return undefined;
+  }
+
+  const exposes = remoteSnapshot.modules
+    .map((module) => module.moduleName)
+    .filter(Boolean);
+
+  return exposes.length ? exposes.join(',') : undefined;
+}
 
 export function createRemoteEntryInitOptions(
   remoteInfo: RemoteInfo,
@@ -118,16 +137,52 @@ class Module {
     const remoteEntryExports = await this.getEntry();
 
     if (this.inited) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        cached: true,
+        origin: this.host,
+      });
       return remoteEntryExports;
     }
 
     if (this.initPromise) {
-      await this.initPromise;
+      try {
+        await this.initPromise;
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          cached: true,
+          origin: this.host,
+        });
+      } catch (initError) {
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          error: initError,
+          cached: true,
+          origin: this.host,
+        });
+        throw initError;
+      }
       return remoteEntryExports;
     }
 
     this.initing = true;
     this.initPromise = (async () => {
+      await this.host.loaderHook.lifecycle.beforeInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        origin: this.host,
+      });
+
       const { remoteEntryInitOptions, shareScope, initScope } =
         createRemoteEntryInitOptions(
           this.remoteInfo,
@@ -160,11 +215,27 @@ class Module {
         );
       }
 
-      await remoteEntryExports.init(
-        initContainerOptions.shareScope,
-        initContainerOptions.initScope,
-        initContainerOptions.remoteEntryInitOptions,
-      );
+      try {
+        await remoteEntryExports.init(
+          initContainerOptions.shareScope,
+          initContainerOptions.initScope,
+          initContainerOptions.remoteEntryInitOptions,
+        );
+      } catch (initError) {
+        error(
+          RUNTIME_015,
+          runtimeDescMap,
+          {
+            hostName: this.host.name,
+            remoteName: this.remoteInfo.name,
+            remoteEntryUrl: this.remoteInfo.entry,
+            remoteEntryKey: this.remoteInfo.entryGlobalName,
+            shareScope: this.remoteInfo.shareScope,
+          },
+          `${initError}`,
+          optionsToMFContext(this.host.options),
+        );
+      }
 
       await this.host.hooks.lifecycle.initContainer.emit({
         ...initContainerOptions,
@@ -177,6 +248,23 @@ class Module {
 
     try {
       await this.initPromise;
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        origin: this.host,
+      });
+    } catch (initError) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        error: initError,
+        origin: this.host,
+      });
+      throw initError;
     } finally {
       this.initing = false;
       this.initPromise = undefined;
@@ -197,22 +285,66 @@ class Module {
     const remoteEntryExports = await this.init(id, remoteSnapshot);
     this.lib = remoteEntryExports;
 
-    let moduleFactory;
-    moduleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
-      remoteEntryExports,
+    await this.host.loaderHook.lifecycle.beforeGetExpose.emit({
+      id,
       expose,
       moduleInfo: this.remoteInfo,
+      remoteEntryExports,
+      origin: this.host,
     });
 
-    // get exposeGetter
-    if (!moduleFactory) {
-      moduleFactory = await remoteEntryExports.get(expose);
-    }
+    let moduleFactory: RemoteModuleFactory | undefined;
+    try {
+      const hookModuleFactory =
+        await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+          remoteEntryExports,
+          expose,
+          moduleInfo: this.remoteInfo,
+        });
+      moduleFactory =
+        typeof hookModuleFactory === 'function' ? hookModuleFactory : undefined;
 
-    assert(
-      moduleFactory,
-      `${getFMId(this.remoteInfo)} remote don't export ${expose}.`,
-    );
+      // get exposeGetter
+      if (!moduleFactory) {
+        moduleFactory = await remoteEntryExports.get(expose);
+      }
+
+      if (!moduleFactory) {
+        error(
+          RUNTIME_014,
+          runtimeDescMap,
+          {
+            hostName: this.host.name,
+            remoteName: this.remoteInfo.name,
+            remoteEntryUrl: this.remoteInfo.entry,
+            expose,
+            requestId: id,
+            availableExposes: getAvailableExposeNames(remoteSnapshot),
+          },
+          undefined,
+          optionsToMFContext(this.host.options),
+        );
+      }
+
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        moduleFactory,
+        origin: this.host,
+      });
+    } catch (getExposeError) {
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        error: getExposeError,
+        origin: this.host,
+      });
+      throw getExposeError;
+    }
 
     // keep symbol for module name always one format
     const symbolName = processModuleAlias(this.remoteInfo.name, expose);
@@ -221,16 +353,43 @@ class Module {
     if (!loadFactory) {
       return wrapModuleFactory;
     }
-    const exposeContent = await wrapModuleFactory();
 
-    return exposeContent;
+    await this.host.loaderHook.lifecycle.beforeExecuteFactory.emit({
+      id,
+      expose,
+      moduleInfo: this.remoteInfo,
+      loadFactory,
+      origin: this.host,
+    });
+
+    try {
+      const exposeContent = await wrapModuleFactory();
+
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        exposeModule: exposeContent,
+        origin: this.host,
+      });
+
+      return exposeContent;
+    } catch (executeFactoryError) {
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        error: executeFactoryError,
+        origin: this.host,
+      });
+      throw executeFactoryError;
+    }
   }
 
-  private wraperFactory(
-    moduleFactory: () => any | (() => Promise<any>),
-    id: string,
-  ) {
-    function defineModuleId(res: any, id: string) {
+  private wraperFactory(moduleFactory: RemoteModuleFactory, id: string) {
+    function defineModuleId(res: unknown, id: string) {
       if (
         res &&
         typeof res === 'object' &&
@@ -244,21 +403,21 @@ class Module {
       }
     }
 
-    if (moduleFactory instanceof Promise) {
-      return async () => {
-        const res = await moduleFactory();
-        // This parameter is used for bridge debugging
-        defineModuleId(res, id);
-        return res;
-      };
-    } else {
-      return () => {
-        const res = moduleFactory();
-        // This parameter is used for bridge debugging
-        defineModuleId(res, id);
-        return res;
-      };
-    }
+    return () => {
+      const res = moduleFactory();
+
+      if (res instanceof Promise) {
+        return res.then((asyncRes) => {
+          // This parameter is used for bridge debugging
+          defineModuleId(asyncRes, id);
+          return asyncRes;
+        });
+      }
+
+      // This parameter is used for bridge debugging
+      defineModuleId(res, id);
+      return res;
+    };
   }
 }
 
diff --git a/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts b/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
index 4a0b04e729b..f4a2e9c09ad 100644
--- a/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
+++ b/packages/runtime-core/src/plugins/snapshot/SnapshotHandler.ts
@@ -9,6 +9,7 @@ import {
 import {
   RUNTIME_003,
   RUNTIME_007,
+  RUNTIME_013,
   runtimeDescMap,
 } from '@module-federation/error-codes';
 import { Options, Remote } from '../../type';
@@ -28,7 +29,6 @@ import {
 } from '../../global';
 import { PluginSystem, AsyncHook, AsyncWaterfallHook } from '../../utils/hooks';
 import { ModuleFederation } from '../../core';
-import { assert } from '../../utils/logger';
 
 export function getGlobalRemoteInfo(
   moduleInfo: Remote,
@@ -358,10 +358,20 @@ export class SnapshotHandler {
         );
       }
 
-      assert(
-        manifestJson.metaData && manifestJson.exposes && manifestJson.shared,
-        `"${manifestUrl}" is not a valid federation manifest for remote "${moduleInfo.name}". Missing required fields: ${missingRequiredFields.join(', ')}.`,
-      );
+      if (missingRequiredFields.length > 0) {
+        error(
+          RUNTIME_013,
+          runtimeDescMap,
+          {
+            manifestUrl,
+            moduleName: moduleInfo.name,
+            hostName: this.HostInstance.options.name,
+            missingFields: missingRequiredFields.join(','),
+          },
+          undefined,
+          optionsToMFContext(this.HostInstance.options),
+        );
+      }
       this.manifestCache.set(manifestUrl, manifestJson);
       return manifestJson;
     };
diff --git a/packages/runtime-core/src/remote/index.ts b/packages/runtime-core/src/remote/index.ts
index b981220a16e..ce38a16471f 100644
--- a/packages/runtime-core/src/remote/index.ts
+++ b/packages/runtime-core/src/remote/index.ts
@@ -75,6 +75,20 @@ export class RemoteHandler {
       options: Options;
       origin: ModuleFederation;
     }>('beforeRequest'),
+    afterMatchRemote: new AsyncHook<
+      [
+        {
+          id: string;
+          options: Options;
+          remote?: Remote;
+          expose?: string;
+          remoteInfo?: RemoteInfo;
+          error?: unknown;
+          origin: ModuleFederation;
+        },
+      ],
+      void
+    >('afterMatchRemote'),
     onLoad: new AsyncHook<
       [
         {
@@ -439,20 +453,37 @@ export class RemoteHandler {
       idRes,
     );
     if (!remoteSplitInfo) {
-      error(
-        RUNTIME_004,
-        runtimeDescMap,
-        {
-          hostName: host.options.name,
-          requestId: idRes,
-        },
-        undefined,
-        optionsToMFContext(host.options),
-      );
+      try {
+        error(
+          RUNTIME_004,
+          runtimeDescMap,
+          {
+            hostName: host.options.name,
+            requestId: idRes,
+          },
+          undefined,
+          optionsToMFContext(host.options),
+        );
+      } catch (matchError) {
+        await this.hooks.lifecycle.afterMatchRemote.emit({
+          id: idRes,
+          options: host.options,
+          error: matchError,
+          origin: host,
+        });
+        throw matchError;
+      }
     }
 
     const { remote: rawRemote } = remoteSplitInfo;
     const remoteInfo = getRemoteInfo(rawRemote);
+    await this.hooks.lifecycle.afterMatchRemote.emit({
+      id: idRes,
+      ...remoteSplitInfo,
+      options: host.options,
+      remoteInfo,
+      origin: host,
+    });
     const matchInfo =
       await host.sharedHandler.hooks.lifecycle.afterResolve.emit({
         id: idRes,
diff --git a/packages/runtime-core/src/type/config.ts b/packages/runtime-core/src/type/config.ts
index 7f4c3a4fe39..98c6c357bbf 100644
--- a/packages/runtime-core/src/type/config.ts
+++ b/packages/runtime-core/src/type/config.ts
@@ -122,16 +122,6 @@ export type ShareInfos = {
   [pkgName: string]: Shared[];
 };
 
-export interface SecurityOptions {
-  diagnostics?: {
-    enabled?: boolean;
-    maxEvents?: number;
-    console?: boolean;
-    browserGlobal?: boolean;
-    fileOutput?: boolean;
-  };
-}
-
 export interface Options {
   id?: string;
   name: string;
@@ -141,7 +131,6 @@ export interface Options {
   plugins: Array<ModuleFederationRuntimePlugin>;
   inBrowser: boolean;
   shareStrategy?: ShareStrategy;
-  security?: SecurityOptions;
 }
 
 export type UserOptions = Omit<
diff --git a/packages/runtime/src/index.ts b/packages/runtime/src/index.ts
index f14b4e992d3..9519a4eca66 100644
--- a/packages/runtime/src/index.ts
+++ b/packages/runtime/src/index.ts
@@ -18,7 +18,6 @@ export {
   registerGlobalPlugins,
   type ModuleFederationRuntimePlugin,
   type Federation,
-  type SecurityOptions,
 } from '@module-federation/runtime-core';
 
 export { ModuleFederation };
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4b4db01a270..3c7da21d8d3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1107,7 +1107,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1126,7 +1126,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1165,7 +1165,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1184,7 +1184,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1232,7 +1232,7 @@ importers:
         version: link:../../../packages/storybook-addon
       '@rsbuild/plugin-react':
         specifier: ^1.4.5
-        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@rslib/core':
         specifier: ^0.9.0
         version: 0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
@@ -1259,7 +1259,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1278,7 +1278,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1330,7 +1330,7 @@ importers:
         version: link:../../../packages/rsbuild-plugin
       '@rsbuild/plugin-react':
         specifier: ^1.4.5
-        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@rslib/core':
         specifier: ^0.9.0
         version: 0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
@@ -1348,7 +1348,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1367,7 +1367,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1406,7 +1406,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1425,7 +1425,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1464,7 +1464,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1483,7 +1483,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1522,7 +1522,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1541,7 +1541,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -1580,7 +1580,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../packages/modernjs-v3
@@ -1599,7 +1599,7 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
@@ -2126,7 +2126,7 @@ importers:
         version: 1.7.3
       '@rsbuild/plugin-vue':
         specifier: ^1.2.6
-        version: 1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
+        version: 1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
       tailwindcss:
         specifier: ^3.4.3
         version: 3.4.13(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.9.3))
@@ -2243,7 +2243,7 @@ importers:
         version: 1.7.3
       '@rsbuild/plugin-vue':
         specifier: ^1.2.6
-        version: 1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
+        version: 1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
       '@vue/tsconfig':
         specifier: ^0.5.1
         version: 0.5.1
@@ -2393,7 +2393,7 @@ importers:
         version: link:../../packages/storybook-addon
       '@rsbuild/plugin-react':
         specifier: ^1.4.5
-        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+        version: 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@rslib/core':
         specifier: ^0.9.0
         version: 0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
@@ -2414,10 +2414,10 @@ importers:
         version: 8.6.17(prettier@3.8.1)
       storybook-addon-rslib:
         specifier: ^1.0.1
-        version: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rslib/core@0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3))(storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3))(typescript@5.9.3)
+        version: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rslib/core@0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3))(storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3))(typescript@5.9.3)
       storybook-react-rsbuild:
         specifier: ^1.0.1
-        version: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)(webpack@5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.25.0)(webpack-cli@5.1.4))
+        version: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)(webpack@5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.25.0)(webpack-cli@5.1.4))
 
   apps/runtime-demo/3005-runtime-host:
     dependencies:
@@ -2437,15 +2437,15 @@ importers:
       '@module-federation/core':
         specifier: workspace:*
         version: link:../../../packages/core
-      '@module-federation/diagnostics-plugin':
-        specifier: workspace:*
-        version: link:../../../packages/diagnostics-plugin
       '@module-federation/dts-plugin':
         specifier: workspace:*
         version: link:../../../packages/dts-plugin
       '@module-federation/enhanced':
         specifier: workspace:*
         version: link:../../../packages/enhanced
+      '@module-federation/observability-plugin':
+        specifier: workspace:*
+        version: link:../../../packages/observability-plugin
       '@module-federation/runtime':
         specifier: workspace:*
         version: link:../../../packages/runtime
@@ -2559,7 +2559,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/enhanced':
         specifier: workspace:*
         version: link:../../../../packages/enhanced
@@ -2578,13 +2578,13 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/plugin-server':
         specifier: 2.68.0
-        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/tsconfig':
         specifier: 3.0.1
         version: 3.0.1
@@ -2629,7 +2629,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/enhanced':
         specifier: workspace:*
         version: link:../../../../packages/enhanced
@@ -2648,13 +2648,13 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/plugin-server':
         specifier: 2.68.0
-        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/tsconfig':
         specifier: 3.0.1
         version: 3.0.1
@@ -2693,7 +2693,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../../packages/modernjs-v3
@@ -2712,16 +2712,16 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/plugin-server':
         specifier: 2.68.0
-        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/tsconfig':
         specifier: 3.0.1
         version: 3.0.1
@@ -2769,7 +2769,7 @@ importers:
         version: 7.28.2
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@module-federation/modern-js-v3':
         specifier: workspace:*
         version: link:../../../../packages/modernjs-v3
@@ -2788,13 +2788,13 @@ importers:
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/eslint-config':
         specifier: 2.59.0
         version: 2.59.0(typescript@5.0.4)
       '@modern-js/plugin-server':
         specifier: 2.68.0
-        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/tsconfig':
         specifier: 3.0.1
         version: 3.0.1
@@ -2833,13 +2833,13 @@ importers:
         version: link:../../packages/rspress-plugin
       '@rsbuild/plugin-sass':
         specifier: ^1.5.0
-        version: 1.5.1(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+        version: 1.5.1(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       '@rspress/core':
         specifier: 2.0.3
-        version: 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
+        version: 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
       '@rspress/plugin-llms':
         specifier: 2.0.1
-        version: 2.0.1(@rspress/core@2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1))
+        version: 2.0.1(@rspress/core@2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1))
       framer-motion:
         specifier: ^10.0.0
         version: 10.18.0(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
@@ -3212,12 +3212,6 @@ importers:
         specifier: ^0.2.1
         version: 0.2.1(@rsbuild/core@1.7.3)
 
-  packages/diagnostics-plugin:
-    devDependencies:
-      '@module-federation/runtime':
-        specifier: workspace:*
-        version: link:../runtime
-
   packages/dts-plugin:
     dependencies:
       '@module-federation/error-codes':
@@ -3488,7 +3482,7 @@ importers:
         version: 0.80.0(@babel/core@7.29.0)(@react-native-community/cli@19.1.2(typescript@5.9.3))(@types/react@19.2.14)(react@19.1.0)
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)
+        version: 10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@20.19.5)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -3709,16 +3703,16 @@ importers:
     devDependencies:
       '@modern-js/app-tools':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
       '@modern-js/module-tools':
         specifier: 2.70.5
         version: 2.70.5(@types/node@25.6.0)(typescript@5.9.3)
       '@modern-js/runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4)))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4)))(react@18.3.1)
       '@modern-js/server-runtime':
         specifier: 3.0.1
-        version: 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/tsconfig':
         specifier: 3.0.1
         version: 3.0.1
@@ -3727,10 +3721,10 @@ importers:
         version: link:../manifest
       '@rsbuild/core':
         specifier: 2.0.0-beta.2
-        version: 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+        version: 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       '@rsbuild/plugin-react':
         specifier: 1.4.5
-        version: 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+        version: 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@rslib/core':
         specifier: 0.18.5
         version: 0.18.5(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
@@ -3888,6 +3882,12 @@ importers:
         specifier: ^5.40.0
         version: 5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.27.3)(webpack-cli@5.1.4)
 
+  packages/observability-plugin:
+    devDependencies:
+      '@module-federation/runtime':
+        specifier: workspace:*
+        version: link:../runtime
+
   packages/retry-plugin:
     dependencies:
       '@module-federation/sdk':
@@ -3912,7 +3912,7 @@ importers:
     devDependencies:
       '@rsbuild/core':
         specifier: 2.0.0-beta.2
-        version: 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+        version: 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@rslib/core':
         specifier: ^0.12.4
         version: 0.12.4(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
@@ -3970,7 +3970,7 @@ importers:
         version: link:../sdk
       '@rspress/shared':
         specifier: 2.0.3
-        version: 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+        version: 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       cheerio:
         specifier: 1.0.0-rc.12
         version: 1.0.0-rc.12
@@ -3986,7 +3986,7 @@ importers:
         version: 0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
       '@rspress/core':
         specifier: 2.0.3
-        version: 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@18.3.28)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
+        version: 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@18.3.28)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
       '@types/html-to-text':
         specifier: ^9.0.4
         version: 9.0.4
@@ -8169,8 +8169,8 @@ packages:
   '@module-federation/error-codes@2.2.2':
     resolution: {integrity: sha512-e+dxUrqrdRbhfvg8TyG0UQBQAjYZ8pI2b3HWfESLXqWi3xCiivZSnqsPN+zychrQ1hDZAdCheZ9zT91zhMrkxw==}
 
-  '@module-federation/error-codes@2.3.2':
-    resolution: {integrity: sha512-Y8F6EG+shNY5mJ0yKcJh4t6HlMYEtqMvABDDmxWulLz/tSV859SL05I5eDR1EvK0jNhLbq8LFipFEToQLqF0AA==}
+  '@module-federation/error-codes@2.4.0':
+    resolution: {integrity: sha512-ktCZtwOoiKR1URJyBt223OsOFAUvc13rICYif55mt7+DomtELlh5FicnEz6mPLBUwmNM9vyBMvkxOdp+fQ5oUg==}
 
   '@module-federation/inject-external-runtime-core-plugin@0.21.6':
     resolution: {integrity: sha512-DJQne7NQ988AVi3QB8byn12FkNb+C2lBeU1NRf8/WbL0gmHsr6kW8hiEJCm8LYaURwtsQqtsEV7i+8+51qjSmQ==}
@@ -8250,8 +8250,8 @@ packages:
   '@module-federation/runtime-core@2.2.2':
     resolution: {integrity: sha512-JL+W6Yol1+CPJ662H1SEQLwxfBU2kCKhUcYrMr/X6j0qFWB8x5PBSpQbwAIcJiKfflHgBaJZypmCKmq8qRv3Aw==}
 
-  '@module-federation/runtime-core@2.3.2':
-    resolution: {integrity: sha512-o4Pfi21uADHtSl3/BHu/3ph5+069pDOXL8Lck12b+rxsHessbeZkNo+MOxwP+gXf8fFsT+f9spOmx+Y5gtyc2A==}
+  '@module-federation/runtime-core@2.4.0':
+    resolution: {integrity: sha512-0S8fDw28DXDW17lTQwq5vfJWe2lG0Lw3+w4vk3DVVImLwXXay+OGxLDxzWUfypWcMznfpnoAnFUMO3PtuXziuA==}
 
   '@module-federation/runtime-tools@0.1.6':
     resolution: {integrity: sha512-7ILVnzMIa0Dlc0Blck5tVZG1tnk1MmLnuZpLOMpbdW+zl+N6wdMjjHMjEZFCUAJh2E5XJ3BREwfX8Ets0nIkLg==}
@@ -8283,8 +8283,8 @@ packages:
   '@module-federation/runtime-tools@2.2.2':
     resolution: {integrity: sha512-UnlKvy/zrbLTLItrI1tORiS6wdp5pYOCrR2LtDEbjJ2r+avzANSf2vJ7lAIT4SX5Pi9WwY5RhE4Y/BOwhAj4DA==}
 
-  '@module-federation/runtime-tools@2.3.2':
-    resolution: {integrity: sha512-i9B3h2PgEjXMj9slEQdzus58t6UsTRGAaAB+E2fN7cOIKii4t0+bkChFFLtqplUvWMH6/AQ1D4Gj2IfwlbOXDg==}
+  '@module-federation/runtime-tools@2.4.0':
+    resolution: {integrity: sha512-BWQsGT4EWscV9bx3bVHEwp6lERBsiYm7rnPiDpwd2fx+hGEpz1IM9Pz35VryHNDXYxw7MzaAuwTMM+L7uN8OYQ==}
 
   '@module-federation/runtime@0.1.6':
     resolution: {integrity: sha512-nj6a+yJ+QxmcE89qmrTl4lphBIoAds0PFPVGnqLRWflwAP88jrCcrrTqRhARegkFDL+wE9AE04+h6jzlbIfMKg==}
@@ -8316,8 +8316,8 @@ packages:
   '@module-federation/runtime@2.2.2':
     resolution: {integrity: sha512-zV6kbAUU1tQZr4KrZXQhzQP3WTb7oMRlIFw4UBhbh2JhAKGYS5CNc/n7+RV+mDxIs//qVmVzdSpJtTOMBLeFCw==}
 
-  '@module-federation/runtime@2.3.2':
-    resolution: {integrity: sha512-JFSAbr0zBDmNF+wcqHw22CmZGuUZjTsa4qzm1+RUVi3blrnKeBj9Y2FppEOBwPc/FHUr4/MDijA/6GFE2cv7gQ==}
+  '@module-federation/runtime@2.4.0':
+    resolution: {integrity: sha512-IrLAMwUuteRgFlEkg9jrn4bk8uC897FnXvfNmkKD8/qIoNtSd+32e5ouQn+PEYbX/RjRUB1TYveY6rYHpTPkyg==}
 
   '@module-federation/sdk@0.1.6':
     resolution: {integrity: sha512-qifXpyYLM7abUeEOIfv0oTkguZgRZuwh89YOAYIZJlkP6QbRG7DJMQvtM8X2yHXm9PTk0IYNnOJH0vNQCo6auQ==}
@@ -8354,10 +8354,10 @@ packages:
       node-fetch:
         optional: true
 
-  '@module-federation/sdk@2.3.2':
-    resolution: {integrity: sha512-EKiZpLnD2ogy7OcnuU+vkGO5vhh3J25PHwtEzgVGIAsMis3JHYPpY7L1Ue7i0zVrdmI23dVJPBtfGV/Pg7THPA==}
+  '@module-federation/sdk@2.4.0':
+    resolution: {integrity: sha512-eZDdF5B69W9npuka0VL24FY7XDM+YAwwfkscSeWOSqv4/8Hm0xmcmSurlP6NIOrwbeogerRCtEcnx/TFXYjoow==}
     peerDependencies:
-      node-fetch: ^3.3.2
+      node-fetch: ^2.7.0 || ^3.3.2
     peerDependenciesMeta:
       node-fetch:
         optional: true
@@ -8398,8 +8398,8 @@ packages:
   '@module-federation/webpack-bundler-runtime@2.2.2':
     resolution: {integrity: sha512-g5UEn5APnNYvajwWQ0oc3Um+HO1z/jBcBkLSKAoSOCI6XxQk5eAV1PNDuDehAgJEtJw5yFD25kZPW3X7m39y7g==}
 
-  '@module-federation/webpack-bundler-runtime@2.3.2':
-    resolution: {integrity: sha512-K9XRr7Jhsmo2JjETwIctLi+R22mUjtSZ5hUEgvwcHeGss8enqdDU+kt2NP/SVG+/dRUXkvzkGppqkjd6sBKg7w==}
+  '@module-federation/webpack-bundler-runtime@2.4.0':
+    resolution: {integrity: sha512-Ntx0+QsgcwtXlpGjL/Vf2PMdPjUHl07b3yM4kBc1kbRogW3Ee84QneBRi/X3w4/jlz4JKbHjD+CMXaqi2W6hgw==}
 
   '@mswjs/cookies@0.2.2':
     resolution: {integrity: sha512-mlN83YSrcFgk7Dm1Mys40DLssI1KdJji2CMKN8eOlBqsTADYzj2+jWzsANsUTFbxDMWPD5e9bfA1RGqBpS3O1g==}
@@ -12865,22 +12865,6 @@ packages:
     resolution: {integrity: sha512-IteBhl4XqYNkM54f4ejhLRJiZNqcSCoXUOG2CPK7qbD322KjQozM4kHQOfkG2oln9b9HTYqs+Sae8vBATubxxA==}
     engines: {node: '>=14', npm: '>=6', yarn: '>=1'}
 
-  '@testing-library/react-hooks@8.0.1':
-    resolution: {integrity: sha512-Aqhl2IVmLt8IovEVarNDFuJDVWVvhnr9/GCU6UUnrYXwgDFF9h2L2o2P9KBni1AST5sT6riAyoukFLyjQUgD/g==}
-    engines: {node: '>=12'}
-    peerDependencies:
-      '@types/react': ^16.9.0 || ^17.0.0
-      react: ^16.9.0 || ^17.0.0
-      react-dom: ^16.9.0 || ^17.0.0
-      react-test-renderer: ^16.9.0 || ^17.0.0
-    peerDependenciesMeta:
-      '@types/react':
-        optional: true
-      react-dom:
-        optional: true
-      react-test-renderer:
-        optional: true
-
   '@testing-library/react@15.0.7':
     resolution: {integrity: sha512-cg0RvEdD1TIhhkm1IeYMQxrzy0MtUNfa3minv4MjbgcYzJAZ7yD0i0lwoPOTPr+INtiXFezt2o8xMSnyHhEn2Q==}
     engines: {node: '>=18'}
@@ -13370,9 +13354,6 @@ packages:
   '@types/react-test-renderer@19.1.0':
     resolution: {integrity: sha512-XD0WZrHqjNrxA/MaR9O22w/RNidWR9YZmBdRGI7wcnWGrv/3dA8wKCJ8m63Sn+tLJhcjmuhOi629N66W6kgWzQ==}
 
-  '@types/react@18.0.38':
-    resolution: {integrity: sha512-ExsidLLSzYj4cvaQjGnQCk4HFfVT9+EZ9XZsQ8Hsrcn8QNgXtpZ3m9vSIC2MWtx7jHictK6wYhQgGh6ic58oOw==}
-
   '@types/react@18.2.79':
     resolution: {integrity: sha512-RwGAGXPl9kSXwdNTafkOEuFrTBD5SA2B3iEB96xi8+xu5ddUa/cpvyVCSNn+asgLCTHkb5ZxN8gbuibYJi4s1w==}
 
@@ -13394,9 +13375,6 @@ packages:
   '@types/retry@0.12.2':
     resolution: {integrity: sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==}
 
-  '@types/scheduler@0.26.0':
-    resolution: {integrity: sha512-WFHp9YUJQ6CKshqoC37iOlHnQSmxNc795UhB26CyBBttrN9svdIrUjl/NjnNmfcwtncN0h/0PPAFWv9ovP8mLA==}
-
   '@types/semver@7.5.8':
     resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==}
 
@@ -22878,12 +22856,6 @@ packages:
       react: ^0.14.8 || ^15.0.1 || ^16.0.0 || ^17.0.1 || ^18.0.0
       react-dom: ^0.14.8 || ^15.0.1 || ^16.0.0 || ^17.0.1 || ^18.0.0
 
-  react-error-boundary@3.1.4:
-    resolution: {integrity: sha512-uM9uPzZJTF6wRQORmSrvOIgt4lJ9MC1sNgEOj2XGsDTRE4kmpWxg7ENK9EWNKJRMAOY9z0MuF4yIfl6gp4sotA==}
-    engines: {node: '>=10', npm: '>=6'}
-    peerDependencies:
-      react: '>=16.13.1'
-
   react-error-boundary@4.1.2:
     resolution: {integrity: sha512-GQDxZ5Jd+Aq/qUxbCm1UtzmL/s++V7zKgE8yMktJiCQXCCFZnMZh9ng+6/Ne6PjNSXH0L9CjeOEREfRnq6Duag==}
     peerDependencies:
@@ -23152,11 +23124,6 @@ packages:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
       react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
-  react-shallow-renderer@16.15.0:
-    resolution: {integrity: sha512-oScf2FqQ9LFVQgA73vr86xl2NaOIX73rh+YFqcOp68CWj56tSfgtGKrEbyhCj0rSijyG9M1CYprTh39fBi5hzA==}
-    peerDependencies:
-      react: ^16.0.0 || ^17.0.0 || ^18.0.0
-
   react-side-effect@2.1.2:
     resolution: {integrity: sha512-PVjOcvVOyIILrYoyGEpDN3vmYNLdy1CajSFNt4TDsVQC5KpTijDvWVoR+/7Rz2xT978D8/ZtFceXxzsPwZEDvw==}
     peerDependencies:
@@ -23178,11 +23145,6 @@ packages:
       '@types/react':
         optional: true
 
-  react-test-renderer@18.3.1:
-    resolution: {integrity: sha512-KkAgygexHUkQqtvvx/otwxtuFu5cVjfzTCtjXLH9boS19/Nbtg84zS7wIQn39G8IlrhThBpQsMKkq5ZHZIYFXA==}
-    peerDependencies:
-      react: ^18.3.1
-
   react-test-renderer@19.1.0:
     resolution: {integrity: sha512-jXkSl3CpvPYEF+p/eGDLB4sPoDX8pKkYvRl9+rR8HxLY0X04vW7hCm1/0zHoUSjPZ3bDa+wXWNTDVIw/R8aDVw==}
     peerDependencies:
@@ -25163,27 +25125,6 @@ packages:
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
 
-  ts-jest@29.0.1:
-    resolution: {integrity: sha512-htQOHshgvhn93QLxrmxpiQPk69+M1g7govO1g6kf6GsjCv4uvRV0znVmDrrvjUrVCnTYeY4FBxTYYYD4airyJA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-    hasBin: true
-    peerDependencies:
-      '@babel/core': '>=7.0.0-beta.0 <8'
-      '@jest/types': ^29.0.0
-      babel-jest: ^29.0.0
-      esbuild: '*'
-      jest: ^29.0.0
-      typescript: '>=4.3'
-    peerDependenciesMeta:
-      '@babel/core':
-        optional: true
-      '@jest/types':
-        optional: true
-      babel-jest:
-        optional: true
-      esbuild:
-        optional: true
-
   ts-jest@29.1.5:
     resolution: {integrity: sha512-UuClSYxM7byvvYfyWdFI+/2UxMmwNyJb0NPkZPQE2hew3RurV7l7zURgOHAd/1I1ZdPpe3GUsXNXAcN8TFKSIg==}
     engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0}
@@ -29528,41 +29469,6 @@ snapshots:
       - supports-color
       - ts-node
 
-  '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))':
-    dependencies:
-      '@jest/console': 29.7.0
-      '@jest/reporters': 29.7.0
-      '@jest/test-result': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 20.19.5
-      ansi-escapes: 4.3.2
-      chalk: 4.1.2
-      ci-info: 3.9.0
-      exit: 0.1.2
-      graceful-fs: 4.2.11
-      jest-changed-files: 29.7.0
-      jest-config: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      jest-haste-map: 29.7.0
-      jest-message-util: 29.7.0
-      jest-regex-util: 29.6.3
-      jest-resolve: 29.7.0
-      jest-resolve-dependencies: 29.7.0
-      jest-runner: 29.7.0
-      jest-runtime: 29.7.0
-      jest-snapshot: 29.7.0
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      jest-watcher: 29.7.0
-      micromatch: 4.0.8
-      pretty-format: 29.7.0
-      slash: 3.0.0
-      strip-ansi: 6.0.1
-    transitivePeerDependencies:
-      - babel-plugin-macros
-      - supports-color
-      - ts-node
-
   '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4))':
     dependencies:
       '@jest/console': 29.7.0
@@ -30391,22 +30297,22 @@ snapshots:
       - webpack-hot-middleware
       - webpack-plugin-serve
 
-  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
+  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
     dependencies:
       '@babel/parser': 7.29.2
       '@babel/traverse': 7.29.0
       '@babel/types': 7.29.0
-      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
+      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
       '@modern-js/i18n-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/plugin-data-loader': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       '@swc/helpers': 0.5.17
       es-module-lexer: 1.7.0
       esbuild: 0.25.5
@@ -30442,22 +30348,22 @@ snapshots:
       - webpack
       - webpack-hot-middleware
 
-  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
+  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
     dependencies:
       '@babel/parser': 7.29.2
       '@babel/traverse': 7.29.0
       '@babel/types': 7.29.0
-      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/i18n-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/plugin-data-loader': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@swc/helpers': 0.5.17
       es-module-lexer: 1.7.0
       esbuild: 0.25.5
@@ -30493,22 +30399,22 @@ snapshots:
       - webpack
       - webpack-hot-middleware
 
-  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
+  '@modern-js/app-tools@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(core-js@3.49.0)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
     dependencies:
       '@babel/parser': 7.29.2
       '@babel/traverse': 7.29.0
       '@babel/types': 7.29.0
-      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+      '@modern-js/builder': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       '@modern-js/i18n-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/plugin-data-loader': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/prod-server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@swc/helpers': 0.5.17
       es-module-lexer: 1.7.0
       esbuild: 0.25.5
@@ -30613,7 +30519,7 @@ snapshots:
       - '@rsbuild/core'
       - supports-color
 
-  '@modern-js/babel-preset@2.68.0(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@modern-js/babel-preset@2.68.0(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-proposal-decorators': 7.29.0(@babel/core@7.29.0)
@@ -30625,7 +30531,7 @@ snapshots:
       '@babel/preset-typescript': 7.28.5(@babel/core@7.29.0)
       '@babel/runtime': 7.28.2
       '@babel/types': 7.29.0
-      '@rsbuild/plugin-babel': 1.0.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-babel': 1.0.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       '@swc/helpers': 0.5.17
       '@types/babel__core': 7.20.5
       babel-plugin-dynamic-import-node: 2.3.3
@@ -30676,22 +30582,22 @@ snapshots:
       - '@rsbuild/core'
       - supports-color
 
-  '@modern-js/builder@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
+  '@modern-js/builder@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.9.3)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
     dependencies:
       '@modern-js/flight-server-transform-plugin': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
-      '@rsbuild/plugin-assets-retry': 1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-check-syntax': 1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-css-minimizer': 1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
-      '@rsbuild/plugin-less': 1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-react': 1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
-      '@rsbuild/plugin-rem': 1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-sass': 1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-source-build': 1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
-      '@rsbuild/plugin-svgr': 1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(typescript@5.9.3)(webpack-hot-middleware@2.26.1)
-      '@rsbuild/plugin-type-check': 1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)
-      '@rsbuild/plugin-typed-css-modules': 1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/plugin-assets-retry': 1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-check-syntax': 1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-css-minimizer': 1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
+      '@rsbuild/plugin-less': 1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-react': 1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rsbuild/plugin-rem': 1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-sass': 1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-source-build': 1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
+      '@rsbuild/plugin-svgr': 1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(typescript@5.9.3)(webpack-hot-middleware@2.26.1)
+      '@rsbuild/plugin-type-check': 1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)
+      '@rsbuild/plugin-typed-css-modules': 1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))
       '@swc/core': 1.15.10(@swc/helpers@0.5.17)
       '@swc/helpers': 0.5.17
       autoprefixer: 10.4.24(postcss@8.5.8)
@@ -30708,7 +30614,7 @@ snapshots:
       postcss-media-minmax: 5.0.0(postcss@8.5.8)
       postcss-nesting: 12.1.5(postcss@8.5.8)
       postcss-page-break: 3.0.4(postcss@8.5.8)
-      rspack-manifest-plugin: 5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))
+      rspack-manifest-plugin: 5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))
       ts-deepmerge: 7.0.3
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
@@ -30727,22 +30633,22 @@ snapshots:
       - webpack
       - webpack-hot-middleware
 
-  '@modern-js/builder@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
+  '@modern-js/builder@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(esbuild@0.25.5)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(tslib@2.8.1)(typescript@5.0.4)(webpack-hot-middleware@2.26.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
     dependencies:
       '@modern-js/flight-server-transform-plugin': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
-      '@rsbuild/plugin-assets-retry': 1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-check-syntax': 1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-css-minimizer': 1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
-      '@rsbuild/plugin-less': 1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-react': 1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
-      '@rsbuild/plugin-rem': 1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-sass': 1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-source-build': 1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
-      '@rsbuild/plugin-svgr': 1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(typescript@5.0.4)(webpack-hot-middleware@2.26.1)
-      '@rsbuild/plugin-type-check': 1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)
-      '@rsbuild/plugin-typed-css-modules': 1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/plugin-assets-retry': 1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-check-syntax': 1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-css-minimizer': 1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
+      '@rsbuild/plugin-less': 1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-react': 1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rsbuild/plugin-rem': 1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-sass': 1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-source-build': 1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
+      '@rsbuild/plugin-svgr': 1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(typescript@5.0.4)(webpack-hot-middleware@2.26.1)
+      '@rsbuild/plugin-type-check': 1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)
+      '@rsbuild/plugin-typed-css-modules': 1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       '@swc/core': 1.15.10(@swc/helpers@0.5.17)
       '@swc/helpers': 0.5.17
       autoprefixer: 10.4.24(postcss@8.5.8)
@@ -30759,7 +30665,7 @@ snapshots:
       postcss-media-minmax: 5.0.0(postcss@8.5.8)
       postcss-nesting: 12.1.5(postcss@8.5.8)
       postcss-page-break: 3.0.4(postcss@8.5.8)
-      rspack-manifest-plugin: 5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))
+      rspack-manifest-plugin: 5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))
       ts-deepmerge: 7.0.3
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
@@ -30978,10 +30884,10 @@ snapshots:
       '@modern-js/utils': 2.70.8
       '@swc/helpers': 0.5.17
 
-  '@modern-js/plugin-server@2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/plugin-server@2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 2.68.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-utils': 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+      '@modern-js/server-utils': 2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       '@modern-js/utils': 2.68.0
       '@swc/helpers': 0.5.17
     transitivePeerDependencies:
@@ -31044,12 +30950,12 @@ snapshots:
       '@modern-js/utils': 2.70.8
       '@swc/helpers': 0.5.17
 
-  '@modern-js/plugin@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/plugin@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       '@swc/helpers': 0.5.17
       jiti: 2.6.1
     transitivePeerDependencies:
@@ -31058,12 +30964,12 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/plugin@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/plugin@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@swc/helpers': 0.5.17
       jiti: 2.6.1
     transitivePeerDependencies:
@@ -31092,10 +30998,10 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/prod-server@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/prod-server@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@swc/helpers': 0.5.17
     transitivePeerDependencies:
@@ -31104,10 +31010,10 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/prod-server@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/prod-server@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@swc/helpers': 0.5.17
     transitivePeerDependencies:
@@ -31287,11 +31193,11 @@ snapshots:
       - react-server-dom-webpack
       - supports-color
 
-  '@modern-js/runtime@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4)))(react@18.3.1)':
+  '@modern-js/runtime@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4)))(react@18.3.1)':
     dependencies:
       '@loadable/component': 5.16.7(react@18.3.1)
       '@loadable/server': 5.16.7(@loadable/component@5.16.7(react@18.3.1))(react@18.3.1)
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/plugin-data-loader': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/render': 3.0.1(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4)))(react@18.3.1)
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -31316,11 +31222,11 @@ snapshots:
       - core-js
       - react-server-dom-webpack
 
-  '@modern-js/runtime@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)':
+  '@modern-js/runtime@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)':
     dependencies:
       '@loadable/component': 5.16.7(react@18.3.1)
       '@loadable/server': 5.16.7(@loadable/component@5.16.7(react@18.3.1))(react@18.3.1)
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/plugin-data-loader': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/render': 3.0.1(react-dom@18.3.1(react@18.3.1))(react-server-dom-webpack@19.2.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1))))(react@18.3.1)
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -31381,9 +31287,9 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/server-core@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/server-core@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@swc/helpers': 0.5.17
@@ -31400,9 +31306,9 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/server-core@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/server-core@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/plugin': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@swc/helpers': 0.5.17
@@ -31428,10 +31334,10 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/server-runtime@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/server-runtime@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@swc/helpers': 0.5.17
     transitivePeerDependencies:
@@ -31440,10 +31346,10 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/server-runtime@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@modern-js/server-runtime@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@swc/helpers': 0.5.17
     transitivePeerDependencies:
@@ -31452,7 +31358,7 @@ snapshots:
       - react
       - react-dom
 
-  '@modern-js/server-utils@2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@modern-js/server-utils@2.68.0(@babel/traverse@7.29.0)(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-proposal-decorators': 7.29.0(@babel/core@7.29.0)
@@ -31461,7 +31367,7 @@ snapshots:
       '@babel/preset-typescript': 7.28.5(@babel/core@7.29.0)
       '@modern-js/babel-compiler': 2.68.0
       '@modern-js/babel-plugin-module-resolver': 2.68.0
-      '@modern-js/babel-preset': 2.68.0(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+      '@modern-js/babel-preset': 2.68.0(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       '@modern-js/utils': 2.68.0
       '@swc/helpers': 0.5.17
       babel-plugin-transform-typescript-metadata: 0.3.2(@babel/core@7.29.0)(@babel/traverse@7.29.0)
@@ -31572,10 +31478,10 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)':
+  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@25.6.0)(typescript@5.9.3))(tsconfig-paths@4.2.0)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -31598,10 +31504,10 @@ snapshots:
       - react-dom
       - utf-8-validate
 
-  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)':
+  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.8.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@3.14.2)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -31624,10 +31530,10 @@ snapshots:
       - react-dom
       - utf-8-validate
 
-  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)':
+  '@modern-js/server@3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.0.4))(tsconfig-paths@4.2.0)':
     dependencies:
       '@modern-js/runtime-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@modern-js/server-core': 3.0.1(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/server-utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@modern-js/types': 3.0.1
       '@modern-js/utils': 3.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -32270,7 +32176,7 @@ snapshots:
 
   '@module-federation/error-codes@2.2.2': {}
 
-  '@module-federation/error-codes@2.3.2':
+  '@module-federation/error-codes@2.4.0':
     optional: true
 
   '@module-federation/inject-external-runtime-core-plugin@0.21.6(@module-federation/runtime-tools@0.21.6)':
@@ -32431,18 +32337,18 @@ snapshots:
     transitivePeerDependencies:
       - node-fetch
 
-  '@module-federation/runtime-core@2.3.2(node-fetch@3.3.0)':
+  '@module-federation/runtime-core@2.4.0(node-fetch@3.3.0)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.0)
     transitivePeerDependencies:
       - node-fetch
     optional: true
 
-  '@module-federation/runtime-core@2.3.2(node-fetch@3.3.2)':
+  '@module-federation/runtime-core@2.4.0(node-fetch@3.3.2)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.2)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.2)
     transitivePeerDependencies:
       - node-fetch
     optional: true
@@ -32499,18 +32405,18 @@ snapshots:
     transitivePeerDependencies:
       - node-fetch
 
-  '@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0)':
+  '@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0)':
     dependencies:
-      '@module-federation/runtime': 2.3.2(node-fetch@3.3.0)
-      '@module-federation/webpack-bundler-runtime': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/runtime': 2.4.0(node-fetch@3.3.0)
+      '@module-federation/webpack-bundler-runtime': 2.4.0(node-fetch@3.3.0)
     transitivePeerDependencies:
       - node-fetch
     optional: true
 
-  '@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2)':
+  '@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2)':
     dependencies:
-      '@module-federation/runtime': 2.3.2(node-fetch@3.3.2)
-      '@module-federation/webpack-bundler-runtime': 2.3.2(node-fetch@3.3.2)
+      '@module-federation/runtime': 2.4.0(node-fetch@3.3.2)
+      '@module-federation/webpack-bundler-runtime': 2.4.0(node-fetch@3.3.2)
     transitivePeerDependencies:
       - node-fetch
     optional: true
@@ -32573,20 +32479,20 @@ snapshots:
     transitivePeerDependencies:
       - node-fetch
 
-  '@module-federation/runtime@2.3.2(node-fetch@3.3.0)':
+  '@module-federation/runtime@2.4.0(node-fetch@3.3.0)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/runtime-core': 2.3.2(node-fetch@3.3.0)
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/runtime-core': 2.4.0(node-fetch@3.3.0)
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.0)
     transitivePeerDependencies:
       - node-fetch
     optional: true
 
-  '@module-federation/runtime@2.3.2(node-fetch@3.3.2)':
+  '@module-federation/runtime@2.4.0(node-fetch@3.3.2)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/runtime-core': 2.3.2(node-fetch@3.3.2)
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.2)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/runtime-core': 2.4.0(node-fetch@3.3.2)
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.2)
     transitivePeerDependencies:
       - node-fetch
     optional: true
@@ -32613,12 +32519,12 @@ snapshots:
     optionalDependencies:
       node-fetch: 2.7.0(encoding@0.1.13)
 
-  '@module-federation/sdk@2.3.2(node-fetch@3.3.0)':
+  '@module-federation/sdk@2.4.0(node-fetch@3.3.0)':
     optionalDependencies:
       node-fetch: 3.3.0
     optional: true
 
-  '@module-federation/sdk@2.3.2(node-fetch@3.3.2)':
+  '@module-federation/sdk@2.4.0(node-fetch@3.3.2)':
     optionalDependencies:
       node-fetch: 3.3.2
     optional: true
@@ -32687,20 +32593,20 @@ snapshots:
     transitivePeerDependencies:
       - node-fetch
 
-  '@module-federation/webpack-bundler-runtime@2.3.2(node-fetch@3.3.0)':
+  '@module-federation/webpack-bundler-runtime@2.4.0(node-fetch@3.3.0)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/runtime': 2.3.2(node-fetch@3.3.0)
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/runtime': 2.4.0(node-fetch@3.3.0)
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.0)
     transitivePeerDependencies:
       - node-fetch
     optional: true
 
-  '@module-federation/webpack-bundler-runtime@2.3.2(node-fetch@3.3.2)':
+  '@module-federation/webpack-bundler-runtime@2.4.0(node-fetch@3.3.2)':
     dependencies:
-      '@module-federation/error-codes': 2.3.2
-      '@module-federation/runtime': 2.3.2(node-fetch@3.3.2)
-      '@module-federation/sdk': 2.3.2(node-fetch@3.3.2)
+      '@module-federation/error-codes': 2.4.0
+      '@module-federation/runtime': 2.4.0(node-fetch@3.3.2)
+      '@module-federation/sdk': 2.4.0(node-fetch@3.3.2)
     transitivePeerDependencies:
       - node-fetch
     optional: true
@@ -36193,9 +36099,9 @@ snapshots:
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
 
-  '@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)':
+  '@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)':
     dependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.19)
       '@swc/helpers': 0.5.19
       jiti: 2.6.1
     optionalDependencies:
@@ -36203,9 +36109,9 @@ snapshots:
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
 
-  '@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)':
+  '@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)':
     dependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
       '@swc/helpers': 0.5.19
       jiti: 2.6.1
     optionalDependencies:
@@ -36213,9 +36119,9 @@ snapshots:
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
 
-  '@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)':
+  '@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)':
     dependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
       '@swc/helpers': 0.5.19
       jiti: 2.6.1
     optionalDependencies:
@@ -36223,13 +36129,13 @@ snapshots:
     transitivePeerDependencies:
       - '@module-federation/runtime-tools'
 
-  '@rsbuild/plugin-assets-retry@1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-assets-retry@1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
 
-  '@rsbuild/plugin-assets-retry@1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-assets-retry@1.5.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   '@rsbuild/plugin-assets-retry@1.5.2(@rsbuild/core@1.7.3)':
     optionalDependencies:
@@ -36249,13 +36155,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@rsbuild/plugin-babel@1.0.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-babel@1.0.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-proposal-decorators': 7.29.0(@babel/core@7.29.0)
       '@babel/plugin-transform-class-properties': 7.28.6(@babel/core@7.29.0)
       '@babel/preset-typescript': 7.28.5(@babel/core@7.29.0)
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@types/babel__core': 7.20.5
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
@@ -36287,7 +36193,7 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-check-syntax@1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-check-syntax@1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     dependencies:
       acorn: 8.16.0
       browserslist-to-es-version: 1.4.1
@@ -36295,9 +36201,9 @@ snapshots:
       picocolors: 1.1.1
       source-map: 0.7.6
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
 
-  '@rsbuild/plugin-check-syntax@1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-check-syntax@1.6.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       acorn: 8.16.0
       browserslist-to-es-version: 1.4.1
@@ -36305,7 +36211,7 @@ snapshots:
       picocolors: 1.1.1
       source-map: 0.7.6
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   '@rsbuild/plugin-css-minimizer@1.1.1(@rsbuild/core@1.7.3)(esbuild@0.18.20)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.18.20)(webpack-cli@5.1.4))':
     dependencies:
@@ -36352,12 +36258,12 @@ snapshots:
       - lightningcss
       - webpack
 
-  '@rsbuild/plugin-css-minimizer@1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
+  '@rsbuild/plugin-css-minimizer@1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))':
     dependencies:
       css-minimizer-webpack-plugin: 7.0.2(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.17))(esbuild@0.25.5)(webpack-cli@5.1.4))
       reduce-configs: 1.1.1
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
     transitivePeerDependencies:
       - '@parcel/css'
       - '@swc/css'
@@ -36367,12 +36273,12 @@ snapshots:
       - lightningcss
       - webpack
 
-  '@rsbuild/plugin-css-minimizer@1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
+  '@rsbuild/plugin-css-minimizer@1.1.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))':
     dependencies:
       css-minimizer-webpack-plugin: 7.0.2(esbuild@0.25.5)(webpack@5.104.1(@swc/core@1.15.10(@swc/helpers@0.5.19))(esbuild@0.27.3)(webpack-cli@5.1.4(webpack-dev-server@5.2.3)(webpack@5.104.1)))
       reduce-configs: 1.1.1
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
     transitivePeerDependencies:
       - '@parcel/css'
       - '@swc/css'
@@ -36388,15 +36294,15 @@ snapshots:
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
 
-  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
 
-  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
 
@@ -36465,17 +36371,17 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-react@1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-react@1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       '@rspack/plugin-react-refresh': 1.6.1(react-refresh@0.18.0)(webpack-hot-middleware@2.26.1)
       react-refresh: 0.18.0
     transitivePeerDependencies:
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-react@1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-react@1.4.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@rspack/plugin-react-refresh': 1.6.1(react-refresh@0.18.0)(webpack-hot-middleware@2.26.1)
       react-refresh: 0.18.0
     transitivePeerDependencies:
@@ -36497,25 +36403,25 @@ snapshots:
     transitivePeerDependencies:
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       '@rspack/plugin-react-refresh': 1.6.1(react-refresh@0.18.0)(webpack-hot-middleware@2.26.1)
       react-refresh: 0.18.0
     transitivePeerDependencies:
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@rspack/plugin-react-refresh': 1.6.1(react-refresh@0.18.0)(webpack-hot-middleware@2.26.1)
       react-refresh: 0.18.0
     transitivePeerDependencies:
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-react@1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@rspack/plugin-react-refresh': 1.6.1(react-refresh@0.18.0)(webpack-hot-middleware@2.26.1)
       react-refresh: 0.18.0
     transitivePeerDependencies:
@@ -36528,19 +36434,19 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-rem@1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-rem@1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     dependencies:
       deepmerge: 4.3.1
       terser: 5.46.1
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
 
-  '@rsbuild/plugin-rem@1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-rem@1.0.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       deepmerge: 4.3.1
       terser: 5.46.1
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@1.7.3)':
     dependencies:
@@ -36551,25 +36457,25 @@ snapshots:
       reduce-configs: 1.1.1
       sass-embedded: 1.98.0
 
-  '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
       deepmerge: 4.3.1
       loader-utils: 2.0.4
       postcss: 8.5.8
       reduce-configs: 1.1.1
       sass-embedded: 1.98.0
 
-  '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       deepmerge: 4.3.1
       loader-utils: 2.0.4
       postcss: 8.5.8
       reduce-configs: 1.1.1
       sass-embedded: 1.98.0
 
-  '@rsbuild/plugin-sass@1.5.1(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-sass@1.5.1(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       deepmerge: 4.3.1
       loader-utils: 2.0.4
@@ -36577,7 +36483,7 @@ snapshots:
       reduce-configs: 1.1.1
       sass-embedded: 1.98.0
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@1.7.3)':
     dependencies:
@@ -36587,21 +36493,21 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     dependencies:
       fast-glob: 3.3.3
       json5: 2.2.3
       yaml: 2.8.2
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
 
-  '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     dependencies:
       fast-glob: 3.3.3
       json5: 2.2.3
       yaml: 2.8.2
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   '@rsbuild/plugin-styled-components@1.6.0(@rsbuild/core@1.7.3)':
     dependencies:
@@ -36624,10 +36530,10 @@ snapshots:
       - typescript
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-svgr@1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(typescript@5.9.3)(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-svgr@1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(typescript@5.9.3)(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
-      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@svgr/core': 8.1.0(typescript@5.9.3)
       '@svgr/plugin-jsx': 8.1.0(@svgr/core@8.1.0(typescript@5.9.3))
       '@svgr/plugin-svgo': 8.1.0(@svgr/core@8.1.0(typescript@5.9.3))(typescript@5.9.3)
@@ -36638,10 +36544,10 @@ snapshots:
       - typescript
       - webpack-hot-middleware
 
-  '@rsbuild/plugin-svgr@1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(typescript@5.0.4)(webpack-hot-middleware@2.26.1)':
+  '@rsbuild/plugin-svgr@1.3.0(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(typescript@5.0.4)(webpack-hot-middleware@2.26.1)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
-      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
       '@svgr/core': 8.1.0(typescript@5.0.4)
       '@svgr/plugin-jsx': 8.1.0(@svgr/core@8.1.0(typescript@5.9.3))
       '@svgr/plugin-svgo': 8.1.0(@svgr/core@8.1.0(typescript@5.9.3))(typescript@5.0.4)
@@ -36671,27 +36577,27 @@ snapshots:
       - tslib
       - typescript
 
-  '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)':
+  '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)':
     dependencies:
       deepmerge: 4.3.1
       json5: 2.2.3
       reduce-configs: 1.1.1
-      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)
+      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3)
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
     transitivePeerDependencies:
       - '@rspack/core'
       - tslib
       - typescript
 
-  '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)':
+  '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)':
     dependencies:
       deepmerge: 4.3.1
       json5: 2.2.3
       reduce-configs: 1.1.1
-      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)
+      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4)
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
     transitivePeerDependencies:
       - '@rspack/core'
       - tslib
@@ -36710,14 +36616,14 @@ snapshots:
       - tslib
       - typescript
 
-  '@rsbuild/plugin-type-check@1.3.4(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)':
+  '@rsbuild/plugin-type-check@1.3.4(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)':
     dependencies:
       deepmerge: 4.3.1
       json5: 2.2.3
       reduce-configs: 1.1.1
-      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)
+      ts-checker-rspack-plugin: 1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
     transitivePeerDependencies:
       - '@rspack/core'
       - tslib
@@ -36727,17 +36633,17 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-typed-css-modules@1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0))':
+  '@rsbuild/plugin-typed-css-modules@1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0))':
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(core-js@3.49.0)
 
-  '@rsbuild/plugin-typed-css-modules@1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))':
+  '@rsbuild/plugin-typed-css-modules@1.2.1(@rsbuild/core@2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))':
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.2(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
-  '@rsbuild/plugin-vue@1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))':
+  '@rsbuild/plugin-vue@1.2.7(@rsbuild/core@1.7.3)(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))':
     dependencies:
-      rspack-vue-loader: 17.5.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
+      rspack-vue-loader: 17.5.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3))
     optionalDependencies:
       '@rsbuild/core': 1.7.3
     transitivePeerDependencies:
@@ -37453,29 +37359,29 @@ snapshots:
       '@module-federation/runtime-tools': 0.21.6
       '@swc/helpers': 0.5.19
 
-  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17)':
+  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17)':
     dependencies:
       '@rspack/binding': 2.0.0-beta.0
       '@rspack/lite-tapable': 1.1.0
     optionalDependencies:
-      '@module-federation/runtime-tools': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/runtime-tools': 2.4.0(node-fetch@3.3.0)
       '@swc/helpers': 0.5.17
     optional: true
 
-  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.19)':
+  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.19)':
     dependencies:
       '@rspack/binding': 2.0.0-beta.0
       '@rspack/lite-tapable': 1.1.0
     optionalDependencies:
-      '@module-federation/runtime-tools': 2.3.2(node-fetch@3.3.0)
+      '@module-federation/runtime-tools': 2.4.0(node-fetch@3.3.0)
       '@swc/helpers': 0.5.19
 
-  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)':
+  '@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)':
     dependencies:
       '@rspack/binding': 2.0.0-beta.0
       '@rspack/lite-tapable': 1.1.0
     optionalDependencies:
-      '@module-federation/runtime-tools': 2.3.2(node-fetch@3.3.2)
+      '@module-federation/runtime-tools': 2.4.0(node-fetch@3.3.2)
       '@swc/helpers': 0.5.19
 
   '@rspack/dev-server@1.1.1(@rspack/core@1.3.9(@swc/helpers@0.5.13))(@types/express@4.17.21)(webpack-cli@5.1.4)(webpack@5.104.1)':
@@ -37514,13 +37420,13 @@ snapshots:
     optionalDependencies:
       webpack-hot-middleware: 2.26.1
 
-  '@rspress/core@2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@18.3.28)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)':
+  '@rspress/core@2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@18.3.28)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)':
     dependencies:
       '@mdx-js/mdx': 3.1.1
       '@mdx-js/react': 3.1.1(@types/react@18.3.28)(react@19.2.4)
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
-      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
-      '@rspress/shared': 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rspress/shared': 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@shikijs/rehype': 3.23.0
       '@types/unist': 3.0.3
       '@unhead/react': 2.1.12(react@19.2.4)
@@ -37565,13 +37471,13 @@ snapshots:
       - supports-color
       - webpack-hot-middleware
 
-  '@rspress/core@2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)':
+  '@rspress/core@2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)':
     dependencies:
       '@mdx-js/mdx': 3.1.1
       '@mdx-js/react': 3.1.1(@types/react@19.2.14)(react@19.2.4)
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
-      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
-      '@rspress/shared': 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/plugin-react': 1.4.5(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(webpack-hot-middleware@2.26.1)
+      '@rspress/shared': 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@shikijs/rehype': 3.23.0
       '@types/unist': 3.0.3
       '@unhead/react': 2.1.12(react@19.2.4)
@@ -37616,9 +37522,9 @@ snapshots:
       - supports-color
       - webpack-hot-middleware
 
-  '@rspress/plugin-llms@2.0.1(@rspress/core@2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1))':
+  '@rspress/plugin-llms@2.0.1(@rspress/core@2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1))':
     dependencies:
-      '@rspress/core': 2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
+      '@rspress/core': 2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@types/react@19.2.14)(core-js@3.49.0)(webpack-hot-middleware@2.26.1)
       remark-mdx: 3.1.1
       remark-parse: 11.0.0
       remark-stringify: 11.0.0
@@ -37627,9 +37533,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@rspress/shared@2.0.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)':
+  '@rspress/shared@2.0.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)':
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@shikijs/rehype': 3.23.0
       gray-matter: 4.0.3
       lodash-es: 4.17.23
@@ -38927,16 +38833,6 @@ snapshots:
       lodash: 4.17.23
       redent: 3.0.0
 
-  '@testing-library/react-hooks@8.0.1(@types/react@18.0.38)(react-dom@18.3.1(react@18.3.1))(react-test-renderer@18.3.1(react@18.3.1))(react@18.3.1)':
-    dependencies:
-      '@babel/runtime': 7.28.2
-      react: 18.3.1
-      react-error-boundary: 3.1.4(react@18.3.1)
-    optionalDependencies:
-      '@types/react': 18.0.38
-      react-dom: 18.3.1(react@18.3.1)
-      react-test-renderer: 18.3.1(react@18.3.1)
-
   '@testing-library/react@15.0.7(@types/react@18.2.79)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.28.2
@@ -39488,12 +39384,6 @@ snapshots:
     dependencies:
       '@types/react': 19.2.14
 
-  '@types/react@18.0.38':
-    dependencies:
-      '@types/prop-types': 15.7.15
-      '@types/scheduler': 0.26.0
-      csstype: 3.2.3
-
   '@types/react@18.2.79':
     dependencies:
       '@types/prop-types': 15.7.15
@@ -39519,8 +39409,6 @@ snapshots:
 
   '@types/retry@0.12.2': {}
 
-  '@types/scheduler@0.26.0': {}
-
   '@types/semver@7.5.8': {}
 
   '@types/send@0.17.6':
@@ -43353,21 +43241,6 @@ snapshots:
       - supports-color
       - ts-node
 
-  create-jest@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)):
-    dependencies:
-      '@jest/types': 29.6.3
-      chalk: 4.1.2
-      exit: 0.1.2
-      graceful-fs: 4.2.11
-      jest-config: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      jest-util: 29.7.0
-      prompts: 2.4.2
-    transitivePeerDependencies:
-      - '@types/node'
-      - babel-plugin-macros
-      - supports-color
-      - ts-node
-
   create-jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4)):
     dependencies:
       '@jest/types': 29.6.3
@@ -47870,25 +47743,6 @@ snapshots:
       - supports-color
       - ts-node
 
-  jest-cli@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)):
-    dependencies:
-      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      '@jest/test-result': 29.7.0
-      '@jest/types': 29.6.3
-      chalk: 4.1.2
-      create-jest: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      exit: 0.1.2
-      import-local: 3.2.0
-      jest-config: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      yargs: 17.7.2
-    transitivePeerDependencies:
-      - '@types/node'
-      - babel-plugin-macros
-      - supports-color
-      - ts-node
-
   jest-cli@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4)):
     dependencies:
       '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4))
@@ -47970,37 +47824,6 @@ snapshots:
       - babel-plugin-macros
       - supports-color
 
-  jest-config@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)):
-    dependencies:
-      '@babel/core': 7.29.0
-      '@jest/test-sequencer': 29.7.0
-      '@jest/types': 29.6.3
-      babel-jest: 29.7.0(@babel/core@7.29.0)
-      chalk: 4.1.2
-      ci-info: 3.9.0
-      deepmerge: 4.3.1
-      glob: 7.2.0
-      graceful-fs: 4.2.11
-      jest-circus: 29.7.0(babel-plugin-macros@3.1.0)
-      jest-environment-node: 29.7.0
-      jest-get-type: 29.6.3
-      jest-regex-util: 29.6.3
-      jest-resolve: 29.7.0
-      jest-runner: 29.7.0
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      micromatch: 4.0.8
-      parse-json: 5.2.0
-      pretty-format: 29.7.0
-      slash: 3.0.0
-      strip-json-comments: 3.1.1
-    optionalDependencies:
-      '@types/node': 20.19.5
-      ts-node: 10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)
-    transitivePeerDependencies:
-      - babel-plugin-macros
-      - supports-color
-
   jest-config@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4)):
     dependencies:
       '@babel/core': 7.29.0
@@ -48334,18 +48157,6 @@ snapshots:
       - supports-color
       - ts-node
 
-  jest@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)):
-    dependencies:
-      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      '@jest/types': 29.6.3
-      import-local: 3.2.0
-      jest-cli: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-    transitivePeerDependencies:
-      - '@types/node'
-      - babel-plugin-macros
-      - supports-color
-      - ts-node
-
   jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4)):
     dependencies:
       '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@25.6.0)(typescript@5.0.4))
@@ -53587,11 +53398,6 @@ snapshots:
       react-dom: 19.2.4(react@19.2.4)
       react-is: 18.1.0
 
-  react-error-boundary@3.1.4(react@18.3.1):
-    dependencies:
-      '@babel/runtime': 7.28.2
-      react: 18.3.1
-
   react-error-boundary@4.1.2(react@18.3.1):
     dependencies:
       '@babel/runtime': 7.28.2
@@ -53952,11 +53758,6 @@ snapshots:
       '@remix-run/router': 1.23.1
       react: 19.2.4
 
-  react-router@6.30.3(react@18.3.1):
-    dependencies:
-      '@remix-run/router': 1.23.2
-      react: 18.3.1
-
   react-router@6.30.3(react@19.2.4):
     dependencies:
       '@remix-run/router': 1.23.2
@@ -54053,12 +53854,6 @@ snapshots:
       react: 17.0.2
       react-dom: 17.0.2(react@17.0.2)
 
-  react-shallow-renderer@16.15.0(react@18.3.1):
-    dependencies:
-      object-assign: 4.1.1
-      react: 18.3.1
-      react-is: 18.3.1
-
   react-side-effect@2.1.2(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -54091,13 +53886,6 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.14
 
-  react-test-renderer@18.3.1(react@18.3.1):
-    dependencies:
-      react: 18.3.1
-      react-is: 18.3.1
-      react-shallow-renderer: 16.15.0(react@18.3.1)
-      scheduler: 0.23.2
-
   react-test-renderer@19.1.0(react@19.1.0):
     dependencies:
       react: 19.1.0
@@ -54812,12 +54600,12 @@ snapshots:
       '@microsoft/api-extractor': 7.57.7(@types/node@25.6.0)
       typescript: 5.9.3
 
-  rsbuild-plugin-html-minifier-terser@1.1.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)):
+  rsbuild-plugin-html-minifier-terser@1.1.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)):
     dependencies:
       '@types/html-minifier-terser': 7.0.2
       html-minifier-terser: 7.2.0
     optionalDependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
 
   rsbuild-plugin-publint@0.2.1(@rsbuild/core@1.7.3):
     dependencies:
@@ -54842,24 +54630,24 @@ snapshots:
     optionalDependencies:
       '@rspack/core': 1.7.9(@swc/helpers@0.5.19)
 
-  rspack-manifest-plugin@5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17)):
+  rspack-manifest-plugin@5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17)):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17)
 
-  rspack-manifest-plugin@5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)):
+  rspack-manifest-plugin@5.2.1(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
 
-  rspack-vue-loader@17.5.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3)):
+  rspack-vue-loader@17.5.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(vue@3.5.30(typescript@5.9.3)):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
       chalk: 4.1.2
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
       vue: 3.5.30(typescript@5.9.3)
 
   run-applescript@7.1.0: {}
@@ -55628,18 +55416,18 @@ snapshots:
       es-errors: 1.3.0
       internal-slot: 1.1.0
 
-  storybook-addon-rslib@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rslib/core@0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3))(storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3))(typescript@5.9.3):
+  storybook-addon-rslib@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rslib/core@0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3))(storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3))(typescript@5.9.3):
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@rslib/core': 0.9.2(@microsoft/api-extractor@7.57.7(@types/node@25.6.0))(typescript@5.9.3)
-      storybook-builder-rsbuild: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)
+      storybook-builder-rsbuild: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
 
-  storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3):
+  storybook-builder-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3):
     dependencies:
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
-      '@rsbuild/plugin-type-check': 1.3.4(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/plugin-type-check': 1.3.4(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3)
       '@storybook/addon-docs': 8.6.18(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))
       '@storybook/core-webpack': 8.6.18(storybook@8.6.17(prettier@3.8.1))
       browser-assert: 1.2.1
@@ -55651,7 +55439,7 @@ snapshots:
       magic-string: 0.30.21
       path-browserify: 1.0.1
       process: 0.11.10
-      rsbuild-plugin-html-minifier-terser: 1.1.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))
+      rsbuild-plugin-html-minifier-terser: 1.1.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))
       sirv: 2.0.4
       storybook: 8.6.17(prettier@3.8.1)
       ts-dedent: 2.2.0
@@ -55665,10 +55453,10 @@ snapshots:
       - '@types/react'
       - tslib
 
-  storybook-react-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)(webpack@5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.25.0)(webpack-cli@5.1.4)):
+  storybook-react-rsbuild@1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(rollup@4.59.0)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)(webpack@5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.25.0)(webpack-cli@5.1.4)):
     dependencies:
       '@rollup/pluginutils': 5.3.0(rollup@4.59.0)
-      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0)
+      '@rsbuild/core': 2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0)
       '@storybook/react': 8.6.18(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(storybook@8.6.17(prettier@3.8.1))(typescript@5.9.3)
       '@storybook/react-docgen-typescript-plugin': 1.0.1(typescript@5.9.3)(webpack@5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.25.0)(webpack-cli@5.1.4))
       '@types/node': 18.19.130
@@ -55680,7 +55468,7 @@ snapshots:
       react-dom: 18.3.1(react@18.3.1)
       resolve: 1.22.11
       storybook: 8.6.17(prettier@3.8.1)
-      storybook-builder-rsbuild: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)
+      storybook-builder-rsbuild: 1.0.3(@rsbuild/core@2.0.0-beta.3(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(core-js@3.49.0))(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(@types/react@18.3.28)(storybook@8.6.17(prettier@3.8.1))(tslib@2.8.1)(typescript@5.9.3)
       tsconfig-paths: 4.2.0
     optionalDependencies:
       typescript: 5.9.3
@@ -56732,7 +56520,7 @@ snapshots:
     transitivePeerDependencies:
       - tslib
 
-  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3):
+  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17))(tslib@2.8.1)(typescript@5.9.3):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
       chokidar: 3.6.0
@@ -56740,11 +56528,11 @@ snapshots:
       picocolors: 1.1.1
       typescript: 5.9.3
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.0))(@swc/helpers@0.5.17)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.0))(@swc/helpers@0.5.17)
     transitivePeerDependencies:
       - tslib
 
-  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4):
+  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.0.4):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
       chokidar: 3.6.0
@@ -56752,11 +56540,11 @@ snapshots:
       picocolors: 1.1.1
       typescript: 5.0.4
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
     transitivePeerDependencies:
       - tslib
 
-  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3):
+  ts-checker-rspack-plugin@1.3.0(@rspack/core@2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19))(tslib@2.8.1)(typescript@5.9.3):
     dependencies:
       '@rspack/lite-tapable': 1.1.0
       chokidar: 3.6.0
@@ -56764,7 +56552,7 @@ snapshots:
       picocolors: 1.1.1
       typescript: 5.9.3
     optionalDependencies:
-      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.3.2(node-fetch@3.3.2))(@swc/helpers@0.5.19)
+      '@rspack/core': 2.0.0-beta.0(@module-federation/runtime-tools@2.4.0(node-fetch@3.3.2))(@swc/helpers@0.5.19)
     transitivePeerDependencies:
       - tslib
 
@@ -56776,24 +56564,6 @@ snapshots:
 
   ts-interface-checker@0.1.13: {}
 
-  ts-jest@29.0.1(@babel/core@7.29.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.29.0))(esbuild@0.27.3)(jest@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3)))(typescript@5.9.3):
-    dependencies:
-      bs-logger: 0.2.6
-      fast-json-stable-stringify: 2.1.0
-      jest: 29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.19))(@types/node@20.19.5)(typescript@5.9.3))
-      jest-util: 29.7.0
-      json5: 2.2.3
-      lodash.memoize: 4.1.2
-      make-error: 1.3.6
-      semver: 7.6.3
-      typescript: 5.9.3
-      yargs-parser: 21.1.1
-    optionalDependencies:
-      '@babel/core': 7.29.0
-      '@jest/types': 29.6.3
-      babel-jest: 29.7.0(@babel/core@7.29.0)
-      esbuild: 0.27.3
-
   ts-jest@29.1.5(@babel/core@7.29.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.29.0))(esbuild@0.27.3)(jest@29.7.0(@types/node@20.19.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(@types/node@20.19.5)(typescript@5.9.3)))(typescript@5.9.3):
     dependencies:
       bs-logger: 0.2.6
@@ -56906,6 +56676,26 @@ snapshots:
     optionalDependencies:
       '@swc/core': 1.7.26(@swc/helpers@0.5.13)
 
+  ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@20.19.5)(typescript@5.9.3):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.12
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 20.19.5
+      acorn: 8.16.0
+      acorn-walk: 8.3.5
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.4
+      make-error: 1.3.6
+      typescript: 5.9.3
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+    optionalDependencies:
+      '@swc/core': 1.15.10(@swc/helpers@0.5.17)
+
   ts-node@10.9.2(@swc/core@1.15.10(@swc/helpers@0.5.17))(@types/node@22.19.15)(typescript@5.6.3):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
diff --git a/skills/README.md b/skills/README.md
index 97b52480e08..a33da462508 100644
--- a/skills/README.md
+++ b/skills/README.md
@@ -23,6 +23,7 @@ Examples:
 /mf shared-deps
 /mf config-check
 /mf runtime-error RUNTIME-008
+/mf observability
 ```
 
 Public skill:
diff --git a/skills/mf/SKILL.md b/skills/mf/SKILL.md
index 54e9de4afa6..0c4b3415464 100644
--- a/skills/mf/SKILL.md
+++ b/skills/mf/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: mf
-description: "All-in-one Module Federation skill. Use when the user asks anything about MF — concepts, configuration, runtime API, shared dependencies, type errors, runtime error code troubleshooting, slow builds, Bridge integration, or adding MF to an existing project."
+description: "All-in-one Module Federation skill. Use when the user asks anything about MF — concepts, configuration, runtime API, shared dependencies, type errors, runtime error code troubleshooting, observability, slow builds, Bridge integration, or adding MF to an existing project."
 argument-hint: <sub-command | natural-language-query> [args...]
 allowed-tools: Read Glob Bash(node *) Bash(npx tsc*) Bash(npx mf dts*) Bash(curl *) WebFetch Write Edit AskUserQuestion
 ---
@@ -23,9 +23,15 @@ Parse `$ARGUMENTS` and map to a reference file in the `reference/` directory (sa
 | `config-check` | `config`, `plugin`, `exposes` | `reference/config-check.md` |
 | `bridge-check` | `bridge`, `sub-app` | `reference/bridge-check.md` |
 | `runtime-error` | `runtime-code`, `runtime-008`, `runtime-001`, `remote-entry` | `reference/runtime-error.md` |
+| `observability` | `observe`, `trace`, `traceId`, `report`, `observability`, `debug-loading`, `telemetry`, `runtime-007`, `moduleInfo`, `snapshot` | `reference/observability.md` |
 
 **If no explicit sub-command is found**, detect intent from the full input:
 
+If the input contains an observability report, `traceId`, console `read:` command,
+`.mf/observability` file path, or asks how to observe, debug, trace, inspect, or
+upload Module Federation loading data, choose `reference/observability.md` even
+when the same input also contains a `RUNTIME-xxx` code.
+
 | Signal in input | Reference file |
 |---|---|
 | Question about MF concepts, API, configuration options | `reference/docs.md` |
@@ -36,6 +42,7 @@ Parse `$ARGUMENTS` and map to a reference file in the `reference/` directory (sa
 | "plugin", "asyncStartup", "exposes key", "config" | `reference/config-check.md` |
 | "bridge", "sub-app", "export-app", "createRemoteAppComponent" | `reference/bridge-check.md` |
 | "RUNTIME-001", "RUNTIME-008", "runtime error code", "remote entry load failed", "ScriptNetworkError", "ScriptExecutionError", "container missing", "window[remoteEntryKey]" | `reference/runtime-error.md` |
+| "Observability report generated", "console.error", "traceId", "read:", "diagnosis", "ownerHint", "summary.phases", ".mf/observability", "build-report.json", "latest.json", "RUNTIME-007", "moduleInfo", "remote snapshot", "global snapshot", "snapshot match", "observability", "observe MF", "debug MF loading", "trace loading", "loading report", "telemetry", "onReport", "onEvent", "production report", "upload observability" | `reference/observability.md` |
 | "manifest", "remoteEntry URL", "module info", "publicPath" | `reference/module-info.md` |
 | "context", "what is configured", "MF role", "bundler" | `reference/context.md` |
 
diff --git a/skills/mf/reference/context.md b/skills/mf/reference/context.md
index 7bb88a9e41e..eb72189f6e5 100644
--- a/skills/mf/reference/context.md
+++ b/skills/mf/reference/context.md
@@ -39,7 +39,7 @@ Read the first matched file and extract the `remotes`, `exposes`, and `shared` f
 
 ## 4. Recent Error Event (optional)
 
-Check if `.mf/diagnostics/latest.json` exists; if so, read its contents.
+Check if `.mf/observability/latest.json` exists; if so, read its contents.
 
 ## 5. Build Artifacts (optional)
 
diff --git a/skills/mf/reference/observability.md b/skills/mf/reference/observability.md
new file mode 100644
index 00000000000..4f1975ee937
--- /dev/null
+++ b/skills/mf/reference/observability.md
@@ -0,0 +1,379 @@
+# Sub-skill: observability
+
+Diagnose Module Federation loading reports produced by
+`@module-federation/observability-plugin`.
+
+Use this sub-skill when the user provides or mentions:
+
+- an observability `traceId`
+- a console line containing `Observability report generated`
+- a Module Federation `console.error` observability hint
+- a `read:` command
+- `.mf/observability/latest.json`
+- `.mf/observability/events.jsonl`
+- `.mf/observability/build-info.json`
+- `.mf/observability/build-report.json`
+- a request to observe, debug, trace, inspect, or upload Module Federation
+  loading data
+- production telemetry hooks such as `onReport` or `onEvent`
+- a report field such as `diagnosis`, `summary.phases`, `ownerHint`, or
+  `moduleInfo`
+
+## Runtime codes and plugin reports
+
+Runtime error codes are still the stable first signal. The observability plugin
+does not replace `RUNTIME-xxx`; it enriches the code with phase, moduleInfo,
+shared, and timeline evidence. Build evidence is written separately by the
+build observability plugin.
+
+`@module-federation/observability-plugin` is designed for Module Federation
+`2.5.0` and later. When recommending this plugin, recommend upgrading MF to
+`2.5.0+` at the same time.
+
+If the user only provides a `RUNTIME-xxx` code and no observability report, do not
+claim that a scan or report was read. Use the official runtime troubleshooting
+docs for the code, then recommend enabling `ObservabilityPlugin` when the current
+evidence is too thin to identify the owner or exact phase.
+
+If the app is not upgraded or does not use `@module-federation/observability-plugin`,
+this skill still works in error-code mode: diagnose from the error code,
+console text, URL, network evidence, and runtime/build config. Only ask for an
+observability report when the plugin is actually enabled or the user can enable
+it.
+
+If the user only knows that MF failed, but has no observability report and no
+accurate `RUNTIME-xxx` code or actionable console/network evidence, ask whether
+they can follow the recommended path: upgrade Module Federation to `2.5.0+` and
+enable `@module-federation/observability-plugin` to collect a report with loading
+phase, owner, shared, and moduleInfo evidence. If build evidence is needed, ask
+for the separate `.mf/observability/build-info.json` or
+`.mf/observability/build-report.json` file.
+
+## Step 1: Get the report
+
+Prefer the most direct source available.
+
+### Browser
+
+If the console hint includes a `read:` line, execute that command exactly in the
+browser console context:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReport('mf-...');
+```
+
+If the user only has the latest browser report, use:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getLatestReport();
+```
+
+For recent or filtered browser reports, use:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 5 });
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  remote: 'remote1',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  expose: './Button',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
+  shared: 'react',
+});
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].exportReport('mf-...');
+```
+
+If the browser global is disabled, ask for the app's observability controller or
+for the full report output pasted by the user.
+
+If the browser console only contains `traceId` and `errorCode`, treat it as
+production-safe output. Do not assume the full report is globally readable. Ask
+for an explicit `exportReport(traceId)` output, the app observability controller
+output, or the user's uploaded observability record.
+
+### Node or SSR
+
+Read `.mf/observability/latest.json` first. Use `.mf/observability/events.jsonl`
+only if multiple traces or event ordering are needed.
+
+`latest.json` is the formatted latest complete report. `events.jsonl` is an
+append-only stream where each line is one runtime event with its own `traceId`,
+`timestamp`, `phase`, `status`, context, and error fields when present.
+
+### Build
+
+Read `.mf/observability/build-report.json` for build failures and
+`.mf/observability/build-info.json` for successful build facts.
+
+## Step 2: Read fields in the required order
+
+Do not start from `events`.
+
+Reports omit `undefined` fields. Treat an absent optional field as "not observed
+or not relevant" unless a specific failure guide says that field must be
+present.
+
+Read:
+
+1. `diagnosis.status`
+2. `diagnosis.title`
+3. `diagnosis.ownerHint`
+4. `diagnosis.errorCode`
+5. `diagnosis.facts`
+6. `diagnosis.actions`
+7. `summary.outcome`
+8. `summary.error`
+9. `summary.phases`
+10. `summary.flags`
+11. `summary.shared`
+12. `build`
+13. `moduleInfo`
+14. `events`
+
+## Step 3: Decide the likely owner
+
+Use `diagnosis.ownerHint` first:
+
+- `host`: inspect host remotes, request id, manifest URL, and runtime call.
+- `remote`: inspect producer exposes, remoteEntry type/global, and exposed module
+  execution.
+- `shared`: inspect host and remote shared config, selected provider, versions,
+  shareScope, singleton, strictVersion, and eager.
+- `network`: inspect URL reachability, CORS, status code, response body, timeout,
+  CDN, gateway, or proxy.
+- `build`: inspect build-report, bundler output, and observability output path.
+- `unknown`: use `summary.phases` to find the first missing/error phase, then
+  inspect `events`.
+
+## Step 4: Follow diagnosis actions
+
+Treat `diagnosis.actions` as the prioritized checklist. For each action:
+
+1. inspect the referenced config or runtime fact
+2. compare it with `diagnosis.facts`
+3. compare it with `.mf/observability/build-info.json` when build evidence is needed
+4. make the smallest code/config fix
+5. verify with the failing app or targeted test
+
+## Step 5: Use build evidence correctly
+
+Runtime reports do not have `summary.build`.
+
+Runtime reports also do not embed build facts. If build evidence is needed,
+read `.mf/observability/build-info.json` or `.mf/observability/build-report.json`
+as a separate file and compare it with the runtime report.
+
+`moduleInfo` appears only for snapshot/moduleInfo dependent failures. It is a
+clipped view of `__FEDERATION__.moduleInfo`, not a full dump. Use only:
+
+- `entries[].name`
+- `entries[].publicPath`
+- `entries[].getPublicPath`
+- `entries[].remoteEntry`
+- `entries[].globalName`
+- `totalCount`
+- `matchedCount`
+- `availableNames`
+
+Large fields such as `modules`, `shared`, and assets are intentionally removed.
+The `publicPath`, `getPublicPath`, and `remoteEntry` locator fields preserve
+query/hash data and are only length-limited because deployment platforms often
+use those values to route a module.
+
+Do not describe `moduleInfo.availableNames` as a component list, expose list, or
+prefetch list. It is the clipped list of deployment-provided moduleInfo remote
+candidate keys that were available when no entry matched the failed remote.
+
+## Step 6: Common paths
+
+### Manifest failure / `RUNTIME-003`
+
+Check:
+
+- `diagnosis.facts.url`
+- `summary.phases.manifest`
+- `build.host.remotes`
+
+Fix wrong manifest URL, HTML shell responses, CORS, gateway routing, or stale
+query/hash assumptions.
+
+### Invalid manifest / `RUNTIME-013`
+
+Definition:
+
+`RUNTIME-013` means the manifest URL returned JSON, but the JSON is not a valid
+Module Federation manifest. It is different from `RUNTIME-003`, which means the
+manifest could not be fetched or parsed.
+
+Check:
+
+- `diagnosis.facts.url`
+- `diagnosis.facts.errorCode`
+- `summary.phases.manifest`
+- `diagnosis.facts.hostName`
+- manifest fields such as `metaData`, `exposes`, and `shared`
+
+When explaining this failure, say that the manifest response is reachable but
+structurally invalid or incomplete. Do not describe it as a remoteEntry network
+failure unless the report also contains network evidence.
+
+Fix wrong JSON responses, gateway/deployment rewrites, missing producer manifest
+output, or stale/incomplete manifest files.
+
+### Remote not matched / `RUNTIME-004`
+
+Check:
+
+- `diagnosis.facts.requestId`
+- host remotes in `.mf/observability/build-info.json` when available
+
+Fix remote name, alias, or host remote declaration.
+
+### Snapshot / moduleInfo failure / `RUNTIME-007`
+
+Definition:
+
+`RUNTIME-007` means the runtime failed while resolving a snapshot/moduleInfo
+remote. It is not a remoteEntry network failure, not an expose lookup failure,
+and not a React/component render failure unless another report field explicitly
+shows those later phases.
+
+Check:
+
+- `requestId`
+- `remote.name`
+- `remote.alias`
+- `remote.version`
+- `diagnosis.errorCode`
+- `diagnosis.facts.moduleInfoMatchedCount`
+- `diagnosis.facts.moduleInfoNames`
+- `moduleInfo.entries`
+- `moduleInfo.availableNames`
+- `build.host.remotes`
+
+When explaining this failure, say that the runtime could not match the requested
+remote name/alias/version against deployment-provided `__FEDERATION__.moduleInfo`.
+Do not say "available component list" unless the report explicitly refers to
+remote exposes. This failure usually happens before the remote URL, remoteEntry,
+or exposed component can be loaded.
+
+The first cause sentence must include the literal term `moduleInfo`. Do not
+replace it with "loadable source list", "available source list", "component
+list", or any other paraphrase.
+
+Use this wording:
+
+- "The requested remote did not match any deployment-provided moduleInfo entry."
+- "Check whether the deployment/platform moduleInfo injection contains the
+  requested remote name, alias, or version key."
+- "The component has not been reached yet; the failure is in remote snapshot
+  resolution."
+
+Avoid this wording:
+
+- "The component is missing from the available component list."
+- "The prefetch list does not contain the component."
+- "The expose is missing."
+- "The React component failed to render."
+- "The remoteEntry request failed."
+
+Only mention source files or demo setup code after report evidence. In real
+projects, first inspect the deployment/platform plugin or runtime registration
+that injects `__FEDERATION__.moduleInfo`; do not jump directly to editing the
+business component.
+
+Exclude likely causes when the report only shows a snapshot/moduleInfo failure:
+
+- remoteEntry URL/network/CORS failure
+- remoteEntry execution failure
+- exposed module key missing
+- shared dependency version/provider/eager failure
+- business component render failure
+
+Fix missing deployment-provided `__FEDERATION__.moduleInfo`, mismatched remote
+name/alias keys, or missing `publicPath` / `getPublicPath` in the injected
+moduleInfo.
+
+### Expose not found / `RUNTIME-014`
+
+Definition:
+
+`RUNTIME-014` means the remote entry loaded and initialized, but the requested
+expose was not exported by that remote.
+
+Check:
+
+- `diagnosis.facts.requestId`
+- `diagnosis.facts.remoteName`
+- `diagnosis.facts.expose`
+- producer `exposes` config or manifest `exposes`
+
+When explaining this failure, say that remote loading reached the expose lookup
+phase. Do not call it a manifest fetch failure, moduleInfo match failure,
+remoteEntry network failure, or shared dependency failure unless another report
+field explicitly shows that evidence.
+
+Fix the consumer request id, producer expose name, `./` prefix, case mismatch,
+alias mismatch, or stale producer deployment.
+
+### Remote init failure / `RUNTIME-015`
+
+Definition:
+
+`RUNTIME-015` means the remote entry loaded, but the remote container failed
+during `init`.
+
+Check:
+
+- `diagnosis.facts.remoteName`
+- `diagnosis.facts.remoteEntry`
+- `diagnosis.facts.entryGlobalName`
+- `summary.phases.remoteEntry`
+- original error text in `diagnosis.errorMessage` or `summary.error.errorMessage`
+- shared facts and build-side shared config when available
+
+When explaining this failure, say that the remote entry was reached and failed
+while initializing. If the original error points to shared config, classify the
+likely owner as shared/host+remote config; otherwise inspect producer init
+logic.
+
+Fix shared provider/version/scope/eager config, remoteEntry type/global mismatch,
+or producer code that throws during container initialization.
+
+### Shared or eager failure / `RUNTIME-005` / `RUNTIME-006`
+
+Check:
+
+- `summary.shared`
+- shared config in `.mf/observability/build-info.json` when available
+- `summary.error.lifecycle`
+
+Fix provider availability, version range, shareScope, singleton/strictVersion,
+eager, or async boundary.
+
+### RemoteEntry failure / `RUNTIME-008`
+
+Check:
+
+- `diagnosis.facts.resourceErrorType`
+- `diagnosis.facts.url`
+- `summary.phases.remoteEntry`
+- `.mf/observability/build-info.json` remoteEntry facts when available
+
+If the type is network/timeout, fix URL, CORS, routing, server, or timeout. If
+the type is script execution, inspect the producer exception and fix the remote
+build. Retry does not fix script execution failures.
+
+## Step 7: Final response shape
+
+When reporting back, keep it concrete:
+
+1. what report source was used
+2. likely owner
+3. the key evidence
+4. what was changed or what should be changed
+5. how it was verified
+
+If the report is missing, ask for the console `traceId`, optional `read:` line,
+or `.mf/observability/latest.json`.
diff --git a/skills/mf/reference/runtime-error.md b/skills/mf/reference/runtime-error.md
index 1fe543e1784..a9326319772 100644
--- a/skills/mf/reference/runtime-error.md
+++ b/skills/mf/reference/runtime-error.md
@@ -4,6 +4,24 @@ Diagnose explicit Module Federation runtime error codes.
 
 This sub-skill is only for users who already have a clear runtime error code such as `RUNTIME-001` or `RUNTIME-008`.
 
+If ARGS includes an observability report, `traceId`, console `read:` command, or
+`.mf/observability` file path, stop here and follow `./observability.md` instead.
+
+Runtime error codes remain useful even when the observability plugin is not
+enabled. Do not tell the user that diagnosis requires
+`@module-federation/observability-plugin`. Use the error code, console text,
+network evidence, and runtime/build config first. Recommend the observability
+plugin only as an optional way to collect richer evidence when the code alone is
+not enough. The observability plugin is designed for Module Federation `2.5.0+`;
+when recommending it, ask whether the user can upgrade MF to `2.5.0` or later
+and enable the plugin.
+
+If ARGS only says that Module Federation failed, but does not include an
+accurate runtime error code, observability report, useful console details, network
+evidence, or config evidence, ask the user whether they can follow the
+recommended path: upgrade to Module Federation `2.5.0+` and use
+`@module-federation/observability-plugin` to collect an actionable report.
+
 ## Step 1: Parse the runtime code first
 
 Extract the runtime code from ARGS.
@@ -137,11 +155,11 @@ At the end, clearly state:
    - legacy hidden execution error
 2. what concrete evidence supports the conclusion
 3. what the next fix should be
-4. that the user should upgrade to **`2.3.0` or later** to get more accurate and actionable runtime error information
+4. that `2.3.0+` improves raw runtime error categories, and the recommended observability path is upgrading to **`2.5.0+`** and enabling `@module-federation/observability-plugin`
 
 ## Required final reminder
 
 Always end with this recommendation in plain language:
 
 - older versions may report this kind of problem with incomplete or misleading runtime codes
-- upgrading to **`2.3.0+`** helps the runtime expose the correct error category and clearer details
+- upgrading to **`2.5.0+`** and enabling `@module-federation/observability-plugin` gives a fuller loading report when the raw error code is not enough
diff --git a/skills/mf/reference/type-check.md b/skills/mf/reference/type-check.md
index f5be4b4c41b..d7a7e011f53 100644
--- a/skills/mf/reference/type-check.md
+++ b/skills/mf/reference/type-check.md
@@ -26,7 +26,7 @@ Process each item in the output `results` array and follow the action plan based
 The producer failed to generate type files (TYPE-001 error).
 
 **If `enhancedVersion` > `2.0.1`** (result field `canReadDiagnostics: true`):
-1. Read `.mf/diagnostics/latest.json` to get full error info and the temporary TS config path
+1. Read `.mf/observability/latest.json` to get full error info and the temporary TS config path
 2. Use the temp TS config path with `npx tsc --project <tmp-tsconfig>` to reproduce errors
 3. Fix the TS errors revealed. Refer to FAQ: https://module-federation.io/guide/troubleshooting/type.md
 4. Offer `"skipLibCheck": true` as a temporary workaround if errors are complex

From 9d64c30695bbb07e5034bd95b760082de089c2af Mon Sep 17 00:00:00 2001
From: 2heal1 <TwoHeal@163.com>
Date: Mon, 11 May 2026 11:07:27 +0800
Subject: [PATCH 3/4] fix(observability): reuse sdk manifest path join

---
 packages/observability-plugin/package.json |  3 +++
 packages/observability-plugin/src/build.ts | 13 +++----------
 pnpm-lock.yaml                             |  4 ++++
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/observability-plugin/package.json b/packages/observability-plugin/package.json
index ef1bfa7e0f1..6f09c4a2834 100644
--- a/packages/observability-plugin/package.json
+++ b/packages/observability-plugin/package.json
@@ -52,6 +52,9 @@
   "devDependencies": {
     "@module-federation/runtime": "workspace:*"
   },
+  "dependencies": {
+    "@module-federation/sdk": "workspace:*"
+  },
   "scripts": {
     "build": "tsdown --config tsdown.config.ts && cp *.md dist",
     "test": "vitest run -u -c vitest.config.ts",
diff --git a/packages/observability-plugin/src/build.ts b/packages/observability-plugin/src/build.ts
index a6cf22eb92e..5bb32218eb6 100644
--- a/packages/observability-plugin/src/build.ts
+++ b/packages/observability-plugin/src/build.ts
@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { simpleJoinRemoteEntry } from '@module-federation/sdk';
 
 export type ObservabilityBuildInfoSource = 'config' | 'stats' | 'manifest';
 export type ObservabilityBuildPublicPathMode =
@@ -398,8 +399,8 @@ function getManifestFileName(manifestOption: unknown) {
     : DEFAULT_STATS_FILE;
 
   return {
-    manifestFileName: joinAssetPath(filePath, manifestFile),
-    statsFileName: joinAssetPath(filePath, statsFile),
+    manifestFileName: simpleJoinRemoteEntry(filePath, manifestFile),
+    statsFileName: simpleJoinRemoteEntry(filePath, statsFile),
   };
 }
 
@@ -411,14 +412,6 @@ function insertSuffix(fileName: string, suffix: string) {
   return fileName.replace(/\.json$/i, `${suffix}.json`);
 }
 
-function joinAssetPath(filePath: string, fileName: string) {
-  if (!filePath) {
-    return fileName;
-  }
-
-  return `${filePath.replace(/\\/g, '/').replace(/\/+$/g, '')}/${fileName}`;
-}
-
 function getSourceText(source: unknown): string | undefined {
   if (source === undefined || source === null) {
     return undefined;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3c7da21d8d3..1cff3ae9aa0 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -3883,6 +3883,10 @@ importers:
         version: 5.104.1(@swc/core@1.7.26(@swc/helpers@0.5.13))(esbuild@0.27.3)(webpack-cli@5.1.4)
 
   packages/observability-plugin:
+    dependencies:
+      '@module-federation/sdk':
+        specifier: workspace:*
+        version: link:../sdk
     devDependencies:
       '@module-federation/runtime':
         specifier: workspace:*

From 1c4d7bfdc74b5addb4ccd4a79b3360d918cdd7c5 Mon Sep 17 00:00:00 2001
From: 2heal1 <TwoHeal@163.com>
Date: Mon, 11 May 2026 20:29:45 +0800
Subject: [PATCH 4/4] feat(observability): improve runtime loading traces

---
 .changeset/safe-observability-plugin.md       |   2 +-
 .../3005-runtime-host/cypress/e2e/app.cy.ts   |  22 +-
 .../src/ObservabilityShowcase.tsx             |  31 -
 .../3005-runtime-host/src/observability.ts    |  19 +-
 .../src/components/AnalyticsPanel.tsx         |  22 +-
 .../src/components/ProfileCard.tsx            |  21 +-
 .../skills/mf/reference/observability.md      | 248 ++-----
 .../plugin/plugins/observability-plugin.mdx   | 153 ++++-
 .../plugin/plugins/observability-plugin.mdx   | 149 +++--
 .../AI_TROUBLESHOOTING.md                     |  44 +-
 packages/observability-plugin/README.md       | 156 ++++-
 .../__tests__/observability.spec.ts           | 561 ++++++++++++++--
 packages/observability-plugin/src/index.ts    | 628 ++++++++++++++++--
 packages/observability-plugin/src/node.ts     |  19 +-
 .../observability-plugin/tsdown.config.ts     |   7 +-
 packages/runtime-core/__tests__/hooks.spec.ts |  14 +
 packages/runtime-core/src/remote/index.ts     |   2 +-
 .../runtime-core/src/utils/hooks/asyncHook.ts |   5 +-
 skills/mf/reference/observability.md          | 248 ++-----
 19 files changed, 1725 insertions(+), 626 deletions(-)

diff --git a/.changeset/safe-observability-plugin.md b/.changeset/safe-observability-plugin.md
index 701b96bb23c..2062573e90a 100644
--- a/.changeset/safe-observability-plugin.md
+++ b/.changeset/safe-observability-plugin.md
@@ -5,4 +5,4 @@
 "@module-federation/runtime": minor
 ---
 
-Add an opt-in observability plugin, a Node-specific export for file reports, a build-specific export for build summaries and build error reports, remote and shared lifecycle hooks, console trace hints, safe browser/Node report outputs, configurable error stack capture with explicit console raw-stack opt-ins, shared/eager loading evidence, final loading outcome summaries for Module Federation loading reports, deterministic fact reports for runtime and build failures, no-op return handling for observer hooks, detailed remote match/init/expose/factory phase events with phase durations, compact phase summaries, cache/retry/fallback markers, length-limited business component metadata, clipped moduleInfo evidence with preserved deployment locator fields for snapshot-dependent failures, normalized runtime error summaries with error codes, owner hints, retryability, and safe context, dedicated runtime error codes for invalid manifests, missing exposes, and remote container init failures, plus an AI troubleshooting guide for reading and fixing observability reports.
+Add an opt-in observability plugin, a direct runtime plugin API with instance-bound component loaded marks, opt-in React component lifecycle observation with automatic `onMFRemoteLoaded` prop injection, opt-in start console traces for `loadRemote` and `loadShare`, a Node-specific export for file reports, a build-specific export for build summaries and build error reports, remote and shared lifecycle hooks, console trace hints, safe browser/Node report outputs, configurable error stack capture with explicit console raw-stack opt-ins, shared/eager loading evidence, final loading outcome summaries for Module Federation loading reports, deterministic fact reports for runtime and build failures, no-op return handling for observer hooks, detailed remote match/init/expose/factory phase events with phase durations, compact phase summaries, cache/retry/fallback markers, length-limited business component metadata, clipped moduleInfo evidence with preserved deployment locator fields for snapshot-dependent failures, normalized runtime error summaries with error codes, owner hints, retryability, and safe context, dedicated runtime error codes for invalid manifests, missing exposes, and remote container init failures, plus an AI troubleshooting guide for reading and fixing observability reports.
diff --git a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
index c77a8b5f8ba..cacc7ec9dde 100644
--- a/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
+++ b/apps/runtime-demo/3005-runtime-host/cypress/e2e/app.cy.ts
@@ -9,6 +9,8 @@ type ObservabilityTestReport = {
   errorCode?: string;
   requestId?: string;
   summary: {
+    componentLoaded?: boolean;
+    outcome?: string;
     flags: {
       cached?: boolean;
     };
@@ -26,7 +28,7 @@ type ObservabilityTestReport = {
   };
   events: Array<{
     eventName?: string;
-    metadata?: Record<string, string>;
+    metadata?: Record<string, unknown>;
   }>;
 };
 
@@ -651,6 +653,24 @@ describe('3005-runtime-host/', () => {
         'contain',
         'ProfileCard',
       );
+      cy.window().should((win) => {
+        const reports = getObservabilityReader(win).getReports();
+        const profileReport = reports.find(
+          (report: ObservabilityTestReport) =>
+            report.requestId === 'dynamic-remote/ProfileCard' &&
+            report.summary.componentLoaded === true,
+        );
+
+        expect(profileReport?.summary.componentLoaded).to.equal(true);
+        expect(profileReport?.summary.outcome).to.equal('component-loaded');
+        expect(
+          profileReport?.events.some(
+            (event) =>
+              event.eventName === 'component:business-loaded' &&
+              event.metadata?.producer === 'runtime_remote2',
+          ),
+        ).to.equal(true);
+      });
       cy.get('[data-testid="observability-showcase-load"]').click();
       cy.location('pathname').should(
         'equal',
diff --git a/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx b/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
index 034c4cb686b..b905dd711e8 100644
--- a/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
+++ b/apps/runtime-demo/3005-runtime-host/src/ObservabilityShowcase.tsx
@@ -89,20 +89,6 @@ async function loadProfileWidget() {
   const Component = resolveRemoteComponent(remoteModule);
   const report = observability.getLatestReport();
 
-  if (report?.traceId) {
-    observability.markComponentLoaded({
-      traceId: report.traceId,
-      requestId: profileRequest,
-      componentName: 'ProfileCard',
-      metadata: {
-        route: 'profile',
-        consumer: 'observability_showcase_profile_consumer',
-        producer: producerName,
-        expose: './ProfileCard',
-      },
-    });
-  }
-
   return {
     Component,
     traceId: report?.traceId || '',
@@ -171,23 +157,6 @@ async function loadAnalyticsWorkspace() {
   const Component = resolveRemoteComponent(remoteModule);
   const report = observability.getLatestReport();
 
-  if (report?.traceId) {
-    observability.markComponentLoaded({
-      traceId: report.traceId,
-      requestId: analyticsRequest,
-      componentName: 'AnalyticsPanel',
-      metadata: {
-        route: 'analytics',
-        consumer: analyticsConsumerName,
-        producer: producerName,
-        expose: './AnalyticsPanel',
-        shared: ['react', 'observability-customer-sdk'],
-        customerSdkProvider: sdk.provider,
-        customerSdkVersion: sdk.version,
-      },
-    });
-  }
-
   return {
     Component,
     traceId: report?.traceId || '',
diff --git a/apps/runtime-demo/3005-runtime-host/src/observability.ts b/apps/runtime-demo/3005-runtime-host/src/observability.ts
index cff01684308..f825be15046 100644
--- a/apps/runtime-demo/3005-runtime-host/src/observability.ts
+++ b/apps/runtime-demo/3005-runtime-host/src/observability.ts
@@ -1,10 +1,25 @@
-import { ObservabilityPlugin } from '@module-federation/observability-plugin';
+import { createObservability } from '@module-federation/observability-plugin';
 
-export const observability = ObservabilityPlugin({
+export const observability = createObservability({
   level: 'verbose',
   maxEvents: 100,
   browser: {
     enabled: true,
     scope: 'runtime_host',
   },
+  react: {
+    enabled: true,
+    timeout: 5000,
+    consumerNames: [
+      'observability_showcase_profile_consumer',
+      'observability_showcase_analytics_consumer',
+    ],
+    remoteIds: [
+      'dynamic-remote/ProfileCard',
+      'dynamic-remote/AnalyticsPanel',
+      './ProfileCard',
+      './AnalyticsPanel',
+    ],
+    defaultExportMode: 'component',
+  },
 });
diff --git a/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx b/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
index 55355f372d4..bfe76fab0e2 100644
--- a/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
+++ b/apps/runtime-demo/3007-runtime-remote/src/components/AnalyticsPanel.tsx
@@ -1,4 +1,24 @@
-export default function AnalyticsPanel() {
+import { useEffect } from 'react';
+
+type OnMFRemoteLoaded = (options?: {
+  metadata?: Record<string, unknown>;
+}) => void;
+
+export default function AnalyticsPanel({
+  onMFRemoteLoaded,
+}: {
+  onMFRemoteLoaded?: OnMFRemoteLoaded;
+}) {
+  useEffect(() => {
+    onMFRemoteLoaded?.({
+      metadata: {
+        producer: 'runtime_remote2',
+        expose: './AnalyticsPanel',
+        readySource: 'producer',
+      },
+    });
+  }, [onMFRemoteLoaded]);
+
   return (
     <section
       className="customer-portal__remote-widget"
diff --git a/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx b/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
index 786d89ba900..a282d84eb42 100644
--- a/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
+++ b/apps/runtime-demo/3007-runtime-remote/src/components/ProfileCard.tsx
@@ -1,4 +1,23 @@
-export default function ProfileCard() {
+import { useEffect } from 'react';
+
+type OnMFRemoteLoaded = (options?: {
+  metadata?: Record<string, unknown>;
+}) => void;
+
+export default function ProfileCard({
+  onMFRemoteLoaded,
+}: {
+  onMFRemoteLoaded?: OnMFRemoteLoaded;
+}) {
+  useEffect(() => {
+    onMFRemoteLoaded?.({
+      metadata: {
+        producer: 'runtime_remote2',
+        expose: './ProfileCard',
+      },
+    });
+  }, [onMFRemoteLoaded]);
+
   return (
     <section
       className="customer-portal__remote-widget"
diff --git a/apps/runtime-demo/skills/mf/reference/observability.md b/apps/runtime-demo/skills/mf/reference/observability.md
index 4f1975ee937..be9b2327d6a 100644
--- a/apps/runtime-demo/skills/mf/reference/observability.md
+++ b/apps/runtime-demo/skills/mf/reference/observability.md
@@ -19,7 +19,7 @@ Use this sub-skill when the user provides or mentions:
 - a report field such as `diagnosis`, `summary.phases`, `ownerHint`, or
   `moduleInfo`
 
-## Runtime codes and plugin reports
+## Error codes vs observability reports
 
 Runtime error codes are still the stable first signal. The observability plugin
 does not replace `RUNTIME-xxx`; it enriches the code with phase, moduleInfo,
@@ -68,6 +68,24 @@ If the user only has the latest browser report, use:
 window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getLatestReport();
 ```
 
+If the user wants to inspect loading chains, observe MF loading, or debug a page
+that stays in loading state without an error or `traceId`, do not wait for a
+console error. Read recent reports directly:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 10 });
+```
+
+Then look for reports with `status: "pending"` or
+`summary.outcome: "pending"`. Use `startedAt`, `updatedAt`, `duration`,
+`summary.phases`, and `diagnosis.pendingPhases` to explain which phase has
+started, which phase has not completed, and how long the trace has been idle.
+When the browser reader is enabled in development mode, the console prints
+`Observability trace started` lines for `loadRemote` and `loadShare` by default;
+use the printed `traceId` to read that exact report. In production browser mode,
+these start logs are disabled unless the app explicitly sets
+`trace.printStart: true`.
+
 For recent or filtered browser reports, use:
 
 ```ts
@@ -84,13 +102,13 @@ window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
 window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].exportReport('mf-...');
 ```
 
-If the browser global is disabled, ask for the app's observability controller or
-for the full report output pasted by the user.
+If the browser global is disabled, ask for the app's `onReport` output, uploaded
+observability record, or the full report output pasted by the user.
 
 If the browser console only contains `traceId` and `errorCode`, treat it as
 production-safe output. Do not assume the full report is globally readable. Ask
-for an explicit `exportReport(traceId)` output, the app observability controller
-output, or the user's uploaded observability record.
+for an explicit `exportReport(traceId)` output, the app's `onReport` output, or
+the user's uploaded observability record.
 
 ### Node or SSR
 
@@ -131,6 +149,37 @@ Read:
 13. `moduleInfo`
 14. `events`
 
+## Step 2.1: Decide loading success
+
+Use `summary.outcome` before reading raw `events`:
+
+- `runtime-loaded`: the remote module was loaded by Module Federation runtime.
+- `component-loaded`: a component-level success signal was observed. This may be
+  a business `markComponentLoaded` signal or the opt-in React lifecycle observer
+  reporting `component:react-mounted`.
+- `failed`: loading failed. Use `summary.error`, `diagnosis.actions`, and
+  `failedPhase`.
+- `recovered`: loading failed first, then retry or fallback returned a result.
+
+Use `summary.loadCompleted` only as "the loadRemote flow ended"; it does not by
+itself prove success. Use `summary.runtimeLoaded` for remote module success and
+`summary.componentLoaded` for component-level success.
+
+If `events` are needed, remote module success is usually:
+
+- `phase: "loadRemote"`
+- `status: "success"`
+- `lifecycle: "onLoad"`
+- `message: "remote:loaded"`
+
+React mount observation is opt-in. It records component events such as
+`component:react-render-started`, `component:react-mounted`, and
+`component:react-render-timeout`. Treat `component:react-mounted` as React mount
+success, not as proof that business data, charts, or SDKs finished loading.
+When this option is enabled, the wrapper also injects an `onMFRemoteLoaded` prop
+into the remote React component. If the producer calls that prop, treat the
+resulting `component:business-loaded` event as the producer's own ready signal.
+
 ## Step 3: Decide the likely owner
 
 Use `diagnosis.ownerHint` first:
@@ -185,185 +234,24 @@ Do not describe `moduleInfo.availableNames` as a component list, expose list, or
 prefetch list. It is the clipped list of deployment-provided moduleInfo remote
 candidate keys that were available when no entry matched the failed remote.
 
-## Step 6: Common paths
-
-### Manifest failure / `RUNTIME-003`
-
-Check:
-
-- `diagnosis.facts.url`
-- `summary.phases.manifest`
-- `build.host.remotes`
-
-Fix wrong manifest URL, HTML shell responses, CORS, gateway routing, or stale
-query/hash assumptions.
-
-### Invalid manifest / `RUNTIME-013`
-
-Definition:
-
-`RUNTIME-013` means the manifest URL returned JSON, but the JSON is not a valid
-Module Federation manifest. It is different from `RUNTIME-003`, which means the
-manifest could not be fetched or parsed.
-
-Check:
-
-- `diagnosis.facts.url`
-- `diagnosis.facts.errorCode`
-- `summary.phases.manifest`
-- `diagnosis.facts.hostName`
-- manifest fields such as `metaData`, `exposes`, and `shared`
-
-When explaining this failure, say that the manifest response is reachable but
-structurally invalid or incomplete. Do not describe it as a remoteEntry network
-failure unless the report also contains network evidence.
-
-Fix wrong JSON responses, gateway/deployment rewrites, missing producer manifest
-output, or stale/incomplete manifest files.
-
-### Remote not matched / `RUNTIME-004`
-
-Check:
-
-- `diagnosis.facts.requestId`
-- host remotes in `.mf/observability/build-info.json` when available
-
-Fix remote name, alias, or host remote declaration.
-
-### Snapshot / moduleInfo failure / `RUNTIME-007`
-
-Definition:
-
-`RUNTIME-007` means the runtime failed while resolving a snapshot/moduleInfo
-remote. It is not a remoteEntry network failure, not an expose lookup failure,
-and not a React/component render failure unless another report field explicitly
-shows those later phases.
-
-Check:
-
-- `requestId`
-- `remote.name`
-- `remote.alias`
-- `remote.version`
-- `diagnosis.errorCode`
-- `diagnosis.facts.moduleInfoMatchedCount`
-- `diagnosis.facts.moduleInfoNames`
-- `moduleInfo.entries`
-- `moduleInfo.availableNames`
-- `build.host.remotes`
-
-When explaining this failure, say that the runtime could not match the requested
-remote name/alias/version against deployment-provided `__FEDERATION__.moduleInfo`.
-Do not say "available component list" unless the report explicitly refers to
-remote exposes. This failure usually happens before the remote URL, remoteEntry,
-or exposed component can be loaded.
-
-The first cause sentence must include the literal term `moduleInfo`. Do not
-replace it with "loadable source list", "available source list", "component
-list", or any other paraphrase.
-
-Use this wording:
-
-- "The requested remote did not match any deployment-provided moduleInfo entry."
-- "Check whether the deployment/platform moduleInfo injection contains the
-  requested remote name, alias, or version key."
-- "The component has not been reached yet; the failure is in remote snapshot
-  resolution."
-
-Avoid this wording:
-
-- "The component is missing from the available component list."
-- "The prefetch list does not contain the component."
-- "The expose is missing."
-- "The React component failed to render."
-- "The remoteEntry request failed."
-
-Only mention source files or demo setup code after report evidence. In real
-projects, first inspect the deployment/platform plugin or runtime registration
-that injects `__FEDERATION__.moduleInfo`; do not jump directly to editing the
-business component.
-
-Exclude likely causes when the report only shows a snapshot/moduleInfo failure:
-
-- remoteEntry URL/network/CORS failure
-- remoteEntry execution failure
-- exposed module key missing
-- shared dependency version/provider/eager failure
-- business component render failure
-
-Fix missing deployment-provided `__FEDERATION__.moduleInfo`, mismatched remote
-name/alias keys, or missing `publicPath` / `getPublicPath` in the injected
-moduleInfo.
-
-### Expose not found / `RUNTIME-014`
-
-Definition:
-
-`RUNTIME-014` means the remote entry loaded and initialized, but the requested
-expose was not exported by that remote.
-
-Check:
-
-- `diagnosis.facts.requestId`
-- `diagnosis.facts.remoteName`
-- `diagnosis.facts.expose`
-- producer `exposes` config or manifest `exposes`
-
-When explaining this failure, say that remote loading reached the expose lookup
-phase. Do not call it a manifest fetch failure, moduleInfo match failure,
-remoteEntry network failure, or shared dependency failure unless another report
-field explicitly shows that evidence.
-
-Fix the consumer request id, producer expose name, `./` prefix, case mismatch,
-alias mismatch, or stale producer deployment.
-
-### Remote init failure / `RUNTIME-015`
-
-Definition:
-
-`RUNTIME-015` means the remote entry loaded, but the remote container failed
-during `init`.
-
-Check:
-
-- `diagnosis.facts.remoteName`
-- `diagnosis.facts.remoteEntry`
-- `diagnosis.facts.entryGlobalName`
-- `summary.phases.remoteEntry`
-- original error text in `diagnosis.errorMessage` or `summary.error.errorMessage`
-- shared facts and build-side shared config when available
-
-When explaining this failure, say that the remote entry was reached and failed
-while initializing. If the original error points to shared config, classify the
-likely owner as shared/host+remote config; otherwise inspect producer init
-logic.
-
-Fix shared provider/version/scope/eager config, remoteEntry type/global mismatch,
-or producer code that throws during container initialization.
-
-### Shared or eager failure / `RUNTIME-005` / `RUNTIME-006`
-
-Check:
-
-- `summary.shared`
-- shared config in `.mf/observability/build-info.json` when available
-- `summary.error.lifecycle`
-
-Fix provider availability, version range, shareScope, singleton/strictVersion,
-eager, or async boundary.
+## Step 6: Use runtime error codes as references
 
-### RemoteEntry failure / `RUNTIME-008`
+Runtime error codes are stable entry points, but this observability skill should
+not act as a full `RUNTIME-xxx` troubleshooting manual.
 
-Check:
+When a report contains `diagnosis.errorCode`, `summary.error.errorCode`, or a
+console `RUNTIME-xxx` code:
 
-- `diagnosis.facts.resourceErrorType`
-- `diagnosis.facts.url`
-- `summary.phases.remoteEntry`
-- `.mf/observability/build-info.json` remoteEntry facts when available
+1. use the code to choose the relevant runtime troubleshooting document
+2. use this report to confirm the actual phase, owner, request, remote, shared,
+   `moduleInfo`, and timing evidence
+3. avoid giving a fix based only on the code if report fields contradict it
+4. if there is no observability report, ask for the report, trace id, browser
+   reader output, Node report file, or enough console/network evidence
 
-If the type is network/timeout, fix URL, CORS, routing, server, or timeout. If
-the type is script execution, inspect the producer exception and fix the remote
-build. Retry does not fix script execution failures.
+Keep the explanation centered on the report evidence. For code-specific
+definitions and fixes, refer to the runtime troubleshooting docs instead of
+duplicating that content here.
 
 ## Step 7: Final response shape
 
diff --git a/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx b/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
index 24f9835d940..05634994c7b 100644
--- a/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
+++ b/apps/website-new/docs/en/plugin/plugins/observability-plugin.mdx
@@ -23,6 +23,14 @@ Use it when you want to answer questions such as:
 - Which shared dependency provider and version were selected?
 - What report should I give to a human or AI coding agent?
 
+Shared observability is scoped to the MF instance. It tells you which MF
+instance loaded a shared dependency, which registered provider/version was
+selected, and the related scope, version, and eager configuration. It does not
+guarantee a causal link from that shared dependency back to a specific
+remote/expose. When a flow involves multiple shared dependencies, inspect all
+`phase: "shared"` events. `summary.shared` is only the last observed shared
+summary.
+
 ## Install
 
 ```bash
@@ -37,14 +45,6 @@ Use the default entry in browser runtime code.
 import { createInstance } from '@module-federation/runtime';
 import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-export const observability = ObservabilityPlugin({
-  level: 'verbose',
-  browser: {
-    enabled: true,
-    scope: 'runtime_host',
-  },
-});
-
 export const mf = createInstance({
   name: 'runtime_host',
   remotes: [
@@ -53,7 +53,15 @@ export const mf = createInstance({
       entry: 'https://example.com/mf-manifest.json',
     },
   ],
-  plugins: [observability.plugin],
+  plugins: [
+    ObservabilityPlugin({
+      level: 'verbose',
+      browser: {
+        enabled: true,
+        scope: 'runtime_host',
+      },
+    }),
+  ],
 });
 ```
 
@@ -82,6 +90,27 @@ window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
 window.__FEDERATION__.__OBSERVABILITY__.runtime_host.exportReport('mf-...');
 ```
 
+If you want to observe loading chains in development, or if the page stays in a
+loading state before any error is printed, enable the browser reader.
+Development browser mode prints start logs by default:
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
+```
+
+The plugin prints `console.info` only when `loadRemote` or `loadShare` starts.
+The line includes the `traceId` and read command. Agents can use that `traceId`
+to inspect the current report, including `status: "pending"`,
+`summary.phases`, `updatedAt`, and `duration`. Set `trace.printStart: false` to
+disable it in development browser mode. In production browser mode, start logs
+are disabled by default and require `trace.printStart: true`.
+
 ## Production Runtime
 
 In production, avoid exposing a public browser reader by default. Keep console
@@ -90,7 +119,7 @@ output small and upload reports through your own system.
 ```ts title="mf-runtime.ts"
 import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-export const observability = ObservabilityPlugin({
+export const observabilityPlugin = ObservabilityPlugin({
   level: 'summary',
   browser: {
     mode: 'production',
@@ -118,6 +147,33 @@ In production browser mode, the console hint only contains `traceId` and known
 `errorCode`. The full report should come from `onReport`, `exportReport()`, or
 your own telemetry backend.
 
+## Runtime Options
+
+`ObservabilityPlugin(options)` supports these runtime options:
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | Enable or disable the plugin. Disabled plugins do not record events or generate reports. |
+| `level` | `'summary' \| 'verbose'` | `'summary'` | Report detail level. `verbose` keeps the full event timeline. |
+| `maxEvents` | `number` | built-in limit | Maximum retained events for one plugin instance. |
+| `console` | `boolean` | `true` | Print a short `console.error` hint when a load fails. |
+| `printRawStack` | `boolean` | `false` | Print the raw error stack to console. Keep this off by default in production. |
+| `stackTrace.enabled` | `boolean` | `true` | Store a clipped stack in the report. |
+| `stackTrace.maxLines` | `number` | built-in limit | Maximum stack lines kept in the report. |
+| `stackTrace.maxLength` | `number` | built-in limit | Maximum stack characters kept in the report. |
+| `browser.enabled` | `boolean` | `false` | Expose the browser reader on `window.__FEDERATION__.__OBSERVABILITY__`. |
+| `browser.scope` | `string` | host name | Browser reader namespace, for example `runtime_host`. |
+| `browser.mode` | `'development' \| 'production'` | `'development'` | Browser output mode. Production mode keeps console hints minimal. |
+| `trace.printStart` | `boolean` | `true` in development browser mode, `false` in production browser mode | Print `console.info` when `loadRemote` or `loadShare` starts so development agents can get the `traceId`. Production mode requires an explicit `true`. |
+| `react.enabled` | `boolean` | `false` | Try to observe remote React function component lifecycle. |
+| `react.timeout` | `number` | `5000` | Record a timeout event if the component does not mount in time. |
+| `react.consumerNames` | `string[]` | `[]` | Observe only specific consumer instances. Empty means no consumer filter. |
+| `react.remoteIds` | `string[]` | `[]` | Observe only specific remote requests, such as `remote/Button` or `./Button`. Empty means no remote filter. |
+| `react.defaultExportMode` | `'preserve' \| 'component'` | auto | Controls whether `{ default: Component }` remotes return the wrapped component directly. Usually keep the default. |
+| `onEvent` | `(event, report, context) => void` | `undefined` | Called whenever an observability event is recorded. |
+| `onReport` | `(report, context) => void` | `undefined` | Called whenever a report is updated. Production apps commonly upload reports here. |
+| `onRawError` | `(error, context) => void` | `undefined` | Called with the original error object for integration with your own error system. |
+
 ## Node or SSR Runtime
 
 Use the Node entry when you want local report files.
@@ -126,16 +182,16 @@ Use the Node entry when you want local report files.
 import { createInstance } from '@module-federation/runtime';
 import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
 
-const observability = ObservabilityPlugin({
-  level: 'verbose',
-  fileOutput: true,
-  directory: '.mf/observability',
-});
-
 createInstance({
   name: 'node_host',
   remotes: [],
-  plugins: [observability.plugin],
+  plugins: [
+    ObservabilityPlugin({
+      level: 'verbose',
+      fileOutput: true,
+      directory: '.mf/observability',
+    }),
+  ],
 });
 ```
 
@@ -194,11 +250,41 @@ read the build file separately and compare it with the runtime report.
 ## Mark Business Success
 
 Module Federation can know that a remote module loaded. It cannot always know
-that your business component finished its own rendering or data loading. Call
-`markComponentLoaded` when your application considers the component ready.
+that your business component finished its own data loading, chart rendering, or
+SDK initialization.
+
+When React lifecycle observation is enabled, the plugin injects an
+`onMFRemoteLoaded` prop into the remote React component. The producer can call
+it when its own ready condition is met:
+
+```tsx
+import { useEffect } from 'react';
+import type { OnMFRemoteLoaded } from '@module-federation/observability-plugin';
+
+export default function RemotePanel({
+  onMFRemoteLoaded,
+}: {
+  onMFRemoteLoaded?: OnMFRemoteLoaded;
+}) {
+  useEffect(() => {
+    onMFRemoteLoaded?.({
+      metadata: {
+        dataReady: true,
+      },
+    });
+  }, [onMFRemoteLoaded]);
+
+  return <section>Remote panel</section>;
+}
+```
+
+Consumer-side code can still call the instance method directly when needed:
 
 ```ts
-observability.markComponentLoaded({
+import { getInstance } from '@module-federation/runtime';
+import '@module-federation/observability-plugin';
+
+getInstance()?.markComponentLoaded({
   requestId: 'remote1/Button',
   componentName: 'Button',
   metadata: {
@@ -210,6 +296,33 @@ observability.markComponentLoaded({
 The report will include `component:business-loaded` and
 `summary.outcome: "component-loaded"`.
 
+## Observe React Component Mount
+
+For development or AI debugging, you can explicitly enable remote React
+component lifecycle observation:
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  react: {
+    enabled: true,
+    timeout: 5000,
+  },
+});
+```
+
+When enabled, the plugin tries to detect remote React function components after
+`loadRemote` succeeds and wraps them with a component that does not add DOM
+nodes. The wrapper also injects the `onMFRemoteLoaded` prop. Reports may include:
+
+- `component:react-render-started`
+- `component:react-mounted`
+- `component:react-render-timeout`
+
+This only means React mounted the component. It does not mean business data,
+charts, or SDK initialization completed. Call `props.onMFRemoteLoaded?.()` from
+the producer when the application has its own success condition.
+
 ## Use With the `mf` Skill
 
 Install the skill:
diff --git a/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx b/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
index f6bdb2aa551..358c821cc31 100644
--- a/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
+++ b/apps/website-new/docs/zh/plugin/plugins/observability-plugin.mdx
@@ -19,6 +19,8 @@ description: 观测 Module Federation 加载过程，收集运行时和构建侧
 - 这次命中了哪个 shared provider 和版本？
 - 应该把哪份报告交给人或 AI coding agent 排查？
 
+shared 观测的边界是实例级别：它用于说明哪个 MF 实例加载了哪个共享依赖、最终使用了哪个已注册的 provider/version，以及对应的 scope、版本、eager 等基础信息。它不保证还原该 shared 是由哪个 remote/expose 间接触发的。一次链路涉及多个 shared 时，请查看 `events` 中所有 `phase: "shared"` 的事件；`summary.shared` 只是最后一次观测到的 shared 摘要。
+
 ## 安装
 
 ```bash
@@ -35,35 +37,9 @@ import { Tab, Tabs } from '@theme';
   <Tab label="Build Plugin（使用构建插件）">
   如果应用已经通过构建插件注册 Module Federation，推荐用 `runtimePlugins` 注入观测插件。
 
-  先创建一个运行时插件文件：
-
-  ```ts title="mf-observability-runtime-plugin.ts"
-  import { ObservabilityPlugin } from '@module-federation/observability-plugin';
-  import type {
-    ObservabilityPluginOptions,
-    ObservabilityController,
-  } from '@module-federation/observability-plugin';
-
-  let observability: ObservabilityController | undefined;
-
-  export function getObservability() {
-    return observability;
-  }
-
-  export default function mfObservabilityRuntimePlugin(
-    options: ObservabilityPluginOptions = {},
-  ) {
-    observability = ObservabilityPlugin(options);
-
-    return observability.plugin;
-  }
-  ```
-
-  然后在 Module Federation 构建配置中注入它：
+  在 Module Federation 构建配置中注入插件入口和可序列化参数：
 
   ```ts title="module-federation.config.ts"
-  import path from 'node:path';
-
   export default {
     name: 'runtime_host',
     remotes: {
@@ -71,7 +47,7 @@ import { Tab, Tabs } from '@theme';
     },
     runtimePlugins: [
       [
-        path.resolve(__dirname, './mf-observability-runtime-plugin.ts'),
+        require.resolve('@module-federation/observability-plugin'),
         {
           level: 'verbose',
           browser: {
@@ -84,12 +60,13 @@ import { Tab, Tabs } from '@theme';
   };
   ```
 
-  如果业务代码需要主动标记组件加载成功，可以从同一个插件文件导入 `getObservability()`。
+  如果业务代码需要主动标记组件加载成功，可以在注册插件后的默认实例上调用 `markComponentLoaded`。
 
   ```ts
-  import { getObservability } from './mf-observability-runtime-plugin';
+  import { getInstance } from '@module-federation/runtime';
+  import '@module-federation/observability-plugin';
 
-  getObservability()?.markComponentLoaded({
+  getInstance()?.markComponentLoaded({
     requestId: 'remote1/Button',
     componentName: 'Button',
   });
@@ -103,14 +80,6 @@ import { Tab, Tabs } from '@theme';
   import { createInstance } from '@module-federation/runtime';
   import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-  export const observability = ObservabilityPlugin({
-    level: 'verbose',
-    browser: {
-      enabled: true,
-      scope: 'runtime_host',
-    },
-  });
-
   export const mf = createInstance({
     name: 'runtime_host',
     remotes: [
@@ -119,7 +88,15 @@ import { Tab, Tabs } from '@theme';
         entry: 'https://example.com/mf-manifest.json',
       },
     ],
-    plugins: [observability.plugin],
+    plugins: [
+      ObservabilityPlugin({
+        level: 'verbose',
+        browser: {
+          enabled: true,
+          scope: 'runtime_host',
+        },
+      }),
+    ],
   });
   ```
   </Tab>
@@ -151,12 +128,26 @@ window.__FEDERATION__.__OBSERVABILITY__.runtime_host.findReports({
 window.__FEDERATION__.__OBSERVABILITY__.runtime_host.exportReport('mf-...');
 ```
 
+如果只是想在开发环境观察加载链路，或者页面一直停在 loading 状态但还没有报错，开启浏览器读取入口后，开发模式默认会打印开始日志：
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'runtime_host',
+  },
+});
+```
+
+插件只会在 `loadRemote` 和 `loadShare` 开始时打印 `console.info`，其中包含 `traceId` 和读取命令。Agent 可以用这个 `traceId` 读取当前报告，查看 `status: "pending"`、`summary.phases`、`updatedAt` 和 `duration`，判断当前卡在哪一步。浏览器开发模式可通过 `trace.printStart: false` 关闭；浏览器生产模式默认关闭，只有显式设置 `trace.printStart: true` 才会开启。
+
 开发环境通常打开浏览器读取入口，方便人或 AI coding agent 直接读取报告：
 
 ```ts title="mf-runtime.ts"
 import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-export const observability = ObservabilityPlugin({
+export const observabilityPlugin = ObservabilityPlugin({
   level: 'verbose',
   browser: {
     enabled: true,
@@ -170,7 +161,7 @@ export const observability = ObservabilityPlugin({
 ```ts title="mf-runtime.ts"
 import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-export const observability = ObservabilityPlugin({
+export const observabilityPlugin = ObservabilityPlugin({
   level: 'summary',
   browser: {
     enabled: true,
@@ -215,6 +206,12 @@ export const observability = ObservabilityPlugin({
 | `browser.enabled` | `boolean` | `false` | 是否把读取入口挂到 `window.__FEDERATION__.__OBSERVABILITY__`。 |
 | `browser.scope` | `string` | host 名称 | 浏览器读取入口的命名空间，例如 `runtime_host`。 |
 | `browser.mode` | `'development' \| 'production'` | `'development'` | 浏览器输出模式。生产模式下 console 只输出最小提示。 |
+| `trace.printStart` | `boolean` | 浏览器开发模式为 `true`，浏览器生产模式为 `false` | 是否在 `loadRemote` 和 `loadShare` 开始时打印 `console.info`，便于开发环境和 Agent 获取 `traceId`。生产模式需要显式设置为 `true` 才会开启。 |
+| `react.enabled` | `boolean` | `false` | 是否尝试自动观测远程 React 函数组件的渲染生命周期。默认关闭。 |
+| `react.timeout` | `number` | `5000` | 开启 React 生命周期观测后，组件迟迟没有 mount 时多久记录超时事件。 |
+| `react.consumerNames` | `string[]` | `[]` | 只对指定消费者实例开启 React 生命周期观测。为空时不按消费者过滤。 |
+| `react.remoteIds` | `string[]` | `[]` | 只对指定远程请求开启 React 生命周期观测，例如 `remote/Button` 或 `./Button`。为空时不按远程请求过滤。 |
+| `react.defaultExportMode` | `'preserve' \| 'component'` | 自动选择 | 远程模块是 `{ default: Component }` 时，是否直接把包装后的组件作为返回值。通常保持默认即可。 |
 | `onEvent` | `(event, report, context) => void` | `undefined` | 每次记录观测事件时触发，适合接入自定义日志系统。 |
 | `onReport` | `(report, context) => void` | `undefined` | 报告更新时触发，生产环境常用它上传失败或恢复报告。 |
 | `onRawError` | `(error, context) => void` | `undefined` | 捕获原始错误对象时触发，适合接入业务自己的错误系统。 |
@@ -241,16 +238,16 @@ ObservabilityPlugin({
 import { createInstance } from '@module-federation/runtime';
 import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
 
-const observability = ObservabilityPlugin({
-  level: 'verbose',
-  fileOutput: true,
-  directory: '.mf/observability',
-});
-
 createInstance({
   name: 'node_host',
   remotes: [],
-  plugins: [observability.plugin],
+  plugins: [
+    ObservabilityPlugin({
+      level: 'verbose',
+      fileOutput: true,
+      directory: '.mf/observability',
+    }),
+  ],
 });
 ```
 
@@ -328,10 +325,38 @@ module.exports = {
 
 ## 标记业务组件成功
 
-Module Federation 能知道 remote module 是否加载完成，但不一定能知道业务组件自己的渲染、请求或初始化是否完成。业务认为组件可用时，可以主动标记。
+Module Federation 能知道 remote module 是否加载完成，但不一定能知道业务组件自己的请求、图表或 SDK 初始化是否完成。
+
+开启 React 生命周期观测后，插件会自动给远程 React 组件注入 `onMFRemoteLoaded` prop。生产者组件在自己认为业务可用时调用它即可：
+
+```tsx
+import { useEffect } from 'react';
+import type { OnMFRemoteLoaded } from '@module-federation/observability-plugin';
+
+export default function RemotePanel({
+  onMFRemoteLoaded,
+}: {
+  onMFRemoteLoaded?: OnMFRemoteLoaded;
+}) {
+  useEffect(() => {
+    onMFRemoteLoaded?.({
+      metadata: {
+        dataReady: true,
+      },
+    });
+  }, [onMFRemoteLoaded]);
+
+  return <section>Remote panel</section>;
+}
+```
+
+如果业务需要在消费者侧主动标记，也可以直接调用实例方法：
 
 ```ts
-observability.markComponentLoaded({
+import { getInstance } from '@module-federation/runtime';
+import '@module-federation/observability-plugin';
+
+getInstance()?.markComponentLoaded({
   requestId: 'remote1/Button',
   componentName: 'Button',
   metadata: {
@@ -342,6 +367,28 @@ observability.markComponentLoaded({
 
 报告里会出现 `component:business-loaded`，并且 `summary.outcome` 会变成 `"component-loaded"`。
 
+## 自动观测 React 组件 Mount
+
+如果是开发环境或 AI 调试场景，也可以手动开启远程 React 组件生命周期观测：
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  react: {
+    enabled: true,
+    timeout: 5000,
+  },
+});
+```
+
+开启后，插件会在 `loadRemote` 成功后尝试识别远程 React 函数组件，并包一层不产生 DOM 的组件。报告里会出现：
+
+- `component:react-render-started`
+- `component:react-mounted`
+- `component:react-render-timeout`
+
+这个包装还会给远程组件注入 `onMFRemoteLoaded` prop。这个能力只能说明 React 组件已经 mount，不能说明业务数据、图表或 SDK 已经完成。需要表达业务可用时，在生产者组件里调用 `props.onMFRemoteLoaded?.()`。
+
 ## 配合 `mf` Skill 使用
 
 安装 skill：
diff --git a/packages/observability-plugin/AI_TROUBLESHOOTING.md b/packages/observability-plugin/AI_TROUBLESHOOTING.md
index 2bfbf7485b1..d63dd783beb 100644
--- a/packages/observability-plugin/AI_TROUBLESHOOTING.md
+++ b/packages/observability-plugin/AI_TROUBLESHOOTING.md
@@ -46,12 +46,24 @@ read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport("mf-..."
 ```
 
 Run the `read:` command exactly as printed. If the browser global reader is not
-enabled, use the observability controller created by application code:
+enabled, ask for the application-owned `onReport` output or the uploaded
+observability record.
+
+If the user wants to inspect loading chains or says the page is stuck loading
+without an error, do not wait for a failure hint. Read recent reports directly:
 
 ```ts
-observability.getReport('mf-...');
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 10 });
 ```
 
+Then look for `status: "pending"` or `summary.outcome: "pending"`. Use
+`startedAt`, `updatedAt`, `duration`, `summary.phases`, and
+`diagnosis.pendingPhases` to explain where the trace is currently stuck. When
+the browser reader is enabled in development mode, the console prints
+`Observability trace started` for `loadRemote` and `loadShare` by default; use
+that `traceId` to read the exact report. In production browser mode, this start
+log is disabled unless the app explicitly sets `trace.printStart: true`.
+
 For the latest report:
 
 ```ts
@@ -90,8 +102,7 @@ errorCode: RUNTIME-...
 
 Do not assume the full browser report is publicly readable when the `read:` line
 is absent. Ask the application owner to export it with `exportReport(traceId)`,
-read it through the application-owned observability controller, or check the
-application's own uploaded observability record.
+or check the application's own uploaded observability record.
 
 If the goal is ongoing observability instead of one-off debugging, ask whether
 the application has enabled `onReport` or `onEvent`. In production, those
@@ -170,12 +181,27 @@ not by an AI model.
 
 - `summary.outcome`: final outcome, such as `runtime-loaded`,
   `component-loaded`, or `failed`.
+- `summary.runtimeLoaded`: the remote module loaded successfully in the runtime.
+- `summary.loadCompleted`: the `loadRemote` flow ended; this is not by itself a
+  success signal.
+- `summary.componentLoaded`: a component-level success signal was observed. It
+  can come from business `markComponentLoaded` or from the opt-in React lifecycle
+  observer reporting `component:react-mounted`.
 - `summary.phases`: per-phase status, duration, cache, retry, and recovery
   markers.
 - `summary.flags`: cross-phase cache, retry, fallback, and recovery markers.
-- `summary.shared`: last observed shared provider/version result.
+- `summary.shared`: last observed shared provider/version result. If multiple
+  shared dependencies are involved, inspect every `phase: "shared"` event.
 - `summary.error`: compact error summary.
 
+If React lifecycle observation is enabled, reports may include
+`component:react-render-started`, `component:react-mounted`, or
+`component:react-render-timeout`. Treat `component:react-mounted` as React mount
+success only. It does not prove that business data, charts, or SDK
+initialization completed. The wrapper also injects an `onMFRemoteLoaded` prop
+into the remote React component; if the producer calls it, the report includes
+`component:business-loaded`, which is the producer's explicit ready signal.
+
 ### Build files
 
 Runtime reports do not embed build evidence. If you need build-side facts, read
@@ -354,6 +380,7 @@ Shared dependency or async boundary configuration failed.
 Start with:
 
 - `summary.shared`
+- all `events` entries where `phase === "shared"`
 - shared config in `.mf/observability/build-info.json` when available
 - `summary.error.lifecycle`
 - `diagnosis.actions`
@@ -365,6 +392,13 @@ Likely fixes:
 - Fix `eager` for sync shared usage.
 - Add an async startup or async boundary when needed.
 
+Shared evidence is scoped to the MF instance that resolved the shared
+dependency. It can identify the instance, shared package, selected
+provider/version, and related config. Do not claim that a shared dependency was
+caused by a specific remote/expose unless the report contains explicit evidence.
+Bundler runtime chunk and module execution can trigger shared resolution after
+remote loading, so remote/expose causality is not guaranteed.
+
 ### `RUNTIME-008`
 
 RemoteEntry loading or execution failed.
diff --git a/packages/observability-plugin/README.md b/packages/observability-plugin/README.md
index 7bb14da1542..cfe21e6879f 100644
--- a/packages/observability-plugin/README.md
+++ b/packages/observability-plugin/README.md
@@ -15,21 +15,19 @@ Node file output, and no raw error stack in console output.
 import { createInstance } from '@module-federation/runtime';
 import { ObservabilityPlugin } from '@module-federation/observability-plugin';
 
-const observability = ObservabilityPlugin({
-  level: 'verbose',
-  browser: {
-    enabled: true,
-    scope: 'host',
-  },
-});
-
 createInstance({
   name: 'host',
-  plugins: [observability.plugin],
+  plugins: [
+    ObservabilityPlugin({
+      level: 'verbose',
+      browser: {
+        enabled: true,
+        scope: 'host',
+      },
+    }),
+  ],
   remotes: [],
 });
-
-const report = observability.getLatestReport();
 ```
 
 The plugin does not upload data or expose a browser global by default. Reports
@@ -68,7 +66,13 @@ Failure hints are printed with `console.error` so browser DevTools, CDP-based
 agents, Node logs, and log collection systems can detect that a Module
 Federation load failed and then use the printed `traceId` to fetch the full
 report. Successful or recovered reports are still available through the reader
-APIs and callbacks, but they are not promoted to console errors.
+APIs and callbacks, but they are not promoted to console errors. When the
+browser reader is enabled in development mode, the plugin prints a small
+`console.info` line by default when a `loadRemote` or `loadShare` trace starts.
+The line includes the `traceId` and read command so an agent can inspect pending
+loading state before a timeout or error happens. In production browser mode,
+start logs are disabled by default; set `trace.printStart: true` only when you
+explicitly want them.
 
 The runtime only exposes the loading lifecycle hooks needed to know whether the
 main flow started, succeeded, or failed. This plugin listens to those hooks,
@@ -76,7 +80,8 @@ derives detailed reasons like shared version mismatch or eager boundary issues,
 and exposes the final loading state through a small `summary` object:
 
 - `runtime-loaded`: Module Federation finished loading the remote module.
-- `component-loaded`: business code called `markComponentLoaded`.
+- `component-loaded`: business code called `markComponentLoaded`, or the
+  opt-in React lifecycle observer confirmed that the remote component mounted.
 - `failed`: the load failed and `failedPhase` points to the first specific
   failing phase.
 - `recovered`: loading hit an error but a fallback/recovery path returned a
@@ -120,10 +125,36 @@ mismatch, and eager boundary errors are not retried by the retry plugin by
 default because they are usually configuration or availability problems instead
 of transient network failures.
 
-Business code can mark its own success condition with a fixed event:
+Business code can mark its own success condition with a fixed event. When React
+component lifecycle observation is enabled, the wrapper injects an
+`onMFRemoteLoaded` prop into the remote component. The producer can call it when
+the component's own ready condition is met:
+
+```tsx
+import { useEffect } from 'react';
+import type { OnMFRemoteLoaded } from '@module-federation/observability-plugin';
+
+export default function RemotePanel({ onMFRemoteLoaded }: { onMFRemoteLoaded?: OnMFRemoteLoaded }) {
+  useEffect(() => {
+    onMFRemoteLoaded?.({
+      metadata: {
+        dataReady: true,
+      },
+    });
+  }, [onMFRemoteLoaded]);
+
+  return <section>Remote panel</section>;
+}
+```
+
+If the app wants to mark readiness from the consumer side, it can still call the
+instance method directly:
 
 ```ts
-observability.markComponentLoaded({
+import { getInstance } from '@module-federation/runtime';
+import '@module-federation/observability-plugin';
+
+getInstance()?.markComponentLoaded({
   requestId: 'remote/Button',
   componentName: 'Button',
   metadata: {
@@ -132,9 +163,40 @@ observability.markComponentLoaded({
 });
 ```
 
-This records `component:business-loaded` on the same trace when possible.
+Both paths record `component:business-loaded` on the same trace when possible.
 Business metadata is optional. String values keep their original details and are
-only length-limited, so user-provided metadata remains trustworthy.
+only length-limited, so user-provided metadata remains trustworthy. The instance
+method is attached when the observability plugin is registered. If an
+application uses multiple runtime instances, call it on the instance that
+registered this plugin.
+
+React component lifecycle observation is available only when explicitly enabled:
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  react: {
+    enabled: true,
+    timeout: 5000,
+    consumerNames: ['runtime_host'],
+    remoteIds: ['remote/Button'],
+  },
+});
+```
+
+When this option is enabled, the plugin tries to wrap remote function components
+returned by `loadRemote`. The wrapper does not add DOM nodes. It injects the
+`onMFRemoteLoaded` prop and records
+`component:react-render-started`, `component:react-mounted`, or
+`component:react-render-timeout`. This is useful for dev and AI debugging, but
+it only means React mounted the component. Keep using `markComponentLoaded` when
+the business definition of success depends on data, charts, SDKs, or other async
+work inside the remote component.
+
+Use `react.consumerNames` or `react.remoteIds` to limit this behavior to the
+consumers or remote requests you are actively debugging. If both are empty, the
+plugin observes detected React function components for every runtime instance
+that registered it.
 
 Browser output is available only when the plugin option explicitly enables it.
 When browser output is enabled, the report can be read from:
@@ -147,11 +209,29 @@ window.__FEDERATION__.__OBSERVABILITY__.host.findReports({ remote: 'remote1' });
 window.__FEDERATION__.__OBSERVABILITY__.host.exportReport('mf-trace-id');
 ```
 
-The same methods are available on the observability controller returned by
-`ObservabilityPlugin()`. `getReports({ limit })` returns recent reports newest
-first. `findReports()` can filter by `traceId`, `remote`, `expose`, `shared`,
-`status`, or `outcome`. `exportReport()` returns a copied report object, using
-the latest report when no `traceId` is provided.
+`getReports({ limit })` returns recent reports newest first. `findReports()` can
+filter by `traceId`, `remote`, `expose`, `shared`, `status`, or `outcome`.
+`exportReport()` returns a copied report object, using the latest report when no
+`traceId` is provided.
+
+For agent-led development debugging where a page may stay in a loading state,
+enable the browser reader. Development browser mode prints start traces by
+default:
+
+```ts
+ObservabilityPlugin({
+  level: 'verbose',
+  browser: {
+    enabled: true,
+    scope: 'host',
+  },
+});
+```
+
+This prints only `loadRemote` and `loadShare` start lines. It does not print a
+line for every internal phase. Set `trace.printStart: false` to disable it in
+development browser mode. In production browser mode, set
+`trace.printStart: true` to opt in.
 
 For browser production use, set `browser.mode: "production"` when the runtime
 console must stay minimal:
@@ -169,10 +249,10 @@ ObservabilityPlugin({
 In production browser mode, the `console.error` hint only includes the `traceId`
 and known `errorCode`. It does not print the report body, raw stack, request
 URL, or `read:` command. Full reports are still available only through explicit
-user choices such as the observability controller, `exportReport()`, or an
-application-owned `onReport` upload. Production applications that want richer
-observability should prefer `onReport` / `onEvent` to forward reports to their
-own telemetry system instead of exposing a public browser global.
+user choices such as `exportReport()` or an application-owned `onReport` upload.
+Production applications that want richer observability should prefer
+`onReport` / `onEvent` to forward reports to their own telemetry system instead
+of exposing a public browser global.
 
 Node file output is provided by the Node-specific entry:
 
@@ -180,15 +260,15 @@ Node file output is provided by the Node-specific entry:
 import { createInstance } from '@module-federation/runtime';
 import { ObservabilityPlugin } from '@module-federation/observability-plugin/node';
 
-const observability = ObservabilityPlugin({
-  level: 'verbose',
-  fileOutput: true,
-  directory: '.mf/observability',
-});
-
 createInstance({
   name: 'host',
-  plugins: [observability.plugin],
+  plugins: [
+    ObservabilityPlugin({
+      level: 'verbose',
+      fileOutput: true,
+      directory: '.mf/observability',
+    }),
+  ],
   remotes: [],
 });
 ```
@@ -293,3 +373,13 @@ Shared dependency reports include only evidence fields such as package name,
 share scope, requested version, available versions, selected provider, and a
 reason like `missing-provider`, `version-mismatch`, or `sync-async-boundary`.
 They do not include shared factories, module values, source, or business data.
+
+Shared observability is intentionally scoped to the Module Federation instance
+that resolved the shared dependency. It can answer which MF instance loaded a
+shared package, which registered provider/version was selected, and the related
+scope/version/eager configuration. It does not guarantee a causal link from that
+shared dependency back to a specific remote or expose, because shared resolution
+can be triggered later by the bundler runtime while chunks and module factories
+execute. When multiple shared dependencies are involved, read all
+`phase: "shared"` events. `summary.shared` is only a compact last-observed
+summary.
diff --git a/packages/observability-plugin/__tests__/observability.spec.ts b/packages/observability-plugin/__tests__/observability.spec.ts
index ad3a9465ae1..738dfd644ac 100644
--- a/packages/observability-plugin/__tests__/observability.spec.ts
+++ b/packages/observability-plugin/__tests__/observability.spec.ts
@@ -2,12 +2,12 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
-import { ObservabilityPlugin } from '../src';
+import { createObservability, ObservabilityPlugin } from '../src';
 import {
   ObservabilityBuildPlugin,
   createObservabilityBuildInfo,
 } from '../src/build';
-import { ObservabilityPlugin as ObservabilityNode } from '../src/node';
+import { createNodeObservability as ObservabilityNode } from '../src/node';
 
 const enabledOrigin = {
   options: {
@@ -415,7 +415,7 @@ describe('ObservabilityBuildPlugin', () => {
 });
 
 const emitRemoteLoaded = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.onLoad?.({
@@ -435,7 +435,7 @@ const emitRemoteLoaded = (
   } as any);
 
 const emitRemoteStart = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.beforeRequest?.({
@@ -446,7 +446,7 @@ const emitRemoteStart = (
   } as any);
 
 const emitRemoteComplete = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.afterLoadRemote?.({
@@ -461,7 +461,7 @@ const emitRemoteComplete = (
   } as any);
 
 const emitRemoteMatch = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.afterMatchRemote?.({
@@ -476,7 +476,7 @@ const emitRemoteMatch = (
   } as any);
 
 const emitRemoteInit = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.afterInitRemote?.({
@@ -490,7 +490,7 @@ const emitRemoteInit = (
   } as any);
 
 const emitExposePhase = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   hookName: 'beforeGetExpose' | 'afterGetExpose',
   overrides: Record<string, unknown> = {},
 ) =>
@@ -506,7 +506,7 @@ const emitExposePhase = (
   } as any);
 
 const emitFactoryPhase = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   hookName: 'beforeExecuteFactory' | 'afterExecuteFactory',
   overrides: Record<string, unknown> = {},
 ) =>
@@ -523,7 +523,7 @@ const emitFactoryPhase = (
   } as any);
 
 const emitRemoteError = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.errorLoadRemote?.({
@@ -541,7 +541,7 @@ const emitRemoteError = (
   } as any);
 
 const emitManifestError = (
-  observability: ReturnType<typeof ObservabilityPlugin>,
+  observability: ReturnType<typeof createObservability>,
   overrides: Record<string, unknown> = {},
 ) =>
   observability.plugin.errorLoadRemote?.({
@@ -703,23 +703,325 @@ const createBuildCompilerFixture = (
 };
 
 describe('ObservabilityPlugin', () => {
-  it('does not record events when the plugin is disabled', () => {
-    const observability = ObservabilityPlugin({
+  it('returns a runtime plugin and attaches markComponentLoaded to the runtime instance', () => {
+    const plugin = ObservabilityPlugin({ level: 'verbose' });
+    const instance = {} as {
+      markComponentLoaded?: ReturnType<
+        typeof createObservability
+      >['markComponentLoaded'];
+    };
+
+    expect(plugin.name).toBe('observability-plugin');
+    plugin.apply?.(
+      instance as unknown as Parameters<NonNullable<typeof plugin.apply>>[0],
+    );
+
+    expect(typeof instance.markComponentLoaded).toBe('function');
+  });
+
+  it('wraps a remote React function component only when react lifecycle observability is enabled', async () => {
+    const effects: Array<() => void | (() => void)> = [];
+    const react = {
+      createElement: vi.fn((type: unknown, props?: unknown) => ({
+        type,
+        props,
+      })),
+      useEffect: vi.fn((effect: () => void | (() => void)) => {
+        effects.push(effect);
+      }),
+    };
+    const observability = createObservability({
+      level: 'verbose',
+      react: {
+        enabled: true,
+        timeout: 0,
+      },
+    });
+
+    function RemoteButton() {
+      return null;
+    }
+
+    const wrapped = await observability.plugin.onLoad?.({
+      id: 'remote/Button',
+      pkgNameOrAlias: 'remote',
+      expose: './Button',
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      options: {},
+      origin: {
+        ...enabledOrigin,
+        loadShareSync: () => () => react,
+      },
+      exposeModule: RemoteButton,
+      exposeModuleFactory: undefined,
+      moduleInstance: {},
+    } as any);
+
+    expect(typeof wrapped).toBe('function');
+
+    (wrapped as (props: Record<string, unknown>) => unknown)({
+      label: 'Save',
+    });
+    effects[0]?.();
+
+    const renderedProps = react.createElement.mock.calls[0]?.[1] as {
+      label: string;
+      onMFRemoteLoaded: (options?: {
+        componentName?: string;
+        metadata?: Record<string, unknown>;
+      }) => void;
+    };
+
+    expect(react.createElement).toHaveBeenCalledWith(
+      RemoteButton,
+      expect.objectContaining({
+        label: 'Save',
+        onMFRemoteLoaded: expect.any(Function),
+      }),
+    );
+    expect(observability.getEvents()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          phase: 'component',
+          status: 'start',
+          eventName: 'component:react-render-started',
+          source: 'react',
+          componentName: 'RemoteButton',
+        }),
+        expect.objectContaining({
+          phase: 'component',
+          status: 'success',
+          eventName: 'component:react-mounted',
+          source: 'react',
+          componentName: 'RemoteButton',
+        }),
+      ]),
+    );
+    expect(observability.getLatestReport()?.summary.outcome).toBe(
+      'component-loaded',
+    );
+    expect(observability.getLatestReport()?.diagnosis?.title).toBe(
+      'React component mounted',
+    );
+
+    renderedProps.onMFRemoteLoaded({
+      metadata: {
+        readySource: 'producer',
+      },
+    });
+
+    expect(observability.getEvents()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          phase: 'component',
+          status: 'success',
+          eventName: 'component:business-loaded',
+          source: 'business',
+          componentName: 'RemoteButton',
+          metadata: {
+            readySource: 'producer',
+          },
+        }),
+      ]),
+    );
+
+    react.createElement.mockClear();
+    effects.length = 0;
+
+    function RemoteCard() {
+      return null;
+    }
+
+    const remoteModule = {
+      default: RemoteCard,
+      named: 'value',
+    };
+    const wrappedModule = await observability.plugin.onLoad?.({
+      id: 'remote/Card',
+      pkgNameOrAlias: 'remote',
+      expose: './Card',
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      options: {},
+      origin: {
+        ...enabledOrigin,
+        loadShareSync: () => () => react,
+      },
+      exposeModule: remoteModule,
+      exposeModuleFactory: undefined,
+      moduleInstance: {},
+    } as any);
+
+    expect(wrappedModule).toBeUndefined();
+    expect(remoteModule.named).toBe('value');
+    expect(remoteModule.default).toEqual(expect.any(Function));
+
+    const WrappedDefault = remoteModule.default as (
+      props: Record<string, unknown>,
+    ) => unknown;
+    WrappedDefault({});
+    effects[0]?.();
+
+    expect(react.createElement).toHaveBeenCalledWith(
+      RemoteCard,
+      expect.objectContaining({
+        onMFRemoteLoaded: expect.any(Function),
+      }),
+    );
+  });
+
+  it('wraps explicitly matched React remotes even when the compiled component name is not capitalized', async () => {
+    const react = {
+      createElement: vi.fn((type: unknown, props?: unknown) => ({
+        type,
+        props,
+      })),
+      useEffect: vi.fn(),
+    };
+    const observability = createObservability({
+      level: 'verbose',
+      react: {
+        enabled: true,
+        remoteIds: ['remote/profile'],
+      },
+    });
+
+    const compiledRemote = function profile_widget() {
+      return null;
+    };
+
+    const unmatched = await observability.plugin.onLoad?.({
+      id: 'remote/settings',
+      pkgNameOrAlias: 'remote',
+      expose: './settings',
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      options: {},
+      origin: {
+        ...enabledOrigin,
+        loadShareSync: () => () => react,
+      },
+      exposeModule: compiledRemote,
+      exposeModuleFactory: undefined,
+      moduleInstance: {},
+    } as any);
+
+    expect(unmatched).toBeUndefined();
+
+    const matched = await observability.plugin.onLoad?.({
+      id: 'remote/profile',
+      pkgNameOrAlias: 'remote',
+      expose: './profile',
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      options: {},
+      origin: {
+        ...enabledOrigin,
+        loadShareSync: () => () => react,
+      },
+      exposeModule: compiledRemote,
+      exposeModuleFactory: undefined,
+      moduleInstance: {},
+    } as any);
+
+    expect(typeof matched).toBe('function');
+
+    (matched as (props: Record<string, unknown>) => unknown)({});
+
+    expect(react.createElement).toHaveBeenCalledWith(
+      compiledRemote,
+      expect.objectContaining({
+        onMFRemoteLoaded: expect.any(Function),
+      }),
+    );
+  });
+
+  it('injects the producer loaded callback even when React cannot be resolved from shared scope', async () => {
+    const observability = createObservability({
+      level: 'verbose',
+      react: {
+        enabled: true,
+      },
+    });
+
+    function RemotePanel(props: {
+      onMFRemoteLoaded?: (options?: {
+        metadata?: Record<string, unknown>;
+      }) => void;
+    }) {
+      props.onMFRemoteLoaded?.({
+        metadata: {
+          readySource: 'producer',
+        },
+      });
+      return 'rendered';
+    }
+
+    const wrapped = await observability.plugin.onLoad?.({
+      id: 'remote/Panel',
+      pkgNameOrAlias: 'remote',
+      expose: './Panel',
+      remote: {
+        name: 'remote',
+        entry: 'http://localhost:3001/mf-manifest.json',
+      },
+      options: {},
+      origin: {
+        ...enabledOrigin,
+        loadShareSync: () => false,
+        loadShare: async () => false,
+      },
+      exposeModule: RemotePanel,
+      exposeModuleFactory: undefined,
+      moduleInstance: {},
+    } as any);
+
+    expect(typeof wrapped).toBe('function');
+    expect((wrapped as (props: Record<string, unknown>) => unknown)({})).toBe(
+      'rendered',
+    );
+    expect(observability.getEvents()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          phase: 'component',
+          status: 'success',
+          eventName: 'component:business-loaded',
+          source: 'business',
+          componentName: 'RemotePanel',
+          metadata: {
+            readySource: 'producer',
+          },
+        }),
+      ]),
+    );
+  });
+
+  it('does not record events when the plugin is disabled', async () => {
+    const observability = createObservability({
       enabled: false,
       level: 'verbose',
     });
 
-    emitRemoteLoaded(observability);
+    await emitRemoteLoaded(observability);
 
     expect(observability.getEvents()).toHaveLength(0);
     expect(observability.getLatestReport()).toBeUndefined();
   });
 
-  it('records a successful loadRemote report when enabled', () => {
-    const observability = ObservabilityPlugin({ level: 'verbose' });
+  it('records a successful loadRemote report when enabled', async () => {
+    const observability = createObservability({ level: 'verbose' });
 
     emitRemoteStart(observability);
-    emitRemoteLoaded(observability);
+    await emitRemoteLoaded(observability);
 
     const report = observability.getLatestReport();
     expect(report?.status).toBe('success');
@@ -753,13 +1055,13 @@ describe('ObservabilityPlugin', () => {
     expect(report?.events).toHaveLength(2);
   });
 
-  it('omits undefined fields from public snapshots', () => {
-    const observability = ObservabilityPlugin({
+  it('omits undefined fields from public snapshots', async () => {
+    const observability = createObservability({
       level: 'verbose',
     });
 
     emitRemoteStart(observability);
-    emitRemoteLoaded(observability);
+    await emitRemoteLoaded(observability);
 
     const report = observability.getLatestReport();
     const events = observability.getEvents();
@@ -769,11 +1071,11 @@ describe('ObservabilityPlugin', () => {
     expect(hasUndefinedField(events)).toBe(false);
   });
 
-  it('records a complete loadRemote event as the final runtime outcome', () => {
-    const observability = ObservabilityPlugin({ level: 'verbose' });
+  it('records a complete loadRemote event as the final runtime outcome', async () => {
+    const observability = createObservability({ level: 'verbose' });
 
     emitRemoteStart(observability);
-    emitRemoteLoaded(observability);
+    await emitRemoteLoaded(observability);
     emitRemoteComplete(observability);
 
     const report = observability.getLatestReport();
@@ -788,7 +1090,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records manifest and remoteEntry lifecycle hooks without observability events', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -864,7 +1166,7 @@ describe('ObservabilityPlugin', () => {
         },
       };
 
-      const observability = ObservabilityPlugin({
+      const observability = createObservability({
         level: 'verbose',
         console: false,
       });
@@ -910,7 +1212,7 @@ describe('ObservabilityPlugin', () => {
         },
       };
 
-      const observability = ObservabilityPlugin({
+      const observability = createObservability({
         level: 'verbose',
         console: false,
       });
@@ -974,7 +1276,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('treats a recovered complete event as a recovered runtime outcome', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1005,7 +1307,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('keeps summary level compact while preserving phase durations', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'summary',
       console: false,
     });
@@ -1029,7 +1331,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('preserves urls and error message fields for observability', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1050,7 +1352,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('keeps the first specific failed phase when loadRemote closes the trace', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1087,7 +1389,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records runtime error code and manifest context for RUNTIME-003', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1168,7 +1470,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records host remote summary for RUNTIME-004 match failures', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1226,7 +1528,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records remoteEntry global context for RUNTIME-001', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1300,7 +1602,7 @@ describe('ObservabilityPlugin', () => {
 
   it('classifies RUNTIME-008 remoteEntry resource failures', () => {
     const createReportForError = (error: Error) => {
-      const observability = ObservabilityPlugin({
+      const observability = createObservability({
         level: 'verbose',
         console: false,
       });
@@ -1396,7 +1698,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records detailed remote phases and keeps expose as the failed phase', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1450,7 +1752,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records factory execution success with a phase duration', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1476,8 +1778,8 @@ describe('ObservabilityPlugin', () => {
     });
   });
 
-  it('reads recent reports, filters by observability fields, and exports copies', () => {
-    const observability = ObservabilityPlugin({
+  it('reads recent reports, filters by observability fields, and exports copies', async () => {
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1485,11 +1787,11 @@ describe('ObservabilityPlugin', () => {
     vi.useFakeTimers();
     try {
       vi.setSystemTime(1000);
-      emitRemoteLoaded(observability);
+      await emitRemoteLoaded(observability);
       const buttonTraceId = observability.getLatestReport()?.traceId || '';
 
       vi.setSystemTime(2000);
-      emitRemoteLoaded(observability, {
+      await emitRemoteLoaded(observability, {
         id: 'catalog/Card',
         expose: './Card',
         remote: {
@@ -1560,7 +1862,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('summarizes successful manifest, remoteEntry, cache, and retry recovery facts', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1652,7 +1954,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('records shared dependency observability', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1704,7 +2006,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('derives shared success details from loadShare hooks', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1750,7 +2052,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('derives shared version mismatch details from errorLoadShare', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1801,7 +2103,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('derives eager boundary details from loadShareSync failures', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1864,7 +2166,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('reports pure runtime shared failures with available shared versions', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -1928,7 +2230,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('prints a minimal console hint with traceId on error', () => {
-    const observability = ObservabilityPlugin({ level: 'verbose' });
+    const observability = createObservability({ level: 'verbose' });
     const error = vi
       .spyOn(console, 'error')
       .mockImplementation(() => undefined);
@@ -1952,7 +2254,7 @@ describe('ObservabilityPlugin', () => {
       expect(output).toContain('traceId: mf-');
       expect(output).toContain('phase: manifest');
       expect(output).toContain('errorCode:');
-      expect(output).toContain('read: observability.getReport');
+      expect(output).toContain('read: enable browser output or use onReport');
       expect(output).toContain('demo-secret');
       expect(output).toContain('token=');
       expect(output).toContain('#hash');
@@ -1964,7 +2266,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('prints only traceId and errorCode for browser production console hints', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       browser: {
         enabled: true,
@@ -2001,8 +2303,137 @@ describe('ObservabilityPlugin', () => {
     }
   });
 
+  it('prints start console hints by default in development mode', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: Record<string, unknown>;
+      }
+    ).__FEDERATION__;
+    const info = vi.spyOn(console, 'info').mockImplementation(() => undefined);
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: Record<string, unknown>;
+        }
+      ).__FEDERATION__ = {};
+      const observability = createObservability({
+        browser: {
+          enabled: true,
+          scope: 'runtime_host',
+        },
+      });
+
+      emitRemoteStart(observability);
+      observability.plugin.beforeLoadShare?.({
+        pkgName: 'react',
+        shareInfo: createShared(),
+        shared: {},
+        origin: enabledOrigin,
+      });
+
+      expect(info).toHaveBeenCalledTimes(2);
+      const remoteOutput = String(info.mock.calls[0]?.[0]);
+      const sharedOutput = String(info.mock.calls[1]?.[0]);
+
+      expect(remoteOutput).toContain(
+        '[Module Federation] Observability trace started',
+      );
+      expect(remoteOutput).toContain('traceId: mf-');
+      expect(remoteOutput).toContain('phase: loadRemote');
+      expect(remoteOutput).toContain('requestId: remote/Button');
+      expect(remoteOutput).toContain(
+        'read: window.__FEDERATION__.__OBSERVABILITY__["runtime_host"].getReport',
+      );
+
+      expect(sharedOutput).toContain('phase: shared');
+      expect(sharedOutput).toContain('requestId: shared:react');
+      expect(sharedOutput).toContain('shared: react');
+      expect(sharedOutput).toContain('lifecycle: loadShare');
+
+      const reports = observability.getReports({ limit: 10 });
+      expect(reports).toHaveLength(2);
+      expect(reports.map((report) => report.status)).toEqual([
+        'pending',
+        'pending',
+      ]);
+    } finally {
+      (
+        globalThis as {
+          __FEDERATION__?: Record<string, unknown>;
+        }
+      ).__FEDERATION__ = originalFederation;
+      info.mockRestore();
+    }
+  });
+
+  it('requires explicit start console hints in production mode', () => {
+    const originalFederation = (
+      globalThis as {
+        __FEDERATION__?: Record<string, unknown>;
+      }
+    ).__FEDERATION__;
+    const info = vi.spyOn(console, 'info').mockImplementation(() => undefined);
+
+    try {
+      (
+        globalThis as {
+          __FEDERATION__?: Record<string, unknown>;
+        }
+      ).__FEDERATION__ = {};
+
+      const productionDefault = createObservability({
+        browser: {
+          enabled: true,
+          scope: 'runtime_host',
+          mode: 'production',
+        },
+      });
+
+      emitRemoteStart(productionDefault);
+      productionDefault.plugin.beforeLoadShare?.({
+        pkgName: 'react',
+        shareInfo: createShared(),
+        shared: {},
+        origin: enabledOrigin,
+      });
+
+      expect(info).not.toHaveBeenCalled();
+      expect(productionDefault.getReports({ limit: 10 })).toHaveLength(0);
+
+      const productionExplicit = createObservability({
+        browser: {
+          enabled: true,
+          scope: 'runtime_host',
+          mode: 'production',
+        },
+        trace: {
+          printStart: true,
+        },
+      });
+
+      emitRemoteStart(productionExplicit);
+      productionExplicit.plugin.beforeLoadShare?.({
+        pkgName: 'react',
+        shareInfo: createShared(),
+        shared: {},
+        origin: enabledOrigin,
+      });
+
+      expect(info).toHaveBeenCalledTimes(2);
+      expect(productionExplicit.getReports({ limit: 10 })).toHaveLength(2);
+    } finally {
+      (
+        globalThis as {
+          __FEDERATION__?: Record<string, unknown>;
+        }
+      ).__FEDERATION__ = originalFederation;
+      info.mockRestore();
+    }
+  });
+
   it('stores the original error stack by default', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
     });
@@ -2033,7 +2464,7 @@ describe('ObservabilityPlugin', () => {
   });
 
   it('prints the raw stack only when explicitly allowed', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       printRawStack: true,
     });
@@ -2062,7 +2493,7 @@ describe('ObservabilityPlugin', () => {
     const onRawError = vi.fn(() => {
       throw new Error('ignored callback failure');
     });
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
       onRawError,
@@ -2090,7 +2521,7 @@ describe('ObservabilityPlugin', () => {
     expect(observability.getLatestReport()?.status).toBe('error');
   });
 
-  it('exposes a browser reader only when plugin options allow it', () => {
+  it('exposes a browser reader only when plugin options allow it', async () => {
     const originalFederation = (
       globalThis as {
         __FEDERATION__?: {
@@ -2108,7 +2539,7 @@ describe('ObservabilityPlugin', () => {
         }
       ).__FEDERATION__ = {};
 
-      const observability = ObservabilityPlugin({
+      const observability = createObservability({
         level: 'verbose',
         browser: {
           enabled: true,
@@ -2116,7 +2547,7 @@ describe('ObservabilityPlugin', () => {
         },
       });
 
-      emitRemoteLoaded(observability, {
+      await emitRemoteLoaded(observability, {
         origin: {
           options: {
             name: 'host',
@@ -2187,7 +2618,7 @@ describe('ObservabilityPlugin', () => {
     }
   });
 
-  it('does not expose the browser reader by default', () => {
+  it('does not expose the browser reader by default', async () => {
     const originalFederation = (
       globalThis as {
         __FEDERATION__?: {
@@ -2205,9 +2636,9 @@ describe('ObservabilityPlugin', () => {
         }
       ).__FEDERATION__ = {};
 
-      const observability = ObservabilityPlugin({ level: 'verbose' });
+      const observability = createObservability({ level: 'verbose' });
 
-      emitRemoteLoaded(observability);
+      await emitRemoteLoaded(observability);
 
       expect(
         (
@@ -2361,10 +2792,10 @@ describe('ObservabilityPlugin', () => {
     }
   });
 
-  it('lets business code mark component loaded after runtime observability starts', () => {
-    const observability = ObservabilityPlugin({ level: 'verbose' });
+  it('lets business code mark component loaded after runtime observability starts', async () => {
+    const observability = createObservability({ level: 'verbose' });
 
-    emitRemoteLoaded(observability);
+    await emitRemoteLoaded(observability);
 
     const componentEvent = observability.markComponentLoaded({
       requestId: 'remote/Button',
@@ -2404,8 +2835,8 @@ describe('ObservabilityPlugin', () => {
     expect(JSON.stringify(report)).toContain('token=');
   });
 
-  it('does not let observability callbacks affect loading', () => {
-    const observability = ObservabilityPlugin({
+  it('does not let observability callbacks affect loading', async () => {
+    const observability = createObservability({
       level: 'verbose',
       onEvent: vi.fn(() => {
         throw new Error('onEvent failed');
@@ -2415,13 +2846,13 @@ describe('ObservabilityPlugin', () => {
       }),
     });
 
-    expect(() => emitRemoteLoaded(observability)).not.toThrow();
+    await expect(emitRemoteLoaded(observability)).resolves.toBeUndefined();
 
     expect(observability.getLatestReport()?.status).toBe('success');
   });
 
   it('does not let observability callbacks affect error collection', () => {
-    const observability = ObservabilityPlugin({
+    const observability = createObservability({
       level: 'verbose',
       console: false,
       onEvent: vi.fn(() => {
diff --git a/packages/observability-plugin/src/index.ts b/packages/observability-plugin/src/index.ts
index 8ec0410abca..98978b427c3 100644
--- a/packages/observability-plugin/src/index.ts
+++ b/packages/observability-plugin/src/index.ts
@@ -1,4 +1,7 @@
-import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type {
+  ModuleFederation,
+  ModuleFederationRuntimePlugin,
+} from '@module-federation/runtime';
 
 export type ObservabilityLevel = 'error' | 'summary' | 'verbose';
 export type ObservabilityEventStatus =
@@ -7,7 +10,7 @@ export type ObservabilityEventStatus =
   | 'error'
   | 'complete';
 export type ObservabilityReportStatus = 'pending' | 'success' | 'error';
-export type ObservabilityEventSource = 'runtime' | 'business';
+export type ObservabilityEventSource = 'runtime' | 'business' | 'react';
 export type ObservabilityBrowserMode = 'development' | 'production';
 export type ObservabilityReportOutcome =
   | 'pending'
@@ -226,6 +229,16 @@ export interface ObservabilityPluginOptions {
     scope?: string;
     mode?: ObservabilityBrowserMode;
   };
+  trace?: {
+    printStart?: boolean;
+  };
+  react?: {
+    enabled?: boolean;
+    timeout?: number;
+    consumerNames?: string[];
+    remoteIds?: string[];
+    defaultExportMode?: 'preserve' | 'component';
+  };
   onEvent?: (
     event: ObservabilityEvent,
     report: ObservabilityReport,
@@ -258,6 +271,13 @@ export interface MarkComponentLoadedOptions {
   metadata?: Record<string, unknown>;
 }
 
+export interface MFRemoteLoadedOptions {
+  componentName?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export type OnMFRemoteLoaded = (options?: MFRemoteLoadedOptions) => void;
+
 export interface ObservabilityController {
   plugin: ObservabilityRuntimePlugin;
   getEvents(): ObservabilityEvent[];
@@ -273,6 +293,20 @@ export interface ObservabilityController {
   ): ObservabilityEvent | undefined;
 }
 
+export interface ObservabilityInstanceAPI {
+  markComponentLoaded(
+    options?: MarkComponentLoadedOptions,
+  ): ObservabilityEvent | undefined;
+}
+
+declare module '@module-federation/runtime-core' {
+  interface ModuleFederation {
+    markComponentLoaded(
+      options?: MarkComponentLoadedOptions,
+    ): ObservabilityEvent | undefined;
+  }
+}
+
 export interface ObservabilityRuntimeEventInput {
   phase: string;
   status: ObservabilityEventStatus;
@@ -298,9 +332,13 @@ export interface ObservabilityRuntimeEventInput {
 }
 
 export interface ObservabilityRuntimeOrigin {
+  name?: string;
   options?: {
+    id?: string;
     name?: string;
   };
+  loadShare?: (pkgName: string) => Promise<false | (() => unknown)>;
+  loadShareSync?: (pkgName: string) => false | (() => unknown);
 }
 
 export interface ObservabilityEventContext {
@@ -348,6 +386,7 @@ interface ObservabilityRemoteLoadArgs {
   expose?: string;
   remote?: ObservabilityRuntimeRemoteSource;
   origin: ObservabilityRuntimeOrigin;
+  exposeModule?: unknown;
 }
 
 interface ObservabilityRemoteBeforeRequestArgs {
@@ -476,9 +515,22 @@ interface FederationObservabilityGlobal {
   moduleInfo?: Record<string, unknown>;
 }
 
+interface ObservabilityReactLike {
+  createElement: (
+    type: unknown,
+    props?: Record<string, unknown> | null,
+    ...children: unknown[]
+  ) => unknown;
+  useEffect: (effect: () => void | (() => void), deps?: unknown[]) => void;
+}
+
 const DEFAULT_MAX_EVENTS = 100;
 const HARD_MAX_EVENTS = 1000;
 const COMPONENT_BUSINESS_LOADED_EVENT = 'component:business-loaded';
+const COMPONENT_REACT_RENDER_STARTED_EVENT = 'component:react-render-started';
+const COMPONENT_REACT_MOUNTED_EVENT = 'component:react-mounted';
+const COMPONENT_REACT_RENDER_TIMEOUT_EVENT = 'component:react-render-timeout';
+const ON_MF_REMOTE_LOADED_PROP = 'onMFRemoteLoaded';
 const SENSITIVE_PAIR_PATTERN =
   /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
 const ERROR_CODE_PATTERN = /\b(?:RUNTIME|TYPE|BUILD)-\d{3}\b/;
@@ -850,10 +902,172 @@ function sanitizeShared(
   };
 }
 
+function getObjectValue(value: Record<string, unknown>, key: string) {
+  return value[key];
+}
+
+function isReactLike(value: unknown): value is ObservabilityReactLike {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return (
+    typeof getObjectValue(value, 'createElement') === 'function' &&
+    typeof getObjectValue(value, 'useEffect') === 'function'
+  );
+}
+
+function resolveReactLike(value: unknown): ObservabilityReactLike | undefined {
+  if (isReactLike(value)) {
+    return value;
+  }
+
+  if (isRecord(value)) {
+    const defaultExport = getObjectValue(value, 'default');
+    if (isReactLike(defaultExport)) {
+      return defaultExport;
+    }
+  }
+
+  return undefined;
+}
+
+function getReactComponentName(component: unknown, fallback: string) {
+  if (typeof component === 'function') {
+    const displayName = (component as { displayName?: string }).displayName;
+    return displayName || component.name || fallback;
+  }
+
+  if (!isRecord(component)) {
+    return fallback;
+  }
+
+  const displayName = getObjectValue(component, 'displayName');
+  if (typeof displayName === 'string' && displayName) {
+    return displayName;
+  }
+
+  const render = getObjectValue(component, 'render');
+  if (typeof render === 'function') {
+    return render.displayName || render.name || fallback;
+  }
+
+  return fallback;
+}
+
+function isLikelyReactFunctionComponent(
+  component: unknown,
+  allowAnonymousComponent = false,
+) {
+  if (typeof component !== 'function') {
+    return false;
+  }
+
+  const name =
+    (component as { displayName?: string }).displayName || component.name || '';
+  if (/^use[A-Z0-9]/.test(name)) {
+    return false;
+  }
+
+  if (allowAnonymousComponent) {
+    return true;
+  }
+
+  if (!name) {
+    return false;
+  }
+
+  return /^[A-Z]/.test(name);
+}
+
+function copyComponentStatics(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+) {
+  const reserved = new Set([
+    'arguments',
+    'caller',
+    'length',
+    'name',
+    'prototype',
+    'displayName',
+  ]);
+
+  Object.getOwnPropertyNames(source).forEach((key) => {
+    if (reserved.has(key)) {
+      return;
+    }
+
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (!descriptor || !descriptor.configurable) {
+      return;
+    }
+
+    try {
+      Object.defineProperty(target, key, descriptor);
+    } catch {
+      // Static metadata is best effort and must not affect remote rendering.
+    }
+  });
+}
+
+function resolveReactComponentTarget(
+  component: unknown,
+  defaultExportMode: 'preserve' | 'component' = 'preserve',
+  allowAnonymousComponent = false,
+):
+  | {
+      component: unknown;
+      createResult: (wrappedComponent: unknown) => unknown;
+    }
+  | undefined {
+  if (isLikelyReactFunctionComponent(component, allowAnonymousComponent)) {
+    return {
+      component,
+      createResult: (wrappedComponent) => wrappedComponent,
+    };
+  }
+
+  if (!isRecord(component)) {
+    return undefined;
+  }
+
+  const defaultExport = getObjectValue(component, 'default');
+  if (!isLikelyReactFunctionComponent(defaultExport, allowAnonymousComponent)) {
+    return undefined;
+  }
+
+  return {
+    component: defaultExport,
+    createResult: (wrappedComponent) => {
+      const descriptor = Object.getOwnPropertyDescriptor(component, 'default');
+
+      try {
+        if (!descriptor || descriptor.writable || descriptor.set) {
+          component.default = wrappedComponent;
+        } else if (descriptor.configurable) {
+          Object.defineProperty(component, 'default', {
+            configurable: true,
+            enumerable: descriptor.enumerable,
+            writable: true,
+            value: wrappedComponent,
+          });
+        }
+      } catch {
+        // If the module namespace is read-only, leave the remote module untouched.
+      }
+
+      return defaultExportMode === 'component' ? wrappedComponent : undefined;
+    },
+  };
+}
+
 function normalizeEventSource(
   value: ObservabilityEventSource | undefined,
 ): ObservabilityEventSource | undefined {
-  return value === 'runtime' || value === 'business' ? value : undefined;
+  return value === 'runtime' || value === 'business' || value === 'react'
+    ? value
+    : undefined;
 }
 
 function extractErrorCode(value: unknown): string | undefined {
@@ -1443,7 +1657,7 @@ function createErrorContext(
   return clipObservabilityMetadata(context);
 }
 
-export function ObservabilityPlugin(
+export function createObservability(
   options: ObservabilityPluginOptions = {},
 ): ObservabilityController {
   const level = options.level || 'summary';
@@ -1459,8 +1673,10 @@ export function ObservabilityPlugin(
   const seenManifestUrls = new Set<string>();
   const seenRemoteEntryKeys = new Set<string>();
   const consoleReportedTraceIds = new Set<string>();
+  const consoleReportedStartKeys = new Set<string>();
   let latestTraceId: string | undefined;
   let runtimeObservabilityEnabled = false;
+  let suppressRuntimeEvents = false;
   let effectiveMaxEvents = configuredMaxEvents;
   let browserGlobalScope: string | undefined;
   let lastRuntimeOrigin: ObservabilityRuntimeOrigin | undefined;
@@ -1637,8 +1853,10 @@ export function ObservabilityPlugin(
   const isComponentLoadedEvent = (event: ObservabilityEvent) =>
     event.status === 'success' &&
     (event.eventName === COMPONENT_BUSINESS_LOADED_EVENT ||
+      event.eventName === COMPONENT_REACT_MOUNTED_EVENT ||
       (event.phase === 'component' &&
-        event.message === COMPONENT_BUSINESS_LOADED_EVENT));
+        (event.message === COMPONENT_BUSINESS_LOADED_EVENT ||
+          event.message === COMPONENT_REACT_MOUNTED_EVENT)));
 
   const shouldReplaceFailedPhase = (
     report: ObservabilityReport,
@@ -1764,10 +1982,10 @@ export function ObservabilityPlugin(
     const lastEvent = report.events[report.events.length - 1];
     let outcome: ObservabilityReportOutcome = 'pending';
 
-    if (componentLoaded) {
-      outcome = 'component-loaded';
-    } else if (recovered && runtimeLoaded) {
+    if (recovered && runtimeLoaded) {
       outcome = 'recovered';
+    } else if (componentLoaded) {
+      outcome = 'component-loaded';
     } else if (report.status === 'error') {
       outcome = 'failed';
     } else if (runtimeLoaded) {
@@ -1858,7 +2076,11 @@ export function ObservabilityPlugin(
   const getDiagnosisTitle = (report: ObservabilityReport) => {
     if (report.status !== 'error') {
       if (report.summary.componentLoaded) {
-        return 'Business component loaded';
+        return report.events.some(
+          (event) => event.eventName === COMPONENT_BUSINESS_LOADED_EVENT,
+        )
+          ? 'Business component loaded'
+          : 'React component mounted';
       }
       if (report.summary.runtimeLoaded) {
         return 'Remote loaded successfully';
@@ -2588,6 +2810,21 @@ export function ObservabilityPlugin(
   const shouldUseMinimalBrowserConsole = () =>
     options.browser?.mode === 'production';
 
+  const shouldUseStartTrace = () =>
+    options.trace?.printStart ??
+    (options.browser?.enabled === true && !shouldUseMinimalBrowserConsole());
+
+  const shouldPrintStartConsole = (event: ObservabilityEvent) =>
+    shouldUseStartTrace() &&
+    event.status === 'start' &&
+    (event.phase === 'loadRemote' || event.phase === 'shared') &&
+    shouldUseConsole();
+
+  const shouldRecordStartTrace = (input: ObservabilityRuntimeEventInput) =>
+    shouldUseStartTrace() &&
+    input.status === 'start' &&
+    (input.phase === 'loadRemote' || input.phase === 'shared');
+
   const getBrowserReadCommand = (traceId: string) => {
     if (!browserGlobalScope) {
       return undefined;
@@ -2651,9 +2888,7 @@ export function ObservabilityPlugin(
     if (browserReadCommand) {
       lines.push(`read: ${browserReadCommand}`);
     } else {
-      lines.push(
-        `read: observability.getReport(${JSON.stringify(report.traceId)})`,
-      );
+      lines.push('read: enable browser output or use onReport(report)');
     }
 
     const rawStack = getRawStack(rawError);
@@ -2668,6 +2903,60 @@ export function ObservabilityPlugin(
     }
   };
 
+  const emitStartConsoleHint = (
+    event: ObservabilityEvent,
+    report: ObservabilityReport,
+  ) => {
+    if (!shouldPrintStartConsole(event)) {
+      return;
+    }
+
+    const startKey = [
+      event.traceId,
+      event.phase,
+      event.requestId || event.shared?.name || event.remote?.name || '',
+      event.lifecycle || '',
+    ].join('|');
+    if (consoleReportedStartKeys.has(startKey)) {
+      return;
+    }
+    consoleReportedStartKeys.add(startKey);
+
+    const lines = [
+      '[Module Federation] Observability trace started',
+      `traceId: ${report.traceId}`,
+      `phase: ${event.phase}`,
+    ];
+
+    if (event.requestId) {
+      lines.push(`requestId: ${event.requestId}`);
+    }
+    if (event.remote?.name) {
+      lines.push(`remote: ${event.remote.name}`);
+    }
+    if (event.shared?.name) {
+      lines.push(`shared: ${event.shared.name}`);
+    }
+    if (event.lifecycle) {
+      lines.push(`lifecycle: ${event.lifecycle}`);
+    }
+
+    const browserReadCommand = getBrowserReadCommand(report.traceId);
+    if (browserReadCommand) {
+      lines.push(`read: ${browserReadCommand}`);
+    } else {
+      lines.push(
+        'read: enable browser output or use getReports({ limit: 10 })',
+      );
+    }
+
+    try {
+      console.info(lines.join('\n'));
+    } catch {
+      // Console output is best-effort observability only.
+    }
+  };
+
   const prepareOutputChannels = (origin: ObservabilityRuntimeOrigin) => {
     browserGlobalScope = undefined;
     ensureBrowserGlobal(origin);
@@ -2687,17 +2976,22 @@ export function ObservabilityPlugin(
     input: ObservabilityRuntimeEventInput,
     origin?: ObservabilityRuntimeOrigin,
   ) => {
+    if (suppressRuntimeEvents) {
+      return undefined;
+    }
+
     const traceId = resolveTraceId(input);
     const event = normalizeEvent(input, traceId, origin);
     applyPhaseDuration(event);
     updateTraceMaps(event);
 
-    if (!shouldRecordEvent(level, input)) {
+    if (!shouldRecordEvent(level, input) && !shouldRecordStartTrace(input)) {
       return undefined;
     }
 
     events.push(event);
     const report = updateReport(event);
+    emitStartConsoleHint(event, report);
     emitConsoleHint(event, report, input.error);
     notifyRawError(input.error, event, report, origin);
     notifyEvent(event, report, origin);
@@ -2705,8 +2999,265 @@ export function ObservabilityPlugin(
     return event;
   };
 
+  const markComponentLoaded = (
+    markOptions: MarkComponentLoadedOptions = {},
+  ) => {
+    if (options.enabled === false || !runtimeObservabilityEnabled) {
+      return undefined;
+    }
+
+    const traceId =
+      markOptions.traceId ||
+      (markOptions.requestId
+        ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || '')
+        : undefined) ||
+      latestTraceId ||
+      createTraceId({
+        phase: 'component',
+        status: 'success',
+        requestId: markOptions.requestId,
+      });
+
+    return recordEvent(
+      {
+        traceId,
+        phase: 'component',
+        status: 'success',
+        requestId: markOptions.requestId,
+        componentName: markOptions.componentName,
+        metadata: markOptions.metadata,
+        eventName: COMPONENT_BUSINESS_LOADED_EVENT,
+        message: COMPONENT_BUSINESS_LOADED_EVENT,
+        source: 'business',
+      },
+      lastRuntimeOrigin,
+    );
+  };
+
+  const getReactForOrigin = async (
+    origin: ObservabilityRuntimeOrigin,
+  ): Promise<ObservabilityReactLike | undefined> => {
+    const previousSuppressRuntimeEvents = suppressRuntimeEvents;
+    suppressRuntimeEvents = true;
+    try {
+      let reactFactory: false | (() => unknown) | undefined;
+      try {
+        reactFactory = origin.loadShareSync?.('react');
+      } catch {
+        reactFactory = undefined;
+      }
+
+      if (typeof reactFactory !== 'function') {
+        reactFactory = await origin.loadShare?.('react');
+      }
+
+      if (typeof reactFactory !== 'function') {
+        return undefined;
+      }
+
+      return resolveReactLike(reactFactory());
+    } catch {
+      return undefined;
+    } finally {
+      suppressRuntimeEvents = previousSuppressRuntimeEvents;
+    }
+  };
+
+  const getReactWrapPolicy = (loadArgs: ObservabilityRemoteLoadArgs) => {
+    if (options.react?.enabled !== true) {
+      return undefined;
+    }
+
+    const consumerNames = options.react.consumerNames || [];
+    const remoteIds = options.react.remoteIds || [];
+    if (!consumerNames.length && !remoteIds.length) {
+      return {
+        allowAnonymousComponent: false,
+      };
+    }
+
+    const consumerName = loadArgs.origin.options?.name || loadArgs.origin.name;
+    const consumerId = loadArgs.origin.options?.id;
+    const matched =
+      (consumerName ? consumerNames.includes(consumerName) : false) ||
+      (consumerId ? consumerNames.includes(consumerId) : false) ||
+      remoteIds.includes(loadArgs.id) ||
+      (loadArgs.expose ? remoteIds.includes(loadArgs.expose) : false);
+
+    return matched
+      ? {
+          allowAnonymousComponent: true,
+        }
+      : undefined;
+  };
+
+  const recordReactComponentEvent = (
+    loadArgs: ObservabilityRemoteLoadArgs,
+    status: ObservabilityEventStatus,
+    lifecycle: string,
+    eventName: string,
+    componentName: string,
+    message: string,
+    errorValue?: unknown,
+  ) =>
+    recordEvent(
+      {
+        phase: 'component',
+        status,
+        requestId: loadArgs.id,
+        expose: loadArgs.expose,
+        remote: createRemoteInfo(loadArgs.remote),
+        lifecycle,
+        eventName,
+        componentName,
+        message,
+        source: 'react',
+        error: errorValue,
+      },
+      loadArgs.origin,
+    );
+
+  const wrapReactComponent = async (
+    component: unknown,
+    loadArgs: ObservabilityRemoteLoadArgs,
+  ) => {
+    const wrapPolicy = getReactWrapPolicy(loadArgs);
+    if (!wrapPolicy) {
+      return undefined;
+    }
+
+    const target = resolveReactComponentTarget(
+      component,
+      options.react?.defaultExportMode ||
+        (wrapPolicy.allowAnonymousComponent ? 'component' : 'preserve'),
+      wrapPolicy.allowAnonymousComponent,
+    );
+    if (!target) {
+      return undefined;
+    }
+
+    const componentName = getReactComponentName(
+      target.component,
+      loadArgs.expose || loadArgs.id,
+    );
+    const timeout =
+      typeof options.react.timeout === 'number' &&
+      Number.isFinite(options.react.timeout)
+        ? Math.max(0, options.react.timeout)
+        : 5000;
+    let started = false;
+    let mounted = false;
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const originalComponent = target.component;
+
+    const clearRenderTimeout = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = undefined;
+      }
+    };
+
+    const recordStarted = () => {
+      if (started) {
+        return;
+      }
+      started = true;
+      recordReactComponentEvent(
+        loadArgs,
+        'start',
+        'reactRender',
+        COMPONENT_REACT_RENDER_STARTED_EVENT,
+        componentName,
+        COMPONENT_REACT_RENDER_STARTED_EVENT,
+      );
+
+      if (timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          if (mounted) {
+            return;
+          }
+          recordReactComponentEvent(
+            loadArgs,
+            'error',
+            'reactMountTimeout',
+            COMPONENT_REACT_RENDER_TIMEOUT_EVENT,
+            componentName,
+            COMPONENT_REACT_RENDER_TIMEOUT_EVENT,
+            new Error(
+              `React component "${componentName}" did not mount within ${timeout}ms`,
+            ),
+          );
+        }, timeout);
+      }
+    };
+
+    const react = await getReactForOrigin(loadArgs.origin);
+    const ObservedRemoteComponent = (props: Record<string, unknown>) => {
+      recordStarted();
+      if (react) {
+        react.useEffect(() => {
+          if (!mounted) {
+            mounted = true;
+            clearRenderTimeout();
+            recordReactComponentEvent(
+              loadArgs,
+              'success',
+              'reactMount',
+              COMPONENT_REACT_MOUNTED_EVENT,
+              componentName,
+              COMPONENT_REACT_MOUNTED_EVENT,
+            );
+          }
+
+          return clearRenderTimeout;
+        }, []);
+      }
+
+      const incomingProps = isRecord(props) ? props : {};
+      const originalLoadedCallback = getObjectValue(
+        incomingProps,
+        ON_MF_REMOTE_LOADED_PROP,
+      );
+      const onMFRemoteLoaded: OnMFRemoteLoaded = (loadedOptions = {}) => {
+        markComponentLoaded({
+          requestId: loadArgs.id,
+          componentName: loadedOptions.componentName || componentName,
+          metadata: loadedOptions.metadata,
+        });
+
+        if (typeof originalLoadedCallback === 'function') {
+          (originalLoadedCallback as OnMFRemoteLoaded)(loadedOptions);
+        }
+      };
+
+      const nextProps = {
+        ...incomingProps,
+        [ON_MF_REMOTE_LOADED_PROP]: onMFRemoteLoaded,
+      };
+
+      if (react) {
+        return react.createElement(originalComponent, nextProps);
+      }
+
+      return (
+        originalComponent as (nextProps: Record<string, unknown>) => unknown
+      )(nextProps);
+    };
+
+    ObservedRemoteComponent.displayName = `ObservedRemote(${componentName})`;
+    copyComponentStatics(
+      ObservedRemoteComponent as unknown as Record<string, unknown>,
+      originalComponent as unknown as Record<string, unknown>,
+    );
+
+    return target.createResult(ObservedRemoteComponent);
+  };
+
   const plugin: ObservabilityRuntimePlugin = {
     name: 'observability-plugin',
+    apply(instance: ModuleFederation) {
+      instance.markComponentLoaded = markComponentLoaded;
+    },
     beforeRequest(args) {
       const requestArgs = args as ObservabilityRemoteBeforeRequestArgs;
       if (!prepareRuntimeOrigin(requestArgs.origin)) {
@@ -2816,12 +3367,16 @@ export function ObservabilityPlugin(
         seenManifestUrls.add(manifestUrl);
       }
     },
-    onLoad(args) {
+    async onLoad(args) {
       const loadArgs = args as ObservabilityRemoteLoadArgs;
       if (!prepareRuntimeOrigin(loadArgs.origin)) {
         return;
       }
 
+      const wrappedComponent = await wrapReactComponent(
+        loadArgs.exposeModule,
+        loadArgs,
+      );
       recordEvent(
         {
           phase: 'loadRemote',
@@ -2834,6 +3389,9 @@ export function ObservabilityPlugin(
         },
         loadArgs.origin,
       );
+      if (wrappedComponent) {
+        return wrappedComponent;
+      }
     },
     errorLoadRemote(args) {
       const errorArgs = args as ObservabilityRemoteErrorArgs;
@@ -3165,43 +3723,21 @@ export function ObservabilityPlugin(
       seenManifestUrls.clear();
       seenRemoteEntryKeys.clear();
       consoleReportedTraceIds.clear();
+      consoleReportedStartKeys.clear();
       latestTraceId = undefined;
       runtimeObservabilityEnabled = false;
       effectiveMaxEvents = configuredMaxEvents;
       browserGlobalScope = undefined;
       lastRuntimeOrigin = undefined;
     },
-    markComponentLoaded(markOptions: MarkComponentLoadedOptions = {}) {
-      if (options.enabled === false || !runtimeObservabilityEnabled) {
-        return undefined;
-      }
-
-      const traceId =
-        markOptions.traceId ||
-        (markOptions.requestId
-          ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || '')
-          : undefined) ||
-        latestTraceId ||
-        createTraceId({
-          phase: 'component',
-          status: 'success',
-          requestId: markOptions.requestId,
-        });
-
-      return recordEvent(
-        {
-          traceId,
-          phase: 'component',
-          status: 'success',
-          requestId: markOptions.requestId,
-          componentName: markOptions.componentName,
-          metadata: markOptions.metadata,
-          eventName: COMPONENT_BUSINESS_LOADED_EVENT,
-          message: COMPONENT_BUSINESS_LOADED_EVENT,
-          source: 'business',
-        },
-        lastRuntimeOrigin,
-      );
-    },
+    markComponentLoaded,
   };
 }
+
+export function ObservabilityPlugin(
+  options: ObservabilityPluginOptions = {},
+): ObservabilityRuntimePlugin {
+  return createObservability(options).plugin;
+}
+
+export default ObservabilityPlugin;
diff --git a/packages/observability-plugin/src/node.ts b/packages/observability-plugin/src/node.ts
index 7d74deef2ff..874005e9aa8 100644
--- a/packages/observability-plugin/src/node.ts
+++ b/packages/observability-plugin/src/node.ts
@@ -1,8 +1,9 @@
 import {
-  ObservabilityPlugin as createBaseObservabilityPlugin,
+  createObservability as createBaseObservability,
   type ObservabilityController,
   type ObservabilityEvent,
   type ObservabilityEventContext,
+  type ObservabilityRuntimePlugin,
   type ObservabilityPluginOptions,
   type ObservabilityReport,
 } from './index';
@@ -251,9 +252,7 @@ function emitNodeConsoleHint(
     lines.push(`latest: ${getNodeLatestPathForConsole(options)}`);
     lines.push(`events: ${getNodeEventsPathForConsole(options)}`);
   } else {
-    lines.push(
-      `read: observability.getReport(${JSON.stringify(report.traceId)})`,
-    );
+    lines.push('read: enable fileOutput or use onReport(report)');
   }
 
   if (options.printRawStack === true && rawStack) {
@@ -267,13 +266,13 @@ function emitNodeConsoleHint(
   }
 }
 
-export function ObservabilityPlugin(
+export function createNodeObservability(
   options: ObservabilityNodeOptions = {},
 ): ObservabilityController {
   let nodeWriteQueue: Promise<void> = Promise.resolve();
   const consoleReportedTraceIds = new Set<string>();
   const rawStackByTraceId = new Map<string, string>();
-  const observability = createBaseObservabilityPlugin({
+  const observability = createBaseObservability({
     ...options,
     console: false,
     browser: undefined,
@@ -326,3 +325,11 @@ export function ObservabilityPlugin(
 
   return observability;
 }
+
+export function ObservabilityPlugin(
+  options: ObservabilityNodeOptions = {},
+): ObservabilityRuntimePlugin {
+  return createNodeObservability(options).plugin;
+}
+
+export default ObservabilityPlugin;
diff --git a/packages/observability-plugin/tsdown.config.ts b/packages/observability-plugin/tsdown.config.ts
index f90b3e14619..be386c77a5d 100644
--- a/packages/observability-plugin/tsdown.config.ts
+++ b/packages/observability-plugin/tsdown.config.ts
@@ -11,7 +11,12 @@ const baseConfig = {
   tsconfig: 'tsconfig.json',
   clean: true,
   entry,
-  external: ['@module-federation/runtime', 'node:fs', 'node:path'],
+  external: [
+    '@module-federation/runtime',
+    '@module-federation/sdk',
+    'node:fs',
+    'node:path',
+  ],
 };
 
 export default defineConfig([
diff --git a/packages/runtime-core/__tests__/hooks.spec.ts b/packages/runtime-core/__tests__/hooks.spec.ts
index 4fbce5ab82f..d536c8d359c 100644
--- a/packages/runtime-core/__tests__/hooks.spec.ts
+++ b/packages/runtime-core/__tests__/hooks.spec.ts
@@ -506,6 +506,20 @@ describe('hooks', () => {
     await expect(hook.emit('payload')).resolves.toBe('second-result');
   });
 
+  it('async hooks treat returning the original payload as no explicit result', async () => {
+    const hook = new AsyncHook<
+      [{ id: string }],
+      { id: string; wrapped?: boolean } | void | false
+    >('async-passthrough');
+    const payload = { id: 'remote/Button' };
+    const wrapped = { id: 'remote/Button', wrapped: true };
+
+    hook.on(() => wrapped);
+    hook.on((args) => args);
+
+    await expect(hook.emit(payload)).resolves.toBe(wrapped);
+  });
+
   it('async hooks still abort when a listener returns false', async () => {
     const hook = new AsyncHook<[string], string | void | false>('async-abort');
     const calls: Array<string> = [];
diff --git a/packages/runtime-core/src/remote/index.ts b/packages/runtime-core/src/remote/index.ts
index ce38a16471f..e268f575811 100644
--- a/packages/runtime-core/src/remote/index.ts
+++ b/packages/runtime-core/src/remote/index.ts
@@ -103,7 +103,7 @@ export class RemoteHandler {
           moduleInstance: Module;
         },
       ],
-      void
+      unknown
     >('onLoad'),
     afterLoadRemote: new AsyncHook<
       [
diff --git a/packages/runtime-core/src/utils/hooks/asyncHook.ts b/packages/runtime-core/src/utils/hooks/asyncHook.ts
index aad9fb182f6..f401593e85a 100644
--- a/packages/runtime-core/src/utils/hooks/asyncHook.ts
+++ b/packages/runtime-core/src/utils/hooks/asyncHook.ts
@@ -18,7 +18,10 @@ export class AsyncHook<
           return false; // Abort process
         } else if (i < ls.length) {
           return Promise.resolve(ls[i++].apply(null, data)).then((result) => {
-            if (result === undefined) {
+            if (
+              result === undefined ||
+              (data.length === 1 && result === data[0])
+            ) {
               return call(prev);
             }
             return call(result);
diff --git a/skills/mf/reference/observability.md b/skills/mf/reference/observability.md
index 4f1975ee937..be9b2327d6a 100644
--- a/skills/mf/reference/observability.md
+++ b/skills/mf/reference/observability.md
@@ -19,7 +19,7 @@ Use this sub-skill when the user provides or mentions:
 - a report field such as `diagnosis`, `summary.phases`, `ownerHint`, or
   `moduleInfo`
 
-## Runtime codes and plugin reports
+## Error codes vs observability reports
 
 Runtime error codes are still the stable first signal. The observability plugin
 does not replace `RUNTIME-xxx`; it enriches the code with phase, moduleInfo,
@@ -68,6 +68,24 @@ If the user only has the latest browser report, use:
 window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getLatestReport();
 ```
 
+If the user wants to inspect loading chains, observe MF loading, or debug a page
+that stays in loading state without an error or `traceId`, do not wait for a
+console error. Read recent reports directly:
+
+```ts
+window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].getReports({ limit: 10 });
+```
+
+Then look for reports with `status: "pending"` or
+`summary.outcome: "pending"`. Use `startedAt`, `updatedAt`, `duration`,
+`summary.phases`, and `diagnosis.pendingPhases` to explain which phase has
+started, which phase has not completed, and how long the trace has been idle.
+When the browser reader is enabled in development mode, the console prints
+`Observability trace started` lines for `loadRemote` and `loadShare` by default;
+use the printed `traceId` to read that exact report. In production browser mode,
+these start logs are disabled unless the app explicitly sets
+`trace.printStart: true`.
+
 For recent or filtered browser reports, use:
 
 ```ts
@@ -84,13 +102,13 @@ window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].findReports({
 window.__FEDERATION__.__OBSERVABILITY__['runtime_host'].exportReport('mf-...');
 ```
 
-If the browser global is disabled, ask for the app's observability controller or
-for the full report output pasted by the user.
+If the browser global is disabled, ask for the app's `onReport` output, uploaded
+observability record, or the full report output pasted by the user.
 
 If the browser console only contains `traceId` and `errorCode`, treat it as
 production-safe output. Do not assume the full report is globally readable. Ask
-for an explicit `exportReport(traceId)` output, the app observability controller
-output, or the user's uploaded observability record.
+for an explicit `exportReport(traceId)` output, the app's `onReport` output, or
+the user's uploaded observability record.
 
 ### Node or SSR
 
@@ -131,6 +149,37 @@ Read:
 13. `moduleInfo`
 14. `events`
 
+## Step 2.1: Decide loading success
+
+Use `summary.outcome` before reading raw `events`:
+
+- `runtime-loaded`: the remote module was loaded by Module Federation runtime.
+- `component-loaded`: a component-level success signal was observed. This may be
+  a business `markComponentLoaded` signal or the opt-in React lifecycle observer
+  reporting `component:react-mounted`.
+- `failed`: loading failed. Use `summary.error`, `diagnosis.actions`, and
+  `failedPhase`.
+- `recovered`: loading failed first, then retry or fallback returned a result.
+
+Use `summary.loadCompleted` only as "the loadRemote flow ended"; it does not by
+itself prove success. Use `summary.runtimeLoaded` for remote module success and
+`summary.componentLoaded` for component-level success.
+
+If `events` are needed, remote module success is usually:
+
+- `phase: "loadRemote"`
+- `status: "success"`
+- `lifecycle: "onLoad"`
+- `message: "remote:loaded"`
+
+React mount observation is opt-in. It records component events such as
+`component:react-render-started`, `component:react-mounted`, and
+`component:react-render-timeout`. Treat `component:react-mounted` as React mount
+success, not as proof that business data, charts, or SDKs finished loading.
+When this option is enabled, the wrapper also injects an `onMFRemoteLoaded` prop
+into the remote React component. If the producer calls that prop, treat the
+resulting `component:business-loaded` event as the producer's own ready signal.
+
 ## Step 3: Decide the likely owner
 
 Use `diagnosis.ownerHint` first:
@@ -185,185 +234,24 @@ Do not describe `moduleInfo.availableNames` as a component list, expose list, or
 prefetch list. It is the clipped list of deployment-provided moduleInfo remote
 candidate keys that were available when no entry matched the failed remote.
 
-## Step 6: Common paths
-
-### Manifest failure / `RUNTIME-003`
-
-Check:
-
-- `diagnosis.facts.url`
-- `summary.phases.manifest`
-- `build.host.remotes`
-
-Fix wrong manifest URL, HTML shell responses, CORS, gateway routing, or stale
-query/hash assumptions.
-
-### Invalid manifest / `RUNTIME-013`
-
-Definition:
-
-`RUNTIME-013` means the manifest URL returned JSON, but the JSON is not a valid
-Module Federation manifest. It is different from `RUNTIME-003`, which means the
-manifest could not be fetched or parsed.
-
-Check:
-
-- `diagnosis.facts.url`
-- `diagnosis.facts.errorCode`
-- `summary.phases.manifest`
-- `diagnosis.facts.hostName`
-- manifest fields such as `metaData`, `exposes`, and `shared`
-
-When explaining this failure, say that the manifest response is reachable but
-structurally invalid or incomplete. Do not describe it as a remoteEntry network
-failure unless the report also contains network evidence.
-
-Fix wrong JSON responses, gateway/deployment rewrites, missing producer manifest
-output, or stale/incomplete manifest files.
-
-### Remote not matched / `RUNTIME-004`
-
-Check:
-
-- `diagnosis.facts.requestId`
-- host remotes in `.mf/observability/build-info.json` when available
-
-Fix remote name, alias, or host remote declaration.
-
-### Snapshot / moduleInfo failure / `RUNTIME-007`
-
-Definition:
-
-`RUNTIME-007` means the runtime failed while resolving a snapshot/moduleInfo
-remote. It is not a remoteEntry network failure, not an expose lookup failure,
-and not a React/component render failure unless another report field explicitly
-shows those later phases.
-
-Check:
-
-- `requestId`
-- `remote.name`
-- `remote.alias`
-- `remote.version`
-- `diagnosis.errorCode`
-- `diagnosis.facts.moduleInfoMatchedCount`
-- `diagnosis.facts.moduleInfoNames`
-- `moduleInfo.entries`
-- `moduleInfo.availableNames`
-- `build.host.remotes`
-
-When explaining this failure, say that the runtime could not match the requested
-remote name/alias/version against deployment-provided `__FEDERATION__.moduleInfo`.
-Do not say "available component list" unless the report explicitly refers to
-remote exposes. This failure usually happens before the remote URL, remoteEntry,
-or exposed component can be loaded.
-
-The first cause sentence must include the literal term `moduleInfo`. Do not
-replace it with "loadable source list", "available source list", "component
-list", or any other paraphrase.
-
-Use this wording:
-
-- "The requested remote did not match any deployment-provided moduleInfo entry."
-- "Check whether the deployment/platform moduleInfo injection contains the
-  requested remote name, alias, or version key."
-- "The component has not been reached yet; the failure is in remote snapshot
-  resolution."
-
-Avoid this wording:
-
-- "The component is missing from the available component list."
-- "The prefetch list does not contain the component."
-- "The expose is missing."
-- "The React component failed to render."
-- "The remoteEntry request failed."
-
-Only mention source files or demo setup code after report evidence. In real
-projects, first inspect the deployment/platform plugin or runtime registration
-that injects `__FEDERATION__.moduleInfo`; do not jump directly to editing the
-business component.
-
-Exclude likely causes when the report only shows a snapshot/moduleInfo failure:
-
-- remoteEntry URL/network/CORS failure
-- remoteEntry execution failure
-- exposed module key missing
-- shared dependency version/provider/eager failure
-- business component render failure
-
-Fix missing deployment-provided `__FEDERATION__.moduleInfo`, mismatched remote
-name/alias keys, or missing `publicPath` / `getPublicPath` in the injected
-moduleInfo.
-
-### Expose not found / `RUNTIME-014`
-
-Definition:
-
-`RUNTIME-014` means the remote entry loaded and initialized, but the requested
-expose was not exported by that remote.
-
-Check:
-
-- `diagnosis.facts.requestId`
-- `diagnosis.facts.remoteName`
-- `diagnosis.facts.expose`
-- producer `exposes` config or manifest `exposes`
-
-When explaining this failure, say that remote loading reached the expose lookup
-phase. Do not call it a manifest fetch failure, moduleInfo match failure,
-remoteEntry network failure, or shared dependency failure unless another report
-field explicitly shows that evidence.
-
-Fix the consumer request id, producer expose name, `./` prefix, case mismatch,
-alias mismatch, or stale producer deployment.
-
-### Remote init failure / `RUNTIME-015`
-
-Definition:
-
-`RUNTIME-015` means the remote entry loaded, but the remote container failed
-during `init`.
-
-Check:
-
-- `diagnosis.facts.remoteName`
-- `diagnosis.facts.remoteEntry`
-- `diagnosis.facts.entryGlobalName`
-- `summary.phases.remoteEntry`
-- original error text in `diagnosis.errorMessage` or `summary.error.errorMessage`
-- shared facts and build-side shared config when available
-
-When explaining this failure, say that the remote entry was reached and failed
-while initializing. If the original error points to shared config, classify the
-likely owner as shared/host+remote config; otherwise inspect producer init
-logic.
-
-Fix shared provider/version/scope/eager config, remoteEntry type/global mismatch,
-or producer code that throws during container initialization.
-
-### Shared or eager failure / `RUNTIME-005` / `RUNTIME-006`
-
-Check:
-
-- `summary.shared`
-- shared config in `.mf/observability/build-info.json` when available
-- `summary.error.lifecycle`
-
-Fix provider availability, version range, shareScope, singleton/strictVersion,
-eager, or async boundary.
+## Step 6: Use runtime error codes as references
 
-### RemoteEntry failure / `RUNTIME-008`
+Runtime error codes are stable entry points, but this observability skill should
+not act as a full `RUNTIME-xxx` troubleshooting manual.
 
-Check:
+When a report contains `diagnosis.errorCode`, `summary.error.errorCode`, or a
+console `RUNTIME-xxx` code:
 
-- `diagnosis.facts.resourceErrorType`
-- `diagnosis.facts.url`
-- `summary.phases.remoteEntry`
-- `.mf/observability/build-info.json` remoteEntry facts when available
+1. use the code to choose the relevant runtime troubleshooting document
+2. use this report to confirm the actual phase, owner, request, remote, shared,
+   `moduleInfo`, and timing evidence
+3. avoid giving a fix based only on the code if report fields contradict it
+4. if there is no observability report, ask for the report, trace id, browser
+   reader output, Node report file, or enough console/network evidence
 
-If the type is network/timeout, fix URL, CORS, routing, server, or timeout. If
-the type is script execution, inspect the producer exception and fix the remote
-build. Retry does not fix script execution failures.
+Keep the explanation centered on the report evidence. For code-specific
+definitions and fixes, refer to the runtime troubleshooting docs instead of
+duplicating that content here.
 
 ## Step 7: Final response shape