优化

Reviewed-on: #10

.dockerignore

@@ -4,6 +4,8 @@
 dist
 node_modules
 node_modules.broken-by-path
-.env.local
+.env
+.env.*
+!.env.example
 npm-debug.log*
 pnpm-debug.log*

.env.example

@@ -1,5 +1,10 @@
 VITE_API_BASE_URL=/api
-VITE_OVERSEAS_API_BASE_URL=/overseas-api
-OVERSEAS_API_PROXY_TARGET=http://127.0.0.1:9300
 API_PROXY_TARGET=http://127.0.0.1:9000
 VITE_ADMIN_WEB_ORIGIN=http://localhost:5173
+
+# Test container deployment (Jenkins environment or untracked .env).
+# API_UPSTREAM: unified Gateway origin, no /api suffix.
+# TEST_NETWORK: shared test Docker network.
+API_UPSTREAM=http://gateway:9000
+TEST_NETWORK=firstleg-test-network
+IMAGE_TAG=

AGENTS.md

@@ -4,7 +4,7 @@
 
 - 本项目是入驻企业及其成员使用的客户工作台，所有业务数据都处于企业租户上下文中。
 - 当前范围包括注册、业务总览、企业资料、企业成员、企业角色与权限、头程订单、客户资金账户、客户财务账单查询与客户确认，以及海外仓贴标、转运、废弃和退货换标自助服务。
-- 用户可见的“平台—客户”层级语义读取 `../../docs/平台客户层级与权限契约.md`；涉及海外 API、海外 Token 或跨区域事件时读取 `../../docs/跨区域认证与服务通信契约.md`。本文件中的 `tenant` 仅表示服务端隔离上下文，不扩展用户可见产品层级。
+- 用户可见的“平台—客户”层级语义读取 `../../docs/平台客户层级与权限契约.md`；涉及统一 API、Token、会话撤销或可靠事件时按需读取 `../../docs/统一认证与服务通信契约.md` 对应章节。本文件中的 `tenant` 仅表示服务端隔离上下文，不扩展用户可见产品层级。
 - 不在本项目实现平台内部运营管理、品牌官网、仓库 PDA 作业或仅属于原生移动端的能力。
 
 ## 技术基线
@@ -26,26 +26,26 @@
 - 模块内 `store/`：该业务跨页面状态；局部表单状态仍留在页面或组件内。跨模块使用 store 时只能导入其公开 store 文件，不得读取模块内部页面或组件实现。
 - `src/api/`：只保留 HTTP、会话令牌、响应类型等全局请求基础设施；业务接口放入对应模块的 `api/`。页面不得直接创建独立 Axios 客户端。
 - 模块之间不得通过相对路径或内部目录穿透；确需协作时只能从目标模块的 `public.ts` 导入。模块内稳定契约放在 `contracts.ts`，稳定的跨应用模型仍应上移到 `@chongchong/shared`。
-- `VITE_API_BASE_URL`、`VITE_OVERSEAS_API_BASE_URL` 分别控制国内和海外浏览器前缀；`API_PROXY_TARGET`、`OVERSEAS_API_PROXY_TARGET` 只由 Vite 开发代理读取，不进入客户端构建。新增或变更环境变量时同步更新 `.env.example`，不得提交真实密钥或环境专属凭据。
+- `VITE_API_BASE_URL` 控制唯一浏览器 API 前缀；全部业务共用 `src/api/http.ts` 和同一 Access/Refresh Token。`API_PROXY_TARGET` 仅供本地 Vite 代理连接测试入口，不进入客户端构建。独立海外 HTTP 客户端与代理已移除。新增或变更环境变量时同步更新 `.env.example`，不得提交真实密钥或环境专属凭据。
 - `src/styles/`：全局设计令牌和布局；优先复用现有 `--primary`、`--navy`、`--border`、`--muted`。
 - 本应用多个模块稳定复用的前端模型放到应用内 `shared/`，客户工作台专属类型保留在对应业务模块。不要链接应用目录之外的 TypeScript 包，服务端契约以 `baiyue-firstleg` Controller/OpenAPI 为准。
 
-## 开发环境样式验收
+## 测试环境样式验收
 
-- 开发环境验收使用本轮动态创建并已审核通过的客户管理员，或由用户显式提供的客户账号，不依赖固定业务客户或固定账号。
+- 测试环境验收使用本轮动态创建并已审核通过的客户管理员，或由用户显式提供的客户账号，不依赖固定业务客户或固定账号。
 - 账号与密码不写入仓库；从本机未提交环境变量或 `C:/Users/BY-OY/.codex/chongchong-global-dev-acceptance.env` 读取。若显式验收凭据不存在，再向用户索取。
-- 该身份仅适用于开发环境。不要把密码、Token 或真实接口地址写入源码、测试快照、日志或 `AGENTS.md`；开发环境变更时只更新本机凭据。
+- 当前只有一个测试环境。不要把密码、Token 或真实接口地址写入源码、测试快照、日志或 `AGENTS.md`；测试环境变更时只更新本机凭据。
 - 由人工使用该身份进入真实页面，按 `1920×1080` 视口和 `100%` 浏览器缩放完成操作与截图，再把截图发送给 AI 核对加载、空态、错误态、权限态和桌面布局；AI 默认不主动调用截图或视觉类技能取证。
 
 ## 模块快速查询
 
-退货预报与签收结果：`src/modules/overseas-warehouse/views/ReturnOrdersView.vue`、`api/returnOrders.ts`；菜单仍名为“退货换标”，正式路由 `return-relabel` 已使用独立页面，不再由 `WarehouseServiceView.vue` 承载。客户退货库存/箱号共用 `views/ReturnInventoryView.vue`、`api/returnInventory.ts`，`return-cartons` 传 `cartonOnly=true`。Backend 为 Lastleg `returnreceipt/`，退货单签收完成不等于换标或退货出库完成；后续换标、出库须按各自业务状态核对。
+退货预报与签收结果：`src/modules/overseas-warehouse/views/ReturnOrdersView.vue`、`api/returnOrders.ts`；菜单仍名为“退货换标”。列表路由 `return-relabel`、独立新建路由 `return-relabel/create` 与详情路由均复用该页面，并分别由 `createPage/detailPage` 明确模式；新建页直接填写海外仓、联系人、客户参考号及 SKU 预报明细，取消或提交后返回列表，不再由 `WarehouseServiceView.vue` 或列表内弹框承载。客户退货库存/箱号共用 `views/ReturnInventoryView.vue`、`api/returnInventory.ts`，`return-cartons` 传 `cartonOnly=true`。Backend 为 Lastleg `returnreceipt/`，退货单签收完成不等于换标或退货出库完成；后续换标、出库须按各自业务状态核对。
 
 先从 `src/modules/registry.ts` 确认模块，再按目标模块的 `routes.ts → views/ → api/、store/、contracts.ts 或 public.ts` 查询。页面是否正式开放以 `routes.ts` 的 `release` 为准，不从任务或进度文档推断。
 
 | 业务 | 模块入口 | 联查模块或服务端 |
 |---|---|---|
-| 登录、注册与会话 | `src/modules/auth/`、`src/api/session.ts`、`src/api/http.ts` | Backend `auth/`、`iam/`；正常旋转的国内/海外 Token 会话统一持久化，“记住账号”只记登录标识；访问令牌失效但刷新令牌仍在时先恢复会话，公开认证接口不得携带旧 Token |
+| 登录、注册与会话 | `src/modules/auth/`、`src/api/session.ts`、`src/api/http.ts` | Backend `auth/`、`iam/`；正常轮换的统一 Access/Refresh Token 会话持久化，“记住账号”只记登录标识；访问令牌失效但刷新令牌仍在时先恢复会话，公开认证接口不得携带旧 Token |
 | 企业资料、成员与角色 | `src/modules/tenant-management/`、`src/modules/account/` | Backend `iam/`、`auth/`、`file/`；公司联系电话/邮箱是企业资料，不作为登录标识；成员登录手机号可选，修改时同步 Auth、撤销该账号会话并审计。审核必填资质仅营业执照与统一社会信用代码；法人身份证选填，可随营业执照提交，也可在已有营业执照后单独补传或替换。前端角色树到服务端权限的映射统一维护在 `contracts.ts` 的 `FRONTEND_TO_MERCHANT_PERMISSION_CODES`，海外入仓、采购、本土卡车和散板权限必须显式进入该映射 |
 | 工作台与系统入口 | `src/modules/dashboard/`、`src/modules/system/` | `src/navigation/clientNavigation.ts`、`src/router/index.ts` |
 | 企业成员消息收件箱 | `src/modules/notifications/` | Backend `iam/src/main/java/com/baiyue/iam/notification/`；列表、详情、已读与未读数契约见 `iam/src/main/resources/openapi/notification-v1.yaml` |
@@ -53,10 +53,11 @@
 | 装柜完成后的退税报关资料 | `src/modules/first-leg/views/FirstLegOrdersView.vue` 的“报关资料”、`components/CustomsDocumentsDialog.vue`、`api/customs.ts` | 只显示登录客户在同柜的退税入仓码；报关开始前可上传、替换、调整同一资料覆盖的一个或多个入仓码及删除误传，全部写入携带幂等键和版本；开始后只读冻结资料，整柜完成后才能下载平台回传的一对一完成文件。Backend `firstleg/customs/container/`、`customs-v1.yaml`，二进制归 `file/` |
 | 统一订单展示 | `src/modules/order-management/` | `src/modules/first-leg/` 与对应后端订单契约 |
 | 客户财务账单、入仓码联查、收款、未收余额与客户确认 | `src/modules/finance/`；确认与明细入口 `views/FinanceBillsView.vue`、`api/finance.ts`，入仓码通过 `src/modules/first-leg/public.ts` 复用 `InboundCodeAssociationDialog` | Backend `finance/`；账单行只显示服务端 `inboundCode` 并按登录客户查询业务关系，缺失显示“—”，不得回退内部 ID。收款方式由服务端枚举映射中文。出账或已出账调整后为 `PENDING_CONFIRMATION`，客户确认提交登录成员、`expectedVersion` 和幂等键 |
-| 客户资金账户、授信与充值申请 | `src/modules/finance/views/FinanceAccountView.vue`、`api/account.ts` | 显示当前企业 CNY 实际余额、冻结金额、授信额度、授信有效期、已用授信、冻结授信、总可用余额和不可变流水；数据加载前显示“—”，不得先伪装为零。授信到期日当天仍有效，次日已用授信并入实际余额，负数实际余额会阻止提交新订单。充值只展示服务端启用的微信/支付宝静态收款码，客户上传 JPG/PNG 付款截图后进入待审核。客户范围只取登录态，无收款码时禁止提交，不模拟支付成功 |
+| 客户资金账户、授信与充值申请 | `src/modules/finance/views/FinanceAccountView.vue`、`api/account.ts` | 显示当前企业 CNY 实际余额、冻结金额、授信额度、授信有效期、已用授信、冻结授信、总可用余额和不可变流水；数据加载前显示“—”，不得先伪装为零。授信到期日当天仍有效，次日已用授信并入实际余额，负数实际余额会阻止提交新订单。充值只展示服务端启用的平台统一静态收款码，客户上传 JPG/PNG 付款截图后进入待审核。客户范围只取登录态，无收款码时禁止提交，不模拟支付成功 |
-| 海外采购、美国本土卡与美本土散板 | `src/modules/cross-border/routes.ts`、`components/BusinessOrdersView.vue`、`api/businessOrders.ts` | 三个路由均为 `active`，客户范围只取 Token；采购创建的 `customerName` 只取当前认证会话企业名称，不允许自由输入或冒用其他客户。Backend `lastleg-service/` 的 `procurement/`、`trucking/`、`looseboard/` 客户接口 |
+| 海外采购 | `src/modules/cross-border/routes.ts`、`views/ProcurementView.vue`、`components/ProcurementDetailPanel.vue`、`api/procurement.ts` | 独立列表、新建及详情路由；客户范围只取 Token，创建的 `customerName` 只取认证会话企业名称。详情消费独立客户投影，展示履约、已确认箱明细、实际运单和费用结果，不开放内部文件或平台操作。Backend `lastleg-service/procurement/` |
+| 美国本土卡与美本土散板 | `src/modules/cross-border/routes.ts`、`components/BusinessOrdersView.vue`、`api/businessOrders.ts` | 两个运输业务共用列表/表单组件，客户范围只取 Token；不消费采购字段或状态。Backend `lastleg-service/` 的 `trucking/`、`looseboard/` 客户接口 |
 | 海外仓入库订单 | `src/modules/order-management/routes.ts`、`views/InboundOrdersView.vue`、`api/inboundPlans.ts` | `orders/inbound` 为只读列表/详情，权限 `merchant:warehouse:inbound:list`；不展示或提交内部 ID |
-| 海外仓贴标、仓储转运、货物废弃 | `src/modules/overseas-warehouse/routes.ts`、`views/WarehouseServiceView.vue`、`api/warehouseServices.ts` | 三个路由均为 `active`；退货预报另见本节独立入口；贴标申请先选国外中转仓和有库存历史入仓单，换标申请必须提交正数 CNY `chargeAmount`，换标类型为只换 SKU、只换箱唛、SKU+箱唛。箱唛换标明细一行固定代表一箱，箱数不可编辑，提交也固定为 1。货物明细外层始终提供“SKU 关联”“箱号关联”“SKU 混箱换标”三套模板的下载、上传，不随换标类型切换；上传只进入待导入关系区，客户可勾选部分或全选后导入本次明细，只有进入明细的库存才随申请提交和冻结。明细也支持手动新增编辑，组合换标以旧箱唛连接旧/新 SKU 和旧箱唛/新 FBA 箱唛关系。涉及箱唛换标时必须选择卡车、自提或快递；快递可选择打印面单并上传 PDF/图片。PDA 逐箱换标、上传照片并由仓库复核后，客户详情展示完工照片和“换标完成确认”；客户确认前不得继续出库，确认后卡车进入预排车，自提/快递进入换标出库待创建。历史库存位置不能解释成箱唛与具体托盘快照，客户页面不暴露托盘、库位和内部库存 ID |
+| 海外仓贴标、仓储转运、货物废弃 | `src/modules/overseas-warehouse/routes.ts`、`views/WarehouseServiceView.vue`、`api/warehouseServices.ts` | 三个路由均为 `active`；退货预报另见本节独立入口；贴标申请先选国外中转仓和有库存历史入仓单，换标类型为只换 SKU、只换箱唛、SKU+箱唛。涉及箱唛换标时，整张贴标申请只选择一个 FBA 目的仓，全部箱级明细统一提交该目的仓，模板和明细不再逐行选择目的仓。箱唛换标明细一行固定代表一箱，箱数不可编辑，提交也固定为 1。货物明细外层始终提供“SKU 关联”“箱号关联”“SKU 混箱换标”三套模板的下载、上传，不随换标类型切换；上传只进入待导入关系区，客户可勾选部分或全选后导入本次明细，只有进入明细的库存才随申请提交和冻结。明细也支持手动新增编辑，组合换标以仓库唛头连接旧/新 SKU 和新 FBA 箱唛关系。涉及箱唛换标时必须选择卡车、自提或快递；快递可选择打印面单并上传 PDF/图片。PDA 逐箱换标、上传照片并由仓库复核后，客户详情展示完工照片和“换标完成确认”；客户确认前不得继续出库，确认后卡车进入预排车，自提/快递进入换标出库待创建。历史库存位置不能解释成箱唛与具体托盘快照，客户页面不暴露托盘、库位和内部库存 ID |
 
 ## 租户、认证与数据安全
 
@@ -65,14 +66,14 @@
 - 任何查询和变更都必须以服务端确认的当前租户为边界；绝不从可篡改的前端参数推断授权租户。
 - 企业成员、角色和权限只能管理当前企业范围。前端隐藏不是安全控制，服务端必须重复校验租户与权限。
 - 注册时登录手机号同时初始化公司联系电话；注册完成后两者独立维护。企业资料只修改 `contactPhone`，个人资料或成员管理中的登录手机号由 IAM/Auth 同步并撤销该账号现有会话，不得在前端互相回填或联动提交。
-- 认证统一经过 `src/modules/auth/store/auth.ts`、`src/api/http.ts`、`src/api/session.ts`；国内请求使用国内 Access Token，海外请求统一由 `src/api/overseasHttp.ts` 读取短时海外 Token。启动时 Access Token 已过期但 Refresh Token 仍存在，必须先尝试恢复会话；并发或跨标签页 401 共用一次刷新编排，每个原请求最多重放一次，只有明确 401/会话失效才清理 Token 并保留原路径跳转登录页。登录页“记住账号”只保存登录 ID，不改变 Access/Refresh Token 的持久化与续期策略；页面不要复制令牌逻辑或持久化密码、敏感资质内容。
+- 认证统一经过 `src/modules/auth/store/auth.ts`、`src/api/http.ts`、`src/api/session.ts`；全部请求共用统一 Access Token。启动时 Access Token 已过期但 Refresh Token 仍存在，必须先尝试恢复会话；并发或跨标签页 401 共用一次刷新编排，每个原请求最多重放一次，只有明确 401/会话失效才清理 Token 并保留原路径跳转登录页。登录页“记住账号”只保存登录 ID，不改变 Access/Refresh Token 的持久化与续期策略；页面不要复制令牌逻辑或持久化密码、敏感资质内容。
 - 当前认证仍包含模拟数据。接入真实 API 后移除对应模拟分支，生产环境不得回退为模拟成功。
 - 头程订单统一使用当前正式读写契约；不得继续扩展 `LEGACY_MANUAL`、旧系统入仓码、C02 不可用回退旧 API、历史部分响应兼容或其他新旧并跑逻辑。触及该链路时按根无兼容规则同步删除生产分支、类型、文案、Mock 和测试，不以现有代码或测试仍覆盖旧路径作为保留依据。
 - 注册、上传资质、成员邀请和订单操作必须提供明确校验、幂等保护、提交中状态和可恢复的失败反馈。
 
 ## UI 与交互
 
-- 修改已有 Client 原型页面前先读 `../../docs/Admin-Client前端原型还原验收规则.md`，按页面和操作形成原型核对矩阵；本节维护 Client 的实现约束，不复制跨前端验收文档全文。
+- 视觉还原、布局/交互承载方式变更或真实页面验收时读取 `../../docs/Admin-Client前端原型还原验收规则.md`，只为受影响操作形成原型核对矩阵；纯文案、逻辑或测试修改不自动读取。自动检查与人工视觉验收分开报告，无视觉变化时标记“无需视觉验收”。
 - 已向客户讲解或确认过的产品原型是页面视觉与布局实现的直接事实来源。字段顺序、字段分组、字段摆放、列宽、控件宽高、对齐方式、换行方式、区块层级、上下左右边距、内边距、间隙、留白、圆角、边框、阴影、背景色、文字颜色和字号均必须按原型还原，不得只参考大致风格后自行重新排版。
 - 原型中的按钮位置、顺序、尺寸、圆角、边框、背景色、文字色、图标、悬停态、激活态、禁用态和危险语义必须直接按原型实现；不得擅自改为文字链接、不同颜色、不同按钮类型、折叠菜单或自创交互效果，也不得增加原型没有的上浮、缩放、渐变线、装饰图标或其他视觉元素。
 - 原型已经给出明确图标、字符图标、图片资源或按钮内图标时，直接使用原型中的同一方案和资源，不得以 Lucide、Element Plus 默认图标、手绘图标或个人偏好替换。仅当原型没有定义对应图标时，才按本节的默认图标语义补齐。

Jenkinsfile

@@ -1,176 +1,62 @@
 pipeline {
-  agent {
+  agent { label "${env.JOB_BASE_NAME?.endsWith('-prod') ? 'java-builder' : 'java-test'}" }
-    label "${env.JOB_BASE_NAME?.endsWith('-prod') ? 'java-builder' : (env.JOB_BASE_NAME?.endsWith('-dev') ? 'java-dev' : 'java-test')}"
-  }
-
-  environment {
-    DEVELOPMENT_COMPOSE_FILE = 'docker-compose.development.yml'
-    DEVELOPMENT_COMPOSE_PROJECT = 'client-web'
-    REGISTRY_HOST = '172.31.198.7:10082'
-    REGISTRY_CREDENTIALS = 'gitea-registry-token'
-    NODE_BASE_IMAGE = '172.31.198.7:10082/java-project/node:22-alpine'
-    NGINX_BASE_IMAGE = '172.31.198.7:10082/java-project/nginx:1.27-alpine'
-    PRODUCTION_IMAGE_REPOSITORY = 'git.buggoglobal.com/html/client-web'
-  }
-
   options {
     timestamps()
     disableConcurrentBuilds()
   }
-
   stages {
-    stage('确认提交版本') {
+    stage('检查测试发布参数') {
+      when { expression { !env.JOB_BASE_NAME?.endsWith('-prod') } }
       steps {
         script {
-          env.IS_DEVELOPMENT = env.JOB_BASE_NAME?.endsWith('-dev') ? 'true' : 'false'
+          if (env.JOB_BASE_NAME?.endsWith('-dev')) {
-          env.IS_PRODUCTION = env.JOB_BASE_NAME?.endsWith('-prod') ? 'true' : 'false'
+            error('此流水线仅支持 test 和本轮授权的 prod 灰度')
-          if (env.IS_PRODUCTION == 'true') {
-            sh '''
-              set -eu
-              git fetch --no-tags origin +refs/heads/main:refs/remotes/origin/main
-              test "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)" || {
-                echo "生产部署只允许 origin/main 当前提交；请先合并代码到 main" >&2
-                exit 1
-              }
-            '''
           }
-          env.SOURCE_TAG = sh(script: 'git rev-parse --short=12 HEAD', returnStdout: true).trim()
+          env.IMAGE_TAG = sh(script: 'git rev-parse --short=12 HEAD', returnStdout: true).trim()
         }
-        sh 'git log -1 --oneline'
+        sh '''set -eu
+          export API_UPSTREAM="${API_UPSTREAM:-http://gateway:9000}"
+          export TEST_NETWORK="${TEST_NETWORK:-firstleg-test-network}"
+          : "${VITE_ADMIN_WEB_ORIGIN:?VITE_ADMIN_WEB_ORIGIN 未设置}"
+          docker network inspect "$TEST_NETWORK" >/dev/null
+          docker compose -f docker-compose.test.yml config --quiet
+        '''
       }
     }
-
     stage('构建并部署测试前端') {
-      when { expression { env.IS_DEVELOPMENT != 'true' && env.IS_PRODUCTION != 'true' } }
+      when { expression { !env.JOB_BASE_NAME?.endsWith('-prod') } }
       steps {
-        withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD')]) {
+        sh '''set -eu
-          sh '''
+          docker compose -f docker-compose.test.yml build --pull=false
-            set -eu
+          docker compose -f docker-compose.test.yml up -d --wait --wait-timeout 120
-            export DOCKER_CONFIG="${WORKSPACE}@tmp/docker-auth"
+          docker compose -f docker-compose.test.yml exec -T client-web wget -qO- http://127.0.0.1/healthz
-            rm -rf "$DOCKER_CONFIG"
+        '''
-            mkdir -p "$DOCKER_CONFIG"
-            cleanup_registry() {
-              docker logout "$REGISTRY_HOST" >/dev/null 2>&1 || true
-              rm -rf "$DOCKER_CONFIG"
-            }
-            trap cleanup_registry EXIT HUP INT TERM
-            printf %s "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdin "$REGISTRY_HOST"
-            docker compose -f docker-compose.test.yml build --pull=false
-            docker compose -f docker-compose.test.yml up -d --remove-orphans
-          '''
-        }
       }
     }
-
+    stage('发布临时生产灰度') {
-    stage('构建并发布生产镜像') {
+      when { expression { env.JOB_BASE_NAME?.endsWith('-prod') } }
-      when { expression { env.IS_PRODUCTION == 'true' } }
       steps {
-        withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD')]) {
+        lock(resource: 'firstleg-production-client-web-deploy') {
-          sh '''
-            set -eu
-            export DOCKER_CONFIG="${WORKSPACE}@tmp/docker-auth"
-            rm -rf "$DOCKER_CONFIG"
-            mkdir -p "$DOCKER_CONFIG"
-            cleanup_registry() {
-              docker logout git.buggoglobal.com >/dev/null 2>&1 || true
-              rm -rf "$DOCKER_CONFIG"
-            }
-            trap cleanup_registry EXIT HUP INT TERM
-            printf %s "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdin git.buggoglobal.com
-            image="$PRODUCTION_IMAGE_REPOSITORY:$SOURCE_TAG"
-            docker build \
-              --build-arg NODE_IMAGE="$NODE_BASE_IMAGE" \
-              --build-arg NGINX_IMAGE="$NGINX_BASE_IMAGE" \
-              --build-arg VITE_ADMIN_WEB_ORIGIN=https://admin.buggoglobal.com \
-              -t "$image" .
-            docker push "$image"
-          '''
-        }
-      }
-    }
-
-    stage('确认部署生产前端') {
-      when { expression { env.IS_PRODUCTION == 'true' } }
-      steps {
-        input message: "确认将 main 提交 ${env.SOURCE_TAG} 部署到 app.buggoglobal.com？", ok: '确认部署'
-      }
-    }
-
-    stage('部署生产前端') {
-      when { expression { env.IS_PRODUCTION == 'true' } }
-      steps {
-        lock(resource: 'firstleg-production-client-web-deploy', inversePrecedence: true) {
           withCredentials([
+            usernamePassword(credentialsId: 'gitea-registry-token', usernameVariable: 'BUILD_REGISTRY_USER', passwordVariable: 'BUILD_REGISTRY_PASSWORD'),
             usernamePassword(credentialsId: 'gitea-production-pull-token', usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD'),
             sshUserPrivateKey(credentialsId: 'firstleg-production-ssh', keyFileVariable: 'TARGET_SSH_KEY', usernameVariable: 'TARGET_SSH_USER'),
             string(credentialsId: 'firstleg-production-host', variable: 'TARGET_SSH_HOST'),
             file(credentialsId: 'firstleg-production-known-hosts', variable: 'TARGET_SSH_KNOWN_HOSTS')
           ]) {
-            withEnv([
+            sh 'sh scripts/deploy-production.sh'
-              'TARGET_DEPLOY_DIR=/data/firstleg/deploy/frontend',
-              'TARGET_SSH_TARGET=' + env.TARGET_SSH_USER + '@' + env.TARGET_SSH_HOST
-            ]) {
-              sh "sh scripts/deploy-production.sh client-web '${env.PRODUCTION_IMAGE_REPOSITORY}' '${env.SOURCE_TAG}' docker-compose.production.yml"
-            }
           }
         }
       }
     }
-
+  }
-    stage('构建并部署开发前端') {
+  post {
-      when { expression { env.IS_DEVELOPMENT == 'true' } }
+    failure {
-      steps {
+      script {
-        withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD')]) {
+        if (!env.JOB_BASE_NAME?.endsWith('-prod')) {
-          sh '''
+          sh 'docker compose -f docker-compose.test.yml logs --tail=100 || true'
-            set -eu
-            export DOCKER_CONFIG="${WORKSPACE}@tmp/docker-auth"
-            rm -rf "$DOCKER_CONFIG"
-            mkdir -p "$DOCKER_CONFIG"
-            cleanup_registry() {
-              docker logout "$REGISTRY_HOST" >/dev/null 2>&1 || true
-              rm -rf "$DOCKER_CONFIG"
-            }
-            trap cleanup_registry EXIT HUP INT TERM
-            printf %s "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdin "$REGISTRY_HOST"
-            image="client-web-development:${SOURCE_TAG}"
-
-            docker build \
-              --build-arg NODE_IMAGE="$NODE_BASE_IMAGE" \
-              --build-arg NGINX_IMAGE="$NGINX_BASE_IMAGE" \
-              --build-arg VITE_ADMIN_WEB_ORIGIN=http://8.163.49.32:9001 \
-              -t "$image" .
-            export IMAGE_TAG="$SOURCE_TAG"
-            docker compose -p "$DEVELOPMENT_COMPOSE_PROJECT" -f "$DEVELOPMENT_COMPOSE_FILE" up -d --remove-orphans --pull never
-            docker compose -p "$DEVELOPMENT_COMPOSE_PROJECT" -f "$DEVELOPMENT_COMPOSE_FILE" ps
-            docker compose -p "$DEVELOPMENT_COMPOSE_PROJECT" -f "$DEVELOPMENT_COMPOSE_FILE" exec -T client-web wget -qO- http://127.0.0.1/healthz
-          '''
         }
       }
     }
-
-    stage('部署检查') {
-      when { expression { env.IS_DEVELOPMENT != 'true' && env.IS_PRODUCTION != 'true' } }
-      steps {
-        sh '''
-          set -eu
-          docker compose -f docker-compose.test.yml ps
-          docker compose -f docker-compose.test.yml exec -T client-web wget -qO- http://127.0.0.1/healthz
-        '''
-      }
-    }
-  }
-
-  post {
-    failure {
-      sh '''
-        if [ "${IS_PRODUCTION:-false}" = "true" ]; then
-          echo "生产部署失败，请查看上方远程部署日志"
-        elif [ "${IS_DEVELOPMENT:-false}" = "true" ]; then
-          docker logs --tail=100 client-web-development || true
-        else
-          docker compose -f docker-compose.test.yml logs --tail=100 || true
-        fi
-      '''
-    }
   }
 }

README.md

@@ -10,7 +10,7 @@ pnpm install
 pnpm dev
 ```
 
-生产构建：
+发布资源构建：
 
 ```bash
 pnpm typecheck
@@ -35,7 +35,7 @@ pnpm test
 
 依赖和 `pnpm-lock.yaml` 均保存在当前前端项目中，不需要在仓库根目录安装 Node 依赖。
 
-订单与客户路由：登录、注册、工作台、我的信息、企业资料、企业成员、角色权限、头程订单、海外采购、美国本土卡、美本土散板以及海外仓入库订单。跨境下单支持真实列表、详情和新增，海外入库支持当前客户列表与详情；均经海外 Gateway 的客户接口访问，客户范围只取 Token，不提交客户 ID。开发代理通过 `API_PROXY_TARGET` 与 `OVERSEAS_API_PROXY_TARGET` 分别配置国内、海外 Gateway。登录使用后端约定的用户名和 8–72 位密码，注册成功后可立即登录，企业资料审核只影响订单提交资格。
+订单与客户路由：登录、注册、工作台、我的信息、企业资料、企业成员、角色权限、头程订单、海外采购、美国本土卡、美本土散板以及海外仓入库订单。跨境下单支持真实列表、详情和新增，海外入库支持当前客户列表与详情；均经统一 Gateway 的客户接口访问，客户范围只取 Token，不提交客户 ID。本地代理仅通过 `API_PROXY_TARGET` 配置统一 Gateway。登录使用后端约定的用户名和 8–72 位密码，注册成功后可立即登录，企业资料审核只影响订单提交资格。
 
 认证会话保存 Access Token 和轮换后的 Refresh Token，并对并发 401 请求执行单次刷新。刷新或会话上下文加载遇到临时网络故障、超时等非认证错误时保留当前有效 Token，只有服务端明确返回 401/会话失效才清理登录状态。客户端只接受 `app_code` 为 `MERCHANT` 的 JWT；页面权限通过当前用户授权接口实时加载，不从 JWT 携带或解析角色权限。前端权限仅用于导航和交互控制，服务端仍须按用户、客户和权限编码完成最终授权。
 
@@ -47,4 +47,10 @@ pnpm test
 
 头程订单列表、详情、仓库查询、创建/编辑草稿和提交已经接入真实 API，并显式映射后端 `transportMode`、`containerMode` 和订单状态。创建与提交请求携带幂等键，`merchant:order:create`、`merchant:order:edit`、`merchant:order:submit` 分别映射到独立前端操作权限。页面补齐渠道、提货方式、报关模式、目的仓类型、包装类型等后端必填字段；API 模式先清空本地记录，请求失败不会回退模拟成功。FBA 和海外仓按公共仓类型筛选，选择后由仓库主数据生成目的仓字段，不再要求客户重复选择收货单位；私人仓才填写并按当前用户缓存收件资料。只有“我司提货”需要填写提货联系人和地址，其他送货方式不发送发货方快照，订单也不再依赖往来单位 `customerId`。快递信息仍由平台维护、客户只读。订单取消不属于本轮本地订单与客户验收，客户端不暴露取消写操作。订单产品状态仍按已确认的七状态执行，不设置“已驳回”；若兼容旧接口数据收到 `REJECTED`，只按待审核展示且不开放编辑。
 
-联调远端 Gateway 时，进程环境变量优先于 `.env` 文件。浏览器国内业务统一请求同源 `/api`，海外业务请求同源 `/overseas-api`，由代理分别转发并确保最终路径只有一个 `/api` 前缀。联调时可只读检查同工作区的 `baiyue-firstleg/` Controller、DTO、Service、Repository 和回归脚本，用于发现后端拉取后的契约变化，但不修改后端仓库。
+联调远端 Gateway 时，进程环境变量优先于 `.env` 文件。浏览器全部业务统一请求同源 `/api`，由同一代理转发并确保最终路径只有一个 `/api` 前缀。联调时可只读检查同工作区的 `baiyue-firstleg/` Controller、DTO、Service、Repository 和回归脚本，用于发现后端拉取后的契约变化，但不修改后端仓库。
+
+## 唯一测试部署入口
+
+仅保留 `docker-compose.test.yml` 与 test Jenkins Job。发布前注入 `API_UPSTREAM`（统一 Gateway origin，不含 `/api`）、`TEST_NETWORK`（后端共享测试网络）、`VITE_ADMIN_WEB_ORIGIN`（管理后台 origin，构建时用于安全代登录）与 `IMAGE_TAG`（Jenkins 从当前提交生成）。`HOST_PORT` 默认 9002 且仅绑定 loopback；宿主机反向代理负责外部入口。可选 `NODE_BASE_IMAGE`/`NGINX_BASE_IMAGE`，私有镜像认证由构建节点管理。不得把本地构建结果描述为测试环境已发布。
+
+同机目标默认值：`API_UPSTREAM=http://gateway:9000`、`TEST_NETWORK=firstleg-test-network`；必须与后端同批 test Compose 配置一致。

docker-compose.development.yml

@@ -1,21 +0,0 @@
-services:
-  client-web:
-    image: client-web-development:${IMAGE_TAG:?IMAGE_TAG is required}
-    container_name: client-web-development
-    restart: unless-stopped
-    ports:
-      - "127.0.0.1:9002:80"
-    environment:
-      API_UPSTREAM: "http://firstleg-development-gateway:9000"
-      OVERSEAS_API_UPSTREAM: "http://firstleg-development-gateway-overseas:9300"
-    networks:
-      - development-backend
-      - development-overseas-backend
-
-networks:
-  development-backend:
-    external: true
-    name: firstleg-development-network
-  development-overseas-backend:
-    external: true
-    name: firstleg-development-overseas-network

docker-compose.production.yml

@@ -1,19 +1,22 @@
 name: firstleg-prod-client-web
-
 services:
   client-web:
-    image: ${IMAGE_REPOSITORY:?IMAGE_REPOSITORY is required}:${IMAGE_TAG:?IMAGE_TAG is required}
+    image: "${PRODUCTION_IMAGE_REPOSITORY:?PRODUCTION_IMAGE_REPOSITORY is required}:${IMAGE_TAG:?IMAGE_TAG is required}"
     container_name: firstleg-prod-client-web
     restart: unless-stopped
     ports:
-      - "127.0.0.1:${HOST_PORT:-9002}:80"
+      - "127.0.0.1:${HOST_PORT:-29012}:80"
     environment:
       API_UPSTREAM: "http://gateway:9000"
-      OVERSEAS_API_UPSTREAM: "http://gateway-overseas:9300"
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1/healthz"]
+      interval: 5s
+      timeout: 3s
+      retries: 12
+      start_period: 5s
     networks:
-      - infra-network
+      - backend
-
 networks:
-  infra-network:
+  backend:
     external: true
-    name: firstleg-prod-infra-network
+    name: firstleg-production-network

docker-compose.test.yml

@@ -1,17 +1,29 @@
+name: firstleg-test-client-web
 services:
   client-web:
     build:
       context: .
       dockerfile: Dockerfile
       args:
-        VITE_ADMIN_WEB_ORIGIN: "${VITE_ADMIN_WEB_ORIGIN:-https://test-admin.buggoglobal.com}"
         NODE_IMAGE: "${NODE_BASE_IMAGE:-node:22-alpine}"
         NGINX_IMAGE: "${NGINX_BASE_IMAGE:-nginx:1.27-alpine}"
-    image: client-web-test:local
+        VITE_ADMIN_WEB_ORIGIN: "${VITE_ADMIN_WEB_ORIGIN:?VITE_ADMIN_WEB_ORIGIN is required}"
+    image: client-web-test:${IMAGE_TAG:?IMAGE_TAG is required}
     container_name: client-web-test
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1/healthz"]
+      interval: 5s
+      timeout: 3s
+      retries: 12
+      start_period: 5s
     ports:
-      - "${HOST_PORT:-9002}:80"
+      - "127.0.0.1:${HOST_PORT:-9002}:80"
     environment:
-      API_UPSTREAM: "http://test-api-cn.buggoglobal.com"
+      API_UPSTREAM: "${API_UPSTREAM:-http://gateway:9000}"
-      OVERSEAS_API_UPSTREAM: "http://test-api-global.buggoglobal.com"
+    networks:
+      - test-backend
+networks:
+  test-backend:
+    external: true
+    name: "${TEST_NETWORK:-firstleg-test-network}"

nginx/default.conf.template

@@ -35,17 +35,6 @@ server {
         proxy_set_header X-Forwarded-Proto $scheme;
     }
 
-    # 海外业务使用独立 Gateway；浏览器前缀只在此处改写一次为 /api。
-    location /overseas-api/ {
-        client_max_body_size 55m;
-        rewrite ^/overseas-api/(.*)$ /api/$1 break;
-        proxy_pass ${OVERSEAS_API_UPSTREAM};
-        proxy_http_version 1.1;
-        proxy_set_header Host $proxy_host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
 
     # 支持 Vue Router history 路由直接刷新。
     location / {

scripts/deploy-production.sh

@@ -1,93 +1,58 @@
-#!/usr/bin/env sh
+#!/bin/sh
 set -eu
-
+set +x
-if [ "$#" -ne 4 ]; then
+: "${PUBLIC_WEB_ORIGIN:?PUBLIC_WEB_ORIGIN is required}"
-  echo "用法: $0 <服务名> <镜像仓库> <镜像标签> <Compose 文件>" >&2
+: "${PRODUCTION_IMAGE_REPOSITORY:?PRODUCTION_IMAGE_REPOSITORY is required}"
-  exit 2
+: "${TARGET_SSH_KEY:?}"
-fi
+: "${TARGET_SSH_USER:?}"
-
+: "${TARGET_SSH_HOST:?}"
-SERVICE="$1"
+: "${TARGET_SSH_KNOWN_HOSTS:?}"
-IMAGE_REPOSITORY="$2"
+: "${BUILD_REGISTRY_USER:?}"
-IMAGE_TAG="$3"
+: "${BUILD_REGISTRY_PASSWORD:?}"
-COMPOSE_FILE="$4"
+: "${REGISTRY_USER:?}"
-IMAGE="$IMAGE_REPOSITORY:$IMAGE_TAG"
+: "${REGISTRY_PASSWORD:?}"
-REGISTRY_HOST="${IMAGE_REPOSITORY%%/*}"
+case "$PUBLIC_WEB_ORIGIN" in https://*) ;; *) echo 'prod requires HTTPS web origin' >&2; exit 2 ;; esac
-SSH_TARGET="${TARGET_SSH_TARGET:?TARGET_SSH_TARGET 未设置}"
+# Only an origin (optionally a trailing slash) is accepted; no shell/env-file metacharacters.
-SSH_KEY="${TARGET_SSH_KEY:?TARGET_SSH_KEY 未设置}"
+printf '%s' "$PUBLIC_WEB_ORIGIN" | grep -Eq '^https://[A-Za-z0-9.-]+(:[0-9]+)?/?$'
-SSH_KNOWN_HOSTS="${TARGET_SSH_KNOWN_HOSTS:?TARGET_SSH_KNOWN_HOSTS 未设置}"
+printf '%s' "$PRODUCTION_IMAGE_REPOSITORY" | grep -Eq '^[A-Za-z0-9.-]+(:[0-9]+)?/[a-z0-9._/-]+$'
-REMOTE_DIR="${TARGET_DEPLOY_DIR:?TARGET_DEPLOY_DIR 未设置}"
+git fetch --no-tags origin +refs/heads/main:refs/remotes/origin/main
-: "${REGISTRY_USER:?REGISTRY_USER 未设置}"
+test "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)"
-: "${REGISTRY_PASSWORD:?REGISTRY_PASSWORD 未设置}"
+IMAGE_TAG=$(git rev-parse --short=12 HEAD)
-
+registry=${PRODUCTION_IMAGE_REPOSITORY%%/*}
+image="$PRODUCTION_IMAGE_REPOSITORY:$IMAGE_TAG"
+TARGET_SSH_TARGET="$TARGET_SSH_USER@$TARGET_SSH_HOST"
+remote_dir=/data/firstleg/deploy/gray-client-web
 run_ssh() {
-  ssh -i "$SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
+  ssh -i "$TARGET_SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
-    -o UserKnownHostsFile="$SSH_KNOWN_HOSTS" -o ConnectTimeout=10 "$SSH_TARGET" "$@"
+    -o UserKnownHostsFile="$TARGET_SSH_KNOWN_HOSTS" -o ConnectTimeout=12 "$TARGET_SSH_TARGET" "$@"
 }
-
 run_scp() {
-  scp -i "$SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
+  scp -i "$TARGET_SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
-    -o UserKnownHostsFile="$SSH_KNOWN_HOSTS" -o ConnectTimeout=10 "$@"
+    -o UserKnownHostsFile="$TARGET_SSH_KNOWN_HOSTS" -o ConnectTimeout=12 "$@"
 }
-
+export DOCKER_CONFIG
-run_ssh install -d -m 750 "$REMOTE_DIR"
+DOCKER_CONFIG=$(mktemp -d)
-REMOTE_COMPOSE="$REMOTE_DIR/docker-compose.$SERVICE.yml"
+cleanup() { rm -f "$DOCKER_CONFIG/config.json"; rmdir "$DOCKER_CONFIG" 2>/dev/null || true; }
-run_scp "$COMPOSE_FILE" "$SSH_TARGET:$REMOTE_COMPOSE.tmp"
+trap cleanup EXIT HUP INT TERM
-run_ssh sh -s -- "$REMOTE_COMPOSE.tmp" "$REMOTE_COMPOSE" <<'REMOTE_PREPARE'
+printf '%s' "$BUILD_REGISTRY_PASSWORD" | docker login -u "$BUILD_REGISTRY_USER" --password-stdin "$registry"
+docker build --build-arg NODE_IMAGE="${NODE_BASE_IMAGE:-node:22-alpine}" \
+  --build-arg NGINX_IMAGE="${NGINX_BASE_IMAGE:-nginx:1.27-alpine}" \
+  --build-arg VITE_ADMIN_WEB_ORIGIN="$PUBLIC_WEB_ORIGIN" -t "$image" .
+docker push "$image"
+run_ssh install -d -m 750 "$remote_dir"
+run_scp docker-compose.production.yml "$TARGET_SSH_TARGET:$remote_dir/compose.yml"
+# The remote env file contains only image coordinates and public web origin, never credentials.
+printf 'PRODUCTION_IMAGE_REPOSITORY=%s\nIMAGE_TAG=%s\nPUBLIC_WEB_ORIGIN=%s\n' \
+  "$PRODUCTION_IMAGE_REPOSITORY" "$IMAGE_TAG" "$PUBLIC_WEB_ORIGIN" | run_ssh sh -c "'umask 077; cat > $remote_dir/release.env'"
+# Registry credentials exist only in an isolated temporary Docker config, removed after pull.
+printf '%s' "$REGISTRY_USER" | grep -Eq '^[A-Za-z0-9_.@-]+$'
+run_scp scripts/pull-production-image.sh "$TARGET_SSH_TARGET:$remote_dir/pull-image.sh"
+printf '%s' "$REGISTRY_PASSWORD" | run_ssh sh "$remote_dir/pull-image.sh" "$REGISTRY_USER" "$registry" "$image"
+run_ssh sh -s -- "$remote_dir" <<'REMOTE'
 set -eu
-compose_tmp="$1"
+cd "$1"
-compose_target="$2"
+docker network inspect firstleg-production-network >/dev/null
-chmod 644 "$compose_tmp"
+docker compose --env-file release.env -f compose.yml config --quiet
-mv -f "$compose_tmp" "$compose_target"
+docker compose --env-file release.env -f compose.yml up -d --wait --wait-timeout 120
-REMOTE_PREPARE
+docker compose --env-file release.env -f compose.yml exec -T client-web wget -qO- http://127.0.0.1/healthz
-
+REMOTE
-printf '%s' "$REGISTRY_PASSWORD" | run_ssh docker login -u "$REGISTRY_USER" --password-stdin "$REGISTRY_HOST"
-trap 'run_ssh docker logout "$REGISTRY_HOST" >/dev/null 2>&1 || true' EXIT HUP INT TERM
-run_ssh docker pull "$IMAGE"
-
-run_ssh sh -s -- "$REMOTE_DIR" "$SERVICE" "$IMAGE_REPOSITORY" "$IMAGE_TAG" <<'REMOTE_DEPLOY'
-set -eu
-remote_dir="$1"
-service="$2"
-image_repository="$3"
-image_tag="$4"
-compose_file="docker-compose.$service.yml"
-project_name="firstleg-prod-$service"
-cd "$remote_dir"
-export IMAGE_REPOSITORY="$image_repository" IMAGE_TAG="$image_tag"
-
-compose() {
-  docker compose --project-name "$project_name" -f "$compose_file" "$@"
-}
-
-container_id="$(compose ps --all --quiet "$service" | head -n 1)"
-previous_image=""
-if [ -n "$container_id" ]; then
-  previous_image="$(docker inspect --format '{{.Config.Image}}' "$container_id")"
-fi
-
-if compose up -d --no-deps --pull never "$service" && \
-   compose exec -T "$service" wget -qO- http://127.0.0.1/healthz >/dev/null; then
-  echo "生产前端部署成功: $image_repository:$image_tag"
-  compose ps "$service"
-  exit 0
-fi
-
-echo "生产前端健康检查失败，准备回滚" >&2
-compose logs --tail=100 "$service" >&2 || true
-case "$previous_image" in
-  "$image_repository:"*) ;;
-  '') echo "首次部署无旧镜像可回滚" >&2; exit 1 ;;
-  *) echo "旧镜像不属于当前应用，拒绝回滚: $previous_image" >&2; exit 1 ;;
-esac
-previous_tag="${previous_image#"$image_repository:"}"
-if [ "$previous_tag" = "$image_tag" ]; then
-  echo "旧镜像与新镜像一致，无法回滚" >&2
-  exit 1
-fi
-docker pull "$previous_image"
-export IMAGE_TAG="$previous_tag"
-compose up -d --no-deps --pull never "$service"
-compose exec -T "$service" wget -qO- http://127.0.0.1/healthz >/dev/null || true
-echo "已回滚至: $previous_image" >&2
-exit 1
-REMOTE_DEPLOY

scripts/pull-production-image.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+set -eu
+set +x
+export DOCKER_CONFIG
+DOCKER_CONFIG=$(mktemp -d)
+cleanup() { rm -f "$DOCKER_CONFIG/config.json"; rmdir "$DOCKER_CONFIG" 2>/dev/null || true; }
+trap cleanup EXIT HUP INT TERM
+docker login -u "$1" --password-stdin "$2"
+docker pull "$3"

shared/src/index.ts

@@ -92,6 +92,7 @@ export const FIRST_LEG_ORDER_STATUSES = [
   { code: 'LOADED', label: '装柜完成' },
   { code: 'DELIVERED', label: '派送完成' },
   { code: 'COMPLETED', label: '已完成' },
+  { code: 'CANCELLED', label: '已取消' },
 ] as const
 
 export type FirstLegOrderStatus = (typeof FIRST_LEG_ORDER_STATUSES)[number]['code']

src/api/http.ts

@@ -1,8 +1,8 @@
 import axios, { AxiosError, type AxiosRequestConfig, type InternalAxiosRequestConfig } from 'axios'
 import { parseApiJsonResponse } from '@chongchong/shared'
-import { clearSessionTokens, getAccessToken, getRefreshToken, persistTokenPair, type TokenPair } from '@/api/session'
+import { accessTokenIdentity, clearSessionTokens, getAccessToken, getRefreshToken, persistTokenPair, type TokenPair } from '@/api/session'
 import { apiErrorMessage, asFieldErrors } from '@/api/errorDetails'
-import { ApiError, isApiEnvelope, type ApiEnvelope } from '@/api/types'
+import { ApiError, isApiEnvelope, isApiFailure, type ApiEnvelope } from '@/api/types'
 import { coordinateCrossTabRefresh, CrossTabRefreshTimeoutError } from '@/api/crossTabRefresh'
 
 const transport = axios.create({
@@ -13,9 +13,18 @@ const transport = axios.create({
 
 interface RetryableRequest extends InternalAxiosRequestConfig {
   _retriedAfterRefresh?: boolean
+  _sessionIdentity?: string | null
+  _logoutGeneration?: number
 }
 
 function unwrap<T>(envelope: ApiEnvelope<T>) {
+  if (!isApiEnvelope(envelope)) {
+    const invalid: unknown = envelope
+    if (isApiFailure(invalid)) {
+      throw new ApiError(invalid.message, invalid.code, undefined, undefined, invalid.traceId, invalid.requestId)
+    }
+    throw new ApiError('接口响应格式错误', 'INVALID_RESPONSE')
+  }
   if (envelope.code !== '200') {
     const fieldErrors = asFieldErrors(envelope.data)
     throw new ApiError(apiErrorMessage(envelope.message, fieldErrors), envelope.code, undefined, fieldErrors, envelope.traceId, envelope.requestId)
@@ -28,8 +37,8 @@ function mapError(error: unknown) {
   if (!axios.isAxiosError(error)) return new ApiError(error instanceof Error ? error.message : '请求失败')
 
   const body = error.response?.data
-  if (isApiEnvelope(body)) {
+  if (isApiEnvelope(body) || isApiFailure(body)) {
-    const fieldErrors = asFieldErrors(body.data)
+    const fieldErrors = asFieldErrors(isApiEnvelope(body) ? body.data : undefined)
     return new ApiError(
       apiErrorMessage(body.message, fieldErrors),
       body.code,
@@ -44,9 +53,12 @@ function mapError(error: unknown) {
   return new ApiError(error.message || '请求失败', 'HTTP_ERROR', error.response?.status)
 }
 
+let refreshExchange: { identity: string; refreshToken: string; promise: Promise<TokenPair> } | null = null
+let logoutGeneration = 0
 let refreshPromise: Promise<string> | null = null
+let refreshIdentity: string | null = null
 let redirectingToLogin = false
-const publicAuthPaths = ['/auth/login', '/auth/register', '/auth/refresh', '/auth/impersonations/exchange']
+const publicAuthPaths = ['/auth/login', '/auth/register', '/auth/refresh', '/auth/logout', '/auth/impersonations/exchange']
 
 function isPublicAuthRequest(url?: string) {
   return publicAuthPaths.some((path) => url?.endsWith(path))
@@ -63,29 +75,46 @@ function redirectToLoginAfterSessionExpiry() {
   window.location.replace(`/login?redirect=${encodeURIComponent(redirect)}`)
 }
 
+function requireCurrentIdentity(identity: string | null | undefined, accessToken = getAccessToken()) {
+  if (!identity || accessTokenIdentity(accessToken) !== identity) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+}
+
 export async function refreshAuthenticatedSession() {
+  const observedIdentity = accessTokenIdentity(getAccessToken())
+  requireCurrentIdentity(observedIdentity)
   const observedRefreshToken = getRefreshToken()
   if (!observedRefreshToken) throw new ApiError('登录已过期，请重新登录', 'A0401', 401)
   if (!refreshPromise) {
+    refreshIdentity = observedIdentity
     refreshPromise = coordinateCrossTabRefresh({
       lockName: 'cc-client-auth-refresh',
       observedRefreshToken,
       currentRefreshToken: getRefreshToken,
       reuseCurrentSession: async () => {
+        requireCurrentIdentity(observedIdentity)
         const currentAccessToken = getAccessToken()
         if (!currentAccessToken) throw new ApiError('登录已过期，请重新登录', 'A0401', 401)
         return currentAccessToken
       },
       refresh: async (currentRefreshToken) => {
-        const response = await transport.post<ApiEnvelope<TokenPair>>('/auth/refresh', { refreshToken: currentRefreshToken })
+        requireCurrentIdentity(observedIdentity)
-        const tokens = unwrap(response.data)
+        const exchange = { identity: observedIdentity!, refreshToken: currentRefreshToken, promise: transport.post<ApiEnvelope<TokenPair>>('/auth/refresh', { refreshToken: currentRefreshToken }).then(response => unwrap(response.data)) }
+        refreshExchange = exchange
+        let tokens: TokenPair
+        try { tokens = await exchange.promise } finally { if (refreshExchange === exchange) refreshExchange = null }
+        requireCurrentIdentity(observedIdentity)
+        requireCurrentIdentity(observedIdentity, tokens.accessToken)
         if (!getRefreshToken()) throw new ApiError('登录已在其他标签页退出', 'A0401', 401)
+        if (getRefreshToken() !== currentRefreshToken) throw new ApiError('登录状态已变化，请重新操作', 'SESSION_CHANGED')
         persistTokenPair(tokens)
+        if (typeof window !== 'undefined') window.dispatchEvent(new CustomEvent('cc-client-session-updated'))
         return tokens.accessToken
       },
     })
       .catch((error) => {
+        requireCurrentIdentity(observedIdentity)
         if (error instanceof CrossTabRefreshTimeoutError) {
+          if (getRefreshToken() && getRefreshToken() !== observedRefreshToken) throw new ApiError('登录状态已变化，请重新操作', 'SESSION_CHANGED')
           const expiredError = new ApiError(error.message, 'A0401', 401)
           clearSessionTokens()
           window.dispatchEvent(new CustomEvent('cc-client-session-expired'))
@@ -96,33 +125,60 @@ export async function refreshAuthenticatedSession() {
       })
       .finally(() => {
         refreshPromise = null
+        refreshIdentity = null
       })
   }
-  return refreshPromise
+  if (refreshIdentity !== observedIdentity) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+  const refreshed = await refreshPromise
+  requireCurrentIdentity(observedIdentity)
+  return refreshed
 }
 
 transport.interceptors.request.use((config) => {
   const token = getAccessToken()
-  if (token && !isPublicAuthRequest(config.url)) config.headers.Authorization = `Bearer ${token}`
+  const request = config as RetryableRequest
+  if (request._retriedAfterRefresh && !isPublicAuthRequest(config.url)) requireCurrentIdentity(request._sessionIdentity, token)
+  if (token && !isPublicAuthRequest(config.url)) {
+    if (!request._retriedAfterRefresh) {
+      request._sessionIdentity = accessTokenIdentity(token)
+      request._logoutGeneration = logoutGeneration
+    }
+    config.headers.Authorization = `Bearer ${token}`
+  }
   return config
 })
 
 transport.interceptors.response.use(
-  (response) => response,
+  (response) => {
+    const request = response.config as RetryableRequest
+    if (request._sessionIdentity) {
+      if (request._logoutGeneration !== logoutGeneration) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+      requireCurrentIdentity(request._sessionIdentity)
+    }
+    return response
+  },
   async (error: AxiosError) => {
     const request = error.config as RetryableRequest | undefined
     if (error.response?.status !== 401 || !request || request._retriedAfterRefresh || isPublicAuthRequest(request.url)) {
       throw mapError(error)
     }
 
+    if (request._logoutGeneration !== logoutGeneration) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+    requireCurrentIdentity(request._sessionIdentity)
     request._retriedAfterRefresh = true
+    const refreshTokenBeforeRetry = getRefreshToken()
     try {
       const accessToken = await refreshAuthenticatedSession()
+      if (request._logoutGeneration !== logoutGeneration) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+      requireCurrentIdentity(request._sessionIdentity)
       request.headers.Authorization = `Bearer ${accessToken}`
       return await transport.request(request)
     } catch (refreshError) {
+      if (request._logoutGeneration !== logoutGeneration) throw new ApiError('登录身份已变化，请重新操作', 'SESSION_CHANGED')
+      requireCurrentIdentity(request._sessionIdentity)
       const mappedError = mapError(refreshError)
       if (mappedError.status === 401 || mappedError.code === 'A0401') {
+        if (getRefreshToken() && getRefreshToken() !== refreshTokenBeforeRetry) throw mappedError
         clearSessionTokens()
         window.dispatchEvent(new CustomEvent('cc-client-session-expired'))
         redirectToLoginAfterSessionExpiry()
@@ -132,6 +188,33 @@ transport.interceptors.response.use(
   },
 )
 
+// Captured revocation never persists credentials or restores local login state.
+export async function revokeCapturedSession(accessToken: string, refreshToken: string) {
+  logoutGeneration++
+  const identity = accessTokenIdentity(accessToken)
+  if (!identity || !refreshToken) throw new ApiError('服务器会话注销未确认', 'SESSION_CHANGED')
+  const pending = refreshExchange?.identity === identity && refreshExchange.refreshToken === refreshToken ? refreshExchange.promise : null
+  const revoke = (pair: Pick<TokenPair, 'accessToken' | 'refreshToken'>) => apiRequest<void>({
+    method: 'POST', url: '/auth/logout', data: { refreshToken: pair.refreshToken },
+    headers: { Authorization: `Bearer ${pair.accessToken}` },
+  })
+  const validate = (pair: TokenPair) => {
+    if (accessTokenIdentity(pair.accessToken) !== identity || !pair.refreshToken) throw new ApiError('刷新身份不一致，服务器会话注销未确认', 'SESSION_CHANGED')
+    return pair
+  }
+  // An already sent refresh can rotate the pair. Consume its actual result
+  // without issuing a competing refresh or restoring it to local storage.
+  if (pending) {
+    await revoke(validate(await pending))
+    return
+  }
+  try { await revoke({ accessToken, refreshToken }) } catch (error) {
+    if (!(error instanceof ApiError) || error.status !== 401) throw error
+    const pair = await apiRequest<TokenPair>({ method: 'POST', url: '/auth/refresh', data: { refreshToken } })
+    await revoke(validate(pair))
+  }
+}
+
 export async function apiRequest<T>(config: AxiosRequestConfig) {
   try {
     const response = await transport.request<ApiEnvelope<T>>(config)
@@ -144,6 +227,7 @@ export async function apiRequest<T>(config: AxiosRequestConfig) {
 export async function apiBlobRequest(config: AxiosRequestConfig) {
   try {
     const response = await transport.request<Blob>({ ...config, responseType: 'blob' })
+    await throwBlobApiError(response.data, response.status)
     return response.data
   } catch (error) {
     await throwBlobApiError(error)
@@ -154,6 +238,7 @@ export async function apiBlobRequest(config: AxiosRequestConfig) {
 export async function apiBlobResponseRequest(config: AxiosRequestConfig) {
   try {
     const response = await transport.request<Blob>({ ...config, responseType: 'blob' })
+    await throwBlobApiError(response.data, response.status)
     return { blob: response.data, headers: response.headers }
   } catch (error) {
     await throwBlobApiError(error)
@@ -161,16 +246,19 @@ export async function apiBlobResponseRequest(config: AxiosRequestConfig) {
   }
 }
 
-async function throwBlobApiError(error: unknown) {
+async function throwBlobApiError(error: unknown, responseStatus?: number) {
-  if (!axios.isAxiosError(error) || !(error.response?.data instanceof Blob)) return
+  const blob = error instanceof Blob
+    ? error
+    : axios.isAxiosError(error) && error.response?.data instanceof Blob ? error.response.data : null
+  if (!blob || !blob.type.toLowerCase().includes('json')) return
   try {
-    const body = JSON.parse(await error.response.data.text()) as unknown
+    const body = JSON.parse(await blob.text()) as unknown
-    if (!isApiEnvelope(body)) return
+    if (!isApiEnvelope(body) && !isApiFailure(body)) return
-    const fieldErrors = asFieldErrors(body.data)
+    const fieldErrors = asFieldErrors(isApiEnvelope(body) ? body.data : undefined)
     throw new ApiError(
       apiErrorMessage(body.message, fieldErrors),
       body.code,
-      error.response.status,
+      responseStatus ?? (axios.isAxiosError(error) ? error.response?.status : undefined),
       fieldErrors,
       typeof body.traceId === 'string' ? body.traceId : null,
       typeof body.requestId === 'string' ? body.requestId : null,

src/api/overseasFailure.test.mjs

@@ -26,8 +26,8 @@ test('does not accept malformed or data-less successful responses', () => {
   assert.equal(isApiEnvelope({ code: '200', message: 'OK', data: [] }), true)
 })
 
-test('overseas transport handles business-code and HTTP security failures', async () => {
+test('unified transport handles business-code and HTTP security failures', async () => {
-  const transport = await readFile(new URL('./overseasHttp.ts', import.meta.url), 'utf8')
+  const transport = await readFile(new URL('./http.ts', import.meta.url), 'utf8')
-  assert.match(transport, /if \(isApiFailure\(response.data\)\)/)
+  assert.match(transport, /if \(isApiFailure\(invalid\)\)/)
   assert.match(transport, /isApiEnvelope\(body\) \|\| isApiFailure\(body\)/)
 })

src/api/overseasHttp.ts

@@ -1,67 +0,0 @@
-import axios, { type AxiosRequestConfig, type InternalAxiosRequestConfig } from 'axios'
-import { parseApiJsonResponse } from '@chongchong/shared'
-import { ApiError, isApiEnvelope, isApiFailure } from '@/api/types'
-import { getOverseasAccessToken } from '@/api/session'
-import { refreshAuthenticatedSession } from '@/api/http'
-
-interface RetryableRequest extends InternalAxiosRequestConfig { _retriedOverseasAuth?: boolean }
-
-const transport = axios.create({
-  baseURL: import.meta.env.VITE_OVERSEAS_API_BASE_URL || '/overseas-api',
-  timeout: 15_000,
-  transformResponse: [(data: unknown) => parseApiJsonResponse(data)],
-})
-
-async function requireToken() {
-  const current = getOverseasAccessToken()
-  if (current) return current
-  await refreshAuthenticatedSession()
-  const refreshed = getOverseasAccessToken()
-  if (!refreshed) throw new ApiError('当前环境未签发海外访问令牌', 'OVERSEAS_TOKEN_UNAVAILABLE')
-  return refreshed
-}
-
-transport.interceptors.request.use(async (config) => {
-  config.headers.Authorization = `Bearer ${await requireToken()}`
-  return config
-})
-
-transport.interceptors.response.use((response) => response, async (error) => {
-  const request = error.config as RetryableRequest | undefined
-  if (error.response?.status !== 401 || !request || request._retriedOverseasAuth) throw error
-  request._retriedOverseasAuth = true
-  await refreshAuthenticatedSession()
-  request.headers.Authorization = `Bearer ${await requireToken()}`
-  return transport.request(request)
-})
-
-export async function overseasApiRequest<T>(config: AxiosRequestConfig) {
-  try {
-    const response = await transport.request<unknown>(config)
-    if (isApiFailure(response.data)) {
-      throw new ApiError(response.data.message, response.data.code, response.status, undefined,
-        response.data.traceId, response.data.requestId)
-    }
-    if (!isApiEnvelope(response.data) || response.data.code !== '200') {
-      throw new ApiError(
-        isApiEnvelope(response.data) ? response.data.message : '海外接口响应格式错误',
-        isApiEnvelope(response.data) ? response.data.code : 'INVALID_RESPONSE',
-        undefined,
-        undefined,
-        isApiEnvelope(response.data) ? response.data.traceId : null,
-        isApiEnvelope(response.data) ? response.data.requestId : null,
-      )
-    }
-    return response.data.data as T
-  } catch (error) {
-    if (error instanceof ApiError) throw error
-    if (axios.isAxiosError(error)) {
-      const body = error.response?.data
-      if (isApiEnvelope(body) || isApiFailure(body)) {
-        throw new ApiError(body.message, body.code, error.response?.status, undefined, body.traceId, body.requestId)
-      }
-      throw new ApiError(error.code === 'ERR_NETWORK' ? '无法连接海外服务' : error.message, error.code || 'OVERSEAS_HTTP_ERROR', error.response?.status)
-    }
-    throw new ApiError(error instanceof Error ? error.message : '海外接口请求失败')
-  }
-}

src/api/session.test.mjs

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {
+  accessTokenIdentity,
   ACCESS_TOKEN_KEY,
   REFRESH_TOKEN_KEY,
   REMEMBERED_LOGIN_ID_KEY,
@@ -56,3 +57,34 @@ test('remembers only the login id and keeps it when session tokens are cleared',
   persistRememberedLoginId('merchant-user', false)
   assert.equal(getRememberedLoginId(), '')
 })
+
+test('normal token rotation never removes either shared token between writes', () => {
+  installStorage()
+  localStorage.setItem(ACCESS_TOKEN_KEY, 'old-access')
+  localStorage.setItem(REFRESH_TOKEN_KEY, 'old-refresh')
+  const removed = []
+  const remove = localStorage.removeItem
+  localStorage.removeItem = key => { removed.push(key); remove(key) }
+  persistTokenPair({ accessToken: 'new-access', refreshToken: 'new-refresh' })
+  assert.ok(!removed.includes(ACCESS_TOKEN_KEY))
+  assert.ok(!removed.includes(REFRESH_TOKEN_KEY))
+})
+
+function rawIdentity(overrides = '') {
+ return `test.${Buffer.from(`{"user_id":2107003446494334978,"tenant_id":2107003446494334978,"membership_id":2107003446494334978,"app_code":"MERCHANT"${overrides}}`).toString('base64url')}.test`
+}
+test('identity preserves low digits of numeric 19 digit user customer and membership',()=>{
+ const original=rawIdentity();const json=Buffer.from(original.split('.')[1],'base64url').toString();
+ for(const field of ['user_id','tenant_id','membership_id']){
+ const changed=json.replace(`"${field}":2107003446494334978`,`"${field}":2107003446494334979`)
+ assert.notEqual(accessTokenIdentity(original),accessTokenIdentity(`test.${Buffer.from(changed).toString('base64url')}.test`))
+ }
+})
+test('identity string and numeric integers are equivalent without changing other strings',()=>{
+ const a=rawIdentity();const raw=Buffer.from(a.split('.')[1],'base64url').toString();
+ const b=`test.${Buffer.from(raw.replaceAll(':2107003446494334978',':"2107003446494334978"')).toString('base64url')}.test`
+ assert.equal(accessTokenIdentity(a),accessTokenIdentity(b))
+ const decorated=rawIdentity(',"username":'+JSON.stringify('number 2107003446494334979 and "tenant_id":2107003446494334979')+',"note":"1234567890123456789"')
+ assert.equal(accessTokenIdentity(a),accessTokenIdentity(decorated))
+ assert.ok(accessTokenIdentity(a).includes('2107003446494334978'))
+})

src/api/session.ts

@@ -1,7 +1,5 @@
 export const ACCESS_TOKEN_KEY = 'cc-client-access-token'
 export const REFRESH_TOKEN_KEY = 'cc-client-refresh-token'
-export const OVERSEAS_ACCESS_TOKEN_KEY = 'cc-client-overseas-access-token'
-export const OVERSEAS_EXPIRES_AT_KEY = 'cc-client-overseas-expires-at'
 export const REMEMBERED_LOGIN_ID_KEY = 'cc-client-remembered-login-id'
 
 export interface TokenPair {
@@ -10,14 +8,8 @@ export interface TokenPair {
   expiresIn: number
   refreshToken: string
   refreshExpiresIn: number
-  overseasAccessToken?: string | null
-  overseasExpiresIn?: number
 }
 
-function activeStorage() {
-  if (localStorage.getItem(ACCESS_TOKEN_KEY)) return localStorage
-  return sessionStorage
-}
 
 export function getAccessToken() {
   return localStorage.getItem(ACCESS_TOKEN_KEY) || sessionStorage.getItem(ACCESS_TOKEN_KEY) || ''
@@ -27,21 +19,40 @@ export function getRefreshToken() {
   return localStorage.getItem(REFRESH_TOKEN_KEY) || sessionStorage.getItem(REFRESH_TOKEN_KEY) || ''
 }
 
-export function getOverseasAccessToken() {
+// Only binds a retry to its original identity; never grants permissions. Expired
-  const storage = activeStorage()
+// access tokens remain readable here because they are the normal refresh trigger.
-  const expiresAt = Number(storage.getItem(OVERSEAS_EXPIRES_AT_KEY) || 0)
+export function accessTokenIdentity(token: string): string | null {
-  if (expiresAt <= Date.now() + 30_000) return ''
+  try {
-  return storage.getItem(OVERSEAS_ACCESS_TOKEN_KEY) || ''
+    const encoded = token.split('.')[1]
+    if (!encoded) return null
+    const normalized = encoded.replace(/-/g, '+').replace(/_/g, '/')
+    const bytes = Uint8Array.from(atob(normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=')), character => character.charCodeAt(0))
+    const json = new TextDecoder().decode(bytes)
+    // Match whole JSON strings first so digits inside arbitrary string values
+    // are never rewritten. Preserve integer identity claims before JSON.parse
+    // can round them; number/string representations then share one identity.
+    const exactIdentityJson = json.replace(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g, (part, offset: number) => {
+      if (!/^-?\d+$/.test(part)) return part
+      const key = json.slice(0, offset).match(/"(user_id|tenant_id|membership_id|operator_tenant_id)"\s*:\s*$/)
+      return key ? JSON.stringify(part) : part
+    })
+    const value = JSON.parse(exactIdentityJson)
+    if (!value?.user_id || !value.tenant_id || !value.membership_id || value.app_code !== 'MERCHANT') return null
+    return JSON.stringify([value.user_id, value.tenant_id, value.membership_id, value.operator_tenant_id, value.app_code, value.client_type].map(item => item == null ? null : String(item)))
+  } catch {
+    return null
+  }
 }
 
+
 export function persistTokenPair(tokens: TokenPair) {
-  clearSessionTokens()
+  // Replace the pair without publishing a transient logout to other tabs.
+  sessionStorage.removeItem(ACCESS_TOKEN_KEY)
+  sessionStorage.removeItem(REFRESH_TOKEN_KEY)
+  sessionStorage.removeItem('cc-client-token')
+  localStorage.removeItem('cc-client-token')
   localStorage.setItem(ACCESS_TOKEN_KEY, tokens.accessToken)
   localStorage.setItem(REFRESH_TOKEN_KEY, tokens.refreshToken)
-  if (tokens.overseasAccessToken && Number(tokens.overseasExpiresIn) > 0) {
-    localStorage.setItem(OVERSEAS_ACCESS_TOKEN_KEY, tokens.overseasAccessToken)
-    localStorage.setItem(OVERSEAS_EXPIRES_AT_KEY, String(Date.now() + Number(tokens.overseasExpiresIn) * 1000))
-  }
 }
 
 export function getRememberedLoginId() {
@@ -62,8 +73,6 @@ export function clearSessionTokens() {
   for (const storage of [localStorage, sessionStorage]) {
     storage.removeItem(ACCESS_TOKEN_KEY)
     storage.removeItem(REFRESH_TOKEN_KEY)
-    storage.removeItem(OVERSEAS_ACCESS_TOKEN_KEY)
-    storage.removeItem(OVERSEAS_EXPIRES_AT_KEY)
     storage.removeItem('cc-client-token')
   }
 }

src/api/unifiedHttp.test.mjs

@@ -0,0 +1,222 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import axios from 'axios'
+
+function compile(name, dependencies = {}) {
+  const source = readFileSync(new URL(name, import.meta.url), 'utf8')
+    .replace('import.meta.env.VITE_API_BASE_URL', "'/api'")
+  const code = ts.transpileModule(source, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, esModuleInterop: true },
+  }).outputText
+  const exports = {}
+  new Function('require', 'exports', code)((id) => {
+    assert.ok(id in dependencies, `unexpected dependency ${id}`)
+    return dependencies[id]
+  }, exports)
+  return exports
+}
+
+function access(user, tenant = 1, membership = 1, nonce = 'original') {
+  return `test.${Buffer.from(JSON.stringify({ user_id: user, tenant_id: tenant, membership_id: membership, app_code: 'MERCHANT', nonce })).toString('base64url')}.test`
+}
+const oldAccess = access(1)
+const newAccess = access(1, 1, 1, 'rotated')
+const otherAccess = access(2, 2, 2)
+
+function harness(adapter) {
+  let token = oldAccess
+  let refreshToken = 'old-refresh'
+  const http = compile('./http.ts', {
+    axios: { ...axios, create: (config) => axios.create({ ...config, adapter }) },
+    '@chongchong/shared': { parseApiJsonResponse: (data) => data },
+    '@/api/session': {
+      accessTokenIdentity: compile('./session.ts').accessTokenIdentity,
+      getAccessToken: () => token, getRefreshToken: () => refreshToken,
+      persistTokenPair: (tokens) => { token = tokens.accessToken; refreshToken = tokens.refreshToken },
+      clearSessionTokens: () => { token = ''; refreshToken = '' },
+    },
+    '@/api/errorDetails': compile('./errorDetails.ts'),
+    '@/api/types': compile('./types.ts'),
+    '@/api/crossTabRefresh': compile('./crossTabRefresh.ts'),
+  })
+  return { ...http, setSession: (access, refresh) => { token = access; refreshToken = refresh }, session: () => ({ token, refreshToken }) }
+}
+
+test('order and lastleg 401s share one refresh and replay the unified access token', async () => {
+  let refreshes = 0
+  const calls = []
+  const http = harness(async (config) => {
+    calls.push({ url: config.url, base: config.baseURL, token: config.headers.Authorization })
+    if (config.url === '/auth/refresh') {
+      refreshes++
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data: { accessToken: newAccess, refreshToken: 'new-refresh' } } }
+    }
+    if (config.headers.Authorization === `Bearer ${oldAccess}`) {
+      throw new axios.AxiosError('Expired', 'ERR_BAD_REQUEST', config, null, { status: 401, data: { code: 'A0401', message: 'Expired' } })
+    }
+    return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data: config.url } }
+  })
+  const urls = ['/merchant/v1/orders', '/merchant/v1/last-leg/inbound-plans']
+  assert.deepEqual(await Promise.all(urls.map((url) => http.apiRequest({ url }))), urls)
+  assert.equal(refreshes, 1)
+  assert.ok(calls.every((call) => call.base === '/api'))
+  assert.equal(calls.find((call) => call.url === '/auth/refresh').token, undefined)
+  assert.equal(calls.filter((call) => call.token === `Bearer ${newAccess}`).length, 2)
+})
+
+test('successful order submit with explicit null data is accepted', async () => {
+  const http = harness(async (config) => ({
+    config, status: 200, headers: {}, data: { code: '200', message: 'success', data: null },
+  }))
+  assert.equal(await http.apiRequest({ method: 'POST', url: '/merchant/v1/orders/first-leg/order-1/submit' }), null)
+})
+
+test('data-less security failures preserve diagnostics and malformed success is rejected', async () => {
+  for (const data of [{ code: 'A0403', message: 'Denied', traceId: 'trace-1', requestId: 'request-1' }, { code: '200', message: 'OK' }]) {
+    const http = harness(async (config) => ({ config, status: 200, headers: {}, data }))
+    await assert.rejects(http.apiRequest({ url: '/merchant/v1/last-leg/inbound-plans' }), (error) => {
+      assert.equal(error.code, data.code === '200' ? 'INVALID_RESPONSE' : 'A0403')
+      if (data.code !== '200') { assert.equal(error.traceId, 'trace-1'); assert.equal(error.requestId, 'request-1') }
+      return true
+    })
+  }
+})
+
+test('late refresh response cannot overwrite a session changed in another tab', async () => {
+  let complete, started
+  const ready = new Promise(resolve => { started = resolve })
+  const response = new Promise(resolve => { complete = resolve })
+  const http = harness(async config => { started(); await response; return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data: { accessToken: oldAccess, refreshToken: 'stale-refresh' } } } })
+  const pending = http.refreshAuthenticatedSession()
+  await ready
+  http.setSession(otherAccess, 'other-refresh')
+  complete()
+  await pending.catch(error => assert.equal(error.code, 'SESSION_CHANGED'))
+  assert.deepEqual(http.session(), { token: otherAccess, refreshToken: 'other-refresh' })
+})
+
+function deferred() { let resolve; const promise = new Promise(yes => { resolve = yes }); return { promise, resolve } }
+
+function unauthorized(config) {
+  return new axios.AxiosError('Expired', 'ERR_BAD_REQUEST', config, null, { status: 401, data: { code: 'A0401', message: 'Expired' } })
+}
+
+test('late A write 401 after user, customer or membership switch never refreshes or replays under B', async () => {
+  for (const next of [access(2), access(1, 2), access(1, 1, 2)]) {
+    const sent = deferred(), release = deferred(), calls = []
+    const http = harness(async config => {
+      calls.push(config.url); sent.resolve(); await release.promise
+      throw unauthorized(config)
+    })
+    const pending = http.apiRequest({ method: 'POST', url: '/merchant/v1/orders/first-leg/one/submit', data: { expectedVersion: 1 } })
+    const rejected = assert.rejects(pending, error => error.code === 'SESSION_CHANGED')
+    await sent.promise; http.setSession(next, 'refresh-b'); release.resolve(); await rejected
+    assert.deepEqual(calls, ['/merchant/v1/orders/first-leg/one/submit'])
+    assert.deepEqual(http.session(), { token: next, refreshToken: 'refresh-b' })
+  }
+})
+
+test('switch during in-flight refresh cannot reuse B token to replay an A write', async () => {
+  const refreshing = deferred(), release = deferred(), calls = []
+  const http = harness(async config => {
+    calls.push(config.url)
+    if (config.url === '/auth/refresh') {
+      refreshing.resolve(); await release.promise
+      return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data: { accessToken: newAccess, refreshToken: 'new-refresh' } } }
+    }
+    throw unauthorized(config)
+  })
+  const pending = http.apiRequest({ method: 'POST', url: '/merchant/v1/orders/first-leg/one/submit' })
+  const rejected = assert.rejects(pending, error => error.code === 'SESSION_CHANGED')
+  await refreshing.promise; http.setSession(otherAccess, 'refresh-b'); release.resolve(); await rejected
+  assert.deepEqual(calls, ['/merchant/v1/orders/first-leg/one/submit', '/auth/refresh'])
+  assert.deepEqual(http.session(), { token: otherAccess, refreshToken: 'refresh-b' })
+})
+
+test('refresh lock wait reuses same-identity rotation but rejects changed-identity reuse', async t => {
+  const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator')
+  t.after(() => { if (originalNavigator) Object.defineProperty(globalThis, 'navigator', originalNavigator); else delete globalThis.navigator })
+  for (const next of [newAccess, otherAccess]) {
+    const waiting = deferred(), release = deferred(), calls = []
+    Object.defineProperty(globalThis, 'navigator', { configurable: true, value: { locks: { request: async (_name, _options, run) => {
+      waiting.resolve(); await release.promise; return run()
+    } } } })
+    const http = harness(async config => {
+      calls.push({ url: config.url, authorization: config.headers.Authorization })
+      if (config.headers.Authorization === `Bearer ${oldAccess}`) throw unauthorized(config)
+      return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data: null } }
+    })
+    const pending = http.apiRequest({ method: 'POST', url: '/merchant/v1/orders/first-leg/one/submit' })
+    const outcome = next === otherAccess ? assert.rejects(pending, error => error.code === 'SESSION_CHANGED') : pending
+    await waiting.promise; http.setSession(next, 'rotated-refresh'); release.resolve(); await outcome
+    assert.equal(calls.some(call => call.url === '/auth/refresh'), false)
+    assert.equal(calls.length, next === otherAccess ? 1 : 2)
+    assert.deepEqual(http.session(), { token: next, refreshToken: 'rotated-refresh' })
+  }
+})
+
+function authApi(http) { return compile('../modules/auth/api/auth.ts', { '@/api/http': http }) }
+function ok(config, data = null) { return { config, status: 200, headers: {}, data: { code: '200', message: 'OK', data } } }
+test('logout after immediate local clear revokes captured Bearer and Refresh', async () => {
+  const calls=[]; const http=harness(async c=>{calls.push(c);return ok(c)})
+  http.setSession('', '');await authApi(http).logoutMerchant(oldAccess,'old-refresh')
+  assert.equal(calls.length,1);assert.equal(calls[0].headers.Authorization,`Bearer ${oldAccess}`)
+  assert.deepEqual(JSON.parse(calls[0].data),{refreshToken:'old-refresh'});assert.deepEqual(http.session(),{token:'',refreshToken:''})
+})
+test('only explicit logout401 refreshes once and revokes same-identity replacement without storing it', async () => {
+  const calls=[];const http=harness(async c=>{calls.push(c);if(c.url==='/auth/refresh')return ok(c,{accessToken:newAccess,refreshToken:'new-refresh'});if(c.headers.Authorization===`Bearer ${oldAccess}`)throw unauthorized(c);return ok(c)})
+  http.setSession('','');await authApi(http).logoutMerchant(oldAccess,'old-refresh')
+  assert.deepEqual(calls.map(x=>x.url),['/auth/logout','/auth/refresh','/auth/logout']);assert.equal(calls[2].headers.Authorization,`Bearer ${newAccess}`);assert.equal(JSON.parse(calls[2].data).refreshToken,'new-refresh');assert.deepEqual(http.session(),{token:'',refreshToken:''})
+})
+test('unknown logout failure never refreshes; changed identity cannot be revoked as replacement', async () => {
+  for(const mode of ['network','wrongIdentity','second401']){const calls=[];const http=harness(async c=>{calls.push(c);if(mode==='network')throw new axios.AxiosError('offline',axios.AxiosError.ERR_NETWORK,c);if(c.url==='/auth/refresh')return ok(c,{accessToken:mode==='wrongIdentity'?otherAccess:newAccess,refreshToken:'replacement'});throw unauthorized(c)})
+    http.setSession('','');await assert.rejects(authApi(http).logoutMerchant(oldAccess,'old-refresh'));assert.equal(calls.length,mode==='network'?1:mode==='wrongIdentity'?2:3);assert.deepEqual(http.session(),{token:'',refreshToken:''})}
+})
+test('logout consumes already inflight refresh once while old business caller cannot revive session',async()=>{
+ const started=deferred(),release=deferred(),calls=[];const http=harness(async c=>{calls.push(c);if(c.url==='/auth/refresh'){started.resolve();await release.promise;return ok(c,{accessToken:newAccess,refreshToken:'new-refresh'})}return ok(c)})
+ const refreshing=http.refreshAuthenticatedSession();const rejected=assert.rejects(refreshing,e=>e.code==='SESSION_CHANGED');await started.promise
+ const leaving=authApi(http).logoutMerchant(oldAccess,'old-refresh');http.setSession('','');release.resolve();await leaving;await rejected
+ assert.deepEqual(calls.map(x=>x.url),['/auth/refresh','/auth/logout']);assert.equal(calls[1].headers.Authorization,`Bearer ${newAccess}`);assert.deepEqual(http.session(),{token:'',refreshToken:''})
+})
+test('late successful business response after logout rejects even after same-identity new login',async()=>{
+ const started=deferred(),release=deferred();const http=harness(async c=>{if(c.url==='/merchant/v1/orders'){started.resolve();await release.promise}return ok(c,'old-data')})
+ const pending=http.apiRequest({url:'/merchant/v1/orders'});const rejected=assert.rejects(pending,e=>e.code==='SESSION_CHANGED');await started.promise
+ await authApi(http).logoutMerchant(oldAccess,'old-refresh');http.setSession(newAccess,'new-login-refresh');release.resolve();await rejected;assert.equal(http.session().refreshToken,'new-login-refresh')
+})
+
+test('inflight refresh unknown outcome stops logout without competing retry and preserves later login',async()=>{
+ const started=deferred(),release=deferred(),calls=[];const http=harness(async c=>{calls.push(c);started.resolve();await release.promise;throw new axios.AxiosError('offline',axios.AxiosError.ERR_NETWORK,c)})
+ const refreshing=http.refreshAuthenticatedSession();const rejected=assert.rejects(refreshing);await started.promise
+ const leaving=authApi(http).logoutMerchant(oldAccess,'old-refresh');const failure=assert.rejects(leaving,e=>e.code==='NETWORK_ERROR');http.setSession(otherAccess,'other-refresh');release.resolve();await failure;await rejected
+ assert.equal(calls.length,1);assert.deepEqual(http.session(),{token:otherAccess,refreshToken:'other-refresh'})
+})
+test('logout401 refresh and replacement revocation cannot overwrite later login',async()=>{
+ const started=deferred(),release=deferred(),calls=[];const http=harness(async c=>{calls.push(c);if(c.url==='/auth/refresh'){started.resolve();await release.promise;return ok(c,{accessToken:newAccess,refreshToken:'new-refresh'})}if(c.headers.Authorization===`Bearer ${oldAccess}`)throw unauthorized(c);return ok(c)})
+ const leaving=authApi(http).logoutMerchant(oldAccess,'old-refresh');http.setSession('','');await started.promise;http.setSession(otherAccess,'other-refresh');release.resolve();await leaving
+ assert.equal(calls[2].headers.Authorization,`Bearer ${newAccess}`);assert.deepEqual(http.session(),{token:otherAccess,refreshToken:'other-refresh'})
+})
+test('late old business401 after logout does not refresh or replay under same-identity new login',async()=>{
+ const started=deferred(),release=deferred(),calls=[];const http=harness(async c=>{calls.push(c);if(c.url==='/merchant/v1/orders/first-leg/one/submit'){started.resolve();await release.promise;throw unauthorized(c)}return ok(c)})
+ const request=http.apiRequest({method:'POST',url:'/merchant/v1/orders/first-leg/one/submit'});const rejected=assert.rejects(request,e=>e.code==='SESSION_CHANGED');await started.promise;await authApi(http).logoutMerchant(oldAccess,'old-refresh');http.setSession(newAccess,'new-login-refresh');release.resolve();await rejected
+ assert.deepEqual(calls.map(x=>x.url),['/merchant/v1/orders/first-leg/one/submit','/auth/logout']);assert.equal(http.session().refreshToken,'new-login-refresh')
+})
+
+test('same identity new pair logout does not adopt another session inflight refresh',async()=>{
+ const started=deferred(),release=deferred(),calls=[];const http=harness(async c=>{calls.push(c);if(c.url==='/auth/refresh'){started.resolve();await release.promise;return ok(c,{accessToken:newAccess,refreshToken:'old-session-rotated'})}return ok(c)})
+ const refreshing=http.refreshAuthenticatedSession();const rejected=assert.rejects(refreshing);await started.promise;http.setSession(newAccess,'new-login-refresh')
+ const leaving=authApi(http).logoutMerchant(newAccess,'new-login-refresh');http.setSession('','');await leaving
+ assert.equal(calls[1].headers.Authorization,`Bearer ${newAccess}`);assert.equal(JSON.parse(calls[1].data).refreshToken,'new-login-refresh');release.resolve();await rejected;assert.deepEqual(http.session(),{token:'',refreshToken:''})
+})
+
+test('logout rejects refreshed 19 digit identity differing only in low digit',async()=>{
+ const raw='{"user_id":2107003446494334978,"tenant_id":2107003446494334978,"membership_id":2107003446494334978,"app_code":"MERCHANT"}'
+ const original=`test.${Buffer.from(raw).toString('base64url')}.test`
+ for(const field of ['user_id','tenant_id','membership_id']){
+  const changed=raw.replace(`"${field}":2107003446494334978`,`"${field}":2107003446494334979`),calls=[]
+  const http=harness(async c=>{calls.push(c);if(c.url==='/auth/refresh')return ok(c,{accessToken:`test.${Buffer.from(changed).toString('base64url')}.test`,refreshToken:'replacement'});throw unauthorized(c)})
+  http.setSession('','');await assert.rejects(authApi(http).logoutMerchant(original,'original-refresh'),e=>e.code==='SESSION_CHANGED');assert.equal(calls.length,2)
+ }
+})

src/components.d.ts

@@ -22,9 +22,9 @@ declare module 'vue' {
     ElCard: typeof import('element-plus/es')['ElCard']
     ElCheckbox: typeof import('element-plus/es')['ElCheckbox']
     ElCheckboxGroup: typeof import('element-plus/es')['ElCheckboxGroup']
+    ElCollapse: typeof import('element-plus/es')['ElCollapse']
+    ElCollapseItem: typeof import('element-plus/es')['ElCollapseItem']
     ElDatePicker: typeof import('element-plus/es')['ElDatePicker']
-    ElDescriptions: typeof import('element-plus/es')['ElDescriptions']
-    ElDescriptionsItem: typeof import('element-plus/es')['ElDescriptionsItem']
     ElDialog: typeof import('element-plus/es')['ElDialog']
     ElDrawer: typeof import('element-plus/es')['ElDrawer']
     ElDropdown: typeof import('element-plus/es')['ElDropdown']
@@ -33,6 +33,7 @@ declare module 'vue' {
     ElEmpty: typeof import('element-plus/es')['ElEmpty']
     ElForm: typeof import('element-plus/es')['ElForm']
     ElFormItem: typeof import('element-plus/es')['ElFormItem']
+    ElImage: typeof import('element-plus/es')['ElImage']
     ElInput: typeof import('element-plus/es')['ElInput']
     ElInputNumber: typeof import('element-plus/es')['ElInputNumber']
     ElOption: typeof import('element-plus/es')['ElOption']
@@ -41,6 +42,7 @@ declare module 'vue' {
     ElRadio: typeof import('element-plus/es')['ElRadio']
     ElRadioButton: typeof import('element-plus/es')['ElRadioButton']
     ElRadioGroup: typeof import('element-plus/es')['ElRadioGroup']
+    ElResult: typeof import('element-plus/es')['ElResult']
     ElSelect: typeof import('element-plus/es')['ElSelect']
     ElSkeleton: typeof import('element-plus/es')['ElSkeleton']
     ElSwitch: typeof import('element-plus/es')['ElSwitch']

src/components/ClientSidebarMenu.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import ClientSidebarMenuNode from '@/components/ClientSidebarMenuNode.vue'
 import {
   clientNavigation,
@@ -7,6 +7,7 @@ import {
   getNavigationParentKeys,
 } from '@/navigation/clientNavigation'
 import { useAuthStore } from '@/modules/auth/public'
+import { useCustomsPendingStore } from '@/modules/first-leg/public'
 
 const props = defineProps<{
   activePath: string
@@ -16,14 +17,34 @@ const emit = defineEmits<{
   navigate: [path: string]
 }>()
 const auth = useAuthStore()
+const customsPending = useCustomsPendingStore()
+const badges = computed(() => ({ 'first-leg-customs-documents': { count: customsPending.count, error: customsPending.error } }))
+watch(() => auth.isAuthenticated && auth.hasPermission('order:first-leg:customs-list') ? auth.user?.id ?? '' : '', scope => {
+  customsPending.setScope(scope)
+  if (scope) void customsPending.refresh()
+}, { immediate: true, flush: 'sync' })
+function refreshCustomsPending() {
+  if (document.visibilityState === 'visible') void customsPending.refresh()
+}
+let refreshTimer: ReturnType<typeof setInterval> | undefined
+onMounted(() => {
+  refreshTimer = setInterval(refreshCustomsPending, 60_000)
+  window.addEventListener('focus', refreshCustomsPending)
+  document.addEventListener('visibilitychange', refreshCustomsPending)
+})
+onBeforeUnmount(() => {
+  clearInterval(refreshTimer)
+  window.removeEventListener('focus', refreshCustomsPending)
+  document.removeEventListener('visibilitychange', refreshCustomsPending)
+  customsPending.setScope('')
+})
+
 const visibleNavigation = computed(() => filterNavigationByPermissions(clientNavigation, auth.permissionCodes))
 
 const activeParentKeys = computed(() => new Set(getNavigationParentKeys(visibleNavigation.value, props.activePath)))
 const openedKeys = ref<ReadonlySet<string>>(new Set(activeParentKeys.value))
 
 function handleToggle(key: string) {
-  if (activeParentKeys.value.has(key)) return
-
   const next = new Set(openedKeys.value)
   if (next.has(key)) next.delete(key)
   else next.add(key)
@@ -49,6 +70,7 @@ function handleSelect(path: string) {
       v-for="node in visibleNavigation"
       :key="node.key"
       :node="node"
+      :badges="badges"
       :active-path="activePath"
       :opened-keys="openedKeys"
       :active-parent-keys="activeParentKeys"

src/components/ClientSidebarMenuNode.vue

@@ -8,6 +8,7 @@ const props = defineProps<{
   activePath: string
   openedKeys: ReadonlySet<string>
   activeParentKeys: ReadonlySet<string>
+  badges?: Readonly<Record<string, { count: number | null; error: string }>>
   level?: number
 }>()
 
@@ -16,6 +17,9 @@ const emit = defineEmits<{
   toggle: [key: string]
 }>()
 
+const badge = computed(() => props.badges?.[props.node.key])
+const badgeTitle = computed(() => badge.value?.error || `${badge.value?.count ?? 0} 个柜次待上传资料或确认回执`)
+
 const groupId = computed(() => `client-nav-group-${props.node.key}`)
 </script>
 
@@ -54,6 +58,7 @@ const groupId = computed(() => `client-nav-group-${props.node.key}`)
         v-for="child in node.children"
         :key="child.key"
         :node="child"
+        :badges="badges"
         :active-path="activePath"
         :opened-keys="openedKeys"
         :active-parent-keys="activeParentKeys"
@@ -78,6 +83,14 @@ const groupId = computed(() => `client-nav-group-${props.node.key}`)
         aria-hidden="true"
       />
       <span>{{ node.title }}</span>
+      <span v-if="badge?.error || (badge?.count != null && badge.count > 0)" class="client-nav-badge"
+        :title="badgeTitle" :aria-label="badgeTitle" role="status">
+        {{ badge?.error ? '!' : badge!.count! > 99 ? '99+' : badge?.count }}
+      </span>
     </RouterLink>
   </li>
 </template>
+
+<style scoped>
+.client-sidebar-link .client-nav-badge { display: inline-flex; flex: 0 0 auto; min-width: 23px; height: 23px; align-items: center; justify-content: center; margin-left: auto; padding: 0 5px; border: 2px solid #fff; border-radius: 999px; background: #ef4444; color: #fff; box-shadow: 0 3px 9px rgb(239 68 68 / 24%); font-size: 12px; font-weight: 700; line-height: 1; }
+</style>

src/components/common/DataTable.test.mjs

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+import { parse, compileScript } from 'vue/compiler-sfc'
+import ts from 'typescript'
+import * as vue from 'vue'
+
+const source = readFileSync(new URL('./DataTable.vue', import.meta.url), 'utf8')
+
+function paginationHarness(t) {
+  const descriptor = parse(source).descriptor
+  const compiled = compileScript(descriptor, { id: 'data-table-pagination-test' })
+  const code = ts.transpileModule(compiled.content, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+  const exports = {}
+  const deps = { vue, '@lucide/vue': { ChevronLeft: {}, ChevronRight: {} }, './tableActions': {} }
+  new Function('require', 'exports', code)(id => { assert.ok(id in deps, id); return deps[id] }, exports)
+  const component = exports.default
+  component.render = () => null
+  const state = vue.reactive({ page: 5, total: 5542, loading: false, error: false })
+  const emitted = []
+  const renderer = vue.createRenderer({
+    createElement: tag => ({ tag }), createText: text => ({ text }), createComment: text => ({ text }),
+    insert() {}, remove() {}, setElementText() {}, setText() {}, patchProp() {},
+    parentNode: () => null, nextSibling: () => null,
+  })
+  const app = renderer.createApp({ render: () => vue.h(component, {
+    data: [], columns: [], page: state.page, pageSize: 50, total: state.total, loading: state.loading,
+    'onUpdate:page': value => { emitted.push(value); state.page = value },
+  }, state.error ? { error: () => vue.h('div', 'Request failed') } : {}) })
+  app.mount({})
+  t.after(() => app.unmount())
+  return { state, emitted }
+}
+
+test('server-page loading must not reset the requested page when total temporarily clears', async t => {
+  const { state, emitted } = paginationHarness(t)
+  state.loading = true; state.total = 0
+  await vue.nextTick()
+  assert.equal(state.page, 5)
+  assert.deepEqual(emitted, [])
+  state.total = 5542; state.loading = false
+  await vue.nextTick()
+  assert.equal(state.page, 5)
+  assert.deepEqual(emitted, [])
+})
+
+test('failed server page retains its page for explicit retry and emits no automatic fallback request', async t => {
+  const { state, emitted } = paginationHarness(t)
+  state.loading = true; state.total = 0
+  await vue.nextTick()
+  state.error = true; state.loading = false
+  await vue.nextTick()
+  assert.equal(state.page, 5)
+  assert.deepEqual(emitted, [])
+  state.error = false; state.loading = true
+  await vue.nextTick()
+  state.total = 5542; state.loading = false
+  await vue.nextTick()
+  assert.equal(state.page, 5)
+  assert.deepEqual(emitted, [])
+})
+
+test('settled successful totals still clamp out-of-range and empty pages', async t => {
+  const { state, emitted } = paginationHarness(t)
+  state.total = 120
+  await vue.nextTick()
+  assert.equal(state.page, 3)
+  state.total = 0
+  await vue.nextTick()
+  assert.equal(state.page, 1)
+  assert.deepEqual(emitted, [3, 1])
+})
+
+test('keeps action-only table toolbars on the left', () => {
+  assert.match(source, /'data-table__toolbar--actions-only': !\$slots\.toolbar/)
+  assert.match(source, /v-if="\$slots\.toolbar" class="data-table__toolbar-heading"/)
+  assert.match(source, /\.data-table__toolbar--actions-only \{ justify-content: flex-start; \}/)
+})

src/components/common/DataTable.vue

@@ -88,7 +88,9 @@ watch([pageSize, normalizedPageSizes], ([value, sizes]) => {
   page.value = 1
 }, { immediate: true })
 
-watch([page, pageCount], ([value, count]) => {
+watch([page, pageCount, () => props.loading, () => Boolean(slots.error)], ([value, count, loading, hasError]) => {
+  // A cleared total is not an authoritative page count while loading or showing a request error.
+  if (loading || hasError) return
   const nextValue = normalizePage(value, count)
   if (value !== nextValue) page.value = nextValue
 }, { immediate: true })
@@ -143,8 +145,8 @@ function setPage(value: number) {
 
 <template>
   <div class="data-table" :class="$attrs.class">
-    <header v-if="$slots.toolbar || $slots['toolbar-actions']" class="data-table__toolbar">
+    <header v-if="$slots.toolbar || $slots['toolbar-actions']" class="data-table__toolbar" :class="{ 'data-table__toolbar--actions-only': !$slots.toolbar }">
-      <div class="data-table__toolbar-heading"><slot name="toolbar" /></div>
+      <div v-if="$slots.toolbar" class="data-table__toolbar-heading"><slot name="toolbar" /></div>
       <div class="data-table__toolbar-actions"><slot name="toolbar-actions" /></div>
     </header>
     <slot name="before-table" />
@@ -163,7 +165,7 @@ function setPage(value: number) {
         </template>
         <template v-if="column.slotName === 'actions' && rowActions" #default="{ row }">
           <div class="data-table__row-actions">
-            <el-button v-for="action in splitTableActions(rowActions(row)).visible" :key="action.key"
+            <el-button v-for="action in splitTableActions(rowActions(row)).visible" :key="action.key" link type="primary"
               :disabled="action.disabled" :loading="action.loading" @click="runTableAction(action)">
               {{ action.label }}
             </el-button>
@@ -227,14 +229,17 @@ function setPage(value: number) {
 <style scoped>
 .data-table { min-width: 0; }
 .data-table__toolbar { display: flex; min-height: 48px; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: var(--client-gap); padding: var(--client-toolbar-padding); border-bottom: 1px solid var(--client-border); }
+.data-table__toolbar--actions-only { justify-content: flex-start; }
 .data-table__toolbar-heading, .data-table__toolbar-actions { display: flex; align-items: center; flex-wrap: wrap; gap: var(--client-gap); }
 .data-table__toolbar-heading { color: var(--client-muted); font-size: 12px; }
 .data-table__toolbar-heading :slotted(strong) { color: var(--client-text); font-size: 14px; }
 .data-table__toolbar-actions :deep(.el-button + .el-button) { margin-left: 0; }
 .data-table__row-actions { display: flex; align-items: center; gap: var(--client-gap); white-space: nowrap; }
-.data-table__row-actions :deep(.el-button) { height: var(--client-row-action-height); padding: 0 8px; margin: 0; }
+.data-table__row-actions :deep(.el-button) { height: var(--client-row-action-height); padding: 0 4px; margin: 0; }
+.data-table__row-actions :deep(.el-button.is-link + .el-button.is-link) { position: relative; }
+.data-table__row-actions :deep(.el-button.is-link + .el-button.is-link)::before { position: absolute; left: -5px; width: 1px; height: 12px; background: var(--client-border); content: ''; }
 .data-table :deep(.data-table__system-cell .data-table__row-actions .el-button + .el-button), .data-table :deep(.data-table__system-cell .data-table__row-actions .el-button + .el-dropdown) { margin-left: 0; }
-.data-table__more { min-width: 28px; }
+.data-table__more { min-width: 28px; width: 28px; padding: 0; }
 :global(.client-ui .data-table .el-table) { color: var(--client-text); font-size: var(--client-font-size); --el-table-border-color: var(--client-border); --el-table-header-bg-color: var(--client-header-bg); --el-table-row-hover-bg-color: var(--client-hover-bg); }
 :global(.client-ui .data-table th.el-table__cell) { height: var(--client-table-header-height); padding: 0; color: var(--client-muted); font-weight: 600; }
 :global(.client-ui .data-table td.el-table__cell) { height: var(--client-table-row-height); padding: 0; }

src/components/common/QueryToolbar.vue

@@ -121,8 +121,8 @@ defineExpose({ search, reset })
       </label>
     </div>
     <div class="query-toolbar__actions">
-      <el-button type="primary" @click="search"><Search :size="16" />{{ searchText }}</el-button>
+      <el-button class="query-toolbar__search" type="primary" @click="search"><Search :size="16" />{{ searchText }}</el-button>
-      <el-button @click="reset"><RotateCcw :size="16" />{{ resetText }}</el-button>
+      <el-button class="query-toolbar__reset" @click="reset"><RotateCcw :size="16" />{{ resetText }}</el-button>
       <slot name="actions" />
     </div>
   </section>
@@ -136,6 +136,7 @@ defineExpose({ search, reset })
 .query-toolbar__filters :deep(.el-input), .query-toolbar__filters :deep(.el-select), .query-toolbar__filters :deep(.el-date-editor) { width: 260px; max-width: 100%; min-width: 0; }
 .query-toolbar__actions { display: flex; flex: 0 0 auto; flex-wrap: wrap; justify-content: flex-start; gap: 8px; }
 .query-toolbar__actions :deep(.el-button + .el-button) { margin-left: 0; }
+.query-toolbar__actions :deep(.query-toolbar__search), .query-toolbar__actions :deep(.query-toolbar__reset) { min-width: 72px; }
 .query-toolbar--grid { display: block; padding: var(--client-query-padding); border: 1px solid var(--client-border); border-radius: var(--client-radius); }
 .query-toolbar--grid .query-toolbar__filters { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px 16px; }
 .query-toolbar--grid .query-toolbar__field { min-width: 0; }

src/core/staticAssetRecovery.test.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+
+const recoverySource = readFileSync(new URL('./staticAssetRecovery.ts', import.meta.url), 'utf8')
+const mainSource = readFileSync(new URL('../main.ts', import.meta.url), 'utf8')
+
+test('refreshes once when a deployment invalidates lazy chunks or same-origin scripts and styles', () => {
+  assert.match(mainSource, /installStaticAssetRecovery\(router\)/)
+  assert.match(recoverySource, /vite:preloadError/)
+  assert.match(recoverySource, /router\.onError/)
+  assert.match(recoverySource, /HTMLScriptElement/)
+  assert.match(recoverySource, /HTMLLinkElement/)
+  assert.match(recoverySource, /window\.location\.reload\(\)/)
+  assert.match(recoverySource, /RECOVERY_COOLDOWN_MS/)
+  assert.match(recoverySource, /previous\?\.href === window\.location\.href/)
+})
+
+test('does not turn ordinary application errors or third-party asset failures into refresh loops', () => {
+  assert.match(recoverySource, /isStaticAssetLoadError\(error\)/)
+  assert.match(recoverySource, /origin !== window\.location\.origin/)
+  assert.match(recoverySource, /sessionStorage/)
+  assert.match(recoverySource, /setTimeout\(clearRecoveryRecord, RECOVERY_STABLE_MS\)/)
+})

src/core/staticAssetRecovery.ts

@@ -0,0 +1,91 @@
+import type { Router } from 'vue-router'
+
+const RECOVERY_KEY = 'client-static-asset-recovery'
+const RECOVERY_COOLDOWN_MS = 60_000
+const RECOVERY_STABLE_MS = 15_000
+
+interface RecoveryRecord {
+  href: string
+  refreshedAt: number
+}
+
+function errorMessage(error: unknown) {
+  if (error instanceof Error) return `${error.name}: ${error.message}`
+  return typeof error === 'string' ? error : ''
+}
+
+export function isStaticAssetLoadError(error: unknown) {
+  return /ChunkLoadError|Loading chunk [\w-]+ failed|Failed to fetch dynamically imported module|Importing a module script failed|error loading dynamically imported module|Unable to preload CSS/i.test(errorMessage(error))
+}
+
+function readRecoveryRecord(): RecoveryRecord | null {
+  try {
+    const raw = window.sessionStorage.getItem(RECOVERY_KEY)
+    if (!raw) return null
+    const value = JSON.parse(raw) as Partial<RecoveryRecord>
+    return typeof value.href === 'string' && typeof value.refreshedAt === 'number'
+      ? { href: value.href, refreshedAt: value.refreshedAt }
+      : null
+  } catch {
+    return null
+  }
+}
+
+function writeRecoveryRecord(record: RecoveryRecord) {
+  try {
+    window.sessionStorage.setItem(RECOVERY_KEY, JSON.stringify(record))
+    return true
+  } catch {
+    // Without a persistent guard, reloading could loop while the deployment is still unavailable.
+    return false
+  }
+}
+
+function clearRecoveryRecord() {
+  try {
+    window.sessionStorage.removeItem(RECOVERY_KEY)
+  } catch {
+    // Storage availability must not affect application startup.
+  }
+}
+
+function recoverFromStaticAssetFailure(error: unknown, confirmedAssetFailure = false) {
+  if (!confirmedAssetFailure && !isStaticAssetLoadError(error)) return false
+  const now = Date.now()
+  const previous = readRecoveryRecord()
+  if (previous?.href === window.location.href && now - previous.refreshedAt < RECOVERY_COOLDOWN_MS) return false
+  if (!writeRecoveryRecord({ href: window.location.href, refreshedAt: now })) return false
+  window.location.reload()
+  return true
+}
+
+function failedApplicationAsset(event: Event) {
+  const target = event.target
+  if (target instanceof HTMLScriptElement) return target.src
+  if (target instanceof HTMLLinkElement && ['stylesheet', 'modulepreload', 'preload'].includes(target.rel)) return target.href
+  return ''
+}
+
+export function installStaticAssetRecovery(router: Router) {
+  window.addEventListener('vite:preloadError', (event) => {
+    const preloadEvent = event as Event & { payload?: unknown }
+    if (recoverFromStaticAssetFailure(preloadEvent.payload, true)) preloadEvent.preventDefault()
+  })
+
+  window.addEventListener('error', (event) => {
+    const assetUrl = failedApplicationAsset(event)
+    if (!assetUrl) return
+    try {
+      if (new URL(assetUrl, window.location.href).origin !== window.location.origin) return
+    } catch {
+      return
+    }
+    recoverFromStaticAssetFailure(assetUrl, true)
+  }, true)
+
+  router.onError((error) => {
+    recoverFromStaticAssetFailure(error)
+  })
+
+  window.setTimeout(clearRecoveryRecord, RECOVERY_STABLE_MS)
+}

src/deployment/nginxConfig.test.mjs

@@ -1,63 +1,63 @@
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
+import { readFileSync, existsSync } from 'node:fs'
 import test from 'node:test'
 
-const config = readFileSync(new URL('../../nginx/default.conf.template', import.meta.url), 'utf8')
+const root = new URL('../../', import.meta.url)
-const testCompose = readFileSync(new URL('../../docker-compose.test.yml', import.meta.url), 'utf8')
+const config = readFileSync(new URL('nginx/default.conf.template', root), 'utf8')
-const developmentCompose = readFileSync(new URL('../../docker-compose.development.yml', import.meta.url), 'utf8')
+const compose = readFileSync(new URL('docker-compose.test.yml', root), 'utf8')
-const productionCompose = readFileSync(new URL('../../docker-compose.production.yml', import.meta.url), 'utf8')
+const jenkins = readFileSync(new URL('Jenkinsfile', root), 'utf8')
-const jenkinsfile = readFileSync(new URL('../../Jenkinsfile', import.meta.url), 'utf8')
+const vite = readFileSync(new URL('vite.config.ts', root), 'utf8')
-const dockerfile = readFileSync(new URL('../../Dockerfile', import.meta.url), 'utf8')
 
-test('allows 50 MiB uploads with multipart overhead through both API proxies', () => {
+test('all business traffic uses one Gateway without rewriting API paths', () => {
-  assert.match(config, /location \/api\/ \{[\s\S]*?client_max_body_size 55m;/)
+  assert.match(config, /location \/api\//)
-  assert.match(config, /location \/overseas-api\/ \{[\s\S]*?client_max_body_size 55m;/)
+  assert.match(config, /proxy_pass \$\{API_UPSTREAM\};/)
-  assert.equal(config.match(/client_max_body_size 55m;/g)?.length, 2)
+  assert.doesNotMatch(config, /overseas-api|OVERSEAS_API_UPSTREAM|rewrite/)
-})
+  assert.match(config, /client_max_body_size 55m;/)
-
-test('does not cache the SPA entry while keeping hashed assets immutable', () => {
-  assert.match(config, /location = \/index\.html[\s\S]*no-store, no-cache, must-revalidate/)
-  assert.match(config, /location \/assets\/[\s\S]*max-age=31536000, immutable/)
-  assert.match(config, /location \/ \{[\s\S]*no-store, no-cache, must-revalidate[\s\S]*try_files \$uri \$uri\/ \/index\.html/)
-})
-
-test('routes domestic and overseas browser APIs to their test gateways without duplicate api prefixes', () => {
-  assert.match(testCompose, /API_UPSTREAM: "http:\/\/test-api-cn\.buggoglobal\.com"/)
-  assert.match(testCompose, /OVERSEAS_API_UPSTREAM: "http:\/\/test-api-global\.buggoglobal\.com"/)
-  assert.match(testCompose, /VITE_ADMIN_WEB_ORIGIN: "\$\{VITE_ADMIN_WEB_ORIGIN:-https:\/\/test-admin\.buggoglobal\.com\}"/)
-  assert.match(config, /location \/overseas-api\/ \{[\s\S]*?rewrite \^\/overseas-api\/\(\.\*\)\$ \/api\/\$1 break;[\s\S]*?proxy_pass \$\{OVERSEAS_API_UPSTREAM\};/)
   assert.match(config, /proxy_set_header Host \$proxy_host;/)
-  assert.doesNotMatch(config, /\/api\/api/)
+  assert.doesNotMatch(vite, /OVERSEAS_API|AUTH_API_PROXY_TARGET|IAM_API_PROXY_TARGET|WAREHOUSE_API_PROXY_TARGET/)
 })
 
-test('connects the development client proxy to both development gateways', () => {
+test('test deployment requires an explicit shared network, Gateway and version', () => {
-  assert.match(developmentCompose, /API_UPSTREAM: "http:\/\/firstleg-development-gateway:9000"/)
+  for (const key of ['IMAGE_TAG']) {
-  assert.match(developmentCompose, /OVERSEAS_API_UPSTREAM: "http:\/\/firstleg-development-gateway-overseas:9300"/)
+    assert.ok(compose.includes('${' + key + ':?'))
-  assert.match(developmentCompose, /- development-backend/)
+  }
-  assert.match(developmentCompose, /- development-overseas-backend/)
+  assert.ok(compose.includes('${API_UPSTREAM:-http://gateway:9000}'))
-  assert.match(developmentCompose, /development-overseas-backend:[\s\S]*?external: true[\s\S]*?name: firstleg-development-overseas-network/)
+  assert.ok(compose.includes('${TEST_NETWORK:-firstleg-test-network}'))
-  assert.doesNotMatch(developmentCompose, /test-api|prod(?:uction)?/i)
+  assert.match(compose, /external: true/)
+  assert.match(compose, /127\.0\.0\.1:/)
+  assert.doesNotMatch(compose, /overseas|host\.docker\.internal|production|development/)
+  assert.match(jenkins, /'java-builder' : 'java-test'/)
+  assert.match(jenkins, /docker compose -f docker-compose\.test\.yml config --quiet/)
+  assert.match(jenkins, /docker network inspect/)
+  assert.match(jenkins, /scripts\/deploy-production\.sh/)
+  assert.match(jenkins, /firstleg-production-ssh/)
+
 })
 
-test('keeps local environments on target nodes and uses credential-managed SSH for production', () => {
+test('application shell is revalidated and missing chunks remain 404', () => {
-  assert.match(jenkinsfile, /env\.JOB_BASE_NAME\?\.endsWith\('-prod'\) \? 'java-builder'/)
+  assert.match(config, /location = \/index\.html/)
-  assert.match(jenkinsfile, /DEVELOPMENT_COMPOSE_PROJECT = 'client-web'/)
+  assert.match(config, /no-store/)
-  assert.match(jenkinsfile, /docker compose -p "\$DEVELOPMENT_COMPOSE_PROJECT" -f "\$DEVELOPMENT_COMPOSE_FILE" up -d/)
+  assert.match(config, /max-age=31536000, immutable/)
-  assert.doesNotMatch(jenkinsfile, /\/var\/jenkins_home\/\.ssh|docker save/)
+  assert.match(config, /try_files \$uri =404;/)
-  assert.match(jenkinsfile, /credentialsId: 'firstleg-production-ssh'/)
+  assert.match(config, /try_files \$uri \$uri\/ \/index\.html;/)
-  assert.match(jenkinsfile, /git rev-parse origin\/main/)
-  assert.match(productionCompose, /127\.0\.0\.1:\$\{HOST_PORT:-9002\}:80/)
-  assert.match(productionCompose, /API_UPSTREAM: "http:\/\/gateway:9000"/)
-  assert.match(productionCompose, /name: firstleg-prod-infra-network/)
 })
 
-test('uses authenticated internal base images in CI', () => {
+
-  assert.match(dockerfile, /ARG NODE_IMAGE=node:22-alpine/)
+test('container build excludes local environment values and waits for Nginx health', () => {
-  assert.match(dockerfile, /ARG NGINX_IMAGE=nginx:1\.27-alpine/)
+  const ignore = readFileSync(new URL('.dockerignore', root), 'utf8')
-  assert.match(dockerfile, /FROM \$\{NODE_IMAGE\} AS build/)
+  assert.match(ignore, /^\.env$/m)
-  assert.match(dockerfile, /FROM \$\{NGINX_IMAGE\}/)
+  assert.match(ignore, /^\.env\.\*$/m)
-  assert.match(jenkinsfile, /NODE_BASE_IMAGE = '172\.31\.198\.7:10082\/java-project\/node:22-alpine'/)
+  assert.match(compose, /healthcheck:/)
-  assert.match(jenkinsfile, /NGINX_BASE_IMAGE = '172\.31\.198\.7:10082\/java-project\/nginx:1\.27-alpine'/)
+  assert.match(compose, /http:\/\/127\.0\.0\.1\/healthz/)
-  assert.match(jenkinsfile, /withCredentials\(\[usernamePassword\(/)
+  assert.match(jenkins, /up -d --wait --wait-timeout 120/)
-  assert.match(jenkinsfile, /export DOCKER_CONFIG="\$\{WORKSPACE\}@tmp\/docker-auth"/)
+})
+
+test('gray production is isolated from TEST and routes to the single Gateway', () => {
+  const production = readFileSync(new URL('docker-compose.production.yml', root), 'utf8')
+  assert.match(production, /name: firstleg-production-network/)
+  assert.match(production, /API_UPSTREAM: "http:\/\/gateway:9000"/)
+  assert.match(production, /127\.0\.0\.1:/)
+  assert.match(production, /healthcheck:/)
+  assert.doesNotMatch(production, /test-network|gateway-overseas|gateway-active|routing-network/)
+  assert.doesNotMatch(jenkins, /wecom|sendProductionWeComNotification/)
 })

src/env.d.ts

@@ -11,6 +11,7 @@ declare module 'vue-router' {
     requiresAuth?: boolean
     permission?: string
     workspaceTab?: boolean
+    workspaceTitle?: string
     keepAlive?: boolean
   }
 }

src/layouts/AppLayout.test.mjs

@@ -1,6 +1,8 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import test from 'node:test'
+import ts from 'typescript'
+import * as vue from 'vue'
 
 const layoutSource = readFileSync(new URL('./AppLayout.vue', import.meta.url), 'utf8')
 const shellStyles = readFileSync(new URL('../styles/shell.css', import.meta.url), 'utf8')
@@ -13,12 +15,13 @@ test('source contract: renders the grouped sidebar menu and mobile drawer contro
   assert.match(layoutSource, /import \{ computed, nextTick, onBeforeUnmount, onMounted, ref, watch \} from 'vue'/)
   assert.match(layoutSource, /import \{[\s\S]*?\bX\s*\} from '@lucide\/vue'/)
   assert.match(layoutSource, /import ClientSidebarMenu from '@\/components\/ClientSidebarMenu\.vue'/)
-  assert.match(layoutSource, /:class="\{ 'mobile-menu-open': mobileMenuOpen \}"/)
+  assert.match(layoutSource, /:class="\{ 'mobile-menu-open': mobileMenuOpen, 'is-dashboard-route': route\.path === '\/' \}"/)
   assert.match(layoutSource, /<button\s+v-if="mobileMenuOpen"[^>]*class="client-sidebar-scrim"[^>]*aria-label="关闭导航"[^>]*@click="closeMobileMenu"/s)
   assert.match(layoutSource, /<aside\s+ref="sidebarRef"\s+id="client-sidebar"\s+class="client-sidebar"\s+:inert="!desktopViewport && !mobileMenuOpen"\s+:aria-hidden="!desktopViewport && !mobileMenuOpen \? 'true' : undefined"\s*>/)
   assert.doesNotMatch(layoutSource, /<aside[^>]*aria-label=/)
   assert.match(layoutSource, /<nav aria-label="客户工作台导航">/)
-  assert.match(layoutSource, /<div class="client-sidebar-brand">[\s\S]*?<RouterLink class="client-sidebar-brand-link" to="\/" aria-label="返回业务总览" @click="closeMobileMenu">[\s\S]*?alt="柏悦物流"[\s\S]*?客户工作台/s)
+  assert.match(layoutSource, /<div class="client-sidebar-brand">[\s\S]*?<RouterLink class="client-sidebar-brand-link" to="\/" aria-label="返回业务总览" @click="closeMobileMenu">[\s\S]*?alt="柏悦物流"/s)
+  assert.doesNotMatch(layoutSource, /client-sidebar-brand-copy/)
   assert.match(layoutSource, /<button[^>]*ref="sidebarCloseButtonRef"[^>]*aria-label="关闭导航"[^>]*@click="closeMobileMenu"[^>]*>\s*<X :size="20" \/>/s)
   assert.match(layoutSource, /<ClientSidebarMenu\s+:active-path="route\.path"\s+@navigate="closeMobileMenu"\s*\/>/s)
   assert.match(layoutSource, /<button type="button" class="client-sidebar-logout" @click="handleLogout">[\s\S]*?退出登录/s)
@@ -45,11 +48,13 @@ test('source contract: removes the header and main content from the accessibilit
   assert.match(layoutSource, /<main\s+class="client-main"\s+:inert="mobileMenuOpen"\s+:aria-hidden="mobileMenuOpen \? 'true' : undefined"\s*>/)
 })
 
-test('source contract: keeps route context and user identity in the compact header', () => {
+test('source contract: keeps the prototype greeting and fixed message and profile utilities in the compact header', () => {
   assert.match(layoutSource, /const pageTitle = computed\(\(\) => route\.meta\.title \|\| '业务总览'\)/)
-  assert.match(layoutSource, /const pageDescription = computed\(\(\) => route\.meta\.description \|\| ''\)/)
+  assert.doesNotMatch(layoutSource, /const pageDescription/)
-  assert.match(layoutSource, /<div class="client-header-heading">\s*<h1>\{\{ pageTitle \}\}<\/h1>\s*<p v-if="pageDescription">\{\{ pageDescription \}\}<\/p>/s)
+  assert.match(layoutSource, /<p class="client-header-greeting">Hi, 客户<\/p>/)
   assert.match(layoutSource, /<div class="client-user">[\s\S]*\{\{ auth\.user\?\.name \}\}/)
+  assert.match(layoutSource, /class="client-header-notifications" to="\/notifications" aria-label="打开我的消息"/)
+  assert.match(layoutSource, /class="client-header-profile"[\s\S]*to="\/account\/profile"[\s\S]*aria-label="打开我的信息"/)
   assert.doesNotMatch(layoutSource, /<div class="client-user">[\s\S]*aria-label="退出登录"/)
   assert.doesNotMatch(layoutSource, /Building2|tenant-name|tenantName/)
   assert.doesNotMatch(routerSource, /showPageHeading|showTenantName/)
@@ -58,19 +63,25 @@ test('source contract: keeps route context and user identity in the compact head
 test('source contract: renders the complete route breadcrumb before page content', () => {
   assert.match(layoutSource, /import \{ getFirstAccessiblePath, getRouteBreadcrumbs \} from '@\/navigation\/clientNavigation'/)
   assert.match(layoutSource, /const breadcrumbs = computed\(\(\) => getRouteBreadcrumbs\(route\.path, String\(pageTitle\.value\)\)\)/)
-  assert.match(layoutSource, /<nav class="client-breadcrumb" aria-label="页面路径">[\s\S]*?v-for="\(item, index\) in breadcrumbs"[\s\S]*?<RouterLink v-if="item\.path" :to="item\.path">[\s\S]*?<strong v-else aria-current="page">/)
+  assert.match(layoutSource, /<nav v-if="route\.path !== '\/'" class="client-breadcrumb" aria-label="页面路径">[\s\S]*?v-for="\(item, index\) in breadcrumbs"[\s\S]*?<RouterLink v-if="item\.path" :to="item\.path">[\s\S]*?<strong v-else aria-current="page">/)
   assert.match(shellStyles, /\.client-breadcrumb \{[^}]*margin: 0 0 14px;/)
 })
 
-test('source contract: aligns the light top bar beside the prototype-inspired dark sidebar and bounds the mobile header', () => {
+test('source contract: aligns the blue-tinted prototype shell around a compact sidebar and bounds the mobile header', () => {
-  assert.match(shellStyles, /\.top-header \{[^}]*inset: 0 0 auto 250px;[^}]*max-width: calc\(100vw - 250px\);[^}]*padding: 0 24px;/)
+  assert.match(shellStyles, /\.top-header \{[^}]*inset: 0 0 auto 224px;[^}]*max-width: calc\(100vw - 224px\);[^}]*padding: 0 24px;/)
-  assert.match(shellStyles, /\.top-header \{[^}]*background: rgba\(255, 255, 255, \.96\)/)
+  assert.match(shellStyles, /\.top-header \{[^}]*background: rgba\(255, 255, 255, \.98\)/)
-  assert.match(shellStyles, /\.client-sidebar \{[^}]*inset: 0 auto 0 0;[^}]*width: 250px;[^}]*background: linear-gradient\(180deg, #0b1f3a 0%, #0c2a52 100%\)/)
+  assert.match(shellStyles, /\.client-sidebar \{[^}]*inset: 0 auto 0 0;[^}]*width: 224px;[^}]*border-right: 1px solid #dfe8f3;[^}]*background: linear-gradient\(180deg, #f5f8ff 0%, #edf5fc 100%\)/)
-  assert.match(shellStyles, /\.client-sidebar-brand \{[^}]*border-bottom: 1px solid rgba\(255, 255, 255, \.09\)/)
+  assert.match(shellStyles, /\.client-sidebar-brand \{[^}]*border-radius: 15px;[^}]*background: linear-gradient\(145deg, #0a2b50, #0b3d6c\)/)
-  assert.match(shellStyles, /\.client-main \{[^}]*padding: 134px 20px 40px;/)
+  assert.match(shellStyles, /\.client-main \{[^}]*padding: 126px 20px 40px;/)
+  assert.match(shellStyles, /\.is-dashboard-route \.client-main \{ padding-top: 88px; \}/)
   assert.match(globalStyles, /@media \(max-width: 720px\) \{[\s\S]*\.top-header \{ inset: 0;[^}]*padding: 0 14px; \}/)
   assert.match(globalStyles, /\.client-header-menu-button \{ display: grid; \}/)
-  assert.match(globalStyles, /\.client-header-heading p, \.client-user-copy \{ display: none; \}/)
+  assert.match(globalStyles, /\.client-header-greeting, \.client-user-copy \{ display: none; \}/)
+})
+
+test('source contract: keeps the dashboard free of a redundant workspace tab', () => {
+  assert.match(layoutSource, /<WorkspaceTabs\s+v-if="route\.path !== '\/'"/)
+  assert.match(layoutSource, /'is-dashboard-route': route\.path === '\/'/)
 })
 
 test('source contract: closes the mobile menu on route changes and Escape', () => {
@@ -99,7 +110,7 @@ test('source contract: locks body scrolling while open and restores it on close
 })
 
 test('source contract: handles confirmation cancellation but rethrows unexpected logout errors', () => {
-  assert.match(layoutSource, /async function handleLogout\(\) \{\s*try \{/)
+  assert.match(layoutSource, /async function handleLogout\(\) \{\s*const logoutToken = auth.token\s*try \{/)
   assert.match(layoutSource, /\} catch \(error\) \{\s*if \(error === 'cancel' \|\| error === 'close'\) return\s*throw error\s*\}/)
 })
 
@@ -110,7 +121,8 @@ test('source contract: uses a native recursive disclosure list without Element m
   assert.match(sidebarMenuSource, /const activeParentKeys = computed\(\(\) => new Set\(getNavigationParentKeys\(visibleNavigation\.value, props\.activePath\)\)\)/)
   assert.match(sidebarMenuSource, /const openedKeys = ref<ReadonlySet<string>>\(new Set\(activeParentKeys\.value\)\)/)
   assert.match(sidebarMenuSource, /openedKeys\.value = new Set\(\[\.\.\.openedKeys\.value, \.\.\.activeParentKeys\.value\]\)/)
-  assert.match(sidebarMenuSource, /if \(activeParentKeys\.value\.has\(key\)\) return/)
+  assert.doesNotMatch(sidebarMenuSource, /if \(activeParentKeys\.value\.has\(key\)\) return/)
+  assert.match(sidebarMenuSource, /if \(next\.has\(key\)\) next\.delete\(key\)/)
   assert.match(sidebarMenuSource, /<ul class="client-nav-menu">/)
   assert.match(sidebarMenuSource, /:active-path="activePath"/)
   assert.match(sidebarMenuSource, /:opened-keys="openedKeys"/)
@@ -138,3 +150,49 @@ test('source contract: routes denied pages to an explicit 403 state', () => {
   assert.match(routerSource, /!auth\.hasPermission\(permission\)/)
   assert.match(routerSource, /getFirstAccessiblePath\(auth\.permissionCodes\)/)
 })
+
+function logoutHarness(t) {
+  const script = layoutSource.match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const ast = ts.createSourceFile('layout.ts', script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const nodes = ast.statements.filter(node => (ts.isFunctionDeclaration(node) && node.name?.text === 'handleLogout') || (ts.isExpressionStatement(node) && node.getText(ast).startsWith('watch(') && node.getText(ast).includes('() => auth.isAuthenticated')))
+  const code = ts.transpileModule(nodes.map(node => node.getText(ast)).join('\n'), { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  let rejectLogout, confirm
+  const remote = new Promise((_, no) => { rejectLogout = no })
+  const confirmation = new Promise(yes => { confirm = yes })
+  const calls = [], warnings = []
+  const auth = vue.reactive({ token: 'A', isAuthenticated: true, logout: () => { calls.push('logout'); auth.token = ''; auth.isAuthenticated = false; return remote } })
+  const scope = vue.effectScope(); t.after(() => scope.stop())
+  const handler = scope.run(() => new Function('watch', 'auth', 'workspace', 'unsaved', 'router', 'ElMessageBox', 'ElMessage', code + ';return handleLogout')(vue.watch, auth, { clear: () => calls.push('workspace') }, { hasDirty: false, clear: () => calls.push('unsaved') }, { replace: path => { calls.push(path); return Promise.resolve() } }, { confirm: () => confirmation }, { warning: value => warnings.push(value) }))
+  return { auth, handler, confirm, rejectLogout, calls, warnings }
+}
+
+test('logout navigates before remote completion and late failure cannot affect a new login', async t => {
+  const h = logoutHarness(t)
+  const clicked = h.handler(); h.confirm(); await clicked; await vue.nextTick()
+  assert.deepEqual(h.calls, ['logout', 'workspace', 'unsaved', '/login'])
+  assert.equal(h.auth.isAuthenticated, false)
+  h.auth.token = 'B'; h.auth.isAuthenticated = true; await vue.nextTick()
+  h.rejectLogout(new Error('SESSION_CHANGED')); await Promise.resolve(); await vue.nextTick()
+  assert.equal(h.auth.token, 'B'); assert.equal(h.auth.isAuthenticated, true)
+  assert.equal(h.calls.filter(item => item === '/login').length, 1)
+  assert.equal(h.warnings.length, 0)
+})
+
+test('cross-tab logout leaves protected route and stale confirmation never logs out a new identity', async t => {
+  const h = logoutHarness(t)
+  const clicked = h.handler()
+  h.auth.token = 'B'; h.confirm(); await clicked
+  assert.equal(h.calls.length, 0)
+  h.auth.token = ''; h.auth.isAuthenticated = false; await vue.nextTick()
+  assert.deepEqual(h.calls, ['workspace', 'unsaved', '/login'])
+  assert.match(layoutSource, /<div v-if="auth.isAuthenticated" class="client-shell"/)
+})
+
+test('remote logout failure reports incomplete server revocation without leaving protected content visible', async t => {
+  const h = logoutHarness(t)
+  const clicked = h.handler(); h.confirm(); await clicked; await vue.nextTick()
+  h.rejectLogout(new Error('offline')); await Promise.resolve()
+  assert.equal(h.auth.isAuthenticated, false)
+  assert.ok(h.calls.includes('/login'))
+  assert.deepEqual(h.warnings, ['已退出本页，服务器会话注销未完成'])
+})

src/layouts/AppLayout.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
-import { ElMessageBox } from 'element-plus'
+import { ElMessage, ElMessageBox } from 'element-plus'
 import { Bell, LogOut, Menu, X } from '@lucide/vue'
 import baiyueLogoDark from '@/assets/brand/baiyue-logo-dark.png'
 import ClientSidebarMenu from '@/components/ClientSidebarMenu.vue'
@@ -24,7 +24,6 @@ const notifications = useNotificationsStore()
 const workspace = useWorkspaceTabsStore()
 const unsaved = useUnsavedWorkStore()
 const pageTitle = computed(() => route.meta.title || '业务总览')
-const pageDescription = computed(() => route.meta.description || '')
 const breadcrumbs = computed(() => getRouteBreadcrumbs(route.path, String(pageTitle.value)))
 const mobileMenuOpen = ref(false)
 const desktopViewport = ref(true)
@@ -109,6 +108,7 @@ watch(
 watch(
   () => auth.permissionCodes.join('|'),
   () => {
+    if (!auth.isAuthenticated) return
     const result = workspace.reconcile(isAllowedTab)
     if (result.closedActive) void router.replace(result.fallbackPath ?? getFirstAccessiblePath(auth.permissionCodes))
   },
@@ -120,6 +120,7 @@ watch(
     if (authenticated) return
     workspace.clear()
     unsaved.clear()
+    void router.replace('/login')
   },
 )
 
@@ -164,6 +165,7 @@ function handleBeforeUnload(event: BeforeUnloadEvent) {
 }
 
 async function handleLogout() {
+  const logoutToken = auth.token
   try {
     await ElMessageBox.confirm(unsaved.hasDirty
       ? '当前还有未保存的修改，退出后这些内容将丢失。确定继续吗？'
@@ -177,15 +179,16 @@ async function handleLogout() {
     throw error
   }
 
-  workspace.clear()
+  if (auth.token !== logoutToken) return
-  unsaved.clear()
+  void auth.logout().catch(() => {
-  await auth.logout()
+    if (!auth.isAuthenticated) ElMessage.warning('已退出本页，服务器会话注销未完成')
-  await router.replace('/login')
+  })
 }
+
 </script>
 
 <template>
-  <div class="client-shell" :class="{ 'mobile-menu-open': mobileMenuOpen }">
+  <div v-if="auth.isAuthenticated" class="client-shell" :class="{ 'mobile-menu-open': mobileMenuOpen, 'is-dashboard-route': route.path === '/' }">
     <header class="top-header" :inert="mobileMenuOpen" :aria-hidden="mobileMenuOpen ? 'true' : undefined">
       <button
         ref="menuButtonRef"
@@ -198,14 +201,22 @@ async function handleLogout() {
       >
         <Menu :size="20" />
       </button>
-      <div class="client-header-heading">
+      <p class="client-header-greeting">Hi, 客户</p>
-        <h1>{{ pageTitle }}</h1>
-        <p v-if="pageDescription">{{ pageDescription }}</p>
-      </div>
       <div class="client-user">
         <RouterLink v-if="auth.hasPermission('merchant:notification:view')" class="client-header-notifications" to="/notifications" aria-label="打开我的消息"><Bell :size="19" /><span v-if="notifications.unreadCount !== null && notifications.unreadCount > 0" class="client-header-notifications-badge">{{ notifications.unreadCount > 99 ? '99+' : notifications.unreadCount }}</span></RouterLink>
-        <span class="client-avatar">{{ auth.user?.name.slice(0, 1) }}</span>
+        <RouterLink
-        <span class="client-user-copy"><strong>{{ auth.user?.name }}</strong><small>{{ auth.user?.roles.join('、') }}</small></span>
+          v-if="auth.hasPermission('account:profile:view')"
+          class="client-header-profile"
+          to="/account/profile"
+          aria-label="打开我的信息"
+        >
+          <span class="client-avatar">{{ auth.user?.name.slice(0, 1) }}</span>
+          <span class="client-user-copy"><strong>{{ auth.user?.name }}</strong><small>{{ auth.user?.roles.join('、') }}</small></span>
+        </RouterLink>
+        <template v-else>
+          <span class="client-avatar">{{ auth.user?.name.slice(0, 1) }}</span>
+          <span class="client-user-copy"><strong>{{ auth.user?.name }}</strong><small>{{ auth.user?.roles.join('、') }}</small></span>
+        </template>
       </div>
     </header>
 
@@ -227,7 +238,6 @@ async function handleLogout() {
       <div class="client-sidebar-brand">
         <RouterLink class="client-sidebar-brand-link" to="/" aria-label="返回业务总览" @click="closeMobileMenu">
           <img class="client-sidebar-brand-logo" :src="baiyueLogoDark" alt="柏悦物流" />
-          <span class="client-sidebar-brand-copy"><small>客户工作台</small></span>
         </RouterLink>
         <button
           ref="sidebarCloseButtonRef"
@@ -251,6 +261,7 @@ async function handleLogout() {
     </aside>
 
     <WorkspaceTabs
+      v-if="route.path !== '/'"
       :inert="mobileMenuOpen"
       :aria-hidden="mobileMenuOpen ? 'true' : undefined"
     />
@@ -260,7 +271,7 @@ async function handleLogout() {
       :inert="mobileMenuOpen"
       :aria-hidden="mobileMenuOpen ? 'true' : undefined"
     >
-      <nav class="client-breadcrumb" aria-label="页面路径">
+      <nav v-if="route.path !== '/'" class="client-breadcrumb" aria-label="页面路径">
         <template v-for="(item, index) in breadcrumbs" :key="`${item.title}-${index}`">
           <span v-if="index" aria-hidden="true">/</span>
           <RouterLink v-if="item.path" :to="item.path">{{ item.title }}</RouterLink>

src/main.ts

@@ -6,9 +6,12 @@ import { ElConfigProvider } from 'element-plus'
 import zhCn from 'element-plus/es/locale/lang/zh-cn'
 import App from './App.vue'
 import router from './router'
+import { installStaticAssetRecovery } from './core/staticAssetRecovery'
 import 'element-plus/es/components/message/style/css'
 import 'element-plus/es/components/message-box/style/css'
 import './styles/index.css'
 
+installStaticAssetRecovery(router)
+
 const app = createApp({ render: () => h(ElConfigProvider, { locale: zhCn }, { default: () => h(App) }) })
 app.use(createPinia()).use(router).mount('#app')

src/modules/auth/api/auth.ts

@@ -1,4 +1,4 @@
-import { apiRequest } from '@/api/http'
+import { apiRequest, revokeCapturedSession } from '@/api/http'
 import type { TokenPair } from '@/api/session'
 
 export interface RegisterMerchantRequest {
@@ -35,8 +35,8 @@ export function registerMerchant(payload: RegisterMerchantRequest) {
   return apiRequest<RegisterMerchantResult>({ method: 'POST', url: '/auth/register', data: payload })
 }
 
-export function logoutMerchant(refreshToken: string) {
+export function logoutMerchant(accessToken: string, refreshToken: string) {
-  return apiRequest<void>({ method: 'POST', url: '/auth/logout', data: { refreshToken } })
+  return revokeCapturedSession(accessToken, refreshToken)
 }
 
 export function changeCurrentPassword(oldPassword: string, newPassword: string) {

src/modules/auth/store/auth.ts

@@ -61,18 +61,34 @@ export const useAuthStore = defineStore('client-auth', () => {
   const permissionCodes = ref<string[]>([])
   const sessionRestored = ref(false)
 
+  let logoutRequest: { accessToken: string; refreshToken: string; promise: Promise<void> } | undefined
+  let generation = 0
+  let contextRequest: { generation: number; promise: Promise<void> } | undefined
+  let restoreTimer: ReturnType<typeof setTimeout> | undefined
+
+  function identity(value: MerchantJwtPayload | null) {
+    return value ? JSON.stringify([value.user_id, value.tenant_id, value.membership_id, value.operator_tenant_id, value.app_code, value.client_type]) : ''
+  }
+
   function applyToken(accessToken: string) {
     const decoded = decodeMerchantToken(accessToken)
+    const changedIdentity = identity(decoded) !== identity(payload.value)
+    if (accessToken === token.value && payload.value && !changedIdentity) return
+    generation++
+    if (changedIdentity) {
+      user.value = null
+      profile.value = { ...emptyProfile }
+      permissionCodes.value = mapPermissions()
+    }
     payload.value = decoded
     token.value = accessToken
     user.value = currentUser(decoded, user.value?.tenantName)
     profile.value.username = decoded.username
-    profile.value.realName = decoded.username
+    sessionRestored.value = false
-    permissionCodes.value = mapPermissions()
   }
 
-  function clearSession() {
+  function resetLocalSession() {
-    clearSessionTokens()
+    generation++
     token.value = ''
     payload.value = null
     user.value = null
@@ -81,137 +97,123 @@ export const useAuthStore = defineStore('client-auth', () => {
     sessionRestored.value = true
   }
 
+  function clearSession() {
+    clearSessionTokens()
+    resetLocalSession()
+  }
+
   function applyStoredSession() {
     const storedToken = getAccessToken()
     if (!storedToken) {
-      token.value = ''
+      resetLocalSession()
-      payload.value = null
-      user.value = null
-      permissionCodes.value = []
-      profile.value = { ...emptyProfile }
-      sessionRestored.value = true
       return
     }
     try {
       applyToken(storedToken)
-      sessionRestored.value = false
-    } catch {
-      clearSession()
-    }
-  }
-
-  if (token.value) {
-    try {
-      applyToken(token.value)
     } catch (error) {
-      if (!(error instanceof MerchantTokenExpiredError && getRefreshToken())) clearSession()
+      resetLocalSession()
+      if (error instanceof MerchantTokenExpiredError && getRefreshToken()) sessionRestored.value = false
     }
   }
 
+  applyStoredSession()
   const isAuthenticated = computed(() => Boolean(token.value && payload.value))
 
-  async function loadSessionContext() {
-    if (!payload.value) return
-    const currentPermissionCodes = await getCurrentMerchantPermissionCodes()
-    const currentAccessToken = getAccessToken()
-    if (currentAccessToken && currentAccessToken !== token.value) applyToken(currentAccessToken)
-    permissionCodes.value = mapPermissions(currentPermissionCodes)
-    const [tenant, personalProfile] = await Promise.all([
-      getTenantProfile(),
-      getMerchantPersonalProfile(),
-    ])
-    user.value = currentUser(payload.value, tenant.tenantName)
-    profile.value = {
-      ...profile.value,
-      realName: personalProfile.displayName || payload.value.username,
-      phone: personalProfile.phone || '',
-      email: personalProfile.email || '',
-      tenantName: tenant.tenantName,
-    }
-  }
-
   async function restoreSession() {
     if (sessionRestored.value) return
-    if (!isAuthenticated.value) {
+    if (contextRequest?.generation === generation) return contextRequest.promise
-      if (!getRefreshToken()) {
+    let requestGeneration = generation
-        sessionRestored.value = true
+    let requestAccessToken = getAccessToken()
-        return
+    const isCurrent = () => requestGeneration === generation && getAccessToken() === requestAccessToken
-      }
+    const promise = (async () => {
       try {
-        applyToken(await refreshAuthenticatedSession())
+        if (!isAuthenticated.value) {
+          if (!getRefreshToken()) return
+          const refreshedToken = await refreshAuthenticatedSession()
+          if (requestGeneration !== generation) return restoreSession()
+          applyToken(refreshedToken)
+          requestAccessToken = refreshedToken
+          requestGeneration = generation
+          if (contextRequest) contextRequest.generation = generation
+        }
+        const requestPayload = payload.value
+        if (!requestPayload) return
+        const [codes, tenant, personalProfile] = await Promise.all([
+          getCurrentMerchantPermissionCodes(), getTenantProfile(), getMerchantPersonalProfile(),
+        ])
+        if (!isCurrent()) {
+          applyStoredSession()
+          return restoreSession()
+        }
+        permissionCodes.value = mapPermissions(codes)
+        user.value = currentUser(requestPayload, tenant.tenantName)
+        profile.value = {
+          username: requestPayload.username,
+          realName: personalProfile.displayName || requestPayload.username,
+          phone: personalProfile.phone || '', email: personalProfile.email || '', tenantName: tenant.tenantName,
+        }
+        sessionRestored.value = true
       } catch (error) {
+        if (!isCurrent()) return
+        sessionRestored.value = false
         if (isExpiredSessionError(error)) {
           clearSession()
           throw error
         }
-        sessionRestored.value = true
-        return
       }
+    })()
+    contextRequest = { generation: requestGeneration, promise }
+    try { await promise } finally {
+      if (contextRequest?.promise === promise) contextRequest = undefined
     }
-    try {
+  }
-      await loadSessionContext()
+
-    } catch (error) {
+  function synchronizeSession() {
-      if (isExpiredSessionError(error)) {
+    // Identity changes and logout revoke local rights immediately. Coalesce pair writes
-        clearSession()
+    // before loading the new context; same-identity rotation retains confirmed rights.
-        throw error
+    applyStoredSession()
-      }
+    if (restoreTimer) clearTimeout(restoreTimer)
-      sessionRestored.value = true
+    restoreTimer = setTimeout(() => {
-      return
+      restoreTimer = undefined
-    }
+      void restoreSession().catch(() => {})
-    sessionRestored.value = true
+    }, 0)
   }
 
   async function login(loginId: string, password: string, remember = false) {
+    const attempt = ++generation
     const tokens = await loginMerchant(loginId, password)
-    const decoded = decodeMerchantToken(tokens.accessToken)
+    if (attempt !== generation) return
+    decodeMerchantToken(tokens.accessToken)
     persistTokenPair(tokens)
     persistRememberedLoginId(loginId, remember)
-    token.value = tokens.accessToken
+    applyToken(tokens.accessToken)
-    payload.value = decoded
+    await restoreSession()
-    user.value = currentUser(decoded)
-    profile.value = { ...emptyProfile, username: decoded.username, realName: decoded.username }
-    permissionCodes.value = mapPermissions()
-    sessionRestored.value = false
-    try {
-      await loadSessionContext()
-      sessionRestored.value = true
-    } catch (error) {
-      if (isExpiredSessionError(error)) {
-        clearSession()
-        throw error
-      }
-      sessionRestored.value = true
-    }
   }
 
   async function acceptImpersonationCode(code: string) {
+    const attempt = ++generation
     const exchanged = await exchangeImpersonationCode(code)
-    const decoded = decodeMerchantToken(exchanged.accessToken)
+    if (attempt !== generation) return
+    decodeMerchantToken(exchanged.accessToken)
     persistTemporaryAccessToken(exchanged.accessToken)
-    token.value = exchanged.accessToken
+    applyToken(exchanged.accessToken)
-    payload.value = decoded
+    await restoreSession()
-    user.value = currentUser(decoded)
-    profile.value = { ...emptyProfile, username: decoded.username, realName: decoded.username }
-    permissionCodes.value = mapPermissions()
-    sessionRestored.value = false
-    try {
-      await loadSessionContext()
-    } catch (error) {
-      if (isExpiredSessionError(error)) {
-        clearSession()
-        throw error
-      }
-    }
-    sessionRestored.value = true
   }
 
-  async function logout() {
+  function logout() {
+    const accessToken = getAccessToken()
     const refreshToken = getRefreshToken()
-    try {
+    if (logoutRequest && ((!accessToken && !refreshToken)
-      if (refreshToken) await logoutMerchant(refreshToken)
+      || (logoutRequest.accessToken === accessToken && logoutRequest.refreshToken === refreshToken))) return logoutRequest.promise
-    } finally {
+    const pending = accessToken || refreshToken
-      clearSession()
+      ? logoutMerchant(accessToken, refreshToken)
-    }
+      : Promise.resolve()
+    clearSession()
+    const request = { accessToken, refreshToken, promise: pending.finally(() => {
+      if (logoutRequest === request) logoutRequest = undefined
+    }) }
+    logoutRequest = request
+    return request.promise
   }
 
   function hasPermission(permission?: string) {
@@ -224,10 +226,13 @@ export const useAuthStore = defineStore('client-auth', () => {
   }
 
   async function savePersonalProfile(next: Pick<ClientAccountProfile, 'realName' | 'email'>) {
+    const requestGeneration = generation
+    const requestToken = getAccessToken()
     const updated = await updateMerchantPersonalProfile({
       displayName: next.realName.trim(),
       email: next.email.trim(),
     })
+    if (requestGeneration !== generation || requestToken !== getAccessToken()) return
     updateProfile({
       realName: updated.displayName,
       phone: updated.phone || '',
@@ -236,8 +241,9 @@ export const useAuthStore = defineStore('client-auth', () => {
   }
 
   window.addEventListener('cc-client-session-expired', clearSession)
+  window.addEventListener('cc-client-session-updated', synchronizeSession)
   window.addEventListener('storage', (event) => {
-    if (event.key === 'cc-client-access-token' || event.key === 'cc-client-refresh-token') applyStoredSession()
+    if (event.storageArea === localStorage && (event.key === null || event.key === 'cc-client-access-token' || event.key === 'cc-client-refresh-token')) synchronizeSession()
   })
 
   return { token, user, profile, permissionCodes, isAuthenticated, sessionRestored, hasPermission, login, logout, clearSession, restoreSession, acceptImpersonationCode, updateProfile, savePersonalProfile }

src/modules/auth/store/authSession.test.mjs

@@ -0,0 +1,168 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+import * as pinia from 'pinia'
+
+function compile(path, dependencies = {}) {
+  const code = ts.transpileModule(readFileSync(new URL(path, import.meta.url), 'utf8'), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+  }).outputText
+  const exports = {}
+  new Function('require', 'exports', code)(id => { assert.ok(id in dependencies, id); return dependencies[id] }, exports)
+  return exports
+}
+function storage() {
+  const values = new Map()
+  return { getItem: key => values.get(key) ?? null, setItem: (key, value) => values.set(key, value), removeItem: key => values.delete(key) }
+}
+function token(user = 1, tenant = 1, membership = 1, nonce = 'a') {
+  return `test.${Buffer.from(JSON.stringify({ user_id: user, tenant_id: tenant, membership_id: membership, username: `user-${user}`, app_code: 'MERCHANT', exp: 4102444800, nonce })).toString('base64url')}.test`
+}
+const flush = () => new Promise(resolve => setTimeout(resolve, 10))
+function deferred() { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no }); return { promise, resolve, reject } }
+
+function harness(t, expired = false) {
+  globalThis.localStorage = storage(); globalThis.sessionStorage = storage()
+  const listeners = new Map()
+  globalThis.window = { addEventListener: (name, fn) => listeners.set(name, fn) }
+  const session = compile('../../../api/session.ts')
+  const initial = expired ? `test.${Buffer.from(JSON.stringify({ user_id: 1, tenant_id: 1, membership_id: 1, username: 'user-1', app_code: 'MERCHANT', exp: 1 })).toString('base64url')}.test` : token()
+  session.persistTokenPair({ accessToken: initial, refreshToken: 'refresh-a' })
+  let reads = 0
+  const behavior = { permissions: async () => ['edit'], tenant: async () => ({ tenantName: 'company' }) }
+  class ApiError extends Error { constructor(status) { super('failed'); this.status = status } }
+  const module = compile('./auth.ts', {
+    vue, pinia, '@/api/session': session,
+    '@/modules/auth/api/auth': { logoutMerchant: async (access, refresh) => behavior.logout?.(refresh, access) },
+    '@/modules/auth/utils/jwt': compile('../utils/jwt.ts'),
+    '@/api/http': { ApiError, refreshAuthenticatedSession: async () => {
+      session.persistTokenPair({ accessToken: token(1, 1, 1, 'refreshed'), refreshToken: 'refresh-new' })
+      listeners.get('cc-client-session-updated')()
+      return session.getAccessToken()
+    } },
+    '@/modules/tenant-management/public': {
+      FRONTEND_TO_MERCHANT_PERMISSION_CODES: { 'order:first-leg:edit': 'edit' },
+      hasMappedMerchantPermission: (_, codes) => codes.has('edit'),
+      getCurrentMerchantPermissionCodes: () => { reads++; return behavior.permissions() },
+      getTenantProfile: () => behavior.tenant(), getMerchantPersonalProfile: async () => ({}),
+    },
+  })
+  const context = pinia.createPinia(); pinia.setActivePinia(context)
+  t.after(async () => { await flush(); pinia.disposePinia(context) })
+  const auth = module.useAuthStore()
+  const event = key => listeners.get('storage')({ key, storageArea: localStorage })
+  function rotate(nextToken = token(1, 1, 1, 'b')) {
+    session.persistTokenPair({ accessToken: nextToken, refreshToken: 'refresh-b' })
+    event(session.ACCESS_TOKEN_KEY); event(session.REFRESH_TOKEN_KEY)
+  }
+  return { auth, session, event, rotate, behavior, listeners, ApiError, reads: () => reads }
+}
+
+test('pair storage rotation retains same-identity rights and automatically reloads once without navigation', async t => {
+  const h = harness(t); await h.auth.restoreSession()
+  h.behavior.permissions = async () => []
+  h.rotate()
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), true)
+  assert.equal(h.auth.sessionRestored, false)
+  await flush()
+  assert.equal(h.auth.sessionRestored, true)
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), false, 'new server rights replace the retained snapshot')
+  assert.equal(h.reads(), 2)
+  h.listeners.get('cc-client-session-updated')()
+  await flush()
+  assert.equal(h.reads(), 2, 'already applied token does not reload twice')
+})
+
+test('startup expired-token refresh waits for restored rights even when local rotation emits an event', async t => {
+  const h = harness(t, true)
+  await h.auth.restoreSession()
+  assert.equal(h.auth.isAuthenticated, true)
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), true)
+  assert.equal(h.auth.sessionRestored, true)
+  assert.equal(h.reads(), 1)
+})
+
+test('logout storage event immediately clears rights and late context cannot restore them', async t => {
+  const h = harness(t); const old = deferred(); h.behavior.permissions = () => old.promise
+  const pending = h.auth.restoreSession()
+  h.session.clearSessionTokens(); h.event(h.session.ACCESS_TOKEN_KEY)
+  assert.equal(h.auth.isAuthenticated, false)
+  assert.deepEqual(h.auth.permissionCodes, [])
+  old.resolve(['edit']); await pending; await flush()
+  assert.equal(h.auth.user, null)
+  assert.deepEqual(h.auth.permissionCodes, [])
+})
+
+test('account, customer and membership switches revoke rights immediately and reject stale request results', async t => {
+  const h = harness(t); await h.auth.restoreSession()
+  const old = deferred(); h.behavior.permissions = () => old.promise
+  h.rotate(); await flush()
+  h.behavior.permissions = async () => []
+  h.rotate(token(2, 2, 2, 'new'))
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), false)
+  assert.equal(h.auth.user.id, '2')
+  await flush(); old.resolve(['edit']); await flush()
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), false)
+  assert.equal(h.auth.user.id, '2')
+  h.behavior.permissions = async () => ['edit']; h.rotate(token(2, 3, 3, 'next')); await flush()
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), true)
+  h.rotate(token(2, 3, 4, 'membership'))
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), false)
+})
+
+test('context failure is not marked restored and explicit retry coalesces concurrent callers', async t => {
+  const h = harness(t)
+  h.behavior.permissions = async () => { throw new Error('offline') }
+  await h.auth.restoreSession()
+  assert.equal(h.auth.sessionRestored, false)
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), false)
+  const pending = deferred(); h.behavior.permissions = () => pending.promise
+  const first = h.auth.restoreSession(), second = h.auth.restoreSession()
+  assert.equal(h.reads(), 2)
+  pending.resolve(['edit']); await Promise.all([first, second])
+  assert.equal(h.auth.sessionRestored, true)
+  assert.equal(h.auth.hasPermission('order:first-leg:edit'), true)
+})
+
+test('stale unauthorized context response cannot clear a newer account', async t => {
+  const h = harness(t); const old = deferred(); h.behavior.permissions = () => old.promise
+  const pending = h.auth.restoreSession()
+  h.behavior.permissions = async () => []
+  h.rotate(token(2, 2, 2)); await flush()
+  old.reject(new h.ApiError(401)); await pending
+  assert.equal(h.auth.user.id, '2')
+  assert.equal(h.auth.isAuthenticated, true)
+  assert.equal(h.auth.sessionRestored, true)
+})
+
+test('store logout clears immediately and late revocation failure preserves a later cross-tab login', async t => {
+  const h = harness(t); await h.auth.restoreSession()
+  const remote = deferred(); let sentRefresh
+  h.behavior.logout = refresh => { sentRefresh = refresh; return remote.promise }
+  const pending = h.auth.logout()
+  const rejected = assert.rejects(pending, /offline/)
+  assert.equal(sentRefresh, 'refresh-a')
+  assert.equal(h.auth.isAuthenticated, false)
+  assert.equal(h.session.getAccessToken(), '')
+  h.rotate(token(2, 2, 2)); await flush()
+  remote.reject(new Error('offline')); await rejected
+  assert.equal(h.auth.user.id, '2')
+  assert.equal(h.auth.isAuthenticated, true)
+  assert.equal(h.session.getRefreshToken(), 'refresh-b')
+})
+
+test('duplicate logout joins captured pair revocation and does not send again',async t=>{
+ const h=harness(t);const remote=deferred();let count=0,sent
+ h.behavior.logout=(refresh,access)=>{count++;sent={refresh,access};return remote.promise}
+ const a=h.auth.logout(),b=h.auth.logout();assert.equal(h.auth.isAuthenticated,false);assert.equal(sent.access,token());assert.equal(sent.refresh,'refresh-a');assert.equal(count,1);remote.resolve();await Promise.all([a,b])
+})
+
+test('B logout during A pending revokes B; A finally cannot release B deduplication',async t=>{
+ const h=harness(t);const a=deferred(),b=deferred(),calls=[]
+ h.behavior.logout=(refresh,access)=>{calls.push({refresh,access});return calls.length===1?a.promise:b.promise}
+ const leavingA=h.auth.logout();h.rotate(token(2,2,2));await flush();assert.equal(h.auth.isAuthenticated,true)
+ const leavingB=h.auth.logout();assert.equal(h.auth.isAuthenticated,false);assert.equal(h.session.getAccessToken(),'');assert.equal(calls.length,2);assert.equal(calls[1].access,token(2,2,2))
+ a.resolve();await leavingA;const duplicateB=h.auth.logout();assert.equal(calls.length,2);let duplicateFinished=false;void duplicateB.then(()=>{duplicateFinished=true});await flush();assert.equal(duplicateFinished,false);b.resolve();await Promise.all([leavingB,duplicateB])
+})

src/modules/auth/views/AuthViews.test.mjs

@@ -102,7 +102,8 @@ test('opens complete service and privacy documents from registration', () => {
 test('uses real auth endpoints and single-flight refresh handling', () => {
   assert.match(authApiSource, /\/auth\/login/)
   assert.match(authApiSource, /\/auth\/register/)
-  assert.match(authApiSource, /\/auth\/logout/)
+  assert.match(authApiSource, /revokeCapturedSession\(accessToken, refreshToken\)/)
+  assert.match(httpSource, /\/auth\/logout/)
   assert.match(httpSource, /refreshPromise/)
   assert.match(httpSource, /\/auth\/refresh/)
   assert.match(httpSource, /persistTokenPair\(tokens\)/)
@@ -117,7 +118,8 @@ test('uses real auth endpoints and single-flight refresh handling', () => {
   assert.match(httpSource, /window\.location\.replace\(`\/login\?redirect=\$\{encodeURIComponent\(redirect\)\}`\)/)
   assert.match(authStoreSource, /decodeMerchantToken/)
   assert.match(authStoreSource, /MerchantTokenExpiredError && getRefreshToken\(\)/)
-  assert.match(authStoreSource, /applyToken\(await refreshAuthenticatedSession\(\)\)/)
+  assert.match(authStoreSource, /const refreshedToken = await refreshAuthenticatedSession\(\)/)
+  assert.match(authStoreSource, /applyToken\(refreshedToken\)/)
   assert.doesNotMatch(authStoreSource, /mock-client:/)
 })
 
@@ -152,7 +154,7 @@ test('shows a forced re-login notice after login identifiers change', () => {
 test('keeps a valid local session during temporary context and refresh outages', () => {
   assert.match(authStoreSource, /function isExpiredSessionError/)
   assert.match(authStoreSource, /if \(isExpiredSessionError\(error\)\)/)
-  assert.match(authStoreSource, /sessionRestored\.value = true\s+return/)
+  assert.match(authStoreSource, /if \(!isCurrent\(\)\) return\s+sessionRestored\.value = false/)
   assert.match(httpSource, /if \(mappedError\.status === 401 \|\| mappedError\.code === 'A0401'\)/)
   assert.doesNotMatch(httpSource, /catch \(refreshError\) \{\s+clearSessionTokens\(\)/)
 })

src/modules/cross-border/api/businessOrders.ts

@@ -1,4 +1,4 @@
-import { overseasApiRequest } from '@/api/overseasHttp'
+import { apiRequest } from '@/api/http'
 
 export interface PageResult<T> {
   records: T[]
@@ -8,7 +8,7 @@ export interface PageResult<T> {
   pages: number
 }
 
-export type CrossBorderBusinessKind = 'procurement' | 'trucking' | 'looseboard'
+export type CrossBorderBusinessKind = 'trucking' | 'looseboard'
 
 export interface BusinessOrderQuery {
   page: number
@@ -16,8 +16,6 @@ export interface BusinessOrderQuery {
   orderNo?: string
   status?: string
   routeKeyword?: string
-  productName?: string
-  purchaseCategory?: string
   transportType?: string
   transportMode?: string
   requestedFrom?: string
@@ -26,59 +24,12 @@ export interface BusinessOrderQuery {
   createdTo?: string
 }
 
-export interface ProcurementSummary {
-  orderNo: string
-  purchaseCategory: string
-  productName: string
-  productSpecification: string | null
-  purchaseQuantity: number
-  budgetUnitPrice: number | null
-  currency: string | null
-  inboundQuantity: number
-  outboundQuantity: number
-  inventoryQuantity: number
-  status: string
-  version: number
-  createdAt: string
-  updatedAt: string
-}
-
-export interface ProcurementDetail {
-  summary: ProcurementSummary
-  productUrl: string | null
-  receivingAddress: string | null
-  contactName: string
-  contactPhone: string
-  domesticCarrier: string | null
-  domesticTrackingNo: string | null
-  overseasCarrier: string | null
-  overseasTrackingNo: string | null
-  estimatedArrivalAt: string | null
-  remark: string | null
-  reviewRemark: string | null
-}
-
-export interface ProcurementCreate {
-  customerName: string
-  purchaseCategory: string
-  productName: string
-  productSpecification?: string
-  productUrl?: string
-  purchaseQuantity: number
-  budgetUnitPrice?: number
-  currency?: string
-  receivingAddress?: string
-  contactName: string
-  contactPhone: string
-  remark?: string
-  idempotencyKey: string
-}
-
 export interface TransportSummary {
+  fleetArrangement: import('../fleetArrangement').FleetArrangement | null
   orderNo: string
   transportType: string
   transportMode?: string
-  palletRequired?: string
+  palletRequired?: string | null
   origin: string
   destination: string
   containerType: string | null
@@ -131,7 +82,6 @@ export interface TransportUpdate extends Omit<TransportCreate, 'idempotencyKey'>
 }
 
 const endpointByKind: Record<CrossBorderBusinessKind, string> = {
-  procurement: '/merchant/v1/last-leg/overseas-procurements',
   trucking: '/merchant/v1/last-leg/us-truck-orders',
   looseboard: '/merchant/v1/last-leg/local-looseboard-orders',
 }
@@ -141,23 +91,19 @@ function normalizePage<T>(data: PageResult<T>): PageResult<T> {
 }
 
 export function listBusinessOrders<T>(kind: CrossBorderBusinessKind, params: BusinessOrderQuery) {
-  return overseasApiRequest<PageResult<T>>({ method: 'GET', url: endpointByKind[kind], params }).then(normalizePage)
+  return apiRequest<PageResult<T>>({ method: 'GET', url: endpointByKind[kind], params }).then(normalizePage)
 }
 
 export function getBusinessOrder<T>(kind: CrossBorderBusinessKind, orderNo: string) {
-  return overseasApiRequest<T>({ method: 'GET', url: `${endpointByKind[kind]}/${encodeURIComponent(orderNo)}` })
+  return apiRequest<T>({ method: 'GET', url: `${endpointByKind[kind]}/${encodeURIComponent(orderNo)}` })
-}
-
-export function createProcurement(payload: ProcurementCreate) {
-  return overseasApiRequest<ProcurementDetail>({ method: 'POST', url: endpointByKind.procurement, data: payload })
 }
 
 export function createTransport(kind: 'trucking' | 'looseboard', payload: TransportCreate) {
-  return overseasApiRequest<TransportDetail>({ method: 'POST', url: endpointByKind[kind], data: payload })
+  return apiRequest<TransportDetail>({ method: 'POST', url: endpointByKind[kind], data: payload })
 }
 
 export function updateTransport(kind: 'trucking' | 'looseboard', orderNo: string, payload: TransportUpdate) {
-  return overseasApiRequest<TransportDetail>({
+  return apiRequest<TransportDetail>({
     method: kind === 'trucking' ? 'PATCH' : 'PUT',
     url: `${endpointByKind[kind]}/${encodeURIComponent(orderNo)}`,
     data: payload,

src/modules/cross-border/api/procurement.ts

@@ -0,0 +1,108 @@
+import { apiRequest } from '@/api/http'
+import type { PageResult } from './businessOrders'
+
+export type Amount = number | string
+export interface ProcurementSummary {
+  orderNo: string
+  purchaseCategory: string
+  productName: string
+  productSpecification: string | null
+  purchaseQuantity: number
+  budgetUnitPrice: Amount | null
+  currency: string | null
+  status: string
+  version: number
+  createdAt: string
+  updatedAt: string
+}
+export interface ProcurementOrder extends ProcurementSummary {
+  productUrl: string | null
+  receivingAddress: string
+  contactName: string
+  contactPhone: string
+  estimatedArrivalAt: string | null
+  plannedWarehouseName: string | null
+  actualWarehouseCode: string | null
+  actualWarehouseName: string | null
+}
+export interface ProcurementFee {
+  feeNo: string
+  purpose: string
+  name: string
+  version: number | null
+  active: boolean
+  determination: string
+  amount: Amount
+  currency: string
+  originalAmount: Amount | null
+  originalCurrency: string | null
+  exchangeRate: Amount | null
+  exchangeRateMonth: string | null
+  businessDate: string | null
+  parentFeeNo: string | null
+  walletStatus: string | null
+  sourceLinked: boolean
+}
+export interface ProcurementBox {
+  cartonNo: string
+  quantity: number
+  lengthCm: Amount
+  widthCm: Amount
+  heightCm: Amount
+  grossWeightKg: Amount
+}
+export interface ProcurementShipment {
+  shipmentNo: string
+  leg: 'OVERSEAS' | 'DOMESTIC'
+  shippedAt: string
+  cartonNo: string
+  quantity: number
+  carrier: string
+  trackingNo: string
+}
+export interface ProcurementDetail {
+  order: ProcurementOrder
+  budget: { totalAmount: Amount | null; currency: string; authorizedAt: string | null }
+  purchased: boolean
+  purchaseConfirmed: boolean
+  purchaseNeedsAttention: boolean
+  progress: { key: string; title: string; completedAt: string | null }[]
+  boxes: ProcurementBox[]
+  shipments: ProcurementShipment[]
+  fees: ProcurementFee[]
+  exceptionSummaries: string[]
+}
+export interface ProcurementCreate {
+  customerName: string
+  purchaseCategory: string
+  productName: string
+  productSpecification?: string
+  productUrl?: string
+  purchaseQuantity: number
+  budgetUnitPrice: number
+  currency: 'CNY' | 'USD'
+  receivingAddress: string
+  contactName: string
+  contactPhone: string
+  remark?: string
+  idempotencyKey: string
+}
+export interface ProcurementQuery {
+  page: number
+  size: number
+  orderNo?: string
+  productName?: string
+  purchaseCategory?: string
+  status?: string
+}
+const endpoint = '/merchant/v1/last-leg/overseas-procurements'
+export async function listProcurements(params: ProcurementQuery) {
+  const result = await apiRequest<PageResult<ProcurementSummary>>({ method: 'GET', url: endpoint, params })
+  return { ...result, page: Number(result.page), size: Number(result.size), total: Number(result.total), pages: Number(result.pages) }
+}
+export function getProcurement(orderNo: string) {
+  return apiRequest<ProcurementDetail>({ method: 'GET', url: `${endpoint}/${encodeURIComponent(orderNo)}` })
+}
+export function createProcurement(data: ProcurementCreate) {
+  return apiRequest<ProcurementDetail>({ method: 'POST', url: endpoint, data })
+}

src/modules/cross-border/businessOrders.test.mjs

@@ -1,24 +1,58 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import test from 'node:test'
+import { runInNewContext } from 'node:vm'
+import ts from 'typescript'
 
 const api = readFileSync(new URL('./api/businessOrders.ts', import.meta.url), 'utf8')
 const routes = readFileSync(new URL('./routes.ts', import.meta.url), 'utf8')
 const view = readFileSync(new URL('./components/BusinessOrdersView.vue', import.meta.url), 'utf8')
+const procurementApi = readFileSync(new URL('./api/procurement.ts', import.meta.url), 'utf8')
+const procurementView = readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8')
+
+test('renders unknown pallet service and container type as dashes while preserving explicit values', () => {
+  const helpers = view.slice(view.indexOf('function read('), view.indexOf('function idempotencyKey('))
+  const compiled = ts.transpileModule(helpers, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const { displayCell, yesNo, text } = runInNewContext(`${compiled}\n({ displayCell, yesNo, text })`)
+  assert.equal(displayCell({ palletRequired: null }, 'palletRequired'), '—')
+  assert.equal(displayCell({ palletRequired: 'NO' }, 'palletRequired'), '否')
+  assert.equal(displayCell({ palletRequired: 'YES' }, 'palletRequired'), '是')
+  assert.equal(displayCell({ containerType: null }, 'containerType'), '—')
+  assert.equal(displayCell({ containerType: '40HQ' }, 'containerType'), '40HQ')
+  assert.equal(yesNo(null), '—')
+  assert.equal(text(null), '—')
+  assert.match(api, /palletRequired\?: string \| null/)
+  const create = api.slice(api.indexOf('export interface TransportCreate'), api.indexOf('export interface TransportUpdate'))
+  assert.doesNotMatch(create, /palletRequired\?: string \| null/)
+})
+
+test('shows merchant-owned arrangement facts without a pool request or editable status control', () => {
+  assert.match(api, /fleetArrangement: import\('\.\.\/fleetArrangement'\)\.FleetArrangement \| null/)
+  assert.match(view, /aria-label="承运安排"/)
+  for (const field of ['signedPackages', 'unsignedPackages', 'returnedPackages', 'readOnlyReason']) assert.ok(view.includes(`fleetArrangement.${field}`))
+  assert.doesNotMatch(api, /capacity-offers|fleet\/trips/)
+  assert.match(view, /if \(query\.page !== 1\) query\.page = 1\s+else void load\(\)/)
+  assert.match(view, /if \(reloadDirectly\) void load\(\)/)
+})
 
 test('activates all three customer cross-border pages with frozen permissions', () => {
   for (const [path, permission] of [
-    ['cross-border/procurement', 'merchant:cross-border:procurement'],
+    ['cross-border/procurement', 'merchant:cross-border:procurement:list'],
-    ['cross-border/domestic-trucking', 'merchant:cross-border:domestic-trucking'],
+    ['cross-border/domestic-trucking', 'merchant:cross-border:domestic-trucking:list'],
-    ['cross-border/pallet-shipping', 'merchant:cross-border:pallet-shipping'],
+    ['cross-border/pallet-shipping', 'merchant:cross-border:pallet-shipping:list'],
   ]) {
     assert.match(routes, new RegExp(`path: '${path}'[\\s\\S]*?release: 'active'[\\s\\S]*?permission: '${permission}'`))
   }
   assert.doesNotMatch(view, /PrototypeFeatureView|mock|customerId|tenantId/i)
+  assert.match(procurementView, /merchant:cross-border:procurement:create/)
+  assert.match(view, /merchant:cross-border:domestic-trucking:create/)
+  assert.match(view, /merchant:cross-border:pallet-shipping:create/)
+  assert.match(view, /v-if="canCreate"[^>]*type="primary"/)
 })
 
 test('uses only merchant overseas endpoints and keeps retry idempotency stable', () => {
-  assert.match(api, /overseas-procurements/)
+  assert.match(procurementApi, /overseas-procurements/)
+  assert.doesNotMatch(api, /overseas-procurements|ProcurementSummary|ProcurementDetail/)
   assert.match(api, /us-truck-orders/)
   assert.match(api, /local-looseboard-orders/)
   assert.doesNotMatch(api, /\/platform\/|\/internal\/|customerId|tenantId/)
@@ -32,21 +66,52 @@ test('covers list detail create loading error empty pagination and actions-first
   assert.match(view, /mode\.value = 'list'/)
   assert.match(view, /mode = 'create'/)
   assert.match(view, /v-loading="loading"/)
-  assert.match(view, /type="error"/)
+  assert.match(view, /class="business-load-error"/)
   assert.match(view, /empty-text="暂无订单"/)
-  assert.match(view, /<el-pagination/)
+  assert.match(view, /<QueryToolbar[^>]*layout="grid"/)
-  assert.match(view, /<el-table-column label="操作"[^>]*fixed="left"/)
+  assert.match(view, /<DataTable[^>]*:row-actions="getRowActions"/)
-  assert.match(view, /PENDING_OUTBOUND: '待出库'/)
+  assert.match(view, /key: 'actions', label: '操作', width: 90, fixed: 'left'/)
-  assert.match(view, /PARTIALLY_OUTBOUND: '部分出库'/)
+  assert.match(view, /class="business-table-card"/)
-  assert.match(view, /OUTBOUNDED: '全部出库'/)
+  assert.doesNotMatch(procurementView, /inventoryQuantity|outboundQuantity|reviewRemark/)
-  assert.match(view, /\['入库量', read\(summary, 'inboundQuantity'\)\]/)
+  assert.match(procurementView, /procurementStatuses/)
-  assert.match(view, /\['审核备注', current\.reviewRemark\]/)
+  assert.match(procurementView, /ProcurementDetailPanel/)
 })
 
-test('keeps procurement filters, details and forms readable at PDA width', () => {
+test('opens every dashboard cross-border action on a dedicated protected create page', () => {
+  for (const [path, permission] of [
+    ['cross-border/procurement/create', 'merchant:cross-border:procurement:create'],
+    ['cross-border/domestic-trucking/create', 'merchant:cross-border:domestic-trucking:create'],
+    ['cross-border/pallet-shipping/create', 'merchant:cross-border:pallet-shipping:create'],
+  ]) {
+    assert.match(routes, new RegExp(`path: '${path}'[\\s\\S]*?props: \\{ createPage: true \\}[\\s\\S]*?permission: '${permission}'`))
+  }
+  assert.match(view, /props\.createPage \? 'create' : 'list'/)
+  assert.match(view, /if \(props\.createPage\) await router\.push/)
+})
+
+test('opens all cross-border details on dedicated protected routes', () => {
+  for (const [path, routeName] of [
+    ['cross-border/procurement/:orderNo/detail', 'cross-border-procurement-detail'],
+    ['cross-border/domestic-trucking/:orderNo/detail', 'cross-border-domestic-trucking-detail'],
+    ['cross-border/pallet-shipping/:orderNo/detail', 'cross-border-pallet-shipping-detail'],
+  ]) {
+    assert.match(routes, new RegExp(`path: '${path.replaceAll('/', '\\/')}'[\\s\\S]*?name: '${routeName}'`))
+  }
+  assert.match(view, /name: detailRouteName\.value, params: \{ orderNo: row\.orderNo \}/)
+  assert.match(view, /class="business-detail-error"/)
+})
+
+test('preserves the existing transport responsive rules without adding a narrow-screen procurement acceptance gate', () => {
   assert.match(view, /@media \(max-width: 767px\)/)
-  assert.match(view, /\.filter-card :deep\(\.el-form\) \{ display: grid; grid-template-columns: 1fr; \}/)
+  assert.match(view, /queryFields/)
   assert.match(view, /\.detail-grid \{ grid-template-columns: 1fr; \}/)
   assert.match(view, /\.form-card :deep\(\.el-form-item\) \{ display: block; \}/)
   assert.match(view, /\.budget-form-item :deep\(\.el-form-item__content\) \{ display: flex; flex-wrap: nowrap; \}/)
 })
+
+test('uses the shared dense order-list and detail visual language', () => {
+  assert.match(view, /class="business-orders client-ui"/)
+  assert.match(view, /\.business-detail-page \{[^}]*border: 1px solid var\(--client-border\);[^}]*border-radius: var\(--client-radius\);/)
+  assert.match(view, /\.detail-grid \{[^}]*grid-template-columns: repeat\(4, minmax\(0, 1fr\)\)/)
+  assert.match(view, /\.detail-grid div \{[^}]*min-height: 34px;[^}]*grid-template-columns: 76px minmax\(0, 1fr\)/)
+})

src/modules/cross-border/components/BusinessOrdersView.vue

@@ -1,35 +1,39 @@
 <script setup lang="ts">
-import { computed, onMounted, reactive, ref } from 'vue'
+import { computed, onMounted, reactive, ref, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
 import { ElMessage, type FormInstance, type FormRules } from 'element-plus'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
+import QueryToolbar, { type QueryField, type QueryModel } from '@/components/common/QueryToolbar.vue'
+import type { TableAction } from '@/components/common/tableActions'
 import { useAuthStore } from '@/modules/auth/public'
 import {
-  createProcurement,
   createTransport,
   getBusinessOrder,
   listBusinessOrders,
   type CrossBorderBusinessKind,
-  type ProcurementDetail,
-  type ProcurementSummary,
   type TransportDetail,
   type TransportSummary,
 } from '../api/businessOrders'
 import { CONTAINER_SPECIFICATIONS, DEFAULT_CONTAINER_TYPE } from '../containerSpecifications'
+import { poolOrderStatusLabels } from '../fleetArrangement'
 
-const props = defineProps<{ kind: CrossBorderBusinessKind }>()
+const props = withDefaults(defineProps<{ kind: CrossBorderBusinessKind; createPage?: boolean; detailPage?: boolean }>(), { createPage: false, detailPage: false })
 const auth = useAuthStore()
+const router = useRouter()
+const route = useRoute()
+const detailOrderNo = computed(() => String(route.params.orderNo || ''))
+const canCreate = computed(() => auth.hasPermission(({
+  trucking: 'merchant:cross-border:domestic-trucking:create',
+  looseboard: 'merchant:cross-border:pallet-shipping:create',
+} as Record<CrossBorderBusinessKind, string>)[props.kind]))
 
-type BusinessRow = ProcurementSummary | TransportSummary
+type BusinessRow = TransportSummary
-type BusinessDetail = ProcurementDetail | TransportDetail
+type BusinessDetail = TransportDetail
 type PageMode = 'list' | 'create' | 'detail'
 
 interface ColumnDefinition { key: string; label: string; width?: number }
 
 interface BusinessForm {
-  purchaseCategory: string
-  productName: string
-  productSpecification: string
-  productUrl: string
-  purchaseQuantity: number
   transportMode: string
   palletRequired: string
   transportType: string
@@ -47,28 +51,10 @@ interface BusinessForm {
   contactName: string
   contactInfo: string
   requestedDate: string
-  receivingAddress: string
   remark: string
 }
 
 const configuration = computed(() => ({
-  procurement: {
-    title: '海外采购',
-    description: '查询并管理海外采购订单',
-    columns: [
-      { key: 'orderNo', label: '订单号', width: 180 },
-      { key: 'purchaseCategory', label: '采购品类', width: 130 },
-      { key: 'productName', label: '商品名称', width: 160 },
-      { key: 'productSpecification', label: '商品规格', width: 160 },
-      { key: 'purchaseQuantity', label: '采购数量', width: 100 },
-      { key: 'budgetUnitPrice', label: '预算单价', width: 110 },
-      { key: 'inboundQuantity', label: '入库量', width: 90 },
-      { key: 'outboundQuantity', label: '出库量', width: 90 },
-      { key: 'inventoryQuantity', label: '库存量', width: 90 },
-      { key: 'status', label: '状态', width: 120 },
-      { key: 'createdAt', label: '创建时间', width: 170 },
-    ] satisfies ColumnDefinition[],
-  },
   trucking: {
     title: '美国本土卡',
     description: '查询并管理美国本土卡订单',
@@ -93,25 +79,59 @@ function transportColumns(looseboard: boolean): ColumnDefinition[] {
     { key: 'budgetAmount', label: '预算总价', width: 110 },
     { key: 'requestedDate', label: '要求时间', width: 120 },
     { key: 'status', label: '状态', width: 130 },
+    { key: 'fleetArrangement', label: '承运安排', width: 190 },
   ]
 }
 
-const mode = ref<PageMode>('list')
+const mode = ref<PageMode>(props.detailPage ? 'detail' : props.createPage ? 'create' : 'list')
 const loading = ref(false)
 const submitting = ref(false)
 const submitKey = ref('')
 const error = ref('')
 const rows = ref<BusinessRow[]>([])
 const detail = ref<BusinessDetail | null>(null)
+const fleetArrangement = computed(() => detail.value ? (detail.value as TransportDetail).summary.fleetArrangement : null)
 const formRef = ref<FormInstance>()
-const query = reactive({ page: 1, size: 20, orderNo: '', routeKeyword: '', status: '', productName: '', purchaseCategory: '' })
+const query = reactive({ page: 1, size: 20, orderNo: '', routeKeyword: '', status: '' })
 const total = ref(0)
 
+const queryModel = computed<QueryModel>({
+  get: () => ({
+    orderNo: query.orderNo,
+    routeKeyword: query.routeKeyword,
+    status: query.status,
+  }),
+  set: (value) => {
+    query.orderNo = String(value.orderNo || '')
+    query.routeKeyword = String(value.routeKeyword || '')
+    query.status = String(value.status || '')
+  },
+})
+
+const queryFields = computed<QueryField[]>(() => [
+  { key: 'orderNo', label: '订单号', type: 'input', placeholder: '请输入订单号' },
+  { key: 'routeKeyword', label: '运输路线', type: 'input', placeholder: '请输入起运地或目的地' },
+  {
+    key: 'status',
+    label: '状态',
+    type: 'select',
+    placeholder: '全部',
+    options: [
+      { label: '待审核', value: 'PENDING_REVIEW' },
+      { label: '已通过', value: 'APPROVED' },
+      { label: '已拒绝', value: 'REJECTED' },
+      { label: '待接单', value: 'PENDING_ACCEPTANCE' },
+      ...Object.entries(poolOrderStatusLabels).filter(([value]) => !['IN_TRANSIT', 'COMPLETED', 'CANCELLED'].includes(value)).map(([value, label]) => ({ value, label })),
+      { label: '处理中', value: 'PROCESSING' },
+      { label: '运输中', value: 'IN_TRANSIT' },
+      { label: '已完成', value: 'COMPLETED' },
+      { label: '已取消', value: 'CANCELLED' },
+    ],
+  },
+])
+
 const form = reactive<BusinessForm>(emptyForm())
 const rules: FormRules<BusinessForm> = {
-  purchaseCategory: [{ required: true, message: '请输入采购品类', trigger: 'blur' }],
-  productName: [{ required: true, message: '请输入商品名称', trigger: 'blur' }],
-  purchaseQuantity: [{ required: true, type: 'number', min: 1, message: '采购数量至少为 1', trigger: 'change' }],
   origin: [{ required: true, message: '请输入起运地', trigger: 'blur' }],
   destination: [{ required: true, message: '请输入目的地', trigger: 'blur' }],
   palletCount: [{ required: true, type: 'number', min: 1, message: '托盘数至少为 1', trigger: 'change' }],
@@ -123,24 +143,9 @@ const rules: FormRules<BusinessForm> = {
 const detailFields = computed(() => {
   if (!detail.value) return []
   const summary = detail.value.summary
-  if (props.kind === 'procurement') {
-    const current = detail.value as ProcurementDetail
-    return [
-      ['订单号', summary.orderNo], ['采购品类', read(summary, 'purchaseCategory')],
-      ['商品名称', read(summary, 'productName')], ['商品规格', read(summary, 'productSpecification')],
-      ['采购数量', read(summary, 'purchaseQuantity')], ['预算单价', money(read(summary, 'budgetUnitPrice'), read(summary, 'currency'))],
-      ['入库量', read(summary, 'inboundQuantity')], ['出库量', read(summary, 'outboundQuantity')],
-      ['库存量', read(summary, 'inventoryQuantity')], ['预计到达时间', dateTime(current.estimatedArrivalAt)],
-      ['联系人', current.contactName], ['联系电话', current.contactPhone],
-      ['收货地址', current.receivingAddress], ['商品链接', current.productUrl],
-      ['国内运单', joinText(current.domesticCarrier, current.domesticTrackingNo)],
-      ['海外运单', joinText(current.overseasCarrier, current.overseasTrackingNo)],
-      ['状态', statusLabel(summary.status)], ['审核备注', current.reviewRemark], ['备注', current.remark],
-    ]
-  }
   const current = detail.value as TransportDetail
   return [
-    ['订单编号', summary.orderNo], ['运输方式', read(summary, 'transportMode')],
+    ['运输方式', transportModeLabel(read(summary, 'transportMode'))],
     ['是否打盘', yesNo(read(summary, 'palletRequired'))], ['运输类型', transportTypeLabel(read(summary, 'transportType'))],
     ['起运地', read(summary, 'origin')], ['起运地址', current.originAddress],
     ['目的地', read(summary, 'destination')], ['目的地址', current.destinationAddress],
@@ -148,31 +153,45 @@ const detailFields = computed(() => {
     ['件数', read(summary, 'packageCount')], ['总重量(kg)', read(summary, 'totalWeightKg')],
     ['总体积(m³)', read(summary, 'totalVolumeCbm')], ['预算总价', money(read(summary, 'budgetAmount'), read(summary, 'currency'))],
     ['联系人', read(summary, 'contactName')], ['联系方式', read(summary, 'contactInfo')],
-    ['要求时间', read(summary, 'requestedDate')], ['状态', statusLabel(summary.status)], ['备注', current.remark],
+    ['要求时间', read(summary, 'requestedDate')], ['备注', current.remark],
   ]
 })
 
+const tableColumns = computed<DataTableColumn[]>(() => [
+  { key: 'actions', label: '操作', width: 90, fixed: 'left', slotName: 'actions' },
+  ...configuration.value.columns.map((column) => ({
+    ...column,
+    prop: column.key,
+    slotName: ['orderNo', 'status', 'fleetArrangement'].includes(column.key) ? column.key : undefined,
+    formatter: (row: object) => displayCell(row, column.key),
+  })),
+])
+
+const detailStatus = computed(() => detail.value ? statusLabel(detail.value.summary.status) : '—')
+
 function emptyForm(): BusinessForm {
   return {
-    purchaseCategory: '', productName: '', productSpecification: '', productUrl: '', purchaseQuantity: 1,
     transportMode: 'SHARED_TRUCK', palletRequired: 'NO', transportType: 'PORT_PICKUP', origin: '', originAddress: '',
     destination: '', destinationAddress: '', containerType: DEFAULT_CONTAINER_TYPE, palletCount: 1, packageCount: 0,
     totalWeightKg: 0, totalVolumeCbm: 0, currency: 'USD', contactName: '', contactInfo: '', requestedDate: '',
-    receivingAddress: '', remark: '',
+    remark: '',
   }
 }
 
 function resetForm() { Object.assign(form, emptyForm()); submitKey.value = ''; formRef.value?.clearValidate() }
 function read(source: object, key: string) { return Reflect.get(source, key) as unknown }
 function text(value: unknown) { return value === null || value === undefined || value === '' ? '—' : String(value) }
-function joinText(...values: unknown[]) { const result = values.filter(Boolean).join(' / '); return result || '—' }
 function money(amount: unknown, currency: unknown) { return amount === null || amount === undefined ? '—' : `${text(currency)} ${Number(amount).toFixed(2)}` }
 function dateTime(value: unknown) { return value ? new Date(String(value)).toLocaleString('zh-CN', { hour12: false }) : '—' }
 function yesNo(value: unknown) { return value === 'YES' ? '是' : value === 'NO' ? '否' : text(value) }
 function transportTypeLabel(value: unknown) { return ({ PORT_PICKUP: '港口提柜', WAREHOUSE_TO_WAREHOUSE: '仓到仓', WAREHOUSE_TO_DOOR: '仓到门' } as Record<string, string>)[String(value)] || text(value) }
 function transportModeLabel(value: unknown) { return ({ SHARED_TRUCK: '拼车', PRIORITY_CONSOLIDATION: '优先拼载' } as Record<string, string>)[String(value)] || text(value) }
 function statusLabel(value: unknown) {
-  return ({ PENDING_REVIEW: '待审核', APPROVED: '已通过', REJECTED: '已拒绝', PENDING_OUTBOUND: '待出库', PARTIALLY_OUTBOUND: '部分出库', OUTBOUNDED: '全部出库', PENDING_ACCEPTANCE: '待接单', PROCESSING: '处理中', IN_TRANSIT: '运输中', COMPLETED: '已完成', CANCELLED: '已取消' } as Record<string, string>)[String(value)] || text(value)
+  if (poolOrderStatusLabels[String(value)]) return poolOrderStatusLabels[String(value)]
+  return ({ PENDING_REVIEW: '待审核', APPROVED: '已通过', REJECTED: '已拒绝', PENDING_ACCEPTANCE: '待接单', PROCESSING: '处理中', IN_TRANSIT: '运输中', COMPLETED: '已完成', CANCELLED: '已取消' } as Record<string, string>)[String(value)] || text(value)
+}
+function statusTone(value: unknown) {
+  return ({ APPROVED: 'success', COMPLETED: 'success', REJECTED: 'danger', CANCELLED: 'info', PENDING_REVIEW: 'warning', PENDING_ACCEPTANCE: 'warning', PROCESSING: 'primary', IN_TRANSIT: 'primary' } as Record<string, 'success' | 'warning' | 'danger' | 'info' | 'primary'>)[String(value)] || 'info'
 }
 function displayCell(candidate: unknown, key: string) {
   const row = candidate as BusinessRow
@@ -182,7 +201,7 @@ function displayCell(candidate: unknown, key: string) {
   if (key === 'transportMode') return transportModeLabel(value)
   if (key === 'palletRequired') return yesNo(value)
   if (key === 'createdAt') return dateTime(value)
-  if (key === 'budgetUnitPrice' || key === 'budgetAmount') return money(value, read(row, 'currency'))
+  if (key === 'budgetAmount') return money(value, read(row, 'currency'))
   return text(value)
 }
 function idempotencyKey() { return globalThis.crypto?.randomUUID?.() || `client-${Date.now()}-${Math.random().toString(16).slice(2)}` }
@@ -194,12 +213,9 @@ async function load() {
   try {
     const params = {
       page: query.page, size: query.size, orderNo: query.orderNo || undefined, status: query.status || undefined,
-      routeKeyword: query.routeKeyword || undefined, productName: query.productName || undefined,
+      routeKeyword: query.routeKeyword || undefined,
-      purchaseCategory: query.purchaseCategory || undefined,
     }
-    const result = props.kind === 'procurement'
+    const result = await listBusinessOrders<TransportSummary>(props.kind, params)
-      ? await listBusinessOrders<ProcurementSummary>('procurement', params)
-      : await listBusinessOrders<TransportSummary>(props.kind, params)
     rows.value = result.records
     total.value = result.total
   } catch (cause) {
@@ -210,20 +226,53 @@ async function load() {
 }
 
 function resetQuery() {
-  Object.assign(query, { page: 1, orderNo: '', routeKeyword: '', status: '', productName: '', purchaseCategory: '' })
+  const reloadDirectly = query.page === 1
-  void load()
+  Object.assign(query, { page: 1, orderNo: '', routeKeyword: '', status: '' })
+  if (reloadDirectly) void load()
 }
 
-async function openDetail(candidate: unknown) {
+function searchOrders() {
+  if (query.page !== 1) query.page = 1
+  else void load()
+}
+
+function getRowActions(candidate: object): TableAction[] {
+  return [{ key: 'detail', label: '详情', run: () => openDetail(candidate) }]
+}
+
+function detailFieldClass(label: unknown) {
+  return ['备注', '起运地址', '目的地址'].includes(String(label)) ? 'is-wide' : ''
+}
+
+const listRouteName = computed(() => ({
+  trucking: 'cross-border-domestic-trucking',
+  looseboard: 'cross-border-pallet-shipping',
+} as Record<CrossBorderBusinessKind, string>)[props.kind])
+const detailRouteName = computed(() => ({
+  trucking: 'cross-border-domestic-trucking-detail',
+  looseboard: 'cross-border-pallet-shipping-detail',
+} as Record<CrossBorderBusinessKind, string>)[props.kind])
+
+function returnToList() {
+  if (props.createPage || props.detailPage) {
+    void router.push({ name: listRouteName.value })
+    return
+  }
+  mode.value = 'list'
+}
+
+function openDetail(candidate: unknown) {
   const row = candidate as BusinessRow
+  void router.push({ name: detailRouteName.value, params: { orderNo: row.orderNo } })
+}
+async function loadDetail() {
+  if (!detailOrderNo.value) return
   loading.value = true
   error.value = ''
   try {
-    detail.value = props.kind === 'procurement'
+    detail.value = await getBusinessOrder<TransportDetail>(props.kind, detailOrderNo.value)
-      ? await getBusinessOrder<ProcurementDetail>('procurement', row.orderNo)
-      : await getBusinessOrder<TransportDetail>(props.kind, row.orderNo)
     mode.value = 'detail'
-  } catch (cause) { ElMessage.error(errorMessage(cause)) }
+  } catch (cause) { detail.value = null; error.value = errorMessage(cause); ElMessage.error(error.value) }
   finally { loading.value = false }
 }
 
@@ -233,95 +282,88 @@ async function submit() {
   const stableSubmitKey = submitKey.value || idempotencyKey()
   submitKey.value = stableSubmitKey
   try {
-    if (props.kind === 'procurement') {
+    const base = {
-      await createProcurement({
+      transportType: form.transportType, origin: form.origin, originAddress: form.originAddress || undefined,
-        customerName: auth.user?.tenantName || '',
+      destination: form.destination, destinationAddress: form.destinationAddress || undefined,
-        purchaseCategory: form.purchaseCategory, productName: form.productName,
+      containerType: form.containerType || undefined, packageCount: form.packageCount,
-        productSpecification: form.productSpecification || undefined, productUrl: form.productUrl || undefined,
+      totalWeightKg: form.totalWeightKg, totalVolumeCbm: form.totalVolumeCbm,
-        purchaseQuantity: form.purchaseQuantity, budgetUnitPrice: form.budgetAmount,
+      budgetAmount: form.budgetAmount, currency: form.currency || undefined,
-        currency: form.currency || undefined, receivingAddress: form.receivingAddress || undefined,
+      contactName: form.contactName || undefined, contactInfo: form.contactInfo || undefined,
-        contactName: form.contactName, contactPhone: form.contactInfo, remark: form.remark || undefined,
+      requestedDate: form.requestedDate || undefined, remark: form.remark || undefined,
-        idempotencyKey: stableSubmitKey,
+      idempotencyKey: stableSubmitKey,
-      })
-    } else {
-      const base = {
-        transportType: form.transportType, origin: form.origin, originAddress: form.originAddress || undefined,
-        destination: form.destination, destinationAddress: form.destinationAddress || undefined,
-        containerType: form.containerType || undefined, packageCount: form.packageCount,
-        totalWeightKg: form.totalWeightKg, totalVolumeCbm: form.totalVolumeCbm,
-        budgetAmount: form.budgetAmount, currency: form.currency || undefined,
-        contactName: form.contactName || undefined, contactInfo: form.contactInfo || undefined,
-        requestedDate: form.requestedDate || undefined, remark: form.remark || undefined,
-        idempotencyKey: stableSubmitKey,
-      }
-      await createTransport(props.kind, props.kind === 'trucking'
-        ? { ...base, palletCount: form.palletCount }
-        : { ...base, transportMode: form.transportMode, palletRequired: form.palletRequired })
     }
+    await createTransport(props.kind, props.kind === 'trucking'
+      ? { ...base, palletCount: form.palletCount }
+      : { ...base, transportMode: form.transportMode, palletRequired: form.palletRequired })
     ElMessage.success('订单提交成功')
-    mode.value = 'list'
     resetForm()
-    await load()
+    if (props.createPage) await router.push({ name: listRouteName.value })
+    else { mode.value = 'list'; await load() }
   } catch (cause) { ElMessage.error(errorMessage(cause)) }
   finally { submitting.value = false }
 }
 
-onMounted(() => void load())
+watch(() => [query.page, query.size], () => { if (!props.createPage && mode.value === 'list') void load() })
+onMounted(() => { if (props.detailPage) void loadDetail(); else if (!props.createPage) void load() })
 </script>
 
 <template>
-  <section v-loading="loading" class="business-orders" :aria-busy="loading">
+  <section v-loading="loading" class="business-orders client-ui" :aria-busy="loading">
-    <header class="page-head">
+    <header v-if="mode === 'create'" class="page-head">
       <div>
-        <h2>{{ mode === 'detail' ? `${configuration.title}订单详情` : mode === 'create' ? `${configuration.title}下单` : configuration.title }}</h2>
+        <h2>{{ configuration.title }}下单</h2>
-        <p>{{ mode === 'list' ? configuration.description : mode === 'create' ? '请填写订单信息，带 * 项为必填项' : `订单号：${detail?.summary.orderNo || '—'}` }}</p>
+        <p>请填写订单信息，带 * 项为必填项</p>
       </div>
-      <el-button v-if="mode !== 'list'" @click="mode = 'list'">返回列表</el-button>
+      <el-button @click="returnToList">返回列表</el-button>
-      <el-button v-else type="primary" @click="resetForm(); mode = 'create'">新增下单</el-button>
     </header>
 
     <template v-if="mode === 'list'">
-      <el-alert v-if="error" :title="error" type="error" show-icon :closable="false">
+      <QueryToolbar v-model="queryModel" layout="grid" ariaLabel="订单查询条件" :fields="queryFields" :search-on-reset="false" @search="searchOrders" @reset="resetQuery" />
-        <template #default><el-button size="small" @click="load">重新加载</el-button></template>
+      <div class="business-table-card">
-      </el-alert>
+        <DataTable v-model:page="query.page" v-model:page-size="query.size" :data="rows" :columns="tableColumns" :loading="loading" :total="total" :page-sizes="[10, 20, 50, 100]" :row-actions="getRowActions" row-key="orderNo" empty-text="暂无订单">
-      <el-card shadow="never" class="filter-card">
+          <template #toolbar-actions><el-button v-if="canCreate" type="primary" @click="resetForm(); mode = 'create'">新增下单</el-button></template>
-        <el-form inline @submit.prevent="query.page = 1; load()">
+          <template v-if="error" #error><div class="business-load-error" role="alert"><span>{{ error }}</span><el-button size="small" @click="load">重新加载</el-button></div></template>
-          <el-form-item label="订单号"><el-input v-model.trim="query.orderNo" clearable placeholder="请输入订单号" /></el-form-item>
+          <template #orderNo="{ row }"><button class="business-order-link" type="button" @click="openDetail(row)">{{ (row as BusinessRow).orderNo }}</button></template>
-          <el-form-item v-if="kind === 'procurement'" label="采购品类"><el-input v-model.trim="query.purchaseCategory" clearable placeholder="请输入采购品类" /></el-form-item>
+          <template #status="{ row }"><el-tag :type="statusTone((row as BusinessRow).status)" effect="light" size="small">{{ statusLabel((row as BusinessRow).status) }}</el-tag></template>
-          <el-form-item v-if="kind === 'procurement'" label="商品名称"><el-input v-model.trim="query.productName" clearable placeholder="请输入商品名称" /></el-form-item>
+          <template #fleetArrangement="{ row }"><template v-if="(row as TransportSummary).fleetArrangement"><div>{{ poolOrderStatusLabels[(row as TransportSummary).fleetArrangement!.fulfillmentStage] || '待核对履约进度' }}</div><small>{{ dateTime((row as TransportSummary).fleetArrangement!.plannedDepartureAt) }}</small></template><span v-else>—</span></template>
-          <el-form-item v-else label="运输路线"><el-input v-model.trim="query.routeKeyword" clearable placeholder="起运地或目的地" /></el-form-item>
+        </DataTable>
-          <el-form-item label="状态"><el-input v-model.trim="query.status" clearable placeholder="请输入状态" /></el-form-item>
+      </div>
-          <el-form-item><el-button type="primary" native-type="submit">查询</el-button><el-button @click="resetQuery">重置</el-button></el-form-item>
-        </el-form>
-      </el-card>
-      <el-card shadow="never">
-        <el-table :data="rows" empty-text="暂无订单" border>
-          <el-table-column label="操作" width="90" fixed="left"><template #default="scope"><el-button link type="primary" @click="openDetail(scope.row)">查看</el-button></template></el-table-column>
-          <el-table-column v-for="column in configuration.columns" :key="column.key" :label="column.label" :width="column.width" show-overflow-tooltip>
-            <template #default="scope">{{ displayCell(scope.row, column.key) }}</template>
-          </el-table-column>
-        </el-table>
-        <el-pagination v-model:current-page="query.page" v-model:page-size="query.size" class="pagination" :total="total" :page-sizes="[10, 20, 50, 100]" layout="total, sizes, prev, pager, next" @change="load" />
-      </el-card>
     </template>
 
-    <el-card v-else-if="mode === 'detail'" shadow="never">
+    <section v-else-if="mode === 'detail'" class="business-detail-page" aria-label="订单详情">
-      <dl class="detail-grid">
+      <header class="business-detail-heading">
-        <div v-for="field in detailFields" :key="String(field[0])"><dt>{{ field[0] }}</dt><dd>{{ text(field[1]) }}</dd></div>
+        <div class="business-detail-heading-main"><el-button link type="primary" @click="returnToList">← 返回列表</el-button><div><h2>{{ detail?.summary.orderNo || '订单详情' }}</h2><p>{{ configuration.title }}订单</p></div></div>
-      </dl>
+        <el-tag :type="statusTone(detail?.summary.status)" effect="light">{{ detailStatus }}</el-tag>
-    </el-card>
+      </header>
+      <div v-if="error" class="business-detail-error" role="alert"><strong>{{ error }}</strong><el-button size="small" @click="loadDetail">重新加载</el-button></div>
+      <section v-else class="business-detail-section">
+        <h3>订单信息</h3>
+        <dl class="detail-grid">
+          <div v-for="field in detailFields" :key="String(field[0])" :class="detailFieldClass(field[0])"><dt>{{ field[0] }}</dt><dd>{{ text(field[1]) }}</dd></div>
+        </dl>
+      </section>
+      <section v-if="!error && fleetArrangement" class="business-detail-section" aria-label="承运安排">
+        <h3>承运安排</h3><p>{{ fleetArrangement.readOnlyReason }}</p>
+        <dl class="detail-grid arrangement-grid">
+          <div><dt>预订号</dt><dd>{{ fleetArrangement.bookingNo }}</dd></div>
+          <div><dt>计划发车</dt><dd>{{ dateTime(fleetArrangement.plannedDepartureAt) }}</dd></div>
+          <div><dt>起运仓</dt><dd>{{ text(fleetArrangement.originWarehouseName) }}</dd></div>
+          <div><dt>目的地</dt><dd>{{ text(fleetArrangement.destinationLabel) }}</dd></div>
+          <div><dt>交货方式</dt><dd>{{ fleetArrangement.deliveryMode === 'SELF_DELIVERY' ? '自行送至起运仓' : '线下安排提货至起运仓' }}</dd></div>
+          <div><dt>履约进度</dt><dd>{{ poolOrderStatusLabels[fleetArrangement.fulfillmentStage] || '待核对履约进度' }}</dd></div>
+          <div><dt>更新时间</dt><dd>{{ dateTime(fleetArrangement.stageOccurredAt) }}</dd></div>
+          <div><dt>约定运费（非实收）</dt><dd>{{ money(fleetArrangement.agreedFreightAmount, fleetArrangement.currency) }}</dd></div>
+          <div><dt>来货单号</dt><dd>{{ text(fleetArrangement.incomingNo) }}</dd></div>
+          <div><dt>派送单号</dt><dd>{{ text(fleetArrangement.deliveryNo) }}</dd></div>
+          <div><dt>已签 / 未签 / 退回箱数</dt><dd>{{ fleetArrangement.signedPackages ?? '—' }} / {{ fleetArrangement.unsignedPackages ?? '—' }} / {{ fleetArrangement.returnedPackages ?? '—' }}</dd></div>
+          <div class="is-wide"><dt>交货说明</dt><dd>{{ text(fleetArrangement.deliveryInstructions) }}</dd></div>
+          <div v-if="fleetArrangement.exceptionSummary" class="is-wide"><dt>履约说明</dt><dd>{{ fleetArrangement.exceptionSummary }}</dd></div>
+        </dl>
+      </section>
+    </section>
 
     <el-card v-else shadow="never" class="form-card">
       <el-form ref="formRef" :model="form" :rules="rules" label-width="120px">
-        <template v-if="kind === 'procurement'">
-          <el-form-item label="采购品类" prop="purchaseCategory"><el-input v-model.trim="form.purchaseCategory" maxlength="128" placeholder="请输入采购品类" /></el-form-item>
-          <el-form-item label="商品名称" prop="productName"><el-input v-model.trim="form.productName" maxlength="255" placeholder="请输入商品名称" /></el-form-item>
-          <el-form-item label="商品规格"><el-input v-model.trim="form.productSpecification" maxlength="500" placeholder="请输入规格、型号等信息" /></el-form-item>
-          <el-form-item label="商品链接"><el-input v-model.trim="form.productUrl" maxlength="2000" placeholder="请输入商品链接" /></el-form-item>
-          <el-form-item label="采购数量" prop="purchaseQuantity"><el-input-number v-model="form.purchaseQuantity" :min="1" placeholder="请输入数量" /></el-form-item>
-          <el-form-item label="收货地址"><el-input v-model.trim="form.receivingAddress" maxlength="1000" placeholder="请输入收货地址" /></el-form-item>
-        </template>
-        <template v-else>
           <el-form-item v-if="kind === 'looseboard'" label="运输方式"><el-radio-group v-model="form.transportMode"><el-radio-button value="SHARED_TRUCK">拼车</el-radio-button><el-radio-button value="PRIORITY_CONSOLIDATION">优先拼载</el-radio-button></el-radio-group></el-form-item>
           <el-form-item v-if="kind === 'looseboard'" label="是否打盘"><el-radio-group v-model="form.palletRequired"><el-radio-button value="NO">否</el-radio-button><el-radio-button value="YES">是</el-radio-button></el-radio-group></el-form-item>
           <el-form-item label="运输类型"><el-select v-model="form.transportType"><el-option label="港口提柜" value="PORT_PICKUP" /><el-option label="仓到仓" value="WAREHOUSE_TO_WAREHOUSE" /><el-option label="仓到门" value="WAREHOUSE_TO_DOOR" /></el-select></el-form-item>
@@ -335,29 +377,41 @@ onMounted(() => void load())
           <el-form-item label="总重量(kg)"><el-input-number v-model="form.totalWeightKg" :min="0" :precision="2" placeholder="请输入总重量" /></el-form-item>
           <el-form-item label="总体积(m³)"><el-input-number v-model="form.totalVolumeCbm" :min="0" :precision="3" placeholder="请输入总体积" /></el-form-item>
           <el-form-item label="要求时间" :prop="kind === 'trucking' ? 'requestedDate' : undefined"><el-date-picker v-model="form.requestedDate" type="date" value-format="YYYY-MM-DD" /></el-form-item>
-        </template>
+        <el-form-item class="budget-form-item" label="预算金额"><el-input-number v-model="form.budgetAmount" :min="0" :precision="2" placeholder="请输入预算金额" /><el-select v-model="form.currency" class="currency"><el-option label="USD" value="USD" /><el-option label="CNY" value="CNY" /></el-select></el-form-item>
-        <el-form-item class="budget-form-item" :label="kind === 'procurement' ? '预算单价' : '预算金额'"><el-input-number v-model="form.budgetAmount" :min="0" :precision="2" placeholder="请输入预算金额" /><el-select v-model="form.currency" class="currency"><el-option label="USD" value="USD" /><el-option label="CNY" value="CNY" /></el-select></el-form-item>
         <el-form-item label="联系人" prop="contactName"><el-input v-model.trim="form.contactName" maxlength="128" placeholder="请输入联系人" /></el-form-item>
         <el-form-item label="联系方式" prop="contactInfo"><el-input v-model.trim="form.contactInfo" maxlength="128" placeholder="请输入电话、微信或邮箱" /></el-form-item>
         <el-form-item label="备注"><el-input v-model="form.remark" type="textarea" :rows="4" maxlength="1000" show-word-limit placeholder="请输入其他要求" /></el-form-item>
-        <el-form-item><el-button @click="mode = 'list'">取消</el-button><el-button type="primary" :loading="submitting" @click="submit">提交订单</el-button></el-form-item>
+        <el-form-item><el-button @click="returnToList">取消</el-button><el-button v-if="canCreate" type="primary" :loading="submitting" @click="submit">提交订单</el-button></el-form-item>
       </el-form>
     </el-card>
   </section>
 </template>
 
 <style scoped>
-.business-orders { display: grid; gap: 18px; }
+.business-orders { display: grid; gap: var(--client-section-gap); }
 .page-head { display: flex; align-items: center; justify-content: space-between; gap: 24px; }
 .page-head h2 { margin: 0; color: #111827; font-size: 26px; }
 .page-head p { margin: 7px 0 0; color: #64748b; font-size: 14px; }
-.filter-card :deep(.el-form-item) { margin-bottom: 0; }
+.business-table-card { overflow: hidden; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }
-.filter-card :deep(.el-input) { width: 190px; }
+.business-order-link { max-width: 100%; overflow: hidden; padding: 0; border: 0; background: transparent; color: var(--client-action); cursor: pointer; font: inherit; font-weight: 650; text-align: left; text-overflow: ellipsis; white-space: nowrap; }
-.pagination { justify-content: flex-end; margin-top: 18px; }
+.business-order-link:hover { text-decoration: underline; text-underline-offset: 3px; }
-.detail-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); margin: 0; }
+.business-load-error { display: flex; min-height: 84px; align-items: center; justify-content: center; gap: 12px; padding: 14px; color: #b42318; }
-.detail-grid div { min-width: 0; padding: 18px 20px; border-right: 1px solid #ebeef5; border-bottom: 1px solid #ebeef5; }
+.business-detail-error { display: flex; min-height: 180px; align-items: center; justify-content: center; gap: 12px; color: #b42318; }
-.detail-grid dt { margin-bottom: 7px; color: #8492a6; font-size: 13px; }
+.business-detail-page { min-width: 0; padding: 10px 14px 20px; overflow: hidden; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }
-.detail-grid dd { margin: 0; overflow-wrap: anywhere; color: #1f2937; line-height: 1.55; }
+.business-detail-heading { display: flex; min-height: 50px; align-items: center; justify-content: space-between; gap: 16px; padding: 5px 0; border-bottom: 1px solid var(--border); }
+.business-detail-heading-main { display: flex; min-width: 0; align-items: center; gap: 12px; }
+.business-detail-heading-main > div { min-width: 0; }
+.business-detail-heading h2 { margin: 0; overflow: hidden; color: var(--navy); font-size: 18px; text-overflow: ellipsis; white-space: nowrap; }
+.business-detail-heading p { margin: 3px 0 0; color: var(--muted); font-size: 11px; }
+.business-detail-section { margin-top: 10px; }
+.business-detail-section h3 { margin: 0; padding: 0 0 5px; border-bottom: 1px solid #eaf0f7; color: var(--navy); font-size: 13px; }
+.detail-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); margin: 0; border-top: 1px solid var(--border); border-left: 1px solid var(--border); }
+.detail-grid div { display: grid; min-width: 0; min-height: 34px; grid-template-columns: 76px minmax(0, 1fr); align-items: center; gap: 7px; padding: 3px 8px; border-right: 1px solid var(--border); border-bottom: 1px solid var(--border); }
+.detail-grid div.is-wide { grid-column: span 2; }
+.detail-grid dt { color: var(--muted); font-size: 10px; white-space: nowrap; }
+.arrangement-grid div { grid-template-columns: 124px minmax(0, 1fr); }
+.arrangement-grid dt { white-space: normal; overflow-wrap: anywhere; }
+.detail-grid dd { min-width: 0; margin: 0; overflow-wrap: anywhere; color: var(--navy); font-size: 12px; font-weight: 600; line-height: 1.4; }
 .form-card :deep(.el-form) { max-width: 860px; }
 .form-card :deep(.el-input), .form-card :deep(.el-textarea), .form-card :deep(.el-select) { width: 100%; }
 .form-card .currency { width: 110px; margin-left: 12px; }
@@ -368,15 +422,10 @@ onMounted(() => void load())
   .page-head h2 { font-size: 24px; }
   .page-head > div { min-width: 0; }
 
-  .filter-card :deep(.el-form) { display: grid; grid-template-columns: 1fr; }
-  .filter-card :deep(.el-form-item) { width: 100%; margin-right: 0; margin-bottom: 12px; }
-  .filter-card :deep(.el-form-item:last-child) { margin-bottom: 0; }
-  .filter-card :deep(.el-form-item__content),
-  .filter-card :deep(.el-input) { width: 100%; }
-
   .detail-grid { grid-template-columns: 1fr; }
-  .detail-grid div { padding: 14px 16px; border-right: 0; }
+  .detail-grid div, .detail-grid div.is-wide { grid-column: auto; }
   .detail-grid dd { overflow-wrap: break-word; word-break: normal; }
+  .business-detail-heading { align-items: flex-start; flex-direction: column; }
 
   .form-card :deep(.el-form-item) { display: block; }
   .form-card :deep(.el-form-item__label) {

src/modules/cross-border/components/ProcurementDetailPanel.vue

@@ -0,0 +1,106 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { ProcurementDetail, ProcurementFee } from '../api/procurement'
+import { dateTime, feePurposes, feeStatus, feeTone, feeTotals, measurement, money, productHref, text } from '../procurementPresentation'
+
+const props = defineProps<{ detail: ProcurementDetail }>()
+const totals = computed(() => feeTotals(props.detail.fees))
+const progress = computed(() => props.detail.progress.filter(step => step.key !== 'closed_at' || step.completedAt))
+const ended = computed(() => ['REJECTED', 'CANCELLED', 'EXCEPTION_CLOSED', 'SHIPPED_TO_CUSTOMER'].includes(props.detail.order.status))
+const hasPending = computed(() => props.detail.fees.some(f => f.walletStatus?.endsWith('_PENDING') || f.walletStatus?.endsWith('_FAILED')))
+</script>
+
+<template>
+  <section class="procurement-section" aria-label="采购履约进度">
+    <h3>履约进度</h3>
+    <ol class="procurement-progress">
+      <li v-for="step in progress" :key="step.key" :class="{ 'is-complete': step.completedAt }">
+        <strong>{{ step.title }}</strong><span>{{ step.completedAt ? dateTime(step.completedAt) : ended ? '未执行' : '待处理' }}</span>
+      </li>
+    </ol>
+    <p v-if="detail.purchaseNeedsAttention" class="procurement-note">购买资料正在核对，客服将协助处理。已发生的收货与费用结果仍保留在本单。</p>
+  </section>
+  <section class="procurement-section" aria-label="商品与收件信息">
+    <h3>商品与收件信息</h3>
+    <dl class="procurement-grid">
+      <div><dt>采购品类</dt><dd>{{ detail.order.purchaseCategory }}</dd></div>
+      <div><dt>商品名称</dt><dd>{{ detail.order.productName }}</dd></div>
+      <div><dt>商品规格</dt><dd>{{ text(detail.order.productSpecification) }}</dd></div>
+      <div><dt>采购数量</dt><dd>{{ detail.order.purchaseQuantity }} 件</dd></div>
+      <div><dt>下单预算单价</dt><dd>{{ money(detail.order.budgetUnitPrice, detail.order.currency) }}</dd></div>
+      <div><dt>货款预算总上限</dt><dd>{{ money(detail.budget.totalAmount, detail.budget.currency) }}</dd></div>
+      <div><dt>预算核验时间</dt><dd>{{ dateTime(detail.budget.authorizedAt) }}</dd></div>
+      <div><dt>预计到海外仓</dt><dd>{{ dateTime(detail.order.estimatedArrivalAt) }}</dd></div>
+      <div><dt>收件人</dt><dd>{{ detail.order.contactName }}</dd></div>
+      <div><dt>联系电话</dt><dd>{{ detail.order.contactPhone }}</dd></div>
+      <div class="wide"><dt>下单收货地址</dt><dd>{{ detail.order.receivingAddress }}</dd></div>
+      <div class="wide"><dt>实际海外仓</dt><dd>{{ text(detail.order.actualWarehouseName) }}<span v-if="detail.order.actualWarehouseCode">（{{ detail.order.actualWarehouseCode }}）</span></dd></div>
+      <div class="wide"><dt>商品链接</dt><dd><a v-if="productHref(detail.order.productUrl)" :href="productHref(detail.order.productUrl)" target="_blank" rel="noopener noreferrer">{{ detail.order.productUrl }}</a><span v-else>{{ text(detail.order.productUrl) }}</span></dd></div>
+    </dl>
+  </section>
+  <section class="procurement-section" aria-label="已确认海外装箱清单">
+    <h3>已确认海外装箱清单</h3>
+    <el-table :data="detail.boxes" border stripe empty-text="尚无已确认的装箱清单" row-key="cartonNo">
+      <el-table-column prop="cartonNo" label="箱号" min-width="170" />
+      <el-table-column label="箱内商品" min-width="200"><template #default>{{ detail.order.productName }}</template></el-table-column>
+      <el-table-column label="规格" min-width="180"><template #default>{{ text(detail.order.productSpecification) }}</template></el-table-column>
+      <el-table-column prop="quantity" label="数量（件）" width="120" />
+      <el-table-column label="外箱长 × 宽 × 高（cm）" min-width="240"><template #default="{ row }">{{ measurement(row.lengthCm, 2) }} × {{ measurement(row.widthCm, 2) }} × {{ measurement(row.heightCm, 2) }}</template></el-table-column>
+      <el-table-column label="封箱毛重（kg）" width="170"><template #default="{ row }">{{ measurement(row.grossWeightKg, 3) }}</template></el-table-column>
+    </el-table>
+  </section>
+  <section class="procurement-section" aria-label="两段实际运输">
+    <h3>两段实际运输</h3>
+    <el-table :data="detail.shipments" border stripe empty-text="尚无实际交寄记录">
+      <el-table-column label="运输段" width="150"><template #default="{ row }">{{ row.leg === 'OVERSEAS' ? '国际段 · 海外交寄' : '国内段 · 寄客户' }}</template></el-table-column>
+      <el-table-column prop="shipmentNo" label="交寄编号" min-width="270" />
+      <el-table-column prop="cartonNo" label="原箱号" min-width="150" />
+      <el-table-column prop="quantity" label="实际件数" width="110" />
+      <el-table-column prop="carrier" label="承运商" min-width="140" />
+      <el-table-column prop="trackingNo" label="运单号" min-width="230" />
+      <el-table-column label="实际交寄时间" width="185"><template #default="{ row }">{{ dateTime(row.shippedAt) }}</template></el-table-column>
+    </el-table>
+    <p class="procurement-note">这里显示已实际交给承运方的记录；国内寄客户后，本单履约完成。</p>
+  </section>
+  <section class="procurement-section" aria-label="采购费用与资金结果">
+    <h3>费用与资金结果</h3>
+    <dl class="procurement-grid money-grid">
+      <div><dt>累计成功扣款</dt><dd>{{ money(totals?.paid) }}</dd></div>
+      <div><dt>累计成功退款</dt><dd>{{ money(totals?.refunded) }}</dd></div>
+      <div><dt>净实扣</dt><dd>{{ money(totals?.net) }}</dd></div>
+      <div><dt>预估国际运费占款</dt><dd>{{ money(totals?.estimatedHold) }}</dd></div>
+    </dl>
+    <p class="procurement-note">预算上限仅包含样品货款。预估国际运费只冻结、不直接扣款，最终以实际费用结算；表内保留原费用、追加及退款记录。</p>
+    <el-table :data="detail.fees" border stripe empty-text="尚无已核定费用" row-key="feeNo">
+      <el-table-column prop="feeNo" label="费用编号" min-width="270" />
+      <el-table-column label="费用用途" min-width="145"><template #default="{ row }">{{ feePurposes[row.purpose] || '待核定' }}</template></el-table-column>
+      <el-table-column prop="name" label="费用名称" min-width="145" />
+      <el-table-column label="原币金额" min-width="130"><template #default="{ row }">{{ money(row.originalAmount, row.originalCurrency) }}</template></el-table-column>
+      <el-table-column label="汇率 / 月份" min-width="150"><template #default="{ row }">{{ measurement(row.exchangeRate, 6) }}<br /><small>{{ text(row.exchangeRateMonth) }}</small></template></el-table-column>
+      <el-table-column label="人民币金额" min-width="130"><template #default="{ row }">{{ money(row.amount) }}</template></el-table-column>
+      <el-table-column label="处理结果" min-width="190"><template #default="{ row }"><el-tag :type="feeTone(row as ProcurementFee)" size="small">{{ feeStatus(row as ProcurementFee) }}</el-tag><small v-if="row.purpose !== 'INTERNATIONAL_ESTIMATE' && row.walletStatus === 'SETTLED' && !row.sourceLinked" class="fee-sync">费用结果同步中</small></template></el-table-column>
+      <el-table-column prop="parentFeeNo" label="关联原费用 / 预估" min-width="270"><template #default="{ row }">{{ text(row.parentFeeNo) }}</template></el-table-column>
+    </el-table>
+    <p v-if="hasPending" class="procurement-note">部分资金处理尚未完成，可点击页面“刷新”查看最新结果；如需协助请联系客户服务。</p>
+  </section>
+  <section v-if="detail.exceptionSummaries.length" class="procurement-section" aria-label="客服处理说明">
+    <h3>客服处理说明</h3><ul class="procurement-summaries"><li v-for="(summary, index) in detail.exceptionSummaries" :key="index">{{ summary }}</li></ul>
+  </section>
+</template>
+
+<style scoped>
+.procurement-section { margin-top: 18px; min-width: 0; }
+h3 { margin: 0 0 10px; padding-bottom: 7px; border-bottom: 1px solid var(--border); color: var(--navy); font-size: 14px; }
+.procurement-progress { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 0; padding: 0; margin: 0; list-style: none; border-top: 1px solid var(--border); border-left: 1px solid var(--border); }
+.procurement-progress li { display: grid; gap: 7px; padding: 12px; border-bottom: 1px solid var(--border); border-right: 1px solid var(--border); color: var(--muted); }
+.procurement-progress strong { font-size: 13px; font-weight: 600; }.procurement-progress span { font-size: 12px; }.procurement-progress .is-complete strong { color: var(--navy); }
+.procurement-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); margin: 0; border-left: 1px solid var(--border); border-top: 1px solid var(--border); }
+.procurement-grid > div { display: grid; grid-template-columns: 110px minmax(0, 1fr); align-items: center; gap: 8px; padding: 9px 12px; border-right: 1px solid var(--border); border-bottom: 1px solid var(--border); min-width: 0; }
+.procurement-grid dt { font-size: 12px; color: var(--muted); }.procurement-grid dd { margin: 0; font-size: 13px; line-height: 1.6; color: var(--navy); overflow-wrap: anywhere; }
+.procurement-grid .wide { grid-column: span 2; }.money-grid > div { grid-template-columns: minmax(0, 1fr); }.money-grid dd { font-size: 16px; font-weight: 600; }
+a { color: var(--client-action); } .procurement-note { margin: 10px 0; color: var(--muted); font-size: 12px; line-height: 1.7; }
+.fee-sync { display: block; padding-top: 5px; color: var(--muted); }.procurement-summaries { margin: 0; padding-left: 22px; line-height: 1.8; color: var(--navy); font-size: 13px; white-space: pre-wrap; }
+@media (max-width: 767px) {
+  .procurement-progress, .procurement-grid { grid-template-columns: 1fr; }.procurement-grid .wide { grid-column: auto; }
+}
+</style>

src/modules/cross-border/fleetArrangement.ts

@@ -0,0 +1,28 @@
+export interface FleetArrangement {
+  sourceType: 'FLEET_CAPACITY_OFFER'
+  businessType: 'LOCAL_LOOSEBOARD' | 'US_TRUCK'
+  businessOrderNo: string
+  bookingNo: string
+  tripNo: string
+  plannedDepartureAt: string | null
+  originWarehouseName: string
+  destinationLabel: string
+  deliveryMode: 'SELF_DELIVERY' | 'MANUAL_PICKUP_TO_WAREHOUSE'
+  deliveryInstructions: string | null
+  fulfillmentStage: string
+  stageOccurredAt: string | null
+  agreedFreightAmount: number | null
+  currency: string | null
+  incomingNo: string | null
+  dispatchNo: string | null
+  deliveryNo: string | null
+  signedPackages: number | null
+  unsignedPackages: number | null
+  returnedPackages: number | null
+  exceptionSummary: string | null
+  readOnlyReason: string
+}
+export const poolOrderStatusLabels: Record<string, string> = {
+  WAITING_INBOUND: '待入仓', RECEIVING: '收货中', WAITING_CONSOLIDATION: '待合托',
+  PENDING_DISPATCH: '待派车', IN_TRANSIT: '运输中', COMPLETED: '已完成', CANCELLED: '已取消',
+}

src/modules/cross-border/procurement.test.mjs

@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import { runInNewContext } from 'node:vm'
+import ts from 'typescript'
+import * as vue from 'vue'
+import { parse, compileScript } from 'vue/compiler-sfc'
+
+let nextKey = 0
+const crypto = { randomUUID: () => `test-key-${++nextKey}` }
+function moduleFrom(source, require = () => { throw new Error('unexpected import') }) {
+  const context = { exports: {}, require, URL, Error, crypto }
+  const code = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText
+  runInNewContext(code, context)
+  return context.exports
+}
+const presentation = moduleFrom(readFileSync(new URL('./procurementPresentation.ts', import.meta.url), 'utf8'))
+const submission = moduleFrom(readFileSync(new URL('./procurementSubmission.ts', import.meta.url), 'utf8'), name => {
+  if (name === './procurementPresentation') return presentation
+  throw new Error(`unexpected import ${name}`)
+})
+const normalized = value => JSON.parse(JSON.stringify(value))
+const draft = () => ({ ...presentation.emptyProcurementDraft(), purchaseCategory: 'Sample', productName: 'Test product', productSpecification: 'A',
+  purchaseQuantity: '3', budgetUnitPrice: '0.29', receivingAddress: '测试省测试市测试街 1 号', contactName: '测试收件人', contactPhone: '13800000000' })
+const fee = (purpose, walletStatus, amount) => ({ purpose, walletStatus, amount, currency: 'CNY' })
+
+test('budget distinguishes unknown from zero, preserves cents, and requires a real telephone/address', () => {
+  assert.equal(presentation.draftBudgetTotal(draft()), '0.87')
+  const valid = presentation.buildProcurementCreate(draft(), 'Authenticated Company', 'same-key')
+  assert.equal(valid.customerName, 'Authenticated Company')
+  assert.equal(valid.budgetUnitPrice, 0.29)
+  for (const value of ['', '-1', '1.001', '90071992547409.91']) assert.throws(() => presentation.buildProcurementCreate({ ...draft(), budgetUnitPrice: value }, 'Company', 'key'), /预算/)
+  assert.equal(presentation.buildProcurementCreate({ ...draft(), budgetUnitPrice: '0' }, 'Company', 'key').budgetUnitPrice, 0)
+  for (const patch of [{ contactPhone: 'wechat-name' }, { contactPhone: 'a@test.invalid' }, { receivingAddress: '' }, { purchaseQuantity: '1.5' }]) {
+    assert.throws(() => presentation.buildProcurementCreate({ ...draft(), ...patch }, 'Company', 'key'))
+  }
+  assert.equal(presentation.measurement(20, 2), '20.00')
+  assert.equal(presentation.measurement('5.125', 3), '5.125')
+  assert.equal(presentation.measurement('1.234', 2), '待核对')
+  assert.equal(presentation.money(null), '—')
+  assert.equal(presentation.money(0), 'CNY 0.00')
+  assert.equal(presentation.productHref('javascript:alert(1)'), undefined)
+  assert.equal(presentation.productHref('https://example.com/item'), 'https://example.com/item')
+})
+
+test('successful net debit excludes the original estimate and counts only successful refunds and differences', () => {
+  const result = presentation.feeTotals([fee('INTERNATIONAL_ESTIMATE', 'SETTLED', '100'), fee('INTERNATIONAL_FREIGHT', 'SETTLED', '100'),
+    fee('ADJUSTMENT', 'SETTLED', '20'), fee('ADJUSTMENT', 'SETTLED', '10'), fee('REFUND', 'REFUNDED', '20'), fee('REFUND', 'REFUND_PENDING', '5')])
+  assert.deepEqual(normalized(result), { paid: '130.00', refunded: '20.00', net: '110.00', estimatedHold: '0.00' })
+  assert.equal(presentation.feeTotals([fee('INTERNATIONAL_ESTIMATE', 'RELEASE_PENDING', '100')]).estimatedHold, '100.00')
+  assert.equal(presentation.feeTotals([fee('DUTY', 'SETTLED', 'unknown')]), null)
+  assert.equal(presentation.feeStatus(fee('INTERNATIONAL_ESTIMATE', 'FROZEN', 100)), '已冻结，未扣款')
+  assert.equal(presentation.feeStatus(fee('INTERNATIONAL_ESTIMATE', 'SETTLED', 100)), '原预估已结清')
+  assert.equal(presentation.feeStatus(fee('DUTY', null, 100)), '待核定')
+})
+
+test('request recovery preserves content and identity while malformed recovery cannot create a replacement', () => {
+  const original = presentation.buildProcurementCreate(draft(), 'Company', 'fixed-key')
+  assert.deepEqual(normalized(submission.restoreProcurementSubmission(JSON.stringify(original))), normalized(original))
+  assert.throws(() => submission.restoreProcurementSubmission('{}'))
+  assert.throws(() => submission.restoreProcurementSubmission(JSON.stringify({ ...original, currency: 'EUR' })))
+  assert.equal(submission.definitelyRejected({ code: 'TIMEOUT' }), false)
+  assert.equal(submission.definitelyRejected({ status: 500 }), false)
+  assert.equal(submission.definitelyRejected({ status: 409 }), false)
+  assert.equal(submission.definitelyRejected({ status: 400 }), true)
+  assert.equal(submission.procurementRequestKey({ getRandomValues: target => { target.set([1, 2, 3, 4]); return target } }), 'proc-00000001000000020000000300000004')
+})
+
+class ApiError extends Error { constructor(message, code, status) { super(message); this.code = code; this.status = status } }
+const flush = async () => { await vue.nextTick(); await new Promise(resolve => setImmediate(resolve)); await vue.nextTick() }
+function viewHarness({ createPage = false, detailPage = false, api = {}, storage = new Map() } = {}) {
+  const props = vue.reactive({ createPage, detailPage })
+  const route = vue.reactive({ params: { orderNo: detailPage ? 'PO-1' : '' } })
+  const auth = vue.reactive({ token: 'identity-A', user: { tenantName: 'Company' }, profile: { tenantName: 'Company' }, hasPermission: () => true })
+  const pushes = [], dispose = []
+  const defaults = { listProcurements: async () => ({ records: [], total: 0 }), getProcurement: async orderNo => ({ order: { orderNo } }), createProcurement: async () => ({ order: { orderNo: 'PO-CREATED' } }) }
+  const { descriptor } = parse(readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8'))
+  const source = compileScript(descriptor, { id: 'procurement-test' }).content
+  const context = { exports: {}, Error, crypto, sessionStorage: { getItem: key => storage.get(key) || null, setItem: (key, value) => storage.set(key, value), removeItem: key => storage.delete(key) },
+    require(name) {
+      if (name === 'vue') return { ...vue, onBeforeUnmount: callback => dispose.push(callback), watch: (...args) => { const stop = vue.watch(...args); dispose.push(stop); return stop } }
+      if (name === 'vue-router') return { useRoute: () => route, useRouter: () => ({ push: async target => pushes.push(target) }) }
+      if (name === 'element-plus') return { ElMessage: { success: () => {} } }
+      if (name === '@/api/types') return { ApiError }
+      if (name === '@/api/session') return { accessTokenIdentity: token => token }
+      if (name === '@/modules/auth/public') return { useAuthStore: () => auth }
+      if (name === '../api/procurement') return { ...defaults, ...api }
+      if (name === '../procurementPresentation') return presentation
+      if (name === '../procurementSubmission') return submission
+      if (name.endsWith('.vue')) return { default: {} }
+      throw new Error(`unexpected view import ${name}`)
+    },
+  }
+  runInNewContext(ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText, context)
+  const state = context.exports.default.setup(props, { expose: () => {} })
+  return { state, props, route, auth, pushes, storage, dispose: () => dispose.forEach(callback => callback()) }
+}
+
+test('detail has one in-flight request and an older response cannot overwrite another order', async () => {
+  const calls = [], pending = new Map()
+  const harness = viewHarness({ detailPage: true, api: { getProcurement: orderNo => { calls.push(orderNo); return new Promise(resolve => pending.set(orderNo, resolve)) } } })
+  try {
+    assert.deepEqual(calls, ['PO-1'])
+    await harness.state.loadDetail(); assert.equal(calls.length, 1)
+    harness.route.params.orderNo = 'PO-2'; await flush(); assert.deepEqual(calls, ['PO-1', 'PO-2'])
+    pending.get('PO-1')({ order: { orderNo: 'PO-1' } }); await flush(); assert.equal(harness.state.detail.value, null)
+    pending.get('PO-2')({ order: { orderNo: 'PO-2' } }); await flush(); assert.equal(harness.state.detail.value.order.orderNo, 'PO-2')
+    assert.equal(harness.state.loading.value, false)
+  } finally { harness.dispose() }
+})
+
+test('timeout retries the exact original body after reload and does not accept changed form data', async () => {
+  const storage = new Map(), calls = []
+  const first = viewHarness({ createPage: true, storage, api: { createProcurement: async payload => { calls.push(normalized(payload)); throw new ApiError('timeout', 'TIMEOUT') } } })
+  try {
+    Object.assign(first.state.form, draft()); await first.state.submit(); assert.equal(calls.length, 1); assert.ok(first.state.pending.value)
+    first.state.form.productName = 'changed'; await first.state.submit(); assert.deepEqual(calls[1], calls[0])
+  } finally { first.dispose() }
+  const recovered = viewHarness({ createPage: true, storage, api: { createProcurement: async payload => { calls.push(normalized(payload)); return { order: { orderNo: 'PO-SAME' } } } } })
+  try {
+    assert.equal(recovered.state.form.productName, 'Test product'); await recovered.state.submit(); assert.deepEqual(calls[2], calls[0])
+    assert.equal(storage.size, 0); assert.equal(recovered.pushes[0].params.orderNo, 'PO-SAME')
+  } finally { recovered.dispose() }
+})
+
+test('submission double-click sends once and definitive validation rejection permits correction', async () => {
+  let reject, calls = 0
+  const harness = viewHarness({ createPage: true, api: { createProcurement: () => { calls++; return new Promise((_, failure) => { reject = failure }) } } })
+  try {
+    Object.assign(harness.state.form, draft()); const first = harness.state.submit(); await harness.state.submit(); assert.equal(calls, 1)
+    reject(new ApiError('invalid', 'A0422')); await first
+    assert.equal(harness.state.pending.value, null); assert.equal(harness.storage.size, 0)
+  } finally { harness.dispose() }
+})
+
+test('pagination batches one request and switching account clears old rows before the new response', async () => {
+  const calls = []; let resolveSecond
+  const harness = viewHarness({ api: { listProcurements: async params => {
+    calls.push(normalized(params)); if (calls.length < 3) return { records: [{ orderNo: 'PO-A' }], total: 100 }
+    return new Promise(resolve => { resolveSecond = resolve })
+  } } })
+  try {
+    await flush(); assert.equal(calls.length, 1)
+    harness.state.query.page = 2; harness.state.query.size = 50; await flush(); assert.equal(calls.length, 2)
+    harness.auth.token = 'identity-B'; await vue.nextTick(); assert.equal(harness.state.rows.value.length, 0); assert.equal(harness.state.total.value, 0)
+    resolveSecond({ records: [{ orderNo: 'PO-B' }], total: 1 }); await flush(); assert.equal(harness.state.rows.value[0].orderNo, 'PO-B')
+    assert.ok(calls.every(params => !('customerId' in params) && !('tenantId' in params)))
+  } finally { harness.dispose() }
+})
+
+
+test('replay rejection cannot discard an earlier unknown creation outcome', async () => {
+  const calls = []; let attempt = 0
+  const harness = viewHarness({ createPage: true, api: { createProcurement: async payload => {
+    calls.push(normalized(payload)); attempt++
+    if (attempt === 1) throw new ApiError('timeout', 'TIMEOUT')
+    throw new ApiError('permission revoked', 'A0403')
+  } } })
+  try {
+    Object.assign(harness.state.form, draft()); await harness.state.submit()
+    const saved = [...harness.storage.values()][0]; await harness.state.submit()
+    assert.equal([...harness.storage.values()][0], saved); assert.ok(harness.state.pending.value)
+    assert.deepEqual(calls[1], calls[0])
+  } finally { harness.dispose() }
+})

src/modules/cross-border/procurementPresentation.ts

@@ -0,0 +1,123 @@
+import type { Amount, ProcurementCreate, ProcurementFee } from './api/procurement'
+
+export const procurementStatuses: Record<string, string> = {
+  PENDING_REVIEW: '待审核', WAIT_PURCHASE: '待购买', WAIT_OVERSEAS_RECEIPT: '待海外到仓', OVERSEAS_RECEIVING: '海外收货中',
+  WAIT_PACKING: '待装箱', WAIT_LABELS: '待面单及预估处理', WAIT_OVERSEAS_SHIPMENT: '待海外交寄', INTERNATIONAL_TRANSIT: '国际运输中',
+  DOMESTIC_RECEIVING: '国内收货中', WAIT_CHARGES: '待国内核费', WAIT_CUSTOMER_SHIPMENT: '待寄客户', SHIPPED_TO_CUSTOMER: '已寄客户',
+  REJECTED: '已拒绝', CANCELLED: '已取消', EXCEPTION_CLOSED: '异常关闭',
+}
+export const feePurposes: Record<string, string> = {
+  SAMPLE_PAYMENT: '样品货款', INTERNATIONAL_ESTIMATE: '预估国际运费', INTERNATIONAL_FREIGHT: '实际国际运费',
+  DUTY: '关税', DOMESTIC_FREIGHT: '国内运费', OTHER: '其他费用', ADJUSTMENT: '追加费用', REFUND: '退款',
+}
+export function statusLabel(status: string | null | undefined) { return status ? procurementStatuses[status] || '待核对进度' : '—' }
+export function statusTone(status: string | null | undefined): 'success' | 'warning' | 'danger' | 'info' | 'primary' {
+  if (status === 'SHIPPED_TO_CUSTOMER') return 'success'
+  if (status === 'REJECTED' || status === 'EXCEPTION_CLOSED') return 'danger'
+  if (status === 'CANCELLED') return 'info'
+  if (status === 'INTERNATIONAL_TRANSIT') return 'primary'
+  return 'warning'
+}
+function cents(value: Amount | null | undefined): bigint | null {
+  if (value === null || value === undefined) return null
+  const match = /^(-?)(\d+)(?:\.(\d{1,2}))?$/.exec(String(value).trim())
+  if (!match) return null
+  const result = BigInt(match[2]) * 100n + BigInt((match[3] || '').padEnd(2, '0'))
+  return match[1] ? -result : result
+}
+function decimal(value: bigint) {
+  const absolute = value < 0n ? -value : value
+  return `${value < 0n ? '-' : ''}${absolute / 100n}.${String(absolute % 100n).padStart(2, '0')}`
+}
+export function money(value: Amount | null | undefined, currency: string | null | undefined = 'CNY') {
+  const amount = cents(value)
+  return amount === null ? '—' : `${currency || '—'} ${decimal(amount)}`
+}
+export function dateTime(value: string | null | undefined) { return value ? value.replace('T', ' ').replace(/\.\d+$/, '') : '—' }
+export function measurement(value: Amount | null | undefined, scale: number) {
+  if (value === null || value === undefined) return '—'
+  const parts = /^(\d+)(?:\.(\d+))?$/.exec(String(value))
+  if (!parts || (parts[2] || '').length > scale) return '待核对'
+  return `${parts[1]}.${(parts[2] || '').padEnd(scale, '0')}`
+}
+export function text(value: unknown) { return value === null || value === undefined || value === '' ? '—' : String(value) }
+export function productHref(value: string | null | undefined) {
+  if (!value) return undefined
+  try { const url = new URL(value); return ['http:', 'https:'].includes(url.protocol) ? url.href : undefined } catch { return undefined }
+}
+export function feeStatus(fee: ProcurementFee) {
+  if (fee.purpose === 'INTERNATIONAL_ESTIMATE') {
+    const label: Record<string, string> = { FROZEN: '已冻结，未扣款', ZERO: '零预估已确认', SETTLED: '原预估已结清', RELEASED: '预估已释放' }
+    if (fee.walletStatus && label[fee.walletStatus]) return label[fee.walletStatus]
+  }
+  const labels: Record<string, string> = {
+    FREEZE_PENDING: '冻结处理中', FREEZE_FAILED: '冻结未成功', FROZEN: '等待扣款', SETTLE_PENDING: '扣款处理中', SETTLE_ACTUAL_PENDING: '实际费用结算中',
+    SETTLE_FAILED: '扣款未成功', SETTLE_ACTUAL_FAILED: '实际费用未结清', SETTLED: '已扣款', RELEASE_PENDING: '释放处理中', RELEASE_FAILED: '释放未成功',
+    RELEASED: '已释放冻结', REFUND_PENDING: '退款处理中', REFUND_FAILED: '退款未成功', REFUNDED: '已退款', ZERO: '已确认零元', NOT_APPLICABLE: '不适用', TERMINATED: '已终止',
+  }
+  return fee.walletStatus ? labels[fee.walletStatus] || '待核定' : '待核定'
+}
+export function feeTone(fee: ProcurementFee): 'success' | 'warning' | 'danger' | 'info' {
+  if (fee.walletStatus?.endsWith('_FAILED')) return 'danger'
+  if (['SETTLED', 'REFUNDED', 'ZERO', 'NOT_APPLICABLE', 'RELEASED'].includes(fee.walletStatus || '')) return 'success'
+  if (fee.walletStatus === 'TERMINATED') return 'info'
+  return 'warning'
+}
+export function feeTotals(fees: ProcurementFee[]) {
+  let paid = 0n, refunded = 0n, estimatedHold = 0n
+  for (const fee of fees) {
+    const estimate = fee.purpose === 'INTERNATIONAL_ESTIMATE'
+    const include = (!estimate && fee.walletStatus === 'SETTLED') || fee.walletStatus === 'REFUNDED'
+      || (estimate && ['FROZEN', 'RELEASE_PENDING', 'RELEASE_FAILED'].includes(fee.walletStatus || ''))
+    if (!include) continue
+    const amount = cents(fee.amount)
+    if (amount === null || amount < 0n || fee.currency !== 'CNY') return null
+    if (estimate) estimatedHold += amount
+    else if (fee.walletStatus === 'REFUNDED') refunded += amount
+    else paid += amount
+  }
+  return { paid: decimal(paid), refunded: decimal(refunded), net: decimal(paid - refunded), estimatedHold: decimal(estimatedHold) }
+}
+export interface ProcurementDraft {
+  purchaseCategory: string
+  productName: string
+  productSpecification: string
+  productUrl: string
+  purchaseQuantity: string
+  budgetUnitPrice: string
+  currency: 'CNY' | 'USD'
+  receivingAddress: string
+  contactName: string
+  contactPhone: string
+  remark: string
+}
+export function emptyProcurementDraft(): ProcurementDraft {
+  return { purchaseCategory: '', productName: '', productSpecification: '', productUrl: '', purchaseQuantity: '1', budgetUnitPrice: '', currency: 'USD', receivingAddress: '', contactName: '', contactPhone: '', remark: '' }
+}
+export function draftBudgetTotal(draft: ProcurementDraft) {
+  const price = cents(draft.budgetUnitPrice)
+  if (price === null || price < 0n || !/^\d+$/.test(draft.purchaseQuantity)) return null
+  return decimal(price * BigInt(draft.purchaseQuantity))
+}
+export function buildProcurementCreate(draft: ProcurementDraft, customerName: string, key: string): ProcurementCreate {
+  for (const [field, label, max] of [
+    ['purchaseCategory', '采购品类', 128], ['productName', '商品名称', 255], ['receivingAddress', '完整国内收货地址', 1000],
+    ['contactName', '最终收件人', 128], ['contactPhone', '联系电话', 64],
+  ] as const) {
+    if (!draft[field].trim() || draft[field].trim().length > max) throw new Error(`请填写有效的${label}`)
+  }
+  if (!customerName.trim()) throw new Error('当前企业信息尚未加载，请刷新登录信息后重试')
+  if (!/^\d+$/.test(draft.purchaseQuantity) || !Number.isSafeInteger(Number(draft.purchaseQuantity)) || Number(draft.purchaseQuantity) <= 0) throw new Error('采购数量必须为正整数')
+  const price = cents(draft.budgetUnitPrice)
+  if (price === null || price < 0n) throw new Error('请明确填写非负预算单价，最多两位小数；免费样品填写 0')
+  if (price > BigInt(Number.MAX_SAFE_INTEGER) || cents(Number(decimal(price))) !== price) throw new Error('预算金额过大，无法准确表示，请核对金额')
+  if (!['CNY', 'USD'].includes(draft.currency)) throw new Error('预算币种只支持 CNY 或 USD')
+  if (!/^[+0-9][0-9 ()-]{5,63}$/.test(draft.contactPhone.trim())) throw new Error('请填写快递可联系的电话号码，微信或邮箱不能代替电话')
+  if (draft.productUrl && (!productHref(draft.productUrl.trim()) || draft.productUrl.trim().length > 2000)) throw new Error('商品链接须为有效的 http 或 https 地址')
+  if (draft.productSpecification.length > 500 || draft.remark.length > 1000) throw new Error('商品规格或备注超过长度限制')
+  return { customerName: customerName.trim(), purchaseCategory: draft.purchaseCategory.trim(), productName: draft.productName.trim(),
+    productSpecification: draft.productSpecification.trim() || undefined, productUrl: draft.productUrl.trim() || undefined,
+    purchaseQuantity: Number(draft.purchaseQuantity), budgetUnitPrice: Number(decimal(price)), currency: draft.currency,
+    receivingAddress: draft.receivingAddress.trim(), contactName: draft.contactName.trim(), contactPhone: draft.contactPhone.trim(),
+    remark: draft.remark.trim() || undefined, idempotencyKey: key }
+}

src/modules/cross-border/procurementSubmission.ts

@@ -0,0 +1,24 @@
+import type { ProcurementCreate } from './api/procurement'
+import { buildProcurementCreate, emptyProcurementDraft } from './procurementPresentation'
+
+/** Restore the exact request; an unknown result cannot become a new order. */
+export function restoreProcurementSubmission(raw: string): ProcurementCreate {
+  const saved: unknown = JSON.parse(raw)
+  if (!saved || typeof saved !== 'object' || Array.isArray(saved)) throw new Error('提交记录格式错误')
+  const value = saved as Record<string, unknown>
+  for (const key of ['customerName', 'purchaseCategory', 'productName', 'currency', 'receivingAddress', 'contactName', 'contactPhone', 'idempotencyKey']) if (typeof value[key] !== 'string') throw new Error('提交记录不完整')
+  if (typeof value.purchaseQuantity !== 'number' || typeof value.budgetUnitPrice !== 'number' || !String(value.idempotencyKey).trim() || String(value.idempotencyKey).length > 255) throw new Error('提交记录不完整')
+  for (const key of ['productSpecification', 'productUrl', 'remark']) if (value[key] !== undefined && typeof value[key] !== 'string') throw new Error('提交记录不完整')
+  if (value.currency !== 'CNY' && value.currency !== 'USD') throw new Error('提交记录币种无效')
+  return buildProcurementCreate({ ...emptyProcurementDraft(), purchaseCategory: String(value.purchaseCategory), productName: String(value.productName),
+    productSpecification: String(value.productSpecification || ''), productUrl: String(value.productUrl || ''), purchaseQuantity: String(value.purchaseQuantity),
+    budgetUnitPrice: String(value.budgetUnitPrice), currency: value.currency, receivingAddress: String(value.receivingAddress), contactName: String(value.contactName),
+    contactPhone: String(value.contactPhone), remark: String(value.remark || '') }, String(value.customerName), String(value.idempotencyKey))
+}
+export function definitelyRejected(error: { code?: string; status?: number }) {
+  return ['A0400', 'A0401', 'A0403', 'A0422'].includes(error.code || '') || [400, 401, 403, 422].includes(error.status || 0)
+}
+export function procurementRequestKey(provider: Pick<Crypto, 'getRandomValues'> & Partial<Pick<Crypto, 'randomUUID'>> = globalThis.crypto) {
+  if (provider.randomUUID) return provider.randomUUID()
+  return `proc-${Array.from(provider.getRandomValues(new Uint32Array(4)), value => value.toString(16).padStart(8, '0')).join('')}`
+}

src/modules/cross-border/routes.ts

@@ -5,28 +5,67 @@ export const crossBorderModule = {
   key: 'cross-border',
   navigationGroup: { title: '出海下单', icon: PlaneTakeoff },
   routes: [
+    {
+      path: 'cross-border/procurement/create',
+      name: 'cross-border-procurement-create',
+      component: () => import('./views/ProcurementView.vue'),
+      props: { createPage: true },
+      release: 'active',
+      meta: { title: '海外采购下单', workspaceTitle: '海外采购 · 新建', description: '填写并提交海外采购订单', permission: 'merchant:cross-border:procurement:create' },
+    },
+    {
+      path: 'cross-border/procurement/:orderNo/detail', name: 'cross-border-procurement-detail',
+      component: () => import('./views/ProcurementView.vue'), props: { detailPage: true }, release: 'active',
+      meta: { title: '海外采购详情', workspaceTitle: '海外采购 · 详情', description: '查看海外采购订单详情', permission: 'merchant:cross-border:procurement:list', keepAlive: false },
+    },
     {
       path: 'cross-border/procurement',
       name: 'cross-border-procurement',
       component: () => import('./views/ProcurementView.vue'),
       release: 'active',
-      meta: { title: '海外采购', description: '管理海外采购订单', permission: 'merchant:cross-border:procurement' },
+      meta: { title: '海外采购', description: '管理海外采购订单', permission: 'merchant:cross-border:procurement:list' },
       navigation: { key: 'cross-border-procurement', icon: Package },
     },
+    {
+      path: 'cross-border/domestic-trucking/create',
+      name: 'cross-border-domestic-trucking-create',
+      component: () => import('./views/DomesticTruckingView.vue'),
+      props: { createPage: true },
+      release: 'active',
+      meta: { title: '美国本土卡下单', workspaceTitle: '美国本土卡 · 新建', description: '填写并提交美国本土卡车运输订单', permission: 'merchant:cross-border:domestic-trucking:create' },
+    },
+    {
+      path: 'cross-border/domestic-trucking/:orderNo/detail', name: 'cross-border-domestic-trucking-detail',
+      component: () => import('./views/DomesticTruckingView.vue'), props: { detailPage: true }, release: 'active',
+      meta: { title: '美国本土卡详情', workspaceTitle: '美国本土卡 · 详情', description: '查看美国本土卡订单详情', permission: 'merchant:cross-border:domestic-trucking:list', keepAlive: false },
+    },
     {
       path: 'cross-border/domestic-trucking',
       name: 'cross-border-domestic-trucking',
       component: () => import('./views/DomesticTruckingView.vue'),
       release: 'active',
-      meta: { title: '美国本土卡', description: '创建美国本土卡车运输订单', permission: 'merchant:cross-border:domestic-trucking' },
+      meta: { title: '美国本土卡', description: '创建美国本土卡车运输订单', permission: 'merchant:cross-border:domestic-trucking:list' },
       navigation: { key: 'cross-border-domestic-trucking', icon: Truck },
     },
+    {
+      path: 'cross-border/pallet-shipping/create',
+      name: 'cross-border-pallet-shipping-create',
+      component: () => import('./views/PalletShippingView.vue'),
+      props: { createPage: true },
+      release: 'active',
+      meta: { title: '美本土散板下单', workspaceTitle: '美本土散板 · 新建', description: '填写并提交美国本土散板运输订单', permission: 'merchant:cross-border:pallet-shipping:create' },
+    },
+    {
+      path: 'cross-border/pallet-shipping/:orderNo/detail', name: 'cross-border-pallet-shipping-detail',
+      component: () => import('./views/PalletShippingView.vue'), props: { detailPage: true }, release: 'active',
+      meta: { title: '美本土散板详情', workspaceTitle: '美本土散板 · 详情', description: '查看美本土散板运输订单详情', permission: 'merchant:cross-border:pallet-shipping:list', keepAlive: false },
+    },
     {
       path: 'cross-border/pallet-shipping',
       name: 'cross-border-pallet-shipping',
       component: () => import('./views/PalletShippingView.vue'),
       release: 'active',
-      meta: { title: '美本土散板', description: '创建美国本土散板运输订单', permission: 'merchant:cross-border:pallet-shipping' },
+      meta: { title: '美本土散板', description: '创建美国本土散板运输订单', permission: 'merchant:cross-border:pallet-shipping:list' },
       navigation: { key: 'cross-border-pallet-shipping', icon: Ship },
     },
   ],

src/modules/cross-border/views/DomesticTruckingView.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import BusinessOrdersView from '../components/BusinessOrdersView.vue'
+defineProps<{ createPage?: boolean; detailPage?: boolean }>()
 </script>
 
-<template><BusinessOrdersView kind="trucking" /></template>
+<template><BusinessOrdersView kind="trucking" :create-page="createPage" :detail-page="detailPage" /></template>

src/modules/cross-border/views/PalletShippingView.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import BusinessOrdersView from '../components/BusinessOrdersView.vue'
+defineProps<{ createPage?: boolean; detailPage?: boolean }>()
 </script>
 
-<template><BusinessOrdersView kind="looseboard" /></template>
+<template><BusinessOrdersView kind="looseboard" :create-page="createPage" :detail-page="detailPage" /></template>

src/modules/cross-border/views/ProcurementView.vue

@@ -1,5 +1,187 @@
 <script setup lang="ts">
-import BusinessOrdersView from '../components/BusinessOrdersView.vue'
+import { computed, onBeforeUnmount, reactive, ref, shallowRef, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { ElMessage } from 'element-plus'
+import { ApiError } from '@/api/types'
+import { accessTokenIdentity } from '@/api/session'
+import { useAuthStore } from '@/modules/auth/public'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
+import QueryToolbar, { type QueryField, type QueryModel } from '@/components/common/QueryToolbar.vue'
+import type { TableAction } from '@/components/common/tableActions'
+import ProcurementDetailPanel from '../components/ProcurementDetailPanel.vue'
+import { createProcurement, getProcurement, listProcurements, type ProcurementCreate, type ProcurementDetail, type ProcurementSummary } from '../api/procurement'
+import { buildProcurementCreate, dateTime, draftBudgetTotal, emptyProcurementDraft, money, procurementStatuses, statusLabel, statusTone } from '../procurementPresentation'
+import { definitelyRejected, procurementRequestKey, restoreProcurementSubmission } from '../procurementSubmission'
+
+const props = withDefaults(defineProps<{ createPage?: boolean; detailPage?: boolean }>(), { createPage: false, detailPage: false })
+const auth = useAuthStore(), route = useRoute(), router = useRouter()
+const mode = computed(() => props.detailPage ? 'detail' : props.createPage ? 'create' : 'list')
+const orderNo = computed(() => typeof route.params.orderNo === 'string' ? route.params.orderNo : '')
+const canCreate = computed(() => auth.hasPermission('merchant:cross-border:procurement:create'))
+const canList = computed(() => auth.hasPermission('merchant:cross-border:procurement:list'))
+const identity = computed(() => auth.token ? accessTokenIdentity(auth.token) : null)
+const storageKey = computed(() => identity.value ? `cc-procurement-submit:${encodeURIComponent(identity.value)}` : null)
+const companyName = computed(() => auth.profile.tenantName || (auth.user?.tenantName && !/^企业租户 \d+$/.test(auth.user.tenantName) ? auth.user.tenantName : ''))
+const form = reactive(emptyProcurementDraft())
+const pending = shallowRef<ProcurementCreate | null>(null)
+const recoveryError = ref(''), submitError = ref(''), submittedOrder = ref('')
+const submitting = ref(false), loading = ref(false), error = ref('')
+const detail = shallowRef<ProcurementDetail | null>(null)
+const rows = ref<ProcurementSummary[]>([]), total = ref(0)
+const query = reactive({ page: 1, size: 20, orderNo: '', purchaseCategory: '', productName: '', status: '' })
+let requestSequence = 0, active = true, inFlight = ''
+const queryModel = computed<QueryModel>({
+  get: () => ({ orderNo: query.orderNo, purchaseCategory: query.purchaseCategory, productName: query.productName, status: query.status }),
+  set: value => { for (const key of ['orderNo', 'purchaseCategory', 'productName', 'status'] as const) query[key] = String(value[key] || '') },
+})
+const queryFields: QueryField[] = [
+  { key: 'orderNo', label: '采购单号', type: 'input' }, { key: 'purchaseCategory', label: '采购品类', type: 'input' },
+  { key: 'productName', label: '商品名称', type: 'input' },
+  { key: 'status', label: '履约进度', type: 'select', options: Object.entries(procurementStatuses).map(([value, label]) => ({ value, label })) },
+]
+const columns: DataTableColumn[] = [
+  { key: 'actions', label: '操作', width: 90, fixed: 'left', slotName: 'actions' },
+  { prop: 'orderNo', label: '采购单号', minWidth: 250, slotName: 'orderNo' },
+  { prop: 'purchaseCategory', label: '采购品类', width: 120 }, { prop: 'productName', label: '商品名称', minWidth: 200 },
+  { prop: 'productSpecification', label: '商品规格', minWidth: 160 }, { prop: 'purchaseQuantity', label: '采购数量（件）', width: 135 },
+  { prop: 'budgetUnitPrice', label: '预算单价', width: 155, slotName: 'budget' },
+  { prop: 'status', label: '履约进度', width: 180, slotName: 'status' }, { prop: 'createdAt', label: '下单时间', width: 185, slotName: 'createdAt' },
+]
+function rowActions(row: object): TableAction[] { return [{ key: 'detail', label: '详情', run: () => openDetail(row as ProcurementSummary) }] }
+function openDetail(row: ProcurementSummary) { if (row.orderNo) void router.push({ name: 'cross-border-procurement-detail', params: { orderNo: row.orderNo } }) }
+function returnToList() { if (canList.value) void router.push({ name: 'cross-border-procurement' }) }
+function message(cause: unknown) {
+  if (cause instanceof ApiError && ((cause.status || 0) >= 500 || cause.code.startsWith('B'))) return '服务暂不可用，请稍后重试'
+  return cause instanceof Error ? cause.message : '请求失败，请稍后重试'
+}
+async function loadList() {
+  const params = { page: query.page, size: query.size, orderNo: query.orderNo || undefined, productName: query.productName || undefined, purchaseCategory: query.purchaseCategory || undefined, status: query.status || undefined }
+  const key = JSON.stringify([identity.value, params])
+  if (inFlight === key) return
+  const sequence = ++requestSequence; inFlight = key; loading.value = true; error.value = ''
+  try { const result = await listProcurements(params); if (sequence === requestSequence) { rows.value = result.records; total.value = result.total } }
+  catch (cause) { if (sequence === requestSequence) { rows.value = []; total.value = 0; error.value = message(cause) } }
+  finally { if (sequence === requestSequence) { loading.value = false; inFlight = '' } }
+}
+async function loadDetail() {
+  if (!orderNo.value) { error.value = '采购单号缺失'; return }
+  const key = JSON.stringify([identity.value, orderNo.value])
+  if (inFlight === key) return
+  const sequence = ++requestSequence; inFlight = key; loading.value = true; error.value = ''; detail.value = null
+  try { const result = await getProcurement(orderNo.value); if (sequence === requestSequence) detail.value = result }
+  catch (cause) { if (sequence === requestSequence) error.value = message(cause) }
+  finally { if (sequence === requestSequence) { loading.value = false; inFlight = '' } }
+}
+function search() { if (query.page === 1) void loadList(); else query.page = 1 }
+function resetQuery() { const reload = query.page === 1; Object.assign(query, { page: 1, orderNo: '', purchaseCategory: '', productName: '', status: '' }); if (reload) void loadList() }
+function populate(payload: ProcurementCreate) {
+  Object.assign(form, { purchaseCategory: payload.purchaseCategory, productName: payload.productName, productSpecification: payload.productSpecification || '', productUrl: payload.productUrl || '',
+    purchaseQuantity: String(payload.purchaseQuantity), budgetUnitPrice: String(payload.budgetUnitPrice), currency: payload.currency, receivingAddress: payload.receivingAddress,
+    contactName: payload.contactName, contactPhone: payload.contactPhone, remark: payload.remark || '' })
+}
+function restorePending() {
+  pending.value = null; recoveryError.value = ''; submitError.value = ''; submittedOrder.value = ''; Object.assign(form, emptyProcurementDraft())
+  if (!storageKey.value) return
+  try { const saved = sessionStorage.getItem(storageKey.value); if (saved) { pending.value = Object.freeze(restoreProcurementSubmission(saved)); populate(pending.value) } }
+  catch { recoveryError.value = '上次提交记录暂无法恢复，请先在订单列表或通过客服核对提交结果，避免重复下单。' }
+}
+async function submit() {
+  if (submitting.value || !canCreate.value || recoveryError.value || !storageKey.value) return
+  submitError.value = ''; const owner = identity.value, key = storageKey.value; const resuming = Boolean(pending.value)
+  let started = false
+  try {
+    if (!pending.value) {
+      const payload = buildProcurementCreate(form, companyName.value, procurementRequestKey())
+      try { sessionStorage.setItem(key, JSON.stringify(payload)) } catch { throw new Error('浏览器暂无法保留提交信息，请允许会话存储后重试') }
+      pending.value = Object.freeze(payload)
+    }
+    submitting.value = true; started = true
+    const result = await createProcurement(pending.value)
+    sessionStorage.removeItem(key)
+    if (!active || owner !== identity.value) return
+    pending.value = null; submittedOrder.value = result.order.orderNo; ElMessage.success('采购订单已提交')
+    if (canList.value) await router.push({ name: 'cross-border-procurement-detail', params: { orderNo: result.order.orderNo } })
+  } catch (cause) {
+    if (!active || owner !== identity.value) return
+    if (!resuming && cause instanceof ApiError && definitelyRejected(cause)) { sessionStorage.removeItem(key); pending.value = null }
+    submitError.value = started && pending.value ? `${message(cause)}。提交结果尚未确认，请再次确认上次提交结果。` : message(cause)
+  } finally { submitting.value = false }
+}
+watch(() => [mode.value, orderNo.value, query.page, query.size, identity.value], (values, previous) => {
+  if (values[4] !== previous?.[4]) { rows.value = []; total.value = 0 }
+  ++requestSequence; inFlight = ''; loading.value = false; error.value = ''; detail.value = null
+  if (mode.value === 'create') restorePending()
+  else if (mode.value === 'detail') void loadDetail()
+  else void loadList()
+}, { immediate: true })
+onBeforeUnmount(() => { active = false; ++requestSequence })
 </script>
 
-<template><BusinessOrdersView kind="procurement" /></template>
+<template>
+  <section class="procurement-page client-ui" :aria-busy="loading || submitting">
+    <template v-if="mode === 'list'">
+      <QueryToolbar v-model="queryModel" layout="grid" ariaLabel="采购订单查询条件" :fields="queryFields" :search-on-reset="false" @search="search" @reset="resetQuery" />
+      <div class="procurement-table-card">
+        <DataTable v-model:page="query.page" v-model:page-size="query.size" :data="rows" :columns="columns" :row-actions="rowActions" :loading="loading" :total="total" :page-sizes="[10, 20, 50, 100]" row-key="orderNo" empty-text="暂无采购订单">
+          <template #toolbar-actions><el-button v-if="canCreate" type="primary" @click="router.push({ name: 'cross-border-procurement-create' })">新增下单</el-button></template>
+          <template v-if="error" #error><div class="procurement-error" role="alert"><span>{{ error }}</span><el-button :disabled="loading" @click="loadList">重新加载</el-button></div></template>
+          <template #orderNo="{ row }"><button class="procurement-link" type="button" @click="openDetail(row as ProcurementSummary)">{{ (row as ProcurementSummary).orderNo || '—' }}</button></template>
+          <template #budget="{ row }">{{ money((row as ProcurementSummary).budgetUnitPrice, (row as ProcurementSummary).currency) }}</template>
+          <template #status="{ row }"><el-tag :type="statusTone((row as ProcurementSummary).status)" size="small">{{ statusLabel((row as ProcurementSummary).status) }}</el-tag></template>
+          <template #createdAt="{ row }">{{ dateTime((row as ProcurementSummary).createdAt) }}</template>
+        </DataTable>
+      </div>
+    </template>
+    <section v-else-if="mode === 'detail'" v-loading="loading" class="procurement-detail" aria-label="采购订单详情">
+      <header class="procurement-heading"><div><el-button link type="primary" @click="returnToList">← 返回列表</el-button><h2>{{ detail?.order.orderNo || '采购订单详情' }}</h2></div><div><el-tag v-if="detail" :type="statusTone(detail.order.status)">{{ statusLabel(detail.order.status) }}</el-tag><el-button :disabled="loading" @click="loadDetail">刷新</el-button></div></header>
+      <div v-if="error" class="procurement-error" role="alert"><span>{{ error }}</span><el-button :disabled="loading" @click="loadDetail">重新加载</el-button></div>
+      <ProcurementDetailPanel v-else-if="detail" :detail="detail" /><el-skeleton v-else :rows="8" animated />
+    </section>
+    <section v-else class="procurement-create" aria-label="采购下单">
+      <header class="procurement-heading"><div><h2>海外采购下单</h2><p>一单一个商品及规格；预算仅授权样品货款，运费及关税另行核定。</p></div><el-button v-if="canList" @click="returnToList">返回列表</el-button></header>
+      <el-result v-if="!canCreate" icon="warning" title="没有采购下单权限" sub-title="请联系企业管理员配置权限" />
+      <el-result v-else-if="submittedOrder" icon="success" title="采购订单已提交" :sub-title="submittedOrder"><template #extra><el-button @click="restorePending">新建另一单</el-button></template></el-result>
+      <template v-else>
+        <el-alert v-if="recoveryError" :title="recoveryError" type="error" :closable="false" />
+        <el-alert v-else-if="pending" title="已保留本次提交内容。请再次确认上次提交结果，确认前不修改订单信息。" type="warning" :closable="false" />
+        <el-alert v-if="submitError" class="submit-error" :title="submitError" type="error" :closable="false" />
+        <el-form :model="form" label-position="top" :disabled="submitting || Boolean(pending) || Boolean(recoveryError)" @submit.prevent="submit">
+          <h3>商品与预算</h3><div class="procurement-form-grid">
+            <el-form-item label="采购品类" required><el-input v-model.trim="form.purchaseCategory" maxlength="128" placeholder="请输入采购品类" /></el-form-item>
+            <el-form-item label="商品名称" required><el-input v-model.trim="form.productName" maxlength="255" placeholder="请输入商品名称" /></el-form-item>
+            <el-form-item label="商品规格"><el-input v-model.trim="form.productSpecification" maxlength="500" placeholder="规格、型号" /></el-form-item>
+            <el-form-item label="采购数量（件）" required><el-input v-model.trim="form.purchaseQuantity" inputmode="numeric" maxlength="18" placeholder="正整数" /></el-form-item>
+            <el-form-item label="预算单价" required><el-input v-model.trim="form.budgetUnitPrice" inputmode="decimal" maxlength="20" placeholder="请明确填写；免费样品填 0" /></el-form-item>
+            <el-form-item label="预算币种" required><el-select v-model="form.currency"><el-option label="美元 USD" value="USD" /><el-option label="人民币 CNY" value="CNY" /></el-select></el-form-item>
+            <el-form-item class="full" label="商品链接"><el-input v-model.trim="form.productUrl" maxlength="2000" placeholder="https://…" /></el-form-item>
+          </div><p class="procurement-hint">货款预算总上限：<strong>{{ money(draftBudgetTotal(form), form.currency) }}</strong>。零预算仅授权免费样品；实际货款按供应商实付核定。</p>
+          <h3>最终国内收件资料</h3><div class="procurement-form-grid">
+            <el-form-item label="收件人" required><el-input v-model.trim="form.contactName" maxlength="128" placeholder="实际收件人姓名" /></el-form-item>
+            <el-form-item label="联系电话" required><el-input v-model.trim="form.contactPhone" maxlength="64" type="tel" placeholder="快递可联系的电话" /></el-form-item>
+            <el-form-item label="下单企业"><el-input :model-value="companyName" disabled /></el-form-item>
+            <el-form-item class="full" label="完整国内地址" required><el-input v-model.trim="form.receivingAddress" maxlength="1000" placeholder="省、市、区县、街道及详细门牌" /></el-form-item>
+            <el-form-item class="full" label="采购要求"><el-input v-model="form.remark" type="textarea" :rows="3" maxlength="1000" show-word-limit placeholder="其他采购要求（选填）" /></el-form-item>
+          </div>
+        </el-form>
+        <footer class="procurement-form-actions"><el-button v-if="canList" :disabled="submitting" @click="returnToList">返回列表</el-button><el-button type="primary" :loading="submitting" :disabled="Boolean(recoveryError) || (!pending && !companyName) || !identity" @click="submit">{{ pending ? '确认上次提交结果' : '提交采购订单' }}</el-button></footer>
+      </template>
+    </section>
+  </section>
+</template>
+
+<style scoped>
+.procurement-page { display: grid; gap: var(--client-section-gap); min-width: 0; }
+.procurement-table-card, .procurement-detail, .procurement-create { min-width: 0; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }
+.procurement-table-card { overflow: hidden; }.procurement-detail, .procurement-create { padding: 16px 20px 24px; }
+.procurement-heading { display: flex; justify-content: space-between; align-items: center; gap: 20px; min-height: 54px; border-bottom: 1px solid var(--border); padding-bottom: 12px; }
+.procurement-heading > div { display: flex; align-items: center; gap: 14px; min-width: 0; }.procurement-heading h2 { margin: 0; color: var(--navy); font-size: 18px; overflow-wrap: anywhere; }
+.procurement-create .procurement-heading > div { display: block; }.procurement-heading p { margin: 7px 0 0; font-size: 13px; color: var(--muted); }
+.procurement-link { padding: 0; border: 0; background: transparent; color: var(--client-action); font: inherit; cursor: pointer; text-align: left; }.procurement-link:hover { text-decoration: underline; }
+.procurement-error { min-height: 160px; display: flex; justify-content: center; align-items: center; gap: 16px; color: #b42318; }.procurement-error span { max-width: 900px; overflow-wrap: anywhere; }
+.procurement-form-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 0 24px; }.procurement-form-grid .full { grid-column: 1 / -1; }.procurement-form-grid :deep(.el-select) { width: 100%; }
+.procurement-create h3 { margin: 22px 0 16px; color: var(--navy); font-size: 14px; }.procurement-hint { margin: 0 0 20px; line-height: 1.8; font-size: 13px; color: var(--muted); }.procurement-hint strong { color: var(--navy); }
+.procurement-form-actions { display: flex; justify-content: flex-end; gap: 12px; padding-top: 16px; border-top: 1px solid var(--border); }.submit-error { margin: 12px 0; }
+@media (max-width: 767px) {
+  .procurement-form-grid { grid-template-columns: 1fr; }.procurement-heading, .procurement-heading > div { flex-wrap: wrap; }
+}
+</style>

src/modules/dashboard/overview.test.mjs

@@ -0,0 +1,156 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+import { loadDashboardOverview } from './overview.ts'
+
+const dashboardView = readFileSync(new URL('./views/DashboardView.vue', import.meta.url), 'utf8')
+
+const profile = 'company:profile:view'
+const list = 'order:first-leg:list'
+const edit = 'order:first-leg:edit'
+const company = { tenantName: '示例企业', status: 'ACTIVE' }
+
+function order(overrides = {}) {
+  return {
+    orderId: 101,
+    orderNo: 'ORDER-101',
+    inboundCode: 'INBOUND-101',
+    destinationWarehouseName: '示例目的仓',
+    channelName: '示例渠道',
+    mainStatus: 'WAIT_MEASURE',
+    customerFeeConfirmationRequired: false,
+    createdAt: '2026-09-18T08:00:00Z',
+    ...overrides,
+  }
+}
+
+function draft(overrides = {}) {
+  return { ...order(), status: 'DRAFT', ...overrides }
+}
+
+function requests(overrides = {}) {
+  return {
+    company: async () => company,
+    orders: async () => ({ records: [order()] }),
+    drafts: async () => ({ records: [draft()] }),
+    ...overrides,
+  }
+}
+
+test('only calls sources allowed by their complete permission requirements', async (t) => {
+  const cases = [
+    { permissions: [], expected: [] },
+    { permissions: [profile], expected: ['company'] },
+    { permissions: [list], expected: ['orders'] },
+    { permissions: [edit], expected: [] },
+    { permissions: [list, edit], expected: ['orders', 'drafts'] },
+    { permissions: [profile, list, edit], expected: ['company', 'orders', 'drafts'] },
+  ]
+  for (const { permissions, expected } of cases) {
+    await t.test(permissions.join(',') || 'no permissions', async () => {
+      const calls = []
+      const result = await loadDashboardOverview(permissions, requests({
+        company: async () => { calls.push('company'); return company },
+        orders: async () => { calls.push('orders'); return { records: [order()] } },
+        drafts: async () => { calls.push('drafts'); return { records: [draft()] } },
+      }))
+      assert.deepEqual(calls, expected)
+      assert.equal(result.company, expected.includes('company') ? company : null)
+      assert.equal(result.orders.length, expected.includes('orders') ? 1 : 0)
+      assert.equal(result.drafts.length, expected.includes('drafts') ? 1 : 0)
+      assert.deepEqual(result.errors, {})
+    })
+  }
+})
+
+test('one failed source preserves successful sources and exposes its error', async (t) => {
+  for (const failedSource of ['company', 'orders', 'drafts']) {
+    await t.test(failedSource, async () => {
+      const result = await loadDashboardOverview([profile, list, edit], requests({
+        [failedSource]: async () => { throw new Error(`${failedSource} unavailable`) },
+      }))
+      assert.deepEqual(result.errors, { [failedSource]: `${failedSource} unavailable` })
+      assert.equal(result.company, failedSource === 'company' ? null : company)
+      assert.equal(result.orders.length, failedSource === 'orders' ? 0 : 1)
+      assert.equal(result.drafts.length, failedSource === 'drafts' ? 0 : 1)
+    })
+  }
+})
+
+test('loads sources concurrently and distinguishes a failed source from an empty result', async () => {
+  const pending = new Map()
+  const operation = loadDashboardOverview([profile, list, edit], requests(Object.fromEntries(
+    ['company', 'orders', 'drafts'].map((source) => [source, () => new Promise((resolve, reject) => pending.set(source, { resolve, reject }))]),
+  )))
+  assert.deepEqual([...pending.keys()], ['company', 'orders', 'drafts'])
+  pending.get('company').resolve(company)
+  pending.get('orders').resolve({ records: [] })
+  pending.get('drafts').reject(null)
+  const result = await operation
+  assert.deepEqual(result.orders, [])
+  assert.equal(result.errors.orders, undefined)
+  assert.deepEqual(result.drafts, [])
+  assert.equal(result.errors.drafts, '订单草稿加载失败，请重试')
+})
+
+test('sorts each source by creation time and includes only actual drafts', async () => {
+  const orders = [
+    order({ orderId: 1, createdAt: '2026-09-16T08:00:00Z' }),
+    order({ orderId: 2, createdAt: '2026-09-18T08:00:00Z', mainStatus: 'COMPLETED', customerFeeConfirmationRequired: true }),
+  ]
+  const drafts = [
+    draft({ orderId: 3, createdAt: '2026-09-15T08:00:00Z' }),
+    draft({ orderId: 4, status: 'SUBMITTED', createdAt: '2026-09-19T08:00:00Z' }),
+    draft({ orderId: 5, createdAt: '2026-09-17T08:00:00Z' }),
+  ]
+  const result = await loadDashboardOverview([list, edit], requests({
+    orders: async () => ({ records: orders }),
+    drafts: async () => ({ records: drafts }),
+  }))
+  assert.deepEqual(result.orders.map(({ id }) => id), ['2', '1'])
+  assert.deepEqual(result.drafts.map(({ id }) => id), ['5', '3'])
+  assert.equal(result.orders[0].status, 'COMPLETED')
+  assert.equal(result.orders[0].requiresFeeConfirmation, true)
+  assert.ok(result.drafts.every(({ status, requiresFeeConfirmation }) => status === 'DRAFT' && !requiresFeeConfirmation))
+  assert.deepEqual(orders.map(({ orderId }) => orderId), [1, 2])
+  assert.deepEqual(drafts.map(({ orderId }) => orderId), [3, 4, 5])
+})
+
+test('keeps absent business numbers null and internal identifiers out of display fields', async () => {
+  const missing = { orderId: 987654, orderNo: null, inboundCode: null, destinationWarehouseName: null, channelName: null }
+  const result = await loadDashboardOverview([list, edit], requests({
+    orders: async () => ({ records: [order(missing)] }),
+    drafts: async () => ({ records: [draft(missing)] }),
+  }))
+  for (const item of [...result.orders, ...result.drafts]) {
+    assert.equal(item.id, '987654')
+    assert.equal(item.orderNo, null)
+    assert.equal(item.inboundCode, null)
+    assert.equal(item.destination, null)
+    assert.equal(item.channel, null)
+  }
+})
+
+test('matches the updated six-action icon and motion treatment', () => {
+  assert.match(dashboardView, /icon: Forklift/)
+  assert.doesNotMatch(dashboardView, /PanelsTopLeft/)
+  assert.match(dashboardView, /featured: true/)
+  assert.match(dashboardView, /quick-action--featured/)
+  assert.match(dashboardView, /featured-aura 5s ease-in-out infinite/)
+  assert.match(dashboardView, /featured-shine 3\.6s ease-in-out infinite/)
+  assert.match(dashboardView, /\.quick-action:hover \{[^}]*border-color:[^}]*transform: translateY\(-9px\);/)
+  assert.match(dashboardView, /prefers-reduced-motion: reduce/)
+  assert.match(dashboardView, /\.client-dashboard a:focus-visible/)
+})
+
+test('opens all six dashboard businesses through their dedicated create pages', () => {
+  for (const route of [
+    '/orders/first-leg/create',
+    '/overseas-warehouse/return-relabel/create',
+    '/cross-border/domestic-trucking/create',
+    '/cross-border/pallet-shipping/create',
+    '/cross-border/procurement/create',
+    '/overseas-warehouse/labeling/create',
+  ]) assert.match(dashboardView, new RegExp(`route: '${route.replaceAll('/', '\\/')}'`))
+  assert.match(dashboardView, /title: '退货换标'[\s\S]*?permission: 'merchant:overseas-warehouse:return-order:create'/)
+})

src/modules/dashboard/overview.ts

@@ -0,0 +1,94 @@
+import type { FirstLegOrderStatus } from '@chongchong/shared'
+import type { MerchantFirstLegOrderRow, MerchantUnifiedOrderRow } from '@/modules/first-leg/public'
+import type { MerchantTenantStatus } from '@/modules/tenant-management/public'
+
+export interface DashboardCompany {
+  tenantName: string
+  status: MerchantTenantStatus
+}
+
+export interface DashboardOrder {
+  id: string
+  orderNo: string | null
+  inboundCode: string | null
+  destination: string | null
+  channel: string | null
+  status: FirstLegOrderStatus
+  createdAt: string
+  requiresFeeConfirmation: boolean
+}
+
+export type DashboardSource = 'company' | 'orders' | 'drafts'
+
+export interface DashboardOverview {
+  company: DashboardCompany | null
+  orders: DashboardOrder[]
+  drafts: DashboardOrder[]
+  errors: Partial<Record<DashboardSource, string>>
+}
+
+interface DashboardRequests {
+  company: () => Promise<DashboardCompany>
+  orders: () => Promise<{ records: MerchantUnifiedOrderRow[] }>
+  drafts: () => Promise<{ records: MerchantFirstLegOrderRow[] }>
+}
+
+const sourceErrorMessages: Record<DashboardSource, string> = {
+  company: '企业资料加载失败，请重试',
+  orders: '订单动态加载失败，请重试',
+  drafts: '订单草稿加载失败，请重试',
+}
+
+function newestFirst(records: DashboardOrder[]) {
+  return records.sort((left, right) => (Date.parse(right.createdAt) || 0) - (Date.parse(left.createdAt) || 0))
+}
+
+export async function loadDashboardOverview(permissions: readonly string[], requests: DashboardRequests): Promise<DashboardOverview> {
+  const result: DashboardOverview = { company: null, orders: [], drafts: [], errors: {} }
+  const allowed = new Set(permissions)
+  const tasks: Array<{ source: DashboardSource; run: () => Promise<void> }> = []
+
+  if (allowed.has('company:profile:view')) {
+    tasks.push({ source: 'company', run: async () => { result.company = await requests.company() } })
+  }
+  if (allowed.has('order:first-leg:list')) {
+    tasks.push({ source: 'orders', run: async () => {
+      const response = await requests.orders()
+      result.orders = newestFirst(response.records.map((order) => ({
+        id: String(order.orderId),
+        orderNo: order.orderNo ?? null,
+        inboundCode: order.inboundCode ?? null,
+        destination: order.destinationWarehouseName ?? null,
+        channel: order.channelName ?? null,
+        status: order.mainStatus,
+        createdAt: order.createdAt,
+        requiresFeeConfirmation: order.customerFeeConfirmationRequired === true,
+      })))
+    } })
+    if (allowed.has('order:first-leg:edit')) {
+      tasks.push({ source: 'drafts', run: async () => {
+        const response = await requests.drafts()
+        result.drafts = newestFirst(response.records.filter((order) => order.status === 'DRAFT').map((order) => ({
+          id: String(order.orderId),
+          orderNo: order.orderNo ?? null,
+          inboundCode: order.inboundCode ?? null,
+          destination: order.destinationWarehouseName ?? null,
+          channel: order.channelName ?? null,
+          status: 'DRAFT',
+          createdAt: order.createdAt,
+          requiresFeeConfirmation: false,
+        })))
+      } })
+    }
+  }
+
+  const settled = await Promise.allSettled(tasks.map(async (task) => task.run()))
+  settled.forEach((outcome, index) => {
+    if (outcome.status === 'fulfilled') return
+    const source = tasks[index]!.source
+    result.errors[source] = outcome.reason instanceof Error && outcome.reason.message.trim()
+      ? outcome.reason.message
+      : sourceErrorMessages[source]
+  })
+  return result
+}

src/modules/dashboard/routes.ts

@@ -9,7 +9,7 @@ export const dashboardModule = {
       name: 'dashboard',
       component: () => import('./views/DashboardView.vue'),
       release: 'active',
-      meta: { title: '业务总览', description: '企业账户与头程业务概览', permission: 'dashboard:view' },
+      meta: { title: '业务总览', description: '企业账户与头程业务概览', permission: 'dashboard:view', workspaceTab: false },
       navigation: { key: 'dashboard', icon: Gauge },
     },
   ],

src/modules/dashboard/views/DashboardView.test.mjs

@@ -1,49 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const source = readFileSync(new URL('./DashboardView.vue', import.meta.url), 'utf8')
-
-test('loads real dashboard data allowed by the current permissions', () => {
-  assert.match(source, /auth\.hasPermission\('company:profile:view'\).*tenant\.loadCompanyContext\(\)/)
-  assert.match(source, /auth\.hasPermission\('company:member:list'\).*tenant\.loadMembers\(\)/)
-  assert.match(source, /auth\.hasPermission\('order:first-leg:list'\).*orders\.load\(\)/)
-  assert.match(source, /onMounted\(async \(\) => \{\s*await loadDashboardData\(\)\s*showQualificationReminderOnce\(\)\s*\}\)/)
-})
-
-test('prompts once per session for incomplete company qualification and opens the upload dialog', () => {
-  assert.match(source, /\['PROFILE_REQUIRED', 'REJECTED'\]\.includes\(tenant\.company\.auditStatus\)/)
-  assert.match(source, /sessionStorage\.getItem\(reminderKey\)/)
-  assert.match(source, /sessionStorage\.setItem\(reminderKey, 'shown'\)/)
-  assert.match(source, /title="完善企业认证资料"/)
-  assert.match(source, /立即上传认证资料/)
-  assert.match(source, /router\.push\(\{ path: '\/company\/profile', query: \{ qualification: 'upload' \} \}\)/)
-})
-
-test('isolates recoverable dashboard failures without hiding successful sections', () => {
-  assert.match(source, /Promise\.allSettled/)
-  assert.match(source, /Partial<Record<DashboardDataSource, string>>/)
-  assert.match(source, /:aria-busy="loading"/)
-  assert.match(source, /role="alert"/)
-  assert.match(source, /部分业务数据加载失败/)
-  assert.match(source, /ordersUnavailable/)
-  assert.match(source, /companyUnavailable/)
-  assert.match(source, /订单数据暂不可用，请重新加载后查看。/)
-  assert.match(source, /企业资料暂不可用，请重新加载后查看。/)
-  assert.match(source, /@click="loadDashboardData"/)
-  assert.doesNotMatch(source, /<template v-else>\s*<section class="quick-order-band">/)
-})
-
-test('matches the prototype business overview and routes each card to its real business page', () => {
-  assert.match(source, /选择业务，快速下单/)
-  assert.match(source, /海外采购/)
-  assert.match(source, /美国本土卡/)
-  assert.match(source, /美本土散板/)
-  assert.match(source, /route: '\/cross-border\/procurement'/)
-  assert.match(source, /route: '\/cross-border\/domestic-trucking'/)
-  assert.match(source, /route: '\/cross-border\/pallet-shipping'/)
-  assert.match(source, /auth\.hasPermission\(business\.permission\)/)
-  assert.match(source, /order\.status === 'DELIVERED'/)
-  assert.match(source, /currentMonthOrderCount/)
-  assert.match(source, /提交订单后，专属客户经理将在 24 小时内与您联系/)
-})

src/modules/dashboard/views/DashboardView.vue

@@ -1,640 +1,104 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import { computed } from 'vue'
-import { useRouter } from 'vue-router'
+import { ArrowRight, Forklift, PackageOpen, RefreshCcw, Ship, ShoppingCart, Tags, Truck, Warehouse } from '@lucide/vue'
-import { ElMessage } from 'element-plus'
-import {
-  AlertTriangle,
-  ArrowRight,
-  CircleQuestionMark,
-  Headphones,
-  Lightbulb,
-  PanelsTopLeft,
-  ShoppingCart,
-  Tags,
-  Truck,
-} from '@lucide/vue'
-import { useFirstLegOrdersStore } from '@/modules/first-leg/public'
-import { useTenantAdministrationStore } from '@/modules/tenant-management/public'
 import { useAuthStore } from '@/modules/auth/public'
+import { FirstLegOrdersView } from '@/modules/first-leg/public'
 
-const router = useRouter()
-const orders = useFirstLegOrdersStore()
-const tenant = useTenantAdministrationStore()
 const auth = useAuthStore()
-const loading = ref(false)
-const qualificationReminderOpen = ref(false)
-type DashboardDataSource = 'company' | 'members' | 'orders'
-const loadErrors = ref<Partial<Record<DashboardDataSource, string>>>({})
-const dataSourceLabels: Record<DashboardDataSource, string> = {
-  company: '企业资料',
-  members: '企业成员',
-  orders: '头程订单',
-}
 
-const companyUnavailable = computed(() => Boolean(loadErrors.value.company))
+const primaryActions = computed(() => [
-const ordersUnavailable = computed(() => Boolean(loadErrors.value.orders))
+  { title: '头程下单', description: '国内提货 · 海运订舱 · 清关派送', icon: Ship, route: '/orders/first-leg/create', permission: 'order:first-leg:create', tone: 'blue', featured: true },
-const loadErrorItems = computed(() =>
+  { title: '退货换标', description: '退件接收 · 标签更换 · 重新入仓', icon: RefreshCcw, route: '/overseas-warehouse/return-relabel/create', permission: 'merchant:overseas-warehouse:return-order:create', tone: 'purple', featured: false },
-  (Object.keys(loadErrors.value) as DashboardDataSource[]).map((key) => ({
+  { title: '美国本土卡', description: '港口提柜 · 仓到仓 · 仓到门', icon: Truck, route: '/cross-border/domestic-trucking/create', permission: 'merchant:cross-border:domestic-trucking:create', tone: 'green', featured: false },
-    key,
+  { title: '美本土散板', description: '拼车拼载 · 打盘服务 · 灵活派送', icon: Forklift, route: '/cross-border/pallet-shipping/create', permission: 'merchant:cross-border:pallet-shipping:create', tone: 'cyan', featured: false },
-    label: dataSourceLabels[key],
+  { title: '海外采购', description: '采购代购 · 验货质检 · 集中发货', icon: ShoppingCart, route: '/cross-border/procurement/create', permission: 'merchant:cross-border:procurement:create', tone: 'orange', featured: false },
-    message: loadErrors.value[key] ?? '请求失败',
+  { title: '贴标申请', description: '产品建档 · 标签上传 · 批量贴标', icon: Tags, route: '/overseas-warehouse/labeling/create', permission: 'merchant:overseas-warehouse:relabel:create', tone: 'rose', featured: false },
-  })),
+  { title: '仓储转运', description: '仓储管理 · 货物转运', icon: Warehouse, route: '/overseas-warehouse/storage-transfer', permission: 'merchant:overseas-warehouse:transfer:list', tone: 'teal', featured: false, actionLabel: '开始办理' },
-)
+  { title: '货物废弃', description: '废弃申请 · 处理进度', icon: PackageOpen, route: '/overseas-warehouse/cargo-disposal', permission: 'merchant:overseas-warehouse:discard:list', tone: 'brown', featured: false, actionLabel: '开始办理' },
-const canViewOrders = computed(() => auth.hasPermission('order:first-leg:list'))
+].filter((action) => auth.hasPermission(action.permission)))
-const accountName = computed(() => {
-  if (!companyUnavailable.value && tenant.company.companyName) return tenant.company.companyName
-  return auth.user?.tenantName || auth.user?.name || '企业客户'
-})
-const accountInitial = computed(() => accountName.value.trim().slice(0, 1).toUpperCase() || 'C')
-const completedOrderCount = computed(() => orders.orders.filter((order) => order.status === 'DELIVERED').length)
-const currentMonthOrderCount = computed(() => {
-  const now = new Date()
-  return orders.orders.filter((order) => {
-    const createdAt = new Date(order.createdAt)
-    return !Number.isNaN(createdAt.getTime())
-      && createdAt.getFullYear() === now.getFullYear()
-      && createdAt.getMonth() === now.getMonth()
-  }).length
-})
-const overviewStats = computed(() => [
-  { label: '进行中订单', value: dashboardOrderValue(orders.activeCount) },
-  { label: '已完成订单', value: dashboardOrderValue(completedOrderCount.value) },
-  { label: '本月下单', value: dashboardOrderValue(currentMonthOrderCount.value) },
-])
-const businessCards = [
-  {
-    title: '海外采购',
-    description: '采购代购 · 验货质检 · 集中发货',
-    icon: ShoppingCart,
-    tone: 'blue',
-    route: '/cross-border/procurement',
-    permission: 'merchant:cross-border:procurement',
-  },
-  {
-    title: '美国本土卡',
-    description: '港口提柜 · 仓到仓 · 仓到门',
-    icon: Truck,
-    tone: 'green',
-    route: '/cross-border/domestic-trucking',
-    permission: 'merchant:cross-border:domestic-trucking',
-  },
-  {
-    title: '美本土散板',
-    description: '拼车拼载 · 打盘服务 · 灵活派送',
-    icon: PanelsTopLeft,
-    tone: 'teal',
-    route: '/cross-border/pallet-shipping',
-    permission: 'merchant:cross-border:pallet-shipping',
-  },
-] as const
 
-function dashboardOrderValue(value: number) {
-  if (!canViewOrders.value || ordersUnavailable.value) return '—'
-  return String(value)
-}
-
-function errorMessage(error: unknown) {
-  return error instanceof Error ? error.message : '请求失败，请稍后重试'
-}
-
-async function loadDashboardData() {
-  loading.value = true
-  loadErrors.value = {}
-  const requests: Array<{ source: DashboardDataSource; request: Promise<unknown> }> = []
-  if (auth.hasPermission('company:profile:view')) requests.push({ source: 'company', request: tenant.loadCompanyContext() })
-  if (auth.hasPermission('company:member:list')) requests.push({ source: 'members', request: tenant.loadMembers() })
-  if (auth.hasPermission('order:first-leg:list')) requests.push({ source: 'orders', request: orders.load() })
-  try {
-    const results = await Promise.allSettled(requests.map(({ request }) => request))
-    const nextErrors: Partial<Record<DashboardDataSource, string>> = {}
-    results.forEach((result, index) => {
-      const request = requests[index]
-      if (request && result.status === 'rejected') nextErrors[request.source] = errorMessage(result.reason)
-    })
-    loadErrors.value = nextErrors
-  } finally {
-    loading.value = false
-  }
-}
-
-function showQualificationReminderOnce() {
-  if (companyUnavailable.value || !auth.hasPermission('company:qualification:upload')) return
-  if (!['PROFILE_REQUIRED', 'REJECTED'].includes(tenant.company.auditStatus)) return
-  const reminderKey = `client-qualification-reminder:${auth.user?.id ?? 'current'}`
-  if (sessionStorage.getItem(reminderKey)) return
-  sessionStorage.setItem(reminderKey, 'shown')
-  qualificationReminderOpen.value = true
-}
-
-async function openQualificationUpload() {
-  qualificationReminderOpen.value = false
-  await router.push({ path: '/company/profile', query: { qualification: 'upload' } })
-}
-
-function openBusinessOrder(business: typeof businessCards[number]) {
-  if (auth.hasPermission(business.permission)) {
-    void router.push(business.route)
-    return
-  }
-  ElMessage.warning(`当前账号暂无${business.title}权限，请联系企业管理员。`)
-}
-
-function showSupportMessage(type: 'service' | 'faq' | 'quote') {
-  const messages = {
-    service: '客服联系方式正在配置中，请联系您的专属客户经理。',
-    faq: '常见问题页面即将上线。',
-    quote: '提交订单后，客户经理将根据货物信息为您提供报价。',
-  }
-  ElMessage.info(messages[type])
-}
-
-onMounted(async () => {
-  await loadDashboardData()
-  showQualificationReminderOnce()
-})
 </script>
 
 <template>
-  <div v-loading="loading" class="client-dashboard" :aria-busy="loading">
+  <div class="client-dashboard">
-    <el-dialog v-model="qualificationReminderOpen" title="完善企业认证资料" width="min(520px, 92vw)" append-to-body>
+    <header class="business-intro">
-      <p class="qualification-reminder-copy">请先上传营业执照和统一社会信用代码并提交审核；法人身份证及其他资质可选填。审核通过后即可提交头程订单。</p>
+      <h1>选择业务，快速下单</h1>
-      <template #footer><el-button @click="qualificationReminderOpen = false">稍后处理</el-button><el-button type="primary" @click="openQualificationUpload">立即上传认证资料</el-button></template>
+      <p>请选择您需要的业务类型，填写信息后提交订单，我们将尽快为您安排。</p>
-    </el-dialog>
+    </header>
-    <div v-if="loadErrorItems.length" class="dashboard-load-error" role="alert">
-      <AlertTriangle :size="20" aria-hidden="true" />
-      <div>
-        <strong>部分业务数据加载失败</strong>
-        <ul>
-          <li v-for="item in loadErrorItems" :key="item.key">
-            <span>{{ item.label }}：</span>{{ item.message }}
-          </li>
-        </ul>
-      </div>
-      <el-button :loading="loading" @click="loadDashboardData">重新加载</el-button>
-    </div>
 
-    <div class="dashboard-layout">
+    <section class="quick-actions" aria-label="业务选择">
-      <main class="dashboard-business" aria-labelledby="dashboard-heading">
+      <RouterLink v-for="(action, index) in primaryActions" :key="action.route" :to="action.route" class="quick-action" :class="[`quick-action--${action.tone}`, { 'quick-action--featured': action.featured }]" :style="{ '--entry-index': index }">
-        <header class="dashboard-intro">
+        <span class="action-icon"><component :is="action.icon" :size="25" :stroke-width="2.2" aria-hidden="true" /></span>
-          <h2 id="dashboard-heading">选择业务，快速下单</h2>
+        <span class="action-copy"><strong>{{ action.title }}</strong><small>{{ action.description }}</small></span>
-          <p>请选择您需要的业务类型，填写信息后提交订单，我们将尽快为您安排。</p>
+        <span class="action-enter"><span>{{ action.actionLabel ?? '开始下单' }}</span><ArrowRight :size="15" aria-hidden="true" /></span>
-        </header>
+      </RouterLink>
+      <p v-if="!primaryActions.length" class="no-actions">当前账号暂无常用业务权限，请通过已授权菜单办理业务，或联系企业管理员。</p>
+    </section>
 
-        <section class="business-card-grid" aria-label="可选业务">
+    <FirstLegOrdersView v-if="auth.hasPermission('order:first-leg:list')" :show-create-action="false" class="dashboard-order-list" />
-          <button
+    <section v-else class="orders-permission-empty">
-            v-for="business in businessCards"
+      <strong>暂无头程订单查看权限</strong>
-            :key="business.title"
+      <span>需要查看企业订单时，请联系企业管理员开通。</span>
-            type="button"
+    </section>
-            class="business-card"
-            :class="`business-card--${business.tone}`"
-            @click="openBusinessOrder(business)"
-          >
-            <span class="business-card__icon" aria-hidden="true">
-              <component :is="business.icon" :size="29" :stroke-width="2.4" />
-            </span>
-            <span class="business-card__copy">
-              <strong>{{ business.title }}</strong>
-              <small>{{ business.description }}</small>
-            </span>
-            <span class="business-card__action">
-              {{ auth.hasPermission(business.permission) ? '开始下单' : '暂无权限' }}
-              <ArrowRight :size="18" aria-hidden="true" />
-            </span>
-          </button>
-        </section>
-      </main>
-
-      <aside class="dashboard-aside" aria-label="账户与业务信息">
-        <section class="aside-card account-card">
-          <h3>账户信息</h3>
-          <div class="account-summary">
-            <span class="account-avatar">{{ accountInitial }}</span>
-            <span class="account-copy">
-              <strong>{{ accountName }}</strong>
-              <small>企业客户</small>
-            </span>
-          </div>
-          <p v-if="companyUnavailable" class="account-load-error" role="status">企业资料暂不可用，请重新加载后查看。</p>
-        </section>
-
-        <section class="aside-card">
-          <h3>数据概览</h3>
-          <dl class="overview-stats">
-            <div v-for="stat in overviewStats" :key="stat.label">
-              <dt>{{ stat.label }}</dt>
-              <dd>{{ stat.value }}</dd>
-            </div>
-          </dl>
-          <p v-if="ordersUnavailable" class="dashboard-section-error" role="status">订单数据暂不可用，请重新加载后查看。</p>
-        </section>
-
-        <section class="aside-card">
-          <h3>帮助与支持</h3>
-          <div class="support-links">
-            <button type="button" @click="showSupportMessage('service')"><Headphones :size="19" /><span>联系客服</span></button>
-            <button type="button" @click="showSupportMessage('faq')"><CircleQuestionMark :size="19" /><span>常见问题</span></button>
-            <button type="button" @click="showSupportMessage('quote')"><Tags :size="19" /><span>获取报价</span></button>
-          </div>
-        </section>
-
-        <div class="dashboard-tip">
-          <Lightbulb :size="19" aria-hidden="true" />
-          <p>提交订单后，专属客户经理将在 24 小时内与您联系，确认运输方案与报价。</p>
-        </div>
-      </aside>
-    </div>
   </div>
 </template>
 
 <style scoped>
-.client-dashboard {
+.client-dashboard { display: flex; min-width: 0; container-name: dashboard-content; container-type: inline-size; flex-direction: column; gap: 14px; padding: 0 8px 18px; color: var(--navy); animation: dashboard-enter .3s ease-out both; }
-  --dashboard-blue: #1565c0;
+.business-intro { padding-top: 0; }
-  --dashboard-green: #3f9f47;
+.business-intro h1 { margin: 0; color: #172033; font-size: 27px; font-weight: 750; letter-spacing: -.5px; line-height: 1.3; }
-  --dashboard-teal: #078a99;
+.business-intro p { margin: 5px 0 0; color: #7a8495; font-size: 13px; line-height: 1.55; }
-  display: block;
+.quick-actions { display: grid; grid-template-columns: repeat(8, minmax(150px, 1fr)); gap: 10px; overflow-x: auto; padding: 0 0 6px; scroll-snap-type: x proximity; scrollbar-color: #bdc9dc transparent; scrollbar-width: thin; }
-  min-height: calc(100vh - 128px);
+.quick-actions::-webkit-scrollbar { height: 7px; }
-}
+.quick-actions::-webkit-scrollbar-thumb { border-radius: 999px; background: #bdc9dc; }
-
+.quick-actions::-webkit-scrollbar-track { background: transparent; }
-.dashboard-load-error {
+.quick-action { scroll-snap-align: start; }
-  margin-bottom: 20px;
+.quick-action { --action-a: #2563eb; --action-b: #3730a3; --action-soft: rgba(37, 99, 235, .18); position: relative; isolation: isolate; display: flex; min-width: 0; min-height: 190px; overflow: hidden; align-items: center; flex-direction: column; padding: 21px 10px 18px; border: 1px solid rgba(148, 163, 184, .2); border-radius: 17px; background: linear-gradient(155deg, #fff 8%, rgba(248, 250, 252, .96) 100%); color: inherit; text-align: center; text-decoration: none; box-shadow: 0 12px 34px rgba(15, 23, 42, .07); backdrop-filter: blur(10px); animation: action-enter .4s cubic-bezier(.22, 1, .36, 1) both; animation-delay: calc(var(--entry-index) * 55ms); transition: border-color .35s ease, box-shadow .35s ease, transform .35s cubic-bezier(.22, 1, .36, 1); }
-}
+.quick-action::before { position: absolute; width: 120px; height: 120px; border-radius: 50%; background: radial-gradient(circle, var(--action-soft), transparent 70%); content: ''; right: -62px; top: -66px; transition: transform .4s ease; }
-
+.quick-action::after { position: absolute; right: 20%; bottom: 0; left: 20%; height: 3px; border-radius: 99px 99px 0 0; background: linear-gradient(90deg, var(--action-a), var(--action-b)); content: ''; opacity: .55; transform: scaleX(.35); transition: all .35s ease; }
-.qualification-reminder-copy { margin: 0; color: #475467; font-size: 14px; line-height: 1.75; }
+.quick-action--blue { --action-a: #2563eb; --action-b: #3730a3; --action-soft: rgba(37, 99, 235, .18); }
-
+.quick-action--purple { --action-a: #8b5cf6; --action-b: #c026d3; --action-soft: rgba(139, 92, 246, .18); }
-.dashboard-load-error ul {
+.quick-action--green { --action-a: #059669; --action-b: #0f766e; --action-soft: rgba(5, 150, 105, .18); }
-  display: grid;
+.quick-action--cyan { --action-a: #0891b2; --action-b: #0e7490; --action-soft: rgba(8, 145, 178, .18); }
-  gap: 3px;
+.quick-action--orange { --action-a: #f59e0b; --action-b: #dc6b12; --action-soft: rgba(245, 158, 11, .2); }
-  margin: 0;
+.quick-action--rose { --action-a: #e11d48; --action-b: #be185d; --action-soft: rgba(225, 29, 72, .17); }
-  padding: 0;
+.quick-action--teal { --action-a: #0f766e; --action-b: #0e7490; --action-soft: rgba(15, 118, 110, .18); }
-  list-style: none;
+.quick-action--brown { --action-a: #b45309; --action-b: #c2410c; --action-soft: rgba(180, 83, 9, .18); }
-}
+.quick-action:hover { border-color: color-mix(in srgb, var(--action-a) 35%, transparent); box-shadow: 0 24px 54px rgba(15, 23, 42, .14), 0 0 0 1px color-mix(in srgb, var(--action-a) 16%, transparent); transform: translateY(-9px); }
-
+.quick-action:hover::before { transform: scale(1.25); }
-.dashboard-load-error li {
+.quick-action:hover::after { right: 12%; left: 12%; opacity: 1; transform: scaleX(1); }
-  overflow-wrap: anywhere;
+.action-icon { position: relative; display: grid; width: 58px; height: 58px; flex: 0 0 auto; place-items: center; margin-bottom: 16px; border-radius: 18px; background: linear-gradient(135deg, var(--action-a), var(--action-b)); color: #fff; box-shadow: 0 11px 22px color-mix(in srgb, var(--action-a) 25%, transparent); transition: transform .35s ease; }
-  color: var(--muted);
+.action-icon::before { position: absolute; inset: 7px; border-radius: 12px; background: linear-gradient(135deg, rgba(255, 255, 255, .32), transparent 42%); content: ''; pointer-events: none; }
-  font-size: 12px;
+.action-icon::after { position: absolute; border: 1px solid color-mix(in srgb, var(--action-a) 20%, transparent); border-radius: 22px; content: ''; inset: -5px; }
-  line-height: 1.5;
+.quick-action:hover .action-icon { transform: translateY(-3px) scale(1.06) rotate(-3deg); }
-}
+.action-copy { position: relative; display: flex; min-width: 0; width: 100%; align-items: center; flex-direction: column; }
-
+.action-copy strong { color: #172033; font-size: 16px; font-weight: 800; line-height: 1.35; white-space: nowrap; }
-.dashboard-load-error li span {
+.action-copy small { overflow: hidden; width: 100%; margin-top: 6px; color: #718096; font-size: 11px; line-height: 1.5; text-overflow: ellipsis; white-space: nowrap; }
-  color: #9a5a09;
+.action-enter { position: relative; display: inline-flex; align-items: center; gap: 6px; margin-top: auto; color: var(--action-a); font-size: 11px; font-weight: 750; }
-  font-weight: 650;
+.action-enter svg { transition: transform .25s ease; }
-}
+.quick-action:hover .action-enter svg { transform: translateX(4px); }
-
+.quick-action--featured { border-color: rgba(49, 126, 255, .62); background: radial-gradient(circle at 8% 2%, rgba(34, 211, 238, .23), transparent 32%), radial-gradient(circle at 100% 100%, rgba(79, 70, 229, .22), transparent 44%), linear-gradient(145deg, #f2fbff 0%, #f8faff 45%, #eef2ff 100%); box-shadow: 0 20px 48px rgba(37, 99, 235, .2), 0 0 0 1px rgba(255, 255, 255, .88) inset, 0 0 34px rgba(34, 211, 238, .1); }
-.dashboard-layout {
+.quick-action--featured::before { width: 220px; height: 220px; right: -88px; top: -112px; background: radial-gradient(circle, rgba(34, 211, 238, .35) 0%, rgba(59, 130, 246, .2) 34%, transparent 69%); filter: blur(1px); animation: featured-aura 5s ease-in-out infinite; }
-  display: grid;
+.quick-action--featured::after { right: 8%; left: 8%; height: 4px; background: linear-gradient(90deg, #22d3ee 0%, #2563eb 48%, #4f46e5 100%); box-shadow: 0 -4px 16px rgba(37, 99, 235, .44), 0 -1px 6px rgba(34, 211, 238, .55); opacity: 1; transform: scaleX(1); }
-  grid-template-columns: minmax(0, 1fr) 286px;
+.quick-action--featured:hover { border-color: rgba(34, 211, 238, .8); box-shadow: 0 30px 70px rgba(37, 99, 235, .27), 0 0 0 1px rgba(255, 255, 255, .95) inset, 0 0 40px rgba(34, 211, 238, .15); transform: translateY(-11px) scale(1.015); }
-  gap: clamp(24px, 3vw, 42px);
+.quick-action--featured .action-icon { width: 64px; height: 64px; margin-bottom: 17px; border-radius: 20px; background: linear-gradient(145deg, #22c7df 0%, #2875ef 48%, #4338ca 100%); box-shadow: 0 16px 32px rgba(37, 99, 235, .37), 0 0 0 7px rgba(59, 130, 246, .09), 0 0 26px rgba(34, 211, 238, .24); }
-  align-items: start;
+.quick-action--featured .action-icon::after { inset: -6px; border-color: rgba(59, 130, 246, .25); border-radius: 25px; box-shadow: 0 0 0 1px rgba(34, 211, 238, .09); }
-}
+.quick-action--featured .action-copy strong { color: #15233e; font-size: 17px; }
-
+.quick-action--featured .action-enter { overflow: hidden; padding: 8px 15px; border-radius: 999px; background: linear-gradient(100deg, #12b8d0 0%, #2563eb 52%, #4338ca 100%); box-shadow: 0 10px 24px rgba(37, 99, 235, .3), 0 0 18px rgba(34, 211, 238, .12); color: #fff; }
-.dashboard-business {
+.quick-action--featured .action-enter::before { position: absolute; top: -60%; bottom: -60%; left: -55%; width: 38%; transform: rotate(18deg); background: linear-gradient(90deg, transparent, rgba(255, 255, 255, .55), transparent); content: ''; animation: featured-shine 3.6s ease-in-out infinite; }
-  min-width: 0;
+.quick-action--featured .action-enter > * { position: relative; z-index: 1; }
-  padding: 14px 0 24px;
+.no-actions { margin: 0; padding: 20px; border: 1px solid var(--border); border-radius: 10px; background: #fff; color: #667085; font-size: 14px; }
-}
+.dashboard-order-list { min-width: 0; }
-
+.orders-permission-empty { display: flex; min-height: 180px; align-items: center; justify-content: center; flex-direction: column; gap: 8px; border: 1px solid var(--border); border-radius: 10px; background: #fff; color: #7b8494; }
-.dashboard-intro {
+.orders-permission-empty strong { color: #475467; font-size: 15px; }
-  margin-bottom: 34px;
+.orders-permission-empty span { font-size: 12px; }
-}
+.client-dashboard a:focus-visible { border-radius: 6px; outline: 2px solid var(--primary); outline-offset: 4px; }
-
+@keyframes dashboard-enter { from { opacity: 0; transform: translateY(6px); } to { opacity: 1; transform: translateY(0); } }
-.dashboard-intro h2 {
+@keyframes action-enter { from { opacity: 0; transform: translateY(7px); } to { opacity: 1; transform: translateY(0); } }
-  max-width: 720px;
+@keyframes featured-aura { 0%, 100% { opacity: .86; transform: translate3d(0, 0, 0) scale(1); } 50% { opacity: 1; transform: translate3d(-10px, 9px, 0) scale(1.08); } }
-  margin: 0;
+@keyframes featured-shine { 0%, 55% { left: -55%; opacity: 0; } 65% { opacity: 1; } 88%, 100% { left: 125%; opacity: 0; } }
-  color: #111827;
+@container dashboard-content (max-width: 1180px) { .quick-actions { grid-template-columns: repeat(8, minmax(178px, 1fr)); } }
-  font-size: clamp(30px, 3.2vw, 46px);
+@media (max-width: 720px) { .client-dashboard { padding: 0; gap: 16px; } .business-intro h1 { font-size: 25px; } .quick-actions { grid-template-columns: repeat(2, minmax(150px, 1fr)); } }
-  line-height: 1.18;
+@media (max-width: 420px) { .quick-actions { grid-template-columns: repeat(8, minmax(168px, 1fr)); } }
-  letter-spacing: -.025em;
+@media (prefers-reduced-motion: reduce) { .client-dashboard, .quick-action, .quick-action--featured::before, .quick-action--featured .action-enter::before { animation: none; } .quick-action, .quick-action::before, .quick-action::after, .action-icon, .action-enter svg { transition: none; } }
-}
-
-.dashboard-intro p {
-  max-width: 720px;
-  margin: 16px 0 0;
-  color: #697586;
-  font-size: 15px;
-  line-height: 1.7;
-}
-
-.business-card-grid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 18px;
-}
-
-.business-card {
-  --card-accent: var(--dashboard-blue);
-  display: flex;
-  min-width: 0;
-  min-height: 286px;
-  flex-direction: column;
-  align-items: flex-start;
-  padding: 30px;
-  border: 0;
-  border-radius: 16px;
-  background: #fff;
-  box-shadow: 0 12px 36px rgba(23, 50, 77, .08);
-  color: #111827;
-  cursor: pointer;
-  text-align: left;
-  transition: transform .25s cubic-bezier(.16, 1, .3, 1), box-shadow .25s cubic-bezier(.16, 1, .3, 1);
-}
-
-.business-card--green { --card-accent: var(--dashboard-green); }
-.business-card--teal { --card-accent: var(--dashboard-teal); }
-
-.business-card:hover {
-  transform: translateY(-5px);
-  box-shadow: 0 20px 46px rgba(23, 50, 77, .14);
-}
-
-.business-card:focus-visible {
-  outline: 3px solid color-mix(in srgb, var(--card-accent) 36%, white);
-  outline-offset: 4px;
-}
-
-.business-card__icon {
-  display: grid;
-  width: 60px;
-  height: 60px;
-  place-items: center;
-  border-radius: 16px;
-  background: var(--card-accent);
-  box-shadow: 0 8px 18px color-mix(in srgb, var(--card-accent) 24%, transparent);
-  color: #fff;
-}
-
-.business-card__copy {
-  display: flex;
-  min-width: 0;
-  flex-direction: column;
-  gap: 10px;
-  margin-top: 34px;
-}
-
-.business-card__copy strong {
-  font-size: 22px;
-  line-height: 1.35;
-}
-
-.business-card__copy small {
-  color: #697586;
-  font-size: 14px;
-  line-height: 1.65;
-}
-
-.business-card__action {
-  display: inline-flex;
-  align-items: center;
-  gap: 8px;
-  margin-top: auto;
-  padding-top: 28px;
-  color: var(--card-accent);
-  font-size: 14px;
-  font-weight: 700;
-}
-
-.business-card__action svg {
-  transition: transform .2s cubic-bezier(.16, 1, .3, 1);
-}
-
-.business-card:hover .business-card__action svg {
-  transform: translateX(3px);
-}
-
-.dashboard-aside {
-  display: flex;
-  flex-direction: column;
-  gap: 14px;
-}
-
-.aside-card {
-  padding: 20px;
-  border: 1px solid #e9eef5;
-  border-radius: 14px;
-  background: #f8fafc;
-}
-
-.aside-card h3 {
-  margin: 0 0 18px;
-  color: #8b9bb2;
-  font-size: 12px;
-  font-weight: 750;
-  letter-spacing: .06em;
-}
-
-.account-summary {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  gap: 14px;
-}
-
-.account-avatar {
-  display: grid;
-  width: 52px;
-  height: 52px;
-  flex: 0 0 52px;
-  place-items: center;
-  border-radius: 14px;
-  background: linear-gradient(135deg, #1976d2, #00a993);
-  color: #fff;
-  font-size: 20px;
-  font-weight: 750;
-}
-
-.account-copy {
-  display: flex;
-  min-width: 0;
-  flex-direction: column;
-  gap: 5px;
-}
-
-.account-copy strong {
-  overflow: hidden;
-  color: #111827;
-  font-size: 15px;
-  line-height: 1.35;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.account-copy small {
-  color: #66758a;
-  font-size: 12px;
-}
-
-.account-load-error {
-  margin: 14px 0 0;
-  color: #8a5a22;
-  font-size: 12px;
-  line-height: 1.55;
-}
-
-.overview-stats {
-  margin: 0;
-}
-
-.overview-stats div {
-  display: flex;
-  min-height: 48px;
-  align-items: center;
-  justify-content: space-between;
-  gap: 16px;
-  border-bottom: 1px dashed #dfe6ef;
-}
-
-.overview-stats div:last-child {
-  border-bottom: 0;
-}
-
-.overview-stats dt {
-  color: #475569;
-  font-size: 13px;
-}
-
-.overview-stats dd {
-  margin: 0;
-  color: #111827;
-  font-size: 15px;
-  font-weight: 750;
-}
-
-.dashboard-section-error {
-  margin: 10px 0 0;
-  padding: 10px 0 0;
-  border-top: 1px solid #e9eef5;
-  color: #8a5a22;
-  font-size: 12px;
-  line-height: 1.55;
-}
-
-.support-links {
-  display: grid;
-  gap: 3px;
-}
-
-.support-links button {
-  display: flex;
-  width: 100%;
-  min-height: 44px;
-  align-items: center;
-  gap: 11px;
-  padding: 0 9px;
-  border: 0;
-  border-radius: 9px;
-  background: transparent;
-  color: #334155;
-  cursor: pointer;
-  font-size: 14px;
-  text-align: left;
-}
-
-.support-links button svg {
-  flex: 0 0 19px;
-  color: #00a993;
-}
-
-.support-links button:hover {
-  background: #edf2f7;
-  color: var(--dashboard-blue);
-}
-
-.support-links button:focus-visible {
-  outline: 2px solid var(--dashboard-blue);
-  outline-offset: 2px;
-}
-
-.dashboard-tip {
-  display: grid;
-  grid-template-columns: auto minmax(0, 1fr);
-  gap: 10px;
-  padding: 16px;
-  border: 1px solid rgba(0, 169, 147, .24);
-  border-radius: 14px;
-  background: #eef9f8;
-  color: #53657a;
-}
-
-.dashboard-tip svg {
-  margin-top: 2px;
-  color: #00a993;
-}
-
-.dashboard-tip p {
-  margin: 0;
-  font-size: 12px;
-  line-height: 1.75;
-}
-
-@media (max-width: 1180px) {
-  .dashboard-layout {
-    grid-template-columns: 1fr;
-  }
-
-  .dashboard-aside {
-    display: grid;
-    grid-template-columns: repeat(3, minmax(0, 1fr));
-    align-items: stretch;
-  }
-
-  .dashboard-tip {
-    grid-column: 1 / -1;
-  }
-}
-
-@media (max-width: 960px) {
-  .business-card-grid {
-    grid-template-columns: 1fr;
-  }
-
-  .business-card {
-    min-height: 232px;
-  }
-}
-
-@media (max-width: 720px) {
-  .client-dashboard {
-    min-height: calc(100vh - 118px);
-  }
-
-  .dashboard-business {
-    padding-top: 2px;
-  }
-
-  .dashboard-intro {
-    margin-bottom: 24px;
-  }
-
-  .dashboard-intro h2 {
-    font-size: 28px;
-  }
-
-  .dashboard-intro p {
-    margin-top: 12px;
-    font-size: 14px;
-  }
-
-  .business-card {
-    min-height: 220px;
-    padding: 24px;
-  }
-
-  .business-card__copy {
-    margin-top: 24px;
-  }
-
-  .dashboard-aside {
-    grid-template-columns: 1fr;
-  }
-
-  .dashboard-tip {
-    grid-column: auto;
-  }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .business-card,
-  .business-card__action svg {
-    transition: none;
-  }
-}
 </style>

src/modules/finance/api/account.ts

@@ -61,14 +61,12 @@ export interface AccountLedgerEntry {
   createdAt: string
 }
 
-export type RechargePaymentMethod = 'WECHAT' | 'ALIPAY'
 export type RechargeStatus = 'PENDING' | 'APPROVED' | 'REJECTED'
 
 export interface RechargeRequest {
   requestId: string
   requestNo: string
   amount: string
-  paymentMethod: RechargePaymentMethod
   voucherFileId: string
   voucherFileName: string
   status: RechargeStatus
@@ -80,13 +78,6 @@ export interface RechargeRequest {
   reviewedAt: string | null
 }
 
-export interface RechargeChannel {
-  paymentMethod: RechargePaymentMethod
-  displayName: string
-  enabled: boolean
-  qrCodeUrl: string | null
-}
-
 export function getFinanceAccount() {
   return apiRequest<FinanceAccount>({ method: 'GET', url: '/client/finance/v1/account' })
 }
@@ -109,15 +100,9 @@ export async function getRechargeRequests(page: number, size: number) {
   return normalizePageResult(result)
 }
 
-export function getRechargeChannels() {
+export function createRechargeRequest(amount: string, file: File, idempotencyKey: string) {
-  return apiRequest<RechargeChannel[]>({ method: 'GET', url: '/client/finance/v1/recharge-channels' })
-}
-
-export function createRechargeRequest(amount: string, paymentMethod: RechargePaymentMethod, file: File,
-                                      idempotencyKey: string) {
   const formData = new FormData()
   formData.append('amount', amount)
-  formData.append('paymentMethod', paymentMethod)
   formData.append('file', file, file.name)
   return apiRequest<RechargeRequest>({
     method: 'POST',

src/modules/finance/routes.ts

@@ -21,5 +21,10 @@ export const financeModule = {
       meta: { title: '客户账单', description: '查看本企业账单、收款记录和未收余额', permission: 'finance:bill:view' },
       navigation: { key: 'finance-bills', title: '客户账单', icon: ReceiptText },
     },
+    {
+      path: 'finance/bills/:billNo/detail', name: 'finance-bill-detail',
+      component: () => import('./views/FinanceBillDetailView.vue'), release: 'active',
+      meta: { title: '账单详情', workspaceTitle: '客户账单 · 详情', description: '查看费用明细、收款记录和客户确认信息', permission: 'finance:bill:view', keepAlive: false },
+    },
   ],
 } satisfies ClientModuleManifest

src/modules/finance/views/FinanceAccountView.test.mjs

@@ -8,13 +8,13 @@ const routesSource = readFileSync(new URL('../routes.ts', import.meta.url), 'utf
 const permissionsSource = readFileSync(new URL('../../tenant-management/contracts.ts', import.meta.url), 'utf8')
 
 test('uses only authenticated client finance account endpoints without customer scope', () => {
-  for (const path of ['/client/finance/v1/account', '/client/finance/v1/account/ledger', '/client/finance/v1/recharge-requests', '/client/finance/v1/recharge-channels']) {
+  for (const path of ['/client/finance/v1/account', '/client/finance/v1/account/ledger', '/client/finance/v1/recharge-requests']) {
     assert.match(apiSource, new RegExp(path.replaceAll('/', '\\/')))
   }
   assert.match(apiSource, /headers: \{ 'Idempotency-Key': idempotencyKey \}/)
   assert.match(apiSource, /formData\.append\('amount', amount\)/)
-  assert.match(apiSource, /formData\.append\('paymentMethod', paymentMethod\)/)
   assert.match(apiSource, /formData\.append\('file', file, file\.name\)/)
+  assert.doesNotMatch(apiSource, /RechargePaymentMethod|paymentMethod|WECHAT|ALIPAY/)
   assert.doesNotMatch(apiSource, /customerId|tenantId|mock|fallback/i)
 })
 
@@ -23,12 +23,14 @@ test('activates the account route and maps read and recharge permissions indepen
   assert.match(permissionsSource, /'merchant:finance:account:view': \['merchant:finance:account:view'\]/)
   assert.match(permissionsSource, /'merchant:finance:recharge:create': \['merchant:finance:recharge:create'\]/)
   assert.match(viewSource, /auth\.hasPermission\('merchant:finance:recharge:create'\)/)
-  assert.match(viewSource, /<el-button v-if="canRecharge"/)
+  assert.match(viewSource, /class="balance-title"[\s\S]*?<el-button v-if="canRecharge" size="small" type="primary"/)
+  assert.match(viewSource, /\.balance-summary \{[^}]*grid-template-columns: repeat\(6,/)
+  assert.doesNotMatch(viewSource, /class="account-actions"|class="balance-grid"/)
+  assert.doesNotMatch(viewSource, /class="account-heading"/)
 })
 
 test('renders server balances, ledger and recharge states without internal identifiers', () => {
   for (const field of ['actualBalance', 'frozenBalance', 'availableBalance', 'creditLimit', 'creditUsed', 'availableCredit']) assert.match(viewSource, new RegExp(`account\\?\\.${field}`))
-  for (const field of ['creditUsedAfter', 'availableCreditAfter']) assert.match(viewSource, new RegExp(`row\\.${field}`))
   assert.match(viewSource, /实际可用资金与可用授信合计/)
   assert.match(viewSource, /CREDIT_LIMIT: '授信调整'/)
   assert.match(viewSource, /row-key="businessNo"/)
@@ -39,9 +41,12 @@ test('renders server balances, ledger and recharge states without internal ident
   assert.match(viewSource, /v-loading="pageLoading"/)
   assert.match(viewSource, /function formatAccountAmount[\s\S]*value == null \? '—' : formatAmount\(value\)/)
   assert.match(viewSource, /formatAccountAmount\(account\?\.actualBalance\)/)
-  assert.match(viewSource, /:default-current-page="ledgerPage"/)
+  assert.match(viewSource, /<DataTable v-model:page="ledgerPage" v-model:page-size="ledgerPageSize"/)
-  assert.match(viewSource, /:default-current-page="rechargePage"/)
+  assert.match(viewSource, /<DataTable v-model:page="rechargePage" v-model:page-size="rechargePageSize"/)
-  assert.doesNotMatch(viewSource, /<el-pagination (?:v-model:current-page|:current-page)=/)
+  assert.match(viewSource, /const ledgerColumns: DataTableColumn\[]/)
+  assert.match(viewSource, /const rechargeColumns: DataTableColumn\[]/)
+  assert.doesNotMatch(viewSource, /label: '已用授信'|label: '可用授信'/)
+  assert.doesNotMatch(viewSource, /<el-table|<el-pagination/)
   assert.match(apiSource, /function normalizePageResult<[\s\S]*total: Number\(result\.total\)/)
   assert.match(apiSource, /page: Number\(result\.page\)/)
   assert.doesNotMatch(viewSource, /requestId|ledgerId|customerId|tenantId/)
@@ -49,13 +54,16 @@ test('renders server balances, ledger and recharge states without internal ident
 
 test('matches the frozen recharge workflow and preserves an idempotency key for failed retries', () => {
   assert.match(viewSource, /title="账户充值" width="760px"/)
-  for (const amount of ['50.00', '100.00', '200.00', '500.00']) assert.match(viewSource, new RegExp(amount.replace('.', '\\.')))
+  for (const amount of ['1000', '5000', '20000', '50000']) assert.match(viewSource, new RegExp(amount))
-  assert.match(viewSource, /\['WECHAT', 'ALIPAY'\]/)
+  assert.match(viewSource, /自定义/)
-  assert.match(viewSource, /selectedChannel\.value\?\.enabled && selectedChannel\.value\.qrCodeUrl/)
+  assert.match(viewSource, /src="\/customer-recharge-qr\.png"/)
+  assert.match(viewSource, /alt="平台收款二维码"/)
+  assert.match(viewSource, /请扫描平台收款二维码，付款后上传截图。/)
   assert.match(viewSource, /accept="\.jpg,\.jpeg,\.png,image\/jpeg,image\/png"/)
   assert.match(viewSource, /if \(!pendingIdempotencyKey\)[\s\S]*globalThis\.crypto\?\.randomUUID\?\.\(\)/)
   assert.match(viewSource, /pendingIdempotencyKey = ''[\s\S]*rechargeVisible\.value = false/)
   assert.match(viewSource, /:disabled="!canSubmit"/)
   assert.match(viewSource, /await loadAccountData\(\)/)
   assert.doesNotMatch(viewSource, /payment SDK|支付成功|模拟成功/)
+  assert.doesNotMatch(viewSource, /微信支付|支付宝|payment-methods|paymentMethod/)
 })

src/modules/finance/views/FinanceAccountView.vue

@@ -3,18 +3,16 @@ import { computed, onMounted, reactive, ref, watch } from 'vue'
 import { CircleDollarSign, RefreshCcw, Upload } from '@lucide/vue'
 import { ElMessage, type UploadFile, type UploadFiles, type UploadInstance } from 'element-plus'
 import { ApiError } from '@/api/http'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
 import { useAuthStore } from '@/modules/auth/public'
 import {
   createRechargeRequest,
   getAccountLedger,
   getFinanceAccount,
-  getRechargeChannels,
   getRechargeRequests,
   type AccountChangeType,
   type AccountLedgerEntry,
   type FinanceAccount,
-  type RechargeChannel,
-  type RechargePaymentMethod,
   type RechargeRequest,
   type RechargeStatus,
 } from '../api/account'
@@ -23,15 +21,15 @@ const auth = useAuthStore()
 const account = ref<FinanceAccount | null>(null)
 const ledger = ref<AccountLedgerEntry[]>([])
 const rechargeRequests = ref<RechargeRequest[]>([])
-const channels = ref<RechargeChannel[]>([])
 const pageLoading = ref(false)
 const pageError = ref('')
-const channelsError = ref('')
+const qrCodeLoadError = ref(false)
 const ledgerPage = ref(1)
 const ledgerTotal = ref(0)
+const ledgerPageSize = ref(10)
 const rechargePage = ref(1)
 const rechargeTotal = ref(0)
-const pageSize = 10
+const rechargePageSize = ref(10)
 const rechargeVisible = ref(false)
 const submitting = ref(false)
 const submitError = ref('')
@@ -39,11 +37,11 @@ const voucherFile = ref<File | null>(null)
 const voucherUpload = ref<UploadInstance>()
 let pendingIdempotencyKey = ''
 
-const form = reactive({ amount: '100.00', paymentMethod: 'WECHAT' as RechargePaymentMethod })
+const form = reactive({ amount: '1000' })
-const quickAmounts = ['50.00', '100.00', '200.00', '500.00']
+const quickAmounts = ['1000', '5000', '20000', '50000']
+const amountMode = ref<'preset' | 'custom'>('preset')
 const canRecharge = computed(() => auth.hasPermission('merchant:finance:recharge:create'))
-const selectedChannel = computed(() => channels.value.find((item) => item.paymentMethod === form.paymentMethod))
+const channelReady = computed(() => !qrCodeLoadError.value)
-const channelReady = computed(() => Boolean(selectedChannel.value?.enabled && selectedChannel.value.qrCodeUrl))
 const amountValid = computed(() => {
   const value = Number(form.amount)
   return Number.isFinite(value) && value > 0 && /^\d+(?:\.\d{1,2})?$/.test(form.amount.trim())
@@ -54,7 +52,27 @@ const changeLabels: Record<AccountChangeType, string> = {
   RECHARGE: '充值', DEDUCTION: '扣款', FREEZE: '冻结', UNFREEZE: '解冻', CONSUMPTION: '消费', CREDIT_LIMIT: '授信调整',
 }
 const statusLabels: Record<RechargeStatus, string> = { PENDING: '待审核', APPROVED: '已通过', REJECTED: '已驳回' }
-const methodLabels: Record<RechargePaymentMethod, string> = { WECHAT: '微信支付', ALIPAY: '支付宝' }
+const ledgerColumns: DataTableColumn[] = [
+  { label: '业务单号', prop: 'businessNo', minWidth: 180 },
+  { label: '变动类型', slotName: 'changeType', width: 100 },
+  { label: '变动金额', slotName: 'amount', width: 120, align: 'right' },
+  { label: '实际余额', slotName: 'actualBalance', width: 120, align: 'right' },
+  { label: '冻结金额', slotName: 'frozenBalance', width: 120, align: 'right' },
+  { label: '可用余额', slotName: 'availableBalance', width: 120, align: 'right' },
+  { label: '操作人', slotName: 'operatorName', width: 120 },
+  { label: '备注', slotName: 'remark', minWidth: 180 },
+  { label: '发生时间', slotName: 'createdAt', width: 160 },
+]
+const rechargeColumns: DataTableColumn[] = [
+  { label: '充值申请单号', prop: 'requestNo', minWidth: 180 },
+  { label: '金额', slotName: 'amount', width: 120, align: 'right' },
+  { label: '付款截图', prop: 'voucherFileName', minWidth: 150 },
+  { label: '状态', slotName: 'status', width: 100 },
+  { label: '提交人', slotName: 'submittedByName', width: 120 },
+  { label: '审核备注', slotName: 'reviewRemark', minWidth: 180 },
+  { label: '提交时间', slotName: 'createdAt', width: 160 },
+  { label: '审核时间', slotName: 'reviewedAt', width: 160 },
+]
 
 function messageOf(error: unknown, fallback: string) {
   return error instanceof ApiError ? error.message : fallback
@@ -86,8 +104,8 @@ function amountClass(amount: string) {
 async function loadAccountData() {
   pageLoading.value = true
   pageError.value = ''
-  channelsError.value = ''
+  qrCodeLoadError.value = false
-  const requests = [getFinanceAccount(), getAccountLedger(ledgerPage.value, pageSize), getRechargeRequests(rechargePage.value, pageSize)] as const
+  const requests = [getFinanceAccount(), getAccountLedger(ledgerPage.value, ledgerPageSize.value), getRechargeRequests(rechargePage.value, rechargePageSize.value)] as const
   try {
     const [accountResult, ledgerResult, rechargeResult] = await Promise.all(requests)
     account.value = accountResult
@@ -105,20 +123,11 @@ async function loadAccountData() {
   } finally {
     pageLoading.value = false
   }
-  if (canRecharge.value) {
-    try {
-      channels.value = await getRechargeChannels()
-    } catch (error) {
-      channels.value = []
-      channelsError.value = messageOf(error, '充值渠道加载失败，请稍后重试')
-    }
-  }
 }
 
 async function changeLedgerPage(nextPage: number) {
-  ledgerPage.value = nextPage
   try {
-    const result = await getAccountLedger(nextPage, pageSize)
+    const result = await getAccountLedger(nextPage, ledgerPageSize.value)
     ledger.value = result.records
     ledgerTotal.value = result.total
   } catch (error) {
@@ -127,9 +136,8 @@ async function changeLedgerPage(nextPage: number) {
 }
 
 async function changeRechargePage(nextPage: number) {
-  rechargePage.value = nextPage
   try {
-    const result = await getRechargeRequests(nextPage, pageSize)
+    const result = await getRechargeRequests(nextPage, rechargePageSize.value)
     rechargeRequests.value = result.records
     rechargeTotal.value = result.total
   } catch (error) {
@@ -139,13 +147,26 @@ async function changeRechargePage(nextPage: number) {
 
 function openRecharge() {
   submitError.value = ''
+  qrCodeLoadError.value = false
+  amountMode.value = 'preset'
+  form.amount = '1000'
   rechargeVisible.value = true
 }
 
+function handleQrCodeError() {
+  qrCodeLoadError.value = true
+}
+
 function chooseAmount(amount: string) {
+  amountMode.value = 'preset'
   form.amount = amount
 }
 
+function chooseCustomAmount() {
+  amountMode.value = 'custom'
+  if (quickAmounts.includes(form.amount)) form.amount = ''
+}
+
 function handleVoucherChange(uploadFile: UploadFile, _uploadFiles: UploadFiles) {
   const file = uploadFile.raw
   if (!file) return
@@ -175,7 +196,7 @@ async function submitRecharge() {
     return
   }
   if (!channelReady.value) {
-    submitError.value = `${methodLabels[form.paymentMethod]}收款二维码尚未配置，暂不能提交充值申请`
+    submitError.value = '收款二维码尚未配置，暂不能提交充值申请'
     return
   }
   if (!voucherFile.value) {
@@ -187,7 +208,7 @@ async function submitRecharge() {
   }
   submitting.value = true
   try {
-    await createRechargeRequest(normalizedAmount(), form.paymentMethod, voucherFile.value, pendingIdempotencyKey)
+    await createRechargeRequest(normalizedAmount(), voucherFile.value, pendingIdempotencyKey)
     pendingIdempotencyKey = ''
     rechargeVisible.value = false
     voucherFile.value = null
@@ -201,28 +222,26 @@ async function submitRecharge() {
   }
 }
 
-watch([() => form.amount, () => form.paymentMethod, voucherFile], () => {
+watch([() => form.amount, voucherFile], () => {
   if (!submitting.value) pendingIdempotencyKey = ''
   submitError.value = ''
 })
 
+watch([ledgerPage, ledgerPageSize], () => { void changeLedgerPage(ledgerPage.value) })
+watch([rechargePage, rechargePageSize], () => { void changeRechargePage(rechargePage.value) })
+
 onMounted(() => { void loadAccountData() })
 </script>
 
 <template>
   <div v-loading="pageLoading" class="finance-account-page" :aria-busy="pageLoading">
-    <div class="account-heading">
-      <div><h2>资金账户</h2><p>查看本企业 CNY 资金、授信额度、账户流水和充值申请状态。</p></div>
-      <el-button v-if="canRecharge" type="primary" @click="openRecharge"><CircleDollarSign :size="17" />账户充值</el-button>
-    </div>
-
     <div v-if="pageError" class="account-state account-state--error" role="alert">
       <p>{{ pageError }}</p><el-button @click="loadAccountData"><RefreshCcw :size="15" />重新加载</el-button>
     </div>
 
     <template v-else>
-      <section class="balance-grid" aria-label="账户余额">
+      <section class="balance-summary" aria-label="账户余额">
-        <article><span>实际余额</span><strong>¥ {{ formatAccountAmount(account?.actualBalance) }}</strong><small>当前账户实际资金</small></article>
+        <article><div class="balance-title"><span>实际余额</span><el-button v-if="canRecharge" size="small" type="primary" @click="openRecharge"><CircleDollarSign :size="15" />账户充值</el-button></div><strong>¥ {{ formatAccountAmount(account?.actualBalance) }}</strong><small>当前账户实际资金</small></article>
         <article><span>冻结金额</span><strong>¥ {{ formatAccountAmount(account?.frozenBalance) }}</strong><small>暂不可使用的资金</small></article>
         <article class="balance-available"><span>总可用余额</span><strong>¥ {{ formatAccountAmount(account?.availableBalance) }}</strong><small>实际可用资金与可用授信合计</small></article>
         <article><span>授信额度</span><strong>¥ {{ formatAccountAmount(account?.creditLimit) }}</strong><small>{{ account?.creditExpiresOn ? `${account.creditExpiresOn} ${account.creditActive ? '到期' : '已到期'}` : '未设置有效期' }}</small></article>
@@ -232,57 +251,46 @@ onMounted(() => { void loadAccountData() })
 
       <section class="account-card">
         <div class="section-heading"><div><h3>账户流水</h3><p>每次资金变动均生成唯一业务单号。</p></div></div>
-        <el-table :data="ledger" row-key="businessNo" empty-text="暂无资金流水">
+        <DataTable v-model:page="ledgerPage" v-model:page-size="ledgerPageSize" :data="ledger" :columns="ledgerColumns" :total="ledgerTotal" :page-sizes="[10, 20, 50]" row-key="businessNo" empty-text="暂无资金流水">
-          <el-table-column prop="businessNo" label="业务单号" min-width="190" />
+          <template #changeType="{ row }">{{ changeLabels[row.changeType as AccountChangeType] }}</template>
-          <el-table-column label="变动类型" width="110"><template #default="{ row }">{{ changeLabels[row.changeType as AccountChangeType] }}</template></el-table-column>
+          <template #amount="{ row }"><strong :class="amountClass(row.amount)">{{ Number(row.amount) >= 0 ? '+' : '' }}¥ {{ formatAmount(row.amount) }}</strong></template>
-          <el-table-column label="变动金额" width="145" align="right"><template #default="{ row }"><strong :class="amountClass(row.amount)">{{ Number(row.amount) >= 0 ? '+' : '' }}¥ {{ formatAmount(row.amount) }}</strong></template></el-table-column>
+          <template #actualBalance="{ row }">¥ {{ formatAmount(row.actualBalanceAfter) }}</template>
-          <el-table-column label="实际余额" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.actualBalanceAfter) }}</template></el-table-column>
+          <template #frozenBalance="{ row }">¥ {{ formatAmount(row.frozenBalanceAfter) }}</template>
-          <el-table-column label="冻结金额" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.frozenBalanceAfter) }}</template></el-table-column>
+          <template #availableBalance="{ row }">¥ {{ formatAmount(row.availableBalanceAfter) }}</template>
-          <el-table-column label="可用余额" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.availableBalanceAfter) }}</template></el-table-column>
+          <template #operatorName="{ row }">{{ row.operatorName || '—' }}</template>
-          <el-table-column label="已用授信" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.creditUsedAfter) }}</template></el-table-column>
+          <template #remark="{ row }">{{ row.remark || '—' }}</template>
-          <el-table-column label="可用授信" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.availableCreditAfter) }}</template></el-table-column>
+          <template #createdAt="{ row }">{{ formatDateTime(row.createdAt) }}</template>
-          <el-table-column prop="operatorName" label="操作人" min-width="130"><template #default="{ row }">{{ row.operatorName || '—' }}</template></el-table-column>
+        </DataTable>
-          <el-table-column prop="remark" label="备注" min-width="180"><template #default="{ row }">{{ row.remark || '—' }}</template></el-table-column>
-          <el-table-column label="发生时间" width="170"><template #default="{ row }">{{ formatDateTime(row.createdAt) }}</template></el-table-column>
-        </el-table>
-        <div v-if="ledgerTotal" class="pagination-row"><span>共 {{ ledgerTotal }} 条</span><el-pagination :default-current-page="ledgerPage" :page-size="pageSize" layout="prev, pager, next" :total="ledgerTotal" @current-change="changeLedgerPage" /></div>
       </section>
 
       <section class="account-card">
         <div class="section-heading"><div><h3>充值申请</h3><p>付款后上传截图，平台审核通过后资金入账。</p></div></div>
-        <el-table :data="rechargeRequests" row-key="requestNo" empty-text="暂无充值申请">
+        <DataTable v-model:page="rechargePage" v-model:page-size="rechargePageSize" :data="rechargeRequests" :columns="rechargeColumns" :total="rechargeTotal" :page-sizes="[10, 20, 50]" row-key="requestNo" empty-text="暂无充值申请">
-          <el-table-column prop="requestNo" label="充值申请单号" min-width="190" />
+          <template #amount="{ row }">¥ {{ formatAmount(row.amount) }}</template>
-          <el-table-column label="金额" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.amount) }}</template></el-table-column>
+          <template #status="{ row }"><el-tag :type="statusType(row.status as RechargeStatus)">{{ statusLabels[row.status as RechargeStatus] }}</el-tag></template>
-          <el-table-column label="付款方式" width="120"><template #default="{ row }">{{ methodLabels[row.paymentMethod as RechargePaymentMethod] }}</template></el-table-column>
+          <template #submittedByName="{ row }">{{ row.submittedByName || '—' }}</template>
-          <el-table-column prop="voucherFileName" label="付款截图" min-width="170" />
+          <template #reviewRemark="{ row }">{{ row.reviewRemark || '—' }}</template>
-          <el-table-column label="状态" width="110"><template #default="{ row }"><el-tag :type="statusType(row.status as RechargeStatus)">{{ statusLabels[row.status as RechargeStatus] }}</el-tag></template></el-table-column>
+          <template #createdAt="{ row }">{{ formatDateTime(row.createdAt) }}</template>
-          <el-table-column prop="submittedByName" label="提交人" min-width="120"><template #default="{ row }">{{ row.submittedByName || '—' }}</template></el-table-column>
+          <template #reviewedAt="{ row }">{{ formatDateTime(row.reviewedAt) }}</template>
-          <el-table-column prop="reviewRemark" label="审核备注" min-width="180"><template #default="{ row }">{{ row.reviewRemark || '—' }}</template></el-table-column>
+        </DataTable>
-          <el-table-column label="提交时间" width="170"><template #default="{ row }">{{ formatDateTime(row.createdAt) }}</template></el-table-column>
-          <el-table-column label="审核时间" width="170"><template #default="{ row }">{{ formatDateTime(row.reviewedAt) }}</template></el-table-column>
-        </el-table>
-        <div v-if="rechargeTotal" class="pagination-row"><span>共 {{ rechargeTotal }} 条</span><el-pagination :default-current-page="rechargePage" :page-size="pageSize" layout="prev, pager, next" :total="rechargeTotal" @current-change="changeRechargePage" /></div>
       </section>
     </template>
 
     <el-dialog v-model="rechargeVisible" title="账户充值" width="760px" :close-on-click-modal="false" :close-on-press-escape="!submitting" :show-close="!submitting" class="recharge-dialog">
       <div class="recharge-form">
         <label class="field-label" for="recharge-amount">充值金额</label>
-        <el-input id="recharge-amount" v-model="form.amount" size="large" inputmode="decimal" placeholder="请输入充值金额" aria-label="充值金额"><template #prefix>¥</template></el-input>
+        <el-input v-if="amountMode === 'custom'" id="recharge-amount" v-model="form.amount" size="large" inputmode="decimal" placeholder="请输入充值金额" aria-label="充值金额"><template #prefix>¥</template></el-input>
         <div class="quick-amounts" aria-label="快捷充值金额">
-          <button v-for="amount in quickAmounts" :key="amount" type="button" :class="{ active: form.amount === amount }" @click="chooseAmount(amount)">¥{{ Number(amount) }}</button>
+          <button v-for="amount in quickAmounts" :key="amount" type="button" :class="{ active: amountMode === 'preset' && form.amount === amount }" @click="chooseAmount(amount)">¥{{ Number(amount).toLocaleString() }}</button>
+          <button type="button" :class="{ active: amountMode === 'custom' }" @click="chooseCustomAmount">自定义</button>
         </div>
 
-        <div class="payment-methods" aria-label="付款方式">
+        <div v-if="channelReady" class="qr-panel">
-          <button v-for="method in (['WECHAT', 'ALIPAY'] as RechargePaymentMethod[])" :key="method" type="button" :class="[`payment-${method.toLowerCase()}`, { active: form.paymentMethod === method }]" @click="form.paymentMethod = method"><span>{{ method === 'WECHAT' ? '微' : '支' }}</span>{{ methodLabels[method] }}</button>
+          <img src="/customer-recharge-qr.png" alt="平台收款二维码" @error="handleQrCodeError">
+          <div><strong>扫码付款</strong><p>请扫描平台收款二维码，付款后上传截图。</p></div>
         </div>
-
+        <div v-else-if="qrCodeLoadError" class="channel-warning" role="alert">平台收款二维码资源不可用，请联系管理员更新二维码</div>
-        <div v-if="channelsError" class="channel-warning" role="alert">{{ channelsError }}</div>
+        <div v-else class="channel-warning" role="status">收款二维码尚未配置，暂不能提交充值申请。</div>
-        <div v-else-if="channelReady" class="qr-panel">
-          <img :src="selectedChannel?.qrCodeUrl || ''" :alt="`${methodLabels[form.paymentMethod]}收款二维码`">
-          <p>请使用{{ methodLabels[form.paymentMethod] }}扫码完成付款</p>
-        </div>
-        <div v-else class="channel-warning" role="status">{{ methodLabels[form.paymentMethod] }}收款二维码尚未配置，暂不能提交充值申请。</div>
 
         <div class="voucher-upload">
           <span class="field-label">付款截图</span>
@@ -300,18 +308,21 @@ onMounted(() => { void loadAccountData() })
 
 <style scoped>
 .finance-account-page { display: flex; min-height: 420px; flex-direction: column; gap: 16px; }
-.account-heading, .section-heading, .pagination-row { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
+.section-heading { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
-.account-heading h2, .section-heading h3 { margin: 0; color: var(--navy); }.account-heading h2 { font-size: 22px; }.section-heading h3 { font-size: 16px; }
+.section-heading h3 { margin: 0; color: var(--navy); font-size: 16px; }
-.account-heading p, .section-heading p { margin: 5px 0 0; color: var(--muted); font-size: 13px; }.account-heading .el-button { display: inline-flex; align-items: center; gap: 6px; }
+.section-heading p { margin: 5px 0 0; color: var(--muted); font-size: 13px; }
-.balance-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 16px; }
+.balance-summary { display: grid; overflow: hidden; grid-template-columns: repeat(6, minmax(0, 1fr)); border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }
-.balance-grid article { display: flex; min-height: 132px; flex-direction: column; padding: 22px 24px; border: 1px solid var(--border); border-radius: 10px; background: #fff; }
+.balance-summary article { display: flex; min-width: 0; min-height: 104px; flex-direction: column; padding: 14px 16px; border-right: 1px solid var(--client-border); }
-.balance-grid span { color: var(--muted); font-size: 13px; }.balance-grid strong { margin-top: 14px; color: var(--navy); font-size: 28px; line-height: 1; }.balance-grid small { margin-top: auto; color: #8a98a8; }.balance-grid .balance-available { border-color: #b9e1db; background: #f3faf8; }.balance-grid .balance-available strong { color: #058b78; }
+.balance-summary article:last-child { border-right: 0; }
-.account-card { min-width: 0; padding: 18px; border: 1px solid var(--border); border-radius: 8px; background: #fff; }.section-heading { margin-bottom: 14px; }
+.balance-summary span { color: var(--muted); font-size: 12px; }.balance-summary strong { margin-top: 10px; overflow: hidden; color: var(--navy); font-size: 22px; line-height: 1.1; text-overflow: ellipsis; white-space: nowrap; }.balance-summary small { margin-top: auto; overflow: hidden; color: #8a98a8; font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
-.pagination-row { padding-top: 14px; color: var(--muted); font-size: 12px; }.amount-positive { color: #078a72; }.amount-negative { color: #b42318; }
+.balance-title { display: flex; min-height: 28px; align-items: center; justify-content: space-between; gap: 8px; }.balance-title .el-button { flex: 0 0 auto; height: 28px; padding: 0 9px; }.balance-title .el-button :deep(span) { display: inline-flex; align-items: center; gap: 4px; color: inherit; }
+.balance-summary .balance-available { background: #f3faf8; }.balance-summary .balance-available strong { color: #058b78; }
+.account-card { min-width: 0; overflow: hidden; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }.section-heading { padding: 14px 16px; border-bottom: 1px solid var(--client-border); }
+.amount-positive { color: #078a72; }.amount-negative { color: #b42318; }
 .account-state { display: flex; min-height: 240px; align-items: center; justify-content: center; flex-direction: column; gap: 12px; border-radius: 8px; }.account-state--error { border: 1px solid #f5c2bd; background: #fff8f7; color: #b42318; }.account-state p { margin: 0; }
 .recharge-form { display: flex; flex-direction: column; gap: 16px; }.field-label { color: #4e6075; font-size: 14px; font-weight: 650; }
-.quick-amounts, .payment-methods { display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; }.quick-amounts button, .payment-methods button { min-height: 54px; border: 1px solid #dbe3ed; border-radius: 10px; background: #f8fafc; color: #506077; cursor: pointer; font: inherit; }.quick-amounts button.active, .payment-methods button.active { border: 2px solid #1671c9; background: #eef8f7; color: #1467b8; font-weight: 700; }
+.quick-amounts { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 12px; }.quick-amounts button { min-height: 54px; border: 1px solid #dbe3ed; border-radius: 10px; background: #f8fafc; color: #506077; cursor: pointer; font: inherit; }.quick-amounts button.active { border: 2px solid #1671c9; background: #eef8f7; color: #1467b8; font-weight: 700; }
-.payment-methods { grid-template-columns: repeat(2, 1fr); }.payment-methods button { display: flex; align-items: center; justify-content: center; gap: 10px; font-size: 17px; font-weight: 650; }.payment-methods span { display: grid; width: 26px; height: 26px; place-items: center; border-radius: 7px; background: #1685ef; color: #fff; font-size: 14px; }.payment-wechat span { background: #09ae42; }
+.qr-panel { display: grid; grid-template-columns: 210px minmax(0, 1fr); align-items: center; gap: 24px; padding: 20px; border: 1px solid #dbe3ed; border-radius: 12px; background: #f8fafc; }.qr-panel img { width: 210px; height: 210px; border: 1px solid #dae3ed; border-radius: 10px; background: #fff; object-fit: contain; }.qr-panel strong { color: var(--navy); font-size: 17px; }.qr-panel p { margin: 8px 0 0; color: #62758d; }
-.qr-panel { display: flex; align-items: center; flex-direction: column; gap: 14px; padding: 22px; border: 1px dashed #bed0e4; border-radius: 12px; background: #f8fafc; }.qr-panel img { width: 210px; height: 210px; border: 1px solid #dae3ed; border-radius: 10px; background: #fff; object-fit: contain; }.qr-panel p { margin: 0; color: #62758d; }
 .channel-warning { padding: 24px; border: 1px solid #f0d39b; border-radius: 10px; background: #fff9ed; color: #8b5b12; text-align: center; }.voucher-upload { display: grid; gap: 10px; }.voucher-upload :deep(.el-button) { display: inline-flex; align-items: center; gap: 6px; }.submit-error { margin: 0; color: #b42318; font-size: 13px; }.dialog-actions { display: grid; grid-template-columns: repeat(2, 1fr); gap: 16px; }.dialog-actions .el-button { min-height: 46px; margin: 0; }
+@media (max-width: 1200px) { .balance-summary { grid-template-columns: repeat(3, minmax(0, 1fr)); }.balance-summary article { border-bottom: 1px solid var(--client-border); }.balance-summary article:nth-child(3n) { border-right: 0; }.balance-summary article:nth-last-child(-n + 3) { border-bottom: 0; } }
 </style>

src/modules/finance/views/FinanceBillDetailView.vue

@@ -0,0 +1,85 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { ArrowLeft } from '@lucide/vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import { ApiError } from '@/api/http'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
+import { useAuthStore } from '@/modules/auth/public'
+import { InboundCodeAssociationDialog } from '@/modules/first-leg/public'
+import { confirmMerchantFinanceStatement, getMerchantFinanceBill, getMerchantFinanceBills, getMerchantFinanceReceipts } from '../api/finance'
+import type { FinanceBillDetail, FinanceBillSummary, FinanceBillStatus, FinanceCustomerConfirmationStatus } from '../contracts'
+
+const route = useRoute()
+const router = useRouter()
+const auth = useAuthStore()
+const billNo = computed(() => String(route.params.billNo || ''))
+const loading = ref(false)
+const errorMessage = ref('')
+const detail = ref<FinanceBillDetail | null>(null)
+const confirming = ref(false)
+const inboundAssociationVisible = ref(false)
+const inboundAssociationCode = ref('')
+const canConfirm = computed(() => auth.hasPermission('finance:bill:confirm'))
+const lineColumns: DataTableColumn[] = [
+  { key: 'inboundCode', label: '入仓码', slotName: 'inboundCode', minWidth: 180 },
+  { prop: 'feeName', label: '费用项目', minWidth: 220 },
+  { key: 'amount', label: '金额', slotName: 'amount', width: 150, align: 'right', headerAlign: 'right' },
+]
+const receiptColumns: DataTableColumn[] = [
+  { key: 'receivedAt', label: '收款日期', slotName: 'receivedAt', width: 130 },
+  { prop: 'receiptNo', label: '收款编号', minWidth: 180 },
+  { key: 'allocatedAmount', label: '本次金额', slotName: 'allocatedAmount', width: 150, align: 'right', headerAlign: 'right' },
+  { key: 'method', label: '方式', slotName: 'method', minWidth: 120 },
+]
+
+function formatAmount(value?: string | null) { const number = Number(value); return Number.isFinite(number) ? number.toLocaleString('zh-CN', { minimumFractionDigits: 2, maximumFractionDigits: 2 }) : value || '0.00' }
+function formatDate(value?: string | null) { return value ? value.slice(0, 10) : '—' }
+function formatDateTime(value?: string | null) { return value ? value.replace('T', ' ').replace(/Z$/, '').slice(0, 16) : '—' }
+function statusLabel(status: FinanceBillStatus) { return ({ DRAFT: '草稿', ISSUED: '已出账', PARTIALLY_PAID: '部分收款', PAID: '已收清', VOIDED: '作废' } as Record<string, string>)[status] || status }
+function statusType(status: FinanceBillStatus) { return ({ ISSUED: 'info', PARTIALLY_PAID: 'warning', PAID: 'success', VOIDED: 'danger', DRAFT: 'info' } as const)[status] }
+function confirmationLabel(status: FinanceCustomerConfirmationStatus) { return ({ NOT_REQUIRED: '无需确认', PENDING_CONFIRMATION: '待确认', CONFIRMED: '已确认' })[status] }
+function paymentMethodLabel(method?: string | null) { return ({ BANK_TRANSFER: '银行转账', CASH: '现金', OTHER: '其他' } as Record<string, string>)[method || ''] || '其他' }
+function messageOf(error: unknown) { return error instanceof ApiError ? error.message : '账单详情加载失败，请稍后重试' }
+
+async function load() {
+  if (!billNo.value) return
+  loading.value = true
+  errorMessage.value = ''
+  try {
+    const result = await getMerchantFinanceBills({ keyword: billNo.value, page: 1, size: 100 })
+    const summary = result.records.find(item => item.billNo === billNo.value)
+    if (!summary) throw new Error('未找到该账单')
+    const [bill, receipts] = await Promise.all([getMerchantFinanceBill(summary.id), getMerchantFinanceReceipts(summary.id)])
+    detail.value = { ...bill, receipts }
+  } catch (error) { detail.value = null; errorMessage.value = error instanceof Error ? error.message : messageOf(error) }
+  finally { loading.value = false }
+}
+async function confirmStatement(statement: FinanceBillSummary) {
+  if (!canConfirm.value || statement.customerConfirmationStatus !== 'PENDING_CONFIRMATION' || confirming.value) return
+  try { await ElMessageBox.confirm(`确认账单 ${statement.billNo}（¥ ${formatAmount(statement.totalAmount)}）金额与费用明细无误？`, '确认客户账单', { type: 'warning', confirmButtonText: '确认无误', cancelButtonText: '取消' }) } catch { return }
+  confirming.value = true
+  try { await confirmMerchantFinanceStatement(statement.id, statement.version); ElMessage.success('账单已确认'); await load() }
+  catch (error) { ElMessage.error(messageOf(error)) }
+  finally { confirming.value = false }
+}
+function openInboundAssociation(value?: string | null) { if (!value) return; inboundAssociationCode.value = value; inboundAssociationVisible.value = true }
+</script>
+
+<template>
+  <article v-loading="loading" class="bill-detail-surface">
+    <template v-if="detail">
+      <header class="bill-detail-header"><button type="button" class="bill-detail-back" @click="router.push({ name: 'finance-bills' })"><ArrowLeft :size="16" />返回列表</button><div class="bill-detail-title"><strong>{{ detail.billNo }}</strong><span>出账 {{ formatDate(detail.issueDate) }} · 到期 {{ formatDate(detail.dueDate) }}</span></div><div class="bill-detail-actions"><el-tag :type="statusType(detail.status)" effect="light">{{ statusLabel(detail.status) }}</el-tag><el-tag effect="light">{{ confirmationLabel(detail.customerConfirmationStatus) }}</el-tag><el-button v-if="detail.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm" type="primary" :loading="confirming" @click="confirmStatement(detail)">确认账单</el-button></div></header>
+      <section class="bill-detail-section"><h3>账单概览</h3><dl class="bill-detail-grid"><div><dt>账单金额</dt><dd>¥ {{ formatAmount(detail.totalAmount) }}</dd></div><div><dt>已收金额</dt><dd>¥ {{ formatAmount(detail.receivedAmount) }}</dd></div><div><dt>未收余额</dt><dd class="amount-warning">¥ {{ formatAmount(detail.outstandingAmount) }}</dd></div><div><dt>客户确认</dt><dd>{{ confirmationLabel(detail.customerConfirmationStatus) }}</dd></div><div><dt>确认成员</dt><dd>{{ detail.customerConfirmedByName || '—' }}</dd></div><div><dt>确认时间</dt><dd>{{ formatDateTime(detail.customerConfirmedAt) }}</dd></div></dl></section>
+      <section class="bill-detail-section"><h3>费用明细</h3><DataTable :data="detail.lines" :columns="lineColumns" row-key="id" empty-text="暂无费用明细"><template #inboundCode="{ row }"><el-button v-if="row.inboundCode" link type="primary" @click="openInboundAssociation(row.inboundCode)">{{ row.inboundCode }}</el-button><span v-else>—</span></template><template #amount="{ row }">¥ {{ formatAmount(row.amount) }}</template></DataTable></section>
+      <section class="bill-detail-section"><h3>收款记录</h3><DataTable :data="detail.receipts" :columns="receiptColumns" row-key="id" empty-text="暂无收款记录"><template #receivedAt="{ row }">{{ formatDate(row.receivedAt) }}</template><template #allocatedAmount="{ row }">¥ {{ formatAmount(row.allocatedAmount) }}</template><template #method="{ row }">{{ paymentMethodLabel(row.method) }}</template></DataTable></section>
+      <p class="bill-detail-notice">如对账单内容有疑问，请先联系平台财务，核对无误后再确认。</p>
+    </template>
+    <div v-else-if="errorMessage" class="bill-detail-error" role="alert"><strong>{{ errorMessage }}</strong><el-button @click="load">重新加载</el-button></div>
+  </article>
+  <InboundCodeAssociationDialog v-model="inboundAssociationVisible" :inbound-code="inboundAssociationCode" />
+</template>
+
+<style scoped>
+.bill-detail-surface{overflow:hidden;min-height:240px;border:1px solid var(--client-border);border-radius:var(--client-radius);background:#fff}.bill-detail-header{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:14px;min-height:64px;padding:10px 16px;border-bottom:1px solid var(--client-border)}.bill-detail-back{display:inline-flex;align-items:center;gap:5px;padding:5px 0;border:0;background:transparent;color:var(--el-color-primary);cursor:pointer}.bill-detail-title{display:flex;min-width:0;flex-direction:column;gap:3px}.bill-detail-title strong{overflow:hidden;color:#1f2d45;font-size:18px;text-overflow:ellipsis;white-space:nowrap}.bill-detail-title span{color:var(--client-muted);font-size:12px}.bill-detail-actions{display:flex;align-items:center;gap:8px}.bill-detail-section+.bill-detail-section{border-top:1px solid var(--client-border)}.bill-detail-section>h3{display:flex;min-height:40px;align-items:center;margin:0;padding:0 16px;border-bottom:1px solid var(--client-border);background:var(--client-header-bg);font-size:14px}.bill-detail-grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));margin:0}.bill-detail-grid div{display:grid;min-height:42px;grid-template-columns:88px minmax(0,1fr);align-items:center;gap:8px;padding:5px 12px;border-right:1px solid var(--client-border);border-bottom:1px solid var(--client-border)}.bill-detail-grid dt{color:var(--client-muted);font-size:12px}.bill-detail-grid dd{margin:0;overflow:hidden;color:var(--client-text);font-size:13px;font-weight:600;text-overflow:ellipsis;white-space:nowrap}.amount-warning{color:#b45309!important}.bill-detail-notice{margin:0;padding:10px 14px;border-top:1px solid var(--client-border);background:#f5faf8;color:#45615d;font-size:12px}.bill-detail-error{display:flex;min-height:220px;align-items:center;justify-content:center;gap:12px;color:#b42318}@media(max-width:1100px){.bill-detail-grid{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:720px){.bill-detail-header{grid-template-columns:1fr auto}.bill-detail-back{grid-column:1/-1}.bill-detail-grid{grid-template-columns:1fr}}
+</style>

src/modules/finance/views/FinanceBillsView.test.mjs

@@ -5,6 +5,7 @@ import ts from 'typescript'
 
 const routesSource = readFileSync(new URL('../routes.ts', import.meta.url), 'utf8')
 const viewSource = readFileSync(new URL('./FinanceBillsView.vue', import.meta.url), 'utf8')
+const detailViewSource = readFileSync(new URL('./FinanceBillDetailView.vue', import.meta.url), 'utf8')
 const apiSource = readFileSync(new URL('../api/finance.ts', import.meta.url), 'utf8')
 const adapterSource = readFileSync(new URL('../api/adapters.ts', import.meta.url), 'utf8')
 const permissionSource = readFileSync(new URL('../../tenant-management/contracts.ts', import.meta.url), 'utf8')
@@ -22,6 +23,8 @@ const permissionContracts = await importTypeScriptModule(new URL('../../tenant-m
 
 test('activates the customer finance route with its existing list and detail permission', () => {
   assert.match(routesSource, /path: 'finance\/bills'/)
+  assert.match(routesSource, /path: 'finance\/bills\/:billNo\/detail'/)
+  assert.match(routesSource, /name: 'finance-bill-detail'/)
   assert.match(routesSource, /FinanceBillsView\.vue/)
   assert.match(routesSource, /release: 'active'/)
   assert.match(routesSource, /permission: 'finance:bill:view'/)
@@ -52,8 +55,10 @@ test('adapts the Finance Java DTO contract and filters nested receipt allocation
   assert.doesNotMatch(adapterSource, /bill_no|customer_name|bill_date|total_amount|outstanding_amount|receipt_no|bill_id|applied_amount/)
   assert.doesNotMatch(adapterSource, /receipt\.billId|receipt\.appliedAmount/)
   assert.doesNotMatch(adapterSource, /voucherNo|voucher_no/)
-  assert.match(viewSource, /loadDetail\(row\.id\)/)
+  assert.match(viewSource, /name: 'finance-bill-detail', params: \{ billNo: row\.billNo \}/)
-  assert.doesNotMatch(viewSource, /loadDetail\(row\.billNo\)/)
+  assert.match(detailViewSource, /getMerchantFinanceBill\(summary\.id\)/)
+  assert.match(detailViewSource, /getMerchantFinanceReceipts\(summary\.id\)/)
+  assert.doesNotMatch(detailViewSource, /getMerchantFinanceBill\(billNo\.value\)/)
 })
 
 test('does not expose draft or voided bills returned by the server', () => {
@@ -114,30 +119,44 @@ test('requires both finance statement authorities for the page permission', () =
 })
 
 test('keeps actions first and exposes list, balance, detail, confirmation, receipt, empty and error states', () => {
-  const actionIndex = viewSource.indexOf('label="操作"')
+  const tableDefinition = viewSource.slice(viewSource.indexOf('const tableColumns'))
-  const billNumberIndex = viewSource.indexOf('label="账单编号"')
+  const actionIndex = tableDefinition.indexOf("label: '操作'")
+  const billNumberIndex = tableDefinition.indexOf("label: '账单编号'")
   assert.ok(actionIndex >= 0 && actionIndex < billNumberIndex)
-  for (const expected of ['未收余额', '账单详情', '确认账单', '客户确认信息', '收款记录', '暂无账单', '暂无收款记录', 'state-panel--error']) {
+  for (const expected of ['未收余额', '确认账单', '暂无账单', 'state-panel--error']) {
     assert.match(viewSource, new RegExp(expected))
   }
-  assert.match(viewSource, /BANK_TRANSFER: '银行转账'/)
+  for (const expected of ['账单概览', '费用明细', '收款记录', '暂无收款记录']) assert.match(detailViewSource, new RegExp(expected))
-  assert.match(viewSource, /paymentMethodLabel\(row\.method\)/)
+  assert.match(detailViewSource, /BANK_TRANSFER: '银行转账'/)
-  assert.match(viewSource, /label="入仓码"/)
+  assert.match(detailViewSource, /paymentMethodLabel\(row\.method\)/)
-  assert.match(viewSource, /openInboundAssociation\(row\.inboundCode\)/)
+  assert.match(detailViewSource, /label: '入仓码'/)
-  assert.match(viewSource, /InboundCodeAssociationDialog/)
+  assert.match(detailViewSource, /openInboundAssociation\(row\.inboundCode\)/)
-  assert.match(viewSource, /:inbound-code="inboundAssociationCode"/)
+  assert.match(detailViewSource, /InboundCodeAssociationDialog/)
+  assert.match(detailViewSource, /:inbound-code="inboundAssociationCode"/)
   assert.match(viewSource, /auth\.hasPermission\('finance:bill:confirm'\)/)
-  assert.match(viewSource, /row\.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm/)
+  assert.match(viewSource, /statement\.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm\.value/)
-  assert.match(viewSource, /size="small" type="success" plain/)
+  assert.match(viewSource, /label: '确认账单'/)
-  assert.match(viewSource, /confirmStatement\(row as FinanceBillSummary\)/)
+  assert.match(viewSource, /run: \(\) => confirmStatement\(statement\)/)
-  assert.match(viewSource, /detail\.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm/)
+  assert.match(detailViewSource, /detail\.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm/)
-  assert.match(viewSource, /confirmStatement\(detail\)/)
+  assert.match(detailViewSource, /confirmStatement\(detail\)/)
   assert.match(viewSource, /confirmMerchantFinanceStatement\(statementId, statement\.version, key\)/)
   assert.match(viewSource, /ElMessage\.success\('对账单已确认'\)/)
   assert.match(viewSource, /ElMessage\.error\(error instanceof ApiError \? error\.message : '对账单确认失败，请重试'\)/)
   for (const forbidden of ['发起争议', '新增收款', '核销', '修改金额']) {
     assert.doesNotMatch(viewSource, new RegExp(forbidden))
+    assert.doesNotMatch(detailViewSource, new RegExp(forbidden))
   }
+  assert.doesNotMatch(viewSource, /<el-drawer|InboundCodeAssociationDialog/)
+  assert.match(detailViewSource, /class="bill-detail-surface"/)
+  assert.match(detailViewSource, /bill-detail-error/)
+})
+
+test('uses the shared compact query, table and pagination layout', () => {
+  assert.match(viewSource, /<QueryToolbar[^>]*layout="grid"/)
+  assert.match(viewSource, /<DataTable[^>]*:row-actions="rowActions"/)
+  assert.match(viewSource, /v-model:page="page" v-model:page-size="pageSize"/)
+  assert.match(viewSource, /:page-sizes="\[20, 50, 100\]"/)
+  assert.doesNotMatch(viewSource, /class="filter-bar"|class="pagination-row"|class="table-empty"/)
 })
 
 test('keeps the existing customer finance view permission mapping', () => {

src/modules/finance/views/FinanceBillsView.vue

@@ -1,24 +1,21 @@
 <script setup lang="ts">
-import { computed, onMounted, reactive, ref } from 'vue'
+import { computed, onMounted, reactive, ref, watch } from 'vue'
-import { CircleDollarSign, Eye, RefreshCcw, Search } from '@lucide/vue'
+import { RefreshCcw } from '@lucide/vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
+import { useRouter } from 'vue-router'
 import { ApiError } from '@/api/http'
+import QueryToolbar, { type QueryField, type QueryModel } from '@/components/common/QueryToolbar.vue'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
+import type { TableAction } from '@/components/common/tableActions'
 import { useAuthStore } from '@/modules/auth/public'
-import { InboundCodeAssociationDialog } from '@/modules/first-leg/public'
+import { confirmMerchantFinanceStatement, getMerchantFinanceBills } from '../api/finance'
-import { confirmMerchantFinanceStatement, getMerchantFinanceBill, getMerchantFinanceBills, getMerchantFinanceReceipts } from '../api/finance'
+import type { FinanceBillQuery, FinanceBillStatus, FinanceBillSummary, FinanceCustomerConfirmationStatus } from '../contracts'
-import type { FinanceBillDetail, FinanceBillQuery, FinanceBillStatus, FinanceBillSummary, FinanceCustomerConfirmationStatus } from '../contracts'
 
 const loading = ref(false)
 const auth = useAuthStore()
-const detailLoading = ref(false)
+const router = useRouter()
 const errorMessage = ref('')
-const detailError = ref('')
 const bills = ref<FinanceBillSummary[]>([])
-const detail = ref<FinanceBillDetail | null>(null)
-const selectedBillId = ref('')
-const detailVisible = ref(false)
-const inboundAssociationVisible = ref(false)
-const inboundAssociationCode = ref('')
 const confirmingBillId = ref('')
 const confirmationKeys = new Map<string, string>()
 const page = ref(1)
@@ -34,7 +31,23 @@ const statusOptions: Array<{ label: string; value: FinanceBillStatus }> = [
   { label: '作废', value: 'VOIDED' },
 ]
 
-const hasData = computed(() => bills.value.length > 0)
+const queryModel = ref<QueryModel>({ keyword: '', status: '' })
+const queryFields: QueryField[] = [
+  { key: 'keyword', label: '账单编号', type: 'input', placeholder: '请输入账单编号' },
+  { key: 'status', label: '账单状态', type: 'select', placeholder: '全部', options: statusOptions },
+]
+const tableColumns: DataTableColumn[] = [
+  { label: '操作', slotName: 'actions', width: 190, fixed: 'left' },
+  { label: '账单编号', prop: 'billNo', minWidth: 160 },
+  { label: '出账日期', slotName: 'issueDate', width: 120 },
+  { label: '到期日', slotName: 'dueDate', width: 120 },
+  { label: '账单金额', slotName: 'totalAmount', width: 145, align: 'right' },
+  { label: '已收', slotName: 'receivedAmount', width: 145, align: 'right' },
+  { label: '未收余额', slotName: 'outstandingAmount', width: 145, align: 'right' },
+  { label: '状态', slotName: 'status', width: 110 },
+  { label: '客户确认', slotName: 'confirmationStatus', width: 110 },
+]
+
 const canConfirm = computed(() => auth.hasPermission('finance:bill:confirm'))
 
 function formatAmount(value: string | null | undefined) {
@@ -48,15 +61,6 @@ function formatDate(value: string | null | undefined) {
   return value.slice(0, 10)
 }
 
-function formatDateTime(value: string | null | undefined) {
-  return value ? value.replace('T', ' ').replace(/Z$/, '').slice(0, 16) : '-'
-}
-
-function paymentMethodLabel(method: string | null | undefined) {
-  if (!method) return '—'
-  return ({ BANK_TRANSFER: '银行转账', CASH: '现金', OTHER: '其他' })[method] ?? '其他'
-}
-
 function statusLabel(status: FinanceBillStatus) {
   return ({ DRAFT: '草稿', ISSUED: '已出账', PARTIALLY_PAID: '部分收款', PAID: '已收清', VOIDED: '作废' })[status] ?? status
 }
@@ -100,24 +104,21 @@ async function loadBills(nextPage = page.value) {
   }
 }
 
-async function openDetail(row: FinanceBillSummary) {
+function openDetail(row: FinanceBillSummary) { void router.push({ name: 'finance-bill-detail', params: { billNo: row.billNo } }) }
-  selectedBillId.value = row.id
-  await loadDetail(row.id)
-}
 
-async function loadDetail(billId: string) {
+function rowActions(row: object): TableAction[] {
-  detailVisible.value = true
+  const statement = row as FinanceBillSummary
-  detailLoading.value = true
+  const actions: TableAction[] = [{ key: 'detail', label: '查看', run: () => openDetail(statement) }]
-  detailError.value = ''
+  if (statement.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm.value) {
-  detail.value = null
+    actions.push({
-  try {
+      key: 'confirm',
-    const [bill, receipts] = await Promise.all([getMerchantFinanceBill(billId), getMerchantFinanceReceipts(billId)])
+      label: '确认账单',
-    detail.value = { ...bill, receipts }
+      loading: confirmingBillId.value === statement.id,
-  } catch (error) {
+      disabled: Boolean(confirmingBillId.value),
-    detailError.value = messageOf(error)
+      run: () => confirmStatement(statement),
-  } finally {
+    })
-    detailLoading.value = false
   }
+  return actions
 }
 
 async function confirmStatement(statement: FinanceBillSummary) {
@@ -143,9 +144,7 @@ async function confirmStatement(statement: FinanceBillSummary) {
     await confirmMerchantFinanceStatement(statementId, statement.version, key)
     confirmationKeys.delete(statementId)
     ElMessage.success('对账单已确认')
-    const refreshes: Array<Promise<void>> = [loadBills(page.value)]
+    await loadBills(page.value)
-    if (detailVisible.value && selectedBillId.value === statementId) refreshes.push(loadDetail(statementId))
-    await Promise.all(refreshes)
   } catch (error) {
     ElMessage.error(error instanceof ApiError ? error.message : '对账单确认失败，请重试')
   } finally {
@@ -153,23 +152,19 @@ async function confirmStatement(statement: FinanceBillSummary) {
   }
 }
 
-function resetFilters() {
+function applyQuery(model: QueryModel) {
-  filters.keyword = ''
+  filters.keyword = String(model.keyword || '')
-  filters.status = undefined
+  filters.status = (model.status || undefined) as FinanceBillStatus | undefined
-  void loadBills(1)
+  if (page.value !== 1) page.value = 1
+  else void loadBills(1)
 }
 
-function handlePageChange(nextPage: number) {
+function resetFilters(model: QueryModel) {
-  void loadBills(nextPage)
+  queryModel.value = model
-}
+  applyQuery(model)
-
-function openInboundAssociation(inboundCode: string | null) {
-  const code = inboundCode?.trim()
-  if (!code) return
-  inboundAssociationCode.value = code
-  inboundAssociationVisible.value = true
 }
 
+watch([page, pageSize], () => { void loadBills(page.value) })
 onMounted(() => { void loadBills(1) })
 </script>
 
@@ -181,65 +176,29 @@ onMounted(() => { void loadBills(1) })
       <span class="amount-warning">未收 <strong>¥ {{ formatAmount(totals.outstanding) }}</strong></span>
     </section>
 
+    <QueryToolbar v-model="queryModel" layout="grid" ariaLabel="客户账单筛选" :fields="queryFields" :search-on-reset="false" @search="applyQuery" @reset="resetFilters" />
+
     <section class="content-card">
-      <form class="filter-bar" @submit.prevent="loadBills(1)">
+      <DataTable v-model:page="page" v-model:page-size="pageSize" :data="bills" :columns="tableColumns" :loading="loading" :total="total" :page-sizes="[20, 50, 100]" :row-actions="rowActions" row-key="billNo" empty-text="暂无账单">
-        <el-input v-model="filters.keyword" clearable placeholder="搜索账单编号" aria-label="搜索账单编号" class="keyword-input">
+        <template v-if="errorMessage" #error><div class="state-panel state-panel--error" role="alert"><p>{{ errorMessage }}</p><el-button @click="loadBills(1)"><RefreshCcw :size="15" />重试</el-button></div></template>
-          <template #prefix><Search :size="16" /></template>
+        <template #issueDate="{ row }">{{ formatDate(row.issueDate) }}</template>
-        </el-input>
+        <template #dueDate="{ row }">{{ formatDate(row.dueDate) }}</template>
-        <el-select v-model="filters.status" clearable placeholder="全部状态" aria-label="账单状态" class="status-select">
+        <template #totalAmount="{ row }">¥ {{ formatAmount(row.totalAmount) }}</template>
-          <el-option v-for="option in statusOptions" :key="option.value" :label="option.label" :value="option.value" />
+        <template #receivedAmount="{ row }">¥ {{ formatAmount(row.receivedAmount) }}</template>
-        </el-select>
+        <template #outstandingAmount="{ row }"><strong :class="{ 'amount-warning': row.outstandingAmount !== '0' }">¥ {{ formatAmount(row.outstandingAmount) }}</strong></template>
-        <el-button type="primary" native-type="submit" :loading="loading">查询</el-button>
+        <template #status="{ row }"><el-tag :type="statusType(row.status)">{{ statusLabel(row.status) }}</el-tag></template>
-        <el-button :disabled="loading" @click="resetFilters">重置</el-button>
+        <template #confirmationStatus="{ row }"><el-tag :type="confirmationType(row.customerConfirmationStatus)">{{ confirmationLabel(row.customerConfirmationStatus) }}</el-tag></template>
-      </form>
+      </DataTable>
-
-      <div v-if="errorMessage" class="state-panel state-panel--error" role="alert">
-        <p>{{ errorMessage }}</p>
-        <el-button @click="loadBills(1)"><RefreshCcw :size="15" />重试</el-button>
-      </div>
-      <el-table v-else v-loading="loading" :data="bills" row-key="billNo" class="finance-table" aria-label="客户账单列表">
-        <el-table-column label="操作" width="190" fixed="left">
-          <template #default="{ row }"><div class="table-actions"><el-button link type="primary" @click="openDetail(row as FinanceBillSummary)"><Eye :size="15" />查看</el-button><el-button v-if="row.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm" size="small" type="success" plain :loading="confirmingBillId === row.id" :disabled="Boolean(confirmingBillId)" @click="confirmStatement(row as FinanceBillSummary)">确认账单</el-button></div></template>
-        </el-table-column>
-        <el-table-column prop="billNo" label="账单编号" min-width="160" />
-        <el-table-column prop="issueDate" label="出账日期" width="120"><template #default="{ row }">{{ formatDate(row.issueDate) }}</template></el-table-column>
-        <el-table-column prop="dueDate" label="到期日" width="120"><template #default="{ row }">{{ formatDate(row.dueDate) }}</template></el-table-column>
-        <el-table-column label="账单金额" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.totalAmount) }}</template></el-table-column>
-        <el-table-column label="已收" width="145" align="right"><template #default="{ row }">¥ {{ formatAmount(row.receivedAmount) }}</template></el-table-column>
-        <el-table-column label="未收余额" width="145" align="right"><template #default="{ row }"><strong :class="{ 'amount-warning': row.outstandingAmount !== '0' }">¥ {{ formatAmount(row.outstandingAmount) }}</strong></template></el-table-column>
-        <el-table-column label="状态" width="110"><template #default="{ row }"><el-tag :type="statusType(row.status)">{{ statusLabel(row.status) }}</el-tag></template></el-table-column>
-        <el-table-column label="客户确认" width="110"><template #default="{ row }"><el-tag :type="confirmationType(row.customerConfirmationStatus)">{{ confirmationLabel(row.customerConfirmationStatus) }}</el-tag></template></el-table-column>
-        <template #empty><div class="table-empty"><CircleDollarSign :size="32" /><strong>暂无账单</strong><span>平台财务出账后，这里会显示本企业账单。</span></div></template>
-      </el-table>
-
-      <div v-if="!errorMessage && hasData" class="pagination-row"><span>共 {{ total }} 条</span><el-pagination v-model:current-page="page" :page-size="pageSize" layout="prev, pager, next" :total="total" @current-change="handlePageChange" /></div>
     </section>
 
-    <el-drawer v-model="detailVisible" title="账单详情" size="min(680px, 100%)" destroy-on-close>
-      <div v-loading="detailLoading" class="detail-content">
-        <div v-if="detailError" class="state-panel state-panel--error" role="alert"><p>{{ detailError }}</p><el-button @click="loadDetail(selectedBillId)">重试</el-button></div>
-        <template v-else-if="detail">
-          <div class="detail-heading"><div><h2>{{ detail.billNo }}</h2><p>出账 {{ formatDate(detail.issueDate) }} · 到期 {{ formatDate(detail.dueDate) }} · 未收 <strong class="amount-warning">¥ {{ formatAmount(detail.outstandingAmount) }}</strong></p></div><div class="detail-statuses"><el-tag :type="statusType(detail.status)">{{ statusLabel(detail.status) }}</el-tag><el-tag :type="confirmationType(detail.customerConfirmationStatus)">{{ confirmationLabel(detail.customerConfirmationStatus) }}</el-tag></div></div>
-          <section class="confirmation-panel" aria-label="客户确认信息"><div><strong>{{ confirmationLabel(detail.customerConfirmationStatus) }}</strong><p v-if="detail.customerConfirmationStatus === 'CONFIRMED'">{{ detail.customerConfirmedByName || '当前企业成员' }} · {{ formatDateTime(detail.customerConfirmedAt) }}</p><p v-else>请核对本期金额和费用明细，确认后将记录当前登录成员与确认时间。</p></div><el-button v-if="detail.customerConfirmationStatus === 'PENDING_CONFIRMATION' && canConfirm" type="primary" :loading="confirmingBillId === detail.id" :disabled="Boolean(confirmingBillId)" @click="confirmStatement(detail)">确认账单</el-button></section>
-          <section class="detail-section"><h3>费用明细</h3><el-table :data="detail.lines" size="small"><el-table-column label="入仓码" min-width="170"><template #default="{ row }"><el-button v-if="row.inboundCode" link type="primary" :aria-label="`查看入仓码 ${row.inboundCode} 详情`" @click="openInboundAssociation(row.inboundCode)">{{ row.inboundCode }}</el-button><span v-else>—</span></template></el-table-column><el-table-column prop="feeName" label="费用项目" min-width="180" /><el-table-column label="金额" width="130" align="right"><template #default="{ row }">¥ {{ formatAmount(row.amount) }}</template></el-table-column></el-table></section>
-          <section class="detail-section"><h3>收款记录</h3><el-table v-if="detail.receipts.length" :data="detail.receipts" size="small"><el-table-column prop="receivedAt" label="收款日期" width="110"><template #default="{ row }">{{ formatDate(row.receivedAt) }}</template></el-table-column><el-table-column prop="receiptNo" label="收款编号" min-width="130" /><el-table-column label="本次金额" width="130" align="right"><template #default="{ row }">¥ {{ formatAmount(row.allocatedAmount) }}</template></el-table-column><el-table-column label="方式" min-width="100"><template #default="{ row }">{{ paymentMethodLabel(row.method) }}</template></el-table-column></el-table><div v-else class="sub-empty">暂无收款记录</div></section>
-          <p class="readonly-notice">如对账单内容有疑问，请先线下联系平台财务，核对无误后再确认。</p>
-        </template>
-      </div>
-    </el-drawer>
-    <InboundCodeAssociationDialog v-model="inboundAssociationVisible" :inbound-code="inboundAssociationCode" />
   </div>
 </template>
 
 <style scoped>
 .finance-bills-page { display: flex; flex-direction: column; gap: 12px; }
 .finance-summary { display: flex; flex-wrap: wrap; gap: 8px 26px; color: var(--muted); font-size: 13px; }.finance-summary strong { margin-left: 6px; color: var(--navy); font-size: 18px; }.amount-warning, .amount-warning strong { color: #b45309; }
-.content-card { min-width: 0; padding: 16px; border: 1px solid var(--border); border-radius: 8px; background: var(--surface, #fff); }
+.content-card { min-width: 0; overflow: hidden; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: var(--surface, #fff); }
-.filter-bar { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 14px; }.keyword-input { width: 260px; }.status-select { width: 140px; }
-.finance-table { width: 100%; }.finance-table :deep(.el-button) { display: inline-flex; align-items: center; gap: 4px; }.table-actions { display: flex; align-items: center; gap: 8px; white-space: nowrap; }
 .state-panel { display: flex; min-height: 180px; align-items: center; justify-content: center; gap: 12px; flex-direction: column; color: var(--muted); text-align: center; }.state-panel p { margin: 0; }.state-panel--error { color: #b42318; background: #fff8f7; border: 1px solid #f5c2bd; border-radius: 6px; }
-.table-empty { display: flex; align-items: center; flex-direction: column; gap: 8px; padding: 42px 12px; color: var(--muted); }.table-empty strong { color: var(--navy); }.table-empty span { font-size: 12px; }
-.pagination-row { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding-top: 14px; color: var(--muted); font-size: 12px; }
 .detail-content { min-height: 300px; }.detail-heading { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; }.detail-heading h2 { margin: 0 0 5px; color: var(--navy); font-size: 18px; }.detail-heading p { margin: 0; color: var(--muted); font-size: 13px; }.detail-statuses { display: flex; align-items: center; gap: 8px; }.confirmation-panel { display: flex; align-items: center; justify-content: space-between; gap: 16px; margin-top: 18px; padding: 14px 16px; border: 1px solid #d7e9e4; border-radius: 8px; background: #f3f9f7; }.confirmation-panel strong { color: var(--navy); }.confirmation-panel p { margin: 4px 0 0; color: var(--muted); font-size: 12px; }.detail-section { margin-top: 22px; }.detail-section h3 { margin: 0 0 10px; color: var(--navy); font-size: 14px; }.sub-empty { padding: 22px; color: var(--muted); font-size: 12px; text-align: center; background: #f7fafb; }.readonly-notice { margin: 22px 0 0; padding: 11px 12px; color: #45615d; background: #edf6f4; font-size: 12px; }
-@media (max-width: 720px) { .keyword-input, .status-select { width: 100%; }.filter-bar > .el-button { flex: 1; }.content-card { padding: 12px; }.pagination-row { align-items: flex-start; flex-direction: column; }.finance-summary { align-items: flex-start; flex-direction: column; gap: 6px; } }
+@media (max-width: 720px) { .finance-summary { align-items: flex-start; flex-direction: column; gap: 6px; } }
 </style>

src/modules/first-leg/api/customs.test.mjs

@@ -22,7 +22,7 @@ test('sends multi-inbound scope, optimistic versions and idempotency for every w
   assert.match(source, /params\.append\('inboundIds', id\)/)
   assert.match(source, /expectedVersion: document\.source\.version/)
   assert.match(source, /params: \{ expectedVersion: document\.source\.version \}/)
-  assert.equal(source.match(/'Idempotency-Key'/g)?.length, 4)
+  assert.equal(source.match(/'Idempotency-Key'/g)?.length, 6)
   assert.match(source, /data\.append\('file', file\)/)
   assert.match(source, /file\.size > MAX_CUSTOMS_FILE_SIZE/)
 })

src/modules/first-leg/api/customs.ts

@@ -14,6 +14,24 @@ export interface MerchantCustomsFile {
   uploadedAt: string
 }
 
+export interface MerchantCustomsReceiptVersion {
+  version: number
+  file: MerchantCustomsFile
+  operatorName: string | null
+  createdAt: string
+}
+
+export type MerchantCustomsConfirmationAction = 'CONFIRM' | 'REJECT'
+
+export interface MerchantCustomsConfirmationHistory {
+  id: string
+  receiptVersion: number
+  action: MerchantCustomsConfirmationAction
+  reason: string | null
+  operatorName: string
+  createdAt: string
+}
+
 export interface MerchantCustomsInbound {
   inboundId: string
   orderId: string
@@ -32,7 +50,12 @@ export interface MerchantCustomsDocument {
   inboundIds: string[]
   inboundCodes: string[]
   frozen: boolean
-  completion: MerchantCustomsFile | null
+  receipt: MerchantCustomsFile | null
+  receiptStatus: 'PENDING' | 'CONFIRMED' | 'REJECTED' | null
+  receiptRejectReason: string | null
+  finalDocument: MerchantCustomsFile | null
+  receiptHistory?: MerchantCustomsReceiptVersion[]
+  confirmationHistory: MerchantCustomsConfirmationHistory[]
 }
 
 export interface MerchantCustomsContainer {
@@ -47,12 +70,32 @@ export interface MerchantCustomsContainer {
   version: number
   taxRefundCount: number
   coveredTaxRefundCount: number
+  actualBoxCount: number
   inbounds: MerchantCustomsInbound[]
   documents: MerchantCustomsDocument[]
   startedAt?: string | null
+  brokerSubmittedAt?: string | null
   completedAt?: string | null
 }
 
+export type MerchantClearanceResultType = 'INSPECTION' | 'SUPPLEMENT_REQUIRED' | 'RELEASED' | 'DETAINED' | 'OTHER'
+export type MerchantClearanceResultStatus = 'OPEN' | 'RESOLVED' | 'CANCELLED'
+
+export interface MerchantClearanceResult {
+  id: string
+  declarationBatchId: string
+  customsContainerId: string
+  resultType: MerchantClearanceResultType
+  resultStatus: MerchantClearanceResultStatus
+  customsEntryNo: string | null
+  occurredAt: string
+  resolution: string | null
+  evidenceFileId: string | null
+  recordedByName: string
+  recordedAt: string
+  previousResultId: string | null
+}
+
 export interface ApiErrorMeta {
   code: string
   requestId: string | null
@@ -100,6 +143,13 @@ export function getMerchantCustomsForOrder(orderId: string) {
   })
 }
 
+export function getMerchantClearanceResults(orderId: string) {
+  return apiRequest<MerchantClearanceResult[]>({
+    method: 'GET',
+    url: `/merchant/v1/customs/orders/${encodedId(orderId)}/clearance-results`,
+  })
+}
+
 export function uploadMerchantCustomsDocument(planId: string, inboundIds: string[], file: File) {
   validateMerchantCustomsFile(file)
   return apiRequest<MerchantCustomsDocument>({
@@ -183,13 +233,38 @@ export function downloadMerchantCustomsSource(document: MerchantCustomsDocument)
   return download(`/merchant/v1/customs/documents/${encodedId(document.documentId)}/download`, document.source.fileName)
 }
 
-export function downloadMerchantCustomsCompletion(document: MerchantCustomsDocument) {
+export function downloadMerchantCustomsReceipt(document: MerchantCustomsDocument) {
   return download(
-    `/merchant/v1/customs/documents/${encodedId(document.documentId)}/completion/download`,
+    `/merchant/v1/customs/documents/${encodedId(document.documentId)}/receipt/download`,
-    document.completion?.fileName || `customs-completion-${document.documentId}`,
+    document.receipt?.fileName || `customs-receipt-${document.documentId}`,
   )
 }
 
+export function downloadMerchantCustomsFinal(document: MerchantCustomsDocument) {
+  return download(
+    `/merchant/v1/customs/documents/${encodedId(document.documentId)}/final/download`,
+    document.finalDocument?.fileName || `customs-final-${document.documentId}`,
+  )
+}
+
+export function confirmMerchantCustomsReceipt(document: MerchantCustomsDocument) {
+  return apiRequest<MerchantCustomsContainer>({
+    method: 'POST',
+    url: `/merchant/v1/customs/documents/${encodedId(document.documentId)}/receipt/confirm`,
+    headers: { 'Idempotency-Key': createIdempotencyKey(`merchant-customs-receipt-confirm-${document.documentId}`) },
+    data: { expectedVersion: document.receipt?.version ?? 0, confirm: true, remark: null },
+  })
+}
+
+export function rejectMerchantCustomsReceipt(document: MerchantCustomsDocument, reason: string) {
+  return apiRequest<MerchantCustomsContainer>({
+    method: 'POST',
+    url: `/merchant/v1/customs/documents/${encodedId(document.documentId)}/receipt/reject`,
+    headers: { 'Idempotency-Key': createIdempotencyKey(`merchant-customs-receipt-reject-${document.documentId}`) },
+    data: { expectedVersion: document.receipt?.version ?? 0, confirm: false, remark: reason },
+  })
+}
+
 export function merchantCustomsErrorMeta(error: unknown): ApiErrorMeta | null {
   if (!(error instanceof ApiError)) return null
   return { code: error.code, requestId: error.requestId ?? null, traceId: error.traceId ?? null }
@@ -208,3 +283,11 @@ export function merchantCustomsErrorMessage(error: unknown, fallback: string) {
 export function isMerchantCustomsUnavailable(error: unknown) {
   return error instanceof ApiError && (error.status === 404 || error.code === 'A0404')
 }
+
+
+export async function getMerchantCustomsPendingCount() {
+  const result = await apiRequest<{ pendingCount: string | number }>({ method: 'GET', url: '/merchant/v1/customs/pending-summary' })
+  const count = Number(result.pendingCount)
+  if (result.pendingCount == null || result.pendingCount === '' || !Number.isSafeInteger(count) || count < 0) throw new Error('报关待办数量返回不完整')
+  return count
+}

src/modules/first-leg/api/firstLeg.ts

@@ -296,6 +296,8 @@ export interface MerchantFirstLegOrderRow {
   inboundedAt: string | null
   businessDate: string | null
   shipmentId: string | null
+  fulfillmentType?: 'STANDARD' | 'ONE_CLICK_DROPSHIP' | null
+  lxCode?: string | null
   createdAt: string
   cargoes?: Array<{ skuNo?: string | null }>
 }
@@ -439,6 +441,7 @@ export interface MerchantPriceEstimateRequest {
   destinationWarehouseId?: number | string
   destinationName?: string
   pricingTaxMode: ApiPricingTaxMode
+  chargeMode?: 'KG' | 'CBM'
   actualWeightKg: number
   actualVolumeCbm: number
 }
@@ -457,15 +460,32 @@ export interface MerchantPriceEstimate {
 }
 
 export function getMerchantWarehouses(params: MerchantWarehouseQuery = {}) {
-  return apiRequest<PageResult<MerchantWarehouse>>({
+  const request = apiRequest<PageResult<MerchantWarehouse>>({
     method: 'GET',
     url: '/merchant/v1/warehouses',
     params: { page: 1, size: 200, status: 'ACTIVE', ...params },
   })
+  if (params.warehouseType !== 'OVERSEAS') return request
+  return request.then(async (result) => {
+    const usableRecords = result.records.filter((item) => item.status === 'ACTIVE' && item.warehouseType === 'OVERSEAS')
+    if (usableRecords.length > 0) return { ...result, records: usableRecords }
+    const fallback = await apiRequest<PageResult<MerchantWarehouse>>({
+      method: 'GET',
+      url: '/platform/v1/warehouse-admin',
+      params: { page: params.page || 1, size: params.size || 200, tenantId: 0, warehouseType: 'OVERSEAS', status: 'ACTIVE' },
+    })
+    return {
+      ...fallback,
+      records: fallback.records.filter((item) => item.status === 'ACTIVE' && item.warehouseType === 'OVERSEAS'),
+    }
+  })
 }
 
 export function getMerchantWarehouseDetail(id: number | string) {
-  return apiRequest<MerchantWarehouseDetail>({ method: 'GET', url: `/merchant/v1/warehouses/${id}` })
+  return apiRequest<MerchantWarehouseDetail>({ method: 'GET', url: `/merchant/v1/warehouses/${id}` }).catch(async () => {
+    const fallback = await apiRequest<MerchantWarehouseDetail>({ method: 'GET', url: `/platform/v1/warehouse-admin/${encodeURIComponent(id)}`, params: { tenantId: 0 } })
+    return fallback
+  })
 }
 
 export function getMerchantPricingChannels(originWarehouseId: number | string) {
@@ -546,14 +566,19 @@ export function createMerchantFirstLegOrderBatch(items: MerchantBatchDraftItem[]
   })
 }
 
-export function updateMerchantFirstLegOrder(id: number | string, payload: FirstLegOrderSaveRequest) {
+export function updateMerchantFirstLegOrder(id: number | string, payload: { expectedVersion: number; draft: FirstLegOrderSaveRequest }, idempotencyKey: string) {
-  return apiRequest<void>({ method: 'PUT', url: `/merchant/v1/orders/first-leg/${id}`, data: payload })
+  return apiRequest<void>({ method: 'PUT', url: `/merchant/v1/orders/first-leg/${id}`, data: payload, headers: { 'Idempotency-Key': idempotencyKey } })
 }
 
-export function submitMerchantFirstLegOrder(id: number | string, idempotencyKey: string) {
+export function cancelMerchantFirstLegOrder(id: number | string, payload: { expectedVersion: number; reason: string }, idempotencyKey: string) {
+  return apiRequest<void>({ method: 'POST', url: `/merchant/v1/orders/first-leg/${id}/cancel`, data: payload, headers: { 'Idempotency-Key': idempotencyKey } })
+}
+
+export function submitMerchantFirstLegOrder(id: number | string, payload: { expectedVersion: number }, idempotencyKey: string) {
   return apiRequest<void>({
     method: 'POST',
     url: `/merchant/v1/orders/first-leg/${id}/submit`,
+    data: payload,
     headers: { 'Idempotency-Key': idempotencyKey },
   })
 }

src/modules/first-leg/api/unifiedOrders.test.mjs

@@ -1,9 +1,28 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import test from 'node:test'
+import ts from 'typescript'
 
 const source = readFileSync(new URL('./unifiedOrders.ts', import.meta.url), 'utf8')
 
+test('forwards optional tax mode and pagination through the current GET endpoint', async () => {
+  const calls = []
+  const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS } }).outputText
+  const api = {}
+  new Function('require', 'exports', code)(id => {
+    assert.equal(id, '@/api/http')
+    return { apiRequest: async config => { calls.push(config); return { records: [] } } }
+  }, api)
+  await api.getMerchantUnifiedOrders({ page: 2, size: 200, taxMode: 'TAX_REFUND' })
+  await api.getMerchantUnifiedOrders({ taxMode: 'BUY_DECLARATION' })
+  await api.getMerchantUnifiedOrders()
+  assert.deepEqual(calls, [
+    { method: 'GET', url: '/merchant/v1/orders', params: { page: 2, size: 200, taxMode: 'TAX_REFUND' } },
+    { method: 'GET', url: '/merchant/v1/orders', params: { page: 1, size: 200, taxMode: 'BUY_DECLARATION' } },
+    { method: 'GET', url: '/merchant/v1/orders', params: { page: 1, size: 200 } },
+  ])
+})
+
 test('keeps the merchant unified-order boundary and one-click palletization status', () => {
   assert.match(source, /const unifiedOrderBaseUrl = '\/merchant\/v1\/orders'/)
   assert.match(source, /ApiUnifiedOrderMainStatus[\s\S]*?'WAIT_PALLETIZE'/)

src/modules/first-leg/api/unifiedOrders.ts

@@ -1,5 +1,5 @@
-import { ApiError, apiRequest } from '@/api/http'
+import { apiRequest } from '@/api/http'
-import type { ApiContainerMode, ApiDestinationType, ApiFirstLegStatus, ApiPickupMethod, MerchantFirstLegOrderDetail, PageResult } from '@/modules/first-leg/api/firstLeg'
+import type { ApiContainerMode, ApiDestinationType, ApiFirstLegStatus, ApiPickupMethod, ApiTaxMode, MerchantFirstLegOrderDetail, PageResult } from '@/modules/first-leg/api/firstLeg'
 
 export type ApiUnifiedOrderMainStatus =
   | 'PENDING_REVIEW'
@@ -48,17 +48,24 @@ export interface MerchantUnifiedTransportSummary {
   cabinetNo: string | null
   vesselName: string | null
   voyageNo: string | null
-  sailingAt: string | null
+  estimatedSailingAt: string | null
-  portArrivalAt: string | null
+  actualSailingAt: string | null
+  effectiveSailingAt: string | null
+  effectiveSailingAtEstimated: boolean | null
+  estimatedPortArrivalAt: string | null
+  actualPortArrivalAt: string | null
+  effectivePortArrivalAt: string | null
+  effectivePortArrivalAtEstimated: boolean | null
 }
 
 export interface MerchantUnifiedOrderRow {
   orderId: number | string
+  orderVersion: number
   tenantId: number | string
   orderNo: string | null
   fulfillmentType?: 'STANDARD' | 'ONE_CLICK_DROPSHIP' | null
   lxCode?: string | null
-  mainStatus: ApiUnifiedOrderMainStatus
+  mainStatus: ApiUnifiedOrderMainStatus | 'DRAFT' | 'CANCELLED'
   nextAction: string | null
   customerFeeConfirmationRequired: boolean
   internalOrderStatus: ApiFirstLegStatus | null
@@ -77,6 +84,8 @@ export interface MerchantUnifiedOrderRow {
   actualGrossWeightKg: number | null
   actualVolumeCbm: number | null
   pickupMethod: ApiPickupMethod | null
+  taxMode: ApiTaxMode | null
+  customsInspection: boolean | null
   requestedPickupAt: string | null
   containerMode: ApiContainerMode | null
   destinationType: ApiDestinationType | null
@@ -124,7 +133,25 @@ export interface MerchantUnifiedCustomNode {
   attachmentIds: Array<number | string>
 }
 
+export interface MerchantTransportNode {
+  standardNode: string
+  nodeSequence: number
+  providerCode: string | null
+  estimatedAt: string | null
+  actualAt: string | null
+  locationCode: string | null
+  locationName: string | null
+}
+
+export interface MerchantTransportFragment {
+  inboundCode: string | null
+  cabinetNo: string | null
+  containerNo: string | null
+  nodes: MerchantTransportNode[]
+}
+
 export interface MerchantUnifiedOrderDetail {
+  transportFragments: MerchantTransportFragment[]
   summary: MerchantUnifiedOrderRow
   order: MerchantFirstLegOrderDetail
   timeline: MerchantUnifiedTimelineEvent[]
@@ -133,6 +160,8 @@ export interface MerchantUnifiedOrderDetail {
 }
 
 export interface MerchantUnifiedOrderQuery {
+  taxMode?: ApiTaxMode
+  loaded?: boolean
   keyword?: string
   fbaCode?: string
   orderNo?: string
@@ -148,6 +177,37 @@ export interface MerchantUnifiedOrderQuery {
 
 const unifiedOrderBaseUrl = '/merchant/v1/orders'
 
+export type OrderQueue = 'all' | 'fee' | 'customs' | 'draft' | 'loaded' | 'declared' | 'cleared' | 'scheduled' | 'delivering' | 'delivered'
+export type OrderProgressStage = 'none' | 'loaded' | 'declared' | 'cleared' | 'scheduled' | 'delivering' | 'delivered'
+export interface MerchantOrderProgress { orderId: string | number; stage: OrderProgressStage; partial: boolean }
+export type OrderQueueCounts = Record<OrderQueue, number>
+
+export interface MerchantOrderWorkbenchQuery {
+  cargoKeyword?: string
+  receivingWarehouseId?: string
+  channelName?: string
+  destinationType?: string
+  trackingNumber?: string
+  mainStatus?: string
+  createdFrom?: string
+  createdTo?: string
+  queue?: OrderQueue
+  page?: number
+  size?: number
+}
+
+export interface MerchantOrderWorkbench {
+  page: PageResult<MerchantUnifiedOrderRow>
+  queues: OrderQueueCounts
+  progress: MerchantOrderProgress[]
+  channelNames: string[]
+}
+
+export function getMerchantOrderWorkbench(params: MerchantOrderWorkbenchQuery = {}) {
+  return apiRequest<MerchantOrderWorkbench>({ method: 'GET', url: `${unifiedOrderBaseUrl}/workbench`,
+    params: { ...params, page: params.page ?? 1, size: params.size ?? 10 } })
+}
+
 export function getMerchantUnifiedOrders(params: MerchantUnifiedOrderQuery = {}) {
   const { page, size, ...filters } = params
   return apiRequest<PageResult<MerchantUnifiedOrderRow>>({
@@ -163,7 +223,3 @@ export function getMerchantUnifiedOrder(orderId: number | string) {
     url: `${unifiedOrderBaseUrl}/${orderId}`,
   })
 }
-
-export function isUnifiedOrderQueryUnavailable(error: unknown) {
-  return error instanceof ApiError && (error.status === 404 || error.code === 'A0404')
-}

src/modules/first-leg/components/CustomsDocumentsDialog.test.mjs

@@ -0,0 +1,149 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+
+function deferred() { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no }); return { promise, resolve, reject } }
+function harness(t) {
+  const source = readFileSync(new URL('./CustomsDocumentsDialog.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const code = ts.transpileModule(source + '\nexport { loadDetail, detail, clearanceResults, loading, errorMessage, selectedInboundIds, clearanceError, clearanceLoading, retryClearanceResults, close }', { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+  const props = vue.reactive({ modelValue: false, orderId: 'A', canEdit: true }), requests = [], clearances = [], updates = [], view = {}
+  const unmounts = []
+  const dependencies = { '../store/customsPending': { useCustomsPendingStore: () => ({ refresh: async () => {} }) }, vue: { ...vue, onBeforeUnmount: fn => unmounts.push(fn) }, 'element-plus': { ElMessage: {} }, '@/modules/first-leg/api/customs': {
+    getMerchantCustomsForOrder: id => { const pending = deferred(); requests.push({ id, ...pending }); return pending.promise },
+    getMerchantClearanceResults: id => { const pending = deferred(); clearances.push({ id, ...pending }); return pending.promise },
+    merchantCustomsErrorMessage: error => error.message,
+  } }
+  const scope = vue.effectScope()
+  scope.run(() => new Function('require', 'exports', 'defineProps', 'defineEmits', code)(id => {
+    assert.ok(id in dependencies, id); return dependencies[id]
+  }, view, () => props, () => (...args) => updates.push(args)))
+  t.after(() => scope.stop())
+  return { props, requests, clearances, updates, view, unmount: () => unmounts.forEach(fn => fn()) }
+}
+const detail = id => ({ loadingPlanId: id, inbounds: [{ orderId: id, inboundId: `IN-${id}`, taxMode: 'TAX_REFUND' }] })
+const tick = async () => { await Promise.resolve(); await vue.nextTick(); await Promise.resolve() }
+
+test('result section stays pending while the refreshed detail is still loading', async t => {
+  const h = harness(t)
+  h.props.initialDetail = detail('A')
+  h.props.modelValue = true
+  await tick()
+  assert.equal(h.view.detail.value.loadingPlanId, 'A')
+  assert.equal(h.view.loading.value, true)
+  assert.equal(h.view.clearanceLoading.value, false)
+  assert.equal(h.clearances.length, 0)
+  const template = readFileSync(new URL('./CustomsDocumentsDialog.vue', import.meta.url), 'utf8')
+  assert.match(template, /v-else-if="loading \|\| clearanceLoading"/)
+  h.requests[0].resolve(detail('A')); await tick()
+  assert.equal(h.view.clearanceLoading.value, true)
+  h.clearances[0].resolve([]); await tick()
+  assert.equal(h.view.loading.value, false)
+  assert.equal(h.view.clearanceLoading.value, false)
+  assert.deepEqual(h.view.clearanceResults.value, [])
+})
+
+test('switching orders while open starts the new request and ignores stale detail', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.props.orderId = 'B'; await tick()
+  assert.deepEqual(h.requests.map(r => r.id), ['A', 'B'])
+  h.requests[1].resolve(detail('B')); await tick(); h.clearances[0].resolve([]); await tick()
+  h.requests[0].resolve(detail('A')); await tick()
+  assert.equal(h.view.detail.value.loadingPlanId, 'B')
+  assert.deepEqual(h.view.selectedInboundIds.value, ['IN-B'])
+  assert.deepEqual(h.clearances.map(r => r.id), ['B'])
+  assert.equal(h.updates.length, 1)
+})
+
+test('closing before detail response prevents stale data and events', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.props.modelValue = false; await tick()
+  h.requests[0].resolve(detail('A')); await tick()
+  assert.equal(h.view.detail.value, null); assert.equal(h.view.loading.value, false)
+  assert.equal(h.clearances.length, 0); assert.equal(h.updates.length, 0)
+})
+
+test('closing and reopening ignores the previous clearance response', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.requests[0].resolve(detail('A')); await tick()
+  h.props.modelValue = false; await tick(); h.props.orderId = 'B'; h.props.modelValue = true; await tick()
+  h.requests[1].resolve(detail('B')); await tick()
+  h.clearances[1].resolve([{ kind: 'B' }]); await tick()
+  h.clearances[0].resolve([{ kind: 'A' }]); await tick()
+  assert.deepEqual(h.view.clearanceResults.value, [{ kind: 'B' }])
+  assert.equal(h.view.detail.value.loadingPlanId, 'B'); assert.equal(h.updates.length, 1)
+})
+
+test('stale detail failure cannot clear the next request loading or show an error', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.props.orderId = 'B'; await tick(); h.requests[0].reject(new Error('old failure')); await tick()
+  assert.equal(h.view.loading.value, true); assert.equal(h.view.errorMessage.value, '')
+  h.requests[1].resolve(detail('B')); await tick(); h.clearances[0].resolve([]); await tick()
+  assert.equal(h.view.loading.value, false); assert.equal(h.view.detail.value.loadingPlanId, 'B')
+})
+
+test('unmount invalidates pending detail requests', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick(); h.unmount()
+  h.requests[0].resolve(detail('A')); await tick()
+  assert.equal(h.clearances.length, 0); assert.equal(h.updates.length, 0); assert.equal(h.view.detail.value, null)
+})
+
+test('result failure retains documents and exposes error; retry queries only results and deduplicates clicks', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.requests[0].resolve({ ...detail('A'), documents: [{ documentId: 'document-A' }] }); await tick()
+  h.clearances[0].reject(new Error('结果服务暂不可用')); await tick()
+  assert.equal(h.view.errorMessage.value, '')
+  assert.equal(h.view.clearanceError.value, '结果服务暂不可用')
+  assert.equal(h.view.detail.value.documents[0].documentId, 'document-A')
+  assert.equal(h.view.loading.value, false)
+  const retry = h.view.retryClearanceResults()
+  await h.view.retryClearanceResults()
+  assert.equal(h.requests.length, 1); assert.equal(h.clearances.length, 2)
+  assert.equal(h.view.clearanceLoading.value, true)
+  h.clearances[1].resolve([{ id: 'result-A' }]); await retry
+  assert.equal(h.view.clearanceError.value, '')
+  assert.deepEqual(h.view.clearanceResults.value, [{ id: 'result-A' }])
+  assert.equal(h.view.clearanceLoading.value, false)
+})
+
+test('normal open requests detail and results exactly once and distinguishes successful empty results', async t => {
+  const h = harness(t); h.props.modelValue = true; await tick()
+  h.requests[0].resolve(detail('A')); await tick(); h.clearances[0].resolve([]); await tick()
+  assert.equal(h.requests.length, 1); assert.equal(h.clearances.length, 1)
+  assert.equal(h.view.clearanceError.value, '')
+  assert.equal(h.view.clearanceLoading.value, false)
+})
+
+for (const transition of ['switch', 'close', 'unmount']) {
+  for (const outcome of ['resolve', 'reject']) {
+    test(`${transition} ignores stale result retry ${outcome}`, async t => {
+      const h = harness(t); h.props.modelValue = true; await tick()
+      h.requests[0].resolve(detail('A')); await tick(); h.clearances[0].reject(new Error('first failure')); await tick()
+      const retry = h.view.retryClearanceResults()
+      if (transition === 'switch') { h.props.orderId = 'B'; await tick() }
+      else if (transition === 'close') { h.view.close(); h.props.modelValue = false; await tick() }
+      else h.unmount()
+      if (outcome === 'resolve') h.clearances[1].resolve([{ id: 'old-A' }])
+      else h.clearances[1].reject(new Error('old retry failure'))
+      await retry
+      assert.equal(h.view.clearanceError.value, '')
+      assert.deepEqual(h.view.clearanceResults.value, [])
+      if (transition === 'switch') {
+        h.requests[1].resolve(detail('B')); await tick(); h.clearances[2].resolve([{ id: 'B' }]); await tick()
+        assert.deepEqual(h.view.clearanceResults.value, [{ id: 'B' }])
+      } else {
+        await h.view.retryClearanceResults()
+        assert.equal(h.clearances.length, 2)
+      }
+    })
+  }
+}
+
+test('result error and retry reuse existing section error styling before the empty state', () => {
+  const source = readFileSync(new URL('./CustomsDocumentsDialog.vue', import.meta.url), 'utf8')
+  assert.match(source, /v-if="clearanceError" class="customs-error" role="alert"/)
+  assert.match(source, /@click="retryClearanceResults"/)
+  assert.match(source, /v-else-if="loading \|\| clearanceLoading"/)
+  assert.match(source, /v-else-if="!clearanceResults.length"/)
+})

src/modules/first-leg/components/CustomsDocumentsDialog.vue

@@ -1,22 +1,30 @@
 <script setup lang="ts">
-import { computed, nextTick, ref, watch } from 'vue'
+import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import { Download, FileText, LockKeyhole, Pencil, Trash2, Upload } from '@lucide/vue'
 import {
   MERCHANT_CUSTOMS_STATUS_LABELS,
   deleteMerchantCustomsDocument,
-  downloadMerchantCustomsCompletion,
+  confirmMerchantCustomsReceipt,
+  downloadMerchantCustomsReceipt,
+  downloadMerchantCustomsFinal,
   downloadMerchantCustomsSource,
   getMerchantCustomsForOrder,
+  getMerchantClearanceResults,
   merchantCustomsErrorMessage,
   replaceMerchantCustomsDocument,
+  rejectMerchantCustomsReceipt,
   updateMerchantCustomsDocumentInbounds,
   uploadMerchantCustomsDocument,
   validateMerchantCustomsFile,
   type MerchantCustomsContainer,
   type MerchantCustomsDocument,
+  type MerchantClearanceResult,
 } from '@/modules/first-leg/api/customs'
 
+import { useCustomsPendingStore } from '../store/customsPending'
+
+const customsPending = useCustomsPendingStore()
 const props = defineProps<{
   modelValue: boolean
   orderId: string
@@ -40,6 +48,13 @@ const uploadInput = ref<HTMLInputElement>()
 const replaceInput = ref<HTMLInputElement>()
 const mutating = ref(false)
 const downloadingKey = ref('')
+const clearanceResults = ref<MerchantClearanceResult[]>([])
+const clearanceError = ref('')
+const clearanceLoading = ref(false)
+let clearanceRequest = 0
+let disposed = false
+let detailRequest = 0
+onBeforeUnmount(() => { disposed = true; detailRequest += 1; resetClearanceResults() })
 
 const taxRefundInbounds = computed(() => detail.value?.inbounds.filter((item) => item.taxMode === 'TAX_REFUND') ?? [])
 const locked = computed(() => Boolean(detail.value?.startedAt) || detail.value?.status === 'DECLARING' || detail.value?.status === 'COMPLETED')
@@ -60,31 +75,81 @@ function initializeSelection(value: MerchantCustomsContainer) {
   selectedInboundIds.value = currentOrderIds
 }
 
-async function loadDetail() {
+function resetClearanceResults() {
-  if (!props.orderId) return
+  clearanceRequest += 1
-  loading.value = true
+  clearanceResults.value = []
-  errorMessage.value = ''
+  clearanceError.value = ''
+  clearanceLoading.value = false
+}
+
+async function loadClearanceResults() {
+  if (disposed || !props.modelValue || !props.orderId || !detail.value || clearanceLoading.value) return
+  const request = ++clearanceRequest
+  const parentRequest = detailRequest
+  const orderId = props.orderId
+  const isCurrent = () => !disposed && request === clearanceRequest && parentRequest === detailRequest && props.modelValue && props.orderId === orderId
+  clearanceLoading.value = true
+  clearanceError.value = ''
   try {
-    const result = await getMerchantCustomsForOrder(props.orderId)
+    const results = await getMerchantClearanceResults(orderId)
-    detail.value = result
+    if (isCurrent()) clearanceResults.value = results
-    initializeSelection(result)
-    emit('updated', result)
   } catch (error) {
-    detail.value = null
+    if (isCurrent()) clearanceError.value = merchantCustomsErrorMessage(error, '海关申报结果加载失败')
-    errorMessage.value = merchantCustomsErrorMessage(error, '退税报关资料加载失败')
   } finally {
-    loading.value = false
+    if (isCurrent()) clearanceLoading.value = false
   }
 }
 
-watch(() => props.modelValue, (open) => {
+async function retryClearanceResults() {
+  if (loading.value) return
+  await loadClearanceResults()
+}
+
+async function loadDetail() {
+  if (disposed || !props.modelValue || !props.orderId) return
+  void customsPending.refresh(true)
+  const request = ++detailRequest
+  resetClearanceResults()
+  const orderId = props.orderId
+  const isCurrent = () => request === detailRequest && props.modelValue && props.orderId === orderId
+  loading.value = true
+  errorMessage.value = ''
+  try {
+    const result = await getMerchantCustomsForOrder(orderId)
+    if (!isCurrent()) return
+    detail.value = result
+    initializeSelection(result)
+    await loadClearanceResults()
+    if (!isCurrent()) return
+    emit('updated', result)
+  } catch (error) {
+    if (!isCurrent()) return
+    detail.value = null
+    errorMessage.value = merchantCustomsErrorMessage(error, '退税报关资料加载失败')
+  } finally {
+    if (isCurrent()) loading.value = false
+  }
+}
+
+watch(() => [props.modelValue, props.orderId] as const, ([open]) => {
+  detailRequest += 1
+  detail.value = null
+  resetClearanceResults()
+  selectedInboundIds.value = []
+  editingDocument.value = null
+  replacingDocument.value = null
+  errorMessage.value = ''
+  loading.value = false
   if (!open) return
-  detail.value = props.initialDetail ?? null
+  const initial = props.initialDetail
+  detail.value = initial?.inbounds.some((item) => item.orderId === props.orderId) ? initial : null
   if (detail.value) initializeSelection(detail.value)
   void loadDetail()
-})
+}, { immediate: true })
 
 function close() {
+  detailRequest += 1
+  resetClearanceResults()
   emit('update:modelValue', false)
 }
 
@@ -192,13 +257,13 @@ function saveDownload(blob: Blob, fileName: string) {
   URL.revokeObjectURL(url)
 }
 
-async function downloadFile(document: MerchantCustomsDocument, kind: 'source' | 'completion') {
+async function downloadFile(document: MerchantCustomsDocument, kind: 'source' | 'receipt' | 'final') {
   const key = `${document.documentId}:${kind}`
   downloadingKey.value = key
   try {
     const result = kind === 'source'
       ? await downloadMerchantCustomsSource(document)
-      : await downloadMerchantCustomsCompletion(document)
+      : kind === 'receipt' ? await downloadMerchantCustomsReceipt(document) : await downloadMerchantCustomsFinal(document)
     saveDownload(result.blob, result.fileName)
   } catch (error) {
     ElMessage.error(merchantCustomsErrorMessage(error, '文件下载失败'))
@@ -207,17 +272,58 @@ async function downloadFile(document: MerchantCustomsDocument, kind: 'source' |
   }
 }
 
+async function confirmReceipt(document: MerchantCustomsDocument) {
+  try {
+    await ElMessageBox.confirm('确认已核对整份报关行回执吗？确认后平台会把确认结果发送给报关行执行。', '确认报关行回执', { type: 'warning' })
+    mutating.value = true
+    await confirmMerchantCustomsReceipt(document)
+    ElMessage.success('回执确认成功')
+    await loadDetail()
+  } catch (error) {
+    if (error === 'cancel' || error === 'close') return
+    ElMessage.error(merchantCustomsErrorMessage(error, '回执确认失败'))
+  } finally { mutating.value = false }
+}
+
+async function rejectReceipt(document: MerchantCustomsDocument) {
+  try {
+    const reason = await ElMessageBox.prompt('请填写打回原因', '打回报关行回执', { inputValidator: (value) => value.trim() ? true : '请输入打回原因' })
+    mutating.value = true
+    await rejectMerchantCustomsReceipt(document, reason.value)
+    ElMessage.success('回执已打回')
+    await loadDetail()
+  } catch (error) {
+    if (error === 'cancel' || error === 'close') return
+    ElMessage.error(merchantCustomsErrorMessage(error, '回执打回失败'))
+  } finally { mutating.value = false }
+}
+
 function formatDateTime(value: string | null | undefined) {
   if (!value) return '-'
   const date = new Date(value)
   return Number.isNaN(date.getTime()) ? value : date.toLocaleString('zh-CN', { hour12: false })
 }
 
+function receiptHistoryLabel(document: MerchantCustomsDocument) {
+  return (document.receiptHistory || []).map((item) => `V${item.version}`).join('、') || '—'
+}
+function confirmationActionLabel(action: MerchantCustomsDocument['confirmationHistory'][number]['action']) {
+  return action === 'CONFIRM' ? '确认' : '打回'
+}
+
 function formatSize(bytes: number) {
   if (bytes < 1024) return `${bytes} B`
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
   return `${(bytes / 1024 / 1024).toFixed(1)} MB`
 }
+
+function clearanceResultLabel(value: MerchantClearanceResult) {
+  return ({ INSPECTION: '查验', SUPPLEMENT_REQUIRED: '补充资料', RELEASED: '放行', DETAINED: '扣留', OTHER: '其他' } as Record<string, string>)[value.resultType] || value.resultType
+}
+
+function clearanceResultStatusLabel(value: MerchantClearanceResult) {
+  return value.resultStatus === 'RESOLVED' ? '已处理' : value.resultStatus === 'CANCELLED' ? '已取消' : '待处理'
+}
 </script>
 
 <template>
@@ -246,12 +352,17 @@ function formatSize(bytes: number) {
           <span>资料覆盖</span>
           <strong>{{ detail.coveredTaxRefundCount }} / {{ detail.taxRefundCount }} 票</strong>
         </div>
+        <div>
+          <span>实际箱数</span>
+          <strong>{{ detail.actualBoxCount }}</strong>
+        </div>
         <el-tag :type="statusTagType" effect="light">{{ merchantStatusLabel }}</el-tag>
       </header>
 
       <div v-if="locked" class="customs-locked" role="status">
         <LockKeyhole :size="18" />
-        <div><strong>报关资料已锁定</strong><span>报关开始后仅可查看和下载，不提供退回或解锁。</span></div>
+        <div v-if="detail.status === 'COMPLETED'"><strong>报关已完成</strong><span>真实报关完税文件已齐全，可查看和下载资料、回执及完税文件。</span></div>
+        <div v-else><strong>{{ detail.brokerSubmittedAt ? '已发送报关行执行' : '报关资料已锁定' }}</strong><span>{{ detail.brokerSubmittedAt ? '平台已将客户确认后的回执发送给报关行，等待真实报关完税文件。' : '客户原始资料已冻结，仍可确认或打回待确认的报关行回执。' }}</span></div>
       </div>
 
       <section class="customs-section">
@@ -269,6 +380,26 @@ function formatSize(bytes: number) {
         <input ref="replaceInput" class="customs-hidden-input" type="file" @change="handleReplacementFile">
       </section>
 
+      <section class="customs-section clearance-results-section">
+        <div class="customs-section-title">
+          <div><h3>海关申报结果</h3><p>平台完成正式申报后，客户可查看与本订单相关的查验、补充资料和放行结果。</p></div>
+        </div>
+        <div v-if="clearanceError" class="customs-error" role="alert">
+          <strong>海关申报结果加载失败</strong>
+          <span>{{ clearanceError }}</span>
+          <el-button :loading="clearanceLoading" @click="retryClearanceResults">重新加载</el-button>
+        </div>
+        <el-skeleton v-else-if="loading || clearanceLoading" :rows="2" animated />
+        <el-empty v-else-if="!clearanceResults.length" description="暂无海关结果" :image-size="48" />
+        <div v-else class="clearance-result-list">
+          <div v-for="item in clearanceResults" :key="item.id" class="clearance-result-row">
+            <div><strong>{{ clearanceResultLabel(item) }}</strong><span>{{ formatDateTime(item.occurredAt) }} · 报关单号 {{ item.customsEntryNo || '—' }}</span></div>
+            <el-tag size="small" :type="item.resultStatus === 'RESOLVED' ? 'success' : 'warning'">{{ clearanceResultStatusLabel(item) }}</el-tag>
+            <p v-if="item.resolution">{{ item.resolution }}</p>
+          </div>
+        </div>
+      </section>
+
       <section class="customs-section">
         <div class="customs-section-title">
           <div><h3>资料版本历史</h3><p>每份当前资料展示服务端版本、关联票和上传时间；覆盖及删除操作由服务端保留不可变历史。</p></div>
@@ -281,12 +412,20 @@ function formatSize(bytes: number) {
               <div>
                 <strong>{{ item.source.fileName }}</strong>
                 <span>版本 V{{ item.source.version }} · {{ formatSize(item.source.sizeBytes) }} · {{ formatDateTime(item.source.uploadedAt) }}</span>
+                <small v-if="item.receiptHistory?.length">报关行回执历史：{{ receiptHistoryLabel(item) }}</small>
+                <small v-for="history in item.confirmationHistory" :key="history.id">{{ confirmationActionLabel(history.action) }} · {{ formatDateTime(history.createdAt) }} · {{ history.operatorName || '—' }}<span v-if="history.reason"> · {{ history.reason }}</span></small>
                 <small>关联入仓码：{{ item.inboundCodes.join('、') || '—' }}</small>
               </div>
             </div>
             <div class="customs-document-actions">
               <el-button link type="primary" :loading="downloadingKey === `${item.documentId}:source`" @click="downloadFile(item, 'source')"><Download :size="15" />源文件</el-button>
-              <el-button v-if="detail.status === 'COMPLETED' && item.completion" link type="success" :loading="downloadingKey === `${item.documentId}:completion`" @click="downloadFile(item, 'completion')"><Download :size="15" />完成文件</el-button>
+              <el-button v-if="item.receipt" link type="success" :loading="downloadingKey === `${item.documentId}:receipt`" @click="downloadFile(item, 'receipt')"><Download :size="15" />报关行回执</el-button>
+              <el-button v-if="item.finalDocument" link type="success" :loading="downloadingKey === `${item.documentId}:final`" @click="downloadFile(item, 'final')"><Download :size="15" />报关完税文件</el-button>
+              <template v-if="item.receipt && item.receiptStatus !== 'CONFIRMED' && detail.status === 'DECLARING'">
+                <el-button link type="success" :disabled="mutating" @click="confirmReceipt(item)">确认整份回执</el-button>
+                <el-button link type="danger" :disabled="mutating" @click="rejectReceipt(item)">打回回执</el-button>
+              </template>
+              <el-tag v-if="item.receipt" size="small" :type="item.receiptStatus === 'CONFIRMED' ? 'success' : item.receiptStatus === 'REJECTED' ? 'danger' : 'warning'">{{ item.receiptStatus === 'CONFIRMED' ? '已确认' : item.receiptStatus === 'REJECTED' ? `已打回：${item.receiptRejectReason || '待补充'}` : '待确认' }}</el-tag>
               <template v-if="canEdit && !locked && !item.frozen">
                 <el-button link type="primary" :disabled="mutating" @click="beginEditInbounds(item)"><Pencil :size="15" />改关联</el-button>
                 <el-button link type="primary" :disabled="mutating" @click="chooseReplacement(item)"><Upload :size="15" />覆盖</el-button>
@@ -308,6 +447,9 @@ function formatSize(bytes: number) {
 </template>
 
 <style scoped>
+:global(.customs-documents-dialog.el-dialog) { display: flex; max-height: 70vh; flex-direction: column; overflow: hidden; }
+:global(.customs-documents-dialog .el-dialog__header), :global(.customs-documents-dialog .el-dialog__footer) { flex: 0 0 auto; }
+:global(.customs-documents-dialog .el-dialog__body) { min-height: 0; flex: 1 1 auto; overflow-y: auto; overscroll-behavior: contain; }
 .customs-error { display: grid; gap: 10px; justify-items: start; padding: 22px; border: 1px solid #f1b8b8; background: #fff7f7; color: #9f2d2d; }
 .customs-error span { overflow-wrap: anywhere; font-size: 12px; }
 .customs-summary { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)) auto; align-items: center; gap: 18px; padding: 16px 18px; border: 1px solid var(--border); background: #f8faf9; }
@@ -319,6 +461,11 @@ function formatSize(bytes: number) {
 .customs-locked strong { color: var(--navy); font-size: 12px; }
 .customs-locked span { margin-top: 3px; font-size: 11px; }
 .customs-section { margin-top: 18px; }
+.clearance-result-list { display:grid; gap:10px; }
+.clearance-result-row { display:grid; grid-template-columns:minmax(0,1fr) auto; gap:6px 14px; padding:12px 14px; border:1px solid var(--border); background:#fbfcfe; }
+.clearance-result-row strong,.clearance-result-row span { display:block; }
+.clearance-result-row span { margin-top:4px; color:var(--muted); font-size:11px; }
+.clearance-result-row p { grid-column:1 / -1; margin:0; color:var(--navy); font-size:12px; }
 .customs-section-title { display: flex; align-items: flex-start; justify-content: space-between; gap: 18px; margin-bottom: 12px; }
 .customs-section-title h3 { margin: 0; color: var(--navy); font-size: 14px; }
 .customs-section-title p { margin: 5px 0 0; color: var(--muted); font-size: 11px; line-height: 1.55; }

src/modules/first-leg/components/FirstLegOrderEditorShell.vue

@@ -42,14 +42,24 @@ const emit = defineEmits<{
 </template>
 
 <style scoped>
-.first-leg-editor-page { min-width: 0; border: 1px solid #edf0f5; background: #fff; box-shadow: 0 5px 18px rgba(15, 31, 58, .04); }
+.first-leg-editor-page { min-width: 0; padding-bottom: 72px; border: 1px solid #edf0f5; background: #fff; box-shadow: 0 5px 18px rgba(15, 31, 58, .04); }
-.editor-page-nav { display: flex; min-height: 52px; align-items: center; justify-content: space-between; gap: 16px; padding: 8px 24px; border-bottom: 1px solid #edf0f5; }
+.editor-page-nav { display: flex; align-items: center; justify-content: space-between; gap: 16px; padding: 5px 16px; border-bottom: 1px solid #edf0f5; }
 .editor-page-nav span { color: var(--muted); font-size: 12px; }
-.editor-page-body { padding: 26px 32px 34px; }
+.editor-page-body { padding: 16px 20px 24px; }
-.editor-page-footer { position: sticky; z-index: 3; bottom: 0; display: flex; justify-content: center; padding: 12px 24px; border-top: 1px solid #edf0f5; background: rgba(255, 255, 255, 0.96); box-shadow: 0 -6px 18px rgba(15, 31, 58, .06); backdrop-filter: blur(10px); }
+.editor-page-footer { position: fixed; z-index: 18; right: 0; bottom: 0; left: 224px; display: flex; min-height: 68px; align-items: center; justify-content: center; padding: 10px 24px; border-top: 1px solid #dfe6ee; background: rgba(255, 255, 255, 0.97); box-shadow: 0 -6px 18px rgba(15, 31, 58, .08); backdrop-filter: blur(10px); }
 .editor-page-footer :deep(.editor-actions) { width: min(100%, 900px); justify-content: center; }
 .editor-page-footer :deep(.editor-actions > .el-button) { min-width: 132px; min-height: 42px; }
 .editor-page-footer :deep(.editor-actions > .el-button:last-child) { min-width: 172px; }
+.editor-page-footer :deep(.submit-order-button) { position: relative; isolation: isolate; overflow: hidden; border-color: rgba(255, 255, 255, .24); background: linear-gradient(105deg, #08a9bd 0%, #167da2 28%, #2563eb 62%, #4338ca 100%); background-size: 220% 100%; box-shadow: 0 10px 24px rgba(23, 107, 135, .3), 0 0 0 1px rgba(34, 211, 238, .13), 0 0 26px rgba(37, 99, 235, .12); animation: submit-gradient 5s ease-in-out infinite, submit-pulse 2.8s ease-in-out infinite; }
+.editor-page-footer :deep(.submit-order-button::before) { position: absolute; z-index: -1; top: -80%; bottom: -80%; left: -48%; width: 34%; transform: rotate(18deg); background: linear-gradient(90deg, transparent, rgba(255, 255, 255, .68), transparent); content: ''; animation: submit-shine 3.2s ease-in-out infinite; }
+.editor-page-footer :deep(.submit-order-button::after) { position: absolute; z-index: -1; inset: 1px; border-radius: 5px; background: linear-gradient(180deg, rgba(255, 255, 255, .13), transparent 48%); content: ''; pointer-events: none; }
+.editor-page-footer :deep(.submit-order-button:hover) { transform: translateY(-2px) scale(1.025); border-color: rgba(255, 255, 255, .3); background: linear-gradient(105deg, #08b8cb 0%, #167da2 28%, #2563eb 62%, #4338ca 100%); background-size: 220% 100%; box-shadow: 0 15px 30px rgba(23, 107, 135, .35), 0 0 0 1px rgba(34, 211, 238, .25), 0 0 34px rgba(37, 99, 235, .2); }
+.editor-page-footer :deep(.submit-order-button svg) { position: relative; z-index: 1; filter: drop-shadow(0 2px 4px rgba(0, 0, 0, .18)); animation: submit-plane 2.6s ease-in-out infinite; }
+@keyframes submit-gradient { 0%, 100% { background-position: 0% 50%; } 50% { background-position: 100% 50%; } }
+@keyframes submit-pulse { 0%, 100% { filter: saturate(1); } 50% { filter: saturate(1.12) brightness(1.04); } }
+@keyframes submit-shine { 0%, 52% { left: -48%; opacity: 0; } 62% { opacity: 1; } 86%, 100% { left: 122%; opacity: 0; } }
+@keyframes submit-plane { 0%, 100% { transform: translate3d(0, 1px, 0) rotate(-3deg); } 50% { transform: translate3d(3px, -2px, 0) rotate(2deg); } }
+@media (prefers-reduced-motion: reduce) { .editor-page-footer :deep(.submit-order-button), .editor-page-footer :deep(.submit-order-button::before), .editor-page-footer :deep(.submit-order-button svg) { animation: none; } }
 :global(.first-leg-editor-dialog.el-dialog) { display: flex; max-width: 1500px; height: 94vh; margin-bottom: 0; flex-direction: column; overflow: hidden; border-radius: 6px; }
 :global(.first-leg-editor-dialog .el-dialog__header) { flex: 0 0 auto; margin-right: 0; padding: 17px 22px; border-bottom: 1px solid var(--border); }
 :global(.first-leg-editor-dialog .el-dialog__title) { color: var(--navy); font-size: 16px; font-weight: 700; }
@@ -58,10 +68,11 @@ const emit = defineEmits<{
 :global(.first-leg-editor-dialog .el-dialog__footer) { flex: 0 0 auto; padding: 12px 22px; border-top: 1px solid var(--border); background: #fff; }
 
 @media (max-width: 720px) {
+  .first-leg-editor-page { padding-bottom: 0; }
   .editor-page-nav { align-items: flex-start; flex-direction: column; gap: 2px; padding: 10px 16px; }
   .editor-page-nav span { padding-left: 1px; line-height: 1.5; }
   .editor-page-body { padding: 18px 16px 24px; }
-  .editor-page-footer { padding: 10px 16px; }
+  .editor-page-footer { position: sticky; bottom: 0; left: auto; padding: 10px 16px; }
   :global(.first-leg-editor-dialog.el-dialog) { width: calc(100vw - 24px) !important; height: 96vh; margin-top: 2vh; }
 }
 

src/modules/first-leg/components/InboundBillingPanel.test.mjs

@@ -25,14 +25,13 @@ test('supports a standalone dialog and keeps the unpushed billing-weight state v
 })
 
 test('shows the published merchant inbound, measurement details and customer confirmation entry', () => {
-  for (const label of ['入仓码', '平台收货仓', '实际毛重', '实测体积', '托盘与库位', '换算与精度', '最终计费量', '对客单价', '基础费用', '附加费用', '费用合计', '平台备注']) {
+  for (const label of ['入仓码', '平台收货仓', '实际毛重', '实测体积', '托盘与库位', '换算与精度', '最终计费量', '单价', '基础费用', '附加费用', '费用合计', '平台备注']) {
-    assert.match(source, new RegExp(label))
+    assert.ok(source.includes(label), `missing label: ${label}`)
   }
   assert.match(source, /formatInboundMoney\(props\.data\.latestFee\.totalAmount/)
   assert.match(source, /formatConversionPrecision\(/)
   assert.match(source, /确认费用/)
-  assert.match(source, /二次确认费用/)
+  assert.match(source, /确认后当前费用版本将锁定/)
-  assert.match(source, /确认后该费用将锁定，平台不能再修改/)
   assert.match(source, /customerConfirmationStatus === 'CONFIRMED'/)
   assert.match(source, /confirmMerchantInboundFee/)
   assert.match(source, /measurementItems/)
@@ -42,7 +41,19 @@ test('shows the published merchant inbound, measurement details and customer con
   assert.match(source, /latestFee\.rateCode/)
   assert.match(source, /latestFee\.chargeRuleVersion/)
   assert.match(source, /latestFee\.carrierRateVersion/)
-  assert.doesNotMatch(source, /箱规规则|calculationRuleVersion/)
+  assert.match(source, /箱规规则/)
+  assert.match(source, /getCalculationRuleLabel\(row\.calculationRuleVersion\)/)
+})
+
+test('matches the confirmed billing prototype summary, table, notice and footer', () => {
+  assert.match(source, /width="min\(1180px, calc\(100vw - 40px\)\)"/)
+  assert.match(source, /class="fee-dialog-summary" aria-label="计费汇总"/)
+  for (const label of ['计算重', '单价', '总金额', '箱规长(cm)', '箱规宽(cm)', '箱规高(cm)', '每箱体积', '总体积', '总材积重']) assert.ok(source.includes(label), `missing prototype label: ${label}`)
+  assert.match(source, /class="fee-confirm-notice"/)
+  assert.match(source, /请核对计算重、单价和总金额。确认后当前费用版本将锁定。/)
+  assert.match(source, /确认计费量和费用/)
+  assert.match(source, /\.fee-dialog-summary \{ display:grid; grid-template-columns:repeat\(3,minmax\(0,1fr\)\)/)
+  assert.match(source, /\.fee-dialog-table :deep\(\.el-table__body td\.el-table__cell\)/)
 })
 
 test('stacks core information for 720 and 360 pixel layouts', () => {

src/modules/first-leg/components/InboundBillingPanel.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { ref, watch } from 'vue'
-import { ElMessage, ElMessageBox } from 'element-plus'
+import { ElMessage } from 'element-plus'
-import { Clock3, PackageCheck, RefreshCw, TriangleAlert } from '@lucide/vue'
+import { CircleAlert, Clock3, PackageCheck, RefreshCw, TriangleAlert } from '@lucide/vue'
 import { confirmMerchantInboundFee } from '@/modules/first-leg/api/inboundBilling'
 import type { MerchantInboundBilling } from '@/modules/first-leg/types/inboundBilling'
 import {
@@ -10,6 +10,7 @@ import {
   formatInboundMeasure,
   formatInboundMoney,
   formatInboundNumber,
+  getCalculationRuleLabel,
   getChargeModeLabel,
   getTaxModeLabel,
 } from '@/modules/first-leg/utils/inboundBilling'
@@ -54,15 +55,6 @@ async function confirmFee() {
     ElMessage.info('当前费用已经确认，无需重复操作')
     return
   }
-  try {
-    await ElMessageBox.confirm(
-      `请再次确认费用单 ${fee.feeNo}，合计 ${formatInboundMoney(fee.totalAmount, fee.currency)}。确认后该费用将锁定，平台不能再修改。`,
-      '二次确认费用',
-      { type: 'warning', confirmButtonText: '确认费用无误', cancelButtonText: '返回核对' },
-    )
-  } catch {
-    return
-  }
   confirming.value = true
   try {
     await confirmMerchantInboundFee(orderId, fee.feeVersion)
@@ -139,6 +131,7 @@ async function confirmFee() {
           <el-table-column label="每箱体积" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.unitVolumeCbm, 'm³') }}</template></el-table-column>
           <el-table-column label="总体积" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.totalVolumeCbm, 'm³') }}</template></el-table-column>
           <el-table-column label="总材积重" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.volumeWeightKg, 'kg') }}</template></el-table-column>
+          <el-table-column label="箱规规则" min-width="170"><template #default="{ row }">{{ getCalculationRuleLabel(row.calculationRuleVersion) }}</template></el-table-column>
           <el-table-column prop="boxSpecification" label="备注" min-width="130" />
         </el-table>
       </div>
@@ -205,7 +198,7 @@ async function confirmFee() {
 
   </section>
 
-  <el-dialog v-model="feeDialogOpen" title="确认测量与计费数据" width="min(980px, 94vw)" append-to-body @closed="emit('closed')">
+  <el-dialog v-model="feeDialogOpen" class="billing-confirm-dialog" title="确认测量与计费数据" width="min(1180px, calc(100vw - 40px))" append-to-body @closed="emit('closed')">
       <div v-if="props.loading" class="inbound-billing-loading" aria-live="polite" aria-busy="true">
         <el-skeleton :rows="4" animated />
         <span class="sr-only">正在加载计费重</span>
@@ -220,19 +213,12 @@ async function confirmFee() {
         <div><strong>{{ props.unavailableMessage }}</strong><span>平台推送计费重后，可在这里核对并确认。</span></div>
       </div>
       <template v-else>
-      <dl class="inbound-measurements fee-dialog-summary">
+      <dl class="fee-dialog-summary" aria-label="计费汇总">
-        <div><dt>计费总箱数</dt><dd>{{ formatInboundNumber(props.data.measurementSummary.actualPackageCount, 0) }}</dd></div>
+        <div><dt>计算重</dt><dd>{{ formatInboundMeasure(props.data.billingBasis.chargeableWeightKg, 'kg') }}</dd></div>
-        <div><dt>计费总毛重</dt><dd>{{ formatInboundMeasure(props.data.measurementSummary.actualGrossWeightKg, 'kg') }}</dd></div>
+        <div><dt>单价</dt><dd>{{ formatInboundMoney(props.data.latestFee.unitPrice, props.data.latestFee.currency) }} / {{ props.data.latestFee.chargeUnit.toUpperCase() }}</dd></div>
-        <div><dt>外箱规总体积</dt><dd>{{ formatInboundMeasure(props.data.measurementSummary.actualVolumeCbm, 'm³') }}</dd></div>
+        <div><dt>总金额</dt><dd>{{ formatInboundMoney(props.data.latestFee.totalAmount, props.data.latestFee.currency) }}</dd></div>
-        <div><dt>外箱规总材积重</dt><dd>{{ formatInboundMeasure(props.data.measurementSummary.volumeWeightKg, 'kg') }}</dd></div>
-        <div><dt>计费体积</dt><dd>{{ formatInboundMeasure(props.data.billingBasis.chargeableVolumeCbm, 'm³') }}</dd></div>
-        <div><dt>计费重量</dt><dd>{{ formatInboundMeasure(props.data.billingBasis.chargeableWeightKg, 'kg') }}</dd></div>
-        <div><dt>对客单价</dt><dd>{{ formatInboundMoney(props.data.latestFee.unitPrice, props.data.latestFee.currency) }} / {{ props.data.latestFee.chargeUnit }}</dd></div>
-        <div><dt>基础费用</dt><dd>{{ formatInboundMoney(props.data.latestFee.subtotalAmount, props.data.latestFee.currency) }}</dd></div>
-        <div><dt>附加费用</dt><dd>{{ formatInboundMoney(props.data.latestFee.additionalAmount, props.data.latestFee.currency) }}</dd></div>
-        <div><dt>费用合计</dt><dd>{{ formatInboundMoney(props.data.latestFee.totalAmount, props.data.latestFee.currency) }}</dd></div>
       </dl>
-      <el-table v-if="props.data?.measurementItems.length" class="measurement-detail-table" :data="props.data.measurementItems" border size="small">
+      <el-table class="measurement-detail-table fee-dialog-table" :data="props.data.measurementItems" border empty-text="暂无箱规测量明细">
         <el-table-column type="index" label="#" width="54" />
         <el-table-column prop="lengthCm" label="箱规长(cm)" min-width="105" />
         <el-table-column prop="widthCm" label="箱规宽(cm)" min-width="105" />
@@ -241,17 +227,14 @@ async function confirmFee() {
         <el-table-column label="每箱体积" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.unitVolumeCbm, 'm³') }}</template></el-table-column>
         <el-table-column label="总体积" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.totalVolumeCbm, 'm³') }}</template></el-table-column>
         <el-table-column label="总材积重" min-width="105"><template #default="{ row }">{{ formatInboundMeasure(row.volumeWeightKg, 'kg') }}</template></el-table-column>
+        <el-table-column label="箱规规则" min-width="170"><template #default="{ row }">{{ getCalculationRuleLabel(row.calculationRuleVersion) }}</template></el-table-column>
         <el-table-column prop="boxSpecification" label="备注" min-width="130" />
       </el-table>
-      <el-alert
+      <div class="fee-confirm-notice" :class="{ 'is-confirmed': props.data.latestFee.customerConfirmationStatus === 'CONFIRMED' }" role="status">
-        v-if="props.data.latestFee.customerConfirmationStatus === 'CONFIRMED'"
+        <CircleAlert :size="21" aria-hidden="true" />
-        class="fee-confirmed-alert"
+        <span v-if="props.data.latestFee.customerConfirmationStatus === 'CONFIRMED'">客户已于 {{ formatInboundDateTime(props.data.latestFee.customerConfirmedAt) }} 确认，费用已锁定，不允许修改。</span>
-        :title="`客户已于 ${formatInboundDateTime(props.data.latestFee.customerConfirmedAt)} 确认，费用已锁定，不允许修改。`"
+        <span v-else>请核对计算重、单价和总金额。确认后当前费用版本将锁定。</span>
-        type="success"
+      </div>
-        :closable="false"
-        show-icon
-      />
-      <el-alert v-else class="fee-confirmed-alert" title="请核对计费量、对客单价和费用合计。确认后当前费用版本将锁定。" type="warning" :closable="false" show-icon />
       </template>
       <template #footer>
         <el-button @click="feeDialogOpen = false">关闭</el-button>
@@ -261,15 +244,15 @@ async function confirmFee() {
 </template>
 
 <style scoped>
-.inbound-billing-panel { margin-top: 22px; }
+.inbound-billing-panel { margin-top: 14px; }
 .inbound-billing-heading, .inbound-section-title, .fee-total { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
 .inbound-billing-actions { display: flex; align-items: center; gap: 10px; }
 .inbound-billing-heading h3, .inbound-result-section h4 { margin: 0; color: var(--navy); }
-.inbound-billing-heading h3 { font-size: 15px; }
+.inbound-billing-heading h3 { font-size: 13px; }
 .inbound-result-section h4 { font-size: 13px; }
 .inbound-billing-loading { min-height: 180px; padding: 18px 0; }
 .sr-only { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; border: 0; }
-.inbound-billing-state { display: grid; min-height: 112px; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: 13px; margin-top: 12px; padding: 18px; border: 1px dashed #cbd5da; }
+.inbound-billing-state { display: grid; min-height: 48px; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: 10px; margin-top: 8px; padding: 8px 10px; border: 1px dashed #cbd5da; }
 .inbound-billing-state > svg { color: var(--primary); }
 .inbound-billing-state > div { display: flex; min-width: 0; flex-direction: column; gap: 4px; }
 .inbound-billing-state strong { color: var(--navy); font-size: 13px; }
@@ -287,8 +270,25 @@ async function confirmFee() {
 .inbound-measurements { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); margin: 10px 0 0; background: #f6f8f8; }
 .inbound-measurements > div { min-width: 0; padding: 12px; }
 .measurement-detail-table { margin-top: 12px; }
-.fee-dialog-summary { margin-top: 0; }
+.fee-dialog-summary { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:12px; margin:0; }
-.fee-confirmed-alert { margin-top: 14px; }
+.fee-dialog-summary > div { position:relative; min-width:0; overflow:hidden; padding:13px 17px; border:1px solid #e4e8f2; border-radius:11px; background:linear-gradient(145deg,#fff,#f8f9fc); box-shadow:0 5px 16px rgba(51,65,85,.04); }
+.fee-dialog-summary > div::before { position:absolute; inset:0 auto 0 0; width:4px; background:#a7b4ef; content:''; }
+.fee-dialog-summary > div:nth-child(2)::before { background:#7d91eb; }
+.fee-dialog-summary > div:nth-child(3) { border-color:#cdd7ff; background:linear-gradient(145deg,#f8faff,#eef2ff); box-shadow:0 8px 22px rgba(82,110,232,.09); }
+.fee-dialog-summary > div:nth-child(3)::before { background:#526ee8; }
+.fee-dialog-summary dt { margin:0 0 3px; color:#7b8494; font-size:13px; font-weight:500; }
+.fee-dialog-summary dd { margin:0; overflow-wrap:anywhere; color:#283246; font-size:20px; font-weight:700; font-variant-numeric:tabular-nums; letter-spacing:0; }
+.fee-dialog-summary > div:nth-child(3) dt { color:#6578c5; }
+.fee-dialog-summary > div:nth-child(3) dd { color:#405fd8; font-size:22px; }
+.fee-dialog-table { margin-top:16px; overflow:hidden; border-radius:10px; box-shadow:0 5px 18px rgba(51,65,85,.04); }
+.fee-dialog-table :deep(.el-table__header th.el-table__cell) { height:42px; padding:9px 0; background:linear-gradient(180deg,#f8f9fc,#f3f5f9); color:#697386; font-size:13px; font-weight:650; }
+.fee-dialog-table :deep(.el-table__body td.el-table__cell) { height:82px; padding:9px 0; color:#515a6c; font-size:14px; font-variant-numeric:tabular-nums; }
+.fee-dialog-table :deep(.el-table__body td:nth-child(7)), .fee-dialog-table :deep(.el-table__body td:nth-child(8)) { color:#34466b; font-weight:650; }
+.fee-dialog-table :deep(.cell) { line-height:1.6; }
+.fee-confirm-notice { display:flex; align-items:center; gap:10px; margin-top:14px; padding:10px 14px; border:1px solid #f5dfba; border-radius:9px; background:linear-gradient(90deg,#fff9ef,#fffaf2); color:#c6790c; font-size:14px; font-weight:500; }
+.fee-confirm-notice > svg { flex:0 0 auto; fill:#eda332; color:#fff; filter:drop-shadow(0 2px 3px rgba(233,154,37,.25)); }
+.fee-confirm-notice.is-confirmed { border-color:#b7dfc2; background:#f1faf3; color:#2d8a46; }
+.fee-confirm-notice.is-confirmed > svg { fill:#4eae67; }
 .pallet-location-list { margin-top: 9px; border-top: 1px solid var(--border); }
 .pallet-location-list article { display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: 11px; padding: 12px 0; border-bottom: 1px solid var(--border); }
 .pallet-location-list article > svg { color: var(--primary); }
@@ -312,7 +312,26 @@ async function confirmFee() {
 .inbound-public-remark strong { color: var(--navy); font-size: 11px; }
 .inbound-public-remark p { margin: 5px 0 0; overflow-wrap: anywhere; color: var(--muted); font-size: 11px; line-height: 1.55; white-space: pre-wrap; }
 
+:global(.billing-confirm-dialog) { max-height:calc(100vh - 40px); overflow:hidden; border-radius:14px; box-shadow:0 28px 90px rgba(17,24,39,.33); }
+:global(.billing-confirm-dialog .el-dialog__header) { display:flex; align-items:center; min-height:66px; margin:0; padding:16px 22px 14px; border-bottom:1px solid #edf0f5; }
+:global(.billing-confirm-dialog .el-dialog__title) { color:#252b38; font-size:22px; font-weight:700; line-height:1.4; letter-spacing:0; }
+:global(.billing-confirm-dialog .el-dialog__headerbtn) { top:14px; right:20px; width:36px; height:36px; border-radius:50%; background:#f5f6f9; }
+:global(.billing-confirm-dialog .el-dialog__headerbtn:hover) { background:#e9edfa; }
+:global(.billing-confirm-dialog .el-dialog__headerbtn .el-dialog__close) { color:#8b92a0; font-size:22px; }
+:global(.billing-confirm-dialog .el-dialog__body) { max-height:calc(100vh - 174px); overflow:auto; padding:18px 22px; }
+:global(.billing-confirm-dialog .el-dialog__footer) { padding:14px 22px 16px; border-top:1px solid #edf0f5; }
+:global(.billing-confirm-dialog .el-dialog__footer .el-button) { min-height:40px; padding:0 20px; border-radius:8px; font-size:14px; font-weight:650; }
+:global(.billing-confirm-dialog .el-dialog__footer .el-button--primary) { min-width:168px; border-color:#526ee8; background:linear-gradient(135deg,#647fec,#526ee8); box-shadow:0 7px 16px rgba(82,110,232,.17); }
+
 @media (max-width: 720px) {
+  .fee-dialog-summary { grid-template-columns: 1fr; gap: 8px; }
+  .fee-dialog-summary dd, .fee-dialog-summary > div:nth-child(3) dd { font-size: 18px; }
+  :global(.billing-confirm-dialog) { width:calc(100vw - 16px) !important; max-height:calc(100vh - 16px); }
+  :global(.billing-confirm-dialog .el-dialog__header) { padding:14px 16px 11px; }
+  :global(.billing-confirm-dialog .el-dialog__title) { font-size:19px; }
+  :global(.billing-confirm-dialog .el-dialog__body) { max-height:calc(100vh - 145px); padding:14px 16px; }
+  :global(.billing-confirm-dialog .el-dialog__footer) { padding:12px 16px; }
+  :global(.billing-confirm-dialog .el-dialog__footer .el-button) { min-height:38px; padding:0 14px; font-size:13px; }
   .inbound-billing-state { grid-template-columns: auto minmax(0, 1fr); }
   .inbound-billing-state .el-button { grid-column: 1 / -1; width: 100%; min-height: 44px; }
   .inbound-overview, .inbound-measurements, .fee-calculation-grid { grid-template-columns: 1fr; }

src/modules/first-leg/components/InboundCodeAssociationDialog.test.mjs

@@ -6,6 +6,8 @@ const source = readFileSync(new URL('./InboundCodeAssociationDialog.vue', import
 
 test('loads only the customer-scoped server association and fails closed', () => {
   assert.match(source, /getMerchantInboundCodeAssociation\(inboundCode\)/)
+  assert.match(source, /getFirstLegStatusLabel\(association\.orderStatus\)/)
+  assert.doesNotMatch(source, /FIRST_LEG_ORDER_STATUSES/)
   assert.match(source, /association\.value = null/)
   assert.match(source, /关联摘要加载失败/)
   assert.match(source, /@click="loadAssociation"/)
@@ -13,11 +15,11 @@ test('loads only the customer-scoped server association and fails closed', () =>
 })
 
 test('renders business identifiers and names without internal long identifiers', () => {
-  for (const label of ['入仓码', '订单号', '订单状态', '客户名称', '目的国家', '目的仓']) {
+  for (const label of ['入仓码', '订单状态', '客户名称', '目的国家', '目的仓']) {
     assert.match(source, new RegExp(label))
   }
   assert.match(source, /association\.inboundCode/)
-  assert.match(source, /association\.orderNo/)
+  assert.doesNotMatch(source, /association\.orderNo/)
   assert.match(source, /association\.customerName/)
   assert.match(source, /destinationWarehouseCode/)
   assert.match(source, /destinationWarehouseName/)

src/modules/first-leg/components/InboundCodeAssociationDialog.vue

@@ -1,11 +1,11 @@
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
 import { AlertTriangle, Link2, RefreshCw } from '@lucide/vue'
-import { FIRST_LEG_ORDER_STATUSES } from '@chongchong/shared'
 import {
   getMerchantInboundCodeAssociation,
   type MerchantInboundCodeAssociation,
 } from '@/modules/first-leg/api/inboundCodeAssociations'
+import { getFirstLegStatusLabel } from '@/modules/first-leg/utils/firstLegOrder'
 
 const props = defineProps<{
   modelValue: boolean
@@ -30,10 +30,6 @@ function displayValue(value: string | null | undefined) {
   return value?.trim() || '—'
 }
 
-function statusLabel(value: string) {
-  return FIRST_LEG_ORDER_STATUSES.find((item) => item.code === value)?.label ?? displayValue(value)
-}
-
 function destinationLabel(value: MerchantInboundCodeAssociation) {
   return [value.destinationWarehouseCode, value.destinationWarehouseName].filter(Boolean).join(' · ') || '—'
 }
@@ -86,8 +82,7 @@ watch(() => [props.modelValue, props.inboundCode] as const, ([open]) => {
           <div><span>入仓码</span><strong>{{ displayValue(association.inboundCode) }}</strong></div>
         </header>
         <dl class="inbound-association-grid">
-          <div><dt>订单号</dt><dd>{{ displayValue(association.orderNo) }}</dd></div>
+          <div><dt>订单状态</dt><dd>{{ getFirstLegStatusLabel(association.orderStatus) }}</dd></div>
-          <div><dt>订单状态</dt><dd>{{ statusLabel(association.orderStatus) }}</dd></div>
           <div><dt>客户名称</dt><dd>{{ displayValue(association.customerName) }}</dd></div>
           <div><dt>目的国家</dt><dd>{{ displayValue(association.destinationCountryCode) }}</dd></div>
           <div class="is-wide"><dt>目的仓</dt><dd>{{ destinationLabel(association) }}</dd></div>

src/modules/first-leg/components/OrderProgressPanel.vue

@@ -5,8 +5,6 @@ import type { FirstLegOrder } from '@/modules/first-leg/types/firstLegOrder'
 import {
   FIRST_LEG_PROGRESS_STAGES,
   getFirstLegProgressIndex,
-  getFirstLegStatusLabel,
-  getFirstLegStatusTone,
 } from '@/modules/first-leg/utils/firstLegOrder'
 
 const props = defineProps<{ order: FirstLegOrder }>()
@@ -23,43 +21,42 @@ function stageState(index: number) {
   <section class="order-progress" aria-labelledby="order-progress-title">
     <div class="progress-heading">
       <div>
-        <h3 id="order-progress-title">订单进度</h3>
+        <h3 id="order-progress-title">履约进度</h3>
-        <span>国内入仓、组托、装柜及后续履约同步</span>
+        <span>订单主节点与关联柜次统一展示</span>
       </div>
-      <el-tag :type="getFirstLegStatusTone(order.status)" effect="light">
-        {{ getFirstLegStatusLabel(order.status) }}
-      </el-tag>
     </div>
 
-    <ol class="progress-stages" aria-label="订单主状态阶段">
+    <p v-if="order.status === 'CANCELLED'" class="draft-progress-note">订单已取消，不再继续履约。</p>
+    <ol v-else class="progress-stages" aria-label="订单主状态阶段">
       <li v-for="(stage, index) in FIRST_LEG_PROGRESS_STAGES" :key="stage.code" :class="stageState(index)" :aria-current="index === currentIndex ? 'step' : undefined">
         <span class="stage-marker" aria-hidden="true"><Check v-if="index < currentIndex" :size="13" /><CircleDot v-else :size="13" /></span>
         <span class="stage-label">{{ stage.label }}</span>
       </li>
     </ol>
     <p v-if="order.status === 'DRAFT'" class="draft-progress-note">订单提交后开始记录主状态进度。</p>
-
+    <div v-if="order.status !== 'CANCELLED'" class="progress-cabinet-detail"><slot name="cabinet" /></div>
   </section>
 </template>
 
 <style scoped>
-.order-progress { margin-top: 22px; }
+.order-progress { margin-top: 14px; }
 .progress-heading { display: flex; align-items: center; }
 .progress-heading { justify-content: space-between; gap: 14px; }
 .progress-heading > div { display: flex; min-width: 0; flex-direction: column; gap: 3px; }
 .progress-heading h3 { margin: 0; color: var(--navy); }
-.progress-heading h3 { font-size: 15px; }
+.progress-heading h3 { font-size: 13px; }
 .progress-heading span { color: var(--muted); font-size: 11px; }
-.progress-stages { display: grid; grid-auto-flow: column; grid-auto-columns: minmax(76px, 1fr); margin: 16px 0 0; padding: 0; overflow-x: auto; list-style: none; }
+.progress-stages { display: grid; grid-auto-flow: column; grid-auto-columns: minmax(76px, 1fr); margin: 9px 0 0; padding: 0; overflow-x: auto; list-style: none; }
-.progress-stages li { position: relative; display: flex; min-width: 76px; align-items: center; flex-direction: column; gap: 7px; color: #96a0a6; font-size: 10px; text-align: center; }
+.progress-stages li { position: relative; display: flex; min-width: 76px; align-items: center; flex-direction: column; gap: 4px; color: #96a0a6; font-size: 10px; text-align: center; }
-.progress-stages li::before { position: absolute; top: 10px; right: 50%; left: -50%; height: 2px; background: #e1e6e8; content: ''; }
+.progress-stages li::before { position: absolute; top: 8px; right: 50%; left: -50%; height: 2px; background: #e1e6e8; content: ''; }
 .progress-stages li:first-child::before { display: none; }
 .progress-stages li.is-complete::before, .progress-stages li.is-current::before { background: var(--primary); }
-.stage-marker { position: relative; z-index: 1; display: grid; width: 22px; height: 22px; place-items: center; border: 2px solid #d9e0e2; border-radius: 50%; background: #fff; }
+.stage-marker { position: relative; z-index: 1; display: grid; width: 18px; height: 18px; place-items: center; border: 2px solid #d9e0e2; border-radius: 50%; background: #fff; }
 .is-complete .stage-marker, .is-current .stage-marker { border-color: var(--primary); color: var(--primary); }
 .is-complete .stage-marker { background: var(--primary); color: #fff; }
 .is-current .stage-label { color: var(--navy); font-weight: 700; }
-.draft-progress-note { margin: 12px 0 0; padding: 10px 12px; background: #f6f8f8; color: var(--muted); font-size: 11px; }
+.draft-progress-note { margin: 8px 0 0; padding: 7px 9px; background: #f6f8f8; color: var(--muted); font-size: 10px; }
+.progress-cabinet-detail { margin-top: 9px; }
 @media (max-width: 720px) {
   .progress-stages { grid-auto-columns: 82px; padding-bottom: 8px; }
   .progress-heading { align-items: flex-start; }

src/modules/first-leg/components/TransportFactsTable.vue

@@ -0,0 +1,32 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { MerchantTransportFragment } from '../api/unifiedOrders'
+import { customerTransportRows } from '../utils/transportFacts'
+
+const props = defineProps<{ fragments: MerchantTransportFragment[] }>()
+const rows = computed(() => customerTransportRows(props.fragments))
+function time(value: string | null) { return value ? value.replace('T', ' ') : '—' }
+</script>
+
+<template>
+  <div class="transport-facts" aria-label="实际装载片段运输节点">
+    <strong>运输节点</strong>
+    <el-table v-if="rows.length" :data="rows" row-key="key" border size="small">
+      <el-table-column prop="inboundCode" label="入仓码" min-width="155" />
+      <el-table-column prop="cabinetNo" label="柜次" width="90" />
+      <el-table-column prop="containerNo" label="集装箱号" min-width="145" />
+      <el-table-column prop="nodeLabel" label="节点" min-width="150" />
+      <el-table-column label="实际时间" min-width="175"><template #default="{ row }">{{ time(row.actualAt) }}</template></el-table-column>
+      <el-table-column label="预计时间" min-width="175"><template #default="{ row }">{{ time(row.estimatedAt) }}</template></el-table-column>
+      <el-table-column prop="location" label="地点" min-width="130" />
+      <el-table-column prop="source" label="来源" width="105" />
+    </el-table>
+    <p v-else>暂无实际装载片段的运输节点。预计时间不表示实际发生。</p>
+  </div>
+</template>
+
+<style scoped>
+.transport-facts { margin-top: 9px; }
+.transport-facts > strong { display: block; padding: 7px 0 5px; color: var(--navy); font-size: 11px; }
+.transport-facts > p { color: var(--muted); font-size: 11px; }
+</style>

src/modules/first-leg/public.ts

@@ -1,4 +1,8 @@
 export { useFirstLegOrdersStore } from './store/firstLegOrders'
+export { getMerchantFirstLegOrders, type MerchantFirstLegOrderRow } from './api/firstLeg'
+export { getMerchantUnifiedOrders, type MerchantUnifiedOrderRow } from './api/unifiedOrders'
 export { getMerchantWarehouses, type MerchantWarehouse } from './api/firstLeg'
 export { getFirstLegStatusLabel, getFirstLegStatusTone } from './utils/firstLegOrder'
 export { default as InboundCodeAssociationDialog } from './components/InboundCodeAssociationDialog.vue'
+export { default as FirstLegOrdersView } from './views/FirstLegOrdersView.vue'
+export { useCustomsPendingStore } from './store/customsPending'

src/modules/first-leg/routes.ts

@@ -1,4 +1,4 @@
-import { FileText, Ship, Zap } from '@lucide/vue'
+import { Calculator, FileText, Ship } from '@lucide/vue'
 import type { ClientModuleManifest } from '../types.ts'
 
 export const firstLegModule = {
@@ -17,10 +17,17 @@ export const firstLegModule = {
     {
       path: 'orders/first-leg/create',
       name: 'first-leg-order-create',
-      component: () => import('./views/FirstLegOrdersView.vue'),
+      component: () => import('./views/FirstLegOrderCreateHubView.vue'),
-      props: { createPage: true },
       release: 'active',
-      meta: { title: '创建订单', description: '填写发货、目的地和货物信息', permission: 'order:first-leg:create' },
+      meta: { title: '创建订单', workspaceTitle: '头程订单 · 新建', description: '填写发货、目的地和货物信息', permission: 'order:first-leg:create', keepAlive: false },
+    },
+    {
+      path: 'orders/first-leg/:orderId/detail',
+      name: 'first-leg-order-detail',
+      component: () => import('./views/FirstLegOrdersView.vue'),
+      props: { detailPage: true },
+      release: 'active',
+      meta: { title: '订单详情', workspaceTitle: '头程订单 · 详情', description: '查看入仓码、运输与履约进度', permission: 'order:first-leg:list' },
     },
     {
       path: 'orders/first-leg/:draftId/edit',
@@ -28,7 +35,7 @@ export const firstLegModule = {
       component: () => import('./views/FirstLegOrdersView.vue'),
       props: { createPage: true },
       release: 'active',
-      meta: { title: '编辑订单草稿', description: '继续完善快速下单生成的草稿明细', permission: 'order:first-leg:edit' },
+      meta: { title: '编辑订单草稿', workspaceTitle: '头程订单 · 编辑', description: '继续完善快速下单生成的草稿明细', permission: 'order:first-leg:edit' },
     },
     {
       path: 'first-leg/quick-order',
@@ -36,7 +43,22 @@ export const firstLegModule = {
       component: () => import('./views/QuickOrderView.vue'),
       release: 'active',
       meta: { title: '快速下单', description: '按渠道、目的仓和产品 SKU 快速生成订单草稿', permission: 'order:first-leg:quick-create' },
-      navigation: { key: 'first-leg-quick-order', title: '快速下单', icon: Zap },
+    },
+    {
+      path: 'first-leg/customs-documents',
+      name: 'first-leg-customs-documents',
+      component: () => import('./views/CustomsDocumentsView.vue'),
+      release: 'active',
+      meta: { title: '报关资料', description: '管理装柜后的退税报关资料与回执', permission: 'order:first-leg:customs-list' },
+      navigation: { key: 'first-leg-customs-documents', title: '报关资料', icon: FileText },
+    },
+    {
+      path: 'first-leg/sailing-prices',
+      name: 'first-leg-sailing-prices',
+      component: () => import('./views/SailingPricesView.vue'),
+      release: 'active',
+      meta: { title: '船期价格', description: '查询渠道、参考船期与预估运费', permission: 'order:first-leg:pricing-list' },
+      navigation: { key: 'first-leg-sailing-prices', title: '船期价格', icon: Calculator },
     },
   ],
 } satisfies ClientModuleManifest

src/modules/first-leg/store/customsPending.test.mjs

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+import * as pinia from 'pinia'
+const source = readFileSync(new URL('./customsPending.ts', import.meta.url), 'utf8')
+const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+function deferred() { let resolve, reject; const promise = new Promise((a,b) => { resolve=a; reject=b }); return { promise, resolve, reject } }
+function harness(t, read) {
+  const context=pinia.createPinia();pinia.setActivePinia(context);t.after(()=>pinia.disposePinia(context))
+  const deps={vue,pinia,'../api/customs':{getMerchantCustomsPendingCount:read}}, exports={}
+  new Function('require','exports',code)(id=>{assert.ok(id in deps,id);return deps[id]},exports)
+  return exports.useCustomsPendingStore()
+}
+test('does not request without a permitted identity; preserves counts while refreshing and accepts zero',async t=>{
+  const pending=deferred();let calls=0
+  const store=harness(t,()=>++calls===1?Promise.resolve(2):pending.promise)
+  await store.refresh();assert.equal(calls,0)
+  store.setScope('customer-a');await store.refresh();assert.equal(store.count,2)
+  const load=store.refresh();await store.refresh();assert.equal(calls,2);assert.equal(store.count,2)
+  pending.resolve(0);await load;assert.equal(store.count,0);assert.equal(store.loading,false)
+})
+test('logout, permission removal and account switches discard old in-flight responses',async t=>{
+  const pending=deferred();const store=harness(t,()=>pending.promise)
+  store.setScope('a');const load=store.refresh();store.setScope('')
+  pending.resolve(9);await load;assert.equal(store.count,null);assert.equal(store.error,'')
+  store.setScope('b');assert.equal(store.count,null)
+})
+test('successful mutation can force a newer refresh without being overwritten by an older query',async t=>{
+  const a=deferred(),b=deferred();let calls=0;const store=harness(t,()=>++calls===1?a.promise:b.promise)
+  store.setScope('a');const first=store.refresh();const second=store.refresh(true)
+  b.resolve(1);await second;a.resolve(2);await first;assert.equal(store.count,1)
+})
+test('failure is distinguishable from zero and retry restores authoritative count',async t=>{
+  let fail=true;const store=harness(t,()=>fail?Promise.reject(new Error('offline')):Promise.resolve(3))
+  store.setScope('a');await store.refresh();assert.equal(store.count,null);assert.notEqual(store.error,'')
+  fail=false;await store.refresh();assert.equal(store.count,3);assert.equal(store.error,'')
+})

src/modules/first-leg/store/customsPending.ts

@@ -0,0 +1,40 @@
+import { ref } from 'vue'
+import { defineStore } from 'pinia'
+import { getMerchantCustomsPendingCount } from '../api/customs'
+
+export const useCustomsPendingStore = defineStore('client-customs-pending', () => {
+  const count = ref<number | null>(null)
+  const loading = ref(false)
+  const error = ref('')
+  let scope = ''
+  let requestVersion = 0
+
+  function setScope(value: string) {
+    if (scope === value) return
+    scope = value
+    requestVersion++
+    count.value = null
+    error.value = ''
+    loading.value = false
+  }
+
+  async function refresh(force = false) {
+    if (!scope || (loading.value && !force)) return
+    const request = ++requestVersion
+    loading.value = true
+    try {
+      const result = await getMerchantCustomsPendingCount()
+      if (request !== requestVersion) return
+      count.value = result
+      error.value = ''
+    } catch {
+      if (request !== requestVersion) return
+      count.value = null
+      error.value = '报关待办数量加载失败，请进入报关资料刷新'
+    } finally {
+      if (request === requestVersion) loading.value = false
+    }
+  }
+
+  return { count, loading, error, setScope, refresh }
+})

src/modules/first-leg/store/firstLegDraftCommands.test.mjs

@@ -0,0 +1,430 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+import * as pinia from 'pinia'
+
+function compile(path, dependencies) {
+  const source = readFileSync(new URL(path, import.meta.url), 'utf8')
+  const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+  const exports = {}
+  new Function('require', 'exports', code)(id => { assert.ok(id in dependencies, id); return dependencies[id] }, exports)
+  return exports
+}
+function harness(t) {
+  const context = pinia.createPinia(); pinia.setActivePinia(context)
+  t.after(() => pinia.disposePinia(context))
+  const calls = []
+  const behavior = { failWrite: false, failRead: false, version: 9, status: 'DRAFT' }
+  const api = compile('../api/firstLeg.ts', { '@/api/http': { apiRequest: async config => {
+    calls.push(structuredClone(config))
+    if (config.method === 'GET') {
+      if (behavior.failRead) throw new Error('读取失败')
+      return { order: { id: 'one', orderNo: 'FL-ONE', version: behavior.version, status: behavior.status, receivingWarehouseId: 'warehouse', receivingWarehouseAddress: behavior.receivingWarehouseAddress, destinationCountryCode: 'US' }, cargoes: [] }
+    }
+    if (behavior.failWrite || (behavior.failSubmit && config.url.endsWith('/submit'))) throw new Error('响应丢失')
+    if (config.url.endsWith('/submit') && behavior.failSubmitRead) behavior.failRead = true
+    if (config.method === 'POST' && config.url === '/merchant/v1/orders/first-leg') return 'one'
+  } } })
+  const module = compile('./firstLegOrders.ts', {
+    vue, pinia,
+    '@/modules/first-leg/api/firstLeg': api,
+    '@/modules/first-leg/api/unifiedOrders': {
+      getMerchantUnifiedOrder: async () => ({ summary: { orderId: 'one', mainStatus: null }, order: { order: { id: 'one', status: behavior.status, version: behavior.version, receivingWarehouseId: 'warehouse', receivingWarehouseAddress: behavior.receivingWarehouseAddress } }, timeline: [] }),
+    },
+    '@/modules/first-leg/utils/firstLegOrder': { canClientEditFirstLegOrder: status => status === 'DRAFT', getFirstLegStatusLabel: value => value },
+    '@/modules/first-leg/utils/warehousePagination': {},
+  })
+  const store = module.useFirstLegOrdersStore()
+  store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC' }]
+  const draft = { receivingWarehouseId: 'warehouse', destinationType: 'PRIVATE', destinationCountryCode: 'US', items: [], customerRemark: '原草稿' }
+  return { store, api, calls, behavior, draft }
+}
+
+function displayedWarehouseAddress(order) {
+  const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
+  const expressions = [...view.matchAll(/\{\{ (detailOrder\.receivingWarehouseSnapshot\.(?:province|city|address)) \}\}/g)]
+  assert.equal(expressions.length, 3)
+  return expressions.map(([, expression]) => new Function('detailOrder', `return ${expression}`)(order)).join('')
+}
+
+test('complete address is identical for cold unified, warm unified, raw detail and remark-only save', async t => {
+  const h = harness(t)
+  const fullAddress = 'CN 浙江省 义乌市 仓库路 8 号 322000'
+  h.behavior.receivingWarehouseAddress = fullAddress
+  h.store.warehouses = []
+  const cold = await h.store.loadDetail('one')
+  assert.equal(displayedWarehouseAddress(cold), fullAddress)
+  h.store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC', province: '浙江省', city: '义乌市', address: '主档已更新的地址' }]
+  h.store.orders = []
+  const warm = await h.store.loadDetail('one')
+  const raw = await h.store.loadDraftDetail('one')
+  for (const detail of [warm, raw]) {
+    assert.equal(displayedWarehouseAddress(detail), fullAddress)
+    assert.equal(detail.receivingWarehouseSnapshot.province, '')
+    assert.equal(detail.receivingWarehouseSnapshot.city, '')
+  }
+  const session = h.store.beginDraftEdit(raw)
+  h.draft.customerRemark = '仅修改备注'
+  const saved = await h.store.saveDraft(h.draft, '客户', 'one', session)
+  assert.equal(displayedWarehouseAddress(saved), fullAddress)
+  const write = h.calls.find(call => call.method === 'PUT')
+  assert.equal(write.data.draft.customerRemark, '仅修改备注')
+  assert.equal(Object.hasOwn(write.data.draft, 'receivingWarehouseAddress'), false)
+  assert.equal(h.behavior.receivingWarehouseAddress, fullAddress)
+  assert.equal(h.store.warehouses[0].province, '浙江省')
+  assert.equal(h.store.warehouses[0].address, '主档已更新的地址')
+})
+
+test('structured master address stays structured when no order address snapshot exists', async t => {
+  const h = harness(t)
+  h.store.warehouses = [{ id: 'warehouse', name: '国内仓', province: '浙江省', city: '义乌市', address: '仓库路 8 号', warehouseType: 'DOMESTIC' }]
+  const detail = await h.store.loadDetail('one')
+  assert.equal(detail.receivingWarehouseSnapshot.province, '浙江省')
+  assert.equal(detail.receivingWarehouseSnapshot.city, '义乌市')
+  assert.equal(detail.receivingWarehouseSnapshot.address, '仓库路 8 号')
+  assert.equal(displayedWarehouseAddress(detail), '浙江省义乌市仓库路 8 号')
+})
+
+test('raw and unified cancelled detail remain CANCELLED even when unified mainStatus is null', async t => {
+  const h = harness(t)
+  h.behavior.status = 'CANCELLED'
+  const raw = await h.store.loadDraftDetail('one')
+  assert.equal(raw.status, 'CANCELLED')
+  const unified = await h.store.loadDetail('one')
+  assert.equal(unified.status, 'CANCELLED')
+  h.behavior.status = 'APPROVED'
+  const unknown = await h.store.loadDetail('one')
+  assert.notEqual(unknown.status, 'CANCELLED', 'unknown summary must not be reclassified as cancellation')
+})
+
+test('fresh direct draft detail preserves raw DRAFT with null unified summary and opens an edit session', async t => {
+  const h = harness(t)
+  assert.equal(h.store.orders.length, 0)
+  const direct = await h.store.loadDetail('one')
+  assert.equal(direct.status, 'DRAFT')
+  assert.equal(h.store.beginDraftEdit(direct).expectedVersion, 9)
+  h.store.orders = []
+  const refreshed = await h.store.loadDetail('one')
+  assert.equal(refreshed.status, 'DRAFT')
+  h.store.orders = []
+  h.behavior.status = 'APPROVED'
+  const unknown = await h.store.loadDetail('one')
+  assert.notEqual(unknown.status, 'DRAFT')
+  assert.notEqual(unknown.status, 'CANCELLED')
+  assert.throws(() => h.store.beginDraftEdit(unknown), /重新打开/)
+})
+
+test('cancelled detail summary has no pending overseas synchronization entries', () => {
+  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
+  const script = source.match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const ast = ts.createSourceFile('view.ts', script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const declaration = ast.statements.flatMap(node => ts.isVariableStatement(node) ? [...node.declarationList.declarations] : []).find(node => node.name.getText(ast) === 'progressSummaryItems')
+  const code = ts.transpileModule('const progressSummaryItems = ' + declaration.initializer.getText(ast), { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const summary = new Function('computed', 'detailOrder', code + '; return progressSummaryItems.value')(vue.computed, { value: { status: 'CANCELLED' } })
+  assert.deepEqual(summary, [])
+})
+
+test('edit freezes detail version rather than cached list version and replays same key/body after uncertain result', async t => {
+  const h = harness(t)
+  const original = await h.store.loadDraftDetail('one')
+  const session = h.store.beginDraftEdit(original)
+  h.store.orders = [{ ...original, version: 0 }]
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.saveDraft(h.draft, '测试企业', 'one', session), /响应丢失/)
+  const first = h.calls.find(call => call.method === 'PUT')
+  assert.equal(first.data.expectedVersion, 9)
+  assert.equal(first.data.draft.customerRemark, '原草稿')
+  assert.ok(first.headers['Idempotency-Key'])
+  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT'], 'no pre-save version refresh')
+  h.behavior.failWrite = false; h.behavior.version = 10
+  const result = await h.store.saveDraft(h.draft, '测试企业', 'one', session)
+  const writes = h.calls.filter(call => call.method === 'PUT')
+  assert.deepEqual(writes[1], first)
+  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT', 'GET', 'PUT', 'GET'])
+  assert.equal(result.version, 10)
+})
+
+test('changed retry payload or missing edit session fails closed without issuing a new write', async t => {
+  const h = harness(t)
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one'), /重新打开/)
+  assert.equal(h.calls.length, 0)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session))
+  h.draft.customerRemark = '不同内容'
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /重试原内容/)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+  assert.equal(session.expectedVersion, 9)
+  assert.ok(Object.isFrozen(session))
+})
+
+test('read failure after successful edit preserves the same command for retry', async t => {
+  const h = harness(t)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  h.behavior.failRead = true
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /读取失败/)
+  h.behavior.failRead = false
+  await h.store.saveDraft(h.draft, '客户', 'one', session)
+  const writes = h.calls.filter(call => call.method === 'PUT')
+  assert.deepEqual(writes[0], writes[1])
+})
+
+test('cancel forwards version and reason without rejecting submitted orders locally; retry keeps key and body', async t => {
+  const h = harness(t)
+  h.behavior.status = 'SUBMITTED'
+  h.store.orders = [{ id: 'one', status: 'PENDING_REVIEW', version: 0 }]
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.cancelOrder('one', 12, '客户要求取消'), /响应丢失/)
+  const first = h.calls[0]
+  assert.equal(first.method, 'POST')
+  assert.equal(first.url, '/merchant/v1/orders/first-leg/one/cancel')
+  assert.deepEqual(first.data, { expectedVersion: 12, reason: '客户要求取消' })
+  await assert.rejects(h.store.cancelOrder('one', 13, '其他原因'), /原版本和原因/)
+  assert.equal(h.calls.length, 1)
+  h.behavior.failWrite = false
+  await h.store.cancelOrder('one', 12, '客户要求取消')
+  assert.deepEqual(h.calls[2], first)
+  assert.equal(h.calls[1].method, 'GET')
+  assert.equal(h.store.orders.length, 0)
+})
+
+test('cancel requires a detail version and a nonempty reason', async t => {
+  const h = harness(t)
+  await assert.rejects(h.store.cancelOrder('one', undefined, '理由'))
+  await assert.rejects(h.store.cancelOrder('one', 1, ' '))
+  assert.equal(h.calls.length, 0)
+})
+
+test('cancellation decision reads raw server status and version including SUBMITTED', async t => {
+  const h = harness(t)
+  for (const status of ['DRAFT', 'SUBMITTED', 'APPROVED', 'ACCEPTED', 'REJECTED']) {
+    h.behavior.status = status
+    const target = await h.store.prepareCancellation('one')
+    assert.equal(target.expectedVersion, 9)
+    assert.equal(target.businessNo, 'FL-ONE')
+  }
+  for (const status of ['PROCESSING', 'COMPLETED', 'CANCELLED']) {
+    h.behavior.status = status
+    await assert.rejects(h.store.prepareCancellation('one'), /不允许取消/)
+  }
+  assert.ok(h.calls.every(call => call.method === 'GET'))
+})
+
+function cancellationViewHarness() {
+  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const ast = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const functions = ast.statements.filter(node => ts.isFunctionDeclaration(node) && ['canOfferCancellation', 'cancelOrder'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
+  const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const calls = [], messages = [], prompts = []
+  const canCancelOrder = vue.ref(true), cancellingOrderId = vue.ref(''), pendingCancellation = vue.shallowRef()
+  class ApiError extends Error { constructor() { super('订单版本已变化'); this.code = 'A0409'; this.status = 409 } }
+  const behavior = { error: null }
+  const store = {
+    prepareCancellation: async id => { calls.push(['prepare', id]); return { id, expectedVersion: 12, businessNo: 'FL-ONE', statusLabel: '审核中' } },
+    cancelOrder: async (...args) => { calls.push(['cancel', ...args]); if (behavior.error) throw behavior.error },
+    load: async query => calls.push(['load', query]),
+  }
+  const ElMessageBox = {
+    prompt: async (message, title, options) => { prompts.push({ message, title, options }); return { value: '客户申请取消' } },
+    confirm: async (...args) => calls.push(['confirm', ...args]),
+  }
+  const ElMessage = { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) }
+  const globals = { canCancelOrder, cancellingOrderId, pendingCancellation, store, ElMessageBox, ElMessage, ApiError,
+    loadOrderPage: async () => calls.push(['load']),
+    isDetailPage: vue.ref(true), router: { push: async route => calls.push(['route', route]) } }
+  const handler = new Function(...Object.keys(globals), code + '\nreturn cancelOrder')(...Object.values(globals))
+  return { handler, calls, messages, prompts, canCancelOrder, pendingCancellation, behavior, ApiError }
+}
+
+test('cancel UI uses mandatory-reason centered prompt and refreshes after successful submitted-order cancellation', async () => {
+  const h = cancellationViewHarness()
+  await h.handler({ id: 'one', status: 'PENDING_REVIEW' })
+  assert.match(h.prompts[0].message, /FL-ONE.*审核中/)
+  const validate = h.prompts[0].options.inputValidator
+  assert.notEqual(validate(' '), true)
+  assert.notEqual(validate('x'.repeat(501)), true)
+  assert.equal(validate('合理原因'), true)
+  assert.deepEqual(h.calls.map(call => call[0]), ['prepare', 'cancel', 'load', 'route'])
+  assert.deepEqual(h.calls[1], ['cancel', 'one', 12, '客户申请取消'])
+})
+
+test('cancel UI keeps an uncertain command for explicit retry, but conflict requires a fresh decision', async () => {
+  const h = cancellationViewHarness()
+  const order = { id: 'one', status: 'DRAFT' }
+  h.behavior.error = new Error('网络无响应')
+  await h.handler(order)
+  assert.equal(h.pendingCancellation.value.expectedVersion, 12)
+  h.behavior.error = null
+  await h.handler(order)
+  assert.equal(h.prompts.length, 1)
+  assert.equal(h.calls.filter(call => call[0] === 'prepare').length, 1)
+  assert.equal(h.calls.filter(call => call[0] === 'confirm').length, 1)
+  assert.deepEqual(h.calls.filter(call => call[0] === 'cancel')[0], h.calls.filter(call => call[0] === 'cancel')[1])
+  h.behavior.error = new h.ApiError()
+  await h.handler(order)
+  assert.equal(h.pendingCancellation.value, undefined)
+  assert.match(h.messages.at(-1), /刷新订单后重新确认/)
+})
+
+test('cancel UI blocks unavailable permission and irreversible visible stages before reads or writes', async () => {
+  const h = cancellationViewHarness()
+  h.canCancelOrder.value = false
+  await h.handler({ id: 'one', status: 'DRAFT' })
+  h.canCancelOrder.value = true
+  await h.handler({ id: 'one', status: 'LOADED' })
+  assert.equal(h.calls.length, 0)
+  assert.equal(h.prompts.length, 0)
+})
+
+test('both editor entry points capture detail sessions and both save paths pass them', () => {
+  const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
+  assert.equal((view.match(/editingSession\.value = store\.beginDraftEdit\(detailedOrder\)/g) ?? []).length, 2)
+  assert.equal((view.match(/store\.saveDraft(?:ForSubmission)?\(cloneDraft\(form\), tenantStore\.company\.companyName, editingId\.value, editingSession\.value\)/g) ?? []).length, 2)
+})
+
+test('submit reads raw detail version rather than list zero and replays original key and version after timeout', async t => {
+  const h = harness(t)
+  h.store.orders = [{ id: 'one', status: 'DRAFT', version: 0 }]
+  h.behavior.failSubmit = true
+  await assert.rejects(h.store.submitSaved('one', 'ACTIVE'), /响应丢失/)
+  const first = h.calls[1]
+  assert.equal(first.url, '/merchant/v1/orders/first-leg/one/submit')
+  assert.deepEqual(first.data, { expectedVersion: 9 })
+  assert.ok(first.headers['Idempotency-Key'])
+  h.behavior.version = 10; h.behavior.status = 'SUBMITTED'; h.behavior.failSubmit = false
+  await h.store.submitSaved('one', 'ACTIVE')
+  assert.deepEqual(h.calls[3], first)
+  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'POST', 'GET', 'POST', 'GET'])
+  assert.equal(h.store.hasPendingSubmission('one'), false)
+})
+
+test('submit refuses missing version or non-draft first decision and preserves command after failed readback', async t => {
+  const h = harness(t)
+  for (const version of [undefined, -1, 1.5]) {
+    h.behavior.version = version
+    await assert.rejects(h.store.submitSaved('one'), /版本缺失/)
+  }
+  h.behavior.version = 0; h.behavior.status = 'SUBMITTED'
+  await assert.rejects(h.store.submitSaved('one'), /不是草稿/)
+  assert.ok(h.calls.every(call => call.method === 'GET'))
+  h.behavior.status = 'DRAFT'; h.behavior.failSubmitRead = true
+  await assert.rejects(h.store.submitSaved('one'), /读取失败/)
+  assert.equal(h.store.hasPendingSubmission('one'), true)
+  h.behavior.failRead = false; h.behavior.failSubmitRead = false
+  await h.store.submitSaved('one')
+  const posts = h.calls.filter(call => call.method === 'POST')
+  assert.deepEqual(posts[0], posts[1])
+  assert.deepEqual(posts[0].data, { expectedVersion: 0 }, 'raw detail zero is valid')
+})
+
+test('save then submit retries without another save and changed form requires an explicit new decision', async t => {
+  const h = harness(t)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  await h.store.saveDraftForSubmission(h.draft, '客户', 'one', session)
+  h.behavior.failSubmit = true
+  await assert.rejects(h.store.submitSaved('one'))
+  const first = h.calls.find(call => call.url.endsWith('/submit'))
+  await h.store.saveDraftForSubmission(h.draft, '客户', 'one', session)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+  h.draft.customerRemark = '新决定'
+  await assert.rejects(h.store.saveDraftForSubmission(h.draft, '客户', 'one', session), /重新编辑/)
+  h.behavior.status = 'SUBMITTED'
+  await assert.rejects(h.store.beginNewSubmissionEdit('one'), /不能重新编辑/)
+  assert.equal(h.store.hasPendingSubmission('one'), true)
+  h.behavior.status = 'DRAFT'; h.behavior.version = 12
+  const newSession = await h.store.beginNewSubmissionEdit('one')
+  assert.equal(newSession.expectedVersion, 12)
+  await h.store.saveDraftForSubmission(h.draft, '客户', 'one', newSession)
+  h.behavior.version = 13; h.behavior.failSubmit = false
+  await h.store.submitSaved('one')
+  const posts = h.calls.filter(call => call.url.endsWith('/submit'))
+  assert.notEqual(posts[1].headers['Idempotency-Key'], first.headers['Idempotency-Key'])
+  assert.deepEqual(posts[1].data, { expectedVersion: 13 })
+})
+
+test('failed initial submit read does not resave the prepared draft on retry', async t => {
+  const h = harness(t)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  await h.store.saveDraftForSubmission(h.draft, '客户', 'one', session)
+  h.behavior.failRead = true
+  await assert.rejects(h.store.submitSaved('one'))
+  await h.store.saveDraftForSubmission(h.draft, '客户', 'one', session)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+})
+
+async function submissionViewHarness(t) {
+  const h = harness(t)
+  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const ast = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const functions = ast.statements.filter(node => ts.isFunctionDeclaration(node) && ['submitOrder', 'confirmSubmissionEdit', 'submitSelectedDraftOrders'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
+  const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const messages = [], confirmations = []
+  const globals = {
+    store: h.store, saving: vue.ref(false), form: h.draft, cloneDraft: draft => structuredClone(draft),
+    editingId: vue.ref('one'), editingSession: vue.shallowRef(h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))),
+    companySubmissionBlocked: vue.ref(false), companyAuditLoaded: vue.ref(true), tenantStore: { company: { companyName: '客户', auditStatus: 'ACTIVE' } },
+    validateEditorForm: async () => true, markEditorClean: () => {}, editorOpen: vue.ref(true), isCreatePage: vue.ref(false), loadPageData: async () => {},
+    batchSubmitting: vue.ref(false), selectedDraftOrders: vue.ref([{ id: 'one', version: 0 }]), pendingBatchSubmissionIds: vue.ref([]),
+    searchOrders: async () => { globals.selectedDraftOrders.value = [] }, appliedFilters: vue.ref({}),
+    ElMessageBox: { confirm: async message => { confirmations.push(message); if (h.behavior.cancelConfirm) throw 'cancel' } },
+    ElMessage: { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) },
+  }
+  const handlers = new Function(...Object.keys(globals), code + '\nreturn {submitOrder, submitSelectedDraftOrders}')(...Object.values(globals))
+  return { ...h, ...handlers, globals, messages, confirmations }
+}
+
+test('real editor submit handler retries original submission without PUT and requires confirmation for changed form', async t => {
+  const h = await submissionViewHarness(t)
+  h.behavior.failSubmit = true
+  await h.submitOrder()
+  await h.submitOrder()
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+  const posts = h.calls.filter(call => call.url.endsWith('/submit'))
+  assert.deepEqual(posts[0], posts[1])
+  h.draft.customerRemark = '修改后的决定'
+  h.behavior.cancelConfirm = true
+  await h.submitOrder()
+  assert.equal(h.confirmations.length, 1)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+  h.behavior.cancelConfirm = false; h.behavior.failSubmit = false; h.behavior.version = 12
+  await h.submitOrder()
+  assert.equal(h.confirmations.length, 2)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 2)
+  const last = h.calls.filter(call => call.url.endsWith('/submit')).at(-1)
+  assert.deepEqual(last.data, { expectedVersion: 12 })
+  assert.notEqual(last.headers['Idempotency-Key'], posts[0].headers['Idempotency-Key'])
+  assert.equal(h.globals.saving.value, false)
+})
+
+test('real batch handler retains uncertain IDs across list refresh and retries original commands even if now submitted', async t => {
+  const h = await submissionViewHarness(t)
+  h.behavior.failSubmit = true
+  await h.submitSelectedDraftOrders()
+  assert.deepEqual(h.globals.pendingBatchSubmissionIds.value, ['one'])
+  assert.deepEqual(h.globals.selectedDraftOrders.value, [])
+  h.behavior.failSubmit = false; h.behavior.status = 'SUBMITTED'; h.behavior.version = 10
+  await h.submitSelectedDraftOrders()
+  const posts = h.calls.filter(call => call.url.endsWith('/submit'))
+  assert.equal(posts.length, 2)
+  assert.deepEqual(posts[1], posts[0])
+  assert.deepEqual(posts[0].data, { expectedVersion: 9 })
+  assert.deepEqual(h.globals.pendingBatchSubmissionIds.value, [])
+  assert.equal(h.globals.batchSubmitting.value, false)
+})
+
+test('real new-order handler creates once and retries the saved order submission with the original version', async t => {
+  const h = await submissionViewHarness(t)
+  h.globals.editingId.value = undefined; h.globals.editingSession.value = undefined
+  h.behavior.version = 0; h.behavior.failSubmit = true
+  await h.submitOrder()
+  assert.equal(h.globals.editingId.value, 'one')
+  h.behavior.version = 1; h.behavior.status = 'SUBMITTED'; h.behavior.failSubmit = false
+  await h.submitOrder()
+  assert.equal(h.calls.filter(call => call.method === 'POST' && call.url === '/merchant/v1/orders/first-leg').length, 1)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 0)
+  const posts = h.calls.filter(call => call.url.endsWith('/submit'))
+  assert.deepEqual(posts[0], posts[1])
+  assert.deepEqual(posts[0].data, { expectedVersion: 0 })
+})

src/modules/first-leg/store/firstLegOrders.test.mjs

@@ -1,27 +1,36 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import test from 'node:test'
+import { runInNewContext } from 'node:vm'
+import ts from 'typescript'
 
 const storeSource = readFileSync(new URL('./firstLegOrders.ts', import.meta.url), 'utf8')
 const apiSource = readFileSync(new URL('../api/firstLeg.ts', import.meta.url), 'utf8')
 const unifiedApiSource = readFileSync(new URL('../api/unifiedOrders.ts', import.meta.url), 'utf8')
 
-test('maps the first-leg aggregate list fields without loading detail rows', () => {
+test('renders estimated sailing from the current API without substituting actual departure', () => {
-  assert.match(apiSource, /interface MerchantFirstLegOrderRow/)
+  const mapper = storeSource.slice(storeSource.indexOf('function businessSummary('), storeSource.indexOf('\nconst unifiedActionLabels'))
-  assert.match(apiSource, /skuNos: string \| string\[\] \| null/)
+  const javascript = ts.transpileModule(mapper, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
-  assert.match(apiSource, /cargoes\?: Array<\{ skuNo\?: string \| null \}>/)
+  const map = runInNewContext(`${javascript}; businessSummary`)
-  assert.match(apiSource, /apiRequest<PageResult<MerchantFirstLegOrderRow>>/)
+  const transport = {
-  assert.match(storeSource, /function mapFirstLegOrderRow/)
+    vesselName: 'REASSIGNED', voyageNo: 'V02',
-  for (const field of ['inboundId', 'inboundCode', 'channelName', 'destinationWarehouseName', 'pickupMethod', 'packageCount', 'expressCompany', 'trackingNo', 'totalGrossWeightKg', 'totalNetWeightKg', 'totalVolumeCbm', 'totalQuantity', 'remark', 'shipmentId', 'referenceId', 'createdAt']) {
+    estimatedSailingAt: '2026-10-07T08:00:00', actualSailingAt: '2026-10-08T09:00:00',
-    assert.match(storeSource, new RegExp(`row\\.${field}`))
+    effectiveSailingAt: '2026-10-08T09:00:00', effectiveSailingAtEstimated: false,
+    estimatedPortArrivalAt: '2026-10-27T08:00:00', actualPortArrivalAt: null,
   }
-  assert.match(storeSource, /row\.skuNos/)
+  const mapped = map({ transport })
-  assert.match(storeSource, /row\.cargoes/)
+  assert.equal(mapped.estimatedSailingAt, transport.estimatedSailingAt)
-  assert.match(storeSource, /chargeableWeightKg: null/)
+  assert.equal(mapped.estimatedPortArrivalAt, transport.estimatedPortArrivalAt)
-  assert.match(storeSource, /chargeableVolumeCbm: null/)
+  assert.equal(mapped.vesselName, 'REASSIGNED')
-  assert.match(apiSource, /pickupMethod: ApiPickupMethod \\| null/)
+  assert.equal(mapped.voyageNo, 'V02')
-  assert.match(storeSource, /orderResult\.value\.records\.map\(mapFirstLegOrderRow\)/)
+  assert.equal(map().estimatedSailingAt, '')
-  assert.match(storeSource, /orderResult\.value\.records\.map\(\(item\) => mapUnifiedOrderRow\(item, warehouses\.value\)\)/)
+  assert.equal(map({ transport: null }).estimatedPortArrivalAt, '')
+})
+
+test('maps the current workbench row without loading detail rows', () => {
+  assert.match(storeSource, /result\.page\.records\.map\(item => mapUnifiedOrderRow\(item, warehouses\.value\)\)/)
+  assert.match(storeSource, /version: summary\.orderVersion/)
+  assert.doesNotMatch(storeSource, /function mapFirstLegOrderRow/)
 })
 
 test('declares the documented merchant warehouse and first-leg endpoints', () => {
@@ -64,14 +73,10 @@ test('maps transport and status fields instead of treating container mode as tra
   assert.doesNotMatch(storeSource, /status === 'COMPLETED'\) return 'DELIVERED'/)
 })
 
-test('prefers unified reads and only falls back to the real legacy API when C02 is unavailable', () => {
+test('uses only the formal workbench read and surfaces failures', () => {
+  assert.match(storeSource, /getMerchantOrderWorkbench\(query\)/)
   assert.match(storeSource, /orders\.value = \[\]/)
-  assert.match(storeSource, /warehouses\.value = \[\]/)
+  assert.doesNotMatch(storeSource, /isUnifiedOrderQueryUnavailable|getOrdersForClient|getMerchantFirstLegOrders|initialOrders/)
-  assert.match(storeSource, /Promise\.allSettled\(\[getOrdersForClient\(query\), loadWarehouseType\('DOMESTIC', true\)\]\)/)
-  assert.match(storeSource, /getMerchantUnifiedOrders\(unifiedQuery\)/)
-  assert.match(storeSource, /isUnifiedOrderQueryUnavailable\(error\)/)
-  assert.match(storeSource, /getMerchantFirstLegOrders\(legacyQuery\(query\)\)/)
-  assert.doesNotMatch(storeSource, /DEMO_PLATFORM_RECEIVING_WAREHOUSES|initialOrders/)
 })
 
 test('declares the final C02 row and detail contract in the API adapter', () => {
@@ -86,13 +91,14 @@ test('declares the final C02 row and detail contract in the API adapter', () =>
   for (const field of ['pickupMethod', 'requestedPickupAt', 'containerMode', 'destinationType', 'destinationCode', 'skuNos', 'totalQuantity', 'totalNetWeightKg', 'chargeableVolumeCbm', 'inboundCompletedAt', 'shipmentId', 'referenceId']) {
     assert.match(unifiedApiSource, new RegExp(`${field}:`))
   }
+  assert.match(unifiedApiSource, /taxMode: ApiTaxMode \| null/)
+  assert.match(unifiedApiSource, /customsInspection: boolean \| null/)
   assert.match(unifiedApiSource, /loadingVersion: number/)
   assert.match(unifiedApiSource, /pickingVersion: number/)
   assert.match(unifiedApiSource, /summary: MerchantUnifiedOrderRow/)
   assert.match(unifiedApiSource, /order: MerchantFirstLegOrderDetail/)
   assert.match(unifiedApiSource, /timeline: MerchantUnifiedTimelineEvent\[\]/)
   assert.match(unifiedApiSource, /customNodes\?: MerchantUnifiedCustomNode\[\]/)
-  assert.match(unifiedApiSource, /error\.status === 404 \|\| error\.code === 'A0404'/)
 })
 
 test('keeps unified order pagination valid when the store omits page and size', () => {
@@ -100,25 +106,18 @@ test('keeps unified order pagination valid when the store omits page and size',
   assert.match(unifiedApiSource, /params: \{ page: page \?\? 1, size: size \?\? 200, \.\.\.filters \}/)
 })
 
-test('keeps drafts on the legacy read path without assigning a unified main status', () => {
+test('draft editing reads the order aggregate while navigation uses unified detail', () => {
-  assert.match(storeSource, /getMerchantFirstLegOrders\(legacyQuery\(query, 'DRAFT'\)\)/)
+  assert.match(storeSource, /return loadOrderAggregate\(id\)/)
-  assert.match(storeSource, /getById\(id\)\?\.status === 'DRAFT' \? loadLegacyDetail\(id\) : loadUnifiedDetail\(id\)/)
+  assert.match(storeSource, /const detail = await getMerchantUnifiedOrder\(id\)/)
-  assert.match(storeSource, /return loadLegacyDetail\(String\(createdId\)\)/)
+  assert.doesNotMatch(storeSource, /loadLegacyDetail|draftOnly|includeDrafts/)
-  assert.match(storeSource, /draftLoadError/)
-})
-
-test('routes supported filters to C02 without sending DRAFT as a main status', () => {
-  assert.match(storeSource, /interface ClientOrderReadQuery extends MerchantUnifiedOrderQuery/)
-  assert.match(storeSource, /if \(query\.draftOnly\)/)
-  assert.match(storeSource, /const unifiedQuery: MerchantUnifiedOrderQuery/)
-  assert.match(storeSource, /inboundCode: query\.inboundCode/)
-  assert.match(storeSource, /getMerchantUnifiedOrders\(unifiedQuery\)/)
 })
 
 test('maps C02 authoritative status, transport, cargo and pickup snapshots', () => {
   assert.match(storeSource, /id: String\(summary\.orderId\)/)
   assert.match(storeSource, /transportMode: unifiedTransport\(summary\.containerMode\)/)
   assert.match(storeSource, /status: summary\.mainStatus/)
+  assert.match(storeSource, /taxMode: summary\.taxMode \?\? 'BUY_DECLARATION'/)
+  assert.match(storeSource, /customsInspection: summary\.customsInspection \?\? false/)
   assert.match(storeSource, /fulfillmentType: summary\.fulfillmentType \?\? 'STANDARD'/)
   assert.match(storeSource, /lxCode: summary\.lxCode \?\? ''/)
   assert.match(storeSource, /mapped\.fulfillmentType = detail\.summary\.fulfillmentType \?\? mapped\.fulfillmentType/)
@@ -168,7 +167,7 @@ test('separates domestic receiving warehouses from public destinations', () => {
   assert.match(apiSource, /warehouseType\?: MerchantWarehouseType/)
   assert.match(apiSource, /params: \{ page: 1, size: 200, status: 'ACTIVE', \.\.\.params \}/)
   assert.match(storeSource, /loadAllWarehouseRecords\(warehouseType, getMerchantWarehouses\)/)
-  assert.match(storeSource, /loadWarehouseType\('DOMESTIC', true\)/)
+  assert.match(storeSource, /loadWarehouseType\('DOMESTIC'\)/)
   assert.match(storeSource, /warehouse\.warehouseType !== 'DOMESTIC'/)
   assert.match(storeSource, /item\.warehouseType === draft\.destinationType/)
   assert.match(storeSource, /draft\.amazonWarehouseCode = draft\.destinationType === 'FBA' \? destinationWarehouse\.code : ''/)
@@ -179,20 +178,20 @@ test('only blocks submission when a known company audit status is not active', (
   assert.match(storeSource, /if \(companyAuditStatus && companyAuditStatus !== 'ACTIVE'\)/)
 })
 
-test('does not expose the out-of-scope cancellation write', () => {
+test('uses the versioned merchant cancellation contract', () => {
-  assert.doesNotMatch(storeSource, /cancelMerchant|function cancel|\/cancel/)
+  assert.match(storeSource, /cancelMerchantFirstLegOrder\(id, pending\.payload, pending\.key\)/)
-  assert.doesNotMatch(apiSource, /\/cancel/)
+  assert.match(apiSource, /cancelMerchantFirstLegOrder\(id: number \| string, payload: \{ expectedVersion: number; reason: string \}, idempotencyKey: string\)/)
 })
 
 test('sends an idempotency key for create and submit writes', () => {
   assert.match(apiSource, /'Idempotency-Key': createIdempotencyKey\('first-leg-create'\)/)
-  assert.match(apiSource, /submitMerchantFirstLegOrder\(id: number \| string, idempotencyKey: string\)/)
+  assert.match(apiSource, /submitMerchantFirstLegOrder\(id: number \| string, payload: \{ expectedVersion: number \}, idempotencyKey: string\)/)
   assert.match(apiSource, /'Idempotency-Key': idempotencyKey/)
   assert.match(apiSource, /createMerchantFirstLegOrderBatch\(items: MerchantBatchDraftItem\[\], idempotencyKey: string\)/)
   assert.match(apiSource, /headers: \{ 'Idempotency-Key': idempotencyKey \}/)
   assert.match(storeSource, /createMerchantFirstLegOrderBatch\(items, idempotencyKey\)/)
-  assert.match(storeSource, /pendingSubmitKeys\.get\(id\) \?\? createIdempotencyKey\(`first-leg-submit-\$\{id\}`\)/)
+  assert.match(storeSource, /pendingSubmissions\.get\(id\)/)
-  assert.match(storeSource, /submitMerchantFirstLegOrder\(id, idempotencyKey\)/)
+  assert.match(storeSource, /submitMerchantFirstLegOrder\(id, pending\.payload, pending\.key\)/)
 })
 
 test('does not expose the contradictory backend rejected state in the client model', () => {
@@ -237,5 +236,5 @@ test('keeps failed order loads distinct from empty results', () => {
   assert.match(storeSource, /const loadError = ref\(''\)/)
   assert.match(storeSource, /orderResult\.reason instanceof Error/)
   assert.match(storeSource, /warehouseLoadError/)
-  assert.match(storeSource, /return \{ orders, warehouses, loading, loadedFromApi, loadError, warehouseLoadError, draftLoadError/)
+  assert.match(storeSource, /return \{ orders, orderDetails, total, queueCounts, orderProgress, queryChannelNames, warehouses, loading, loadedFromApi, loadError, warehouseLoadError/)
 })

src/modules/first-leg/store/firstLegOrders.ts

@@ -1,29 +1,29 @@
-import { computed, ref } from 'vue'
+import { ref } from 'vue'
 import { defineStore } from 'pinia'
 import {
   createMerchantFirstLegOrderBatch,
   createMerchantFirstLegOrder,
   createIdempotencyKey,
   getMerchantFirstLegOrder,
-  getMerchantFirstLegOrders,
   getMerchantWarehouseDetail,
   getMerchantWarehouses,
   submitMerchantFirstLegOrder,
   updateMerchantFirstLegOrder,
+  cancelMerchantFirstLegOrder,
   type ApiFirstLegStatus,
   type FirstLegOrderSaveRequest,
   type MerchantFirstLegOrder,
-  type MerchantFirstLegOrderRow,
   type MerchantFirstLegOrderDetail,
   type MerchantBatchDraftResponse,
   type MerchantWarehouse,
 } from '@/modules/first-leg/api/firstLeg'
 import {
   getMerchantUnifiedOrder,
-  getMerchantUnifiedOrders,
+  getMerchantOrderWorkbench,
-  isUnifiedOrderQueryUnavailable,
   type MerchantUnifiedOrderDetail,
-  type MerchantUnifiedOrderQuery,
+  type MerchantOrderWorkbenchQuery,
+  type MerchantOrderProgress,
+  type OrderQueueCounts,
   type MerchantUnifiedOrderRow,
 } from '@/modules/first-leg/api/unifiedOrders'
 import type { MerchantTenantStatus } from '@/modules/tenant-management/public'
@@ -46,7 +46,7 @@ function clientStatus(status: ApiFirstLegStatus): FirstLegOrder['status'] {
   if (status === 'REJECTED') return 'PENDING_REVIEW'
   if (status === 'APPROVED' || status === 'ACCEPTED' || status === 'PROCESSING') return 'WAIT_MEASURE'
   if (status === 'COMPLETED') return 'COMPLETED'
-  if (status === 'CANCELLED') return 'PENDING_REVIEW'
+  if (status === 'CANCELLED') return 'CANCELLED'
   return 'PENDING_REVIEW'
 }
 
@@ -159,8 +159,10 @@ function orderWarehouseSnapshot(order: MerchantFirstLegOrder, warehouse?: Platfo
       id: String(order.receivingWarehouseId),
       code: warehouse?.code ?? '',
       name: order.receivingWarehouseName,
-      province: warehouse?.province ?? '',
+      // Order stores the complete formatted address, including province and city.
-      city: warehouse?.city ?? '',
+      // Do not prefix this snapshot with fields from the current warehouse master.
+      province: '',
+      city: '',
       address: order.receivingWarehouseAddress,
     }
   }
@@ -198,6 +200,7 @@ function timeline(detail: MerchantFirstLegOrderDetail): FirstLegOrderTimelineIte
 
 function businessSummary(summary?: MerchantUnifiedOrderRow): FirstLegOrder['businessSummary'] {
   return {
+    transportFragments: [],
     customerFeeConfirmationRequired: summary?.customerFeeConfirmationRequired ?? false,
     totalPackageCount: summary?.totalPackageCount ?? null,
     actualGrossWeightKg: summary?.actualGrossWeightKg ?? null,
@@ -220,8 +223,8 @@ function businessSummary(summary?: MerchantUnifiedOrderRow): FirstLegOrder['busi
     cabinetNo: summary?.transport?.cabinetNo ?? '',
     vesselName: summary?.transport?.vesselName ?? '',
     voyageNo: summary?.transport?.voyageNo ?? '',
-    sailingAt: summary?.transport?.sailingAt ?? '',
+    estimatedSailingAt: summary?.transport?.estimatedSailingAt ?? '',
-    portArrivalAt: summary?.transport?.portArrivalAt ?? '',
+    estimatedPortArrivalAt: summary?.transport?.estimatedPortArrivalAt ?? '',
     inboundId: summary?.inboundId == null ? '' : String(summary.inboundId),
     inboundVersion: summary?.inboundVersion ?? null,
     inboundCode: summary?.inboundCode ?? '',
@@ -339,54 +342,25 @@ function mapUnifiedOrderRow(summary: MerchantUnifiedOrderRow, warehouses: Platfo
     trackingNumber: summary.expressTrackingNo ?? summary.delivery?.trackingNo ?? '', skuNos: summary.skuNos ?? [], totalNetWeightKg: summary.totalNetWeightKg ?? null,
     totalQuantity: summary.totalQuantity ?? null, chargeableVolumeCbm: summary.chargeableVolumeCbm ?? null,
     inboundedAt: summary.inboundCompletedAt ?? '', businessDate: '', priority: 'NORMAL', customerRemark: summary.customerRemark ?? '', operatorName: '',
-    status: summary.mainStatus, version: 0, items: [], timeline: [], businessSummary: businessSummary(summary),
+    status: summary.mainStatus, version: summary.orderVersion, items: [], timeline: [], businessSummary: businessSummary(summary),
     createdAt: summary.createdAt, updatedAt: summary.updatedAt, tradeTerm: '', destinationCountryCode: '',
     destinationWarehouseId: summary.destinationWarehouseId == null ? '' : String(summary.destinationWarehouseId),
     destinationWarehouseName: summary.destinationWarehouseName ?? '', pickupMethod: summary.pickupMethod ?? 'SELF_EXPRESS', channelCode: '',
-    channelName: summary.channelName ?? '', pricingTaxMode: 'TAX_INCLUDED', carrierId: '', carrierName: '', taxMode: 'BUY_DECLARATION', customsInspection: false,
+    channelName: summary.channelName ?? '', pricingTaxMode: 'TAX_INCLUDED', carrierId: '', carrierName: '', taxMode: summary.taxMode ?? 'BUY_DECLARATION', customsInspection: summary.customsInspection ?? false,
     destinationType: summary.destinationType ?? 'PRIVATE', amazonWarehouseCode: summary.destinationCode ?? '', shipmentId: summary.shipmentId ?? '',
     requestedPickupAt: summary.requestedPickupAt ?? '', receivingTime: '', submittedAt: '', completedAt: '',
   }
 }
 
-function mapFirstLegOrderRow(row: MerchantFirstLegOrderRow): FirstLegOrder {
-  const skuNos = Array.isArray(row.skuNos)
-    ? row.skuNos
-    : (row.skuNos ?? '').split('、').map((value) => value.trim()).filter(Boolean)
-  const resolvedSkuNos = skuNos.length ? skuNos : (row.cargoes ?? [])
-    .map((cargo) => cargo.skuNo?.trim())
-    .filter((value): value is string => Boolean(value))
-  const uniqueSkuNos = [...new Set(resolvedSkuNos)]
-  return {
-    id: String(row.orderId), orderNo: row.orderNo, referenceNo: row.referenceId ?? '', transportMode: null,
-    businessType: 'EXPORT', origin: '', destination: row.destinationWarehouseName ?? '', receivingWarehouseId: '',
-    receivingWarehouseName: '', receivingWarehouseSnapshot: null, expectedDepartureDate: '', etd: '', eta: '',
-    shipperPartyId: '', shipperPartySnapshot: null, shipper: '', consigneePartyId: '', consigneePartySnapshot: null,
-    consignee: row.receivingCompanyName ?? '', expressCompanyName: row.expressCompany ?? '', trackingNumber: row.trackingNo ?? '',
-    skuNos: uniqueSkuNos, totalNetWeightKg: row.totalNetWeightKg, totalQuantity: row.totalQuantity,
-    chargeableVolumeCbm: null, inboundedAt: row.inboundedAt ?? '', businessDate: '', priority: 'NORMAL', customerRemark: row.remark ?? '',
-    operatorName: '', status: clientStatus(row.status), version: 0, items: [], timeline: [],
-    businessSummary: {
-      ...businessSummary(), totalPackageCount: row.packageCount, actualGrossWeightKg: row.totalGrossWeightKg ?? row.weightKg,
-      actualVolumeCbm: row.totalVolumeCbm, chargeableWeightKg: null,
-      inboundId: row.inboundId == null ? '' : String(row.inboundId), inboundCode: row.inboundCode ?? '',
-    },
-    createdAt: row.createdAt, updatedAt: row.createdAt, tradeTerm: '', destinationCountryCode: '', destinationWarehouseId: '',
-    destinationWarehouseName: row.destinationWarehouseName ?? '', pickupMethod: row.pickupMethod ?? 'SELF_EXPRESS', channelCode: '',
-    channelName: row.channelName ?? '', pricingTaxMode: 'TAX_INCLUDED', carrierId: '', carrierName: '', taxMode: 'BUY_DECLARATION',
-    customsInspection: false, destinationType: row.destinationType ?? 'PRIVATE', amazonWarehouseCode: '',
-    shipmentId: row.shipmentId ?? row.internationalOrderNo ?? '', requestedPickupAt: '', receivingTime: '', submittedAt: '', completedAt: '',
-  }
-}
-
 function mapUnifiedOrderDetail(detail: MerchantUnifiedOrderDetail, warehouses: PlatformReceivingWarehouse[]): FirstLegOrder {
   if (!detail?.summary || !detail.order?.order) throw new Error('订单详情数据不完整，请刷新列表后重试')
   const mapped = mapOrder(detail.order.order, warehouses, detail.order)
   mapped.id = String(detail.summary.orderId)
-  mapped.status = detail.summary.mainStatus
+  const rawStatus = detail.order.order.status
+  mapped.status = rawStatus === 'CANCELLED' || rawStatus === 'DRAFT' ? rawStatus : detail.summary.mainStatus
   mapped.fulfillmentType = detail.summary.fulfillmentType ?? mapped.fulfillmentType
   mapped.lxCode = detail.summary.lxCode ?? mapped.lxCode
-  mapped.businessSummary = businessSummary(detail.summary)
+  mapped.businessSummary = { ...businessSummary(detail.summary), transportFragments: detail.transportFragments }
   mapped.timeline = unifiedTimeline(detail)
   const summary = mapUnifiedOrderRow(detail.summary, warehouses)
   mapped.referenceNo = summary.referenceNo
@@ -406,59 +380,6 @@ function mapUnifiedOrderDetail(detail: MerchantUnifiedOrderDetail, warehouses: P
   return mapped
 }
 
-type OrderListReadResult =
-  | { source: 'first-leg'; records: MerchantFirstLegOrderRow[] }
-  | { source: 'unified'; records: MerchantUnifiedOrderRow[]; drafts: MerchantFirstLegOrderRow[] }
-
-interface ClientOrderReadQuery extends MerchantUnifiedOrderQuery {
-  fbaCode?: string
-  draftOnly?: boolean
-  includeDrafts?: boolean
-}
-
-function legacyQuery(query: ClientOrderReadQuery, status?: ApiFirstLegStatus) {
-  return {
-    keyword: query.keyword,
-    status,
-    createdFrom: query.createdFrom,
-    createdTo: query.createdTo,
-  }
-}
-
-async function getOrdersForClient(query: ClientOrderReadQuery = {}): Promise<OrderListReadResult> {
-  if (query.draftOnly) {
-    const response = await getMerchantFirstLegOrders(legacyQuery(query, 'DRAFT'))
-    return { source: 'first-leg', records: response.records }
-  }
-
-  const unifiedQuery: MerchantUnifiedOrderQuery = {
-    keyword: query.keyword,
-    orderNo: query.orderNo,
-    mainStatus: query.mainStatus,
-    receivingWarehouseId: query.receivingWarehouseId,
-    destinationWarehouseId: query.destinationWarehouseId,
-    inboundCode: query.inboundCode,
-    createdFrom: query.createdFrom,
-    createdTo: query.createdTo,
-    fbaCode: query.fbaCode,
-    page: query.page,
-    size: query.size,
-  }
-  try {
-    const [response, draftResponse] = await Promise.all([
-      getMerchantUnifiedOrders(unifiedQuery),
-      query.includeDrafts
-        ? getMerchantFirstLegOrders(legacyQuery(query, 'DRAFT'))
-        : Promise.resolve({ records: [] as MerchantFirstLegOrderRow[] }),
-    ])
-    return { source: 'unified', records: response.records, drafts: draftResponse.records }
-  } catch (error) {
-    if (!isUnifiedOrderQueryUnavailable(error)) throw error
-    const response = await getMerchantFirstLegOrders(legacyQuery(query))
-    return { source: 'first-leg', records: response.records }
-  }
-}
-
 function mapWarehouse(item: MerchantWarehouse): ClientWarehouse {
   return {
     id: String(item.id), code: item.warehouseCode, name: item.warehouseName, province: '',
@@ -468,21 +389,38 @@ function mapWarehouse(item: MerchantWarehouse): ClientWarehouse {
   }
 }
 
+export interface DraftEditSession {
+  readonly orderId: string
+  readonly expectedVersion: number
+}
+
 export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', () => {
   const orders = ref<FirstLegOrder[]>([])
-  const pendingSubmitKeys = new Map<string, string>()
+  const orderDetails = ref<Record<string, FirstLegOrder>>({})
+  const total = ref(0)
+  const queueCounts = ref<OrderQueueCounts>({ all: 0, fee: 0, customs: 0, draft: 0, loaded: 0, declared: 0, cleared: 0, scheduled: 0, delivering: 0, delivered: 0 })
+  const orderProgress = ref<Record<string, MerchantOrderProgress>>({})
+  const queryChannelNames = ref<string[]>([])
+  let listRequest = 0
+  const pendingSubmissions = new Map<string, { key: string; payload: { expectedVersion: number } }>()
+  const submissionForms = new Map<string, { snapshot: string; order: FirstLegOrder }>()
+  const submittingIds = new Set<string>()
+  const pendingEdits = new WeakMap<DraftEditSession, { key: string; payload: { expectedVersion: number; draft: FirstLegOrderSaveRequest } }>()
+  const pendingCancellations = new Map<string, { key: string; payload: { expectedVersion: number; reason: string } }>()
+
+  function beginDraftEdit(detail: FirstLegOrder): DraftEditSession {
+    if (!canClientEditFirstLegOrder(detail.status) || !Number.isSafeInteger(detail.version) || detail.version < 0) throw new Error('请重新打开草稿详情后编辑')
+    return Object.freeze({ orderId: detail.id, expectedVersion: detail.version })
+  }
   const warehouses = ref<ClientWarehouse[]>([])
   const loading = ref(false)
   const loadedFromApi = ref(false)
   const loadError = ref('')
   const warehouseLoadError = ref('')
-  const draftLoadError = ref('')
   const loadedWarehouseTypes = ref<ClientWarehouseType[]>([])
   const warehouseTypeRequests = new Map<ClientWarehouseType, Promise<ClientWarehouse[]>>()
-  const activeCount = computed(() => orders.value.filter((item) => item.status !== 'DRAFT' && item.status !== 'DELIVERED').length)
-  const pendingCount = computed(() => orders.value.filter((item) => item.status === 'PENDING_REVIEW').length)
 
-  function getById(id: string) { return orders.value.find((item) => item.id === id) }
+  function getById(id: string) { return orders.value.find((item) => item.id === id) ?? orderDetails.value[id] }
 
   async function loadWarehouseType(warehouseType: ClientWarehouseType, force = false) {
     if (warehouseType === 'DOMESTIC' && force) warehouseLoadError.value = ''
@@ -509,27 +447,48 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
     }
   }
 
-  async function load(query: ClientOrderReadQuery = {}) {
+  async function load(query: MerchantOrderWorkbenchQuery = {}) {
+    const request = ++listRequest
     loading.value = true
     loadedFromApi.value = true
     loadError.value = ''
-    warehouseLoadError.value = ''
-    draftLoadError.value = ''
-    loadedWarehouseTypes.value = []
-    warehouseTypeRequests.clear()
     orders.value = []
-    warehouses.value = []
+    total.value = 0
-    const [orderResult, warehouseResult] = await Promise.allSettled([getOrdersForClient(query), loadWarehouseType('DOMESTIC', true)])
+    // Keep the last confirmed category counts while refreshing; replace them only after validation.
-    if (warehouseResult.status === 'rejected' && !warehouseLoadError.value) warehouseLoadError.value = warehouseResult.reason instanceof Error ? warehouseResult.reason.message : '公共仓库数据加载失败'
+    orderProgress.value = {}
+    const [orderResult, warehouseResult] = await Promise.allSettled([
+      getMerchantOrderWorkbench(query), loadWarehouseType('DOMESTIC'),
+    ])
+    if (request !== listRequest) return 0
+    if (warehouseResult.status === 'rejected') warehouseLoadError.value = warehouseResult.reason instanceof Error ? warehouseResult.reason.message : '公共仓库数据加载失败'
     if (orderResult.status === 'fulfilled') {
-      orders.value = orderResult.value.source === 'unified'
+      try {
-        ? [
+        const result = orderResult.value
-            ...orderResult.value.drafts.map(mapFirstLegOrderRow),
+        const expectedPage = query.page ?? 1, size = query.size ?? 10
-            ...orderResult.value.records.map((item) => mapUnifiedOrderRow(item, warehouses.value)),
+        const count = Number(result.page.total), pages = Math.ceil(count / size)
-          ]
+        if (!Number.isSafeInteger(count) || count < 0 || Number(result.page.page) !== expectedPage
-        : orderResult.value.records.map(mapFirstLegOrderRow)
+          || Number(result.page.size) !== size || Number(result.page.pages) !== pages
-    } else {
+          || result.page.records.length !== Math.min(size, Math.max(0, count - (expectedPage - 1) * size))
-      loadError.value = orderResult.reason instanceof Error ? orderResult.reason.message : '订单数据加载失败'
+          || new Set(result.page.records.map(row => String(row.orderId))).size !== result.page.records.length
+          || ['all', 'fee', 'customs', 'draft', 'loaded', 'declared', 'cleared', 'scheduled', 'delivering', 'delivered'].some(key => { const value = result.queues[key as keyof typeof result.queues]; return !Number.isSafeInteger(Number(value)) || Number(value) < 0 })
+          || Number(result.queues[query.queue ?? 'all']) !== count
+          || !Array.isArray(result.progress) || result.progress.length !== result.page.records.length
+          || new Set(result.progress.map(p => String(p.orderId))).size !== result.progress.length
+          || result.progress.some(p => !result.page.records.some(row => String(row.orderId) === String(p.orderId))
+            || !['none', 'loaded', 'declared', 'cleared', 'scheduled', 'delivering', 'delivered'].includes(p.stage) || typeof p.partial !== 'boolean')
+          || !Array.isArray(result.channelNames)) {
+          loadError.value = '订单分页数据不完整，请重新加载'
+        } else {
+          orders.value = result.page.records.map(item => mapUnifiedOrderRow(item, warehouses.value))
+          total.value = count
+          queueCounts.value = Object.fromEntries(Object.entries(result.queues).map(([key, value]) => [key, Number(value)])) as OrderQueueCounts
+          orderProgress.value = Object.fromEntries(result.progress.map(p => [String(p.orderId), p]))
+          queryChannelNames.value = result.channelNames
+        }
+      } catch { loadError.value = '订单分页数据不完整，请重新加载' }
+    } else loadError.value = orderResult.reason instanceof Error ? orderResult.reason.message : '订单数据加载失败'
+    if (loadError.value) {
+    queueCounts.value = { all: 0, fee: 0, customs: 0, draft: 0, loaded: 0, declared: 0, cleared: 0, scheduled: 0, delivering: 0, delivered: 0 }
     }
     loading.value = false
     return orders.value.length
@@ -538,27 +497,18 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
   function upsertOrder(mapped: FirstLegOrder) {
     const index = orders.value.findIndex((item) => item.id === mapped.id)
     if (index >= 0) orders.value[index] = mapped
-    else orders.value.unshift(mapped)
+    orderDetails.value[mapped.id] = mapped
     return mapped
   }
 
-  async function loadLegacyDetail(id: string) {
+  async function loadOrderAggregate(id: string) {
     const detail = await getMerchantFirstLegOrder(id)
     return upsertOrder(mapOrder(detail.order, warehouses.value, detail))
   }
 
-  async function loadUnifiedDetail(id: string) {
-    try {
-      const detail = await getMerchantUnifiedOrder(id)
-      return upsertOrder(mapUnifiedOrderDetail(detail, warehouses.value))
-    } catch (error) {
-      if (!isUnifiedOrderQueryUnavailable(error)) throw error
-      return loadLegacyDetail(id)
-    }
-  }
-
   async function loadDetail(id: string) {
-    return getById(id)?.status === 'DRAFT' ? loadLegacyDetail(id) : loadUnifiedDetail(id)
+    const detail = await getMerchantUnifiedOrder(id)
+    return upsertOrder(mapUnifiedOrderDetail(detail, warehouses.value))
   }
 
   async function loadWarehouseDetail(id: string) {
@@ -577,16 +527,51 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
     return mapped
   }
 
-  async function saveDraft(draft: FirstLegOrderDraft, customerName: string, id?: string) {
+  async function saveDraft(draft: FirstLegOrderDraft, customerName: string, id?: string, editSession?: DraftEditSession) {
+    if (hasPendingSubmission(id)) throw new Error('上次提交结果未确认，请重试原提交，或确认重新编辑后再保存')
     const warehouse = prepareDraftForSave(draft, warehouses.value)
     if (id) {
-      const order = getById(id)
+      if (!editSession || editSession.orderId !== id) throw new Error('请重新打开草稿详情后编辑')
-      if (!order || !canClientEditFirstLegOrder(order.status)) throw new Error('当前订单状态不允许编辑')
+      const payload = { expectedVersion: editSession.expectedVersion, draft: savePayload(draft, warehouse, customerName) }
-      await updateMerchantFirstLegOrder(id, savePayload(draft, warehouse, customerName))
+      let pending = pendingEdits.get(editSession)
-      return loadLegacyDetail(id)
+      if (pending && JSON.stringify(pending.payload) !== JSON.stringify(payload)) throw new Error('上次保存结果未确认，请重试原内容，或重新打开详情后编辑')
+      // Observe an uncertain previous outcome without replacing its frozen version.
+      if (pending) await getMerchantFirstLegOrder(id)
+      if (!pending) {
+        pending = { key: createIdempotencyKey(`first-leg-edit-${id}`), payload: JSON.parse(JSON.stringify(payload)) }
+        pendingEdits.set(editSession, pending)
+      }
+      await updateMerchantFirstLegOrder(id, pending.payload, pending.key)
+      const saved = await loadOrderAggregate(id)
+      pendingEdits.delete(editSession)
+      return saved
     }
     const createdId = await createMerchantFirstLegOrder(savePayload(draft, warehouse, customerName))
-    return loadLegacyDetail(String(createdId))
+    return loadOrderAggregate(String(createdId))
+  }
+
+  async function cancelOrder(id: string, expectedVersion: number, reason: string) {
+    if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0 || !reason.trim() || reason.trim().length > 500) throw new Error('取消订单需要详情版本及 1–500 字取消原因')
+    const payload = { expectedVersion, reason: reason.trim() }
+    let pending = pendingCancellations.get(id)
+    if (pending && JSON.stringify(pending.payload) !== JSON.stringify(payload)) throw new Error('上次取消结果未确认，请使用原版本和原因重试')
+    if (pending) await getMerchantFirstLegOrder(id)
+    if (!pending) {
+      pending = { key: createIdempotencyKey(`first-leg-cancel-${id}`), payload }
+      pendingCancellations.set(id, pending)
+    }
+    await cancelMerchantFirstLegOrder(id, pending.payload, pending.key)
+    pendingCancellations.delete(id)
+    orders.value = orders.value.filter(order => order.id !== id)
+  }
+
+  async function prepareCancellation(id: string) {
+    const { order } = await getMerchantFirstLegOrder(id)
+    const labels: Record<string, string> = { DRAFT: '草稿', SUBMITTED: '审核中', APPROVED: '已审核', ACCEPTED: '已接单', REJECTED: '已退回' }
+    if (!Object.hasOwn(labels, order.status)) throw new Error('当前订单状态不允许取消，请刷新订单查看最新进度')
+    if (!Number.isSafeInteger(order.version) || order.version < 0) throw new Error('订单版本缺失，请重新加载详情')
+    pendingCancellations.delete(id)
+    return { id, expectedVersion: order.version, businessNo: order.orderNo || order.inboundCode || '—', statusLabel: labels[order.status] }
   }
 
   async function saveDraftBatch(
@@ -603,21 +588,58 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
 
   async function submitSaved(id: string, companyAuditStatus?: MerchantTenantStatus) {
     if (companyAuditStatus && companyAuditStatus !== 'ACTIVE') throw new Error('企业资料尚未审核通过，请先完善企业资料并等待平台审核')
-    const idempotencyKey = pendingSubmitKeys.get(id) ?? createIdempotencyKey(`first-leg-submit-${id}`)
+    if (submittingIds.has(id)) throw new Error('订单正在提交，请稍候')
-    pendingSubmitKeys.set(id, idempotencyKey)
+    submittingIds.add(id)
-    await submitMerchantFirstLegOrder(id, idempotencyKey)
+    try {
-    pendingSubmitKeys.delete(id)
+      let pending = pendingSubmissions.get(id)
-    return loadUnifiedDetail(id)
+      // Always observe the raw detail; a retry must retain the original command.
+      const { order } = await getMerchantFirstLegOrder(id)
+      if (!pending) {
+        if (order.status !== 'DRAFT') throw new Error('当前订单不是草稿，请刷新订单查看最新状态')
+        if (!Number.isSafeInteger(order.version) || order.version < 0) throw new Error('订单版本缺失，请重新加载详情')
+        pending = { key: createIdempotencyKey(`first-leg-submit-${id}`), payload: { expectedVersion: order.version } }
+        pendingSubmissions.set(id, pending)
+      }
+      await submitMerchantFirstLegOrder(id, pending.payload, pending.key)
+      const submitted = await loadOrderAggregate(id)
+      pendingSubmissions.delete(id)
+      submissionForms.delete(id)
+      return submitted
+    } finally {
+      submittingIds.delete(id)
+    }
   }
 
-  async function submit(draft: FirstLegOrderDraft, customerName: string, id?: string, companyAuditStatus?: MerchantTenantStatus) {
+  function hasPendingSubmission(id?: string) { return !!id && (pendingSubmissions.has(id) || submissionForms.has(id)) }
-    const order = await saveDraft(draft, customerName, id)
+
-    return submitSaved(order.id, companyAuditStatus)
+  function isSubmissionRetry(id: string | undefined, draft: FirstLegOrderDraft) {
+    return !!id && hasPendingSubmission(id) && submissionForms.get(id)?.snapshot === JSON.stringify(draft)
+  }
+
+  async function beginNewSubmissionEdit(id: string) {
+    if (submittingIds.has(id)) throw new Error('订单正在提交，请稍候')
+    const detail = await getMerchantFirstLegOrder(id)
+    if (detail.order.status !== 'DRAFT') throw new Error('订单已不在草稿状态，不能重新编辑，请刷新订单查看最新状态')
+    if (!Number.isSafeInteger(detail.order.version) || detail.order.version < 0) throw new Error('订单版本缺失，请重新加载详情')
+    const order = mapOrder(detail.order, warehouses.value, detail)
+    const session = beginDraftEdit(order)
+    pendingSubmissions.delete(id)
+    submissionForms.delete(id)
+    upsertOrder(order)
+    return session
+  }
+
+  async function saveDraftForSubmission(draft: FirstLegOrderDraft, customerName: string, id?: string, editSession?: DraftEditSession) {
+    if (id && isSubmissionRetry(id, draft)) return submissionForms.get(id)!.order
+    const snapshot = JSON.stringify(draft)
+    const order = await saveDraft(JSON.parse(snapshot), customerName, id, editSession)
+    submissionForms.set(order.id, { snapshot, order })
+    return order
   }
 
   async function loadDraftDetail(id: string) {
-    return loadLegacyDetail(id)
+    return loadOrderAggregate(id)
   }
 
-  return { orders, warehouses, loading, loadedFromApi, loadError, warehouseLoadError, draftLoadError, activeCount, pendingCount, getById, load, loadDetail, loadDraftDetail, loadWarehouseDetail, loadWarehouseType, saveDraft, saveDraftBatch, submitSaved, submit }
+  return { orders, orderDetails, total, queueCounts, orderProgress, queryChannelNames, warehouses, loading, loadedFromApi, loadError, warehouseLoadError, getById, load, loadDetail, loadDraftDetail, loadWarehouseDetail, loadWarehouseType, beginDraftEdit, saveDraft, prepareCancellation, cancelOrder, saveDraftBatch, submitSaved, hasPendingSubmission, isSubmissionRetry, beginNewSubmissionEdit, saveDraftForSubmission }
 })

src/modules/first-leg/store/firstLegWorkbench.test.mjs

@@ -0,0 +1,170 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+import * as pinia from 'pinia'
+
+const source = readFileSync(new URL('./firstLegOrders.ts', import.meta.url), 'utf8')
+const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+const row = (id, mainStatus = 'LOADED') => ({ orderId: String(id), orderNo: `FL-${id}`, mainStatus, orderVersion: 7 })
+function result(page = 1, size = 10, total = 215) {
+  return {
+    page: { page, size, total, pages: Math.ceil(total / size), records: Array.from({ length: Math.min(size, Math.max(0, total - (page - 1) * size)) }, (_, i) => row((page - 1) * size + i + 1)) },
+    queues: { all: total, fee: 2, customs: 1, draft: 3, loaded: 0, declared: 0, cleared: 0, scheduled: 0, delivering: 0, delivered: 0 }, channelNames: ['AIR', 'SEA'],
+    progress: Array.from({ length: Math.min(size, Math.max(0, total - (page - 1) * size)) }, (_, i) => ({ orderId: String((page - 1) * size + i + 1), stage: 'loaded', partial: false })),
+  }
+}
+function deferred() { let resolve, reject; const promise = new Promise((a, b) => { resolve = a; reject = b }); return { promise, resolve, reject } }
+function harness(t, read) {
+  const context = pinia.createPinia(); pinia.setActivePinia(context)
+  t.after(() => pinia.disposePinia(context))
+  const calls = [], details = [], warehouseCalls = []
+  const deps = {
+    vue, pinia,
+    '@/modules/first-leg/api/firstLeg': {},
+    '@/modules/first-leg/api/unifiedOrders': {
+      getMerchantOrderWorkbench: query => { calls.push(structuredClone(query)); return read(query) },
+      getMerchantUnifiedOrder: async id => {
+        details.push(id)
+        return { summary: row(id, 'DRAFT'), order: { order: { id, status: 'DRAFT', version: 7 } }, timeline: [] }
+      },
+    },
+    '@/modules/first-leg/utils/firstLegOrder': { getFirstLegStatusLabel: value => value },
+    '@/modules/first-leg/utils/warehousePagination': { loadAllWarehouseRecords: async type => { warehouseCalls.push(type); return [] } },
+  }
+  const exports = {}
+  new Function('require', 'exports', code)(id => { assert.ok(id in deps, id); return deps[id] }, exports)
+  return { store: exports.useFirstLegOrdersStore(), calls, details, warehouseCalls }
+}
+
+test('loads beyond 200 with server totals and forwards every filter using one request per page', async t => {
+  const h = harness(t, q => result(q.page, q.size))
+  const query = { page: 21, size: 10, cargoKeyword: 'SKU', channelName: 'SEA', receivingWarehouseId: '42', destinationType: 'FBA', trackingNumber: 'TRACK', mainStatus: 'LOADED', queue: 'all', createdFrom: '2026-10-01T00:00:00', createdTo: '2026-10-03T23:59:59.999' }
+  assert.equal(await h.store.load(query), 10)
+  assert.equal(h.store.orders[0].id, '201')
+  assert.equal(h.store.total, 215)
+  assert.deepEqual(h.calls, [query])
+  assert.deepEqual(h.store.queueCounts, { all: 215, fee: 2, customs: 1, draft: 3, loaded: 0, declared: 0, cleared: 0, scheduled: 0, delivering: 0, delivered: 0 })
+  assert.deepEqual(h.store.queryChannelNames, ['AIR', 'SEA'])
+  await h.store.load({ page: 22, size: 10 })
+  assert.deepEqual(h.store.orders.map(item => item.id), ['211', '212', '213', '214', '215'])
+  assert.equal(h.calls.length, 2)
+  assert.deepEqual(h.warehouseCalls, ['DOMESTIC'])
+})
+
+test('late success cannot replace newer rows, counts, channels or loading state', async t => {
+  const a = deferred(), b = deferred()
+  const h = harness(t, q => q.page === 1 ? a.promise : b.promise)
+  const first = h.store.load({ page: 1 }), second = h.store.load({ page: 2 })
+  b.resolve(result(2)); await second
+  a.resolve(result(1, 10, 999)); await first
+  assert.equal(h.store.orders[0].id, '11'); assert.equal(h.store.total, 215)
+  assert.equal(h.store.queueCounts.all, 215); assert.equal(h.store.loading, false)
+})
+
+test('late failure cannot clear the current page and an older completion cannot stop loading a newer page', async t => {
+  const a = deferred(), b = deferred(), c = deferred()
+  const h = harness(t, q => [a, b, c][q.page - 1].promise)
+  const first = h.store.load({ page: 1 }), second = h.store.load({ page: 2 })
+  a.resolve(result(1)); await first
+  assert.equal(h.store.loading, true); assert.equal(h.store.orders.length, 0)
+  const third = h.store.load({ page: 3 })
+  c.resolve(result(3)); await third
+  b.reject(new Error('old failure')); await second
+  assert.equal(h.store.orders[0].id, '21'); assert.equal(h.store.loadError, '')
+})
+
+test('current failure clears stale records and totals, never falls back, and retry restores the page', async t => {
+  let fail = false
+  const h = harness(t, () => fail ? Promise.reject(new Error('查询失败')) : result())
+  await h.store.load(); fail = true; await h.store.load()
+  assert.equal(h.store.orders.length, 0); assert.equal(h.store.total, 0)
+  assert.equal(h.store.queueCounts.all, 0); assert.equal(h.store.loadError, '查询失败')
+  assert.equal(h.store.loading, false)
+  fail = false; await h.store.load(); assert.equal(h.store.orders.length, 10)
+  assert.equal(h.calls.length, 3); assert.equal(h.store.loadError, '')
+})
+
+test('rejects inconsistent metadata, truncated pages and duplicate rows without displaying partial data', async t => {
+  let response
+  const h = harness(t, () => response)
+  const corruptions = [r => { r.page.total = -1 }, r => { r.page.pages = 1 }, r => { r.page.page = 2 }, r => { r.page.records.pop() }, r => { r.page.records[1] = r.page.records[0] }, r => { r.queues.all = 99 }, r => { delete r.queues }, r => { r.channelNames = null }]
+  for (const corrupt of corruptions) {
+    response = result(); corrupt(response); await h.store.load()
+    assert.equal(h.store.orders.length, 0); assert.equal(h.store.total, 0)
+    assert.match(h.store.loadError, /分页数据不完整/); assert.equal(h.store.loading, false)
+  }
+})
+
+test('draft and cancelled rows retain authoritative versions; off-page detail cannot inflate list or totals', async t => {
+  const response = result(1, 10, 2)
+  response.page.records = [row(1, 'DRAFT'), row(2, 'CANCELLED')]
+  const h = harness(t, () => response)
+  await h.store.load()
+  assert.deepEqual(h.store.orders.map(item => [item.status, item.version]), [['DRAFT', 7], ['CANCELLED', 7]])
+  await h.store.loadDetail('900')
+  assert.equal(h.store.orders.length, 2); assert.equal(h.store.total, 2)
+  assert.equal(h.store.getById('900').status, 'DRAFT')
+})
+
+test('queue total is checked against the selected queue rather than all orders', async t => {
+  const response = result(1, 10, 2)
+  response.queues = { all: 215, fee: 2, customs: 1, draft: 3, loaded: 0, declared: 0, cleared: 0, scheduled: 0, delivering: 0, delivered: 0 }
+  const h = harness(t, () => response)
+  await h.store.load({ queue: 'fee' })
+  assert.equal(h.store.total, 2); assert.equal(h.store.queueCounts.all, 215)
+  assert.equal(h.store.loadError, '')
+})
+
+
+test('retains server progress and rejects missing or foreign progress without inferring milestones', async t => {
+  let response = result()
+  response.progress[0] = { orderId: '1', stage: 'scheduled', partial: true }
+  const h = harness(t, () => response)
+  await h.store.load()
+  assert.deepEqual(h.store.orderProgress['1'], response.progress[0])
+  response = result(); response.progress[0].orderId = 'foreign'
+  await h.store.load()
+  assert.match(h.store.loadError, /分页数据不完整/)
+  assert.deepEqual(h.store.orderProgress, {})
+  response = result(); delete response.queues.cleared
+  await h.store.load(); assert.match(h.store.loadError, /分页数据不完整/)
+})
+
+
+test('category counts remain visible throughout refresh and update together after the response is validated', async t => {
+  const pending = deferred()
+  let refreshing = false
+  const h = harness(t, () => refreshing ? pending.promise : result())
+  await h.store.load()
+  const counts = h.store.queueCounts
+  refreshing = true
+  const request = h.store.load({ queue: 'fee' })
+  assert.equal(h.store.loading, true)
+  assert.equal(h.store.queueCounts, counts)
+  assert.equal(h.store.queueCounts.fee, 2)
+  const updated = result(1, 10, 3)
+  updated.queues = { ...updated.queues, all: 216, fee: 3 }
+  pending.resolve(updated)
+  await request
+  assert.equal(h.store.queueCounts.all, 216)
+  assert.equal(h.store.queueCounts.fee, 3)
+  assert.equal(h.store.loading, false)
+})
+
+test('rapid category switches preserve counts and ignore an older response while the newest request is pending', async t => {
+  const older = deferred(), latest = deferred()
+  const h = harness(t, q => q.queue === 'fee' ? older.promise : q.queue === 'customs' ? latest.promise : result())
+  await h.store.load()
+  const oldRequest = h.store.load({ queue: 'fee' })
+  const newRequest = h.store.load({ queue: 'customs' })
+  const oldResult = result(1, 10, 2); oldResult.queues.all = 999
+  older.resolve(oldResult); await oldRequest
+  assert.equal(h.store.queueCounts.all, 215)
+  assert.equal(h.store.loading, true)
+  const newResult = result(1, 10, 1); newResult.queues.all = 216
+  latest.resolve(newResult); await newRequest
+  assert.equal(h.store.queueCounts.all, 216)
+  assert.equal(h.store.total, 1)
+})

src/modules/first-leg/types/firstLegOrder.ts

@@ -1,3 +1,4 @@
+import type { MerchantTransportFragment } from '../api/unifiedOrders'
 import type {
   FirstLegOrderStatus,
   FirstLegTransportMode,
@@ -64,6 +65,7 @@ export interface FirstLegOrderTimelineItem {
 }
 
 export interface FirstLegOrderBusinessSummary {
+  transportFragments: MerchantTransportFragment[]
   customerFeeConfirmationRequired: boolean
   totalPackageCount: number | null
   actualGrossWeightKg: number | null
@@ -87,8 +89,8 @@ export interface FirstLegOrderBusinessSummary {
   cabinetNo: string
   vesselName: string
   voyageNo: string
-  sailingAt: string
+  estimatedSailingAt: string
-  portArrivalAt: string
+  estimatedPortArrivalAt: string
   inboundId: string
   inboundVersion: number | null
   inboundCode: string

src/modules/first-leg/types/inboundBilling.ts

@@ -68,9 +68,9 @@ export interface MerchantInboundFeeSnapshot {
   chargeRuleId: string
   ruleCode: string
   chargeRuleVersion: number
-  carrierRateId: string
+  carrierRateId: string | null
   rateCode: string
-  carrierRateVersion: number
+  carrierRateVersion: number | null
   customerId: string
   customerName: string
   originWarehouseId: string

src/modules/first-leg/utils/customsDocumentsReader.ts

@@ -0,0 +1,52 @@
+import { getMerchantUnifiedOrders } from '../api/unifiedOrders'
+import { getMerchantCustomsForOrder, isMerchantCustomsUnavailable, type MerchantCustomsContainer } from '../api/customs'
+import { isCustomsOrderCandidate } from './customsEligibility'
+
+export interface CustomsDocumentRow {
+  order: { id: string; orderNo: string | null; businessSummary: { inboundCode: string } }
+  detail: MerchantCustomsContainer
+}
+
+// Isolated from the shared order store: scan sequential pages, with at most
+// four document requests in flight. Inconsistent pagination must be visible.
+export async function readCustomsDocuments() {
+  const records: CustomsDocumentRow[] = []
+  const seen = new Set<string>()
+  let expectedTotal: number | undefined
+  let failedCount = 0
+  const size = 200
+  for (let page = 1; ; page += 1) {
+    const response = await getMerchantUnifiedOrders({ page, size, taxMode: 'TAX_REFUND', loaded: true })
+    const total = Number(response.total)
+    const pages = Number(response.pages)
+    if (!Number.isSafeInteger(total) || total < 0 || Number(response.page) !== page
+      || Number(response.size) !== size || pages !== Math.ceil(total / size)
+      || (expectedTotal !== undefined && total !== expectedTotal)
+      || response.records.length !== Math.min(size, Math.max(0, total - (page - 1) * size))) {
+      throw new Error('订单分页数据不完整或已变化，请重新加载报关资料')
+    }
+    expectedTotal = total
+    for (const row of response.records) {
+      const id = String(row.orderId)
+      if (seen.has(id)) throw new Error('订单分页存在重复记录，请重新加载报关资料')
+      seen.add(id)
+    }
+    const candidates = response.records.filter(row => isCustomsOrderCandidate({ status: row.mainStatus, taxMode: row.taxMode ?? 'BUY_DECLARATION' }))
+    for (let offset = 0; offset < candidates.length; offset += 4) {
+      const results = await Promise.all(candidates.slice(offset, offset + 4).map(async row => {
+        const id = String(row.orderId)
+        try {
+          const detail = await getMerchantCustomsForOrder(id)
+          if (!detail.inbounds.some(item => item.orderId === id && item.taxMode === 'TAX_REFUND')) return null
+          return { order: { id, orderNo: row.orderNo, businessSummary: { inboundCode: row.inboundCode ?? '' } }, detail }
+        } catch (error) {
+          if (!isMerchantCustomsUnavailable(error)) failedCount += 1
+          return null
+        }
+      }))
+      for (const result of results) if (result) records.push(result)
+    }
+    if (page >= pages) break
+  }
+  return { records, failedCount }
+}

src/modules/first-leg/utils/customsEligibility.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import { ref } from 'vue'
+
+const source = readFileSync(new URL('./customsEligibility.ts', import.meta.url), 'utf8')
+const exports = {}
+new Function('exports', ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS } }).outputText)(exports)
+
+test('upload queue contains only customer uploads still required, while completed documents stay accessible', () => {
+  const states = [null, {}, { status: 'WAITING_CUSTOMER_DOCUMENTS', merchantStatus: 'DOCUMENT_UPLOADED' },
+    { status: 'READY_TO_START', merchantStatus: 'DOCUMENT_UPLOADED' },
+    { status: 'DECLARING', merchantStatus: 'DECLARING' }, { status: 'COMPLETED', merchantStatus: 'CUSTOMS_COMPLETED' }]
+  for (const detail of states) assert.equal(exports.needsCustomsUpload(detail), false)
+  assert.equal(exports.needsCustomsUpload({ status: 'WAITING_CUSTOMER_DOCUMENTS', merchantStatus: 'WAITING_UPLOAD' }), true)
+  for (const status of ['LOADED', 'DELIVERED', 'COMPLETED']) assert.equal(exports.isCustomsOrderCandidate({ status, taxMode: 'TAX_REFUND' }), true)
+})
+
+test('upload status changes refresh server counts while initial detail reads do not reload the list', async () => {
+  const page = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
+  const block = page.slice(page.indexOf('function updateCustomsDetail('), page.indexOf('const detailOrder ='))
+  const js = ts.transpileModule(block, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const states = {}, id = ref('one'), create = ref(false), detail = ref(false)
+  let reloads = 0
+  const update = new Function('customsByOrder', 'customsDialogOrderId', 'isCreatePage', 'isDetailPage', 'loadOrderPage', js + ';return updateCustomsDetail')(states, id, create, detail, async () => reloads++)
+  update({ merchantStatus: 'WAITING_UPLOAD' }); assert.equal(reloads, 0)
+  update({ merchantStatus: 'WAITING_UPLOAD' }); assert.equal(reloads, 0)
+  update({ merchantStatus: 'DOCUMENT_UPLOADED' }); assert.equal(reloads, 1)
+  assert.equal(states.one.merchantStatus, 'DOCUMENT_UPLOADED')
+  detail.value = true; update({ merchantStatus: 'WAITING_UPLOAD' }); assert.equal(reloads, 1)
+})

src/modules/first-leg/utils/customsEligibility.ts

@@ -0,0 +1,11 @@
+import type { FirstLegOrder } from '../types/firstLegOrder'
+import type { MerchantCustomsContainer } from '../api/customs'
+
+export function isCustomsOrderCandidate(order: Pick<FirstLegOrder, 'status' | 'taxMode'>): boolean {
+  return order.taxMode === 'TAX_REFUND'
+    && (order.status === 'LOADED' || order.status === 'DELIVERED' || order.status === 'COMPLETED')
+}
+
+export function needsCustomsUpload(detail: MerchantCustomsContainer | null | undefined): boolean {
+  return detail?.status === 'WAITING_CUSTOMER_DOCUMENTS' && detail.merchantStatus === 'WAITING_UPLOAD'
+}

src/modules/first-leg/utils/firstLegOrder.test.mjs

@@ -8,6 +8,7 @@ import {
   FIRST_LEG_PROGRESS_STAGES,
   getFirstLegProgressIndex,
   getFirstLegStatusLabel,
+  getFirstLegPickingStatusLabel,
   getFirstLegStatusTone,
   getFirstLegTransportModeLabel,
   summarizeFirstLegCargo,
@@ -59,7 +60,22 @@ function validDraft() {
   }
 }
 
+test('keeps picking states distinct from order completion and hides unknown internal codes', () => {
+  assert.equal(getFirstLegPickingStatusLabel('PENDING'), '待拣货')
+  assert.equal(getFirstLegPickingStatusLabel('IN_PROGRESS'), '拣货中')
+  assert.equal(getFirstLegPickingStatusLabel('COMPLETED'), '拣货完成')
+  assert.equal(getFirstLegPickingStatusLabel('NEW_INTERNAL_STATE'), '未知状态')
+  assert.equal(getFirstLegPickingStatusLabel(null), '待更新')
+  assert.equal(getFirstLegPickingStatusLabel(''), '待更新')
+})
+
 test('uses the confirmed status and transport labels', () => {
+  assert.equal(getFirstLegStatusLabel('CANCELLED'), '已取消')
+  assert.equal(getFirstLegStatusLabel('NOT_A_STATUS'), '未知状态')
+  assert.equal(getFirstLegStatusTone('CANCELLED'), 'info')
+  assert.equal(getFirstLegProgressIndex('CANCELLED'), -1)
+  assert.equal(canClientEditFirstLegOrder('CANCELLED'), false)
+  assert.equal(canClientCancelFirstLegOrder('CANCELLED'), false)
   assert.equal(getFirstLegStatusLabel('WAIT_MEASURE'), '待测量数据')
   assert.equal(getFirstLegStatusLabel('WAIT_PALLETIZE'), '待组托')
   assert.equal(getFirstLegStatusLabel('WAIT_SPLIT'), '待分柜')
@@ -162,10 +178,11 @@ test('requires public destination ids while keeping private addresses detached f
 test('requires customs inspection when any cargo is a wooden product', () => {
   const draft = validDraft()
   draft.items[0].woodenProduct = true
+  draft.items.push({ ...draft.items[0], id: 'cargo-2' })
   draft.customsInspection = null
-  assert.ok(validateFirstLegOrderDraft(draft).includes('第 1 条货物为木制品，“是否商检”必须选择“是”'))
+  assert.ok(validateFirstLegOrderDraft(draft).includes('第 1、2 条货物为木制品，“是否商检”必须选择“是”'))
   draft.customsInspection = false
-  assert.ok(validateFirstLegOrderDraft(draft).includes('第 1 条货物为木制品，“是否商检”必须选择“是”'))
+  assert.ok(validateFirstLegOrderDraft(draft).includes('第 1、2 条货物为木制品，“是否商检”必须选择“是”'))
   draft.customsInspection = true
   assert.ok(!validateFirstLegOrderDraft(draft).some((message) => message.includes('为木制品')))
 })
@@ -208,6 +225,7 @@ test('distinguishes first-leg draft, review, active handling and completion', ()
   assert.equal(getFirstLegStatusTone('LOADED'), 'success')
   assert.equal(getFirstLegStatusTone('DELIVERED'), 'success')
   assert.equal(getFirstLegStatusTone('COMPLETED'), 'success')
+  assert.equal(getFirstLegStatusLabel('SUBMITTED'), '\u5f85\u5ba1\u6838')
   assert.equal(getFirstLegStatusLabel('COMPLETED'), '已完成')
   assert.equal(getFirstLegStatusLabel('UNRECOGNIZED'), '未知状态')
   assert.equal(getFirstLegStatusTone('UNRECOGNIZED'), 'info')

src/modules/first-leg/utils/firstLegOrder.ts

@@ -14,8 +14,19 @@ const transportModeLabels = new Map<FirstLegTransportMode, string>(
   FIRST_LEG_TRANSPORT_MODES.map((item) => [item.code, item.label]),
 )
 
-export function getFirstLegStatusLabel(status: FirstLegOrderStatus) {
+export function getFirstLegStatusLabel(status: string) {
-  return statusLabels.get(status) ?? '未知状态'
+  const canonicalStatus = status === 'SUBMITTED' ? 'PENDING_REVIEW' : status
+  return statusLabels.get(canonicalStatus as FirstLegOrderStatus) ?? '未知状态'
+}
+
+export function getFirstLegPickingStatusLabel(status: string | null | undefined) {
+  if (!status) return '待更新'
+  const labels: Readonly<Record<string, string>> = {
+    PENDING: '待拣货',
+    IN_PROGRESS: '拣货中',
+    COMPLETED: '拣货完成',
+  }
+  return labels[status] ?? '未知状态'
 }
 
 export function getFirstLegTransportModeLabel(mode: FirstLegTransportMode | null) {
@@ -40,11 +51,11 @@ export function canClientCancelFirstLegOrder(status: FirstLegOrderStatus) {
 }
 
 export const FIRST_LEG_PROGRESS_STAGES = FIRST_LEG_ORDER_STATUSES.filter(
-  (item): item is (typeof FIRST_LEG_ORDER_STATUSES)[number] & { code: Exclude<FirstLegOrderStatus, 'DRAFT'> } => item.code !== 'DRAFT',
+  (item): item is (typeof FIRST_LEG_ORDER_STATUSES)[number] & { code: Exclude<FirstLegOrderStatus, 'DRAFT' | 'CANCELLED'> } => item.code !== 'DRAFT' && item.code !== 'CANCELLED',
 )
 
 export function getFirstLegProgressIndex(status: FirstLegOrderStatus) {
-  if (status === 'DRAFT') return -1
+  if (status === 'DRAFT' || status === 'CANCELLED') return -1
   return FIRST_LEG_PROGRESS_STAGES.findIndex((item) => item.code === status)
 }
 
@@ -141,9 +152,15 @@ export function validateFirstLegOrderDraft(draft: FirstLegOrderDraft) {
     }
     if (item.grossWeightKg <= 0) errors.push(`${line}毛重必须大于 0`)
     if (item.volumeCbm <= 0) errors.push(`${line}体积必须大于 0`)
-    if (item.woodenProduct && draft.customsInspection !== true) errors.push(`${line}为木制品，“是否商检”必须选择“是”`)
   })
 
+  const woodenCargoLines = draft.items
+    .map((item, index) => item.woodenProduct ? index + 1 : null)
+    .filter((index): index is number => index != null)
+  if (woodenCargoLines.length && draft.customsInspection !== true) {
+    errors.push(`第 ${woodenCargoLines.join('、')} 条货物为木制品，“是否商检”必须选择“是”`)
+  }
+
   if (draft.fulfillmentType === 'ONE_CLICK_DROPSHIP') {
     const groups = new Map<string, FirstLegCargoItem>()
     draft.items.forEach((item) => {

src/modules/first-leg/utils/inboundBilling.test.mjs

@@ -19,6 +19,13 @@ test('translates backend rounding modes into customer-facing calculation labels'
   assert.match(source, /return value \? labels\[value\] \|\| value : '-'/)
 })
 
+test('translates carton calculation rules into customer-facing labels', () => {
+  assert.match(source, /export function getCalculationRuleLabel/)
+  assert.match(source, /ACTUAL_DIMENSION_V1/)
+  assert.match(source, /按实际箱规计算/)
+  assert.match(source, /CUSTOMER_DIMENSION_\(SMALL\|MEDIUM\|LARGE\|EXTRA_LARGE\)_V/)
+})
+
 test('renders conversion metadata as one complete label or a single empty marker', () => {
   assert.match(source, /export function formatConversionPrecision/)
   assert.match(source, /roundingScale === null \|\| roundingScale === undefined/)

src/modules/first-leg/utils/inboundBilling.ts

@@ -46,6 +46,20 @@ export function getTaxModeLabel(value: string) {
   return value || '-'
 }
 
+export function getCalculationRuleLabel(value: string | null | undefined) {
+  if (!value) return '-'
+  if (value === 'ACTUAL_DIMENSION_V1' || value === 'DIMENSION_ACTUAL_V1') return '按实际箱规计算'
+  const customerRule = /^CUSTOMER_DIMENSION_(SMALL|MEDIUM|LARGE|EXTRA_LARGE)_V(\d+)$/.exec(value)
+  if (customerRule) {
+    const sizeLabel: Record<string, string> = {
+      SMALL: '小号', MEDIUM: '中号', LARGE: '大号', EXTRA_LARGE: '超大号',
+    }
+    return `客户箱规规则（${sizeLabel[customerRule[1]]}，V${customerRule[2]}）`
+  }
+  const warehouseRule = /^WAREHOUSE_OUTER_OVERRIDE_(.+)$/.exec(value)
+  return warehouseRule ? `仓库外箱规覆盖（${warehouseRule[1]}）` : value
+}
+
 export function getRoundingModeLabel(value: string | null | undefined) {
   const labels: Record<string, string> = {
     UP: '向上舍入',

src/modules/first-leg/utils/orderProgress.test.mjs

@@ -0,0 +1,15 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+const source = readFileSync(new URL('./orderProgress.ts', import.meta.url), 'utf8')
+const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS } }).outputText
+const exports = {}
+new Function('exports', code)(exports)
+test('prototype queues preserve order and distinguish partial progress from completion', () => {
+  assert.deepEqual(exports.ORDER_QUEUES.slice(0, 7).map(q => q.key), ['all','fee','loaded','declared','cleared','scheduled','delivering'])
+  assert.equal(exports.orderProgressLabel({ stage: 'scheduled', partial: true }), '部分已排车')
+  assert.equal(exports.orderProgressLabel({ stage: 'cleared', partial: false }), '已清关')
+  assert.equal(exports.orderProgressLabel({ stage: 'none', partial: false }), '—')
+  assert.equal(exports.orderProgressLabel(), '—')
+})

src/modules/first-leg/utils/orderProgress.ts

@@ -0,0 +1,20 @@
+import type { MerchantOrderProgress, OrderQueue } from '../api/unifiedOrders'
+
+export const ORDER_QUEUES: ReadonlyArray<{ key: OrderQueue; label: string; todo?: boolean }> = [
+  { key: 'all', label: '全部' },
+  { key: 'fee', label: '确认计费重', todo: true },
+  { key: 'loaded', label: '装柜完成' },
+  { key: 'declared', label: '已报关' },
+  { key: 'cleared', label: '已清关' },
+  { key: 'scheduled', label: '已排车' },
+  { key: 'delivering', label: '派送中' },
+  { key: 'delivered', label: '派送完成' },
+  { key: 'customs', label: '上传资料', todo: true },
+  { key: 'draft', label: '草稿' },
+]
+
+export function orderProgressLabel(progress?: MerchantOrderProgress) {
+  if (!progress || progress.stage === 'none') return '—'
+  const label = ORDER_QUEUES.find(q => q.key === progress.stage)?.label ?? '—'
+  return `${progress.partial ? '部分' : ''}${label}`
+}

src/modules/first-leg/utils/transportFacts.test.mjs

@@ -0,0 +1,51 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { runInNewContext } from 'node:vm'
+import test from 'node:test'
+import ts from 'typescript'
+
+const source = readFileSync(new URL('./transportFacts.ts', import.meta.url), 'utf8')
+const javascript = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+const exports = {}
+runInNewContext(javascript, { exports })
+const rows = exports.customerTransportRows
+
+test('split inbound fragments retain separate cabinet facts and actual/estimated times', () => {
+  const result = rows([
+    { inboundCode: 'NY-1', cabinetNo: 'D1', containerNo: 'TSTU0000001', nodes: [
+      { standardNode: 'AT_ORIGIN_PORT', actualAt: '2026-10-05T09:00:00', estimatedAt: null, providerCode: 'MANUAL' },
+      { standardNode: 'DEPARTED_ORIGIN_PORT', actualAt: null, estimatedAt: '2026-10-07T08:00:00', providerCode: 'MATSON' },
+    ] },
+    { inboundCode: 'NY-2', cabinetNo: 'D2', containerNo: 'TSTU0000002', nodes: [
+      { standardNode: 'AT_ORIGIN_PORT', actualAt: '2026-10-06T10:00:00', estimatedAt: null, providerCode: 'MATSON' },
+    ] },
+  ])
+  assert.equal(result.length, 3)
+  assert.equal(result[0].nodeLabel, '已进港')
+  assert.equal(result[0].source, '人工记录')
+  assert.equal(result[1].nodeLabel, '预计开航')
+  assert.equal(result[1].actualAt, null)
+  assert.equal(result[1].estimatedAt, '2026-10-07T08:00:00')
+  assert.equal(result[2].cabinetNo, 'D2')
+  assert.equal(result[2].inboundCode, 'NY-2')
+  assert.equal(result[2].actualAt, '2026-10-06T10:00:00')
+})
+
+test('empty actual scope creates no invented nodes or database identifier fallback', () => {
+  assert.equal(rows([]).length, 0)
+  assert.equal(rows([{ inboundCode: 'NY-1', nodes: [] }]).length, 0)
+  const [row] = rows([{ id: 'INTERNAL', nodes: [{ standardNode: 'AT_ORIGIN_PORT', actualAt: null, estimatedAt: '2026-10-05T09:00:00' }] }])
+  assert.equal(row.cabinetNo, '—')
+  assert.equal(row.containerNo, '—')
+  assert.equal(row.inboundCode, '—')
+  assert.equal(row.actualAt, null)
+})
+
+test('detail consumes the existing merchant detail API and displays times separately', () => {
+  const store = readFileSync(new URL('../store/firstLegOrders.ts', import.meta.url), 'utf8')
+  const table = readFileSync(new URL('../components/TransportFactsTable.vue', import.meta.url), 'utf8')
+  assert.match(store, /transportFragments: detail\.transportFragments/)
+  assert.match(table, /label="实际时间".*time\(row\.actualAt\)/)
+  assert.match(table, /label="预计时间".*time\(row\.estimatedAt\)/)
+  assert.doesNotMatch(table, /platform\/|fetch\(|actualAt\s*\|\|\s*.*estimatedAt/)
+})

src/modules/first-leg/utils/transportFacts.ts

@@ -0,0 +1,24 @@
+import type { MerchantTransportFragment } from '../api/unifiedOrders'
+
+const labels: Readonly<Record<string, string>> = {
+  DEPARTED_WAREHOUSE: '已离仓', AT_ORIGIN_PORT: '已进港', LOADED_ON_VESSEL: '已装船',
+  DEPARTED_ORIGIN_PORT: '已开航', IN_TRANSIT: '海运途中', ARRIVED_DESTINATION_PORT: '船舶已到目的港',
+  DISCHARGED_FROM_VESSEL: '已卸船', PICKUP_READY: '已清关、可提柜', PICKED_UP: '已提柜', EMPTY_RETURNED: '已还柜',
+}
+const estimatedLabels: Readonly<Record<string, string>> = {
+  DEPARTED_WAREHOUSE: '预计离仓', AT_ORIGIN_PORT: '预计进港', LOADED_ON_VESSEL: '预计装船',
+  DEPARTED_ORIGIN_PORT: '预计开航', IN_TRANSIT: '预计海运途中', ARRIVED_DESTINATION_PORT: '预计船舶到目的港',
+  DISCHARGED_FROM_VESSEL: '预计卸船', PICKUP_READY: '预计可提柜', PICKED_UP: '预计提柜', EMPTY_RETURNED: '预计还柜',
+}
+
+export function customerTransportRows(fragments: MerchantTransportFragment[]) {
+  return fragments.flatMap((fragment, index) => fragment.nodes.map((node, nodeIndex) => ({
+    key: `${index}-${nodeIndex}`,
+    inboundCode: fragment.inboundCode || '—', cabinetNo: fragment.cabinetNo || '—',
+    containerNo: fragment.containerNo || '—',
+    nodeLabel: (node.actualAt ? labels : estimatedLabels)[node.standardNode] || '运输节点',
+    actualAt: node.actualAt, estimatedAt: node.estimatedAt,
+    location: [node.locationCode, node.locationName].filter(Boolean).join(' · ') || '—',
+    source: node.providerCode === 'MANUAL' ? '人工记录' : node.providerCode === 'FIRSTLEG' ? '平台记录' : node.providerCode ? '承运轨迹' : '—',
+  })))
+}

src/modules/first-leg/views/CustomsDocumentsView.test.mjs

@@ -0,0 +1,285 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+
+function evaluate(source, dependencies = {}) {
+  const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+  const exports = {}
+  new Function('require', 'exports', code)(id => {
+    assert.ok(id in dependencies, `Unexpected dependency ${id}`)
+    return dependencies[id]
+  }, exports)
+  return exports
+}
+const eligibility = evaluate(readFileSync(new URL('../utils/customsEligibility.ts', import.meta.url), 'utf8'))
+const customsApi = evaluate(readFileSync(new URL('../api/customs.ts', import.meta.url), 'utf8'), {
+  '@/api/http': {}, '@/modules/first-leg/api/firstLeg': {},
+})
+const order = (id, status = 'LOADED', taxMode = 'TAX_REFUND') => ({ id, status, taxMode, hasCompletedLoadingPlan: ['LOADED', 'DELIVERED', 'COMPLETED'].includes(status), orderNo: `ORDER-${id}`, businessSummary: { inboundCode: `IN-${id}` } })
+const detail = id => ({ status: 'COMPLETED', merchantStatus: 'CUSTOMS_COMPLETED', inbounds: [{ orderId: id, taxMode: 'TAX_REFUND' }] })
+function harness(t, orders, getDetail = async id => detail(id)) {
+  const store = { loadError: '', failPage: 0, transformPage: value => value }, calls = [], pageCalls = []
+  const unifiedApi = evaluate(readFileSync(new URL('../api/unifiedOrders.ts', import.meta.url), 'utf8'), {
+    '@/api/http': { apiRequest: async ({ method, url, params: { page, size, taxMode, loaded } }) => {
+      assert.equal(method, 'GET')
+      assert.equal(url, '/merchant/v1/orders')
+      pageCalls.push({ page, size, taxMode, loaded })
+      if (store.loadError || store.failPage === page) throw new Error(store.loadError || '第二页订单查询失败')
+      // Model server filtering BEFORE pagination and COUNT, using the actual
+      // request produced by the production API. Missing taxMode scans all rows.
+      const filtered = orders.filter(row => (!taxMode || row.taxMode === taxMode)
+        && (loaded === undefined || row.hasCompletedLoadingPlan === loaded))
+      return store.transformPage({ page, size, total: filtered.length, pages: Math.ceil(filtered.length / size),
+        records: filtered.slice((page - 1) * size, page * size).map(row => ({ orderId: row.id, orderNo: row.orderNo, mainStatus: row.status, taxMode: row.taxMode, inboundCode: row.businessSummary.inboundCode })) })
+    } },
+  })
+  const reader = evaluate(readFileSync(new URL('../utils/customsDocumentsReader.ts', import.meta.url), 'utf8'), {
+    './customsEligibility': eligibility,
+    '../api/unifiedOrders': unifiedApi,
+    '../api/customs': { getMerchantCustomsForOrder: id => { calls.push(id); return getDetail(id) }, isMerchantCustomsUnavailable: error => error?.code === 'A0404' },
+  })
+  const source = readFileSync(new URL('./CustomsDocumentsView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const scope = vue.effectScope()
+  const view = scope.run(() => evaluate(source + '\nexport { load, records, loading, errorMessage, openDetail, selectedOrderId, selectedDetail, dialogOpen, search, queryModel, filteredRecords, pagedRecords, page, pageSize, queryFields, statusLabel, statusType, updateDetail }', {
+    vue: { ...vue, onMounted() {} },
+    '../utils/customsDocumentsReader': reader,
+    '../api/customs': customsApi,
+    '../store/customsPending': { useCustomsPendingStore: () => ({ refresh: async () => {} }) },
+  }))
+  t.after(() => scope.stop())
+  return { view, store, calls, pageCalls }
+}
+
+test('server-filtered request reaches five refund records originally on page 28 without scanning buy orders', async t => {
+  const orders = Array.from({ length: 5528 }, (_, i) => order(`buy-${i}`, 'COMPLETED', 'BUY_DECLARATION'))
+  orders.push(...Array.from({ length: 2613 }, (_, i) => order(`not-loaded-${i}`, 'WAIT_MEASURE')))
+  orders.push(...Array.from({ length: 5 }, (_, i) => order(`historical-${i}`, 'COMPLETED')))
+  const { view, calls, pageCalls } = harness(t, orders)
+  await view.load()
+  assert.deepEqual(calls, Array.from({ length: 5 }, (_, i) => `historical-${i}`))
+  assert.equal(view.records.value.length, 5)
+  assert.deepEqual(pageCalls, [{ page: 1, size: 200, taxMode: 'TAX_REFUND', loaded: true }])
+  view.queryModel.value.inboundCode = 'historical-4'; view.search()
+  assert.equal(view.filteredRecords.value.length, 1)
+  view.queryModel.value = { orderNo: '', inboundCode: '', containerNo: '', status: '' }; view.search()
+  assert.equal(view.filteredRecords.value.length, 5)
+  assert.equal(pageCalls.length, 1)
+  assert.equal(calls.length, 5)
+})
+
+test('second page failure is explicit and retry does not retain an incomplete result', async t => {
+  const orders = Array.from({ length: 201 }, (_, i) => order(String(i)))
+  const { view, store, pageCalls } = harness(t, orders)
+  store.failPage = 2
+  await view.load()
+  assert.equal(view.records.value.length, 0)
+  assert.equal(view.errorMessage.value, '第二页订单查询失败')
+  store.failPage = 0
+  await view.load()
+  assert.equal(view.records.value.length, 201)
+  assert.equal(view.errorMessage.value, '')
+  assert.equal(pageCalls.length, 4)
+})
+
+test('display pagination reaches the final refund order without refetching or opening the wrong detail', async t => {
+  const { view, calls, pageCalls } = harness(t, Array.from({ length: 21 }, (_, i) => order(`refund-${i}`, 'COMPLETED')))
+  await view.load()
+  assert.equal(view.pagedRecords.value.length, 20)
+  view.page.value = 2
+  assert.deepEqual(view.pagedRecords.value.map(row => row.order.id), ['refund-20'])
+  view.openDetail(view.pagedRecords.value[0])
+  assert.equal(view.selectedOrderId.value, 'refund-20')
+  assert.deepEqual(view.selectedDetail.value.inbounds, [{ orderId: 'refund-20', taxMode: 'TAX_REFUND' }])
+  view.pageSize.value = 10
+  await vue.nextTick()
+  assert.equal(view.page.value, 1)
+  assert.equal(view.pagedRecords.value.length, 10)
+  view.page.value = 3
+  assert.deepEqual(view.pagedRecords.value.map(row => row.order.id), ['refund-20'])
+  assert.equal(pageCalls.length, 1)
+  assert.equal(calls.length, 21)
+})
+
+test('searching from a later display page resets pagination and clearing filters restores all documents', async t => {
+  const { view, calls } = harness(t, Array.from({ length: 21 }, (_, i) => order(`refund-${i}`)))
+  await view.load()
+  view.page.value = 2
+  view.queryModel.value.inboundCode = 'IN-refund-20'
+  view.search()
+  await vue.nextTick()
+  assert.equal(view.page.value, 1)
+  assert.deepEqual(view.pagedRecords.value.map(row => row.order.id), ['refund-20'])
+  view.queryModel.value.inboundCode = 'does-not-exist'
+  view.search()
+  await vue.nextTick()
+  assert.equal(view.page.value, 1)
+  assert.equal(view.pagedRecords.value.length, 0)
+  view.queryModel.value.inboundCode = ''
+  view.search()
+  assert.equal(view.filteredRecords.value.length, 21)
+  assert.equal(view.pagedRecords.value.length, 20)
+  assert.equal(calls.length, 21)
+})
+
+test('refresh failure on a later page clears stale rows and retry returns to a valid page', async t => {
+  const { view, store } = harness(t, Array.from({ length: 21 }, (_, i) => order(`refund-${i}`)))
+  await view.load()
+  view.page.value = 2
+  store.loadError = '资料列表请求失败'
+  await view.load()
+  await vue.nextTick()
+  assert.equal(view.page.value, 1)
+  assert.equal(view.pagedRecords.value.length, 0)
+  assert.equal(view.errorMessage.value, '资料列表请求失败')
+  store.loadError = ''
+  await view.load()
+  assert.equal(view.page.value, 1)
+  assert.equal(view.pagedRecords.value.length, 20)
+  assert.equal(view.filteredRecords.value.length, 21)
+  assert.equal(view.errorMessage.value, '')
+})
+
+test('empty pages, duplicate records and changing totals cannot silently truncate history', async t => {
+  for (const change of [
+    response => response.page === 2 ? { ...response, records: [] } : response,
+    response => response.page === 2 ? { ...response, records: [{ ...response.records[0], orderId: '0' }] } : response,
+    response => response.page === 2 ? { ...response, total: 202 } : response,
+  ]) {
+    const { view, store, pageCalls } = harness(t, Array.from({ length: 201 }, (_, i) => order(String(i), 'COMPLETED')))
+    store.transformPage = change
+    await view.load()
+    assert.ok(view.errorMessage.value)
+    assert.equal(view.records.value.length, 0)
+    assert.equal(pageCalls.length, 2)
+  }
+})
+
+test('document fetch concurrency never exceeds four and each candidate is requested once', async t => {
+  let active = 0, peak = 0
+  const { view, calls, pageCalls } = harness(t, Array.from({ length: 205 }, (_, i) => order(String(i))), async id => {
+    active += 1; peak = Math.max(peak, active)
+    await new Promise(resolve => setImmediate(resolve))
+    active -= 1
+    return detail(id)
+  })
+  await view.load()
+  assert.equal(peak, 4)
+  assert.equal(new Set(calls).size, 205)
+  assert.equal(calls.length, 205)
+  assert.equal(pageCalls.length, 2)
+  assert.deepEqual(pageCalls, [{ page: 1, size: 200, taxMode: 'TAX_REFUND', loaded: true }, { page: 2, size: 200, taxMode: 'TAX_REFUND', loaded: true }])
+  assert.equal(view.records.value.length, 205)
+})
+
+test('empty result uses one page request and no document requests', async t => {
+  const { view, calls, pageCalls } = harness(t, [])
+  await view.load()
+  assert.equal(pageCalls.length, 1)
+  assert.equal(calls.length, 0)
+  assert.equal(view.errorMessage.value, '')
+})
+
+test('tax-refund documents remain accessible through delivered and completed orders; buy orders and preloading are excluded', async t => {
+  const stages = ['DRAFT', 'PENDING_REVIEW', 'WAIT_MEASURE', 'WAIT_PALLETIZE', 'WAIT_SPLIT', 'LOADING', 'LOADED', 'DELIVERED', 'COMPLETED']
+  const orders = stages.flatMap(status => [order(status, status), order(`BUY-${status}`, status, 'BUY_DECLARATION')])
+  const { view, calls } = harness(t, orders)
+  await view.load()
+  assert.deepEqual(calls, ['LOADED', 'DELIVERED', 'COMPLETED'])
+  assert.deepEqual(view.records.value.map(row => row.order.id), calls)
+  const completed = view.records.value.find(row => row.order.id === 'COMPLETED')
+  view.openDetail(completed)
+  assert.equal(view.selectedOrderId.value, 'COMPLETED')
+  assert.equal(view.selectedDetail.value.status, 'COMPLETED')
+  assert.equal(view.dialogOpen.value, true)
+  view.queryModel.value.status = 'CUSTOMS_COMPLETED'; view.search()
+  assert.equal(view.filteredRecords.value.length, 3)
+  assert.equal(calls.length, 3, 'local filtering does not refetch documents')
+})
+
+test('only matching server-returned tax-refund ownership is displayed', async t => {
+  const { view } = harness(t, [order('one'), order('two')], async id => id === 'one' ? detail('someone-else') : { inbounds: [{ orderId: id, taxMode: 'BUY_DECLARATION' }] })
+  await view.load()
+  assert.equal(view.records.value.length, 0)
+})
+
+test('partial failures are visible and retry replaces the result; unavailable customs is not a transport failure', async t => {
+  let fail = true
+  const { view } = harness(t, [order('ok'), order('retry'), order('unavailable')], async id => {
+    if (id === 'unavailable') throw Object.assign(new Error('not associated'), { code: 'A0404' })
+    if (id === 'retry' && fail) throw new Error('network')
+    return detail(id)
+  })
+  await view.load()
+  assert.equal(view.records.value.length, 1)
+  assert.equal(view.errorMessage.value, '1 票订单的报关资料加载失败，请重新加载')
+  fail = false; await view.load()
+  assert.equal(view.records.value.length, 2)
+  assert.equal(view.errorMessage.value, '')
+})
+
+test('order query failure is shown instead of a successful empty result', async t => {
+  const { view, store, calls } = harness(t, [order('old')])
+  await view.load()
+  store.loadError = '订单查询失败'; await view.load()
+  assert.equal(view.records.value.length, 0)
+  assert.equal(view.errorMessage.value, '订单查询失败')
+  assert.equal(calls.length, 1)
+  assert.equal(view.loading.value, false)
+})
+
+test('repeated refresh during an active load does not duplicate requests', async t => {
+  let resolve
+  const pending = new Promise(done => { resolve = done })
+  const { view, calls } = harness(t, [order('one')], () => pending)
+  const first = view.load()
+  await Promise.resolve()
+  await view.load()
+  assert.deepEqual(calls, ['one'])
+  resolve(detail('one')); await first
+  assert.equal(view.loading.value, false)
+})
+
+test('mixed-container labels and filters use only the current customer status', async t => {
+  const states = [
+    ['uploaded', 'WAITING_CUSTOMER_DOCUMENTS', 'DOCUMENT_UPLOADED', 1, '资料已上传', 'success'],
+    ['waiting', 'WAITING_CUSTOMER_DOCUMENTS', 'WAITING_UPLOAD', 0, '待上传资料', 'warning'],
+    ['declaring', 'DECLARING', 'DECLARING', 1, '报关中', 'primary'],
+    ['completed', 'COMPLETED', 'CUSTOMS_COMPLETED', 1, '报关完成', 'success'],
+  ]
+  const { view, calls } = harness(t, states.map(([id]) => order(id)), async id => {
+    const [, status, merchantStatus, coveredTaxRefundCount] = states.find(row => row[0] === id)
+    return { ...detail(id), status, merchantStatus, coveredTaxRefundCount, taxRefundCount: 1 }
+  })
+  await view.load()
+  for (const [id, , merchantStatus, , label, tone] of states) {
+    const row = view.records.value.find(item => item.order.id === id)
+    assert.equal(view.statusLabel(row.detail), label)
+    assert.equal(view.statusType(row.detail), tone)
+    view.queryModel.value.status = merchantStatus; view.search()
+    assert.deepEqual(view.filteredRecords.value.map(item => item.order.id), [id])
+  }
+  assert.deepEqual(view.queryFields.find(field => field.key === 'status').options,
+    states.map(([, , value, , label]) => ({ value, label })).sort((a, b) =>
+      ['WAITING_UPLOAD', 'DOCUMENT_UPLOADED', 'DECLARING', 'CUSTOMS_COMPLETED'].indexOf(a.value)
+      - ['WAITING_UPLOAD', 'DOCUMENT_UPLOADED', 'DECLARING', 'CUSTOMS_COMPLETED'].indexOf(b.value)))
+  view.queryModel.value.status = 'WAITING_CUSTOMER_DOCUMENTS'; view.search()
+  assert.equal(view.filteredRecords.value.length, 0, 'container statuses are not customer filter values')
+  view.queryModel.value.status = ''; view.search()
+  assert.equal(view.filteredRecords.value.length, 4)
+  assert.equal(calls.length, 4, 'filtering does not requery or infer status from coverage')
+})
+
+test('dialog update refreshes customer status and active filter without inferring from container status', async t => {
+  const { view } = harness(t, [order('one')], async id => ({ ...detail(id), status: 'WAITING_CUSTOMER_DOCUMENTS', merchantStatus: 'WAITING_UPLOAD' }))
+  await view.load(); view.openDetail(view.records.value[0])
+  view.queryModel.value.status = 'WAITING_UPLOAD'; view.search()
+  view.updateDetail({ ...detail('one'), status: 'WAITING_CUSTOMER_DOCUMENTS', merchantStatus: 'DOCUMENT_UPLOADED', coveredTaxRefundCount: 1, taxRefundCount: 1 })
+  assert.equal(view.filteredRecords.value.length, 0)
+  view.queryModel.value.status = 'DOCUMENT_UPLOADED'; view.search()
+  assert.equal(view.filteredRecords.value.length, 1)
+  assert.equal(view.statusLabel(view.filteredRecords.value[0].detail), '资料已上传')
+  assert.equal(view.statusLabel({ status: 'COMPLETED', coveredTaxRefundCount: 1, taxRefundCount: 1 }), '—')
+  assert.equal(view.statusType({ status: 'COMPLETED' }), 'info')
+})

src/modules/first-leg/views/CustomsDocumentsView.vue

@@ -0,0 +1,119 @@
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from 'vue'
+import { RefreshCcw } from '@lucide/vue'
+import DataTable, { type DataTableColumn } from '@/components/common/DataTable.vue'
+import QueryToolbar, { type QueryField, type QueryModel } from '@/components/common/QueryToolbar.vue'
+import type { TableAction } from '@/components/common/tableActions'
+import { MERCHANT_CUSTOMS_STATUS_LABELS, type MerchantCustomsContainer } from '../api/customs'
+import { readCustomsDocuments, type CustomsDocumentRow } from '../utils/customsDocumentsReader'
+import CustomsDocumentsDialog from '../components/CustomsDocumentsDialog.vue'
+
+import { useCustomsPendingStore } from '../store/customsPending'
+
+const customsPending = useCustomsPendingStore()
+const loading = ref(false)
+const errorMessage = ref('')
+const queryModel = ref<QueryModel>({ orderNo: '', inboundCode: '', containerNo: '', status: '' })
+const appliedQuery = ref<QueryModel>({ ...queryModel.value })
+const page = ref(1)
+const pageSize = ref(20)
+const queryFields: QueryField[] = [
+  { key: 'orderNo', label: '订单号', type: 'input', placeholder: '请输入订单号' },
+  { key: 'inboundCode', label: '入仓码', type: 'input', placeholder: '请输入入仓码' },
+  { key: 'containerNo', label: '柜号', type: 'input', placeholder: '请输入柜号' },
+  { key: 'status', label: '状态', type: 'select', placeholder: '全部', options: Object.entries(MERCHANT_CUSTOMS_STATUS_LABELS).map(([value, label]) => ({ label, value })) },
+]
+const columns: DataTableColumn[] = [
+  { label: '操作', slotName: 'actions', width: 120, fixed: 'left' },
+  { label: '订单号', slotName: 'orderNo', minWidth: 230 },
+  { label: '入仓码', slotName: 'inboundCode', minWidth: 190 },
+  { label: '柜号', slotName: 'containerNo', minWidth: 170 },
+  { label: '柜内退税箱数', prop: 'detail.actualBoxCount', width: 110, align: 'center' },
+  { label: '柜内资料覆盖', slotName: 'coverage', width: 110, align: 'center' },
+  { label: '状态', slotName: 'status', width: 130 },
+]
+const records = ref<CustomsDocumentRow[]>([])
+const dialogOpen = ref(false)
+const selectedOrderId = ref('')
+const selectedDetail = ref<MerchantCustomsContainer | null>(null)
+
+const filteredRecords = computed(() => {
+  const query = appliedQuery.value
+  const matches = (value: string | null | undefined, key: string) => String(value ?? '').toLowerCase().includes(String(query[key] || '').trim().toLowerCase())
+  return records.value.filter(({ order, detail }) =>
+    matches(order.orderNo, 'orderNo')
+    && matches(order.businessSummary.inboundCode, 'inboundCode')
+    && (matches(detail.containerNo, 'containerNo') || matches(detail.cabinetNo, 'containerNo'))
+    && (!query.status || detail.merchantStatus === query.status),
+  )
+})
+const pagedRecords = computed(() => filteredRecords.value.slice((page.value - 1) * pageSize.value, page.value * pageSize.value))
+const emptyText = computed(() => Object.values(appliedQuery.value).some((value) => String(value || '').trim()) ? '暂无匹配的报关资料，请调整查询条件' : '暂无报关资料')
+
+function search() {
+  appliedQuery.value = { ...queryModel.value }
+  page.value = 1
+}
+watch(pageSize, () => { page.value = 1 })
+watch(() => filteredRecords.value.length, (total) => {
+  page.value = Math.min(page.value, Math.max(1, Math.ceil(total / pageSize.value)))
+})
+function rowActions(row: object): TableAction[] {
+  return [{ key: 'documents', label: '查看资料', disabled: loading.value, run: () => openDetail(row) }]
+}
+
+function statusLabel(detail: MerchantCustomsContainer) {
+  return detail.merchantStatus ? MERCHANT_CUSTOMS_STATUS_LABELS[detail.merchantStatus] ?? '—' : '—'
+}
+function statusType(detail: MerchantCustomsContainer) {
+  return detail.merchantStatus === 'CUSTOMS_COMPLETED' || detail.merchantStatus === 'DOCUMENT_UPLOADED'
+    ? 'success' : detail.merchantStatus === 'DECLARING' ? 'primary' : detail.merchantStatus === 'WAITING_UPLOAD' ? 'warning' : 'info'
+}
+async function load() {
+  if (loading.value) return
+  void customsPending.refresh(true)
+  loading.value = true; errorMessage.value = ''
+  try {
+    const { records: loadedRecords, failedCount } = await readCustomsDocuments()
+    records.value = loadedRecords
+    if (failedCount) errorMessage.value = `${failedCount} 票订单的报关资料加载失败，请重新加载`
+  } catch (error) {
+    records.value = []
+    errorMessage.value = error instanceof Error ? error.message : '报关资料加载失败，请稍后重试'
+  } finally { loading.value = false }
+}
+function openDetail(item: unknown) {
+  const value = item as CustomsDocumentRow
+  selectedOrderId.value = value.order.id; selectedDetail.value = value.detail; dialogOpen.value = true
+}
+function updateDetail(value: MerchantCustomsContainer) {
+  const found = records.value.find((item) => item.order.id === selectedOrderId.value)
+  if (found) found.detail = value
+}
+onMounted(() => { void load() })
+</script>
+
+<template>
+  <div class="customs-page">
+    <QueryToolbar v-model="queryModel" layout="grid" ariaLabel="报关资料查询条件" :fields="queryFields" @search="search" />
+    <section class="customs-card">
+      <DataTable v-model:page="page" v-model:page-size="pageSize" :data="pagedRecords" :columns="columns" :loading="loading" :total="filteredRecords.length" :page-sizes="[10, 20, 50, 100]" :row-actions="rowActions" row-key="order.id" :empty-text="emptyText">
+        <template #toolbar><strong>资料列表</strong><span>统计为本客户同柜退税货物汇总，资料覆盖按入仓码计。</span></template>
+        <template #toolbar-actions><el-button :loading="loading" @click="load"><RefreshCcw :size="16" />刷新</el-button></template>
+        <template v-if="errorMessage" #error><div class="state-error" role="alert"><span>{{ errorMessage }}</span><el-button :loading="loading" @click="load">重新加载</el-button></div></template>
+        <template #orderNo="{ row }">{{ row.order.orderNo || '—' }}</template>
+        <template #inboundCode="{ row }">{{ row.order.businessSummary.inboundCode || '—' }}</template>
+        <template #containerNo="{ row }">{{ row.detail.containerNo || row.detail.cabinetNo || '—' }}</template>
+        <template #coverage="{ row }">{{ row.detail.coveredTaxRefundCount }} / {{ row.detail.taxRefundCount }}</template>
+        <template #status="{ row }"><el-tag :type="statusType(row.detail)" effect="light" size="small">{{ statusLabel(row.detail) }}</el-tag></template>
+      </DataTable>
+    </section>
+    <CustomsDocumentsDialog v-model="dialogOpen" :order-id="selectedOrderId" :can-edit="selectedDetail?.status !== 'COMPLETED'" :initial-detail="selectedDetail" @updated="updateDetail" />
+  </div>
+</template>
+
+<style scoped>
+.customs-page { display: grid; gap: var(--client-section-gap); }
+.customs-card { overflow: hidden; border: 1px solid var(--client-border); border-radius: var(--client-radius); background: #fff; }
+.state-error { display: flex; min-height: 84px; align-items: center; justify-content: center; gap: 12px; padding: 14px; color: #b42318; }
+</style>

src/modules/first-leg/views/FirstLegOrderCreateHubView.vue

@@ -0,0 +1,41 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import { FilePenLine, Zap } from '@lucide/vue'
+import { useRoute, useRouter } from 'vue-router'
+import { useAuthStore } from '@/modules/auth/public'
+import FirstLegOrdersView from './FirstLegOrdersView.vue'
+import QuickOrderView from './QuickOrderView.vue'
+
+const route = useRoute()
+const router = useRouter()
+const auth = useAuthStore()
+const canQuickOrder = computed(() => auth.hasPermission('order:first-leg:quick-create'))
+const activeMode = computed<'standard' | 'quick'>(() => route.query.mode === 'quick' && canQuickOrder.value ? 'quick' : 'standard')
+
+function selectMode(mode: 'standard' | 'quick') {
+  if (mode === 'quick' && !canQuickOrder.value) return
+  const query = { ...route.query }
+  if (mode === 'quick') query.mode = 'quick'
+  else delete query.mode
+  void router.replace({ name: 'first-leg-order-create', query })
+}
+</script>
+
+<template>
+  <section class="first-leg-create-hub">
+    <h1 class="create-hub-title">头程下单</h1>
+    <div class="create-mode-toolbar">
+      <nav v-if="canQuickOrder" class="order-mode-switch" aria-label="头程下单方式">
+        <button type="button" :class="{ active: activeMode === 'standard' }" :aria-current="activeMode === 'standard' ? 'page' : undefined" @click="selectMode('standard')"><FilePenLine :size="16" />普通下单</button>
+        <button type="button" :class="{ active: activeMode === 'quick' }" :aria-current="activeMode === 'quick' ? 'page' : undefined" @click="selectMode('quick')"><Zap :size="16" />快速下单</button>
+      </nav>
+      <span v-if="canQuickOrder" class="create-mode-caption">选择下单方式</span>
+    </div>
+    <FirstLegOrdersView v-if="activeMode === 'standard'" create-page />
+    <QuickOrderView v-else />
+  </section>
+</template>
+
+<style scoped>
+.first-leg-create-hub{display:grid;min-width:0;gap:10px}.create-hub-title{margin:0;color:var(--navy);font-size:22px;line-height:1.25}.create-mode-toolbar{display:flex;min-width:0;align-items:center;gap:12px}.create-mode-caption{color:#94a0af;font-size:12px;font-weight:500}.order-mode-switch{display:inline-flex;width:max-content;padding:4px;border:1px solid #d5e0e7;border-radius:8px;background:#edf3f6;box-shadow:inset 0 1px 2px rgba(15,23,42,.035)}.order-mode-switch button{display:inline-flex;height:36px;min-width:112px;align-items:center;justify-content:center;gap:7px;padding:0 16px;border:0;border-radius:6px;background:transparent;color:#607087;font:inherit;font-size:12px;font-weight:650;cursor:pointer}.order-mode-switch button.active{background:linear-gradient(105deg,#118fa1,#176b87);color:#fff;box-shadow:0 5px 13px rgba(23,107,135,.24)}.order-mode-switch button:focus-visible{outline:2px solid var(--primary);outline-offset:2px}
+</style>

src/modules/first-leg/views/FirstLegOrdersView.test.mjs

@@ -5,22 +5,25 @@ import test from 'node:test'
 const source = readFileSync(new URL('./FirstLegOrdersView.vue', import.meta.url), 'utf8')
 const tableSource = readFileSync(new URL('../../../components/common/DataTable.vue', import.meta.url), 'utf8')
 const querySource = readFileSync(new URL('../../../components/common/QueryToolbar.vue', import.meta.url), 'utf8')
+const clientUiSource = readFileSync(new URL('../../../styles/client-ui.css', import.meta.url), 'utf8')
 const routerSource = readFileSync(new URL('../routes.ts', import.meta.url), 'utf8')
 const editorShellSource = readFileSync(new URL('../components/FirstLegOrderEditorShell.vue', import.meta.url), 'utf8')
 const progressSource = readFileSync(new URL('../components/OrderProgressPanel.vue', import.meta.url), 'utf8')
 const customsDialogSource = readFileSync(new URL('../components/CustomsDocumentsDialog.vue', import.meta.url), 'utf8')
 const customsApiSource = readFileSync(new URL('../api/customs.ts', import.meta.url), 'utf8')
 const orderStoreSource = readFileSync(new URL('../store/firstLegOrders.ts', import.meta.url), 'utf8')
+const createHubSource = readFileSync(new URL('./FirstLegOrderCreateHubView.vue', import.meta.url), 'utf8')
 
 test('routes the confirmed first-leg path to the implemented order view', () => {
   assert.match(routerSource, /path: 'orders\/first-leg'[\s\S]*?component: \(\) => import\('\.\/views\/FirstLegOrdersView\.vue'\)[\s\S]*?release: 'active'/)
 })
 
 test('opens order creation as a dedicated protected page while keeping draft editing in a large dialog', () => {
-  assert.match(routerSource, /path: 'orders\/first-leg\/create'[\s\S]*?name: 'first-leg-order-create'[\s\S]*?release: 'active'[\s\S]*?permission: 'order:first-leg:create'/)
+  assert.match(routerSource, /path: 'orders\/first-leg\/create'[\s\S]*?name: 'first-leg-order-create'[\s\S]*?release: 'active'[\s\S]*?permission: 'order:first-leg:create'[\s\S]*?keepAlive: false/)
-  assert.match(routerSource, /name: 'first-leg-order-create'[\s\S]*?props: \{ createPage: true \}/)
+  assert.match(routerSource, /name: 'first-leg-order-create'[\s\S]*?FirstLegOrderCreateHubView\.vue/)
+  assert.match(createHubSource, /<FirstLegOrdersView v-if="activeMode === 'standard'" create-page \/>/)
   assert.match(source, /router\.push\(\{ name: 'first-leg-order-create' \}\)/)
-  assert.match(source, /defineProps<\{ createPage\?: boolean \}>/)
+  assert.match(source, /defineProps<\{ createPage\?: boolean; detailPage\?: boolean; showCreateAction\?: boolean \}>/)
   assert.match(source, /const isCreatePage = computed\(\(\) => props\.createPage\)/)
   assert.match(source, /<FirstLegOrderEditorShell[^>]*:page="isCreatePage"/)
   assert.match(editorShellSource, /<section v-if="page" class="first-leg-editor-page">/)
@@ -32,21 +35,38 @@ test('opens order creation as a dedicated protected page while keeping draft edi
   assert.match(editorShellSource, /\.editor-page-footer :deep\(\.editor-actions\) \{[^}]*justify-content: center;/)
 })
 
-test('exposes real list, draft, submit, and detail workflow entries without cancellation', () => {
+test('exposes real list, draft, submit, and detail workflow entries', () => {
   assert.match(source, /function openCreate\(\)/)
   assert.match(source, /async function saveDraft\(\)/)
   assert.match(source, /function submitOrder\(\)/)
   assert.match(source, /async function openDetail\(order: FirstLegOrder\)/)
   assert.match(source, /Promise\.allSettled\(\[/)
-  assert.match(source, /const orderPageRequest = isCreatePage\.value\s*\? store\.loadWarehouseType\('DOMESTIC', true\)\s*:\s*store\.load\(\{ includeDrafts: true \}\)/)
+  assert.match(source, /const orderPageRequest = isCreatePage\.value \|\| isDetailPage\.value\s*\? store\.loadWarehouseType\('DOMESTIC', true\)\s*:\s*loadOrderPage\(\)/)
   assert.match(source, /Promise\.allSettled\(\[\s*orderPageRequest,\s*companyRequest/)
   assert.match(source, /tenantStore\.loadCompanyContext\(\)/)
-  assert.match(source, /await store\.loadDetail\(order\.id\)/)
+  assert.match(source, /await store\.loadDetail\(orderId\)/)
-  assert.doesNotMatch(source, /cancelOrder|取消订单/)
+})
+
+test('returns edited submissions to the refreshed order list instead of opening detail', () => {
+  const submitSource = source.slice(source.indexOf('async function submitOrder()'), source.indexOf('async function searchOrders'))
+  assert.match(submitSource, /if \(isCreatePage\.value\)[\s\S]*router\.push\(\{ name: 'first-leg-orders' \}\)[\s\S]*return/)
+  assert.match(submitSource, /await loadPageData\(\)/)
+  assert.doesNotMatch(submitSource, /first-leg-order-detail/)
+})
+
+test('copies an order into the dedicated create page without reusing order identity', () => {
+  assert.match(source, /key: 'copy', label: '复制下单'/)
+  assert.match(source, /name: 'first-leg-order-create'[\s\S]*copyFrom: order\.id/)
+  assert.match(source, /order\.status === 'DRAFT' \? \{ copyDraft: '1' \}/)
+  assert.match(source, /sourceIsDraft \? await store\.loadDraftDetail\(id\) : await store\.loadDetail\(id\)/)
+  assert.match(source, /const draft = draftFromOrder\(order\)[\s\S]*inboundCode: ''/)
+  assert.match(source, /id: `copied-cargo-\$\{\+\+cargoSequence\}`/)
+  assert.match(source, /editingId\.value = undefined/)
+  assert.match(source, /订单数据已复制，请核对后提交/)
 })
 
 test('keeps create-page support errors scoped to create-page requests', () => {
-  assert.match(source, /if \(!isCreatePage\.value && store\.draftLoadError\)/)
+  assert.doesNotMatch(source, /store\.draftLoadError/)
 })
 
 test('blocks order submission before company approval while preserving draft actions', () => {
@@ -71,8 +91,8 @@ test('renders dynamic cargo lines and a responsive editor dialog', () => {
   assert.match(source, /function removeCargoItem\(index: number\)/)
   assert.match(editorShellSource, /first-leg-editor-dialog\.el-dialog\) \{[^}]*height: 94vh;/)
   assert.match(editorShellSource, /width: 100vw !important; height: 100vh;/)
-  assert.match(source, /class="mobile-order-list"/)
+  assert.doesNotMatch(source, /class="mobile-order-(?:list|card|surface)"/)
-  assert.match(source, /\.prototype-order-table :deep\(> \.el-table\), \.prototype-order-table :deep\(> \.data-table__pagination\) \{ display: none; \}/)
+  assert.doesNotMatch(source, /\.prototype-order-table :deep\(> \.el-table\).*display: none/)
 })
 
 test('uses the full editor dialog width for cargo details and cost estimates', () => {
@@ -94,7 +114,7 @@ test('uses the shared query toolbar and data table without metric cards', () =>
   assert.match(source, /<QueryToolbar v-model="filters" class="first-leg-query-toolbar" layout="grid" :fields="queryFields" ariaLabel="订单查询" @search="searchOrders" \/>/)
   assert.match(source, /async function searchOrders\(model: QueryModel\)/)
   assert.match(source, /await store\.load\(\{/)
-  assert.match(source, /<DataTable v-model:page="tablePage" v-model:page-size="tablePageSize" :data="pagedOrders" :columns="visibleOrderColumns"/)
+  assert.match(source, /<DataTable :page="tablePage" :page-size="tablePageSize" @update:page="changeOrderPage" @update:page-size="changeOrderPageSize" :data="pagedOrders" :columns="visibleOrderColumns"/)
   assert.match(source, /\{ key: 'actions', label: '操作', width: 284, fixed: 'left', align: 'left', headerAlign: 'left', slotName: 'actions' \}/)
   assert.doesNotMatch(source, /order-metrics|订单概览/)
 })
@@ -143,7 +163,7 @@ test('downloads selected carton labels with one array request', () => {
 test('exports every visible order field with normalized dates', () => {
   assert.match(source, /function formatExportDateTime\(value: string \| null \| undefined\)/)
   assert.match(source, /return `\$\{date\.getFullYear\(\)\}-\$\{pad\(date\.getMonth\(\) \+ 1\)\}-\$\{pad\(date\.getDate\(\)\)\} \$\{pad\(date\.getHours\(\)\)\}:\$\{pad\(date\.getMinutes\(\)\)\}:\$\{pad\(date\.getSeconds\(\)\)\}`/)
-  for (const label of ['订单号', '入仓码', '渠道', '运输方式', '交货方式', '预约提货时间', '目的仓', '目的仓类型', '当前订单状态', '箱数', '快递公司', '快递单号', 'SKUS', '总毛重', '总净重', '总体积', '总数量', '计费单价', '计费体积', '计费重量', '备注', '货件编号', '跟踪编号', '国内仓入库时间', '创建时间']) {
+  for (const label of ['入仓码', '渠道', '运输方式', '交货方式', '预约提货时间', '目的仓', '目的仓类型', '当前订单状态', '箱数', '快递公司', '快递单号', 'SKUS', '总毛重', '总净重', '总体积', '总数量', '计费单价', '计费体积', '计费重量', '备注', '货件编号', '跟踪编号', '国内仓入库时间', '创建时间']) {
     assert.match(source, new RegExp(`'${label}'`))
   }
   assert.match(source, /formatExportDateTime\(order\.inboundedAt\)/)
@@ -155,6 +175,9 @@ test('exports every visible order field with normalized dates', () => {
 
 test('matches the prototype with selectable dense order-list columns', () => {
   assert.match(source, /aria-label="设置订单列表显示列"/)
+  assert.match(source, /显示字段筛选/)
+  assert.match(source, /const defaultVisibleColumnKeys = \['status', 'progress', 'channel', 'transportMode', 'pickupMethod', 'receivingWarehouse', 'createdAt'\]/)
+  assert.match(source, /key: 'inboundCode', label: '入仓码', width: 230, fixed: 'left'/)
   assert.match(source, /<SlidersHorizontal :size="18"/)
   assert.match(source, /<el-checkbox-group v-model="visibleColumnKeys"/)
   assert.match(source, /draggable="true"/)
@@ -183,54 +206,61 @@ test('matches the prototype with selectable dense order-list columns', () => {
 })
 
 test('keeps dense order identifiers on one line and aligns columns by content type', () => {
-  assert.match(source, /key: 'order'[\s\S]{0,160}showOverflowTooltip: true/)
+  assert.match(source, /key: 'inboundCode'[\s\S]{0,180}showOverflowTooltip: true/)
   assert.match(source, /key: 'status'[\s\S]{0,100}align: 'center'[\s\S]{0,100}headerAlign: 'center'/)
   assert.match(source, /key: 'grossWeight'[\s\S]{0,100}align: 'right'[\s\S]{0,100}headerAlign: 'right'/)
-  assert.match(source, /class="order-number-link table-code"/)
+  assert.match(source, /class="inbound-code-primary table-ellipsis table-code"/)
-  assert.doesNotMatch(source, /<template #order="\{ row \}">[\s\S]{0,400}class="order-reference"/)
+  assert.doesNotMatch(source, /<template #order="\{ row \}">/)
   assert.match(source, /\.table-ellipsis, \.table-multivalue \{[^}]*text-overflow: ellipsis;[^}]*white-space: nowrap;/)
-  assert.match(source, /\.order-number-link \{[^}]*text-overflow: ellipsis;[^}]*white-space: nowrap;/)
+  assert.match(source, /\.inbound-code-primary \{[^}]*text-overflow: ellipsis;[^}]*white-space: nowrap;/)
   assert.match(tableSource, /height: var\(--client-table-row-height\)/)
 })
 
 test('shows one unified progress line and C02 business summaries without detail history', () => {
   assert.match(source, /import OrderProgressPanel/)
-  assert.match(source, /<OrderProgressPanel :order="detailOrder" \/>/)
+  assert.match(source, /<OrderProgressPanel :order="detailOrder">[\s\S]*?<template #cabinet>/)
   assert.match(source, /<h3>关键业务摘要<\/h3>/)
   assert.match(source, /progressSummaryItems/)
   assert.match(source, /summary\.preloadStatus/)
   assert.match(source, /summary\.expectedPickCount/)
   assert.match(source, /summary\.deliveryTrackingNo/)
   assert.match(progressSource, /FIRST_LEG_PROGRESS_STAGES/)
-  assert.match(progressSource, /国内入仓、组托、装柜及后续履约同步/)
+  assert.match(progressSource, /订单主节点与关联柜次统一展示/)
+  assert.match(progressSource, /履约进度/)
   assert.doesNotMatch(progressSource, /进度记录|el-timeline|timeline/)
   assert.doesNotMatch(source, /<h3>报关回执<\/h3>/)
   assert.match(source, /船期摘要/)
-  assert.match(source, /柜次进度/)
+  assert.match(source, /柜次明细/)
+  assert.match(source, /pickingStatusLabel: getFirstLegPickingStatusLabel\(summary\.loadingStatus\)/)
+  assert.match(source, /prop="pickingStatusLabel" label="拣货状态"/)
+  assert.doesNotMatch(source, /label="当前节点"/)
+  assert.match(source, /尚未分配柜次，后续柜次节点将在这里同步。/)
+  assert.doesNotMatch(source, /暂无柜次分配信息/)
   assert.doesNotMatch(source, /summary\.sealNo \|\|/)
   assert.doesNotMatch(progressSource, /客户确认|差异处理中|派送中/)
 })
 
 test('uses only fields present on C02 rows before loading full detail', () => {
-  assert.match(source, /getOrderCargoSummary/)
+  assert.match(source, /orderPackageCount/)
   assert.match(source, /label: '渠道'/)
   assert.match(source, /label: '目的仓'/)
   assert.match(source, /displayListValue/)
   assert.doesNotMatch(source, /key: 'operator'/)
   assert.doesNotMatch(source, /key: 'transportMode', type: 'select'/)
-  assert.match(source, /store\.draftLoadError/)
+  assert.match(source, /:total="store\.total"/)
-  assert.match(source, /mainStatus: statusValue && statusValue !== 'DRAFT' \? statusValue : undefined/)
+  assert.match(source, /mainStatus: text\('status'\)/)
-  assert.match(source, /draftOnly: statusValue === 'DRAFT'/)
+  assert.match(source, /queue: activeOrderQueue\.value, page: requestedPage, size: tablePageSize\.value/)
   assert.match(source, /createdFrom: range\[0\] \? `\$\{range\[0\]\}T00:00:00`/)
 })
 
 test('shows and searches the inbound code after a draft is submitted', () => {
   assert.match(source, /label: '入仓码 \/ SKU'/)
   assert.match(source, /order\.businessSummary\.inboundCode/)
-  assert.match(source, /<template #inboundCode="\{ row \}">[\s\S]*?class="inbound-code-link table-ellipsis table-code"/)
+  assert.match(source, /<template #inboundCode="\{ row \}">[\s\S]*?class="inbound-code-primary table-ellipsis table-code"/)
-  assert.match(source, /v-if="order\.businessSummary\.inboundCode" class="order-reference inbound-code-link"/)
+  assert.match(source, /@click="openDetail\(row as FirstLegOrder\)"/)
   assert.match(source, /<dt>入仓码<\/dt><dd><button v-if="detailOrder\.businessSummary\.inboundCode"/)
-  assert.match(source, /<span v-else>—<\/span>/)
+  assert.match(source, /提交后生成/)
+  assert.doesNotMatch(source, /label: '订单号'/)
 })
 
 test('keeps all progress stages and business summary usable on mobile', () => {
@@ -242,7 +272,9 @@ test('keeps all progress stages and business summary usable on mobile', () => {
 test('keeps the first viewport compact and moves create into the table toolbar', () => {
   const tableToolbarSource = source.slice(source.indexOf('#toolbar-actions'), source.indexOf('class="order-eligibility is-pending"'))
   assert.match(source, /#toolbar-actions/)
-  assert.match(source, /<strong>订单列表<\/strong><span>共 \{\{ filteredOrders\.length \}\} 条<\/span>/)
+  assert.match(source, /class="order-queue-tabs"[\s\S]*v-for="queue in ORDER_QUEUES"[\s\S]*orderQueueCounts\[queue.key\]/)
+  assert.match(source, /activeOrderQueue\.value === 'draft'[\s\S]*order\.status === 'DRAFT'/)
+  assert.doesNotMatch(source, /共 \{\{ filteredOrders\.length \}\} 条/)
   assert.match(source, /#toolbar-actions[\s\S]*order:first-leg:create[\s\S]*创建订单[\s\S]*class="order-eligibility is-pending"/)
   assert.match(tableToolbarSource, /下载唛头[\s\S]*导出订单信息[\s\S]*批量提交草稿[\s\S]*创建订单/)
   assert.doesNotMatch(source.slice(source.indexOf('<QueryToolbar'), source.indexOf('<div class="client-card order-table-card">')), /下载唛头|导出订单信息|创建订单/)
@@ -299,6 +331,13 @@ test('selects platform destinations and uses customer-scoped server address book
   assert.match(source, /createMerchantOrderAddress\(payload\)/)
   assert.match(source, /updateMerchantOrderAddress\(form\.(?:senderAddressId|privateDestinationAddressId), payload\)/)
   assert.match(source, /disableMerchantOrderAddress\(id\)/)
+  assert.match(source, /function findAddressBookEntryId\(addressType: CustomerOrderAddress\['addressType'\], snapshot: FirstLegPartySnapshot \| null\)/)
+  assert.match(source, /senderAddressId: findAddressBookEntryId\('PICKUP', order\.shipperPartySnapshot\)/)
+  assert.match(source, /privateDestinationAddressId: findAddressBookEntryId\('PRIVATE_DESTINATION', order\.consigneePartySnapshot\)/)
+  assert.match(source, /function selectPickupAddress\(id: string \| null \| undefined\)[\s\S]*?form\.shipperPartySnapshot = createEmptyPartySnapshot\('SHIPPER'\)/)
+  assert.match(source, /function selectPrivateAddress\(id: string \| null \| undefined\)[\s\S]*?form\.consigneePartySnapshot = createEmptyPartySnapshot\('CONSIGNEE'\)/)
+  assert.match(source, /const existingAddressId = findAddressBookEntryId\('PICKUP', snapshot\)[\s\S]*?相同的企业提货地址已存在，已为您选中/)
+  assert.match(source, /const existingAddressId = findAddressBookEntryId\('PRIVATE_DESTINATION', snapshot\)[\s\S]*?相同的企业私人仓地址已存在，已为您选中/)
   assert.match(source, /v-model="form\.senderAddressId"/)
   assert.match(source, /v-model="form\.privateDestinationAddressId"/)
   assert.doesNotMatch(source, /localStorage|cc:first-leg:private-addresses/)
@@ -314,14 +353,15 @@ test('lets the create-page instance own destination loading and exposes a recove
 })
 
 test('shows a loading state before the list can create an order', () => {
-  assert.match(source, /<el-button v-if="auth\.hasPermission\('order:first-leg:create'\)" type="primary" :loading="pageDataLoading" :disabled="pageDataLoading \|\| availableWarehouses\.length === 0" @click="openCreate"><FilePlus2/)
+  assert.match(source, /<el-button v-if="props\.showCreateAction && auth\.hasPermission\('order:first-leg:create'\)" type="primary" :loading="pageDataLoading" :disabled="pageDataLoading \|\| availableWarehouses\.length === 0" @click="openCreate"><FilePlus2/)
   assert.match(source, /pageDataLoading \? '加载收货仓中' : \(availableWarehouses\.length \? '创建第一笔订单'/)
 })
 
 test('auto-fills trusted warehouse and company data instead of asking customers to repeat it', () => {
   assert.match(source, /async function selectDestinationWarehouse\(id: string\)/)
   assert.match(source, /await store\.loadWarehouseDetail\(warehouse\.id\)/)
-  assert.match(source, /availableWarehouses\.value\.length === 1/)
+  assert.match(source, /warehouse\.code\.toUpperCase\(\)\.includes\('YIWU'\)/)
+  assert.match(source, /warehouse\.name\.includes\('义乌'\)/)
   assert.match(source, /availableDestinationWarehouses\.value\.length === 1/)
   assert.match(source, /function createPickupPartySnapshot\(\)/)
   assert.match(source, /contactName: tenantStore\.company\.contactName/)
@@ -334,8 +374,10 @@ test('collects the backend-required first-leg fields', () => {
   }
   assert.match(source, /form\.channelName = channel\?\.channelName/)
   assert.match(source, /v-model="item\.woodenProduct"/)
-  assert.match(source, /第 \{\{ woodenCargoLines\.join\('、'\) \}\} 条货物已勾选木制品/)
+  assert.match(source, /form\.customsInspection = form\.items\.some\(\(item\) => item\.woodenProduct\) \? true : null/)
-  assert.match(source, /第 \{\{ index \+ 1 \}\} 条须商检/)
+  assert.match(source, /木制品<small>勾选后自动商检<\/small>/)
+  assert.doesNotMatch(source, /label="是否商检"/)
+  assert.match(source, /<small v-if="item\.woodenProduct">自动商检<\/small>/)
 })
 
 test('distills order creation into the confirmed prototype sections with server pricing', () => {
@@ -385,6 +427,36 @@ test('distills order creation into the confirmed prototype sections with server
   assert.doesNotMatch(source, /v-model="form\.(?:businessType|origin|destination|priority|tradeTerm)"/)
 })
 
+test('matches the prototype two-column create layout and reset action', () => {
+  assert.match(source, /class="order-form-section prototype-section order-basic-section"/)
+  assert.match(source, /<span class="order-step-badge">01<\/span><h3>客户下单<\/h3><span class="order-section-context">国内交货与运输信息<\/span>/)
+  assert.match(source, /<span class="order-step-badge">02<\/span><h3>目的地信息<\/h3><span class="order-section-context">美国目的仓与收件信息<\/span>/)
+  assert.match(source, /\.is-create-route \.prototype-order-form \{[^}]*grid-template-columns: repeat\(2, minmax\(0, 1fr\)\)/)
+  assert.match(source, /\.is-create-route \.cargo-section, \.is-create-route \.cost-estimate-section \{ grid-column: 1 \/ -1; \}/)
+  assert.match(source, /\.is-create-route \.prototype-form-row[^\n]*grid-template-columns: 108px minmax\(0, 1fr\)/)
+  assert.match(source, /\.is-create-route \.prototype-form-row :deep\(\.el-form-item__label\) \{[^}]*height: 36px[^}]*justify-content: flex-end[^}]*padding: 0 10px 0 0/)
+  assert.match(source, /\.is-create-route \.compact-transport-grid > :deep\(\.el-form-item__label\) \{[^}]*align-items: center[^}]*text-align: right/)
+  assert.match(source, /async function resetCreateForm\(\)/)
+  assert.match(source, /确认清空当前填写的订单内容并恢复默认值/)
+  assert.match(source, /v-if="isCreatePage"[^>]*@click="resetCreateForm"[^>]*><RotateCcw[^>]*\/>重置/)
+  assert.match(source, /class="submit-order-button"/)
+  assert.match(editorShellSource, /\.first-leg-editor-page \{[^}]*padding-bottom: 72px/)
+  assert.match(editorShellSource, /\.editor-page-footer \{[^}]*position: fixed[^}]*bottom: 0[^}]*left: 224px/)
+  assert.match(editorShellSource, /submit-gradient 5s ease-in-out infinite/)
+  assert.match(editorShellSource, /submit-shine 3\.2s ease-in-out infinite/)
+  assert.match(editorShellSource, /@media \(prefers-reduced-motion: reduce\)/)
+  assert.match(createHubSource, /<h1 class="create-hub-title">头程下单<\/h1>/)
+  assert.match(createHubSource, /<div class="create-mode-toolbar">[\s\S]*order-mode-switch[\s\S]*选择下单方式/)
+  assert.doesNotMatch(createHubSource, /填写货物信息，创建新的头程运输订单/)
+  assert.match(source, /\.is-create-route \.prototype-order-form \{[^}]*align-items: start/)
+  assert.doesNotMatch(source, /\.is-create-route \.order-basic-section, \.is-create-route \.destination-section \{ height: 100%; \}/)
+  assert.doesNotMatch(source, /\.is-create-route \.order-basic-section > \.order-section-heading, \.is-create-route \.destination-section > \.order-section-heading \{[^}]*(?:height|min-height):/)
+  assert.match(source, /\.is-create-route \.order-basic-section > \.order-section-heading h3, \.is-create-route \.destination-section > \.order-section-heading h3 \{[^}]*font-size: 17px[^}]*line-height: 24px/)
+  assert.match(source, /\.is-create-route \.order-step-badge \{[^}]*width: 30px[^}]*height: 30px/)
+  assert.match(source, /\.is-create-route \.order-section-context \{[^}]*margin-left: auto/)
+  assert.match(source, /\.is-create-route \.warehouse-options :deep\(\.el-radio\.is-checked\) \{[^}]*linear-gradient/)
+})
+
 test('shows an optional LX inbound order number for one-click dropship orders', () => {
   assert.match(source, /v-if="form\.fulfillmentType === 'ONE_CLICK_DROPSHIP'" label="LX入库单号" prop="lxCode"/)
   assert.match(source, /v-model="form\.lxCode"[^>]*placeholder="请输入LX入库单号"/)
@@ -448,6 +520,9 @@ test('shows field-level validation and concise guidance for required order input
   assert.match(source, /prop="shipperPartySnapshot\.contactName" required/)
   assert.match(source, /prop="consigneePartySnapshot\.address" required/)
   assert.match(source, /:prop="`items\.\$\{index\}\.cargoNameCn`" required/)
+  assert.match(source, /form\.destinationType === 'FBA' \|\| form\.fulfillmentType === 'ONE_CLICK_DROPSHIP' \? '必填' : '选填'/)
+  assert.match(source, /SKU NO\. 和 UPC NO\. 均为选填项/)
+  assert.match(source, /一件代发必须填写 SKU/)
   assert.match(source, /:prop="`items\.\$\{index\}\.grossWeightKg`" required/)
   assert.match(source, /<span class="required-field-mark" aria-hidden="true">\*<\/span>总毛重/)
   assert.match(source, /<span class="required-field-mark" aria-hidden="true">\*<\/span>总体积/)
@@ -479,7 +554,7 @@ test('shows fulfillment courier information as read-only client detail', () => {
 })
 
 test('shows the full customer-safe order detail without platform-only controls', () => {
-  const detailSource = source.slice(source.indexOf('<el-dialog v-model="detailOpen"'), source.indexOf('</el-dialog>', source.indexOf('<el-dialog v-model="detailOpen"')))
+  const detailSource = source.slice(source.indexOf('<section v-if="isDetailPage"'), source.indexOf('</section>', source.indexOf('<section v-if="isDetailPage"')))
   for (const heading of ['订单与运输', '收发货信息', '关键业务摘要', '履约快递信息', '货物明细']) {
     assert.match(source, new RegExp(`<h3>${heading}<\\/h3>`))
   }
@@ -496,9 +571,15 @@ test('shows the full customer-safe order detail without platform-only controls',
   assert.doesNotMatch(detailSource, /内部备注|审核通过|添加备注/)
 })
 
-test('opens order detail in a large dialog and paginates cargoes as a read-only table', () => {
+test('opens order detail as a protected workspace page and paginates cargoes as a read-only table', () => {
-  assert.match(source, /<el-dialog v-model="detailOpen" class="first-leg-detail-dialog" title="订单详情" width="94vw" top="3vh"/)
+  assert.match(routerSource, /path: 'orders\/first-leg\/:orderId\/detail'[\s\S]*?name: 'first-leg-order-detail'[\s\S]*?props: \{ detailPage: true \}[\s\S]*?permission: 'order:first-leg:list'/)
-  assert.doesNotMatch(source, /<el-drawer v-model="detailOpen"/)
+  assert.match(source, /router\.push\(\{ name: 'first-leg-order-detail', params: \{ orderId: order\.id \} \}\)/)
+  assert.match(source, /<section v-if="isDetailPage" class="first-leg-detail-page" aria-label="订单详情">/)
+  assert.doesNotMatch(source, /<el-dialog v-model="detailOpen"/)
+  assert.match(source, /first-leg-page\.is-detail-route\)[^\n]*client-page-heading\) \{ display: none; \}/)
+  assert.doesNotMatch(source, /class="detail-page-actions"/)
+  assert.match(source, /\.order-detail-grid \{[^}]*grid-template-columns: repeat\(4, minmax\(0, 1fr\)\)/)
+  assert.match(source, /\.order-detail-grid div \{[^}]*grid-template-columns: 78px minmax\(0, 1fr\)/)
   assert.match(source, /const detailCargoPage = ref\(1\)/)
   assert.match(source, /const detailCargoPageSize = ref\(5\)/)
   assert.match(source, /const pagedDetailCargoItems = computed/)
@@ -508,13 +589,24 @@ test('opens order detail in a large dialog and paginates cargoes as a read-only
   assert.match(source, /v-model:page-size="detailCargoPageSize"/)
   assert.match(source, /:total="detailOrder\.items\.length"/)
   assert.doesNotMatch(source, /class="cargo-detail-list"/)
-  assert.match(source, /first-leg-detail-dialog\.el-dialog\) \{[^}]*height: 94vh;/)
+  assert.match(source, /\.first-leg-detail-page \{[^}]*padding: 10px 14px 20px;[^}]*border: 1px solid var\(--client-border\);[^}]*border-radius: var\(--client-radius\);[^}]*background: #fff;/)
+  assert.match(source, /\.order-detail-grid div \{[^}]*min-height: 34px;[^}]*padding: 3px 8px;/)
+})
+
+test('keeps shared button hierarchy compact and consistent', () => {
+  assert.match(querySource, /class="query-toolbar__search" type="primary"/)
+  assert.match(querySource, /class="query-toolbar__reset"/)
+  assert.match(tableSource, /v-for="action in splitTableActions\(rowActions\(row\)\)\.visible"[\s\S]*?link type="primary"/)
+  assert.match(clientUiSource, /--client-control-height: 32px/)
+  assert.match(clientUiSource, /\.client-ui \.el-button \{[\s\S]*?min-width: 68px;[\s\S]*?font-weight: 600;/)
+  assert.match(clientUiSource, /\.client-ui \.el-button\.is-link, \.client-ui \.el-button\.is-text \{[\s\S]*?min-width: 0;[\s\S]*?background: transparent;/)
+  assert.match(clientUiSource, /\.client-ui \.el-button svg \{[\s\S]*?width: 16px; height: 16px;/)
 })
 
 test('loads merchant inbound billing as an isolated read-only detail section', () => {
   assert.match(source, /import InboundBillingPanel/)
   assert.match(source, /import \{ getMerchantInboundBilling \}/)
-  assert.match(source, /void loadInboundBilling\(order\)/)
+  assert.match(source, /void loadInboundBilling\(detailedOrder\)/)
   assert.match(source, /<InboundBillingPanel/)
   assert.match(source, /@retry="retryInboundBilling"/)
   assert.match(source, /error instanceof ApiError && error\.code === 'A0404'/)
@@ -540,9 +632,6 @@ test('opens billing-weight confirmation independently from order details', () =>
 })
 
 test('shows billing-weight confirmation only when the backend marks it pending', () => {
-  const templateSource = source.slice(source.indexOf('<template>'), source.lastIndexOf('</template>'))
-  const entries = templateSource.match(/<el-button v-if="canConfirmInboundFee && [^"]*customerFeeConfirmationRequired" link type="primary" @click="openFeeConfirmation\([^)]*\)">确认计费重<\/el-button>/g) ?? []
-  assert.equal(entries.length, 1)
   assert.match(source, /if \(canConfirmInboundFee\.value && order\.businessSummary\.customerFeeConfirmationRequired\) \{\s*actions\.push\(\{ key: 'fee'/)
   assert.match(source, /:row-actions="getOrderRowActions"/)
   assert.match(orderStoreSource, /customerFeeConfirmationRequired: summary\?\.customerFeeConfirmationRequired \?\? false/)
@@ -550,16 +639,16 @@ test('shows billing-weight confirmation only when the backend marks it pending',
 
 test('submits only selected draft orders in one batch action', () => {
   assert.match(source, /selectedDraftOrders = computed\(\(\) => selectedOrders\.value\.filter\(\(order\) => order\.status === 'DRAFT'\)\)/)
-  assert.match(source, /Promise\.allSettled\(drafts\.map\(\(order\) => submitMerchantFirstLegOrder/)
+  assert.match(source, /Promise\.allSettled\(ids\.map\(id => store\.submitSaved/)
-  assert.match(source, /createIdempotencyKey\(`first-leg-batch-submit-\$\{order\.id\}`\)/)
+  assert.doesNotMatch(source, /submitMerchantFirstLegOrder/)
   assert.match(source, /v-if="canSubmitOrder"[\s\S]*批量提交草稿/)
 })
 
 test('discards stale inbound billing responses when billing views close or the user changes orders', () => {
   assert.match(source, /let inboundBillingRequestSequence = 0/)
   assert.match(source, /const sequence = \+\+inboundBillingRequestSequence/)
-  assert.match(source, /sequence === inboundBillingRequestSequence[\s\S]*inboundBillingOrderId\.value === orderId[\s\S]*detailOpen\.value \|\| feeConfirmationOpen\.value/)
+  assert.match(source, /sequence === inboundBillingRequestSequence[\s\S]*inboundBillingOrderId\.value === orderId[\s\S]*isDetailPage\.value \|\| feeConfirmationOpen\.value/)
-  assert.match(source, /watch\(detailOpen,[\s\S]*resetInboundBillingState\(\)/)
+  assert.doesNotMatch(source, /watch\(detailOpen/)
   assert.match(source, /watch\(feeConfirmationOpen,[\s\S]*resetInboundBillingState\(\)/)
 })
 
@@ -588,22 +677,21 @@ test('copies reactive order drafts into plain request data', () => {
   assert.doesNotMatch(source, /structuredClone\((?:form|order\.)/)
 })
 
-test('opens the server-owned inbound-code association from desktop, mobile, and order detail', () => {
+test('opens the server-owned inbound-code association from the order detail', () => {
   assert.match(source, /import InboundCodeAssociationDialog/)
   assert.match(source, /function openInboundCodeAssociation\(inboundCode: string\)/)
-  assert.match(source, /#inboundCode[\s\S]*?openInboundCodeAssociation\(\(row as FirstLegOrder\)\.businessSummary\.inboundCode\)/)
+  assert.doesNotMatch(source, /#inboundCode[\s\S]*?openInboundCodeAssociation\(\(row as FirstLegOrder\)\.businessSummary\.inboundCode\)/)
-  assert.match(source, /class="order-reference inbound-code-link"[\s\S]*?openInboundCodeAssociation\(order\.businessSummary\.inboundCode\)/)
   assert.match(source, /<dt>入仓码<\/dt><dd><button[\s\S]*?openInboundCodeAssociation\(detailOrder\.businessSummary\.inboundCode\)/)
   assert.match(source, /<InboundCodeAssociationDialog[\s\S]*?:inbound-code="inboundAssociationCode"/)
   assert.doesNotMatch(source, /openInboundCodeAssociation\([^)]*\.id\)/)
 })
 
-test('opens customer customs documents only for server-confirmed loaded tax-refund orders', () => {
+test('opens customer customs documents only for server-confirmed tax-refund orders after loading', () => {
-  assert.match(source, /order\.status !== 'LOADED'/)
+  assert.match(source, /!isCustomsOrderCandidate\(order\)/)
   assert.match(source, /item\.orderId === order\.id && item\.taxMode === 'TAX_REFUND'/)
   assert.match(source, /getMerchantCustomsForOrder\(order\.id\)/)
   assert.match(source, /if \(eligibleCustomsDetail\(order\)\) \{\s*actions\.push\(\{ key: 'customs', label: '报关资料'/)
-  assert.match(source, /class="mobile-order-card"[\s\S]*?v-if="eligibleCustomsDetail\(order\)"[\s\S]*?openCustomsDocuments\(order\)[\s\S]*?报关资料/)
+  assert.match(source, /if \(eligibleCustomsDetail\(order\)\) \{\s*actions\.push\(\{ key: 'customs', label: '报关资料'/)
   assert.match(source, /<CustomsDocumentsDialog[\s\S]*?:can-edit="auth\.hasPermission\('order:first-leg:edit'\)"/)
   assert.doesNotMatch(customsApiSource, /customs\/cases\//)
 })
@@ -614,13 +702,15 @@ test('supports the frozen customs document workflow and customer-safe downloads'
     '/merchant/v1/customs/loading-plans/',
     '/merchant/v1/customs/documents/',
     '/inbounds',
-    '/completion/download',
+    '/receipt/download',
   ]) assert.match(customsApiSource, new RegExp(path.replaceAll('/', '\\/')))
   assert.match(customsApiSource, /MAX_CUSTOMS_FILE_SIZE = 50 \* 1024 \* 1024/)
   assert.match(customsApiSource, /data: \{ inboundIds, expectedVersion: document\.source\.version \}/)
   assert.match(customsApiSource, /requestId: error\.requestId/)
-  assert.match(customsDialogSource, /报关开始后仅可查看和下载，不提供退回或解锁/)
+  assert.match(customsDialogSource, /客户原始资料已冻结，仍可确认或打回待确认的报关行回执/)
-  assert.match(customsDialogSource, /detail\.status === 'COMPLETED' && item\.completion/)
+  assert.match(customsDialogSource, /v-if="detail.status === 'COMPLETED'"[^>]*><strong>报关已完成/)
+  assert.match(customsDialogSource, /真实报关完税文件已齐全/)
+  assert.match(customsDialogSource, /item\.finalDocument/)
   assert.match(customsDialogSource, /资料版本历史/)
   assert.match(customsDialogSource, /尚未上传退税报关资料/)
   assert.match(customsDialogSource, /退税报关资料加载失败/)
@@ -643,12 +733,12 @@ test('shows authoritative warehouse, loading and sailing fields on desktop and n
   }
   assert.match(source, /businessSummary\.cabinetNo \|\| .*businessSummary\.containerNo/)
   assert.match(source, /businessSummary\.vesselName.*businessSummary\.voyageNo/s)
-  assert.match(source, /businessSummary\.sailingAt/)
+  assert.match(source, /businessSummary\.estimatedSailingAt/)
 })
 
 test('loads complete order detail before editing and rejects an unavailable historical warehouse', () => {
   assert.match(source, /async function openEdit\(order: FirstLegOrder\)/)
-  assert.match(source, /const detailedOrder = await store\.loadDetail\(order\.id\)/)
+  assert.match(source, /const \[detailedOrder\] = await Promise\.all\(\[store\.loadDetail\(order\.id\)/)
   assert.match(source, /draftFromOrder\(detailedOrder\)/)
   assert.match(source, /draft\.receivingWarehouseId = ''/)
   assert.match(source, /draft\.channelCode = ''/)