@epxing/core 5.3.0-beta.1 → 5.3.0-beta.3

package/src/router/config.js

@@ -1,864 +1,861 @@
-import { runtimeRouteComponent } from '../runtime-services'
-const Page = runtimeRouteComponent('Page')
-const Login = runtimeRouteComponent('Login')
-const QyWechat = runtimeRouteComponent('QyWechat')
-const App = runtimeRouteComponent('App')
-const WikiSitePage = runtimeRouteComponent('WikiSitePage')
-const Module = runtimeRouteComponent('Module')
-const AppRoleSelect = runtimeRouteComponent('AppRoleSelect')
-const Task = runtimeRouteComponent('Task')
-const Config = runtimeRouteComponent('Config')
-const Error = runtimeRouteComponent('Error')
-const HelpDocSet = runtimeRouteComponent('HelpDocSet')
-import { isEmpty } from 'lodash-es'
-import { runtimeStore as store, getRuntimeService } from '../runtime-services'
-import util from '@epxing/core/src/runtime-utils/util'
-import http from '@epxing/core/src/api'
-import loadLibrary from '@epxing/core/src/loadLibrary'
-import { GET_USER, GET_APP_CONFIG, GET_COMPONENT_GLOBAL_CONFIG, DELETE_USER } from '@epxing/core/src/store/actions'
-import { ElMessage } from 'element-plus/es/components/message/index.mjs'
-import { setElementPlusLocale } from '@epxing/core/src/plugins/element-plus'
-// 菜单直达路由的纯函数层（别改引 navigation.js——那边引 router 单例会成环）
-import { MENU_ROUTE_ALIAS, effectiveRouteName, roleStorage } from '@epxing/core/src/menu-route'
-window.isLoadLibrary = false
-let isVisitedService = false
-// Task 19 / C2：**同一次用户导航内**的登录校验结果交接（不是「本会话只校验一次」）。
-//
-// 现象：守卫自己发起的二次导航（补默认角色 `next({...role})`、跳角色选择页、剥 URL 上的
-// token）会让 beforeEach 完整重跑一遍。重跑时 appConfig 有 `isEmpty` 门挡着、loadLibrary 有
-// `window.isLoadLibrary` 门挡着，唯独 loginPromise 没有任何跨遍复用 ⇒ 一次 app1 冷启动发两次
-// `FM_USER/validLogin`（Task 20 实测，两次相差 1.27s）。
-//
-// ⚠️ 刻意**不**做成 judgeIsLogin 那种「置一次、永不复检」的布尔标记（那个半成品的字面语义正是
-// 如此，见下面 willCheckLogin 处的说明）：登录态**会过期**，永久标记会让中途失效的 token 再也
-// 检不出来，用户带着废会话继续操作，直到某个业务请求 401 才被踢——「validLogin 2→1」这个判据
-// 会满足，但改动是错的。
-//
-// 复用作用域 = **同一条重定向链**，三个条件同时成立才继承（修复轮 1，评审 C-1）：
-//   ① 本遍守卫以 `next(location)` 自我重定向收尾 —— 由 runBeforeEach 里那层 next 包装**显式
-//      挂载**。注意这是「默认不泄漏」：不再像第一版那样无条件挂上、指望函数尾部清掉（那种形状
-//      在**守卫抛错**这条出口上会把交接原样留在模块变量里，评审已造出现场：manage 分支
-//      `hasMangeService` 请求失败 ⇒ 守卫抛错 ⇒ 残留被下一次用户导航捡走）。外层 beforeEach
-//      还包了一层 try/catch 兜底，抛错必清。
-//   ② 本遍是 vue-router 标记的「重定向续跑」（`to.redirectedFrom` 有值）。
-//   ③ **链根一致**：交接绑定在重定向链根的 fullPath 上。只有 ② 是不够的 —— 路由表 `redirect:`
-//      （本文件 /m/:menuKey 两条兼容链接）会让一次**纯用户导航**的 redirectedFrom 天然为真，
-//      锁 ② 对它形同虚设。依据：vue-router 4.6 pushWithRedirect 对路由表 redirect 与守卫
-//      重定向两条递归都传 `redirectedFrom || (targetLocation|toLocation)`（vue-router.mjs
-//      :1293/:1314）⇒ 整条链上 redirectedFrom 恒等于链根，用它当身份在多跳链上也精确。
-// 任何一次真正由用户发起的导航（redirectedFrom 为空，或链根对不上）都会照常重新发 validLogin。
-//
-// 注意：单纯「复用 in-flight promise」在这里是**空操作**——二次导航发生在 `await loginPromise`
-// **之后**（见下面各分支：先 await 拿到 isLogin，再 await GET_USER，最后才 next({...role})），
-// 第二遍开始时第一遍那个 promise 早就 settled 了。省掉请求靠的是复用同一个**已 settled 的
-// promise 对象**，不是靠请求还在飞。
-let handoff = null // { promise, key: 重定向链根 fullPath, at: 挂载时刻 }
-// 陈旧上界（保险丝，不是去重机制本身）。挂载点是 `next(location)` 那一刻，消费点是紧接着重跑的
-// 那一遍守卫的第一行，中间只隔 vue-router 的微任务、**没有网络**，实测同一 tick 内完成；这个
-// 常数只是给「redirect 目标与当前路由相同被判 NAVIGATION_DUPLICATED、守卫压根没重跑」这类
-// 病态路径封一个顶，免得残留在模块变量里躺成用户步调。取值比正常间隔大三个数量级，判据不会
-// 挂在它身上。
-const HANDOFF_MAX_AGE_MS = 10000
-// Task 13 review v2（round 3：注释前提已改，见下）：改方案后（发起点挪到 GET_APP_CONFIG
-// resolve 之后，见 beforeEach），本函数与 loadLibrary 不再需要显式穿 client/domainContext。
-// 撑住这一点的**不是**"appConfig/clientConfig 必然一起就绪"——这个前提是假的：
-// GET_APP_CONFIG action（store/modules/config.js）有三条分支 clientConfig 从未提交或提交空
-// 对象（`data` 为假 / 请求 reject / 提交的 `client` 本身是 `data.client.data || {}`）。
-// ⚠️ 2026-09 更新：GET_APP_CONFIG 失败的 catch 现在有 return 了（跳错误页后不再往下走，
-// 见 dedupe 相关改动），下面这条不变量此后只需要对"resolve 但 clientConfig 为空/不完整"
-// 这几条分支成立，不用再覆盖"请求 reject"这一种——reject 已经在此之前 return 掉，走不到这里。
-// 真正承重的是更弱、因而更可靠的不变量：从这里到"改动前的原发起位置"之间，只隔着
-// `await GET_COMPONENT_GLOBAL_CONFIG` 这一步，它只 commit `componentGlobalConfig`/
-// `systemComponentGlobalConfig`——axios.js 的头部解析链完全不读这两个 key。所以**不管
-// clientConfig 这次到底有没有就绪**，本函数在这里发起时解析出的请求头，与"改动前挪到原位置
-// 发起"逐字节相同（唯一例外是 localStorage 里的 token，若窗口内先返回的响应带了
-// authorization 刷新头会改写它——但这不是新增的不确定性，基线里 `getI18nMessages` 发出的
-// `FM_MESSAGE` 请求本来就不 await、早已横跨同一段窗口）。已回退到 Task 13 之前的原始实现，
-// 本函数与 loadLibrary.js 均不再有 Task 13 相关改动。
-/**
- * 引导期接口去重（develop 6ce3678ca 系列移植）
- *
- * 同一次页面加载里路由守卫会被重复触发：产品库加载完成后，远程库自己的 install() 里会
- * `router.addRoute(...)` + `router.replace(当前路径)`（见 loadLibrary.js 头部注释、
- * lazy-library.js 的 "util.loadJs 的 onload 重跑一遍 useVuePlugin → app.use → install()"）。
- * 这是**全新的一次导航**，不是守卫内部 `next(location)` 产生的重定向 ——
- * ⚠️ 之前这里的注释说 validLogin 的去重"已经由 handoff 单独承担"，是错的：handoff 的
- * `inheritedLoginPromise` 第一个条件就是 `to.redirectedFrom` 有值（见文件头部 ②、
- * runBeforeEach 里 `chainRootKey`/`inheritedLoginPromise` 那几行），只覆盖守卫**自己发起**
- * 的重定向（补默认角色、剥 token、跳角色选择页）；`router.replace(当前路径)` 是外部代码发起
- * 的全新导航，`redirectedFrom` 恒为空，`inheritedLoginPromise` 摸不到这条路径，第二遍守卫
- * 照样会再发一次 `FM_USER/validLogin`。所以 isLoginFn 仍要包一层这里的 dedupe——
- * 两者不冲突：`inheritedLoginPromise` 命中时走 `||` 短路，压根不会调到 isLoginFn（见下方
- * `loginPromise = willCheckLogin ? (inheritedLoginPromise || isLoginFn()) : null`）。
- * GET_USER / GET_COMPONENT_GLOBAL_CONFIG 同样没有 handoff 这类机制，`isEmpty(user)` /
- * `!componentGlobalConfig` 这类先查后写的判据在守卫重跑时仍可能撞见"上一遍还没提交"的窗口
- * 而重复发起，也包一层。
- * GET_APP_CONFIG 目前的发起顺序严格排在 loadLibrary 之前（Task 13 review），触发重跑的
- * addRoute+replace 发生时它必然已经 resolve，理论上摸不到这个窗口——仍然包一层纯粹是让四个
- * 引导请求统一走同一套去重外壳，不改变现有时序。
- *
- * ttl 为 0 时只复用进行中的请求，大于 0 时结果也复用 ttl 毫秒（引导期够用，之后仍会重新校验）。
- */
-function dedupe (fn, { key = () => '', ttl = 0 } = {}) {
-  const cache = new Map()
-  const wrapped = function (...args) {
-    const cacheKey = key(...args)
-    const hit = cache.get(cacheKey)
-    if (hit && (hit.pending || (ttl > 0 && Date.now() - hit.doneAt < ttl))) return hit.promise
-    const record = { pending: true, doneAt: 0 }
-    record.promise = Promise.resolve()
-      .then(() => fn(...args))
-      .then(data => {
-        record.pending = false
-        record.doneAt = Date.now()
-        return data
-      })
-      .catch(err => {
-        cache.delete(cacheKey)
-        return Promise.reject(err)
-      })
-    cache.set(cacheKey, record)
-    return record.promise
-  }
-  wrapped.clear = () => cache.clear()
-  return wrapped
-}
-// 引导期内复用登录态校验结果，避免守卫重跑时重复请求（BOOT_TTL 之后仍会重新校验，
-// 不是"本会话只查一次"的永久标记——登录态会过期，见文件头部对 judgeIsLogin 反模式的警告）
-const BOOT_TTL = 3000
-const isLoginFn = dedupe(() => {
-  return http.get({
-    action: 'validLogin',
-    entityId: 'FM_USER'
-  })
-    .then(data => {
-      return data
-    })
-    .catch(() => false)
-}, { ttl: BOOT_TTL })
-const getUserOnce = dedupe(() => store.dispatch({ type: GET_USER }))
-const getAppConfigOnce = dedupe(payload => store.dispatch(payload), {
-  key: payload => [payload.client, payload.system, payload.app, payload.id].join('|')
-})
-const getComponentGlobalConfigOnce = dedupe(payload => store.dispatch(payload), {
-  key: payload => [payload.client, payload.system].join('|')
-})
-// 公共 API 可以在应用创建前导入；首次运行守卫时才订阅实际注入的 store。
-const subscribedStores = new WeakSet()
-function subscribeToLogout () {
-  const currentStore = getRuntimeService('store')
-  if (subscribedStores.has(currentStore)) return
-  currentStore.subscribe(mutation => {
-    if (mutation.type === DELETE_USER) {
-      isLoginFn.clear()
-      getUserOnce.clear()
-    }
-  })
-  subscribedStores.add(currentStore)
-}
-
-function getDefaultRole (user, appId) {
-  const { serviceRoles = {} } = user
-  const roleList = serviceRoles[appId] || []
-  let defaultRole = null
-  if (roleList.length === 1) {
-    defaultRole = roleList[0].code + (roleList[0].type === 'client' ? '-client' : '')
-  } else {
-    const defaultRoleMap = roleList.find(item => item.isDefault === true)
-    if (defaultRoleMap) defaultRole = defaultRoleMap.code + (defaultRoleMap.type === 'client' ? '-client' : '')
-  }
-  return defaultRole
-}
-
-function isHasRole (user, appId, role) {
-  const { serviceRoles = {} } = user
-  const roleList = serviceRoles[appId] || []
-  let roleCode = role
-  if (role.endsWith('-client')) {
-    roleCode = role.replace(/-client$/, '')
-    // 从通用角色获取
-    return roleList.find(item => item.code === roleCode && item.type === 'client')
-  } else {
-    return roleList.find(item => item.code === roleCode && item.type !== 'client')
-  }
-}
-
-function getI18nMessages (system) {
-  // 国际化设置
-  const { clientConfig } = store.state.config || {}
-  const { CODE: clientCode, LANGUAGE_DEFAULT: defaultLanguage } = clientConfig
-  const currentLanguage = localStorage.getItem(`${clientCode}-language`) || defaultLanguage
-  // T33：element-ui 的 `locale.use()` → EP 的 reactive config（见 plugins/element-plus.js）
-  setElementPlusLocale(currentLanguage)
-  http.list({
-    entityId: 'FM_MESSAGE',
-    scopeParams: JSON.stringify([
-      {
-        field: 'TYPE',
-        values: 'page'
-      },
-      {
-        lb: '(',
-        field: 'SCOPE',
-        values: 'frame',
-        link: 'or'
-      },
-      {
-        field: 'SYSTEM',
-        values: system,
-        rb: ')'
-      }
-    ])
-  })
-    .then(data => {
-      const messages = {}
-      data.entitys.forEach(item => {
-        let name = item.NAME
-        let content = item.CONTENT
-        if (data.encrypt === '1') {
-          name = util.utf8to16(window.atob(name))
-          content = util.utf8to16(window.atob(content))
-        }
-        messages[name.trim()] = content
-      })
-      globalThis.i18n.setMessage(messages)
-    })
-}
-function visitService (serviceId) {
-  if (isVisitedService) return
-  isVisitedService = true
-  http.get({
-    action: 'visitService',
-    entityId: 'FM_USER_SERVICE_VISIT_RECORD',
-    serviceId
-  })
-}
-
-function closeLoading () {
-  const loadingElem = document.querySelector('#loading')
-  if (loadingElem) loadingElem.style.display = 'none'
-}
-
-// appConfig.NAME 可能只有多语言字段的翻译值 appConfig['NAME#']（`#` 后缀是本平台代码表/字段
-// 显示值的通用约定），只认 NAME 会在这种情况下把标题落空
-function setAppDocumentTitle (appConfig = {}) {
-  const title = appConfig.NAME || appConfig['NAME#']
-  if (title) document.title = title
-  return title
-}
-
-export default [
-  {
-    path: '/login/:client/:system/:app?',
-    name: 'login',
-    component: Login,
-    meta: { nav: false },
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/hall/login/:client',
-    name: 'hallLogin',
-    component: Login,
-    meta: { nav: false },
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/app/role/select/:client/:system?/:app?',
-    name: 'appRoleSelect',
-    component: AppRoleSelect
-  },
-  {
-    path: '/hall/role/select/:client/:app?',
-    name: 'hallRoleSelect',
-    component: AppRoleSelect
-  },
-  {
-    path: '/',
-    name: 'defaultApp',
-    component: App,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/app/:client/:system/:app?/:role?',
-    name: 'app1',
-    component: App,
-    meta: { refresh: false }, // 菜单直达在本路由族内切换 URL,根 router-view 不因 path 变化重挂(防导航闪烁/卡顿)
-    props: route => ({ query: route.query })
-  },
-  {
-    // 菜单直达（menuKey=菜单编号 MODULE_CODE，没配编号用 ID）。不带 role 段——role 走
-    // localStorage（menu-route.js roleStorage）。与 app1 无歧义：本路由比 app1 多吃两段。
-    path: '/app/:client/:system/:app/:menuKey([0-9A-Fa-f]{32})',
-    name: 'appMenu',
-    component: App,
-    meta: { refresh: false },
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/app/:id?/:roleId?',
-    name: 'app',
-    component: App,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    // Wiki 站点：#/wiki/{客户}/{系统}/{空间编码}/{页路径}
-    //
-    // 页路径用通配段而不是单段参数——Wiki 的路径本来就带层级
-    // （implementation/05-sop），单段参数会把斜杠当分隔符，深层页永远打不开。
-    // 客户与系统段与其它业务路由保持同一形状：它们是权限边界的一部分，
-    // 少一段就没法在进页面前判断这个人能不能看这个空间。
-    path: '/wiki/:client/:system/:wiki/:path*',
-    name: 'wikiSite',
-    component: WikiSitePage,
-    props: route => ({ query: route.query })
-  },
-  {
-    // 引用直达：#/wiki/view?w=空间&p=页&rev=版本&h=锚点
-    // 后端铸造的引用地址用这一条。它不带客户/系统段，因为引用是从答案里点进来的，
-    // 上下文已经在登录态里；权限仍由接口按空间的 VIEW_ROLES 判定。
-    path: '/wiki/view',
-    name: 'wikiView',
-    component: WikiSitePage,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/service/setting/:client/:system/:app/:role?',
-    name: 'appSetting',
-    component: App,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/manage/:client/:system/:app/:role?',
-    name: 'manage',
-    component: App,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/system/:client/:system/:role?',
-    name: 'system',
-    component: App,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/client/:client/:role?',
-    name: 'client',
-    component: App,
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/hall/:client/:role?',
-    name: 'hall',
-    component: App,
-    meta: { refresh: false },
-    props: route => ({ query: route.query })
-  },
-  {
-    // 服务大厅的菜单直达（同 appMenu 语义）
-    path: '/hall/:client/:menuKey([0-9A-Fa-f]{32})',
-    name: 'hallMenu',
-    component: App,
-    meta: { refresh: false },
-    props: route => ({ query: route.query })
-  },
-  {
-    path: '/task/:client/:system/:taskId',
-    name: 'Task',
-    component: Task,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/config/:mode/:client/:system/:configId',
-    name: 'Config',
-    component: Config,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/feishuTask/:client/:system/:taskId',
-    name: 'feishuTask',
-    component: Task,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/help/:client/:system/:docset/:docId?',
-    name: 'help',
-    component: HelpDocSet,
-    meta: {
-      title: '帮助中心',
-      loadAppConfig: false,
-      refresh: false
-    }
-  },
-  {
-    path: '/module',
-    name: 'module',
-    component: Module,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/page/:client/:system/:app/:role?',
-    name: 'Page',
-    component: Page,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/page',
-    name: 'Page1',
-    component: Page,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/s/:link',
-    name: 'shorturl',
-    component: App,
-    props: (route) => ({ query: route.query })
-  },
-  {
-    path: '/qywechat',
-    name: 'qywechat',
-    component: QyWechat
-  },
-  {
-    // 旧形态 /m/:menuKey 链接兼容:重定向到无 /m/ 的新形态
-    path: '/app/:client/:system/:app/m/:menuKey',
-    redirect: to => ({ name: 'appMenu', params: to.params, query: to.query })
-  },
-  {
-    path: '/hall/:client/m/:menuKey',
-    redirect: to => ({ name: 'hallMenu', params: to.params, query: to.query })
-  },
-  {
-    path: '/error',
-    name: 'error',
-    component: Error
-  },
-  {
-    path: '/:id?',
-    name: 'app2',
-    component: App,
-    props: (route) => ({ query: route.query })
-  }
-]
-
-/**
- * 路由守卫（对外入口）。守卫体是下面的 runBeforeEach，这层薄壳只做一件事：**任何抛错都保证
- * 登录校验交接被清掉**。守卫体里 await 的请求（GET_APP_CONFIG、hasMangeService…）都可能
- * reject，而守卫一抛错导航就中止、此后不会再有任何守卫运行，残留会一直躺到用户下次导航
- * （评审 C-1 现场）。这是第二道保险；第一道是 runBeforeEach 里「只在自我重定向出口显式挂载」。
- * ⚠️ 形参必须保持 3 个：vue-router 用 `guard.length < 3` 判断是不是回调式守卫。
- */
-export const beforeEach = async (to, from, next) => {
-  try {
-    subscribeToLogout()
-    return await runBeforeEach(to, from, next)
-  } catch (err) {
-    handoff = null
-    throw err
-  }
-}
-
-const runBeforeEach = async (to, from, rawNext) => {
-  // 重定向链根的 fullPath —— 交接的身份（三个条件见文件头部）。必须在下面 isMenuRoute 改写
-  // to 之前取（那里的 `to = {...to, …}` 是浅拷贝，其实也带得走，但别依赖它）。
-  const chainRootKey = to.redirectedFrom?.fullPath || to.fullPath
-  // 交接**一次性消费**：读完立刻无条件清空。这条无条件清空同时保证了「交接最多只能被紧接着的
-  // 那一遍守卫捡走」——中间只要再跑过任何一遍守卫（任何导航），残留就没了。
-  const inheritedLoginPromise = (to.redirectedFrom && handoff && handoff.key === chainRootKey &&
-    Date.now() - handoff.at <= HANDOFF_MAX_AGE_MS) ? handoff.promise : null
-  handoff = null
-  // 本遍自己的登录校验结果，只有本遍以 next(location) 自我重定向收尾时才交接出去。
-  // ⚠️ 必须是独立变量、且在函数最开头初始化，不能让下面那层 next 包装直接去读 `let loginPromise`：
-  // shorturl 长链接分支的 `return`（见下）排在 `let libPromise, loginPromise` **之前**，它在
-  // .then 里异步调 next 时那行 let 根本没执行过，读 loginPromise 会撞 TDZ ReferenceError。
-  let ownLoginPromise = null
-  let nextCalled = false
-  // 把「挂载交接」从**无条件挂上、指望函数尾部清掉**倒过来成**只在自我重定向这个出口显式挂上**。
-  // 包在 next 上是为了让守卫体里那十几处 next(...) 调用点一行都不用改。
-  const next = (location) => {
-    // 只认第一次调用（与 vue-router 一致）。本文件末尾就有一处既有的 next 双调用，记账必须跟着
-    // 第一次走，否则剥 token 那条重定向刚挂上的交接会被紧随其后的 next() 清掉。调用本身照常
-    // 原样转发，不改动 router 行为。
-    if (!nextCalled) {
-      nextCalled = true
-      // 自我重定向 = 传了一个 location 对象。next()/next(false)/next(Error) 都不是；
-      // next('/error?…') 那种字符串也不算——那条路径上 ownLoginPromise 还是 null，且「不挂交接」
-      // 最多多发一次 validLogin，是安全方向。
-      // ⚠️ 必须写 globalThis.Error：本文件顶上 `import Error from '@epxing/business/src/views/Error'`
-      // 把全局 Error 构造器**在整个模块作用域里遮蔽**成了一个 Vue 组件对象，直接写
-      // `x instanceof Error` 会抛 `TypeError: Right-hand side of 'instanceof' is not callable`
-      // ——这条已在本轮实测中真的炸过一次（守卫抛错 ⇒ 补默认角色的重定向整个不发生）。
-      handoff = (ownLoginPromise && location && typeof location === 'object' && !(location instanceof globalThis.Error))
-        ? { promise: ownLoginPromise, key: chainRootKey, at: Date.now() }
-        : null
-    }
-    return rawNext(location)
-  }
-  // 菜单直达路由（appMenu/hallMenu）归一成旧路由处理：name 换成别名（app1/hall），
-  // role 从 localStorage 补进 params（这些路由不带 role 段）。只改本函数内的局部视图，
-  // vue-router 实际导航目标不变（URL 保持 /m/:menuKey）。
-  const isMenuRoute = !!MENU_ROUTE_ALIAS[to.name]
-  if (isMenuRoute) {
-    const storedRole = roleStorage.get(to.params.client, to.params.system)
-    to = { ...to, name: effectiveRouteName(to.name), params: { ...to.params, role: to.params.role || storedRole || undefined } }
-  }
-  if (MENU_ROUTE_ALIAS[from.name]) {
-    from = { ...from, name: effectiveRouteName(from.name) }
-  }
-  // 访问其他应用刷新页面
-  if ((to.name === 'app' || to.name === 'appRoleSelect') && (from.name === 'app' || from.name === 'appRoleSelect')) {
-    if (to.params.id !== from.params.id || to.params.app !== from.params.app) {
-      setTimeout(() => {
-        window.location.reload()
-      }, 200)
-    }
-  }
-  if ((to.name === 'app1' || to.name === 'hall') && (from.name === 'app1' || from.name === 'hall')) {
-    if (to.params.app !== from.params.app) {
-      setTimeout(() => {
-        window.location.reload()
-      }, 200)
-    }
-  }
-  let { id, appId, client, system, app, roleId, role } = to.params
-  // 带 role 的旧式 URL 进来顺手持久化（供菜单直达路由/无 role URL 复用同一角色）
-  if (role && client) roleStorage.set(client, system, role)
-  if (to.path === '/') {
-    client = window.BASE_CLIENT_ID
-    system = window.BASE_SYSTEM_ID
-    app = window.BASE_APP_ID
-  }
-  if (to.name === 'Config') {
-    app = 'FM_SERVICE_SYSTEM'
-  }
-  // Wiki 引用直达（#/wiki/view?w=…）刻意不带客户/系统段：它是从答案或空间列表
-  // 点进来的，上下文已在登录态里。但刷新时 to.params 是空的，getAppConfig 会拿着
-  // undefined 去查，最后跳 /error——现象是「点开能看，刷一下就报错，像把租户和系统弄丢了」。
-  // 退回平台默认上下文，与 to.path === '/' 同一套；空间能不能看仍由接口按 VIEW_ROLES 判。
-  if (to.name === 'wikiView') {
-    client = client || window.BASE_CLIENT_ID
-    system = system || window.BASE_SYSTEM_ID
-    app = app || window.BASE_APP_ID
-  }
-  let belongToClient = client
-  let belongToSystem = system
-  if (/\/s\/([\w]+)/.test(to.path)) {
-    if (!to.params.pageId && !to.params.flag && !to.params.app) {
-      http.get({
-        action: 'getLongUrl',
-        entityId: 'FM_URL_MAP',
-        url: to.params.link
-      }, {
-        domainContext: window.BASE_PROJECT_NAME,
-        client: client,
-        system: window.BASE_SYSTEM_ID
-      })
-        .then(data => {
-          const fullPath = window.ROUTER_MODE === 'history' ? data : data.split('#')[1]
-          const path = fullPath.split('?')[0]
-          const search = fullPath.split('?')[1]
-          const params = {
-            ...to.params
-          }
-          if (search) {
-            const searchArr = search.split('&')
-            searchArr.forEach(item => {
-              const arr = item.split('=')
-              params[arr[0]] = arr[1]
-            })
-          }
-
-          /\/(app|recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(path)
-          params.client = RegExp.$2
-          params.system = RegExp.$3
-          params.app = RegExp.$4
-          next({ ...to, params })
-        })
-      return
-    }
-  } else if (to.name === 'client' || to.name === 'system' || to.name === 'hall' || to.name === 'hallRoleSelect' || to.name === 'hallLogin' || to.name === 'appSetting') {
-    belongToSystem = 'epxing-frame'
-    app = to.name === 'appSetting' ? 'FM_SERVICE_SETTING' : to.name === 'client' ? 'FM_SERVICE_CLIENT' : to.name === 'system' ? 'FM_SERVICE_SYSTEM' : 'FM_SERVICE_HALL'
-  } else if (to.name === 'wikiSite' || to.name === 'wikiView') {
-    // Wiki 站点是独立页面，不挂在任何业务应用下，沿用服务大厅的上下文加载配置。
-    //
-    // 不给这条分支的话 client / system / app 全是空，getAppConfig 拿不到配置，
-    // 直接输地址或刷新就打不开——而在 SPA 内 router.push 过去却是好的。
-    // 这个差别很要命：站点地址是设计成可分享的，别人拿到链接一打开就是白屏，
-    // 自己在页面里点却一切正常，最容易被当成「偶发」放过去。
-    //
-    // wikiView（引用直达）地址上没有客户段，回落到部署的默认客户端；
-    // wikiSite 的地址里带，优先用它自己的。
-    belongToClient = client || window.BASE_CLIENT_ID
-    belongToSystem = 'epxing-frame'
-    app = 'FM_SERVICE_HALL'
-  } else if (app === 'FM_SERVICE_SYSTEM') {
-    belongToSystem = 'epxing-frame'
-  } else if (/\/(recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(window.location.hash)) {
-    belongToClient = RegExp.$2
-    belongToSystem = RegExp.$3
-    app = RegExp.$4
-  }
-  // 在任何路由请求或参数清理前接收一次 URL Token；localStorage 受限时会回落到当前标签页内存。
-  if (belongToClient) util.consumeUrlToken(belongToClient)
-  if (to.meta?.title) document.title = to.meta.title
-  let { appConfig, componentGlobalConfig } = store.state.config || {}
-  // libPromise/loginPromise 声明在 if 外层（函数作用域）：isLoginFn 的 await 消费点散落在
-  // 本函数后面第二个独立的 if-else 链（shorturl/app1/app/Task 等分支，与本 if 是兄弟块），
-  // 块级作用域的 const 够不到那里。未进下面这个 if 时两者保持 undefined 且不会被 await 到
-  // ——现有分支结构保证了这点（'error' 路由/loadAppConfig:false 路由不落进第二条链的任何分支）。
-  let libPromise, loginPromise
-  if (to.name !== 'error' && to.meta?.loadAppConfig !== false) {
-    if (isEmpty(appConfig)) {
-      try {
-        appConfig = await getAppConfigOnce({ type: GET_APP_CONFIG, client: belongToClient, system: belongToSystem, app, id: id || appId, routeClient: client }) || {}
-      } catch (err) {
-        console.error(err)
-        // 已经跳错误页，后面的引导逻辑不用再跑（继续跑会拿着空 appConfig 发一堆没有意义的请求，
-        // 还会二次调用 next）
-        return next('/error?code=' + (err.code || '') + '&url=' + window.location.hash)
-      }
-      getI18nMessages(appConfig['SYSTEM|ID'] || appConfig.SYSTEM)
-    }
-    // Task 13 / C1 v2（评审换方案后，设计文档 §7.2；round 3：下面这段的前提改过，见理由）：
-    // 只把 loadLibrary 与 isLoginFn 的"发起"提前到这里——GET_APP_CONFIG 已经 resolve。
-    // 撑住"不需要显式穿 client/domainContext"这一点的**不是**"appConfig/clientConfig 必然
-    // 一起就绪"：GET_APP_CONFIG action 有三条分支 clientConfig 从未提交或提交空对象
-    // （`data` 为假 / 请求 reject / 提交的 `client` 本身是空对象，见 store/modules/config.js）。
-    // ⚠️ 2026-09 更新：上面的 catch 现在有 return 了，"请求 reject"这一种已经在此之前跳错误页
-    // 退出，走不到这里；下面这条不变量只需要对"resolve 但 clientConfig 为空/不完整"的其余两条
-    // 分支成立。真正承重的是更弱、因而更可靠的不变量：从这里到"改动前的原发起位置"之间，只隔着
-    // 这一步，它只 commit `componentGlobalConfig`/`systemComponentGlobalConfig`——axios.js
-    // 的头部解析链完全不读这两个 key。所以不管 clientConfig 这次到底有没有就绪，这里发起的
-    // 请求头都和"改动前挪到原位置发起"逐字节相同（唯一例外见下方 isLoginFn 定义处的 token
-    // 刷新头注释）。不需要碰 axios.js/createHttp.js/loadLibrary.js——evaluation round 2
-    // 发现在"appConfig 就绪前"提前发起会导致隐式链落空丢 Authorization 头（C-1，且波及比最初
-    // 判断更多的路由族），而给 createHttp.js 的 options.client 打通到 axios.js 又会撞上全仓
-    // 15 处既有调用点的既有语义（N-1，新 Critical）；挪到这个位置后两个问题都不存在，故两轮
-    // 相关改动已从 axios.js/createHttp.js/loadLibrary.js/isLoginFn 上完全回退。与紧接着的
-    // GET_COMPONENT_GLOBAL_CONFIG 请求重叠等待网络时间；下面 await 的位置一行不动（仍是原来
-    // loadLibrary 那一行、以及后面各分支里原来 isLoginFn 那几行）。
-    // ⚠️ 但"副作用发生顺序完全不变"不成立——validLogin 响应侧的副作用（未登录/过期路径触发的
-    // delayToLogin→util.toLogin→router.push）现在可能在本次导航自身的 next() 之前、从一个
-    // 仍处于 pending 的导航内部发出，不再像改动前那样严格排在原分支代码之后。终态大概率相同，
-    // 是任何并行化都躲不掉的固有代价，不是"顺序不变"——详见 task-13-report.md。
-    const libParam = { busiClientCode: client || belongToClient, busiSystemCode: system || belongToSystem }
-    libPromise = window.isLoadLibrary ? null : loadLibrary(libParam)
-    // review I-1（评审确认收窄不削减并行化收益，原样保留）：只在原本就会消费 loginPromise
-    // 的路由族上才发起，镜像下面第二条 if-else 链的分支条件（含内层 isEmpty(user)/
-    // !judgeIsLogin 判据），否则 login/hallLogin/appRoleSelect/Config/Page/qywechat 等公开
-    // 路由会凭空多发一次 validLogin：匿名访问必然拿到 nologin 类响应，被 axios.js 的 401
-    // 拦截器当场弹 toast 并踢去登录页——对着登录页本身踢登录页，是本条改动最容易被忽略的
-    // 副作用。
-    // Task 19 / C2：原来这里还有一个 `&& !judgeIsLogin` 的门（下面 Task/feishuTask 分支里也有
-    // 一个 `if (!judgeIsLogin)`），已一并删除。理由：`store.state.config.judgeIsLogin` 在全仓
-    // **只被读、从未被写**，config 模块的 state 里也没有声明它，且该模块所有 mutation 只往具名
-    // 子对象（systemConfig/appConfig/clientConfig/...）里铺数据，既没有 `Object.assign(state, …)`
-    // 也没有 `state[动态键] =`，后端也没法把它下发注入到 state.config 根上 ⇒ 它恒为 undefined，
-    // `!judgeIsLogin` 恒为 true，两处判据都是死重量，删掉**不改变任何现有行为**。
-    // 之所以是删掉而不是「补上写入语义」：它注释里的意图（「是否校验过用户已登录」）就是一个
-    // 会话级永久标记，而登录态会过期——真按那个字面语义补写入，等于亲手做出上面文件头部警告的
-    // 那个错误修法。去重该做在「同一条重定向链内」这个粒度上，已由 handoff 承担（见文件头部）。
-    const { user } = store.state.user
-    const willCheckLogin = to.name === 'shorturl' ||
-      to.path === '/' || to.name === 'app1' || to.name === 'client' || to.name === 'hall' ||
-      to.name === 'system' || to.name === 'appSetting' || to.name === 'manage' ||
-      (to.name === 'app' && isEmpty(user)) ||
-      to.name === 'Task' || to.name === 'feishuTask'
-    // 本遍是「自我重定向的续跑」就直接复用上一遍那个已 settled 的 promise，不再发请求；
-    // 否则照常发。inheritedLoginPromise 的产生/失效条件见文件头部注释。
-    loginPromise = willCheckLogin ? (inheritedLoginPromise || isLoginFn()) : null
-    // 只登记「本遍可交接的结果是什么」。真正的挂载在上面那层 next 包装里，且只发生在自我重定向
-    // 这个出口 —— 走别的出口（正常 next()、next(false)、守卫抛错）都不会留下任何东西。
-    ownLoginPromise = loginPromise
-    // 立即挂 catch 占位，否则在被 await 之前 reject 会产生 unhandled rejection。
-    // catch 返回的是新 promise，不影响原 promise 的 reject 传播，真正的错误处理仍在原 await 处。
-    if (libPromise) libPromise.catch(() => {})
-    if (loginPromise) loginPromise.catch(() => {})
-
-    if (!componentGlobalConfig) {
-      await getComponentGlobalConfigOnce({ type: GET_COMPONENT_GLOBAL_CONFIG, client: appConfig.CLIENT, system: appConfig['SYSTEM|ID'] || appConfig.SYSTEM })
-    }
-    setAppDocumentTitle(appConfig)
-    if (!window.componentLibrary) window.componentLibrary = {}
-    if (!window.isLoadLibrary) {
-      await libPromise
-      window.isLoadLibrary = true
-      console.log('----加载完成----')
-    }
-  }
-  const nextTo = { ...to }
-  if (to.name === 'shorturl') {
-    let { user } = store.state.user
-    if (setAppDocumentTitle(appConfig)) {
-      if (!app) app = appConfig.CODE
-    }
-    // 判断用户是否登录
-    const isLogin = await loginPromise
-    if (isLogin) {
-      if (isEmpty(user)) {
-        try {
-          user = await getUserOnce()
-        } catch (error) {
-          ElMessage.error(error.message)
-          util.toLogin()
-        }
-      }
-      visitService(appConfig.ID)
-      closeLoading()
-      // 判断是否需要角色
-      if (appConfig.EXTEND_OF_COMPETENCE !== 'allRole' && (!roleId && (!role || !isHasRole(user, appConfig.ID, role)))) {
-        const defaultRole = getDefaultRole(user, appConfig.ID)
-        if (defaultRole) {
-          return next({
-            name: to.name,
-            params: { ...to.params, role: defaultRole },
-            query: { ...to.query }
-          })
-        } else {
-          return next({
-            name: 'appRoleSelect',
-            params: { ...to.params, name: to.name },
-            query: { ...to.query },
-            replace: true
-          })
-        }
-      }
-    }
-  } else if (to.path === '/' || to.name === 'app1' || to.name === 'client' || to.name === 'hall' || to.name === 'system' || to.name === 'appSetting' || to.name === 'manage') {
-    let { user } = store.state.user
-    if (setAppDocumentTitle(appConfig)) {
-      if (!app) app = appConfig.CODE
-    }
-    // 判断用户是否登录
-    const isLogin = await loginPromise
-    if (isLogin) {
-      if (isEmpty(user)) {
-        try {
-          user = await getUserOnce()
-        } catch (error) {
-          ElMessage.error(error.message)
-          util.toLogin()
-        }
-      }
-      visitService(appConfig.ID)
-      closeLoading()
-      if (to.name === 'manage') {
-        // 获取权限
-        const manageRight = await http.get({
-          action: 'hasMangeService',
-          entityId: 'FM_USER',
-          querySystem: appConfig.SYSTEM
-        })
-        if (manageRight.systemAdmin !== 'true') {
-          return next({
-            name: 'app1',
-            params: { id: appId || '', client, system, app },
-            query: { ...to.query },
-            replace: true
-          })
-        }
-      } else if (appConfig.EXTEND_OF_COMPETENCE !== 'allRole' && (!roleId && (!role || !isHasRole(user, appConfig.ID, role)))) {
-        const defaultRole = getDefaultRole(user, appConfig.ID)
-        if (defaultRole) {
-          if (isMenuRoute) {
-            // 菜单直达路由不做补 role 的 URL 重定向（会丢 /m/:menuKey）：默认角色落
-            // localStorage，取数点经 resolveRouteRole 读取，导航照常放行
-            roleStorage.set(client, system, defaultRole)
-          } else {
-            return next({
-              name: to.name,
-              params: { id: appId || '', client, system, app, role: defaultRole },
-              query: { ...to.query },
-              replace: true
-            })
-          }
-        } else {
-          return next({
-            name: to.name === 'hall' ? 'hallRoleSelect' : 'appRoleSelect',
-            // backMenu：菜单直达进来的，选完角色回到原菜单（AppRoleSelect 消费）
-            params: { system: system || '', client, app, appId, name: to.name === 'defaultApp' ? to.name : '' },
-            query: { ...to.query, ...(isMenuRoute ? { backMenu: to.params.menuKey } : {}) },
-            replace: true
-          })
-        }
-      }
-    }
-  } else if (to.name === 'app') {
-    const { user } = store.state.user
-    if (setAppDocumentTitle(appConfig)) {
-      appId = appConfig.ID
-    }
-    if (isEmpty(user)) {
-      // 判断用户是否登录
-      const isLogin = await loginPromise
-      if (isLogin) {
-        // 没有角色
-        let user = null
-        try {
-          user = await getUserOnce()
-        } catch (error) {
-          ElMessage.error(error.message)
-          util.toLogin()
-        }
-        visitService(appConfig.ID)
-        closeLoading()
-        if (!to.params.roleId && to.name !== 'appRoleSelect') {
-          const { serviceRoles = {} } = user
-          const roleList = serviceRoles[appId] || []
-          let defaultRole = null
-          if (roleList.length === 1) {
-            defaultRole = roleList[0].id
-          } else {
-            const defaultRoleMap = roleList.find(item => item.isDefault === true) || {}
-            defaultRole = defaultRoleMap.id
-          }
-          if (defaultRole) {
-            return next({
-              name: 'app',
-              params: { id: appId || '', roleId: defaultRole },
-              query: { ...to.query }
-            })
-          } else {
-            return next({
-              name: 'appRoleSelect',
-              params: { id: appId || '' },
-              query: { ...to.query }
-            })
-          }
-        }
-      }
-    }
-  } else if (/\/(recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(window.location.hash) && !to.name) {
-    // 同样是重定向，必须 return，否则末尾还会再调一次 next
-    return next({ ...nextTo })
-  } else if (to.name === 'Task' || to.name === 'feishuTask') {
-    let { user } = store.state.user
-    // Task 19 / C2：原来这里包着一层 `if (!judgeIsLogin)`，judgeIsLogin 恒为 undefined ⇒ 恒进入，
-    // 已连同上面 willCheckLogin 里的同一个死判据一起删除（理由见那里）。行为不变。
-    // 判断用户是否登录
-    const isLogin = await loginPromise
-    if (isLogin) {
-      if (isEmpty(user)) {
-        try {
-          user = await getUserOnce()
-        } catch (error) {
-          ElMessage.error(error.message)
-          util.toLogin()
-        }
-      }
-    }
-  }
-  closeLoading()
-  if (nextTo.query.token || nextTo.query._token) {
-    const query = { ...nextTo.query }
-    delete query.token
-    delete query._token
-    delete query.code
-    // 剥 token 的重定向仍属同一次用户导航 ⇒ 交接由上面那层 next 包装自动保留（传的是 location
-    // 对象）。（下面那句 next() 是既有的重复调用——vue-router 与本文件的记账都只认第一次调用，
-    // 这里不顺手改它。）
-    next({ ...nextTo, query })
-  }
-  // 走到这里而没有自我重定向的，什么都没挂过：登录校验结果**绝不跨用户导航复用**，否则就退化成
-  // 「本会话只校验一次」，token 中途过期再也检不出来（见文件头部注释）。
-  next()
-}
+import { restoreChatWikiRoute } from '@epxing/utils/src/wiki-path'
+import { runtimeRouteComponent, runtimeStore as store, getRuntimeService } from '../runtime-services'
+import { isEmpty } from 'lodash-es'
+import util from '@epxing/core/src/runtime-utils/util'
+import http from '@epxing/core/src/api'
+import loadLibrary from '@epxing/core/src/loadLibrary'
+import { GET_USER, GET_APP_CONFIG, GET_COMPONENT_GLOBAL_CONFIG, DELETE_USER } from '@epxing/core/src/store/actions'
+import { ElMessage } from 'element-plus/es/components/message/index.mjs'
+import { setElementPlusLocale } from '@epxing/core/src/plugins/element-plus'
+// 菜单直达路由的纯函数层（别改引 navigation.js——那边引 router 单例会成环）
+import { MENU_ROUTE_ALIAS, effectiveRouteName, roleStorage } from '@epxing/core/src/menu-route'
+const Page = runtimeRouteComponent('Page')
+const Login = runtimeRouteComponent('Login')
+const App = runtimeRouteComponent('App')
+const WikiSitePage = runtimeRouteComponent('WikiSitePage')
+const Module = runtimeRouteComponent('Module')
+const AppRoleSelect = runtimeRouteComponent('AppRoleSelect')
+const Task = runtimeRouteComponent('Task')
+const Config = runtimeRouteComponent('Config')
+const Error = runtimeRouteComponent('Error')
+const HelpDocSet = runtimeRouteComponent('HelpDocSet')
+window.isLoadLibrary = false
+let isVisitedService = false
+// Task 19 / C2：**同一次用户导航内**的登录校验结果交接（不是「本会话只校验一次」）。
+//
+// 现象：守卫自己发起的二次导航（补默认角色 `next({...role})`、跳角色选择页、剥 URL 上的
+// token）会让 beforeEach 完整重跑一遍。重跑时 appConfig 有 `isEmpty` 门挡着、loadLibrary 有
+// `window.isLoadLibrary` 门挡着，唯独 loginPromise 没有任何跨遍复用 ⇒ 一次 app1 冷启动发两次
+// `FM_USER/validLogin`（Task 20 实测，两次相差 1.27s）。
+//
+// ⚠️ 刻意**不**做成 judgeIsLogin 那种「置一次、永不复检」的布尔标记（那个半成品的字面语义正是
+// 如此，见下面 willCheckLogin 处的说明）：登录态**会过期**，永久标记会让中途失效的 token 再也
+// 检不出来，用户带着废会话继续操作，直到某个业务请求 401 才被踢——「validLogin 2→1」这个判据
+// 会满足，但改动是错的。
+//
+// 复用作用域 = **同一条重定向链**，三个条件同时成立才继承（修复轮 1，评审 C-1）：
+//   ① 本遍守卫以 `next(location)` 自我重定向收尾 —— 由 runBeforeEach 里那层 next 包装**显式
+//      挂载**。注意这是「默认不泄漏」：不再像第一版那样无条件挂上、指望函数尾部清掉（那种形状
+//      在**守卫抛错**这条出口上会把交接原样留在模块变量里，评审已造出现场：manage 分支
+//      `hasMangeService` 请求失败 ⇒ 守卫抛错 ⇒ 残留被下一次用户导航捡走）。外层 beforeEach
+//      还包了一层 try/catch 兜底，抛错必清。
+//   ② 本遍是 vue-router 标记的「重定向续跑」（`to.redirectedFrom` 有值）。
+//   ③ **链根一致**：交接绑定在重定向链根的 fullPath 上。只有 ② 是不够的 —— 路由表 `redirect:`
+//      （本文件 /m/:menuKey 两条兼容链接）会让一次**纯用户导航**的 redirectedFrom 天然为真，
+//      锁 ② 对它形同虚设。依据：vue-router 4.6 pushWithRedirect 对路由表 redirect 与守卫
+//      重定向两条递归都传 `redirectedFrom || (targetLocation|toLocation)`（vue-router.mjs
+//      :1293/:1314）⇒ 整条链上 redirectedFrom 恒等于链根，用它当身份在多跳链上也精确。
+// 任何一次真正由用户发起的导航（redirectedFrom 为空，或链根对不上）都会照常重新发 validLogin。
+//
+// 注意：单纯「复用 in-flight promise」在这里是**空操作**——二次导航发生在 `await loginPromise`
+// **之后**（见下面各分支：先 await 拿到 isLogin，再 await GET_USER，最后才 next({...role})），
+// 第二遍开始时第一遍那个 promise 早就 settled 了。省掉请求靠的是复用同一个**已 settled 的
+// promise 对象**，不是靠请求还在飞。
+let handoff = null // { promise, key: 重定向链根 fullPath, at: 挂载时刻 }
+// 陈旧上界（保险丝，不是去重机制本身）。挂载点是 `next(location)` 那一刻，消费点是紧接着重跑的
+// 那一遍守卫的第一行，中间只隔 vue-router 的微任务、**没有网络**，实测同一 tick 内完成；这个
+// 常数只是给「redirect 目标与当前路由相同被判 NAVIGATION_DUPLICATED、守卫压根没重跑」这类
+// 病态路径封一个顶，免得残留在模块变量里躺成用户步调。取值比正常间隔大三个数量级，判据不会
+// 挂在它身上。
+const HANDOFF_MAX_AGE_MS = 10000
+// Task 13 review v2（round 3：注释前提已改，见下）：改方案后（发起点挪到 GET_APP_CONFIG
+// resolve 之后，见 beforeEach），本函数与 loadLibrary 不再需要显式穿 client/domainContext。
+// 撑住这一点的**不是**"appConfig/clientConfig 必然一起就绪"——这个前提是假的：
+// GET_APP_CONFIG action（store/modules/config.js）有三条分支 clientConfig 从未提交或提交空
+// 对象（`data` 为假 / 请求 reject / 提交的 `client` 本身是 `data.client.data || {}`）。
+// ⚠️ 2026-09 更新：GET_APP_CONFIG 失败的 catch 现在有 return 了（跳错误页后不再往下走，
+// 见 dedupe 相关改动），下面这条不变量此后只需要对"resolve 但 clientConfig 为空/不完整"
+// 这几条分支成立，不用再覆盖"请求 reject"这一种——reject 已经在此之前 return 掉，走不到这里。
+// 真正承重的是更弱、因而更可靠的不变量：从这里到"改动前的原发起位置"之间，只隔着
+// `await GET_COMPONENT_GLOBAL_CONFIG` 这一步，它只 commit `componentGlobalConfig`/
+// `systemComponentGlobalConfig`——axios.js 的头部解析链完全不读这两个 key。所以**不管
+// clientConfig 这次到底有没有就绪**，本函数在这里发起时解析出的请求头，与"改动前挪到原位置
+// 发起"逐字节相同（唯一例外是 localStorage 里的 token，若窗口内先返回的响应带了
+// authorization 刷新头会改写它——但这不是新增的不确定性，基线里 `getI18nMessages` 发出的
+// `FM_MESSAGE` 请求本来就不 await、早已横跨同一段窗口）。已回退到 Task 13 之前的原始实现，
+// 本函数与 loadLibrary.js 均不再有 Task 13 相关改动。
+/**
+ * 引导期接口去重（develop 6ce3678ca 系列移植）
+ *
+ * 同一次页面加载里路由守卫会被重复触发：产品库加载完成后，远程库自己的 install() 里会
+ * `router.addRoute(...)` + `router.replace(当前路径)`（见 loadLibrary.js 头部注释、
+ * lazy-library.js 的 "util.loadJs 的 onload 重跑一遍 useVuePlugin → app.use → install()"）。
+ * 这是**全新的一次导航**，不是守卫内部 `next(location)` 产生的重定向 ——
+ * ⚠️ 之前这里的注释说 validLogin 的去重"已经由 handoff 单独承担"，是错的：handoff 的
+ * `inheritedLoginPromise` 第一个条件就是 `to.redirectedFrom` 有值（见文件头部 ②、
+ * runBeforeEach 里 `chainRootKey`/`inheritedLoginPromise` 那几行），只覆盖守卫**自己发起**
+ * 的重定向（补默认角色、剥 token、跳角色选择页）；`router.replace(当前路径)` 是外部代码发起
+ * 的全新导航，`redirectedFrom` 恒为空，`inheritedLoginPromise` 摸不到这条路径，第二遍守卫
+ * 照样会再发一次 `FM_USER/validLogin`。所以 isLoginFn 仍要包一层这里的 dedupe——
+ * 两者不冲突：`inheritedLoginPromise` 命中时走 `||` 短路，压根不会调到 isLoginFn（见下方
+ * `loginPromise = willCheckLogin ? (inheritedLoginPromise || isLoginFn()) : null`）。
+ * GET_USER / GET_COMPONENT_GLOBAL_CONFIG 同样没有 handoff 这类机制，`isEmpty(user)` /
+ * `!componentGlobalConfig` 这类先查后写的判据在守卫重跑时仍可能撞见"上一遍还没提交"的窗口
+ * 而重复发起，也包一层。
+ * GET_APP_CONFIG 目前的发起顺序严格排在 loadLibrary 之前（Task 13 review），触发重跑的
+ * addRoute+replace 发生时它必然已经 resolve，理论上摸不到这个窗口——仍然包一层纯粹是让四个
+ * 引导请求统一走同一套去重外壳，不改变现有时序。
+ *
+ * ttl 为 0 时只复用进行中的请求，大于 0 时结果也复用 ttl 毫秒（引导期够用，之后仍会重新校验）。
+ */
+function dedupe (fn, { key = () => '', ttl = 0 } = {}) {
+  const cache = new Map()
+  const wrapped = function (...args) {
+    const cacheKey = key(...args)
+    const hit = cache.get(cacheKey)
+    if (hit && (hit.pending || (ttl > 0 && Date.now() - hit.doneAt < ttl))) return hit.promise
+    const record = { pending: true, doneAt: 0 }
+    record.promise = Promise.resolve()
+      .then(() => fn(...args))
+      .then(data => {
+        record.pending = false
+        record.doneAt = Date.now()
+        return data
+      })
+      .catch(err => {
+        cache.delete(cacheKey)
+        return Promise.reject(err)
+      })
+    cache.set(cacheKey, record)
+    return record.promise
+  }
+  wrapped.clear = () => cache.clear()
+  return wrapped
+}
+// 引导期内复用登录态校验结果，避免守卫重跑时重复请求（BOOT_TTL 之后仍会重新校验，
+// 不是"本会话只查一次"的永久标记——登录态会过期，见文件头部对 judgeIsLogin 反模式的警告）
+const BOOT_TTL = 3000
+const isLoginFn = dedupe(() => {
+  return http.get({
+    action: 'validLogin',
+    entityId: 'FM_USER'
+  })
+    .then(data => {
+      return data
+    })
+    .catch(() => false)
+}, { ttl: BOOT_TTL })
+const getUserOnce = dedupe(() => store.dispatch({ type: GET_USER }))
+const getAppConfigOnce = dedupe(payload => store.dispatch(payload), {
+  key: payload => [payload.client, payload.system, payload.app, payload.id].join('|')
+})
+const getComponentGlobalConfigOnce = dedupe(payload => store.dispatch(payload), {
+  key: payload => [payload.client, payload.system].join('|')
+})
+// 公共 API 可以在应用创建前导入；首次运行守卫时才订阅实际注入的 store。
+const subscribedStores = new WeakSet()
+function subscribeToLogout () {
+  const currentStore = getRuntimeService('store')
+  if (subscribedStores.has(currentStore)) return
+  currentStore.subscribe(mutation => {
+    if (mutation.type === DELETE_USER) {
+      isLoginFn.clear()
+      getUserOnce.clear()
+    }
+  })
+  subscribedStores.add(currentStore)
+}
+
+function getDefaultRole (user, appId) {
+  const { serviceRoles = {} } = user
+  const roleList = serviceRoles[appId] || []
+  let defaultRole = null
+  if (roleList.length === 1) {
+    defaultRole = roleList[0].code + (roleList[0].type === 'client' ? '-client' : '')
+  } else {
+    const defaultRoleMap = roleList.find(item => item.isDefault === true)
+    if (defaultRoleMap) defaultRole = defaultRoleMap.code + (defaultRoleMap.type === 'client' ? '-client' : '')
+  }
+  return defaultRole
+}
+
+function isHasRole (user, appId, role) {
+  const { serviceRoles = {} } = user
+  const roleList = serviceRoles[appId] || []
+  let roleCode = role
+  if (role.endsWith('-client')) {
+    roleCode = role.replace(/-client$/, '')
+    // 从通用角色获取
+    return roleList.find(item => item.code === roleCode && item.type === 'client')
+  } else {
+    return roleList.find(item => item.code === roleCode && item.type !== 'client')
+  }
+}
+
+function getI18nMessages (system) {
+  // 国际化设置
+  const { clientConfig } = store.state.config || {}
+  const { CODE: clientCode, LANGUAGE_DEFAULT: defaultLanguage } = clientConfig
+  const currentLanguage = localStorage.getItem(`${clientCode}-language`) || defaultLanguage
+  // T33：element-ui 的 `locale.use()` → EP 的 reactive config（见 plugins/element-plus.js）
+  setElementPlusLocale(currentLanguage)
+  http.list({
+    entityId: 'FM_MESSAGE',
+    scopeParams: JSON.stringify([
+      {
+        field: 'TYPE',
+        values: 'page'
+      },
+      {
+        lb: '(',
+        field: 'SCOPE',
+        values: 'frame',
+        link: 'or'
+      },
+      {
+        field: 'SYSTEM',
+        values: system,
+        rb: ')'
+      }
+    ])
+  })
+    .then(data => {
+      const messages = {}
+      data.entitys.forEach(item => {
+        let name = item.NAME
+        let content = item.CONTENT
+        if (data.encrypt === '1') {
+          name = util.utf8to16(window.atob(name))
+          content = util.utf8to16(window.atob(content))
+        }
+        messages[name.trim()] = content
+      })
+      globalThis.i18n.setMessage(messages)
+    })
+}
+function visitService (serviceId) {
+  if (isVisitedService) return
+  isVisitedService = true
+  http.get({
+    action: 'visitService',
+    entityId: 'FM_USER_SERVICE_VISIT_RECORD',
+    serviceId
+  })
+}
+
+function closeLoading () {
+  const loadingElem = document.querySelector('#loading')
+  if (loadingElem) loadingElem.style.display = 'none'
+}
+
+// appConfig.NAME 可能只有多语言字段的翻译值 appConfig['NAME#']（`#` 后缀是本平台代码表/字段
+// 显示值的通用约定），只认 NAME 会在这种情况下把标题落空
+function setAppDocumentTitle (appConfig = {}) {
+  const title = appConfig.NAME || appConfig['NAME#']
+  if (title) document.title = title
+  return title
+}
+
+export default [
+  {
+    path: '/login/:client/:system/:app?',
+    name: 'login',
+    component: Login,
+    meta: { nav: false },
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/hall/login/:client',
+    name: 'hallLogin',
+    component: Login,
+    meta: { nav: false },
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/app/role/select/:client/:system?/:app?',
+    name: 'appRoleSelect',
+    component: AppRoleSelect
+  },
+  {
+    path: '/hall/role/select/:client/:app?',
+    name: 'hallRoleSelect',
+    component: AppRoleSelect
+  },
+  {
+    path: '/',
+    name: 'defaultApp',
+    component: App,
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/app/:client/:system/:app?/:role?',
+    name: 'app1',
+    component: App,
+    meta: { refresh: false }, // 菜单直达在本路由族内切换 URL,根 router-view 不因 path 变化重挂(防导航闪烁/卡顿)
+    props: route => ({ query: route.query })
+  },
+  {
+    // 菜单直达（menuKey=菜单编号 MODULE_CODE，没配编号用 ID）。不带 role 段——role 走
+    // localStorage（menu-route.js roleStorage）。与 app1 无歧义：本路由比 app1 多吃两段。
+    path: '/app/:client/:system/:app/:menuKey([0-9A-Fa-f]{32})',
+    name: 'appMenu',
+    component: App,
+    meta: { refresh: false },
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/app/:id?/:roleId?',
+    name: 'app',
+    component: App,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    // Wiki 站点：#/wiki/{客户}/{系统}/{空间编码}/{页路径}
+    //
+    // 页路径用通配段而不是单段参数——Wiki 的路径本来就带层级
+    // （implementation/05-sop），单段参数会把斜杠当分隔符，深层页永远打不开。
+    // 客户与系统段与其它业务路由保持同一形状：它们是权限边界的一部分，
+    // 少一段就没法在进页面前判断这个人能不能看这个空间。
+    path: '/wiki/:client/:system/:wiki/:path*',
+    name: 'wikiSite',
+    component: WikiSitePage,
+    props: route => ({ query: route.query })
+  },
+  {
+    // 引用直达：#/wiki/view?w=空间&p=页&rev=版本&h=锚点
+    // 后端铸造的引用地址用这一条。它不带客户/系统段，因为引用是从答案里点进来的，
+    // 上下文已经在登录态里；权限仍由接口按空间的 VIEW_ROLES 判定。
+    path: '/wiki/view',
+    name: 'wikiView',
+    component: WikiSitePage,
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/service/setting/:client/:system/:app/:role?',
+    name: 'appSetting',
+    component: App,
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/manage/:client/:system/:app/:role?',
+    name: 'manage',
+    component: App,
+    props: route => ({ query: route.query })
+  },
+  {
+    // 32 位菜单 ID 与旧角色编号消歧；旧的 /system/.../SYSTEM 地址仍可使用。
+    path: '/system/:client/:system/:menuKey([0-9A-Fa-f]{32})?/:role?',
+    name: 'system',
+    component: App,
+    meta: { refresh: false },
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/client/:client/:role?',
+    name: 'client',
+    component: App,
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/hall/:client/:role?',
+    name: 'hall',
+    component: App,
+    meta: { refresh: false },
+    props: route => ({ query: route.query })
+  },
+  {
+    // 服务大厅的菜单直达（同 appMenu 语义）
+    path: '/hall/:client/:menuKey([0-9A-Fa-f]{32})',
+    name: 'hallMenu',
+    component: App,
+    meta: { refresh: false },
+    props: route => ({ query: route.query })
+  },
+  {
+    path: '/task/:client/:system/:taskId',
+    name: 'Task',
+    component: Task,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/config/:mode/:client/:system/:configId',
+    name: 'Config',
+    component: Config,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/feishuTask/:client/:system/:taskId',
+    name: 'feishuTask',
+    component: Task,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/help/:client/:system/:docset/:docId?',
+    name: 'help',
+    component: HelpDocSet,
+    meta: {
+      title: '帮助中心',
+      loadAppConfig: false,
+      refresh: false
+    }
+  },
+  {
+    path: '/module',
+    name: 'module',
+    component: Module,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/page/:client/:system/:app/:role?',
+    name: 'Page',
+    component: Page,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/page',
+    name: 'Page1',
+    component: Page,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    path: '/s/:link',
+    name: 'shorturl',
+    component: App,
+    props: (route) => ({ query: route.query })
+  },
+  {
+    // 旧形态 /m/:menuKey 链接兼容:重定向到无 /m/ 的新形态
+    path: '/app/:client/:system/:app/m/:menuKey',
+    redirect: to => ({ name: 'appMenu', params: to.params, query: to.query })
+  },
+  {
+    path: '/hall/:client/m/:menuKey',
+    redirect: to => ({ name: 'hallMenu', params: to.params, query: to.query })
+  },
+  {
+    path: '/error',
+    name: 'error',
+    component: Error
+  },
+  {
+    path: '/:id?',
+    name: 'app2',
+    component: App,
+    props: (route) => ({ query: route.query })
+  }
+]
+
+/**
+ * 路由守卫（对外入口）。守卫体是下面的 runBeforeEach，这层薄壳只做一件事：**任何抛错都保证
+ * 登录校验交接被清掉**。守卫体里 await 的请求（GET_APP_CONFIG、hasMangeService…）都可能
+ * reject，而守卫一抛错导航就中止、此后不会再有任何守卫运行，残留会一直躺到用户下次导航
+ * （评审 C-1 现场）。这是第二道保险；第一道是 runBeforeEach 里「只在自我重定向出口显式挂载」。
+ * ⚠️ 形参必须保持 3 个：vue-router 用 `guard.length < 3` 判断是不是回调式守卫。
+ */
+export const beforeEach = async (to, from, next) => {
+  const restoredWikiRoute = restoreChatWikiRoute(to)
+  if (restoredWikiRoute) return next(restoredWikiRoute)
+  try {
+    subscribeToLogout()
+    return await runBeforeEach(to, from, next)
+  } catch (err) {
+    handoff = null
+    throw err
+  }
+}
+
+const runBeforeEach = async (to, from, rawNext) => {
+  // 重定向链根的 fullPath —— 交接的身份（三个条件见文件头部）。必须在下面 isMenuRoute 改写
+  // to 之前取（那里的 `to = {...to, …}` 是浅拷贝，其实也带得走，但别依赖它）。
+  const chainRootKey = to.redirectedFrom?.fullPath || to.fullPath
+  // 交接**一次性消费**：读完立刻无条件清空。这条无条件清空同时保证了「交接最多只能被紧接着的
+  // 那一遍守卫捡走」——中间只要再跑过任何一遍守卫（任何导航），残留就没了。
+  const inheritedLoginPromise = (to.redirectedFrom && handoff && handoff.key === chainRootKey &&
+    Date.now() - handoff.at <= HANDOFF_MAX_AGE_MS) ? handoff.promise : null
+  handoff = null
+  // 本遍自己的登录校验结果，只有本遍以 next(location) 自我重定向收尾时才交接出去。
+  // ⚠️ 必须是独立变量、且在函数最开头初始化，不能让下面那层 next 包装直接去读 `let loginPromise`：
+  // shorturl 长链接分支的 `return`（见下）排在 `let libPromise, loginPromise` **之前**，它在
+  // .then 里异步调 next 时那行 let 根本没执行过，读 loginPromise 会撞 TDZ ReferenceError。
+  let ownLoginPromise = null
+  let nextCalled = false
+  // 把「挂载交接」从**无条件挂上、指望函数尾部清掉**倒过来成**只在自我重定向这个出口显式挂上**。
+  // 包在 next 上是为了让守卫体里那十几处 next(...) 调用点一行都不用改。
+  const next = (location) => {
+    // 只认第一次调用（与 vue-router 一致）。本文件末尾就有一处既有的 next 双调用，记账必须跟着
+    // 第一次走，否则剥 token 那条重定向刚挂上的交接会被紧随其后的 next() 清掉。调用本身照常
+    // 原样转发，不改动 router 行为。
+    if (!nextCalled) {
+      nextCalled = true
+      // 自我重定向 = 传了一个 location 对象。next()/next(false)/next(Error) 都不是；
+      // next('/error?…') 那种字符串也不算——那条路径上 ownLoginPromise 还是 null，且「不挂交接」
+      // 最多多发一次 validLogin，是安全方向。
+      // ⚠️ 必须写 globalThis.Error：本文件顶上 `import Error from '@epxing/business/src/views/Error'`
+      // 把全局 Error 构造器**在整个模块作用域里遮蔽**成了一个 Vue 组件对象，直接写
+      // `x instanceof Error` 会抛 `TypeError: Right-hand side of 'instanceof' is not callable`
+      // ——这条已在本轮实测中真的炸过一次（守卫抛错 ⇒ 补默认角色的重定向整个不发生）。
+      handoff = (ownLoginPromise && location && typeof location === 'object' && !(location instanceof globalThis.Error))
+        ? { promise: ownLoginPromise, key: chainRootKey, at: Date.now() }
+        : null
+    }
+    return rawNext(location)
+  }
+  // 应用与大厅的菜单直达归一到旧路由名，配置中心保留 system；角色从持久化状态恢复。
+  // 只修改守卫内的局部视图，浏览器地址仍保留菜单路径段。
+  const isMenuRoute = !!MENU_ROUTE_ALIAS[to.name] || (to.name === 'system' && !!to.params.menuKey)
+  if (isMenuRoute) {
+    const storedRole = roleStorage.get(to.params.client, to.params.system)
+    to = { ...to, name: effectiveRouteName(to.name), params: { ...to.params, role: to.params.role || storedRole || undefined } }
+  }
+  if (MENU_ROUTE_ALIAS[from.name]) {
+    from = { ...from, name: effectiveRouteName(from.name) }
+  }
+  // 访问其他应用刷新页面
+  if ((to.name === 'app' || to.name === 'appRoleSelect') && (from.name === 'app' || from.name === 'appRoleSelect')) {
+    if (to.params.id !== from.params.id || to.params.app !== from.params.app) {
+      setTimeout(() => {
+        window.location.reload()
+      }, 200)
+    }
+  }
+  if ((to.name === 'app1' || to.name === 'hall') && (from.name === 'app1' || from.name === 'hall')) {
+    if (to.params.app !== from.params.app) {
+      setTimeout(() => {
+        window.location.reload()
+      }, 200)
+    }
+  }
+  let { id, appId, client, system, app, roleId, role } = to.params
+  // 带 role 的旧式 URL 进来顺手持久化（供菜单直达路由/无 role URL 复用同一角色）
+  if (role && client) roleStorage.set(client, system, role)
+  if (to.path === '/') {
+    client = window.BASE_CLIENT_ID
+    system = window.BASE_SYSTEM_ID
+    app = window.BASE_APP_ID
+  }
+  if (to.name === 'Config') {
+    app = 'FM_SERVICE_SYSTEM'
+  }
+  // Wiki 引用直达（#/wiki/view?w=…）刻意不带客户/系统段：它是从答案或空间列表
+  // 点进来的，上下文已在登录态里。但刷新时 to.params 是空的，getAppConfig 会拿着
+  // undefined 去查，最后跳 /error——现象是「点开能看，刷一下就报错，像把租户和系统弄丢了」。
+  // 退回平台默认上下文，与 to.path === '/' 同一套；空间能不能看仍由接口按 VIEW_ROLES 判。
+  if (to.name === 'wikiView') {
+    client = client || window.BASE_CLIENT_ID
+    system = system || window.BASE_SYSTEM_ID
+    app = app || window.BASE_APP_ID
+  }
+  let belongToClient = client
+  let belongToSystem = system
+  if (/\/s\/([\w]+)/.test(to.path)) {
+    if (!to.params.pageId && !to.params.flag && !to.params.app) {
+      http.get({
+        action: 'getLongUrl',
+        entityId: 'FM_URL_MAP',
+        url: to.params.link
+      }, {
+        domainContext: window.BASE_PROJECT_NAME,
+        client: client,
+        system: window.BASE_SYSTEM_ID
+      })
+        .then(data => {
+          const fullPath = window.ROUTER_MODE === 'history' ? data : data.split('#')[1]
+          const path = fullPath.split('?')[0]
+          const search = fullPath.split('?')[1]
+          const params = {
+            ...to.params
+          }
+          if (search) {
+            const searchArr = search.split('&')
+            searchArr.forEach(item => {
+              const arr = item.split('=')
+              params[arr[0]] = arr[1]
+            })
+          }
+
+          /\/(app|recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(path)
+          params.client = RegExp.$2
+          params.system = RegExp.$3
+          params.app = RegExp.$4
+          next({ ...to, params })
+        })
+      return
+    }
+  } else if (to.name === 'client' || to.name === 'system' || to.name === 'hall' || to.name === 'hallRoleSelect' || to.name === 'hallLogin' || to.name === 'appSetting') {
+    belongToSystem = 'epxing-frame'
+    app = to.name === 'appSetting' ? 'FM_SERVICE_SETTING' : to.name === 'client' ? 'FM_SERVICE_CLIENT' : to.name === 'system' ? 'FM_SERVICE_SYSTEM' : 'FM_SERVICE_HALL'
+  } else if (to.name === 'wikiSite' || to.name === 'wikiView') {
+    // Wiki 站点是独立页面，不挂在任何业务应用下，沿用服务大厅的上下文加载配置。
+    //
+    // 不给这条分支的话 client / system / app 全是空，getAppConfig 拿不到配置，
+    // 直接输地址或刷新就打不开——而在 SPA 内 router.push 过去却是好的。
+    // 这个差别很要命：站点地址是设计成可分享的，别人拿到链接一打开就是白屏，
+    // 自己在页面里点却一切正常，最容易被当成「偶发」放过去。
+    //
+    // wikiView（引用直达）地址上没有客户段，回落到部署的默认客户端；
+    // wikiSite 的地址里带，优先用它自己的。
+    belongToClient = client || window.BASE_CLIENT_ID
+    belongToSystem = 'epxing-frame'
+    app = 'FM_SERVICE_HALL'
+  } else if (app === 'FM_SERVICE_SYSTEM') {
+    belongToSystem = 'epxing-frame'
+  } else if (/\/(recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(window.location.hash)) {
+    belongToClient = RegExp.$2
+    belongToSystem = RegExp.$3
+    app = RegExp.$4
+  }
+  // 在任何路由请求或参数清理前接收一次 URL Token；localStorage 受限时会回落到当前标签页内存。
+  if (belongToClient) util.consumeUrlToken(belongToClient)
+  if (to.meta?.title) document.title = to.meta.title
+  let { appConfig, componentGlobalConfig } = store.state.config || {}
+  // libPromise/loginPromise 声明在 if 外层（函数作用域）：isLoginFn 的 await 消费点散落在
+  // 本函数后面第二个独立的 if-else 链（shorturl/app1/app/Task 等分支，与本 if 是兄弟块），
+  // 块级作用域的 const 够不到那里。未进下面这个 if 时两者保持 undefined 且不会被 await 到
+  // ——现有分支结构保证了这点（'error' 路由/loadAppConfig:false 路由不落进第二条链的任何分支）。
+  let libPromise, loginPromise
+  if (to.name !== 'error' && to.meta?.loadAppConfig !== false) {
+    if (isEmpty(appConfig)) {
+      try {
+        appConfig = await getAppConfigOnce({ type: GET_APP_CONFIG, client: belongToClient, system: belongToSystem, app, id: id || appId, routeClient: client }) || {}
+      } catch (err) {
+        console.error(err)
+        // 已经跳错误页，后面的引导逻辑不用再跑（继续跑会拿着空 appConfig 发一堆没有意义的请求，
+        // 还会二次调用 next）
+        return next('/error?code=' + (err.code || '') + '&url=' + window.location.hash)
+      }
+      getI18nMessages(appConfig['SYSTEM|ID'] || appConfig.SYSTEM)
+    }
+    // Task 13 / C1 v2（评审换方案后，设计文档 §7.2；round 3：下面这段的前提改过，见理由）：
+    // 只把 loadLibrary 与 isLoginFn 的"发起"提前到这里——GET_APP_CONFIG 已经 resolve。
+    // 撑住"不需要显式穿 client/domainContext"这一点的**不是**"appConfig/clientConfig 必然
+    // 一起就绪"：GET_APP_CONFIG action 有三条分支 clientConfig 从未提交或提交空对象
+    // （`data` 为假 / 请求 reject / 提交的 `client` 本身是空对象，见 store/modules/config.js）。
+    // ⚠️ 2026-09 更新：上面的 catch 现在有 return 了，"请求 reject"这一种已经在此之前跳错误页
+    // 退出，走不到这里；下面这条不变量只需要对"resolve 但 clientConfig 为空/不完整"的其余两条
+    // 分支成立。真正承重的是更弱、因而更可靠的不变量：从这里到"改动前的原发起位置"之间，只隔着
+    // 这一步，它只 commit `componentGlobalConfig`/`systemComponentGlobalConfig`——axios.js
+    // 的头部解析链完全不读这两个 key。所以不管 clientConfig 这次到底有没有就绪，这里发起的
+    // 请求头都和"改动前挪到原位置发起"逐字节相同（唯一例外见下方 isLoginFn 定义处的 token
+    // 刷新头注释）。不需要碰 axios.js/createHttp.js/loadLibrary.js——evaluation round 2
+    // 发现在"appConfig 就绪前"提前发起会导致隐式链落空丢 Authorization 头（C-1，且波及比最初
+    // 判断更多的路由族），而给 createHttp.js 的 options.client 打通到 axios.js 又会撞上全仓
+    // 15 处既有调用点的既有语义（N-1，新 Critical）；挪到这个位置后两个问题都不存在，故两轮
+    // 相关改动已从 axios.js/createHttp.js/loadLibrary.js/isLoginFn 上完全回退。与紧接着的
+    // GET_COMPONENT_GLOBAL_CONFIG 请求重叠等待网络时间；下面 await 的位置一行不动（仍是原来
+    // loadLibrary 那一行、以及后面各分支里原来 isLoginFn 那几行）。
+    // ⚠️ 但"副作用发生顺序完全不变"不成立——validLogin 响应侧的副作用（未登录/过期路径触发的
+    // delayToLogin→util.toLogin→router.push）现在可能在本次导航自身的 next() 之前、从一个
+    // 仍处于 pending 的导航内部发出，不再像改动前那样严格排在原分支代码之后。终态大概率相同，
+    // 是任何并行化都躲不掉的固有代价，不是"顺序不变"——详见 task-13-report.md。
+    const libParam = { busiClientCode: client || belongToClient, busiSystemCode: system || belongToSystem }
+    libPromise = window.isLoadLibrary ? null : loadLibrary(libParam)
+    // review I-1（评审确认收窄不削减并行化收益，原样保留）：只在原本就会消费 loginPromise
+    // 的路由族上才发起，镜像下面第二条 if-else 链的分支条件（含内层 isEmpty(user)/
+    // !judgeIsLogin 判据），否则 login/hallLogin/appRoleSelect/Config/Page/qywechat 等公开
+    // 路由会凭空多发一次 validLogin：匿名访问必然拿到 nologin 类响应，被 axios.js 的 401
+    // 拦截器当场弹 toast 并踢去登录页——对着登录页本身踢登录页，是本条改动最容易被忽略的
+    // 副作用。
+    // Task 19 / C2：原来这里还有一个 `&& !judgeIsLogin` 的门（下面 Task/feishuTask 分支里也有
+    // 一个 `if (!judgeIsLogin)`），已一并删除。理由：`store.state.config.judgeIsLogin` 在全仓
+    // **只被读、从未被写**，config 模块的 state 里也没有声明它，且该模块所有 mutation 只往具名
+    // 子对象（systemConfig/appConfig/clientConfig/...）里铺数据，既没有 `Object.assign(state, …)`
+    // 也没有 `state[动态键] =`，后端也没法把它下发注入到 state.config 根上 ⇒ 它恒为 undefined，
+    // `!judgeIsLogin` 恒为 true，两处判据都是死重量，删掉**不改变任何现有行为**。
+    // 之所以是删掉而不是「补上写入语义」：它注释里的意图（「是否校验过用户已登录」）就是一个
+    // 会话级永久标记，而登录态会过期——真按那个字面语义补写入，等于亲手做出上面文件头部警告的
+    // 那个错误修法。去重该做在「同一条重定向链内」这个粒度上，已由 handoff 承担（见文件头部）。
+    const { user } = store.state.user
+    const willCheckLogin = to.name === 'shorturl' ||
+      to.path === '/' || to.name === 'app1' || to.name === 'client' || to.name === 'hall' ||
+      to.name === 'system' || to.name === 'appSetting' || to.name === 'manage' ||
+      (to.name === 'app' && isEmpty(user)) ||
+      to.name === 'Task' || to.name === 'feishuTask'
+    // 本遍是「自我重定向的续跑」就直接复用上一遍那个已 settled 的 promise，不再发请求；
+    // 否则照常发。inheritedLoginPromise 的产生/失效条件见文件头部注释。
+    loginPromise = willCheckLogin ? (inheritedLoginPromise || isLoginFn()) : null
+    // 只登记「本遍可交接的结果是什么」。真正的挂载在上面那层 next 包装里，且只发生在自我重定向
+    // 这个出口 —— 走别的出口（正常 next()、next(false)、守卫抛错）都不会留下任何东西。
+    ownLoginPromise = loginPromise
+    // 立即挂 catch 占位，否则在被 await 之前 reject 会产生 unhandled rejection。
+    // catch 返回的是新 promise，不影响原 promise 的 reject 传播，真正的错误处理仍在原 await 处。
+    if (libPromise) libPromise.catch(() => {})
+    if (loginPromise) loginPromise.catch(() => {})
+
+    if (!componentGlobalConfig) {
+      await getComponentGlobalConfigOnce({ type: GET_COMPONENT_GLOBAL_CONFIG, client: appConfig.CLIENT, system: appConfig['SYSTEM|ID'] || appConfig.SYSTEM })
+    }
+    setAppDocumentTitle(appConfig)
+    if (!window.componentLibrary) window.componentLibrary = {}
+    if (!window.isLoadLibrary) {
+      await libPromise
+      window.isLoadLibrary = true
+      console.log('----加载完成----')
+    }
+  }
+  const nextTo = { ...to }
+  if (to.name === 'shorturl') {
+    let { user } = store.state.user
+    if (setAppDocumentTitle(appConfig)) {
+      if (!app) app = appConfig.CODE
+    }
+    // 判断用户是否登录
+    const isLogin = await loginPromise
+    if (isLogin) {
+      if (isEmpty(user)) {
+        try {
+          user = await getUserOnce()
+        } catch (error) {
+          ElMessage.error(error.message)
+          util.toLogin()
+        }
+      }
+      visitService(appConfig.ID)
+      closeLoading()
+      // 判断是否需要角色
+      if (appConfig.EXTEND_OF_COMPETENCE !== 'allRole' && (!roleId && (!role || !isHasRole(user, appConfig.ID, role)))) {
+        const defaultRole = getDefaultRole(user, appConfig.ID)
+        if (defaultRole) {
+          return next({
+            name: to.name,
+            params: { ...to.params, role: defaultRole },
+            query: { ...to.query }
+          })
+        } else {
+          return next({
+            name: 'appRoleSelect',
+            params: { ...to.params, name: to.name },
+            query: { ...to.query },
+            replace: true
+          })
+        }
+      }
+    }
+  } else if (to.path === '/' || to.name === 'app1' || to.name === 'client' || to.name === 'hall' || to.name === 'system' || to.name === 'appSetting' || to.name === 'manage') {
+    let { user } = store.state.user
+    if (setAppDocumentTitle(appConfig)) {
+      if (!app) app = appConfig.CODE
+    }
+    // 判断用户是否登录
+    const isLogin = await loginPromise
+    if (isLogin) {
+      if (isEmpty(user)) {
+        try {
+          user = await getUserOnce()
+        } catch (error) {
+          ElMessage.error(error.message)
+          util.toLogin()
+        }
+      }
+      visitService(appConfig.ID)
+      closeLoading()
+      if (to.name === 'manage') {
+        // 获取权限
+        const manageRight = await http.get({
+          action: 'hasMangeService',
+          entityId: 'FM_USER',
+          querySystem: appConfig.SYSTEM
+        })
+        if (manageRight.systemAdmin !== 'true') {
+          return next({
+            name: 'app1',
+            params: { id: appId || '', client, system, app },
+            query: { ...to.query },
+            replace: true
+          })
+        }
+      } else if (appConfig.EXTEND_OF_COMPETENCE !== 'allRole' && (!roleId && (!role || !isHasRole(user, appConfig.ID, role)))) {
+        const defaultRole = getDefaultRole(user, appConfig.ID)
+        if (defaultRole) {
+          if (isMenuRoute) {
+            // 菜单直达路由不做补 role 的 URL 重定向（会丢 /m/:menuKey）：默认角色落
+            // localStorage，取数点经 resolveRouteRole 读取，导航照常放行
+            roleStorage.set(client, system, defaultRole)
+          } else {
+            return next({
+              name: to.name,
+              params: { id: appId || '', client, system, app, role: defaultRole },
+              query: { ...to.query },
+              replace: true
+            })
+          }
+        } else {
+          return next({
+            name: to.name === 'hall' ? 'hallRoleSelect' : 'appRoleSelect',
+            // backMenu：菜单直达进来的，选完角色回到原菜单（AppRoleSelect 消费）
+            params: { system: system || '', client, app, appId, name: to.name === 'defaultApp' ? to.name : '' },
+            query: { ...to.query, ...(isMenuRoute ? { backMenu: to.params.menuKey } : {}) },
+            replace: true
+          })
+        }
+      }
+    }
+  } else if (to.name === 'app') {
+    const { user } = store.state.user
+    if (setAppDocumentTitle(appConfig)) {
+      appId = appConfig.ID
+    }
+    if (isEmpty(user)) {
+      // 判断用户是否登录
+      const isLogin = await loginPromise
+      if (isLogin) {
+        // 没有角色
+        let user = null
+        try {
+          user = await getUserOnce()
+        } catch (error) {
+          ElMessage.error(error.message)
+          util.toLogin()
+        }
+        visitService(appConfig.ID)
+        closeLoading()
+        if (!to.params.roleId && to.name !== 'appRoleSelect') {
+          const { serviceRoles = {} } = user
+          const roleList = serviceRoles[appId] || []
+          let defaultRole = null
+          if (roleList.length === 1) {
+            defaultRole = roleList[0].id
+          } else {
+            const defaultRoleMap = roleList.find(item => item.isDefault === true) || {}
+            defaultRole = defaultRoleMap.id
+          }
+          if (defaultRole) {
+            return next({
+              name: 'app',
+              params: { id: appId || '', roleId: defaultRole },
+              query: { ...to.query }
+            })
+          } else {
+            return next({
+              name: 'appRoleSelect',
+              params: { id: appId || '' },
+              query: { ...to.query }
+            })
+          }
+        }
+      }
+    }
+  } else if (/\/(recruit\/register)\/([\w-]+)\/([\w-]+)\/([\w-]+)/.test(window.location.hash) && !to.name) {
+    // 同样是重定向，必须 return，否则末尾还会再调一次 next
+    return next({ ...nextTo })
+  } else if (to.name === 'Task' || to.name === 'feishuTask') {
+    let { user } = store.state.user
+    // Task 19 / C2：原来这里包着一层 `if (!judgeIsLogin)`，judgeIsLogin 恒为 undefined ⇒ 恒进入，
+    // 已连同上面 willCheckLogin 里的同一个死判据一起删除（理由见那里）。行为不变。
+    // 判断用户是否登录
+    const isLogin = await loginPromise
+    if (isLogin) {
+      if (isEmpty(user)) {
+        try {
+          user = await getUserOnce()
+        } catch (error) {
+          ElMessage.error(error.message)
+          util.toLogin()
+        }
+      }
+    }
+  }
+  closeLoading()
+  if (nextTo.query.token || nextTo.query._token) {
+    const query = { ...nextTo.query }
+    delete query.token
+    delete query._token
+    delete query.code
+    // 剥 token 的重定向仍属同一次用户导航 ⇒ 交接由上面那层 next 包装自动保留（传的是 location
+    // 对象）。（下面那句 next() 是既有的重复调用——vue-router 与本文件的记账都只认第一次调用，
+    // 这里不顺手改它。）
+    next({ ...nextTo, query })
+  }
+  // 走到这里而没有自我重定向的，什么都没挂过：登录校验结果**绝不跨用户导航复用**，否则就退化成
+  // 「本会话只校验一次」，token 中途过期再也检不出来（见文件头部注释）。
+  next()
+}