From e7c84a82a2421b5dbe3ed64de4772055ff0d5b61 Mon Sep 17 00:00:00 2001
From: oneao <hi_itao@163.com>
Date: Thu, 15 Oct 2026 22:47:42 +0800
Subject: [PATCH] u

---
 .../service/auth/client/IpRegionSearcher.java |    2 +-
 code/g3soft-erp/web/src/utils/powerCodes.ts   |  127 +
 code/g3soft-erp/web/src/utils/schemaJson.ts   |   10 +-
 .../module-management/ModuleI18nPanel.vue     |  235 ++
 .../module-management/ModulePowerPanel.vue    |  564 ++++
 .../module-management/ModuleQueryPanel.vue    | 2522 ++++-------------
 .../views/module/module-management/index.vue  |  151 +-
 .../views/module/module-management/utils.ts   |  208 +-
 .../web/src/views/table-test/index.vue        |  122 +-
 .../ModuleQueryPanel.spec.ts                  |  136 +
 .../.changeset/table-cell-status-shapes.md    |   18 +
 .../.changeset/table-date-editor.md           |   18 +
 .../.changeset/table-keyboard-arrows-enter.md |   25 +
 .../.changeset/table-no-vertical-lines.md     |   14 +
 .../.changeset/table-number-precision.md      |   23 +
 .../g3soft-libs/docs/content/ui/data/table.md |  169 +-
 .../g3soft-libs/packages/ui/e2e/table.spec.ts |  497 +++-
 .../packages/ui/playground/main.ts            |   85 +
 .../packages/ui/src/date/DatePicker.vue       |  120 +-
 .../g3soft-libs/packages/ui/src/date/types.ts |    8 +
 .../packages/ui/src/table/G3Table.vue         |  395 ++-
 .../packages/ui/src/table/index.ts            |   23 +
 .../ui/src/table/style/_overrides.scss        |  103 +-
 .../packages/ui/src/table/types.ts            |   59 +-
 .../packages/ui/src/table/utils/column.ts     |   29 +-
 .../ui/src/table/utils/date-value.test.ts     |   34 +
 .../packages/ui/src/table/utils/date-value.ts |   35 +
 .../ui/src/table/utils/editable.test.ts       |   72 +-
 .../packages/ui/src/table/utils/editable.ts   |  391 ++-
 .../ui/src/table/utils/precision.test.ts      |  107 +
 .../packages/ui/src/table/utils/precision.ts  |  123 +
 31 files changed, 4063 insertions(+), 2362 deletions(-)
 create mode 100644 code/g3soft-erp/web/src/views/module/module-management/ModuleI18nPanel.vue
 create mode 100644 code/g3soft-erp/web/src/views/module/module-management/ModulePowerPanel.vue
 create mode 100644 code/g3soft-erp/web/tests/views/module/module-management/ModuleQueryPanel.spec.ts
 create mode 100644 code/g3soft-libs/.changeset/table-cell-status-shapes.md
 create mode 100644 code/g3soft-libs/.changeset/table-date-editor.md
 create mode 100644 code/g3soft-libs/.changeset/table-keyboard-arrows-enter.md
 create mode 100644 code/g3soft-libs/.changeset/table-no-vertical-lines.md
 create mode 100644 code/g3soft-libs/.changeset/table-number-precision.md
 create mode 100644 code/g3soft-libs/packages/ui/src/table/utils/date-value.test.ts
 create mode 100644 code/g3soft-libs/packages/ui/src/table/utils/date-value.ts
 create mode 100644 code/g3soft-libs/packages/ui/src/table/utils/precision.test.ts
 create mode 100644 code/g3soft-libs/packages/ui/src/table/utils/precision.ts

diff --git a/code/g3soft-erp/server/src/main/java/cn/g3soft/erp/service/auth/client/IpRegionSearcher.java b/code/g3soft-erp/server/src/main/java/cn/g3soft/erp/service/auth/client/IpRegionSearcher.java
index 758895af..e0879dd9 100644
--- a/code/g3soft-erp/server/src/main/java/cn/g3soft/erp/service/auth/client/IpRegionSearcher.java
+++ b/code/g3soft-erp/server/src/main/java/cn/g3soft/erp/service/auth/client/IpRegionSearcher.java
@@ -30,7 +30,7 @@ public class IpRegionSearcher {
             LongByteArray buffer = new LongByteArray();
             buffer.append(bytes);
             searcher = Searcher.newWithBuffer(Version.IPv4, buffer);
-            log.info("ip2region Searcher 初始化完成，数据大小 {} 字节", bytes.length);
+                log.info("ip2region Searcher 初始化完成，数据大小 {} 字节", bytes.length);
         } catch (IOException e) {
             log.error("未找到 classpath 下的 ip2region.xdb，IP 归属地将返回「未知」", e);
             searcher = null;
diff --git a/code/g3soft-erp/web/src/utils/powerCodes.ts b/code/g3soft-erp/web/src/utils/powerCodes.ts
index 31f72f10..c847b500 100644
--- a/code/g3soft-erp/web/src/utils/powerCodes.ts
+++ b/code/g3soft-erp/web/src/utils/powerCodes.ts
@@ -27,6 +27,133 @@ export function typeOfAction(action: string): 'module' | 'action' {
   return isStandardModuleAction(action) ? 'module' : 'action'
 }
 
+/**
+ * 动作 → 默认权限名称（新增权限点时的兜底名称，不覆盖人工输入）。
+ * 标准动作与业务动作都给中文名，未登记的动作回退动作编码本身。
+ *
+ * 这套动词是**跨模块公用**的：「通过」就是「通过」，与它挂在哪个模块下无关。
+ * 因此权限库（历史动作去重列表）的名称也按这里生成 —— 库里若直接用 s_power.b_name，
+ * 拿到的会是「模块名 - 动作名」（写入侧的口径，见 12_fms_workflow_power.sql），
+ * 在按动作去重的库表里显示模块名是噪音。
+ */
+export const ACTION_NAMES: Record<string, string> = {
+  [MODULE_ACCESS_ACTION]: '模块使用',
+  // 标准操作
+  read: '查看',
+  create: '新增',
+  update: '修改',
+  delete: '删除',
+  export: '导出',
+  // 业务动作（工作流审批）
+  submit: '送审',
+  approve: '通过',
+  reject: '驳回',
+  return: '退回',
+  withdraw: '撤回',
+  transfer: '转交',
+  delegate: '委托',
+  reassign: '转派',
+  add_approver: '加签',
+  urge: '催办',
+  workflow_admin: '流程管理员',
+  // 通用业务动作
+  audit: '审核',
+  unaudit: '反审',
+}
+
+/**
+ * 标准动作的共用动作动词资源键（按钮 + 权限共用）。
+ * 「新增」与权限名称共用 action.insert（SQL 语义）；未登记动作回退 action.{动作}。
+ */
+export const ACTION_I18N_KEYS: Record<string, string> = {
+  read: 'action.read',
+  create: 'action.insert',
+  update: 'action.update',
+  delete: 'action.delete',
+  export: 'action.export',
+  audit: 'action.audit',
+  unaudit: 'action.unaudit',
+}
+
+/**
+ * 动作码 → 展示名：优先取登记的中文动词，未登记的回落动作码本身。
+ * 这是「动作」这一层的唯一命名口径，权限库与新增权限都用它，不在调用方各写一份。
+ */
+export function actionLabelOf(action: string): string {
+  const value = String(action || '').trim()
+  if (!value) return ''
+  return ACTION_NAMES[value] || value
+}
+
+/** 动作 → 共用动作动词资源键：通用词不分模块，同一动词只保存一份翻译 */
+export function buildActionI18nKey(action: string): string | null {
+  const value = String(action || '').trim()
+  if (!value) return null
+  return ACTION_I18N_KEYS[value] || `action.${value}`
+}
+
+/**
+ * 权限编码派生：模块使用权限为 module.{模块编码}（不带动作后缀），业务动作为
+ * action.{模块编码}.{动作}；动作或模块编码为空时返回 ''（行还没填完，保存时跳过）。
+ *
+ * 维护界面（模块管理 → 权限）的单元格编辑器与保存前物化共用，不在各自目录重写。
+ */
+export function buildPowerCode(action: string, moduleId: string): string {
+  const normalizedAction = String(action || '').trim()
+  const objectId = String(moduleId || '').trim()
+  if (!normalizedAction || !objectId) return ''
+  return isStandardModuleAction(normalizedAction)
+    ? (buildModulePowerCode(objectId) ?? '')
+    : (buildActionPowerCode(objectId, normalizedAction) ?? '')
+}
+
+/**
+ * 权限点引用的多语言键：模块使用权限复用模块名称键 module.{模块编码}
+ * （它显示的就是模块名）；业务动作复用共用动词键 action.{动词}（跨模块公用，
+ * 同一动词只维护一份翻译）。
+ */
+export function buildPowerI18nKey(action: string, moduleCode: string): string | null {
+  const value = String(action || '').trim()
+  if (!value) return null
+  return typeOfAction(value) === 'module'
+    ? buildModuleI18nKey(moduleCode)
+    : buildActionI18nKey(value)
+}
+
+/**
+ * 权限库（历史录入的动作）只读查询：跨模块去重，列出全系统用过的业务动作，
+ * 供「模块管理 → 权限」一键导入。
+ *
+ * 标准动作（access / read / create / update / delete / export）不进库：它们的权限编码是
+ * module.{模块编码}（整模块一个使用权限点），导入到某个模块会与该模块的模块使用权限撞编码；
+ * 只有业务动作按 action.{模块编码}.{动作} 派生，才能跨模块复用。
+ *
+ * **只取 b_action，不取 b_name**：s_power.b_name 由写入侧拼成「模块名 - 动作名」
+ * （见 12_fms_workflow_power.sql），而本表是**按动作跨模块去重**的，
+ * 同一个动作在多个模块下会得到多个不同的名字，「取哪一个」没有意义 ——
+ * 显示出来就是某个模块的名称（用户看到的「流程定义 - 通过」正是这么来的）。
+ * 动作是跨模块公用的动词，名称统一由 actionLabelOf(action) 在展示侧生成。
+ */
+export function buildPowerLibrarySql(): string {
+  const excluded = [MODULE_ACCESS_ACTION, ...STANDARD_MODULE_ACTIONS]
+    .map((action) => `'${action}'`)
+    .join(', ')
+  return (
+    'select distinct [b_action] ' +
+    'from [s_power] ' +
+    "where [b_object_type] = 'module' and [b_canuse] = 1 " +
+    "and [b_action] is not null and [b_action] <> '' " +
+    `and [b_action] not in (${excluded}) ` +
+    'order by [b_action] asc'
+  )
+}
+
+/** 模块多语言资源键：module.{模块编码} */
+export function buildModuleI18nKey(moduleCode: string): string | null {
+  const code = String(moduleCode || '').trim()
+  return code ? `module.${code}` : null
+}
+
 /**
  * 菜单入口权限编码：menu.{菜单编码}。
  * @returns 权限编码；编码为空时返回 null
diff --git a/code/g3soft-erp/web/src/utils/schemaJson.ts b/code/g3soft-erp/web/src/utils/schemaJson.ts
index 8bbc607e..4eeda7f4 100644
--- a/code/g3soft-erp/web/src/utils/schemaJson.ts
+++ b/code/g3soft-erp/web/src/utils/schemaJson.ts
@@ -37,15 +37,11 @@ export function createDefaultSchema(schemaType: string): SchemaJson {
   // （v1 是平铺字段节点 + newline 标记，加载时仍可容错折成行）
   if (schemaType === 'edit') return { schemaVersion: 2, children: [] }
   if (schemaType === 'query') {
-    // schemaVersion 3：页签可分组（组内单选、组间叠加），页签条件直写 SQL，
-    // 更多筛选由 queryFields 自动铺开（不再手工分组）；
-    // 关键词只配可搜索字段，占位文案与触发方式运行时定
+    // schemaVersion 4：只保留工作队列页签（组内单选、组间叠加，条件直写 SQL）。
+    // 查询能力（关键词字段、更多筛选字段、控件与算子）由列表页按 s_field 运行时推导，不再配置。
     return {
-      schemaVersion: 3,
+      schemaVersion: 4,
       views: [],
-      keywordSearch: { fields: [] },
-      quickFilters: [],
-      queryFields: {},
     }
   }
   return { schemaVersion: 1 }
diff --git a/code/g3soft-erp/web/src/views/module/module-management/ModuleI18nPanel.vue b/code/g3soft-erp/web/src/views/module/module-management/ModuleI18nPanel.vue
new file mode 100644
index 00000000..94431c02
--- /dev/null
+++ b/code/g3soft-erp/web/src/views/module/module-management/ModuleI18nPanel.vue
@@ -0,0 +1,235 @@
+<script setup lang="ts">
+/**
+ * 多语言面板（s_i18n）：受控展示当前模块的多语言译文。
+ *
+ * 数据契约：v-model:rows 绑定父级持有的**透视草稿行**（一行 = 一个资源键，
+ * 每个语言一列）。父级负责语言清单的加载与保存基线，本面板只做展示与行内编辑。
+ *
+ * 透视行的形状：{ _rowKey, b_key, [语言编码]: 译文 }。
+ * s_i18n 的落库形态是长表（b_key + b_locale），透视只是编辑期的视图 ——
+ * 转换与 diff 在父级编排，本面板不碰落库结构。
+ *
+ * 「受管行」：模块名 / 字段名 / 分组标题这类由系统派生的键（_managed），
+ * 键名不可改、行不可删 —— 它们跟着模块结构走，手工删掉下次同步又会回来。
+ * 默认语言列在这类行上只读（值就是名称本身），改文案要去改名称。
+ *
+ * 保存编排尚未移植，本步只做表格与编辑交互。
+ */
+import { computed, nextTick, ref } from 'vue'
+import { Plus, Trash2 } from '@lucide/vue'
+import {
+  G3Button,
+  G3Table,
+  type G3TableColumn,
+  type TableRow,
+} from '@g3soft/ui'
+import { createTempId } from '@/utils/common'
+
+/** 语言项（s_i18n_type 行） */
+export interface I18nLanguage {
+  /** 语言编码（s_i18n_type.b_id，如 zh-CN / en） */
+  code: string
+  /** 语言名称 */
+  name: string
+  /** 是否默认语言（s_i18n_type.b_default = 1） */
+  default?: boolean
+}
+
+/** 透视草稿行 */
+export type I18nPivotRow = TableRow & {
+  _rowKey: string
+  b_key?: string
+  /** 受管行（键由系统派生）：键名只读、行不可删 */
+  _managed?: boolean
+  /** 默认语言列只读（值由名称决定，改文案要去改名称本身） */
+  _autoDefault?: boolean
+}
+
+const props = withDefaults(
+  defineProps<{
+    /** 语言清单（来自 s_i18n_type），决定列定义与默认语言列 */
+    languages?: I18nLanguage[]
+    /** 父级忙碌态（加载中）：期间锁掉新增与批量删除 */
+    loading?: boolean
+  }>(),
+  { languages: () => [], loading: false },
+)
+
+const rowsModel = defineModel<I18nPivotRow[]>('rows', { default: () => [] })
+
+/** 默认语言编码：b_default = 1 的那一个 */
+const defaultLocale = computed(
+  () => props.languages.find((language) => language.default === true)?.code ?? '',
+)
+
+/** 受管行不可改键名、不可删除 */
+function isManagedRow(row: TableRow): boolean {
+  return Boolean((row as I18nPivotRow)._managed)
+}
+
+/**
+ * 默认语言值由名称决定的受管行（模块名 / 字段名 / 分组标题）：
+ * 这些行的默认语言列只读 —— 值由父级的同步逻辑按当前名称维护，改文案要去改名称本身，
+ * 否则会留下一条和名称对不上的译文（列表、权限面板都优先取译文）。
+ */
+function isNameDrivenRow(row: TableRow): boolean {
+  return Boolean((row as I18nPivotRow)._autoDefault)
+}
+
+const tableRef = ref<InstanceType<typeof G3Table> | null>(null)
+const activeKey = ref<string | null>(null)
+const selectedRowKeys = ref<string[]>([])
+
+/** 新增一行空键，并直接进键名单元格编辑 */
+async function addRow() {
+  if (props.loading) return
+  const newKey = createTempId()
+  rowsModel.value = [...rowsModel.value, { _rowKey: newKey, b_key: '' }]
+  activeKey.value = String(newKey)
+  await nextTick()
+  tableRef.value?.editRow?.(String(newKey), 'b_key')
+}
+
+function removeRow(row: TableRow) {
+  if (isManagedRow(row)) return
+  const key = String((row as I18nPivotRow)._rowKey ?? '')
+  rowsModel.value = rowsModel.value.filter((item) => item !== row)
+  selectedRowKeys.value = selectedRowKeys.value.filter((item) => item !== key)
+}
+
+const rowSelection = computed(() => ({
+  selectedRowKeys: selectedRowKeys.value,
+  // 受管行不给勾：它们删不掉，勾了只会让「批量删除」的计数对不上
+  getCheckboxProps: (row: TableRow) => ({ disabled: isManagedRow(row) }),
+  onChange: (keys: unknown[]) => {
+    selectedRowKeys.value = (keys || []).map(String)
+  },
+}))
+
+function batchDelete() {
+  if (props.loading || !selectedRowKeys.value.length) return
+  const removing = new Set(selectedRowKeys.value)
+  const deletable = rowsModel.value.filter(
+    (row) => removing.has(String(row._rowKey)) && !isManagedRow(row),
+  )
+  if (!deletable.length) return
+  const delKeys = new Set(deletable.map((row) => String(row._rowKey)))
+  rowsModel.value = rowsModel.value.filter((row) => !delKeys.has(String(row._rowKey)))
+  selectedRowKeys.value = []
+  if (activeKey.value && delKeys.has(String(activeKey.value))) activeKey.value = null
+}
+
+/**
+ * 列定义：多语言键 + 每个语言一列 + 操作。
+ * 用 computed 而不是 shallowRef —— 语言清单是异步到的（s_i18n_type 加载完才传进来），
+ * 列必须跟着重算；本表格不需要用户拖列宽回写（透视表列由语言决定，不该让用户改没）。
+ */
+const columns = computed<G3TableColumn<TableRow>[]>(() => {
+  const cols: G3TableColumn<TableRow>[] = [
+    {
+      dataIndex: 'b_key',
+      title: '多语言键',
+      width: 260,
+      editor: { type: 'text', disabled: (row: TableRow) => isManagedRow(row) },
+    },
+  ]
+  for (const language of props.languages) {
+    const isDefault = language.code === defaultLocale.value
+    cols.push({
+      dataIndex: language.code,
+      title: language.name,
+      width: 200,
+      editor: {
+        type: 'text',
+        disabled: (row: TableRow) => isDefault && isNameDrivenRow(row),
+      },
+    })
+  }
+  cols.push({
+    dataIndex: 'actions',
+    title: '',
+    width: 60,
+    align: 'center',
+    actions: [
+      {
+        type: 'delete',
+        label: '删除',
+        disabled: (row: TableRow) => isManagedRow(row),
+        onClick: (row: TableRow) => removeRow(row),
+      },
+    ],
+  })
+  return cols
+})
+</script>
+
+<template>
+  <div class="mm-i18n">
+    <div class="mm-i18n__toolbar">
+      <G3Button type="primary" :disabled="loading" @click="addRow">
+        <template #icon><Plus :size="14" /></template>
+        新增多语言
+      </G3Button>
+      <G3Button
+        type="danger-outline"
+        :disabled="loading || !selectedRowKeys.length"
+        @click="batchDelete"
+      >
+        <template #icon><Trash2 :size="14" /></template>
+        批量删除{{ selectedRowKeys.length ? `（${selectedRowKeys.length}）` : '' }}
+      </G3Button>
+    </div>
+    <div class="mm-i18n__table">
+      <G3Table
+        ref="tableRef"
+        v-model:columns="columns"
+        :data-source="rowsModel"
+        :row-height="28"
+        row-key="_rowKey"
+        :row-selection="rowSelection"
+        :active-row-key="activeKey"
+        @row-click="(_, row) => (activeKey = String((row as I18nPivotRow)._rowKey ?? ''))"
+      />
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.mm-i18n {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  min-height: 0;
+}
+
+.mm-i18n__toolbar {
+  display: flex;
+  flex: none;
+  gap: 8px;
+  padding-bottom: 8px;
+}
+
+.mm-i18n__table {
+  /* 纵向撑满剩余高度（否则表体滚动区失效）；横向不拉伸 ——
+     这一层被拉满后，表格的 `max-width: 100%` 就会以「被拉伸的宽度」为上限，
+     等于变相限宽、拖列宽照样出滚动条（权限面板踩过同一个坑）。 */
+  flex: 1 1 auto;
+  min-width: 0;
+  min-height: 0;
+  width: fit-content;
+  max-width: 100%;
+}
+
+/* 表格按列宽定宽，不铺满容器 —— 与权限面板同一口径。
+ *
+ * 多语言表的列数由系统语言决定（通常 1~3 个语言 + 键 + 操作），拉满容器只会
+ * 在每个语言列之间摊开一片空白。让表框贴住内容宽度即可；语言特别多、列宽之和
+ * 超过容器时由 max-width 退回容器宽，横向滚动交给表格自己。
+ *
+ * fit-content 必须作用在**表框**（G3Table 根节点 .g3-table）上：只定宽内层
+ * <table> 的话外框仍会拉满，看起来还是铺满的。 */
+.mm-i18n__table :deep(.g3-table) {
+  width: fit-content;
+  max-width: 100%;
+}
+</style>
diff --git a/code/g3soft-erp/web/src/views/module/module-management/ModulePowerPanel.vue b/code/g3soft-erp/web/src/views/module/module-management/ModulePowerPanel.vue
new file mode 100644
index 00000000..43e3fbeb
--- /dev/null
+++ b/code/g3soft-erp/web/src/views/module/module-management/ModulePowerPanel.vue
@@ -0,0 +1,564 @@
+<script setup lang="ts">
+/**
+ * 模块权限面板（s_power）：维护当前模块的权限点。
+ *
+ * 口径（与 utils/powerCodes 同源，不在本目录另立一套）：
+ * - 权限点挂在模块上：b_object_type='module'、b_object_id=当前模块编码；
+ * - 模块使用权限整模块一个点：b_action='access'，编码 module.{模块编码}（不带动作后缀）；
+ *   标准操作 read / create / update / delete / export 不再各自拆分权限点；
+ * - 业务动作（审核 / 反审 / …）：b_type='action'，编码 action.{模块编码}.{动作}；
+ * - b_type 由动作派生、不手工选择；权限编码与多语言键均派生、不手工编辑。
+ *
+ * 新增走「加一行空动作行 → 直接进动作单元格编辑」：动作决定权限编码，必须先填。
+ * 删除分两种：行内删除（单个）与选中后批量删除。
+ *
+ * 右侧「权限库」是全系统用过的业务动作去重列表，勾选后一键导入到本模块，
+ * 不必再手打动作名；本模块已有的动作在库里置灰，标准动作不进库
+ * （其编码是 module.{模块编码}，导入会与模块使用权限撞编码）。
+ *
+ * 数据契约：v-model:powers 绑定父级持有的权限点草稿（就地编辑、不回写库）。
+ * 保存编排（逐表 diff → 落库）尚未移植，本步只做表格与编辑交互。
+ */
+import { computed, nextTick, ref, shallowRef, watch } from 'vue'
+import { ArrowLeft, Plus, RefreshCw, Trash2 } from '@lucide/vue'
+import {
+  G3Button,
+  G3Message,
+  G3Table,
+  type G3TableColumn,
+  type TableRow,
+} from '@g3soft/ui'
+import { loadDataBySqlApi } from '@/services/api'
+import { createTempId } from '@/utils/common'
+import {
+  MODULE_ACCESS_ACTION,
+  actionLabelOf,
+  buildPowerCode,
+  buildPowerI18nKey,
+  buildPowerLibrarySql,
+  typeOfAction,
+} from '@/utils/powerCodes'
+
+const props = withDefaults(
+  defineProps<{
+    /** 当前模块编码：权限点的挂载对象（b_object_id） */
+    moduleId?: string
+    /** 当前模块名称：模块使用权限点的默认名称 */
+    moduleName?: string
+    /** 父级忙碌态（加载中）：期间锁掉新增与批量删除 */
+    loading?: boolean
+  }>(),
+  { moduleId: '', moduleName: '', loading: false },
+)
+
+/** 权限点行（s_power），父级 v-model 绑定，就地编辑 */
+const powersModel = defineModel<TableRow[]>('powers', { default: () => [] })
+
+/** 权限点行（含本地行键 _rowKey，表格行身份用） */
+type PowerRow = TableRow & {
+  _rowKey: string
+  b_id?: string
+  b_name?: string
+  b_action?: string
+  b_canuse?: number
+  b_i18n?: string
+  b_type?: string
+  b_object_type?: string
+  b_object_id?: string
+  b_xh?: number
+}
+
+/**
+ * 加载阶段只补本地行键（表格的行身份）：b_object_type / b_object_id / b_xh / b_type / b_id
+ * 都是派生列，**不在加载时物化** —— 库里这些派生列与当前规则不一致时（历史数据把 b_id
+ * 存成 module.{编码}.access、b_xh 与排序规则不同等），物化会把草稿改脏，
+ * 表现为「打开模块即提示未保存」。派生列统一在用户编辑时物化。
+ */
+function ensureRowKeys(rows: TableRow[]): boolean {
+  let changed = false
+  for (const row of rows || []) {
+    if (!(row as PowerRow)._rowKey) {
+      ;(row as PowerRow)._rowKey = createTempId()
+      changed = true
+    }
+  }
+  return changed
+}
+
+watch(
+  () => powersModel.value,
+  (rows) => {
+    if (ensureRowKeys(rows)) powersModel.value = [...rows]
+  },
+  { deep: true, immediate: true },
+)
+
+/** 表格给回来的是**展示副本**，按 _rowKey 找回草稿里的那一行 */
+function draftRowOf(row: TableRow): PowerRow | undefined {
+  const key = String((row as PowerRow)._rowKey ?? '')
+  if (!key) return undefined
+  return powersModel.value.find((item) => String((item as PowerRow)._rowKey) === key) as
+    | PowerRow
+    | undefined
+}
+
+/**
+ * 单元格变更：写回**草稿**（表格数据是展示副本，不能就地改它 —— 改了下一帧就被
+ * displayRows 重新算出来覆盖掉，表现为「编辑没反应」）。
+ *
+ * 动作列还要按共用口径重算编码 / 性质 / 多语言键。名称留空时补默认名：
+ * 模块使用权限取模块名，其余取共用动词名。
+ */
+function onCellChange(row: TableRow, col: { dataIndex?: string }, value?: unknown) {
+  const target = draftRowOf(row)
+  const field = col?.dataIndex
+  if (!target || !field) return
+
+  target[field] = value === '' ? null : value
+
+  if (field === 'b_action') {
+    const action = String(target.b_action ?? '')
+    if (!String(target.b_name ?? '').trim()) {
+      target.b_name =
+        action === MODULE_ACCESS_ACTION
+          ? props.moduleName || '模块使用'
+          : actionLabelOf(action)
+    }
+    target.b_type = typeOfAction(action)
+    target.b_id = buildPowerCode(action, props.moduleId)
+    const i18nKey = buildPowerI18nKey(action, props.moduleId)
+    if (i18nKey) target.b_i18n = i18nKey
+  }
+  normalizeRows()
+}
+
+/**
+ * 物化派生列：补行键、回填挂载对象与显示顺序、派生类型与编码，并按编码去重
+ * （重复的只保留第一条，其余清空编码）。
+ *
+ * 只在**用户编辑**时调用：加载阶段不物化，避免库里派生值与规则不一致时「打开即变脏」。
+ */
+function normalizeRows() {
+  const objectId = String(props.moduleId || '')
+  powersModel.value.forEach((row, index) => {
+    const target = row as PowerRow
+    target.b_object_type = 'module'
+    target.b_object_id = objectId
+    target.b_xh = (index + 1) * 10
+    target.b_type = typeOfAction(String(target.b_action ?? ''))
+  })
+  const seen = new Set<string>()
+  for (const row of powersModel.value) {
+    const target = row as PowerRow
+    const code = String(target.b_id ?? '').trim()
+    if (!code) continue
+    if (seen.has(code)) {
+      target.b_id = ''
+      continue
+    }
+    seen.add(code)
+  }
+  // 行对象已就地 patch，换新数组引用触发表格重渲染
+  powersModel.value = [...powersModel.value]
+}
+
+/**
+ * 造一行权限点：派生列一次算好。
+ * @param action 动作码；@param name 指定名称（导入权限库时沿用库里的动词名）
+ */
+function makeRow(action: string, name?: string): PowerRow {
+  const isAccess = action === MODULE_ACCESS_ACTION
+  const row: PowerRow = {
+    _rowKey: createTempId(),
+    b_object_type: 'module',
+    b_object_id: String(props.moduleId || ''),
+    b_action: action,
+    // 模块使用权限的名称取模块名（它就是「这个模块能不能用」）；其余取共用动词名
+    b_name: name || (isAccess ? props.moduleName || '模块使用' : actionLabelOf(action)),
+    b_canuse: 1,
+  }
+  row.b_type = typeOfAction(action)
+  row.b_id = buildPowerCode(action, props.moduleId)
+  const i18nKey = buildPowerI18nKey(action, props.moduleId)
+  if (i18nKey) row.b_i18n = i18nKey
+  return row
+}
+
+/** 表格实例：新增后直接进动作单元格编辑 */
+const tableRef = ref<InstanceType<typeof G3Table> | null>(null)
+
+/** 新增空动作行并直接进入动作单元格编辑 */
+async function addRow() {
+  if (props.loading) return
+  const row = makeRow('')
+  powersModel.value = [...powersModel.value, row]
+  await nextTick()
+  tableRef.value?.editRow?.(String(row._rowKey), 'b_action')
+}
+
+/**
+ * 行内删除：按 _rowKey 从草稿里摘掉。
+ * 不能用 `item !== row` —— 表格给回来的是展示副本，与草稿里的行不是同一个对象引用，
+ * 用引用比较会一行都删不掉。
+ */
+function removeRow(row: TableRow) {
+  const key = String((row as PowerRow)._rowKey ?? '')
+  if (!key) return
+  powersModel.value = powersModel.value.filter(
+    (item) => String((item as PowerRow)._rowKey) !== key,
+  )
+  // 删掉的行若在选中集合里，同步摘掉 —— 否则「批量删除（n）」的计数会把已删行算进去
+  if (selectedRowKeys.value.includes(key)) {
+    selectedRowKeys.value = selectedRowKeys.value.filter((item) => item !== key)
+  }
+}
+
+/* ---------- 批量删除（表格多选） ---------- */
+
+const selectedRowKeys = ref<string[]>([])
+
+const rowSelection = computed(() => ({
+  selectedRowKeys: selectedRowKeys.value,
+  onChange: (keys: unknown[]) => {
+    selectedRowKeys.value = (keys || []).map(String)
+  },
+}))
+
+/** 批量删除选中的权限点行，删完清空选中 */
+function removeSelectedRows() {
+  if (!selectedRowKeys.value.length) return
+  const removing = new Set(selectedRowKeys.value)
+  powersModel.value = powersModel.value.filter(
+    (row) => !removing.has(String((row as PowerRow)._rowKey)),
+  )
+  selectedRowKeys.value = []
+}
+
+// 切换模块时清掉选中：面板实例跨模块复用，上一模块的选中行不该留着
+watch(
+  () => props.moduleId,
+  () => {
+    selectedRowKeys.value = []
+  },
+)
+
+/* ---------- 权限库（历史录入的业务动作，右侧导入） ---------- */
+
+/** 库行：跨模块去重后的业务动作 */
+interface LibraryRow extends TableRow {
+  _rowKey: string
+  b_action: string
+  b_name: string
+}
+
+const libraryRows = ref<LibraryRow[]>([])
+const librarySelectedKeys = ref<string[]>([])
+const libraryLoading = ref(false)
+/** 请求序号：切换模块 / 连点刷新时，只有最后一次的结果能落到界面上 */
+let libraryToken = 0
+
+/** 本模块已用到的动作：库里对应的行置灰（导入会生成同编码的重复行） */
+const usedActions = computed(
+  () =>
+    new Set(
+      powersModel.value.map((row) => String((row as PowerRow).b_action ?? '').trim()).filter(Boolean),
+    ),
+)
+
+/** 库表列：名称固定一档窄宽，动作列自适应吃剩余宽度 */
+const libraryColumns = shallowRef<G3TableColumn<TableRow>[]>([
+  { dataIndex: 'b_name', title: '名称', width: 88 },
+  { dataIndex: 'b_action', title: '动作' },
+])
+
+const libraryRowSelection = computed(() => ({
+  selectedRowKeys: librarySelectedKeys.value,
+  onChange: (keys: unknown[]) => {
+    librarySelectedKeys.value = (keys || []).map(String)
+  },
+  // 已在本模块的动作不给勾：导入了也是重复编码
+  getCheckboxProps: (row: TableRow) => ({
+    disabled: usedActions.value.has(String((row as LibraryRow).b_action ?? '').trim()),
+  }),
+}))
+
+/** 读权限库：SQL 只回动作码（见 buildPowerLibrarySql），名称按共用动词口径生成 */
+async function loadLibrary() {
+  const token = (libraryToken += 1)
+  librarySelectedKeys.value = []
+  libraryLoading.value = true
+  try {
+    const rows = await loadDataBySqlApi(buildPowerLibrarySql())
+    if (token !== libraryToken) return
+    libraryRows.value = (rows || [])
+      .map((row) => {
+        const action = String(row.b_action ?? '')
+        return {
+          _rowKey: `action:${action}`,
+          b_action: action,
+          // 名称取共用动词名（「通过」），**不用** s_power.b_name ——
+          // 库里那是「模块名 - 动作名」，在按动作去重的库表里显示模块名是噪音
+          b_name: actionLabelOf(action),
+        }
+      })
+      .filter((row) => row.b_action)
+  } catch {
+    if (token === libraryToken) libraryRows.value = []
+  } finally {
+    if (token === libraryToken) libraryLoading.value = false
+  }
+}
+
+// 切换模块时重取：在别的模块里改过动作后，「切模块 → 回来导入」拿得到最新清单
+watch(
+  () => props.moduleId,
+  (id) => {
+    librarySelectedKeys.value = []
+    if (!id) {
+      // 丢弃在途结果：没有当前模块，落回来只会覆盖下一次的状态
+      libraryToken += 1
+      return
+    }
+    void loadLibrary()
+  },
+  { immediate: true },
+)
+
+/**
+ * 导入选中的库行：往本模块权限点里追加动作行（名称沿用库里的），已存在的动作跳过。
+ * 与「新增权限」同一条路径：派生列由 makeRow 统一物化。
+ */
+function importSelectedActions() {
+  if (props.loading || !librarySelectedKeys.value.length) return
+  const picked = libraryRows.value.filter((row) =>
+    librarySelectedKeys.value.includes(String(row._rowKey)),
+  )
+  const existing = new Set(usedActions.value)
+  const added: PowerRow[] = []
+  for (const item of picked) {
+    const action = String(item.b_action || '').trim()
+    if (!action || existing.has(action)) continue
+    existing.add(action)
+    added.push(makeRow(action, item.b_name))
+  }
+  librarySelectedKeys.value = []
+  if (!added.length) {
+    G3Message.info('选中的动作本模块都已存在')
+    return
+  }
+  powersModel.value = [...powersModel.value, ...added]
+  normalizeRows()
+  G3Message.success(`已导入 ${added.length} 个权限点`)
+}
+
+/* ---------- 列定义 ---------- */
+
+/**
+ * 表格数据：权限名称只显示**动作名**（「通过」），不显示库里的「模块名 - 动作名」。
+ *
+ * 这是**展示副本**，不是草稿本身：
+ *   - 名称按动作口径渲染（模块使用权限除外 —— 它的名字就是模块名，取动作名没有意义）；
+ *   - 编辑器的改动由 onCellChange 按 _rowKey 写回 powersModel，不写这份副本。
+ *
+ * 为什么不直接改草稿里的 b_name：它是**用户可编辑**的列，且库里存的是
+ * 「模块名 - 动作名」（写入侧口径，见 12_fms_workflow_power.sql）。若加载时就把它
+ * 替换成动作名，用户一进编辑态看到的便是不同的值，**一保存就把库里的值静默改写**。
+ * 只改展示、不碰落库值，才不会动到别人的数据。
+ */
+const displayRows = computed<TableRow[]>(() =>
+  powersModel.value.map((row) => {
+    const target = row as PowerRow
+    const action = String(target.b_action ?? '')
+    // 模块使用权限的名称取模块名（它就是「这个模块能不能用」），不按动作名渲染
+    if (action === MODULE_ACCESS_ACTION) return target
+    return { ...target, b_name: actionLabelOf(action) }
+  }),
+)
+
+const columns = shallowRef<G3TableColumn<TableRow>[]>([
+  { dataIndex: 'b_id', title: '权限编码', width: 190 },
+  { dataIndex: 'b_name', title: '权限名称', width: 140, editor: { type: 'text' } },
+  { dataIndex: 'b_action', title: '动作', width: 110, editor: { type: 'text' } },
+  {
+    dataIndex: 'b_canuse',
+    title: '启用',
+    width: 80,
+    align: 'center',
+    editor: { type: 'checkbox' },
+  },
+  { dataIndex: 'b_i18n', title: '多语言键', width: 170 },
+  {
+    dataIndex: 'actions',
+    title: '',
+    width: 60,
+    align: 'center',
+    actions: [
+      {
+        type: 'delete',
+        label: '删除',
+        onClick: (row: TableRow) => removeRow(row),
+      },
+    ],
+  },
+])
+</script>
+
+<template>
+  <div class="mm-power">
+    <!-- 左右两块并排：左本模块权限点（表按列宽占位），右权限库（定宽）。
+         多余宽度留在最右侧，窄窗口下两块一起被压窄，各自内部滚动。 -->
+    <div class="mm-power__row">
+      <!-- 左：本模块权限点 -->
+      <div class="mm-power__section mm-power__section--main">
+        <div class="mm-power__toolbar">
+          <G3Button type="primary" :disabled="loading" @click="addRow">
+            <template #icon><Plus :size="14" /></template>
+            新增权限
+          </G3Button>
+          <G3Button
+            type="danger-outline"
+            :disabled="loading || !selectedRowKeys.length"
+            :title="
+              selectedRowKeys.length
+                ? `删除选中的 ${selectedRowKeys.length} 个权限点`
+                : '先勾选要删除的权限点'
+            "
+            @click="removeSelectedRows"
+          >
+            <template #icon><Trash2 :size="14" /></template>
+            批量删除{{ selectedRowKeys.length ? `（${selectedRowKeys.length}）` : '' }}
+          </G3Button>
+        </div>
+        <div class="mm-power__table">
+          <G3Table
+            ref="tableRef"
+            v-model:columns="columns"
+            :data-source="displayRows"
+            :row-height="28"
+            row-key="_rowKey"
+            :row-selection="rowSelection"
+            @change="onCellChange"
+          />
+        </div>
+      </div>
+
+      <!-- 右：权限库（其它模块用过的业务动作），勾选后导入到左侧 -->
+      <div class="mm-power__section mm-power__section--library">
+        <div class="mm-power__toolbar">
+          <span class="mm-power__caption">权限库（历史录入）</span>
+          <G3Button
+            type="outline"
+            :disabled="loading || !librarySelectedKeys.length"
+            title="把选中的动作导入到左侧（本模块已有的动作会跳过）"
+            @click="importSelectedActions"
+          >
+            <template #icon><ArrowLeft :size="14" /></template>
+            导入{{ librarySelectedKeys.length ? `（${librarySelectedKeys.length}）` : '' }}
+          </G3Button>
+          <G3Button
+            type="outline"
+            title="重新读取权限库"
+            aria-label="刷新权限库"
+            @click="loadLibrary"
+          >
+            <template #icon><RefreshCw :size="14" /></template>
+          </G3Button>
+        </div>
+        <div class="mm-power__table">
+          <G3Table
+            v-model:columns="libraryColumns"
+            :data-source="libraryRows"
+            :row-height="28"
+            row-key="_rowKey"
+            :row-selection="libraryRowSelection"
+          />
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.mm-power {
+  display: flex;
+  flex: 1;
+  min-height: 0;
+}
+
+/* 左右两块并排：两块紧挨着，多余宽度留在最右侧 */
+.mm-power__row {
+  display: flex;
+  gap: 12px;
+  height: 100%;
+  min-width: 0;
+  flex: 1;
+}
+
+.mm-power__section {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+}
+
+/* 左：只占表格自己的宽度，窗口窄时跟着缩、由表内横向滚动兜底 */
+.mm-power__section--main {
+  flex: 0 1 auto;
+}
+
+/* 右：权限库也只占自己内容宽 —— 库表就两列，拉宽只是多一片空白。
+   **不设 max-width**：一旦限宽，它就成了列宽拖拽的天花板 ——
+   列宽之和超过这个上限时表框被压住，拖到哪里都出横向滚动条（左表没有这个上限，
+   所以拖同样的量它不出滚动条，两张表的手感会不一致）。 */
+.mm-power__section--library {
+  flex: 0 1 auto;
+  min-width: 0;
+}
+
+.mm-power__toolbar {
+  display: flex;
+  flex: none;
+  align-items: center;
+  gap: 8px;
+  padding-bottom: 8px;
+}
+
+/* 库表自己的标题：长文案省略，不与右侧按钮争宽 */
+.mm-power__caption {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  color: var(--g3-color-text-secondary, #4e5969);
+  font-size: 12px;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.mm-power__table {
+  /* 纵向仍要撑满分栏剩余高度（否则表体区域塌成内容高、滚动区失效）；
+     横向**不能**用 flex 拉伸 —— 见下一条注释。 */
+  flex: 1 1 auto;
+  min-width: 0;
+  min-height: 0;
+  /* 这层是 inline 尺寸跟随内容的块：宽度由子元素（表格）撑开，不被父级拉满，
+     这样表格的 `max-width: 100%` 才是「分栏宽度」这个真实上限，
+     而不是「被拉伸后的宽度」。 */
+  width: fit-content;
+  max-width: 100%;
+}
+
+/* 表格按列宽定宽，不铺满容器。
+ *
+ * G3Table 的根节点自带 `width: 100%`，所以默认一定会拉满父级 —— 而权限面板这里
+ * 两张表都**不该**铺满：左表 5 列、右表 2 列，拉宽只是在各列之间摊开一片空白。
+ * 让表框贴住内容宽度，多余宽度留在最右侧即可（照 fms-vue 的 ModulePowerPanel）。
+ *
+ * fit-content 作用在**表框**（G3Table 根节点）上：只定宽内层 <table> 的话外框
+ * 仍会拉满，看起来还是铺满的。max-width 保证列宽之和超过分栏时退回分栏宽，
+ * 横向滚动交给表格自己（这时拖列宽仍然可用）。 */
+.mm-power__table :deep(.g3-table) {
+  width: fit-content;
+  max-width: 100%;
+}
+</style>
diff --git a/code/g3soft-erp/web/src/views/module/module-management/ModuleQueryPanel.vue b/code/g3soft-erp/web/src/views/module/module-management/ModuleQueryPanel.vue
index 8e6a15a3..058d88f6 100644
--- a/code/g3soft-erp/web/src/views/module/module-management/ModuleQueryPanel.vue
+++ b/code/g3soft-erp/web/src/views/module/module-management/ModuleQueryPanel.vue
@@ -1,67 +1,53 @@
 <script setup lang="ts">
 /**
- * 查询配置面板（s_module_schema.b_schema_type = 'query'，schemaVersion 3）。
+ * 查询配置面板（s_module_schema.b_schema_type = 'query'，schemaVersion 4）。
  *
- * 两屏，顶部 Segmented 切换。两屏**同一套操作范式**：一行一个区、条目是 chip、
- * 点 chip 在浮层里改设置、拖 chip 排序或跨区移动。
- * - 查询字段：快捷筛选 / 更多筛选 / 关键词 三行
- * - 工作队列页签：一个页签组一行
+ * 只配一件事：工作队列页签。一个表格，**点格即改**（G3Table 行内编辑），不弹浮层。
  *
- * 字段屏为什么不是表格：原来照 fms 复刻成「全字段表格 + 逐格改单元格」，
- * 一个模块几十个字段、参与查询的就几个，用户得在几十行里找到那几个再一格格改；
- * 而且同一个字段要在「更多条件字段」「快捷筛选字段」「关键词字段」登记 2~3 次，
- * 其中「更多条件字段」的语义还是排除法（= 未进快捷筛选的查询字段），
- * 改一处会让另一张表的内容莫名增减。改成 chip 后配置只发生在「已经配了的字段」上，
- * 找字段交给添加浮层里的搜索，字段在哪一行就是什么状态，不必再用文字解释包含关系。
+ * 为什么是一个表格而不是「一组一张表」：grid 的键盘能力是**表内**的 ——
+ * 方向键到表的上下边界就停住，Tab 走到末格会跳去页面别处，不会接着走进下一组。
+ * 分成多张表，录入时每过几格就「掉出键盘」，得重新用鼠标点回下一张表；
+ * 合成一张后方向键与 Tab 能一路走完全部页签，这才是 Excel 那种手感。
+ * 顺带还省掉了「每张表都要单独算容器高度」这件事（多实例吃不到 flex）。
  *
- * 查询控件与操作符没有编辑入口：由字段业务类型自动定（日期字段当然是日期框、
- * 下拉字段当然是下拉），配置里已有的值原样保留、面板不改写；能人工配的只剩默认查询值。
+ * 组因此从「视觉容器」降级成一个属性 + 表格上方的一行 chip：
+ *   分组   → 表格里的「分组」列（下拉换组，点两下就换）
+ *   组序   → 拖 chip
+ *   改名   → chip 上的名字就地改
+ *   删除   → chip 上的 ×（连同组内页签）
+ * 「分组」列只在每组第一行显示组名，看上去就是一张分组表；其余行为空，不重复占视线。
+ *
+ * 为什么没有「查询字段」这一屏：关键词搜哪些字段、更多筛选铺哪些字段、
+ * 用什么控件与算子，运行时按 s_field 就能推导（控件与算子看业务类型、
+ * 关键词看文本类字段、顺序看 b_xh），配一遍是纯重复劳动还容易漏配。
+ * 相对时间的快捷预设属于日期控件自己的能力，也不归这里配。
  *
  * 数据契约：对外仍是 query JSON（父级 v-model），utils 的适配函数不变。
- * 面板内部以「行」为中心：rebuildFieldRows() 只在草稿被替换 / 字段清单变化时重建，
- * 之后一律就地改行再 syncDraft() 反推草稿——行对象换新会让浮层与拖拽的锚点白白重建。
+ * 行内编辑直接改行对象（不是换数组）—— 换引用会让表格整张重建、丢掉编辑态；
+ * 而 viewRows 的深层 watch 照样会被唤醒，回写父级。
  *
  * 本步只做配置编辑：保存（逐表 diff → 提交）随保存编排一起移植。
  */
-import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue'
-import { GripVertical, Plus, Star, Trash2, X } from '@lucide/vue'
-import {
-  G3Button,
-  G3DatePicker,
-  G3Checkbox,
-  G3Input,
-  G3Message,
-  G3Modal,
-  G3Popover,
-  G3Segmented,
-  type SegmentedValue,
-} from '@g3soft/ui'
+import { computed, nextTick, ref, watch } from 'vue'
+import { GripVertical, Plus, X } from '@lucide/vue'
+import { G3Button, G3Message, G3Modal, G3Table } from '@g3soft/ui'
+import type { G3TableColumn, TableExpose, TableRow } from '@g3soft/ui'
 import { createTempId } from '@/utils/common'
 import { createDefaultSchema, stableStringify, type SchemaJson } from '@/utils/schemaJson'
 import {
   DEFAULT_VIEW_GROUP,
-  QUERY_DATE_PRESETS,
-  QUERY_QUICK_MODES,
   queryDraftToSchema,
-  queryRowDefaults,
   querySchemaToDraft,
   validateConditionSql,
-  type ModuleFieldRow,
-  type ModuleQueryDraft,
-  type ModuleQueryFieldRow,
   type ModuleQueryViewRow,
 } from './utils'
 
 const props = withDefaults(
   defineProps<{
-    /** 模块编码（新行的 b_module_id） */
-    moduleId: string
-    /** 本模块字段清单（s_field）：查询字段表的行源 */
-    fields?: ModuleFieldRow[]
-    /** 父级忙碌态（加载 / 保存中）：期间锁掉勾选与新增按钮 */
+    /** 父级忙碌态（加载 / 保存中）：期间锁掉编辑与增删 */
     loading?: boolean
   }>(),
-  { fields: () => [], loading: false },
+  { loading: false },
 )
 
 /** 查询配置对象（query JSON），父级 v-model 绑定 */
@@ -69,38 +55,26 @@ const queryModel = defineModel<SchemaJson>('query', {
   default: () => createDefaultSchema('query'),
 })
 
-/** 编辑器草稿：页签与字段的编辑态都经它回写 */
-const draft = ref<ModuleQueryDraft | null>(null)
+/** 页签行（视图模型）。声明在草稿 watch 之前——那个 watch 是 immediate 的，到点就会填它 */
+const viewRows = ref<ModuleQueryViewRow[]>([])
 let syncedSchema: SchemaJson | null = null
 
-/** 查询字段表的行（视图模型）。声明在草稿 watch 之前——那个 watch 是 immediate 的，
- *  到点就会调 rebuildFieldRows() 填它。 */
-const fieldRows = ref<QueryFieldRow[]>([])
-
 watch(
   queryModel,
   (value) => {
     if (value === syncedSchema) return
-    draft.value = querySchemaToDraft(value ?? createDefaultSchema('query'), props.moduleId)
+    viewRows.value = querySchemaToDraft(value ?? createDefaultSchema('query')).views
     syncedSchema = value
-    rebuildFieldRows()
   },
   { immediate: true },
 )
 
-// 字段清单是异步到的（选中模块后加载），到货即重建行
-watch(() => props.fields, rebuildFieldRows)
-
 watch(
-  draft,
+  viewRows,
   () => {
-    if (!draft.value) return
     const current = queryModel.value ?? createDefaultSchema('query')
-    const normalizedCurrent = queryDraftToSchema(
-      querySchemaToDraft(current, props.moduleId),
-      current,
-    )
-    const next = queryDraftToSchema(draft.value, current)
+    const normalizedCurrent = queryDraftToSchema(querySchemaToDraft(current), current)
+    const next = queryDraftToSchema({ views: viewRows.value }, current)
     if (stableStringify(next) === stableStringify(normalizedCurrent)) return
     syncedSchema = next
     queryModel.value = next
@@ -108,379 +82,7 @@ watch(
   { deep: true },
 )
 
-/* ================= 屏切换 ================= */
-const activePane = ref<SegmentedValue>('fields')
-
-/* ================= 受控输入的小包装 =================
- * G3Input 的 v-model 负载是 string | number，直接绑到 string 字段上过不了类型检查，
- * 统一走「取值即转字符串」的处理器（与其它面板同款写法）。 */
-
-/* ================= 分节一：查询字段 =================
- * 两个区，对应列表页查询入口里**两件不同的事**：
- *   快捷搜索 —— 摆在查询卡上的入口。一条可以「直接放控件」（用户自己填），
- *     也可以「给预设」（日期字段给一排今天 / 本周 / 本月，点一下就筛）；
- *   关键词搜索 —— 顶部一个**共用**的搜索框，对这一批字段做模糊匹配。
- * 「更多筛选」不在这里：那是普通查询条件，运行时把模块字段全铺进抽屉、用户自己加，
- * 没有可配的东西。所以这里也没有「档位」的概念 —— 每条字段就是两个独立的开关。
- */
-
-/** 两个区 */
-type QueryFieldZone = 'quick' | 'keyword'
-
-const FIELD_ZONES: Array<{ key: QueryFieldZone; label: string }> = [
-  { key: 'quick', label: '快捷搜索' },
-  { key: 'keyword', label: '关键词搜索' },
-]
-
-/** 查询字段行（视图模型，不是落库结构） */
-interface QueryFieldRow {
-  b_field: string
-  b_name: string
-  b_type: string
-  b_canuse: number
-  /** 草稿里配过、但 s_field 里已经没有这个字段（残留行） */
-  missing: boolean
-  /** 摆查询卡上 */
-  quick: boolean
-  /** 进 keywordSearch.fields */
-  keyword: boolean
-  /**
-   * 查询控件 / 操作符 / 默认值：前两个没有编辑入口（按业务类型自动定、已有值原样带过）。
-   * 都只负责「带过」——没有它们，回写会把对应键从配置里删掉（queryDraftToSchema 的 else 分支）。
-   */
-  b_component: string
-  b_operator: string
-  b_default_value: string | null
-  /** 卡上的呈现方式：control 直接放控件 / preset 给一排预设 */
-  mode: string
-  /** preset 模式下要露出的预设（相对时间枚举） */
-  presets: string[]
-  /** preset 模式下默认选中哪个预设（空 = 打开页面不带条件） */
-  defaultPreset: string | null
-  /** 卡上的顺序号；不在卡上时为 null */
-  b_xh: number | null
-  /** 关键词列表里的顺序号；不在关键词里时为 null */
-  kwOrder: number | null
-  /** 原 queryFields 行的未建模属性，回写时原样带回 */
-  _node: Record<string, unknown>
-  [key: string]: unknown
-}
-
-function rebuildFieldRows() {
-  const current = draft.value
-  const configured = new Map<string, ModuleQueryFieldRow>()
-  for (const row of current?.fields || []) {
-    const key = String(row.b_field ?? '')
-    if (key) configured.set(key, row)
-  }
-  const quickSet = new Set((current?.quickFilters || []).map((row) => String(row.field ?? '')))
-  const keywordOrder = new Map<string, number>()
-  for (const [index, field] of (current?.keyword?.fields || []).entries()) {
-    keywordOrder.set(String(field), index)
-  }
-
-  const rows: QueryFieldRow[] = []
-  const known = new Set<string>()
-  for (const field of props.fields || []) {
-    const key = String(field.b_field ?? '')
-    if (!key || known.has(key)) continue
-    known.add(key)
-    const config = configured.get(key)
-    // 没配过的字段按业务类型兜初值：日期字段自然是日期框、数字字段自然是数字框
-    const defaults = queryRowDefaults(field)
-    rows.push({
-      b_field: key,
-      b_name: String(field.b_name ?? ''),
-      b_type: String(field.b_type ?? ''),
-      b_canuse: Number(field.b_canuse ?? 1),
-      missing: false,
-      quick: quickSet.has(key),
-      keyword: keywordOrder.has(key),
-      b_component: String(config?.b_component ?? defaults.b_component),
-      b_operator: String(config?.b_operator ?? defaults.b_operator),
-      b_default_value: config?.b_default_value == null ? null : String(config.b_default_value),
-      mode: String(config?.b_mode ?? 'control'),
-      presets: Array.isArray(config?.b_presets) ? (config.b_presets as string[]) : [],
-      defaultPreset: config?.b_default_preset == null ? null : String(config.b_default_preset),
-      b_xh: config ? Number(config.b_xh) || null : null,
-      kwOrder: keywordOrder.get(key) ?? null,
-      _node: (config?._node as Record<string, unknown>) ?? {},
-    })
-  }
-  // 残留行：字段已从 s_field 消失，但配置还在。保留在区里可见，移出去即清理
-  for (const [key, config] of configured) {
-    if (known.has(key)) continue
-    rows.push({
-      b_field: key,
-      b_name: '',
-      b_type: '',
-      b_canuse: 1,
-      missing: true,
-      quick: quickSet.has(key),
-      keyword: keywordOrder.has(key),
-      b_component: String(config.b_component ?? 'input'),
-      b_operator: String(config.b_operator ?? 'like'),
-      b_default_value: config.b_default_value == null ? null : String(config.b_default_value),
-      mode: String(config.b_mode ?? 'control'),
-      presets: Array.isArray(config.b_presets) ? (config.b_presets as string[]) : [],
-      defaultPreset: config.b_default_preset == null ? null : String(config.b_default_preset),
-      b_xh: Number(config.b_xh) || null,
-      kwOrder: keywordOrder.get(key) ?? null,
-      _node: (config._node as Record<string, unknown>) ?? {},
-    })
-  }
-  fieldRows.value = rows
-}
-
-/** 某个区里的字段，按各自的顺序号排好 */
-function zoneRows(zone: QueryFieldZone): QueryFieldRow[] {
-  if (zone === 'keyword') {
-    return fieldRows.value
-      .filter((row) => row.keyword)
-      .toSorted((a, b) => (a.kwOrder ?? 0) - (b.kwOrder ?? 0))
-  }
-  return fieldRows.value
-    .filter((row) => row.quick)
-    .toSorted((a, b) => (a.b_xh ?? 0) - (b.b_xh ?? 0))
-}
-
-/**
- * 行 → 草稿。
- * queryFields 只收「卡上这些字段」——「更多筛选」运行时按模块字段自动铺，
- * 不需要在这里列清单，所以字段级配置（控件 / 算子 / 默认值 / 预设）就存在这些条目上。
- */
-function syncDraft() {
-  const current = draft.value
-  if (!current) return
-  const active = fieldRows.value
-    .filter((row) => row.quick)
-    .toSorted((a, b) => (a.b_xh ?? 0) - (b.b_xh ?? 0))
-  draft.value = {
-    ...current,
-    fields: active.map((row) => ({
-      _rowKey: createTempId(),
-      _node: row._node || {},
-      b_module_id: props.moduleId,
-      b_field: row.b_field,
-      b_component: row.b_component,
-      b_operator: row.b_operator,
-      b_default_value: row.b_default_value,
-      b_mode: row.mode,
-      b_presets: row.presets,
-      b_default_preset: row.defaultPreset,
-      b_canuse: 1,
-      b_xh: row.b_xh ?? 0,
-      // 列表面板尚未移植：勾选联动所需的 fromList 标记一律不写（= 自定义行）
-      fromList: false,
-    })),
-    quickFilters: active.map((row) => ({
-      _rowKey: createTempId(),
-      field: row.b_field,
-      order: row.b_xh ?? 0,
-    })),
-    keyword: {
-      fields: fieldRows.value
-        .filter((row) => row.keyword)
-        .toSorted((a, b) => (a.kwOrder ?? 0) - (b.kwOrder ?? 0))
-        .map((row) => row.b_field),
-    },
-  }
-}
-
-/** 卡上下一个顺序号：全局最大值 + 10，保证新加的排在最后 */
-function nextFieldXh(): number {
-  let max = 0
-  for (const row of fieldRows.value) {
-    const xh = Number(row.b_xh) || 0
-    if (xh > max) max = xh
-  }
-  return max + 10
-}
-
-/** 关键词列表下一个顺序号 */
-function nextKwOrder(): number {
-  let max = 0
-  for (const row of fieldRows.value) {
-    if (row.kwOrder != null && row.kwOrder > max) max = row.kwOrder
-  }
-  return max + 10
-}
-
-/** 把字段放进某个区；两个区彼此独立，一条字段可以同时在两边 */
-function putFieldInZone(row: QueryFieldRow, zone: QueryFieldZone) {
-  if (zone === 'keyword') {
-    if (row.keyword) return
-    row.keyword = true
-    row.kwOrder = nextKwOrder()
-    return
-  }
-  if (row.quick) return
-  row.quick = true
-  row.b_xh = nextFieldXh()
-}
-
-/** 把字段从某个区移出去（只影响这个区，另一个区不动） */
-function removeFieldFromZone(row: QueryFieldRow, zone: QueryFieldZone) {
-  if (zone === 'keyword') {
-    row.keyword = false
-    row.kwOrder = null
-  } else {
-    row.quick = false
-    row.b_xh = null
-  }
-  syncDraft()
-}
-
-function fieldLabelOf(row: QueryFieldRow): string {
-  return row.b_name || row.b_field || '（未命名）'
-}
-
-/* ---------- 左侧字段池 ----------
- * 把「这个模块有哪些字段」摊开：不用先点 ＋ 才知道有什么可配。
- *   拖到某一区 ＝ 落进那一区；点一下 ＝ 加进「快捷搜索」；拖回池子 ＝ 移出那一区。
- * 已配的字段留在池子里并标出它在哪个区 —— 不然「换区」只能先去右边找到那个 chip。
- */
-
-const fieldPoolSearch = ref('')
-
-const fieldPoolRows = computed<QueryFieldRow[]>(() => {
-  const keyword = fieldPoolSearch.value.trim().toLowerCase()
-  return fieldRows.value.filter(
-    (row) => !keyword || `${row.b_name} ${row.b_field}`.toLowerCase().includes(keyword),
-  )
-})
-
-function onFieldPoolSearch(value: unknown) {
-  fieldPoolSearch.value = value == null ? '' : String(value)
-}
-
-/** 池子里这条字段现在在哪个区（标签要短，池子只有 200px） */
-function fieldZoneTagsOf(row: QueryFieldRow): string[] {
-  const tags: string[] = []
-  if (row.quick) tags.push('快捷')
-  if (row.keyword) tags.push('关键词')
-  return tags
-}
-
-/** 点一下＝加进「快捷搜索」。已经在卡上的不动它，避免误操作 */
-function addPoolFieldByClick(row: QueryFieldRow) {
-  if (row.quick) return
-  putFieldInZone(row, 'quick')
-  syncDraft()
-}
-
-function startPoolFieldDrag(row: QueryFieldRow, event: DragEvent) {
-  if (props.loading) {
-    event.preventDefault()
-    return
-  }
-  dragItem.value = { kind: 'poolField', bField: row.b_field }
-  dropSpot.value = null
-  event.dataTransfer?.setData('text/plain', row.b_field)
-  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
-}
-
-function isPoolFieldDragging(row: QueryFieldRow): boolean {
-  const drag = dragItem.value
-  return drag?.kind === 'poolField' && drag.bField === row.b_field
-}
-
-/** 拖着区里的 chip 经过池子：池子整块都是「拿出去」的落点 */
-function onPoolDragOver(event: DragEvent) {
-  if (dragItem.value?.kind !== 'field') return
-  event.preventDefault()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
-}
-
-function onPoolDrop(event: DragEvent) {
-  event.preventDefault()
-  const drag = dragItem.value
-  endDrag()
-  if (drag?.kind !== 'field') return
-  const row = fieldRows.value.find((item) => item.b_field === drag.bField)
-  if (row) removeFieldFromZone(row, drag.zone)
-}
-
-/* ---------- 卡上这一条怎么摆：直接放控件 / 给预设 ---------- */
-const fieldPopoverKey = ref<string | null>(null)
-
-function onFieldPopover(row: QueryFieldRow, value: boolean) {
-  if (value) fieldPopoverKey.value = row.b_field
-  else if (fieldPopoverKey.value === row.b_field) fieldPopoverKey.value = null
-}
-
-function patchFieldDefault(row: QueryFieldRow, value: unknown) {
-  const text = value == null ? '' : String(value)
-  row.b_default_value = text.trim() ? text : null
-  syncDraft()
-}
-
-/** 切到「给预设」时先垫一组常用预设，免得空着还要用户挨个点 */
-const DEFAULT_PRESET_SEEDS = ['today', 'this_week', 'this_month']
-
-function patchFieldMode(row: QueryFieldRow, value: unknown) {
-  const mode = String(value ?? 'control') === 'preset' ? 'preset' : 'control'
-  row.mode = mode
-  if (mode === 'preset') {
-    if (!row.presets.length) row.presets = [...DEFAULT_PRESET_SEEDS]
-  } else {
-    row.defaultPreset = null
-  }
-  syncDraft()
-}
-
-/** 勾 / 取消一个预设；默认选中若被取消，一并清掉 */
-function togglePreset(row: QueryFieldRow, preset: string, checked: boolean) {
-  const picked = new Set(row.presets)
-  if (checked) picked.add(preset)
-  else picked.delete(preset)
-  // 按枚举顺序落存，勾选顺序不影响展示顺序
-  row.presets = QUERY_DATE_PRESETS.map((item) => item.value).filter((value) => picked.has(value))
-  if (!row.presets.includes(String(row.defaultPreset ?? ''))) row.defaultPreset = null
-  syncDraft()
-}
-
-/** 点一下设成默认选中；再点一下取消（打开页面就不带条件） */
-function patchDefaultPreset(row: QueryFieldRow, preset: string) {
-  const next = String(row.defaultPreset ?? '') === preset ? '' : preset
-  row.defaultPreset = next && row.presets.includes(next) ? next : null
-  syncDraft()
-}
-
-/** 这一条勾了哪些预设（按枚举顺序） */
-function presetOptionsOf(row: QueryFieldRow) {
-  return QUERY_DATE_PRESETS.filter((item) => row.presets.includes(item.value))
-}
-
-/** 预设的显示名（chip 上要展示默认选中的那个） */
-function presetLabelOf(preset: unknown): string {
-  const value = String(preset ?? '')
-  return QUERY_DATE_PRESETS.find((item) => item.value === value)?.label ?? value
-}
-
-/* ================= 分节二：工作队列页签 =================
- * 不用表格，也不用卡片：一屏一行一组，页签是 chip，点 chip 在浮层里改。
- *
- * 为什么不用表格：组是「容器」，不是每行都要重复一遍的值（3 个页签就要写 3 遍「运行状态」），
- * 而且页签运行时长什么样是有定式的——列表页顶部一排可点的页签，配置界面直接画成那个样子。
- * 为什么不用卡片：每组一张卡时，边框 + 内边距 + 卡片间距自己就占掉半屏，组一多就全是框。
- * 为什么编辑器放浮层而不是铺在页面上：铺开会把下面的组整体顶下去，看一行改一个值要来回跳。
- *
- * 页签一定有组（见 utils 的 DEFAULT_VIEW_GROUP），所以没有「未分组」这一行：
- * 建组即建页签，往组里加页签走行尾的 ＋。
- *
- * 原来摊在表格里的东西各自归位：
- *   分组   → 行首的组名（要换组直接把 chip 拖过去）
- *   默认   → chip 上的 ★（组内唯一，勾了自动顶掉同组其它页签）
- *   数量   → chip 上的计数角标（运行时真的会显示记录数）
- *   条件   → 浮层里的多行 SQL，不再是「点一下开弹窗」也不是「表格里一行摘要」
- *   顺序   → 拖 chip（见下面的拖拽一节）
- */
-
-const viewRows = computed<ModuleQueryViewRow[]>(() => draft.value?.views || [])
-
-/** 当前打开编辑浮层的页签（_rowKey）；同时只开一个 */
-const openViewKey = ref<string | null>(null)
+/* ================= 分组 ================= */
 
 function orderOfView(row: ModuleQueryViewRow): number {
   return Number(row.order) || 0
@@ -513,530 +115,188 @@ function groupOfView(row: ModuleQueryViewRow): string {
 
 const viewGroupNames = computed(() => viewGroups.value.map((group) => group.name))
 
-/** 就地改完之后换一次引用：视图（computed）与草稿 watch 都要被唤醒 */
-function bumpViews() {
-  if (!draft.value) return
-  draft.value = { ...draft.value, views: [...viewRows.value] }
+/** 行 key → 它是不是所在组的第一行（「分组」列只在这行显示组名） */
+const groupFirstKeys = computed(() => {
+  const keys = new Set<string>()
+  for (const group of viewGroups.value) {
+    const first = group.items[0]
+    if (first) keys.add(String(first._rowKey))
+  }
+  return keys
+})
+
+/* ================= 表格实例（新增行后要能自动落进编辑态） ================= */
+
+const tableRef = ref<TableExpose | null>(null)
+
+/** 让某一行落进编辑态，并把它设为当前高亮行 */
+async function editRow(rowKey: string, col: string) {
+  const row = viewRows.value.find((item) => String(item._rowKey) === rowKey)
+  if (!row) return
+  activeKey.value = rowKey
+  await nextTick()
+  tableRef.value?.editRow?.(rowKey, col)
 }
 
+/** 当前高亮行（点哪行亮哪行，与其它面板的表格口径一致） */
+const activeKey = ref<string | null>(null)
+
+/* ================= 增删改 ================= */
+
 /**
- * 下一个顺序号，取**全局**最大值 + 10。
+ * 把 order 按「当前的分组与组内顺序」整编成 10、20、30……
  *
- * 不能只看本组：新组的第一个页签若拿本组最大值（空组就是 0）→ 10，会和第一个组的最小
- * order 撞上，组顺序的排序比较器对不上，新组就会插到中间去。取全局最大值后，
- * 新页签恒为全局最后一个，在本组里也必然是末尾。
+ * 单表格下 order 是**全局**一条序列：组的先后由「组内最小 order」决定，
+ * 所以顺序只要全局递增就自然成立。增删行 / 换组之后调它收口，
+ * 免得新行的 order 落在两组交界处、把组打散。
+ *
+ * 先按组名把行取成快照再统一写 order：写的过程会触发 viewGroups 重算，
+ * 边读边写会拿到抖动的中间态。
  */
-function nextViewOrder(): number {
+function renumberViews(groupOrder: string[] = viewGroups.value.map((group) => group.name)) {
+  const snapshot = groupOrder.map((name) => ({
+    name,
+    items: viewRows.value
+      .filter((row) => groupOfView(row) === name)
+      .toSorted((a, b) => orderOfView(a) - orderOfView(b)),
+  }))
+  let xh = 0
+  for (const { items } of snapshot) {
+    for (const row of items) {
+      xh += 10
+      row.order = xh
+    }
+  }
+}
+
+/** 组内当前的最后一个顺序号（新行要接在它后面，不能落进下一组） */
+function lastOrderIn(groupName: string): number {
   let max = 0
   for (const row of viewRows.value) {
-    const order = orderOfView(row)
-    if (order > max) max = order
+    if (groupOfView(row) === groupName) max = Math.max(max, orderOfView(row))
   }
-  return max + 10
-}
-
-async function addViewRow(group: string) {
-  if (props.loading || !draft.value) return
-  const name = String(group || '').trim()
-  const newKey = createTempId()
-  // 组里还没有默认页签时，新加的这个直接当默认——一个组总要有一个默认选中的
-  const hasDefault = viewRows.value.some(
-    (row) => groupOfView(row) === name && row.isDefault,
-  )
-  draft.value = {
-    ...draft.value,
-    views: [
-      ...viewRows.value,
-      {
-        _rowKey: newKey,
-        _node: {},
-        code: '',
-        label: '',
-        group: name,
-        order: nextViewOrder(),
-        showCount: false,
-        isDefault: !hasDefault,
-        conditionSql: '',
-      },
-    ],
-  }
-  // 等 chip 渲染出来再开浮层：浮层要拿它当锚点定位
-  await nextTick()
-  openViewKey.value = newKey
-}
-
-/* ---------- 拖拽：页签（组内重排 / 跨组）与页签组（整行排序） ----------
- * 原生 HTML5 DnD，不引拖拽库：两个容器都是本组件渲染的，落点判定用不着库，
- * 而且仓库里已有同一套范式（G3Tree + 左侧模块树），手感保持一致。
- *
- * 「点 chip 开浮层」和「拖 chip 排序」靠浏览器自己的拖拽阈值分开：纯点击不移动不会触发
- * dragstart，手抖几像素也在阈值内，真拖起来才走排序。
- * 曾经照模块树那套做过「按住 400ms 且位移不超过 6px 才武装 draggable」，两个问题：
- *   1) 不知道要长按的人一按就拖，只觉得「拖不动」；
- *   2) 武装后位移再 disarm 会把 draggable 收回去，浏览器发起拖拽时元素已经不可拖 —— 拖不起来。
- * 模块树那边位移只取消「还没到点的计时器」、不动已武装的状态，所以没踩第二个坑；
- * 但第一个坑绕不过去，芯片这么小的目标不适合长按。
- *
- * 落点记成「插到谁前面」（null = 插到末尾）而不是下标：从同组里拖出来时下标会漂，
- * before 语义不会。
- */
-
-/** 正在拖的对象：页签、页签组、查询字段 */
-type DragItem =
-  | { kind: 'view'; rowKey: string }
-  | { kind: 'group'; name: string }
-  | { kind: 'field'; bField: string; zone: QueryFieldZone }
-  | { kind: 'poolField'; bField: string }
-
-/** 落点：一律记「插到谁前面」，null = 插到末尾 */
-type DropSpot =
-  | { kind: 'view'; groupKey: string; beforeKey: string | null }
-  | { kind: 'group'; before: string | null }
-  | { kind: 'field'; zone: QueryFieldZone; before: string | null }
-
-const dragItem = ref<DragItem | null>(null)
-const dropSpot = ref<DropSpot | null>(null)
-
-function startViewDrag(row: ModuleQueryViewRow, event: DragEvent) {
-  if (props.loading) {
-    event.preventDefault()
-    return
-  }
-  dragItem.value = { kind: 'view', rowKey: String(row._rowKey) }
-  dropSpot.value = null
-  // 拖的时候浮层跟着挪很怪，先收起来
-  openViewKey.value = null
-  // 不写 dataTransfer 的话 Firefox 不会触发 drop
-  event.dataTransfer?.setData('text/plain', String(row._rowKey))
-  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
-}
-
-function startGroupDrag(group: QueryViewGroup, event: DragEvent) {
-  if (props.loading) {
-    event.preventDefault()
-    return
-  }
-  dragItem.value = { kind: 'group', name: group.name }
-  dropSpot.value = null
-  openViewKey.value = null
-  event.dataTransfer?.setData('text/plain', group.name)
-  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
-}
-
-function endDrag() {
-  dragItem.value = null
-  dropSpot.value = null
-  stopAutoScroll()
-}
-
-/* ---------- 拖到边缘时自动滚动 ----------
- * dragover 只在鼠标移动时触发，所以不能「来一次事件滚一点」——鼠标停在边缘不动就停了。
- * 这里用 rAF 循环：记下最后一次 dragover 的纵坐标，按它离容器上/下边的距离逐帧滚，
- * 滚到底（scrollTop 没变化）或指针离开边缘带就自己停。
- * 监听挂在容器的**捕获阶段**：chip 上的 dragover 会 stopPropagation，冒泡阶段收不到。 */
-
-/** 触发自动滚动的边缘带宽度 / 每帧最大滚动量（px） */
-const EDGE_SCROLL_ZONE = 48
-const EDGE_SCROLL_MAX_STEP = 16
-
-const dragScrollRef = ref<HTMLElement | null>(null)
-/** 最后一次 dragover 的屏幕纵坐标（跟容器用同一套坐标系，即视口坐标） */
-let dragPointerY = 0
-let scrollRaf: number | null = null
-
-function stopAutoScroll() {
-  if (scrollRaf != null) {
-    cancelAnimationFrame(scrollRaf)
-    scrollRaf = null
-  }
-}
-
-/** 这一帧该滚多少：越贴边滚得越快；不在边缘带内返回 0 */
-function edgeScrollStep(el: HTMLElement): number {
-  const box = el.getBoundingClientRect()
-  const topZone = box.top + EDGE_SCROLL_ZONE
-  const bottomZone = box.bottom - EDGE_SCROLL_ZONE
-  if (dragPointerY < topZone) {
-    const depth = Math.min((topZone - dragPointerY) / EDGE_SCROLL_ZONE, 1)
-    return -Math.ceil(depth * EDGE_SCROLL_MAX_STEP)
-  }
-  if (dragPointerY > bottomZone) {
-    const depth = Math.min((dragPointerY - bottomZone) / EDGE_SCROLL_ZONE, 1)
-    return Math.ceil(depth * EDGE_SCROLL_MAX_STEP)
-  }
-  return 0
-}
-
-function stepAutoScroll() {
-  scrollRaf = null
-  const el = dragScrollRef.value
-  if (!dragItem.value || !el) return
-  const step = edgeScrollStep(el)
-  if (!step) return
-  const before = el.scrollTop
-  el.scrollTop = before + step
-  // 滚不动了（已经到底）就别空转，等下一次 dragover 再试
-  if (el.scrollTop !== before) scrollRaf = requestAnimationFrame(stepAutoScroll)
-}
-
-/** 容器捕获阶段的 dragover：只记坐标并保证循环在跑，落点判定仍由行 / chip 自己的处理器做 */
-function onDragOverCapture(event: DragEvent) {
-  if (!dragItem.value) return
-  dragPointerY = event.clientY
-  if (scrollRaf == null) scrollRaf = requestAnimationFrame(stepAutoScroll)
-}
-
-/** 拖到某个 chip 上：按鼠标落在它的左 / 右半边决定插到它前面还是后面 */
-function onChipDragOver(group: QueryViewGroup, row: ModuleQueryViewRow, event: DragEvent) {
-  const drag = dragItem.value
-  if (drag?.kind !== 'view' || drag.rowKey === String(row._rowKey)) return
-  event.preventDefault()
-  // 被 chip 接住就别再冒到组行上（组行会当成「落到这一组末尾」）
-  event.stopPropagation()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
-  const box = (event.currentTarget as HTMLElement).getBoundingClientRect()
-  const next = event.clientX > box.left + box.width / 2 ? group.items[group.items.indexOf(row) + 1] : row
-  dropSpot.value = {
-    kind: 'view',
-    groupKey: group.key,
-    beforeKey: next ? String(next._rowKey) : null,
-  }
-}
-
-/** 拖到某一行上：拖页签 = 落到这一组末尾；拖组 = 按上下半边决定插到这一行前面还是后面 */
-function onRowDragOver(group: QueryViewGroup, event: DragEvent) {
-  const drag = dragItem.value
-  if (!drag) return
-  if (drag.kind === 'group' && drag.name === group.name) return
-  event.preventDefault()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
-  if (drag.kind === 'view') {
-    dropSpot.value = { kind: 'view', groupKey: group.key, beforeKey: null }
-    return
-  }
-  const box = (event.currentTarget as HTMLElement).getBoundingClientRect()
-  const after = event.clientY > box.top + box.height / 2
-  const groups = viewGroups.value
-  const next = after ? groups[groups.indexOf(group) + 1] : group
-  dropSpot.value = { kind: 'group', before: next ? next.name : null }
-}
-
-function onViewDrop(event: DragEvent) {
-  event.preventDefault()
-  const drag = dragItem.value
-  const drop = dropSpot.value
-  endDrag()
-  if (!drag || !drop) return
-  if (drag.kind === 'view' && drop.kind === 'view') applyViewDrop(drag.rowKey, drop)
-  else if (drag.kind === 'group' && drop.kind === 'group') applyGroupDrop(drag.name, drop)
+  return max
 }
 
 /**
- * 按给定的组序把**所有**页签的 order 从 10 起连续重编一遍。
+ * 新页签的编码：`view_N`（N = 现有 `view_N` 的最大值 + 1）。
  *
- * 必须整体重排，不能只排被改的那一组：组顺序由「组内最小 order」决定，
- * 单独把某一组编成 10、20、30，它的最小值就压到了别的组前面 —— 组顺序会跟着乱跳
- * （把一个页签拖进 B 组，B 组却窜到最前面，就是这么来的）。
+ * 编码是运行时选中页签的标识，落库时空编码的页签会被丢掉（见 utils 的
+ * `queryDraftToSchema`）—— 让用户自己想一个 snake_case 名字，忘了填就静默少一个页签，
+ * 所以建行时先给一个能用的，需要时再改。
  */
-function renumberViews(groupOrder: string[]) {
-  let xh = 0
-  for (const name of groupOrder) {
-    const items = viewRows.value
-      .filter((item) => groupOfView(item) === name)
-      .toSorted((a, b) => orderOfView(a) - orderOfView(b))
-    for (const item of items) {
-      xh += 10
-      item.order = xh
-    }
+function nextViewCode(): string {
+  let max = 0
+  for (const row of viewRows.value) {
+    const matched = /^view_(\d+)$/.exec(String(row.code ?? '').trim())
+    if (matched) max = Math.max(max, Number(matched[1]))
   }
+  return `view_${max + 1}`
 }
 
-/** 页签落位：换组 + 在目标组里插到 beforeKey 之前，然后整体重编 order */
-function applyViewDrop(rowKey: string, drop: { groupKey: string; beforeKey: string | null }) {
-  // 「插到自己前面」＝原地不动。不拦住的话，剔除自己后 findIndex 会返回 -1，
-  // 被当成「插到末尾」——从右边邻格往回拖一格就会莫名其妙跳到队尾
-  if (drop.beforeKey === rowKey) return
-  const row = viewRows.value.find((item) => String(item._rowKey) === rowKey)
-  const target = viewGroups.value.find((group) => group.key === drop.groupKey)
-  if (!row || !target) return
-  // 先记下当前组序：拖页签不该动组的顺序，重编时照这个顺序走
-  const groupOrder = viewGroups.value.map((group) => group.name)
-  const list = target.items.filter((item) => item !== row)
-  const at =
-    drop.beforeKey == null
-      ? list.length
-      : list.findIndex((item) => String(item._rowKey) === drop.beforeKey)
-  list.splice(at < 0 ? list.length : at, 0, row)
-  row.group = target.name
-  // 先给目标组按新顺序排好（相对值即可），再由 renumberViews 统一编号
-  list.forEach((item, index) => {
-    item.order = (index + 1) * 10
-  })
-  renumberViews(groupOrder)
-  bumpViews()
+/** 组名：分组 1、分组 2 ……（取第一个没被占用的） */
+function nextGroupName(): string {
+  let n = 1
+  while (viewGroupNames.value.includes(`分组 ${n}`)) n += 1
+  return `分组 ${n}`
 }
 
-/** 组落位：组没有独立实体，整组顺序就落在组内页签的 order 上（组内相对顺序不动） */
-function applyGroupDrop(name: string, drop: { before: string | null }) {
-  // 同页签：「插到自己前面」＝原地不动（见 applyViewDrop 的同款判断）
-  if (drop.before === name) return
-  const order = viewGroups.value.map((group) => group.name)
-  const from = order.indexOf(name)
-  if (from < 0) return
-  order.splice(from, 1)
-  const at = drop.before == null ? order.length : order.indexOf(drop.before)
-  order.splice(at < 0 ? order.length : at, 0, name)
-  renumberViews(order)
-  bumpViews()
-}
-
-/** 落点指示：这一行的这一组，要在第几个 chip 之前插一条竖线 */
-function isDropBefore(group: QueryViewGroup, row: ModuleQueryViewRow): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'view' && drop.groupKey === group.key && drop.beforeKey === String(row._rowKey)
-}
-
-/** 拖拽正落在这个组上：整框高亮（框内那条竖线仍然给精确位置） */
-function isViewDropActive(group: QueryViewGroup): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'view' && drop.groupKey === group.key
-}
-
-/** 落点在这一组末尾（拖到组行空白处，或最后一张 chip 的右半边） */
-function isDropEnd(group: QueryViewGroup): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'view' && drop.groupKey === group.key && drop.beforeKey == null
-}
-
-/** 组落点画在哪条边：只画「前面」，落点在末尾时画在最后一行的下边 */
-function groupDropEdge(group: QueryViewGroup): '' | 'before' | 'after' {
-  const drop = dropSpot.value
-  if (drop?.kind !== 'group') return ''
-  if (drop.before === group.name) return 'before'
-  const last = viewGroups.value[viewGroups.value.length - 1]
-  return drop.before == null && last?.name === group.name ? 'after' : ''
-}
-
-function isViewDragging(row: ModuleQueryViewRow): boolean {
-  const drag = dragItem.value
-  return drag?.kind === 'view' && drag.rowKey === String(row._rowKey)
-}
-
-function isGroupDragging(group: QueryViewGroup): boolean {
-  const drag = dragItem.value
-  return drag?.kind === 'group' && drag.name === group.name
-}
-
-/* ---------- 查询字段的拖拽 ----------
- * 三个区之间随便拖，落点决定这条字段变成什么：
- *   拖到「快捷筛选」/「更多筛选」＝ 换档（两者同属 queryFields，只能占一个）；
- *   拖到「关键词」＝ 补上关键词。关键词是另一条轴，不抢查询档位，
- *     所以这条字段会同时出现在两行 —— 反过来从关键词拖到查询行也一样，只改档位。
- * 这跟数据模型是同一套说法：查询档位单选，关键词独立标记。
+/**
+ * 新增页签。新建组也走它 —— 组是从行反推的，没有「空组」这回事，
+ * 建组必然同时建出组里第一个页签，所以两者合一个动作。
  */
+function addViewRow(groupName: string) {
+  if (props.loading) return
+  const name = String(groupName || '').trim() || DEFAULT_VIEW_GROUP
+  const newKey = createTempId()
+  // 组里还没有默认页签时，新加的这个直接当默认——一个组总要有一个默认选中的
+  const hasDefault = viewRows.value.some((row) => groupOfView(row) === name && row.isDefault)
+  viewRows.value = [
+    ...viewRows.value,
+    {
+      _rowKey: newKey,
+      _node: {},
+      code: nextViewCode(),
+      label: '',
+      group: name,
+      // 先接在本组末尾，随后整编把它坐实（免得跨过下一组的行）
+      order: lastOrderIn(name) + 5,
+      showCount: false,
+      isDefault: !hasDefault,
+      conditionSql: '',
+    },
+  ]
+  renumberViews()
+  // 建完直接落进「名称」的编辑态：敲完名称按 Tab 就是编码
+  void editRow(newKey, 'label')
+}
 
-function startFieldDrag(row: QueryFieldRow, zone: QueryFieldZone, event: DragEvent) {
-  if (props.loading) {
-    event.preventDefault()
-    return
+/** 新增分组：建一个组名不重名的组（连同它的第一个页签） */
+function addGroup() {
+  addViewRow(nextGroupName())
+}
+
+/**
+ * 复制页签：内容照抄、编码另取、排在源行之后。
+ * 同一组的几个页签条件往往只差一两个词，复制比从头填快得多。
+ */
+function duplicateView(row: ModuleQueryViewRow) {
+  if (props.loading) return
+  const list = [...viewRows.value]
+  const at = list.indexOf(row)
+  if (at < 0) return
+  const copy: ModuleQueryViewRow = {
+    ...row,
+    _rowKey: createTempId(),
+    _node: { ...row._node },
+    code: nextViewCode(),
+    label: `${String(row.label ?? '').trim() || '页签'} 副本`,
+    // 组内默认是唯一的，副本不抢
+    isDefault: false,
+    // 挤在源行后面（整编会把顺序坐实）
+    order: orderOfView(row) + 5,
   }
-  dragItem.value = { kind: 'field', bField: row.b_field, zone }
-  dropSpot.value = null
-  // 拖的时候浮层跟着挪很怪，先收起来
-  fieldPopoverKey.value = null
-  event.dataTransfer?.setData('text/plain', row.b_field)
-  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
-}
-
-function onFieldChipDragOver(zone: QueryFieldZone, row: QueryFieldRow, event: DragEvent) {
-  const drag = dragItem.value
-  if (drag?.kind !== 'field') return
-  if (drag.zone === zone && drag.bField === row.b_field) return
-  event.preventDefault()
-  // 被 chip 接住就别再冒到行上（行会当成「落到这一区末尾」）
-  event.stopPropagation()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
-  const box = (event.currentTarget as HTMLElement).getBoundingClientRect()
-  const list = zoneRows(zone)
-  const next = event.clientX > box.left + box.width / 2 ? list[list.indexOf(row) + 1] : row
-  dropSpot.value = { kind: 'field', zone, before: next ? next.b_field : null }
-}
-
-function onFieldRowDragOver(zone: QueryFieldZone, event: DragEvent) {
-  const drag = dragItem.value
-  if (drag?.kind !== 'field' && drag?.kind !== 'poolField') return
-  event.preventDefault()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
-  dropSpot.value = { kind: 'field', zone, before: null }
-}
-
-function onFieldDrop(event: DragEvent) {
-  event.preventDefault()
-  const drag = dragItem.value
-  const drop = dropSpot.value
-  endDrag()
-  if (!drag || drag.kind === 'view' || drag.kind === 'group') return
-  if (drop?.kind !== 'field') return
-  applyFieldDrop(drag.bField, drop)
-}
-
-function applyFieldDrop(bField: string, drop: { zone: QueryFieldZone; before: string | null }) {
-  // 「插到自己前面」＝原地不动（同 applyViewDrop 的判断）
-  if (drop.before === bField) return
-  const row = fieldRows.value.find((item) => item.b_field === bField)
-  if (!row) return
-  const list = zoneRows(drop.zone).filter((item) => item !== row)
-  const at =
-    drop.before == null ? list.length : list.findIndex((item) => item.b_field === drop.before)
-  list.splice(at < 0 ? list.length : at, 0, row)
-  if (drop.zone === 'keyword') {
-    row.keyword = true
-    list.forEach((item, index) => {
-      item.kwOrder = (index + 1) * 10
-    })
-  } else {
-    row.quick = true
-    list.forEach((item, index) => {
-      item.b_xh = (index + 1) * 10
-    })
-  }
-  syncDraft()
-}
-
-function isFieldDragging(row: QueryFieldRow, zone: QueryFieldZone): boolean {
-  const drag = dragItem.value
-  return drag?.kind === 'field' && drag.bField === row.b_field && drag.zone === zone
-}
-
-function isFieldDropBefore(zone: QueryFieldZone, row: QueryFieldRow): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'field' && drop.zone === zone && drop.before === row.b_field
-}
-
-/** 拖拽正落在这个区上：整框高亮（框内那条竖线仍然给精确位置） */
-function isFieldDropActive(zone: QueryFieldZone): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'field' && drop.zone === zone
-}
-
-function isFieldDropEnd(zone: QueryFieldZone): boolean {
-  const drop = dropSpot.value
-  return drop?.kind === 'field' && drop.zone === zone && drop.before == null
-}
-
-// 面板销毁时把自动滚动的 rAF 收掉
-onBeforeUnmount(stopAutoScroll)
-
-/** 浮层开关：只认自己那一个 key —— 别的 chip 冒出来的关闭事件不该把刚打开的浮层关掉 */
-function onViewPopover(row: ModuleQueryViewRow, value: boolean) {
-  const key = String(row._rowKey)
-  if (value) openViewKey.value = key
-  else if (openViewKey.value === key) openViewKey.value = null
-}
-
-/** 改一个页签字段 */
-function patchView(
-  row: ModuleQueryViewRow,
-  key: 'label' | 'code' | 'conditionSql',
-  value: unknown,
-) {
-  ;(row as Record<string, unknown>)[key] = value == null ? '' : String(value)
-  bumpViews()
-}
-
-/** 勾选类字段：默认页签组内唯一，勾上即顶掉同组其它页签 */
-function toggleViewFlag(row: ModuleQueryViewRow, key: 'showCount' | 'isDefault', value: unknown) {
-  const next = Boolean(value)
-  if (key === 'isDefault' && next) {
-    const name = groupOfView(row)
-    for (const item of viewRows.value) {
-      if (groupOfView(item) === name) item.isDefault = false
-    }
-  }
-  row[key] = next
-  bumpViews()
+  list.splice(at + 1, 0, copy)
+  viewRows.value = list
+  renumberViews()
+  void editRow(String(copy._rowKey), 'label')
 }
 
 function removeView(row: ModuleQueryViewRow) {
-  if (!draft.value) return
-  draft.value = { ...draft.value, views: viewRows.value.filter((item) => item !== row) }
-  openViewKey.value = null
+  viewRows.value = viewRows.value.filter((item) => item !== row)
 }
 
-/** 条件 SQL 的问题提示（面板不拦保存，只把问题摆在输入框下面） */
-function conditionErrorOf(row: ModuleQueryViewRow): string {
-  const sql = String(row.conditionSql ?? '').trim()
-  if (!sql) return ''
-  const valid = validateConditionSql(sql)
-  return valid === true ? '' : `条件 SQL ${valid}`
+/** 换组：行落到目标组末尾（列上是个下拉，点两下就换，比拖拽稳） */
+function moveToGroup(row: ModuleQueryViewRow, target: unknown) {
+  const name = String(target ?? '').trim()
+  if (!name || groupOfView(row) === name) return
+  row.group = name
+  renumberViews()
 }
 
-/* ---------- 页签组：新建 / 改名 / 删除 ----------
- * 新建与改名共用一份表单状态，但挂在两个不同的浮层锚点上：
- * 工具栏的「新增页签组」按钮，以及组名本身（点一下就地改）。
- * 用浮层而不是弹窗：这里只是一格输入，弹窗的遮罩、标题栏、按钮区比内容还重。 */
-const groupFormMode = ref<'create' | 'rename' | null>(null)
-const groupFormFrom = ref('')
-const groupFormText = ref('')
+/* ================= 分组条：改名 / 删除 / 排序 ================= */
 
-/** 组表单的输入框：打开浮层后要把光标落上去 */
-const groupFormInputRef = ref<{ focus?: (options?: { cursor?: 'all' }) => void } | null>(null)
-
-/** 两个浮层共用同一个输入框引用。卸载时也会回调 null，这里**故意忽略**：
- *  从「新建」浮层直接点到组名时，两个浮层在同一帧里前卸后挂，收 null 会把刚挂上的实例抹掉 */
-function setGroupFormInput(el: unknown) {
-  if (el == null) return
-  groupFormInputRef.value = el as { focus?: (options?: { cursor?: 'all' }) => void }
-}
-
-function onGroupFormInput(value: unknown) {
-  groupFormText.value = value == null ? '' : String(value)
-}
-
-/** 打开后聚焦：新建是空的、改名是全选，露脸就能直接打字 */
-async function focusGroupFormInput() {
-  await nextTick()
-  groupFormInputRef.value?.focus({ cursor: 'all' })
-}
-
-function openGroupCreate() {
-  groupFormMode.value = 'create'
-  groupFormFrom.value = ''
-  groupFormText.value = ''
-  void focusGroupFormInput()
-}
-
-function openGroupRename(group: QueryViewGroup) {
-  groupFormMode.value = 'rename'
-  groupFormFrom.value = group.name
-  groupFormText.value = group.name
-  void focusGroupFormInput()
-}
-
-function closeGroupForm() {
-  groupFormMode.value = null
-}
-
-function confirmGroupForm() {
-  const name = groupFormText.value.trim()
-  if (!name) {
-    G3Message.error('请输入页签组名称')
+/**
+ * 组名就地改：组是共享实体，改名要把组内所有行一起改。
+ *
+ * 入参是输入框本身而不是它的值：`:value` 是单向绑定，数据没变时 Vue 不会重渲染，
+ * 被拒绝的名字（空 / 重名）会**留在框里**，看着像改成功了 —— 所以每条拒绝路径
+ * 都要把 DOM 的值写回组名，让框里显示的永远是数据里真实的名字。
+ */
+function renameGroup(group: QueryViewGroup, input: HTMLInputElement) {
+  const name = input.value.trim()
+  if (!name || name === group.name) {
+    input.value = group.name
     return
   }
-  if (name !== groupFormFrom.value && viewGroupNames.value.includes(name)) {
+  if (viewGroupNames.value.includes(name)) {
     G3Message.error('该页签组已存在')
+    input.value = group.name
     return
   }
-  if (groupFormMode.value === 'create') {
-    void addViewRow(name)
-  } else {
-    const from = groupFormFrom.value
-    for (const row of viewRows.value) {
-      if (groupOfView(row) === from) row.group = name
-    }
-    bumpViews()
+  for (const row of viewRows.value) {
+    if (groupOfView(row) === group.name) row.group = name
   }
-  closeGroupForm()
 }
 
 /** 删组＝删组内全部页签（组是从行上的 group 反推的，没有独立的行可删） */
@@ -1047,55 +307,194 @@ function removeGroup(group: QueryViewGroup) {
     confirmText: '删除',
     confirmButtonProps: { danger: true },
     onConfirm: () => {
-      if (!draft.value) return
       const name = group.name
-      draft.value = {
-        ...draft.value,
-        views: viewRows.value.filter((row) => groupOfView(row) !== name),
-      }
-      // 被删掉的组里可能有正在编辑的页签，浮层一并收起
-      openViewKey.value = null
+      viewRows.value = viewRows.value.filter((row) => groupOfView(row) !== name)
       G3Message.success('页签组已删除')
     },
   })
 }
 
-/* ================= 顶部工具条 ================= */
-const configuredCount = computed(
-  () => fieldRows.value.filter((row) => row.quick || row.keyword).length,
-)
+/** 组内默认唯一：勾上就把同组其它页签摘掉（取消勾选则不自动补，允许整组都没有默认） */
+function setDefault(row: ModuleQueryViewRow, value: unknown) {
+  const next = Boolean(value)
+  if (next) {
+    const name = groupOfView(row)
+    for (const item of viewRows.value) {
+      if (item !== row && groupOfView(item) === name) item.isDefault = false
+    }
+  }
+  row.isDefault = next
+}
 
-const paneOptions = computed(() => [
-  { label: `查询字段 (${configuredCount.value})`, value: 'fields' },
-  { label: `工作队列页签 (${viewRows.value.length})`, value: 'views' },
+/* ================= 校验 ================= */
+
+/** 编码：非空且全局不重名（运行时用它标识页签，落库时空编码会被丢掉） */
+function validateCode(value: unknown, row: TableRow): string | boolean {
+  const code = String(value ?? '').trim()
+  if (!code) return '编码不能为空'
+  const duplicated = viewRows.value.some(
+    (item) => item !== row && String(item.code ?? '').trim() === code,
+  )
+  return duplicated ? '编码已存在' : true
+}
+
+/** 条件 SQL：只拦注入类写法（分号 / 注释），不校验字段与语法 */
+function validateSql(value: unknown): string | boolean {
+  const sql = String(value ?? '').trim()
+  if (!sql) return true
+  const result = validateConditionSql(sql)
+  return result === true ? true : `条件 SQL ${result}`
+}
+
+/* ================= 列定义 =================
+ * 列宽 / 列序拖拽没接 v-model:columns（不写回就会回弹），这里显式关掉。 */
+
+const columns = computed<G3TableColumn<TableRow>[]>(() => [
+  {
+    dataIndex: 'group',
+    title: '分组',
+    width: 110,
+    editor: {
+      type: 'select',
+      options: () => viewGroupNames.value.map((name) => ({ label: name, value: name })),
+      onChange: (value, row) => moveToGroup(row as ModuleQueryViewRow, value),
+    },
+    // 只有每组的第一行显示组名，其余留空 —— 看上去就是一张分组表
+    format: (value, row) =>
+      groupFirstKeys.value.has(String((row as ModuleQueryViewRow)._rowKey)) ? String(value ?? '') : '',
+  },
+  { dataIndex: 'label', title: '名称', width: 160, editor: { type: 'text', placeholder: '例如：未开航' } },
+  {
+    dataIndex: 'code',
+    title: '编码',
+    width: 150,
+    editor: { type: 'text', placeholder: 'view_1', validate: validateCode },
+  },
+  {
+    dataIndex: 'isDefault',
+    title: '默认',
+    width: 64,
+    align: 'center',
+    editor: {
+      type: 'checkbox',
+      onChange: (value, row) => setDefault(row as ModuleQueryViewRow, value),
+    },
+  },
+  { dataIndex: 'showCount', title: '数量', width: 64, align: 'center', editor: { type: 'checkbox' } },
+  {
+    dataIndex: 'conditionSql',
+    title: '条件 SQL',
+    // 有宽度的列不会随容器拉伸，条件是一行 SQL，给它最宽的一栏
+    width: 320,
+    resizable: false,
+    editor: { type: 'textarea', placeholder: "b_state = N'待处理'", validate: validateSql },
+  },
+  {
+    dataIndex: 'actions',
+    title: '操作',
+    width: 130,
+    resizable: false,
+    actions: [
+      { key: 'copy', label: '复制', onClick: (row) => duplicateView(row as ModuleQueryViewRow) },
+      {
+        key: 'remove',
+        type: 'delete',
+        label: '删除',
+        confirm: '删除这个页签？',
+        onClick: (row) => removeView(row as ModuleQueryViewRow),
+      },
+    ],
+  },
 ])
 
+/* ---------- 行拖拽：整表排序 ----------
+ * rows 是拖完之后的**全表**顺序，直接按它重编 order：
+ * 组的先后由「组内最小 order」决定，所以把某行拖到别组前面，那组就跟着挪上去。 */
+
+function onRowOrderChange(rows: TableRow[]) {
+  if (props.loading) return
+  rows.forEach((row, index) => {
+    ;(row as ModuleQueryViewRow).order = (index + 1) * 10
+  })
+}
+
+/* ---------- 分组条：拖 chip 调整组序 ----------
+ * 原生 HTML5 DnD，不引拖拽库：容器就是本组件渲染的，落点判定用不着库，
+ * 而且仓库里已有同一套范式（G3Tree + 左侧模块树），手感保持一致。
+ * 落点记成「插到谁前面」（null = 插到末尾），比记下标稳。
+ */
+
+type DropSpot = { before: string | null }
+
+const dragGroupName = ref<string | null>(null)
+const dropSpot = ref<DropSpot | null>(null)
+
+function startGroupDrag(group: QueryViewGroup, event: DragEvent) {
+  if (props.loading) {
+    event.preventDefault()
+    return
+  }
+  dragGroupName.value = group.name
+  dropSpot.value = null
+  // 不写 dataTransfer 的话 Firefox 不会触发 drop
+  event.dataTransfer?.setData('text/plain', group.name)
+  if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
+}
+
+function endDrag() {
+  dragGroupName.value = null
+  dropSpot.value = null
+}
+
+/** 拖到某个 chip 上：按鼠标落在它的左 / 右半边决定插到它前面还是后面 */
+function onGroupDragOver(group: QueryViewGroup, event: DragEvent) {
+  const name = dragGroupName.value
+  if (!name || name === group.name) return
+  event.preventDefault()
+  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
+  const box = (event.currentTarget as HTMLElement).getBoundingClientRect()
+  const after = event.clientX > box.left + box.width / 2
+  const names = viewGroupNames.value
+  const next = after ? names[names.indexOf(group.name) + 1] : group.name
+  dropSpot.value = { before: next ?? null }
+}
+
+function onGroupDrop(event: DragEvent) {
+  event.preventDefault()
+  const name = dragGroupName.value
+  const drop = dropSpot.value
+  endDrag()
+  // 「插到自己前面」＝原地不动
+  if (!name || !drop || drop.before === name) return
+  const order = [...viewGroupNames.value]
+  const from = order.indexOf(name)
+  if (from < 0) return
+  order.splice(from, 1)
+  const at = drop.before == null ? order.length : order.indexOf(drop.before)
+  order.splice(at < 0 ? order.length : at, 0, name)
+  renumberViews(order)
+}
+
+/** chip 落点画在哪一侧：只画「前面」，落点在末尾时画在最后一个 chip 的右边 */
+function groupDropEdge(group: QueryViewGroup): '' | 'before' | 'after' {
+  const drop = dropSpot.value
+  if (!drop) return ''
+  if (drop.before === group.name) return 'before'
+  const last = viewGroupNames.value[viewGroupNames.value.length - 1]
+  return drop.before == null && last === group.name ? 'after' : ''
+}
+
 /* ================= 预览弹窗 =================
- * 用真组件把查询入口摆出来：页签能点、搜索框能打字、下拉能展开、日期能选，
- * 快捷筛选的控件还带着各自配的默认查询值 —— 「配完长什么样」直接看着试，不靠想象。
+ * 用真组件把查询入口摆出来：页签能点。
+ * 关键词框与更多筛选恒在——它们由运行时按字段推导，不依赖这一屏配了什么。
  * 数据表不在这一屏：它归「列表配置」管，这里只回答查询入口长什么样。 */
 
 const previewOpen = ref(false)
 
-/** 预览里的临时值：默认查询值就是初始值，改了只影响这一次预览 */
-const previewKeywordText = ref('')
-const previewQuickValues = ref<Record<string, string>>({})
-/** 预设模式下当前点中哪个预设 */
-const previewPresetValues = ref<Record<string, string>>({})
 /** 每组当前选中的页签（组内单选），初始取该组的默认页签 */
 const previewActiveTab = ref<Record<string, string>>({})
 
 function openPreview() {
-  previewKeywordText.value = ''
-  const quick: Record<string, string> = {}
-  const presets: Record<string, string> = {}
-  for (const row of previewQuick.value) {
-    quick[row.b_field] = String(row.b_default_value ?? '')
-    // 配了默认选中的预设，就照运行时那样打开即选中
-    presets[row.b_field] = String(row.defaultPreset ?? '')
-  }
-  previewQuickValues.value = quick
-  previewPresetValues.value = presets
   const active: Record<string, string> = {}
   for (const group of viewGroups.value) {
     const target = group.items.find((item) => item.isDefault) ?? group.items[0]
@@ -1107,48 +506,6 @@ function openPreview() {
 
 defineExpose({ openPreview })
 
-const orderOf = (row: { b_xh?: number | null }) => Number(row.b_xh) || 0
-
-/** 摆在查询卡上的字段（快捷搜索） */
-const previewQuick = computed(() =>
-  fieldRows.value
-    .filter((row) => row.quick)
-    .toSorted((a, b) => orderOf(a) - orderOf(b)),
-)
-
-/** 参与关键词搜索的字段 */
-const previewKeyword = computed(() =>
-  fieldRows.value
-    .filter((row) => row.keyword)
-    .toSorted((a, b) => (a.kwOrder ?? 0) - (b.kwOrder ?? 0)),
-)
-
-/** 关键词输入框的占位文案：运行时按可搜索字段名生成 */
-const previewKeywordPlaceholder = computed(() => {
-  const names = previewKeyword.value.map((row) => row.b_name || row.b_field)
-  return names.length ? names.join(' / ') : '输入关键词'
-})
-
-const previewHasEntry = computed(
-  () =>
-    viewGroups.value.length > 0 ||
-    previewQuick.value.length > 0 ||
-    previewKeyword.value.length > 0,
-)
-
-/** 日期控件的精度由 format 决定：配的是日期还是日期时间 */
-function previewDateFormat(row: QueryFieldRow): string {
-  return row.b_component === 'datetime' ? 'yyyy-MM-dd HH:mm:ss' : 'yyyy-MM-dd'
-}
-
-/** 预览里的控件都是「看着能点、点了不查」：值只落在这一份临时状态上 */
-function onPreviewQuickInput(field: string, value: unknown) {
-  previewQuickValues.value = {
-    ...previewQuickValues.value,
-    [field]: value == null ? '' : String(value),
-  }
-}
-
 /** 页签显示名：优先名称，退回编码 */
 function viewLabelOf(row: ModuleQueryViewRow): string {
   return String(row.label ?? '').trim() || String(row.code ?? '').trim() || '未命名页签'
@@ -1157,400 +514,79 @@ function viewLabelOf(row: ModuleQueryViewRow): string {
 
 <template>
   <div class="mm-query">
-    <!-- 工具条：左切换屏，右放当前屏的动作 -->
+    <!-- 工具条：只剩一个动作 -->
     <div class="mm-query__bar">
-      <G3Segmented v-model="activePane" :options="paneOptions" />
-      <div class="mm-query__bar-right">
-        <G3Popover
-          v-if="activePane === 'views'"
-          :open="groupFormMode === 'create'"
-          trigger="click"
-          placement="bottom-end"
-          :offset="6"
-          content-class="mm-group-pop"
-          @update:open="(value) => (value ? openGroupCreate() : closeGroupForm())"
-        >
-          <template #trigger>
-            <G3Button type="outline" :disabled="loading">
-              <template #icon><Plus :size="14" /></template>
-              新增页签组
-            </G3Button>
-          </template>
-          <template #content>
-            <div class="mm-group-pop__form">
-              <G3Input
-                :ref="setGroupFormInput"
-                :model-value="groupFormText"
-                placeholder="组名称"
-                @update:model-value="onGroupFormInput"
-                @keydown.enter="confirmGroupForm"
-              />
-              <G3Button type="primary" @click="confirmGroupForm">确定</G3Button>
-            </div>
-          </template>
-        </G3Popover>
-      </div>
+      <G3Button type="outline" :disabled="loading" @click="addGroup">
+        <template #icon><Plus :size="14" /></template>
+        新增页签组
+      </G3Button>
     </div>
 
-    <!-- 一、查询字段：左池右区——把字段拖进哪一行就是哪个区 -->
-    <div v-if="activePane === 'fields'" class="mm-query__fields">
-      <!-- 左：全部字段。点一下＝加进「更多筛选」，拖＝落到指定区；从右边拖回来＝移出 -->
-      <div
-        class="mm-field-pool"
-        :class="{ 'is-drop-target': dragItem?.kind === 'field' }"
-        @dragover="onPoolDragOver"
-        @drop="onPoolDrop"
-      >
-        <G3Input
-          :model-value="fieldPoolSearch"
-          placeholder="搜索字段"
-          clearable
-          @update:model-value="onFieldPoolSearch"
-        />
-        <ul class="mm-field-pool__list">
-          <li v-for="row in fieldPoolRows" :key="row.b_field">
-            <button
-              type="button"
-              class="mm-field-pool__item"
-              :class="{ 'is-dragging': isPoolFieldDragging(row) }"
-              :title="row.b_field"
-              draggable="true"
-              @dragstart="startPoolFieldDrag(row, $event)"
-              @dragend="endDrag"
-              @click="addPoolFieldByClick(row)"
-            >
-              <span class="mm-field-pool__name">{{ fieldLabelOf(row) }}</span>
-              <em v-if="row.missing" class="mm-view-chip__flag is-missing">已删除</em>
-              <em v-else-if="Number(row.b_canuse) !== 1" class="mm-view-chip__flag">停用</em>
-              <em v-for="tag in fieldZoneTagsOf(row)" :key="tag" class="mm-field-pool__tag">
-                {{ tag }}
-              </em>
-            </button>
-          </li>
-        </ul>
-        <p v-if="!fieldPoolRows.length" class="mm-field-pool__empty">没有匹配的字段</p>
-      </div>
-
-      <!-- 右：三个区。chip 可拖（区内排序 / 快捷与更多之间换档），点 chip 改默认查询值 -->
-      <div ref="dragScrollRef" class="mm-query__zones" @dragover.capture="onDragOverCapture">
-        <div
-          v-for="zone in FIELD_ZONES"
-          :key="zone.key"
-          class="mm-zone"
-          :class="{ 'mm-zone--search': zone.key === 'keyword' }"
-          @dragover="onFieldRowDragOver(zone.key, $event)"
-          @drop="onFieldDrop"
-        >
-          <span class="mm-zone__label">{{ zone.label }}</span>
-
-          <div
-            class="mm-chip-box"
-            :class="{
-              'is-drop-end': isFieldDropEnd(zone.key),
-              'is-drop-active': isFieldDropActive(zone.key),
-            }"
-          >
-            <span
-              v-for="row in zoneRows(zone.key)"
-              :key="row.b_field"
-              class="mm-field-chip"
-              :class="{ 'is-dragging': isFieldDragging(row, zone.key) }"
-            >
-              <!-- 关键词区的条目没有可配的东西（默认值只属于查询字段），浮层直接禁用 -->
-              <G3Popover
-                :open="fieldPopoverKey === row.b_field"
-                :disabled="zone.key === 'keyword'"
-                trigger="click"
-                placement="bottom-start"
-                :offset="6"
-                content-class="mm-field-pop"
-                @update:open="(value) => onFieldPopover(row, value)"
-              >
-                <template #trigger>
-                  <span
-                    class="mm-view-chip"
-                    :class="{ 'is-drop-before': isFieldDropBefore(zone.key, row) }"
-                    draggable="true"
-                    @dragstart="startFieldDrag(row, zone.key, $event)"
-                    @dragend="endDrag"
-                    @dragover="onFieldChipDragOver(zone.key, row, $event)"
-                  >
-                    <span class="mm-view-chip__label">{{ fieldLabelOf(row) }}</span>
-                    <em
-                      v-if="zone.key === 'quick' && row.mode === 'preset' && row.defaultPreset"
-                      class="mm-view-chip__meta"
-                    >
-                      {{ presetLabelOf(row.defaultPreset) }}
-                    </em>
-                    <em v-else-if="row.b_default_value" class="mm-view-chip__meta">
-                      = {{ row.b_default_value }}
-                    </em>
-                    <em v-if="row.missing" class="mm-view-chip__flag is-missing">已删除</em>
-                    <em v-else-if="Number(row.b_canuse) !== 1" class="mm-view-chip__flag">停用</em>
-                  </span>
-                </template>
-                <template #content>
-                  <div class="mm-field-pop__form">
-                    <!-- 只有卡上的条目要选呈现方式；关键词那一区没东西可配（浮层也是禁用的） -->
-                    <div v-if="zone.key === 'quick'" class="mm-field-pop__row">
-                      <span class="mm-field-pop__label">呈现</span>
-                      <G3Segmented
-                        :model-value="row.mode"
-                        :options="QUERY_QUICK_MODES"
-                        @update:model-value="(value) => patchFieldMode(row, value)"
-                      />
-                    </div>
-
-                    <div v-if="zone.key === 'quick' && row.mode !== 'preset'" class="mm-field-pop__row">
-                      <span class="mm-field-pop__label">默认值</span>
-                      <G3Input
-                        :model-value="row.b_default_value ?? ''"
-                        @update:model-value="(value) => patchFieldDefault(row, value)"
-                      />
-                    </div>
-
-                    <template v-if="zone.key === 'quick' && row.mode === 'preset'">
-                      <div class="mm-field-pop__row mm-field-pop__row--stack">
-                        <span class="mm-field-pop__label">给哪些预设</span>
-                        <div class="mm-preset-pick">
-                          <G3Checkbox
-                            v-for="preset in QUERY_DATE_PRESETS"
-                            :key="preset.value"
-                            :model-value="row.presets.includes(preset.value)"
-                            @update:model-value="
-                              (checked) => togglePreset(row, preset.value, Boolean(checked))
-                            "
-                          >
-                            {{ preset.label }}
-                          </G3Checkbox>
-                        </div>
-                      </div>
-                      <div
-                        v-if="presetOptionsOf(row).length"
-                        class="mm-field-pop__row mm-field-pop__row--stack"
-                      >
-                        <span class="mm-field-pop__label">默认选中</span>
-                        <div class="mm-preset-pick">
-                          <button
-                            v-for="preset in presetOptionsOf(row)"
-                            :key="preset.value"
-                            type="button"
-                            class="mm-preset-chip"
-                            :class="{ 'is-active': row.defaultPreset === preset.value }"
-                            @click="patchDefaultPreset(row, preset.value)"
-                          >
-                            {{ preset.label }}
-                          </button>
-                        </div>
-                      </div>
-                    </template>
-                  </div>
-                </template>
-              </G3Popover>
-              <button
-                type="button"
-                class="mm-field-chip__remove"
-                title="移出这一区"
-                @click="removeFieldFromZone(row, zone.key)"
-              >
-                <X :size="12" />
-              </button>
-            </span>
-          </div>
-        </div>
-      </div>
-    </div>
-
-    <!-- 二、工作队列页签：一行一组，页签是 chip，点 chip 在浮层里改 -->
-    <div
-      v-else
-      ref="dragScrollRef"
-      class="mm-query__views"
-      @dragover.capture="onDragOverCapture"
-    >
-      <p v-if="!viewGroups.length" class="mm-view-empty">还没有页签组</p>
-      <div
+    <!-- 分组：拖 chip 调组序，名字就地改，× 删整组（连同组内页签） -->
+    <div v-if="viewGroups.length" class="mm-groups">
+      <span
         v-for="group in viewGroups"
         :key="group.key"
-        class="mm-view-row mm-view-row--boxed"
+        class="mm-groups__item"
         :class="{
-          'is-dragging': isGroupDragging(group),
+          'is-dragging': dragGroupName === group.name,
           'is-drop-before': groupDropEdge(group) === 'before',
           'is-drop-after': groupDropEdge(group) === 'after',
         }"
-        @dragover="onRowDragOver(group, $event)"
-        @drop="onViewDrop"
+        @dragover="onGroupDragOver(group, $event)"
+        @drop="onGroupDrop"
       >
-        <!-- 标签列 = 把手 + 组名，定宽：把手拖动排序，组名点击改名，两者不抢同一个手势。
-             合成一列是为了让每行的 chip 都从同一个 x 起，也让它们跟第一行 chip 齐平。 -->
-        <div class="mm-view-row__label">
-          <span
-            class="mm-view-row__grip"
-            draggable="true"
-            title="拖动排序"
-            @dragstart="startGroupDrag(group, $event)"
-            @dragend="endDrag"
-          >
-            <GripVertical :size="14" />
-          </span>
-          <G3Popover
-            :open="groupFormMode === 'rename' && groupFormFrom === group.name"
-            trigger="click"
-            placement="bottom-start"
-            :offset="6"
-            unwrapped
-            content-class="mm-group-pop"
-            @update:open="(value) => (value ? openGroupRename(group) : closeGroupForm())"
-          >
-            <template #trigger>
-              <span class="mm-view-row__group" :title="group.name">{{ group.name }}</span>
-            </template>
-            <template #content>
-              <div class="mm-group-pop__form">
-                <G3Input
-                  :ref="setGroupFormInput"
-                  :model-value="groupFormText"
-                  placeholder="组名称"
-                  @update:model-value="onGroupFormInput"
-                  @keydown.enter="confirmGroupForm"
-                />
-                <G3Button type="primary" @click="confirmGroupForm">确定</G3Button>
-              </div>
-            </template>
-          </G3Popover>
-        </div>
-
-        <div
-          class="mm-chip-box"
-          :class="{ 'is-drop-end': isDropEnd(group), 'is-drop-active': isViewDropActive(group) }"
+        <span
+          class="mm-groups__grip"
+          draggable="true"
+          title="拖动调整分组顺序"
+          @dragstart="startGroupDrag(group, $event)"
+          @dragend="endDrag"
         >
-          <G3Popover
-            v-for="item in group.items"
-            :key="String(item._rowKey)"
-            :open="openViewKey === String(item._rowKey)"
-            trigger="click"
-            placement="bottom-start"
-            :offset="6"
-            content-class="mm-view-pop"
-            @update:open="(value) => onViewPopover(item, value)"
-          >
-            <template #trigger>
-              <button
-                type="button"
-                class="mm-view-chip"
-                :class="{
-                  'is-default': item.isDefault,
-                  'is-open': openViewKey === String(item._rowKey),
-                  'is-dragging': isViewDragging(item),
-                  'is-drop-before': isDropBefore(group, item),
-                }"
-                draggable="true"
-                @dragstart="startViewDrag(item, $event)"
-                @dragend="endDrag"
-                @dragover="onChipDragOver(group, item, $event)"
-              >
-                <Star v-if="item.isDefault" :size="12" class="mm-view-chip__star" />
-                <span class="mm-view-chip__label">{{ viewLabelOf(item) }}</span>
-                <em
-                  v-if="item.showCount"
-                  class="mm-view-chip__count"
-                  title="运行时在这里显示该页签的记录数"
-                >
-                  (0)
-                </em>
-              </button>
-            </template>
-
-            <!-- 页签设置：不占列表的位，浮在 chip 旁边 -->
-            <template #content>
-              <div class="mm-view-pop__form">
-                <div class="mm-view-pop__row mm-view-pop__row--field">
-                  <span class="mm-view-pop__label">名称</span>
-                  <G3Input
-                    :model-value="item.label"
-                    placeholder="例如：未开航"
-                    @update:model-value="(value) => patchView(item, 'label', value)"
-                  />
-                </div>
-                <div class="mm-view-pop__row mm-view-pop__row--field">
-                  <span class="mm-view-pop__label">编码</span>
-                  <G3Input
-                    :model-value="item.code"
-                    placeholder="例如：not_sailed"
-                    @update:model-value="(value) => patchView(item, 'code', value)"
-                  />
-                </div>
-                <div class="mm-view-pop__row mm-view-pop__row--flags">
-                  <G3Checkbox
-                    :model-value="Boolean(item.showCount)"
-                    @update:model-value="(value) => toggleViewFlag(item, 'showCount', value)"
-                  >
-                    显示数量
-                  </G3Checkbox>
-                  <G3Checkbox
-                    :model-value="Boolean(item.isDefault)"
-                    @update:model-value="(value) => toggleViewFlag(item, 'isDefault', value)"
-                  >
-                    组内默认
-                  </G3Checkbox>
-                </div>
-                <div class="mm-view-pop__row mm-view-pop__row--stack">
-                  <span class="mm-view-pop__label">条件 SQL</span>
-                  <textarea
-                    :value="item.conditionSql"
-                    class="mm-view-pop__sql"
-                    :class="{ 'is-error': Boolean(conditionErrorOf(item)) }"
-                    rows="3"
-                    spellcheck="false"
-                    placeholder="b_state = N'待处理'"
-                    @input="
-                      (event) =>
-                        patchView(item, 'conditionSql', (event.target as HTMLTextAreaElement).value)
-                    "
-                  />
-                  <p v-if="conditionErrorOf(item)" class="mm-view-pop__error">
-                    {{ conditionErrorOf(item) }}
-                  </p>
-                </div>
-                <div class="mm-view-pop__foot">
-                  <G3Button type="danger-outline" @click="removeView(item)">
-                    <template #icon><Trash2 :size="14" /></template>
-                    删除
-                  </G3Button>
-                </div>
-              </div>
-            </template>
-          </G3Popover>
-        </div>
-
-        <div class="mm-view-row__actions">
-          <G3Button
-            type="icon"
-            size="small"
-            class="mm-view-row__remove"
-            title="删除分组（连同组内页签）"
-            aria-label="删除分组"
-            @click="removeGroup(group)"
-          >
-            <Trash2 :size="14" />
-          </G3Button>
-          <G3Button
-            type="icon"
-            size="small"
-            :disabled="loading"
-            title="在这一组新增页签"
-            aria-label="新增页签"
-            @click="addViewRow(group.name)"
-          >
-            <Plus :size="14" />
-          </G3Button>
-        </div>
-      </div>
+          <GripVertical :size="12" />
+        </span>
+        <input
+          class="mm-groups__name"
+          :value="group.name"
+          :title="group.name"
+          spellcheck="false"
+          @change="renameGroup(group, $event.target as HTMLInputElement)"
+        />
+        <span class="mm-groups__count">{{ group.items.length }}</span>
+        <button
+          type="button"
+          class="mm-groups__remove"
+          title="删除分组（连同组内页签）"
+          aria-label="删除分组"
+          @click="removeGroup(group)"
+        >
+          <X :size="12" />
+        </button>
+      </span>
     </div>
 
-    <!-- 预览：用真组件把查询入口摆出来，能点能输 -->
+    <!-- 一个表格装下所有页签：方向键 / Tab 能一路走完，不会被「组的边界」截断 -->
+    <div class="mm-query__table">
+      <G3Table
+        ref="tableRef"
+        :columns="columns"
+        :data-source="viewRows"
+        row-key="_rowKey"
+        :row-height="30"
+        :seq="false"
+        :row-draggable="true"
+        :col-resizable="false"
+        :column-draggable="false"
+        :editable="!loading"
+        :active-row-key="activeKey"
+        @row-click="(_, row) => (activeKey = String(row._rowKey))"
+        @row-order-change="onRowOrderChange"
+      />
+    </div>
+
+    <!-- 预览：用真组件把查询入口摆出来，能点能切 -->
     <G3Modal v-model:open="previewOpen" title="查询入口预览" width="960px" :footer="false">
-      <div v-if="previewHasEntry" class="mm-preview">
+      <div class="mm-preview">
         <!-- 页签：组内单选，点一下就切 -->
         <div v-for="group in viewGroups" :key="group.key" class="mm-preview__tabs">
           <button
@@ -1565,76 +601,25 @@ function viewLabelOf(row: ModuleQueryViewRow): string {
             <em v-if="item.showCount">(0)</em>
           </button>
         </div>
+        <p v-if="!viewGroups.length" class="mm-preview__empty">还没有页签组</p>
 
-        <!-- 关键词 + 快捷搜索 + 更多筛选：与列表页查询卡同一行排布 -->
-        <div v-if="previewKeyword.length || previewQuick.length" class="mm-preview__row">
-          <G3Input
-            v-if="previewKeyword.length"
-            v-model="previewKeywordText"
-            class="mm-preview__keyword"
-            :placeholder="previewKeywordPlaceholder"
-            clearable
-          />
-          <label v-for="row in previewQuick" :key="row.b_field" class="mm-preview__field">
-            <span class="mm-preview__field-label">{{ fieldLabelOf(row) }}</span>
-            <!-- 预设模式：一排相对时间，点一下就筛 -->
-            <span v-if="row.mode === 'preset'" class="mm-preview__presets">
-              <button
-                v-for="preset in presetOptionsOf(row)"
-                :key="preset.value"
-                type="button"
-                class="mm-preview__preset"
-                :class="{ 'is-active': previewPresetValues[row.b_field] === preset.value }"
-                @click="previewPresetValues[row.b_field] = preset.value"
-              >
-                {{ preset.label }}
-              </button>
-            </span>
-            <G3DatePicker
-              v-if="row.b_component === 'date' || row.b_component === 'datetime'"
-              :model-value="previewQuickValues[row.b_field] || null"
-              :format="previewDateFormat(row)"
-              :placeholder="row.b_component === 'datetime' ? '选择日期时间' : '选择日期'"
-              class="mm-preview__control"
-              @update:model-value="(value) => onPreviewQuickInput(row.b_field, value)"
-            />
-            <G3Select
-              v-else-if="row.b_component === 'select' || row.b_component === 'checkbox'"
-              :model-value="previewQuickValues[row.b_field] || ''"
-              :options="[]"
-              class="mm-preview__control"
-              placeholder="请选择"
-              @update:model-value="(value) => onPreviewQuickInput(row.b_field, value)"
-            />
-            <G3Input
-              v-else
-              :model-value="previewQuickValues[row.b_field] ?? ''"
-              class="mm-preview__control"
-              :placeholder="row.b_component === 'number' ? '输入数字' : '输入内容'"
-              @update:model-value="(value) => onPreviewQuickInput(row.b_field, value)"
-            />
-          </label>
-          <!-- 更多筛选不用配，运行时按模块字段自动铺，所以这里恒在 -->
-          <G3Button type="outline">更多筛选</G3Button>
+        <!-- 关键词 + 更多筛选恒在：查询能力由运行时按字段推导，与这一屏的配置无关 -->
+        <div class="mm-preview__row">
+          <span class="mm-preview__keyword">输入关键词</span>
+          <span class="mm-preview__more">更多筛选</span>
         </div>
       </div>
-      <p v-else class="mm-preview__empty">当前配置没有产生任何查询入口</p>
     </G3Modal>
   </div>
 </template>
 
 <style lang="scss" scoped>
-/* 两屏共用一屏高度：工具条固定，表格撑满剩余空间（不再按行数算高度，
- * 一屏只有一张表，让它跟着外层配置卡走）。 */
+/* 一屏高度：工具条 + 分组条固定，表格撑满剩余空间（让它跟着外层配置卡走）。 */
 .mm-query {
-  /* chip 的高度：chip、标签列、落点框都以它为基准，改一处全跟着走 */
-  --mm-chip-height: 26px;
-  /* chip 框的上下内边距：标签与框内首行靠它对齐 */
-  --mm-box-pad-y: 8px;
   display: flex;
   flex: 1;
   flex-direction: column;
-  gap: 12px;
+  gap: 10px;
   min-height: 0;
 }
 
@@ -1642,574 +627,112 @@ function viewLabelOf(row: ModuleQueryViewRow): string {
   display: flex;
   flex: none;
   align-items: center;
-  gap: 16px;
+  justify-content: flex-end;
 }
 
-.mm-query__bar-right {
+/* ================= 分组条 ================= */
+
+/* 一行 chip：组名就地改、可拖排序、× 删整组。
+ * 组在这里只是「页签的一个属性」，不再占一屏高度。 */
+.mm-groups {
   display: flex;
+  flex: none;
+  flex-wrap: wrap;
   align-items: center;
-  gap: 12px;
-  margin-left: auto;
+  gap: 8px;
 }
 
-/* 字段屏三个区：与页签屏同一套 chip 行样式（.mm-view-row / .mm-view-chip 复用） */
-.mm-query__zones {
-  display: flex;
-  flex: 1;
-  flex-direction: column;
-  min-height: 0;
-  overflow: auto;
-}
-
-/* 字段 chip 外包一层：装 hover 才出现的「移出这一区」按钮。
-   按钮不能塞进 chip 里面——chip 本身是浮层的触发器，嵌套可点元素是无效结构 */
-.mm-field-chip {
-  position: relative;
+.mm-groups__item {
   display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 26px;
+  padding: 0 4px 0 2px;
+  border: 1px solid var(--g3-color-border, #e5e6eb);
+  border-radius: 999px;
 }
 
-.mm-field-chip.is-dragging {
-  opacity: 0.4;
+/* 落点线画在 chip 的两侧（chip 是横排的，所以比较横坐标） */
+.mm-groups__item.is-drop-before {
+  box-shadow: inset 2px 0 0 var(--g3-color-primary, #165dff);
 }
 
-.mm-field-chip__remove {
-  position: absolute;
-  top: -6px;
-  right: -6px;
-  display: none;
+.mm-groups__item.is-drop-after {
+  box-shadow: inset -2px 0 0 var(--g3-color-primary, #165dff);
+}
+
+.mm-groups__item.is-dragging {
+  opacity: 0.5;
+}
+
+.mm-groups__grip {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  color: var(--g3-color-text-tertiary, #86909c);
+  cursor: grab;
+}
+
+.mm-groups__grip:active {
+  cursor: grabbing;
+}
+
+/* 组名：平时看着就是 chip 上的一段文字，点进去才是输入框 */
+.mm-groups__name {
+  box-sizing: border-box;
+  width: 88px;
+  padding: 1px 2px;
+  border: 1px solid transparent;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--g3-color-text, #1f2329);
+  font-family: inherit;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.mm-groups__name:hover {
+  border-color: var(--g3-color-border, #e5e6eb);
+}
+
+.mm-groups__name:focus {
+  border-color: var(--g3-color-primary, #165dff);
+  background: var(--g3-color-bg-container, #fff);
+  outline: none;
+}
+
+.mm-groups__count {
+  color: var(--g3-color-text-tertiary, #86909c);
+  font-size: 12px;
+}
+
+.mm-groups__remove {
+  display: inline-flex;
   align-items: center;
   justify-content: center;
   width: 16px;
   height: 16px;
   padding: 0;
-  border: 1px solid var(--g3-color-border, #e5e6eb);
-  border-radius: 50%;
-  background: var(--g3-color-bg-container, #fff);
-  color: var(--g3-color-text-tertiary, #86909c);
-  cursor: pointer;
-}
-
-.mm-field-chip:hover .mm-field-chip__remove {
-  display: inline-flex;
-}
-
-.mm-field-chip__remove:hover {
-  border-color: var(--g3-color-danger, #f53f3f);
-  color: var(--g3-color-danger, #f53f3f);
-}
-
-/* chip 里附带的信息：默认查询值、字段已删除 / 停用 */
-.mm-view-chip__meta {
-  color: var(--g3-color-text-tertiary, #86909c);
-  font-style: normal;
-  font-weight: 400;
-}
-
-.mm-view-chip__flag {
-  padding: 0 4px;
-  border-radius: 3px;
-  background: var(--g3-color-warning-bg, #fff7e6);
-  color: var(--g3-color-warning-text, #d46b08);
-  font-size: 11px;
-  font-style: normal;
-  font-weight: 400;
-}
-
-.mm-view-chip__flag.is-missing {
-  background: color-mix(in srgb, var(--g3-color-danger, #f53f3f) 10%, transparent);
-  color: var(--g3-color-danger, #f53f3f);
-}
-
-/* ================= 字段设置浮层（默认查询值） ================= */
-
-.mm-field-pop {
-  width: 320px;
-}
-
-/* 卡上那条怎么摆：呈现方式 / 默认值 / 预设，纵排 */
-.mm-field-pop__form {
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-  padding: 8px;
-}
-
-.mm-field-pop__row {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-/* 标签在上、内容铺满整行 */
-.mm-field-pop__row--stack {
-  flex-direction: column;
-  align-items: stretch;
-  gap: 6px;
-}
-
-.mm-field-pop__label {
-  flex: none;
-  width: 64px;
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-size: 12px;
-}
-
-.mm-field-pop__row--stack > .mm-field-pop__label {
-  width: auto;
-}
-
-/* 横排那一行里，控件吃掉标签以外的宽度（呈现方式的分段、默认值的输入框） */
-.mm-field-pop__row > :not(.mm-field-pop__label) {
-  flex: 1;
-  min-width: 0;
-}
-
-/* 预设：勾选一排是复选框，选默认是一排小 chip（点一下选中，再点取消） */
-.mm-preset-pick {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 6px 12px;
-}
-
-.mm-preset-chip {
-  padding: 3px 10px;
-  border: 1px solid var(--g3-color-border, #e5e6eb);
-  border-radius: 999px;
-  background: transparent;
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-family: inherit;
-  font-size: 12px;
-  cursor: pointer;
-}
-
-.mm-preset-chip:hover {
-  border-color: var(--g3-color-primary, #165dff);
-  color: var(--g3-color-primary, #165dff);
-}
-
-.mm-preset-chip.is-active {
-  border-color: var(--g3-color-primary, #165dff);
-  background: var(--g3-color-primary-soft, #e8f3ff);
-  color: var(--g3-color-primary, #165dff);
-  font-weight: 600;
-}
-
-/* ---------- 字段屏的区：标签在上、框在下 ----------
- * 不用「标签列 + 框」的横向排法：那 112px 是给页签屏的「把手 + 组名」定的宽，
- * 字段屏只有四个字，右边空一截；标签让到上面，框就能吃满整行。 */
-.mm-zone {
-  display: flex;
-  flex: none;
-  flex-direction: column;
-  gap: 6px;
-}
-
-.mm-zone + .mm-zone {
-  margin-top: 14px;
-}
-
-/* 关键词不是「筛选档位」而是另一个东西（列表页顶部那个搜索框），
-   和上面两行拉开一档距离分成两组：上面是筛选项，下面是全局搜索 */
-.mm-zone + .mm-zone--search {
-  margin-top: 24px;
-}
-
-.mm-zone__label {
-  color: var(--g3-color-text, #1f2329);
-  font-size: 13px;
-  font-weight: 600;
-}
-
-/* ---------- chip 区：一行一组，组里那堆 chip 装在一个虚线框里 ----------
- * 用框而不是分割线：框让「空着的区」也看得见，边界也一眼分明。 */
-.mm-view-row--boxed {
-  align-items: flex-start;
-  padding: 0;
-}
-
-.mm-view-row--boxed + .mm-view-row--boxed {
-  margin-top: 12px;
-}
-
-/* 标签贴框的**第一行**，不是框的正中间：chip 换行时居中会飘到两行之间 */
-.mm-view-row--boxed .mm-view-row__label {
-  padding-top: var(--mm-box-pad-y);
-}
-
-.mm-chip-box {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 8px;
-  min-height: calc(var(--mm-chip-height) + var(--mm-box-pad-y) * 2);
-  padding: var(--mm-box-pad-y) 10px;
-  border: 1px dashed var(--g3-color-border, #e5e6eb);
-  border-radius: var(--g3-radius-base, 0.5rem);
-}
-
-/* 页签屏是横向行：框吃掉剩余宽度；字段屏每区上下排列，不需要它去撑 */
-.mm-view-row .mm-chip-box {
-  flex: 1;
-  min-width: 0;
-}
-
-/* 拖拽正落在这个框上：边框提亮，框里那条竖线继续给精确落点 */
-.mm-chip-box.is-drop-active {
-  border-color: var(--g3-color-primary, #165dff);
-}
-
-/* ================= 字段池（左池右区） ================= */
-
-.mm-query__fields {
-  display: flex;
-  flex: 1;
-  gap: 16px;
-  min-height: 0;
-}
-
-.mm-field-pool {
-  display: flex;
-  flex: none;
-  flex-direction: column;
-  gap: 8px;
-  width: 200px;
-  min-height: 0;
-  padding-right: 16px;
-  border-right: 1px solid var(--g3-color-border, #e5e6eb);
-}
-
-/* 拖着区里的 chip 经过池子：整块都是「拿出去」的落点 */
-.mm-field-pool.is-drop-target {
-  border-right-color: var(--g3-color-primary, #165dff);
-}
-
-.mm-field-pool__list {
-  flex: 1;
-  min-height: 0;
-  margin: 0;
-  padding: 0;
-  overflow: auto;
-  list-style: none;
-}
-
-.mm-field-pool__item {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  width: 100%;
-  padding: 4px 8px;
   border: 0;
-  border-radius: 4px;
+  border-radius: 50%;
   background: transparent;
-  color: var(--g3-color-text, #1f2329);
-  font-family: inherit;
-  font-size: 13px;
-  text-align: left;
-  cursor: grab;
-}
-
-.mm-field-pool__item:hover {
-  background: var(--g3-color-fill-hover, #f2f3f5);
-}
-
-.mm-field-pool__item.is-dragging {
-  opacity: 0.4;
-}
-
-.mm-field-pool__name {
-  flex: 1;
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-/* 这条字段当前在哪个区：池子窄，标签只用两个字 */
-.mm-field-pool__tag {
-  flex: none;
-  padding: 0 4px;
-  border-radius: 3px;
-  background: var(--g3-color-primary-soft, #e8f3ff);
-  color: var(--g3-color-primary, #165dff);
-  font-size: 11px;
-  font-style: normal;
-}
-
-.mm-field-pool__empty {
-  margin: 0;
   color: var(--g3-color-text-tertiary, #86909c);
-  font-size: 12px;
-}
-
-/* ================= 工作队列页签（紧凑行） ================= */
-
-/* 一组一行：组名定宽、chip 占中间、操作靠右；行与行之间只用一条细线断开，
- * 不再给每组画卡片——组多的时候卡片边框和间距自己就占掉半屏。 */
-.mm-query__views {
-  display: flex;
-  flex: 1;
-  flex-direction: column;
-  min-height: 0;
-  overflow: auto;
-}
-
-.mm-view-row {
-  /* chip 换行时标签仍贴第一行，不会飘到两行中间去（基准值见 .mm-query） */
-  display: flex;
-  flex: none;
-  align-items: flex-start;
-  gap: 12px;
-  padding: 10px 0;
-}
-
-.mm-view-empty {
-  margin: 0;
-  padding: 12px 0;
-  color: var(--g3-color-text-tertiary, #86909c);
-  font-size: 12px;
-}
-
-/* 标签列：把手 + 组名，定宽 —— 每行的 chip 都从同一个 x 起，不随组名长短漂 */
-.mm-view-row__label {
-  display: flex;
-  flex: none;
-  align-items: center;
-  gap: 6px;
-  width: 112px;
-  min-width: 0;
-  min-height: var(--mm-chip-height);
-}
-
-.mm-view-row__group {
-  flex: 1;
-  min-width: 0;
-  overflow: hidden;
-  color: var(--g3-color-text, #1f2329);
-  font-size: 13px;
-  font-weight: 600;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  cursor: text;
-}
-
-.mm-view-row__group:hover {
-  color: var(--g3-color-primary, #165dff);
-}
-
-.mm-view-row__remove:hover:not(:disabled) {
-  border-color: var(--g3-color-danger, #f53f3f);
-  color: var(--g3-color-danger, #f53f3f);
-}
-
-.mm-view-row__actions {
-  display: flex;
-  flex: none;
-  align-items: center;
-  gap: 4px;
-  /* 与标签列同款：贴第一行，不跟着换行后的 chip 块居中 */
-  min-height: var(--mm-chip-height);
-}
-
-/* 组排序把手：常驻弱色，hover 才提亮 */
-.mm-view-row__grip {
-  display: inline-flex;
-  flex: none;
-  align-items: center;
-  justify-content: center;
-  height: 14px;
-  color: var(--g3-color-text-tertiary, #86909c);
-  cursor: grab;
-}
-
-.mm-view-row__grip:hover {
-  color: var(--g3-color-text-secondary, #4e5969);
-}
-
-.mm-view-row__grip:active {
-  cursor: grabbing;
-}
-
-/* 拖拽中的行 / 落点：线用 box-shadow 画，不占布局，不会让行高跳一下 */
-.mm-view-row.is-dragging {
-  opacity: 0.5;
-}
-
-.mm-view-row.is-drop-before {
-  box-shadow: inset 0 2px 0 var(--g3-color-primary, #165dff);
-}
-
-.mm-view-row.is-drop-after {
-  box-shadow: inset 0 -2px 0 var(--g3-color-primary, #165dff);
-}
-
-/* 页签 chip：就是它运行时在列表页长的那副样子 */
-.mm-view-chip {
-  position: relative;
-  display: inline-flex;
-  align-items: center;
-  min-height: var(--mm-chip-height);
-  gap: 4px;
-  padding: 3px 11px;
-  border: 1px solid var(--g3-color-border, #e5e6eb);
-  border-radius: 999px;
-  background: transparent;
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-family: inherit;
-  font-size: 12px;
   cursor: pointer;
-
-  &:hover,
-  &.is-open {
-    border-color: var(--g3-color-primary, #165dff);
-    color: var(--g3-color-primary, #165dff);
-  }
-
-  &.is-default .mm-view-chip__label {
-    font-weight: 600;
-  }
 }
 
-.mm-view-chip.is-dragging {
-  opacity: 0.4;
-}
-
-/* 落点竖线：画在目标 chip 的左边；插到末尾时由容器上的 is-drop-end 画 */
-.mm-view-chip.is-drop-before::before {
-  content: '';
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  left: -5px;
-  width: 2px;
-  border-radius: 1px;
-  background: var(--g3-color-primary, #165dff);
-}
-
-.mm-chip-box.is-drop-end::after {
-  content: '';
-  align-self: stretch;
-  width: 2px;
-  border-radius: 1px;
-  background: var(--g3-color-primary, #165dff);
-}
-
-.mm-view-chip__star {
-  flex: none;
-  color: var(--g3-color-warning, #faad14);
-}
-
-.mm-view-chip__count {
-  color: var(--g3-color-text-tertiary, #86909c);
-  font-style: normal;
-}
-
-/* ================= 页签设置浮层 ================= */
-
-.mm-view-pop {
-  width: 360px;
-}
-
-.mm-view-pop__form {
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-  /* 浮层内容区自带的 4px 内边距太贴边，这里再让一圈 */
-  padding: 8px;
-}
-
-.mm-view-pop__row {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-/* 名称 / 编码：控件吃掉标签以外的宽度 */
-.mm-view-pop__row--field > :nth-child(2) {
-  flex: 1;
-  min-width: 0;
-}
-
-/* 条件 SQL：标签在上，输入框铺满整行 */
-.mm-view-pop__row--stack {
-  flex-direction: column;
-  align-items: stretch;
-  gap: 6px;
-}
-
-.mm-view-pop__label {
-  flex: none;
-  width: 52px;
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-size: 12px;
-}
-
-/* 勾选行：没有标签，两个勾选之间拉开距离才不至于连成一片 */
-.mm-view-pop__row--flags {
-  gap: 16px;
-}
-
-.mm-view-pop__sql {
-  box-sizing: border-box;
-  width: 100%;
-  padding: 6px 8px;
-  border: 1px solid var(--g3-color-border, #e5e6eb);
-  border-radius: var(--g3-radius-base, 0.5rem);
-  background: var(--g3-color-bg-container, #fff);
-  color: var(--g3-color-text, #1f2329);
-  font-family: Consolas, Monaco, 'Courier New', monospace;
-  font-size: 12px;
-  line-height: 1.6;
-  resize: vertical;
-}
-
-.mm-view-pop__sql:focus {
-  border-color: var(--g3-color-primary, #165dff);
-  outline: none;
-}
-
-.mm-view-pop__sql.is-error {
-  border-color: var(--g3-color-danger, #f53f3f);
-}
-
-.mm-view-pop__error {
-  margin: 0;
+.mm-groups__remove:hover {
+  background: var(--g3-color-fill-hover, #f2f3f5);
   color: var(--g3-color-danger, #f53f3f);
-  font-size: 12px;
 }
 
-.mm-view-pop__foot {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-/* 删除是浮层里唯一的动作，靠右放，与上面的表单拉开距离 */
-.mm-view-pop__foot > :last-child {
-  margin-left: auto;
-}
-
-/* ================= 页签组表单浮层 ================= */
-
-.mm-group-pop {
-  width: 260px;
-}
-
-.mm-group-pop__form {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 8px;
-}
-
-.mm-group-pop__form > :first-child {
+/* 表格撑满剩余空间（G3Table 内部按容器高度算滚动区） */
+.mm-query__table {
   flex: 1;
-  min-width: 0;
+  min-height: 0;
 }
 
 /* ================= 预览 ================= */
 
-/* 预览就是把列表页的查询卡摆出来：真控件、真排布，能点能输 */
 .mm-preview {
   display: flex;
   flex-direction: column;
@@ -2259,7 +782,8 @@ function viewLabelOf(row: ModuleQueryViewRow): string {
   opacity: 0.7;
 }
 
-/* 关键词 + 快捷筛选 + 更多筛选：同一行，与列表页一致 */
+/* 关键词 + 更多筛选：同一行，与列表页一致。
+ * 预览里它们是静态的（真控件要等列表页那侧），只用来示意查询入口的排布。 */
 .mm-preview__row {
   display: flex;
   flex-wrap: wrap;
@@ -2267,55 +791,23 @@ function viewLabelOf(row: ModuleQueryViewRow): string {
   gap: 12px;
 }
 
+.mm-preview__keyword,
+.mm-preview__more {
+  box-sizing: border-box;
+  display: inline-flex;
+  align-items: center;
+  height: 30px;
+  padding: 0 10px;
+  border: 1px solid var(--g3-color-border, #e5e6eb);
+  border-radius: 6px;
+  color: var(--g3-color-text-tertiary, #86909c);
+  font-size: 13px;
+}
+
 .mm-preview__keyword {
   width: 220px;
 }
 
-.mm-preview__field {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-}
-
-.mm-preview__field-label {
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-size: 12px;
-  white-space: nowrap;
-}
-
-.mm-preview__control {
-  width: 140px;
-}
-
-.mm-preview__presets {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-}
-
-.mm-preview__preset {
-  padding: 3px 10px;
-  border: 1px solid var(--g3-color-border, #e5e6eb);
-  border-radius: 999px;
-  background: transparent;
-  color: var(--g3-color-text-secondary, #4e5969);
-  font-family: inherit;
-  font-size: 12px;
-  cursor: pointer;
-}
-
-.mm-preview__preset:hover {
-  border-color: var(--g3-color-primary, #165dff);
-  color: var(--g3-color-primary, #165dff);
-}
-
-.mm-preview__preset.is-active {
-  border-color: var(--g3-color-primary, #165dff);
-  background: var(--g3-color-primary-soft, #e8f3ff);
-  color: var(--g3-color-primary, #165dff);
-  font-weight: 600;
-}
-
 .mm-preview__empty {
   margin: 0;
   color: var(--g3-color-text-tertiary, #86909c);
diff --git a/code/g3soft-erp/web/src/views/module/module-management/index.vue b/code/g3soft-erp/web/src/views/module/module-management/index.vue
index d75af1b5..4a1ff882 100644
--- a/code/g3soft-erp/web/src/views/module/module-management/index.vue
+++ b/code/g3soft-erp/web/src/views/module/module-management/index.vue
@@ -25,7 +25,7 @@ import {
   G3Tabs,
   G3Tag,
 } from '@g3soft/ui'
-import type { DropdownClickPayload, TreeDropInfo, TreeKey } from '@g3soft/ui'
+import type { DropdownClickPayload, TableRow, TreeDropInfo, TreeKey } from '@g3soft/ui'
 import { loadDataApi, saveObjectApi } from '@/services/api'
 import { createTempId } from '@/utils/common'
 import { buildPowerDeleteDependents } from '@/utils/powerCodes'
@@ -50,6 +50,8 @@ import {
 import ModuleAutoCodePanel from './ModuleAutoCodePanel.vue'
 import ModuleBasicPanel from './ModuleBasicPanel.vue'
 import ModuleFieldsPanel from './ModuleFieldsPanel.vue'
+import ModuleI18nPanel, { type I18nLanguage, type I18nPivotRow } from './ModuleI18nPanel.vue'
+import ModulePowerPanel from './ModulePowerPanel.vue'
 import ModuleQueryPanel from './ModuleQueryPanel.vue'
 import ModuleTreePanel from './ModuleTreePanel.vue'
 import {
@@ -359,6 +361,40 @@ const moduleAutoCode = ref<ModuleAutoCodeRow[]>([])
 /** 选中模块的查询设置草稿（s_module_schema.b_schema_type = 'query' 的配置对象） */
 const moduleQuery = ref<SchemaJson>(createDefaultSchema('query'))
 
+/** 选中模块的权限点草稿（s_power，b_object_type='module'） */
+const modulePowers = ref<TableRow[]>([])
+
+/** 选中模块的多语言译文透视草稿（s_i18n 长表 → 一行一个资源键） */
+const moduleI18nRows = ref<I18nPivotRow[]>([])
+
+/**
+ * 选中模块配置的加载态：权限 / 多语言这类表格面板在加载期间要锁掉增删，
+ * 否则会往一份还没到货的空草稿上追加行。
+ */
+const moduleConfigLoading = ref(false)
+
+/**
+ * 系统语言清单（s_i18n_type）：多语言面板的列定义来源。
+ * 整页只加载一次（语言是系统级配置，不随模块切换变化）。
+ */
+const i18nLanguages = ref<I18nLanguage[]>([])
+let i18nLanguagesLoaded = false
+
+async function loadI18nLanguages() {
+  if (i18nLanguagesLoaded) return
+  try {
+    const rows = await loadDataApi('s_i18n_type', 'b_canuse = 1', 'b_xh ASC, b_id ASC')
+    i18nLanguages.value = (rows ?? []).map((row) => ({
+      code: String(row.b_id ?? ''),
+      name: String(row.b_name ?? ''),
+      default: Number(row.b_default) === 1,
+    }))
+    i18nLanguagesLoaded = true
+  } catch {
+    // 语言清单加载失败：面板按无列展示，不打断其它面板
+  }
+}
+
 /**
  * 自动编码的启用态：开关挂在面板头（与「同步字段」「预览查询入口」同一操作区），
  * 状态由面板回报（@update:enabled），拨动时调面板暴露的 toggleEnabled，
@@ -399,6 +435,8 @@ watch(moduleSelectedId, (id) => {
   void loadModuleFields(id)
   void loadModuleAutoCode(id)
   void loadModuleQuery(id)
+  void loadModulePowers(id)
+  void loadModuleI18n(id)
 })
 
 function toModuleDraft(id: string): ModuleNode | null {
@@ -471,8 +509,96 @@ async function loadModuleQuery(id: string | null) {
   }
 }
 
-/* ================= 卡头动作 ================= */
+/**
+ * 加载本模块的权限点（s_power）：b_object_type='module' + b_object_id=模块编码。
+ *
+ * 只加载不回写：保存编排尚未移植，权限面板的编辑都落在草稿上。
+ * 排序与面板里物化的 b_xh 一致（按顺序号、编码），保证加载后看到的顺序
+ * 就是保存后的顺序。
+ */
+async function loadModulePowers(id: string | null) {
+  modulePowers.value = []
+  if (id == null) return
+  const requested = String(id)
+  moduleConfigLoading.value = true
+  try {
+    const rows = await loadDataApi(
+      's_power',
+      `b_object_type = 'module' AND b_object_id = ${sqlStringLiteral(requested)}`,
+      'b_xh ASC, b_id ASC',
+    )
+    // 选择已切走时丢弃过期响应
+    if (String(moduleSelectedId.value ?? '') !== requested) return
+    modulePowers.value = (rows ?? []).map((row) => ({ ...row }))
+  } catch {
+    // 权限点加载失败不打断页面：面板按空表展示
+  } finally {
+    if (String(moduleSelectedId.value ?? '') === requested) moduleConfigLoading.value = false
+  }
+}
 
+/**
+ * 加载本模块的多语言译文（s_i18n），并透视成「一行一个资源键」的编辑形态。
+ *
+ * s_i18n 是长表（b_key + b_locale），而编辑时一行一个键、每个语言一列更好用，
+ * 所以在这里转换一次。s_i18n **没有模块归属列**，只能按模块已知的资源键前缀
+ * 反查：module.{编码}（模块名）、field.{编码}.%（字段名）、group.{编码}.%（分组标题）、
+ * 以及权限点引用的 action.%（共用动词键，跨模块公用但要在本模块可见可维护）。
+ *
+ * 受管行（键由系统派生）标记 _managed / _autoDefault：
+ * 前者不可删不可改键，后者默认语言列只读（值就是名称本身）。
+ */
+async function loadModuleI18n(id: string | null) {
+  moduleI18nRows.value = []
+  if (id == null) return
+  const requested = String(id)
+  // 前缀用 LIKE 匹配：s_i18n 无模块归属列，只能按资源键前缀反查。
+  // 模块编码里的 `_` 是 LIKE 通配符，必须转义成 [_] 才不会跨模块误匹配。
+  const escaped = requested.replace(/[_[\]%]/g, (char) => `[${char}]`)
+  const condition = [
+    `b_key = ${sqlStringLiteral(`module.${requested}`)}`,
+    `b_key LIKE ${sqlStringLiteral(`field.${escaped}.%`)}`,
+    `b_key LIKE ${sqlStringLiteral(`group.${escaped}.%`)}`,
+    `b_key LIKE ${sqlStringLiteral('action.%')}`,
+  ].join(' OR ')
+  try {
+    const rows = await loadDataApi('s_i18n', condition, 'b_key ASC, b_locale ASC')
+    // 选择已切走时丢弃过期响应
+    if (String(moduleSelectedId.value ?? '') !== requested) return
+    moduleI18nRows.value = pivotI18nRows(rows ?? [])
+  } catch {
+    // 多语言加载失败不打断页面：面板按空表展示
+  }
+}
+
+/** 长表 → 透视行（一行一个 b_key，每个语言一列），并标出受管行 */
+function pivotI18nRows(rows: Record<string, unknown>[]): I18nPivotRow[] {
+  const moduleId = String(moduleSelectedId.value ?? '')
+  const byKey = new Map<string, I18nPivotRow>()
+  for (const row of rows) {
+    const key = String(row.b_key ?? '')
+    if (!key) continue
+    let pivot = byKey.get(key)
+    if (!pivot) {
+      pivot = { _rowKey: createTempId(), b_key: key }
+      // 受管键：模块名 / 字段名 / 分组标题由系统派生，键名不可改、行不可删
+      const managed =
+        key === `module.${moduleId}` ||
+        key.startsWith(`field.${moduleId}.`) ||
+        key.startsWith(`group.${moduleId}.`)
+      if (managed) {
+        pivot._managed = true
+        // 模块名 / 字段名 / 分组标题的默认语言值就是名称本身，不该在这里改
+        pivot._autoDefault = true
+      }
+      byKey.set(key, pivot)
+    }
+    pivot[String(row.b_locale ?? '')] = row.b_value
+  }
+  return [...byKey.values()]
+}
+
+/* ================= 卡头动作 ================= */
 /** 卡头「更多」菜单：模块级动作（删除与左侧树右键菜单是同一入口） */
 const moreMenuItems = computed(() => [
   { key: 'delete', label: '删除模块', icon: Trash2, danger: true },
@@ -735,6 +861,8 @@ async function onModuleDrop({ dragKey, dropKey, dropPosition }: TreeDropInfo) {
 
 onMounted(() => {
   void loadModuleTree()
+  // 语言清单是多语言面板的列定义来源；整页只加载一次，与模块树互不阻塞
+  void loadI18nLanguages()
 })
 </script>
 
@@ -875,13 +1003,11 @@ onMounted(() => {
                   v-else-if="section.key === 'fields'"
                   v-model:fields="moduleFields"
                 />
-                <!-- 查询设置：两屏（查询字段 / 工作队列页签），全字段勾选式，只做编辑不回写 -->
+                <!-- 查询设置：工作队列页签，只做编辑不回写 -->
                 <ModuleQueryPanel
                   v-else-if="section.key === 'query'"
                   :ref="setQueryPanel"
                   v-model:query="moduleQuery"
-                  :module-id="String(moduleDraft?.b_id ?? '')"
-                  :fields="moduleFields"
                 />
                 <!-- 自动编码：仅数据模块（configSections 已按 scope 过滤），单条规则 + 实时预览 -->
                 <ModuleAutoCodePanel
@@ -893,6 +1019,21 @@ onMounted(() => {
                   :fields="moduleFields"
                   @update:enabled="(value) => (autoCodeEnabled = value)"
                 />
+                <!-- 权限：本模块权限点（s_power）+ 右侧权限库导入，只做编辑不回写 -->
+                <ModulePowerPanel
+                  v-else-if="section.key === 'power'"
+                  v-model:powers="modulePowers"
+                  :module-id="String(moduleDraft?.b_id ?? '')"
+                  :module-name="String(moduleDraft?.b_name ?? '')"
+                  :loading="moduleConfigLoading"
+                />
+                <!-- 多语言：s_i18n 透视表（一行一个资源键，每个语言一列），只做编辑不回写 -->
+                <ModuleI18nPanel
+                  v-else-if="section.key === 'i18n'"
+                  v-model:rows="moduleI18nRows"
+                  :languages="i18nLanguages"
+                  :loading="moduleConfigLoading"
+                />
                 <div v-else class="mm-config-placeholder">
                   {{ section.label }}面板将按 fms-vue 逐步移植
                 </div>
diff --git a/code/g3soft-erp/web/src/views/module/module-management/utils.ts b/code/g3soft-erp/web/src/views/module/module-management/utils.ts
index 81002af2..ce2444b1 100644
--- a/code/g3soft-erp/web/src/views/module/module-management/utils.ts
+++ b/code/g3soft-erp/web/src/views/module/module-management/utils.ts
@@ -101,49 +101,21 @@ export interface ModuleAutoCodeRow {
 }
 
 /* ================= 查询设置（s_module_schema.b_schema_type = 'query'） =================
- * 查询配置在编辑器里是一份「扁平草稿」（ModuleQueryDraft，四块内容各一个数组/对象），
- * 落库形态是 query JSON（schemaVersion 3）；两个方向的转换集中在这里，
- * 口径与 fms-vue 的 schemaModel.js 一致。
+ * 只配一件事：工作队列页签（views）。组内单选、组间叠加，条件直接写 SQL。
  *
- * 四块内容：
- * - fields（查询字段）：参与条件查询的字段；未进快捷筛选的，运行时按 b_xh 铺进「更多筛选」抽屉；
- * - views（工作队列页签）：组内单选、组间叠加，条件直接写 SQL；
- * - keyword（关键词字段）：只配可搜索字段，占位文案运行时按字段名生成；
- * - quickFilters（快捷筛选字段）：铺在列表页查询卡上，按 order 排列。
+ * 查询能力不再配置：关键词搜哪些字段、更多筛选铺哪些字段、用什么控件与算子，
+ * 列表页按 s_field 就能推导（控件与算子看业务类型、关键词看文本类字段、
+ * 更多筛选铺全部启用字段并按 b_xh 排序）。配一遍是重复劳动，还容易漏配 ——
+ * 新模块零配置就该有查询能力。相对时间的快捷预设属于日期控件自己的能力，同样不归这里。
  *
- * 未建模属性经行上的 _node 原样带回：草稿只承载面板认识的列，
+ * 控件与算子的取值口径（列表页运行时用）：组件 input 输入框 / select 下拉 / date 日期 /
+ * datetime 日期时间 / number 数字 / checkbox 复选框；操作符 eq 等于 / like 模糊 /
+ * starts_with 开头是 / gt ge lt le 比较 / in 包含 / between 范围。
+ *
+ * 落库形态是 query JSON（schemaVersion 4）；未建模属性经行上的 _node 原样带回，
  * JSON 里未来的扩展键不会在编辑往返中被静默丢掉。
  */
 
-/**
- * 查询组件与操作符（queryFields[字段].component / .operator）。
- *
- * 没有界面入口——查询控件由字段的业务类型决定即可（日期字段当然是日期框、下拉字段当然是下拉），
- * 配置里已有的值由面板原样保留、不回写不认识的东西，这里只给「新参与查询的字段」兜一个初值。
- * 取值：组件 input 输入框 / select 下拉 / date 日期 / datetime 日期时间 / number 数字 / checkbox 复选框；
- * 操作符 eq 等于 / like 模糊 / starts_with 开头是 / gt ge lt le 比较 / in 包含 / between 范围。
- */
-
-/** 按字段业务类型给出查询组件 / 操作符默认值；未列出的（input / textarea）走通用 like */
-const QUERY_COMPONENT_DEFAULTS: Record<string, { component: string; operator: string }> = {
-  number: { component: 'number', operator: 'eq' },
-  money: { component: 'number', operator: 'eq' },
-  date: { component: 'date', operator: 'ge' },
-  datetime: { component: 'datetime', operator: 'ge' },
-  select: { component: 'select', operator: 'eq' },
-  checkbox: { component: 'checkbox', operator: 'eq' },
-}
-
-/** 字段 → 查询组件 / 操作符默认值（新参与查询的字段按业务类型兜初值） */
-export function queryRowDefaults(field: ModuleFieldRow): {
-  b_component: string
-  b_operator: string
-} {
-  const type = String(field?.b_type ?? '')
-  const defaults = QUERY_COMPONENT_DEFAULTS[type] || { component: 'input', operator: 'like' }
-  return { b_component: defaults.component, b_operator: defaults.operator }
-}
-
 /**
  * 页签所属分组：模型上页签「一定有组」——组既是列表页上的一行页签，
  * 也是「组内单选、组间叠加」的作用域，不存在不属于任何组的页签。
@@ -151,57 +123,6 @@ export function queryRowDefaults(field: ModuleFieldRow): {
  */
 export const DEFAULT_VIEW_GROUP = '默认'
 
-/**
- * 快捷搜索项在卡上的呈现方式：
- * control = 直接把控件摆出来（用户自己填），preset = 给一排相对时间的预设（点一下就筛）。
- */
-export const QUERY_QUICK_MODES = [
-  { label: '直接放控件', value: 'control' },
-  { label: '给预设', value: 'preset' },
-]
-
-/**
- * 相对时间的预设。存的**是枚举不是日期**：配的时候不知道用户哪天开页面，
- * 运行时才算成具体区间（如 this_month → 本月 1 号 ~ 今天）。
- */
-export const QUERY_DATE_PRESETS = [
-  { value: 'today', label: '今天' },
-  { value: 'yesterday', label: '昨天' },
-  { value: 'this_week', label: '本周' },
-  { value: 'last_week', label: '上周' },
-  { value: 'this_month', label: '本月' },
-  { value: 'last_month', label: '上月' },
-  { value: 'last_7_days', label: '最近7天' },
-  { value: 'last_30_days', label: '最近30天' },
-]
-
-/** 查询字段行（草稿）：身份是 _rowKey，落库后按 b_field 收进 queryFields */
-export interface ModuleQueryFieldRow {
-  _rowKey: string
-  /** 未建模属性（原 queryFields[字段] 的其余键），回写时原样带回 */
-  _node: Record<string, unknown>
-  b_module_id: string
-  b_field: string | null
-  b_component: string
-  b_operator: string
-  b_default_value: string | null
-  /** 卡上的呈现方式：control 直接放控件 / preset 给一排预设（不写按 control） */
-  b_mode: string
-  /** preset 模式下要露出的预设（相对时间枚举） */
-  b_presets: string[]
-  /** preset 模式下默认选中哪个预设（空 = 打开页面不带条件） */
-  b_default_preset: string | null
-  b_canuse: number
-  b_xh: number
-  /**
-   * 由「列表」勾选自动补出的行（fms 语义）：面板里改过组件 / 算子 / 默认值后摘掉标记，
-   * 转为自定义行，取消列表勾选时不再被自动回收。列表面板尚未移植，
-   * 保留该列只为与落库结构一致。
-   */
-  fromList: boolean
-  [key: string]: unknown
-}
-
 /** 工作队列页签行（草稿）：code 为空的行不落库（页签没有编码就无法被运行时选中） */
 export interface ModuleQueryViewRow {
   _rowKey: string
@@ -216,52 +137,17 @@ export interface ModuleQueryViewRow {
   [key: string]: unknown
 }
 
-/** 快捷筛选行（草稿） */
-export interface ModuleQueryQuickRow {
-  _rowKey: string
-  field: string
-  order: number
-  [key: string]: unknown
-}
-
-/** 查询设置草稿：四个分节的编辑态，与落库 JSON 经下面两个函数双向适配 */
+/** 查询设置草稿：与落库 JSON 经下面两个函数双向适配 */
 export interface ModuleQueryDraft {
-  fields: ModuleQueryFieldRow[]
   views: ModuleQueryViewRow[]
-  keyword: { fields: string[] }
-  quickFilters: ModuleQueryQuickRow[]
 }
 
-/** query JSON → 编辑器草稿 */
-export function querySchemaToDraft(schema: SchemaJson | null, moduleId: string): ModuleQueryDraft {
+/** query JSON → 编辑器草稿（只取页签；其余键不再建模，由回写统一清理） */
+export function querySchemaToDraft(schema: SchemaJson | null): ModuleQueryDraft {
   const source = (schema && typeof schema === 'object' ? schema : {}) as SchemaJson & {
-    queryFields?: Record<string, unknown>
     views?: Array<Record<string, unknown>>
-    keywordSearch?: { fields?: unknown[] }
-    quickFilters?: Array<Record<string, unknown>>
     defaultViewCode?: string
   }
-  const fieldRows = Object.entries(source.queryFields || {}).map(([field, config], index) => {
-    const node =
-      config && typeof config === 'object' ? { ...(config as Record<string, unknown>) } : {}
-    const fromList = node.fromList === true
-    delete node.fromList
-    return {
-      _rowKey: createTempId(),
-      _node: node,
-      b_module_id: String(moduleId),
-      b_field: field,
-      b_component: String(node.component ?? 'input'),
-      b_operator: String(node.operator ?? 'like'),
-      b_default_value: node.defaultValue == null ? null : String(node.defaultValue),
-      b_mode: String(node.mode ?? 'control'),
-      b_presets: Array.isArray(node.presets) ? node.presets.map((item) => String(item)) : [],
-      b_default_preset: node.defaultPreset == null ? null : String(node.defaultPreset),
-      b_canuse: 1,
-      b_xh: (index + 1) * 10,
-      fromList,
-    } as ModuleQueryFieldRow
-  })
   // 旧结构的 defaultViewCode 等价于「该页签 isDefault」，加载时折进来
   const legacyDefaultCode = String(source.defaultViewCode ?? '')
   const views = (source.views || []).map((view, index) => {
@@ -278,18 +164,7 @@ export function querySchemaToDraft(schema: SchemaJson | null, moduleId: string):
       conditionSql: String(view?.conditionSql ?? '').trim(),
     } as ModuleQueryViewRow
   })
-  return {
-    fields: fieldRows,
-    views,
-    keyword: {
-      fields: (source.keywordSearch?.fields || []).map((field) => String(field)),
-    },
-    quickFilters: (source.quickFilters || []).map((entry, index) => ({
-      _rowKey: createTempId(),
-      field: String(entry?.field ?? ''),
-      order: Number(entry?.order) || (index + 1) * 10,
-    })),
-  }
+  return { views }
 }
 
 /** 编辑器草稿 → query JSON（未建模属性经 _node / base 保留，建模属性以草稿为准） */
@@ -298,49 +173,22 @@ export function queryDraftToSchema(
   baseSchema?: SchemaJson | null,
 ): SchemaJson {
   const base = { ...(baseSchema || createDefaultSchema('query')) }
-  // 旧结构的这几个键一律不再使用，改写时一并清掉
+  // 查询能力由列表页按 s_field 推导：这几个配置键不再使用，改写时一并清掉
+  // （queryFields 里还挂着历史遗留的 mode / presets / defaultPreset，随整个键一起清）
+  delete base.queryFields
+  delete base.keywordSearch
+  delete base.quickFilters
+  // 更早版本的遗留键
   delete base.groups
   delete base.quick
   delete base.filterGroups
   delete base.defaultViewCode
 
-  const queryFields: Record<string, unknown> = {}
-  for (const row of draft?.fields || []) {
-    const field = String(row.b_field ?? '').trim()
-    if (!field) continue
-    const config: Record<string, unknown> = { ...(row._node || {}) }
-    if (row.b_component) config.component = row.b_component
-    else delete config.component
-    if (row.b_operator) config.operator = row.b_operator
-    else delete config.operator
-    if (row.b_default_value != null && row.b_default_value !== '') {
-      config.defaultValue = row.b_default_value
-    } else {
-      delete config.defaultValue
-    }
-    // 呈现方式与预设：control 是默认形态，不写进 JSON（省得每条都挂一堆默认值）
-    if (row.b_mode === 'preset') {
-      config.mode = 'preset'
-      const presets = (row.b_presets || []).map((item) => String(item)).filter(Boolean)
-      if (presets.length) config.presets = presets
-      else delete config.presets
-      if (row.b_default_preset) config.defaultPreset = row.b_default_preset
-      else delete config.defaultPreset
-    } else {
-      delete config.mode
-      delete config.presets
-      delete config.defaultPreset
-    }
-    if (row.fromList) config.fromList = true
-    else delete config.fromList
-    queryFields[field] = config
-  }
-
   const views = (draft?.views || [])
     .map((row) => {
       const code = String(row.code ?? '').trim()
       if (!code) return null
-      const view: Record<string, unknown> = { ...(row._node || {}), code }
+      const view: Record<string, unknown> = { ...row._node, code }
       if (String(row.label ?? '').trim()) view.label = String(row.label).trim()
       else delete view.label
       // 页签一定有分组：空的一律落到默认组（历史配置在此被补全）
@@ -357,22 +205,10 @@ export function queryDraftToSchema(
     })
     .filter((view): view is Record<string, unknown> => view != null)
 
-  const keywordFields = [
-    ...new Set((draft?.keyword?.fields || []).map((field) => String(field)).filter(Boolean)),
-  ]
-
   return {
     ...base,
-    schemaVersion: 3,
+    schemaVersion: 4,
     views,
-    keywordSearch: { fields: keywordFields },
-    quickFilters: (draft?.quickFilters || [])
-      .map((row, index) => ({
-        field: String(row.field ?? '').trim(),
-        order: Number(row.order) || (index + 1) * 10,
-      }))
-      .filter((entry) => entry.field),
-    queryFields,
   }
 }
 
diff --git a/code/g3soft-erp/web/src/views/table-test/index.vue b/code/g3soft-erp/web/src/views/table-test/index.vue
index fe563f7c..ff84efc4 100644
--- a/code/g3soft-erp/web/src/views/table-test/index.vue
+++ b/code/g3soft-erp/web/src/views/table-test/index.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
 import { RotateCw, Save, Table, TriangleAlert } from '@lucide/vue'
-import { G3Message, G3Table } from '@g3soft/ui'
+import { checkPrecision, G3Message, G3Table } from '@g3soft/ui'
 import type { G3TableColumn, TableExpose, TableRow } from '@g3soft/ui'
 
 /**
@@ -14,30 +14,38 @@ import type { G3TableColumn, TableExpose, TableRow } from '@g3soft/ui'
  * 换成通用列反而会丢掉「贴近真实业务密度」这一点。
  *
  * 覆盖的能力（按「配置一处、演示一处」组织，方便照抄）：
- *  1. 编辑器类型：text / number / select / checkbox
+ *  1. 编辑器类型：text / number / date / select / checkbox
+ *     `date` 点格即弹日历、也支持手输，值始终是字符串（见「开航日 / 截单日」两列）
  *  2. 校验态：error（红底 + ! 角标）与 warning（琥珀底 + ! 角标）
  *  3. 禁用态：editor.disabled（整列禁用 / 按行条件禁用）
  *  4. 只读列：没配 editor 的列在编辑期自动灰底
  *  5. 当前行高亮：受控 activeRowKey + @row-click（与 fms-vue 的 FmsTable 同款写法）
- *  6. 提交流程：保存时整表校验，未通过则定位到首个错误格
- *  7. **左右冻结列**：左冻结「序号 / 订舱号 / 客户」，右冻结「备注」，横向滚动时两侧不动
+ *  6. 提交流程：保存时整表校验（含组件导出的 `checkPrecision`），未通过则定位到首个错误格
+ *  7. **金额精度**：「海运费」列用 `editor.precision` 声明两位小数 —— 超出即标红、
+ *     悬停看原因，且**不改数据**；展示细节（千分位 / ¥ 前缀）由列上的 `format` 管
+ *  8. **左右冻结列**：左冻结「序号 / 订舱号 / 客户」，右冻结「备注」，横向滚动时两侧不动
  *
- * 关于冻结列（第 7 条），配置只有列上的一个 `fixed`，但有三条硬约束：
+ * 关于冻结列（第 8 条），配置只有列上的一个 `fixed`，但有三条硬约束：
  *  · `fixed: 'left'` 的列要排在 columns **最前面**、`'right'` 的排在**最后面**；
  *  · 固定列**必须写 `width`**。左侧固定列的吸附位置由「它左边那些 left 固定列的
  *    宽度累加」算出来（底座 `useGetFixedColPosition`），没写宽度就没有吸附位移；
  *  · 想看到效果，**总列宽必须超过容器宽**（否则整表都看得见，固定与不固定一个样）——
- *    本页刻意加到 21 列业务列来制造横向溢出。
+ *    本页刻意加到 22 列业务列来制造横向溢出。
  *  序号列（`seq`）由组件内部注入、业务侧不用配，它**本身也是左固定的**
  *  （G3Table 注入时写了 `fixed: 'left'`，与选择列一致），所以左冻结区依次是
  *  「序号 → 订舱号 → 客户」，横向滚动时行号不会跟着丢。
  *  阴影开关 `fixed-col-shadow` 建议打开：冻结列与滚过去的列同为白底，没有这层
  *  渐变就看不出边界在哪。
  *
- * **本页始终处于可编辑状态**（没有「编辑明细」开关按钮）：
- * 进去就能直接点任意单元格改，`editable` 用组件默认值 true。
+ * 本页**始终具备编辑能力**（没有「编辑明细」开关按钮），`editable` 用组件默认值 true。
  * 没有任何行被默认激活 —— 编辑目标是用户点出来的。
  *
+ * ⚠️ 键盘分工（详见 docs/content/ui/data/table.md 的「键盘：单击即编辑，方向键分工」）：
+ *   · **单击格即进入编辑**，可以直接打字（同行换列时重新挂载并全选，输入即替换）；
+ *   · 编辑态里**左右**在输入框内移动光标（`Shift+左右` 选文本）、**上下**切到上 / 下一行的同一列；
+ *   · `Enter` 确认并下移到下一行同列；备注这类多行格里的 `Enter` 是换行；
+ *   · `Esc` 放弃本次编辑（回滚到进入前的值）；`Tab` / `Shift+Tab` 跳过只读列跳下一个可编辑格。
+ *
  * 数据为本地假数据，不请求接口。
  */
 
@@ -69,6 +77,13 @@ interface BookingRow extends TableRow {
   grossWeight: number
   /** 体积，单位 CBM */
   volume: number
+  /**
+   * 海运费（金额）。
+   *
+   * 用来演示「数值精度」这条链路：`editor.precision` 声明两位小数，
+   * 超出即标红（且**不改数据**）；展示细节（千分位 / ¥ 前缀）走列上的 `format`。
+   */
+  freight: number
   /** 业务员（对应 SALESMAN_OPTIONS 的 value） */
   salesman: string
   etd: string
@@ -192,6 +207,15 @@ function makeRow(index: number): BookingRow {
     // 毛重按箱量估：20 尺约 12~19 吨，40 尺按 2 倍箱量已经在 containerCount 里计入
     grossWeight: containerCount * (12 + Math.floor(seeded(index * 11.3) * 8)),
     volume: containerCount * (18 + Math.floor(seeded(index * 13.7) * 12)),
+    /**
+     * 海运费：常规行给**两位以内**的金额（展示千分位与两位小数的格式化效果），
+     * 每第 5 行刻意给**三位小数** —— 这样一进页面就能看到「精度超了」标红的样子，
+     * 不需要自己动手输。
+     */
+    freight:
+      index % 5 === 3
+        ? Math.round(seeded(index * 17.3) * 9000000) / 1000
+        : Math.round(seeded(index * 17.3) * 4000000) / 100,
     salesman: pick(SALESMAN_OPTIONS, index * 12.9).value,
     etd: `2026-${m}-${d}`,
     docClose: `2026-${String((index % 12) + 1).padStart(2, '0')}-${String(Math.max(1, Number(d) - 3)).padStart(2, '0')}`,
@@ -394,17 +418,54 @@ const columns = ref<G3TableColumn<TableRow>[]>([
     align: 'right',
     editor: { type: 'number' },
   },
+  {
+    dataIndex: 'freight',
+    title: '海运费',
+    width: 130,
+    align: 'right',
+    /**
+     * 展示：千分位 + `¥` 前缀。
+     *
+     * ⚠️ **小数位不写在这里** —— 它归 `editor.precision`（一处真源），
+     * `format` 只管「怎么显示」。两者都要写时以 `format.decimals` 为准，
+     * 但那是留给「显示位数 ≠ 数据精度」的例外，常规场景别用。
+     */
+    format: { thousands: true, prefix: '¥' },
+    editor: {
+      type: 'number',
+      /**
+       * 精度：两位小数。
+       *
+       * 超出即 error —— 红底 + 左侧竖条，悬停浮层显示「最多 2 位小数」，
+       * 而这条规则由**组件内置**，不需要在这里写任何与小数位有关的 `validate`。
+       * 且组件**不改数据**：用户输的 `123.456` 原样留在行里，由用户自己改。
+       */
+      precision: 2,
+      validate: (v: unknown) => Number(v) >= 0 || '海运费不能为负数',
+    },
+  },
   {
     dataIndex: 'etd',
     title: '开航日',
-    width: 110,
-    editor: { type: 'text' },
+    // 比纯文本列宽一些：日期框里还要放清除按钮，110px 会把日期挤到省略号
+    width: 140,
+    /**
+     * 日期编辑器。点格即弹日历（不必先点输入框），也能直接手输 `2026-03-15`。
+     *
+     * 值始终是**字符串**、不做 Date ↔ string 转换：面板精度与绑定值格式都由
+     * `format` 决定，默认 `YYYY-MM-DD`，正好是这一列数据的存量格式（见 makeRow）。
+     */
+    editor: { type: 'date' },
   },
   {
     dataIndex: 'docClose',
     title: '截单日',
-    width: 110,
-    editor: { type: 'text' },
+    width: 140,
+    /**
+     * 同样是日期列，但**带时间精度**：`format` 写全到分钟，面板会多出时间列，
+     * 而且选完要点「确定」才提交（只有日精度时点一下日期就完成）。
+     */
+    editor: { type: 'date', format: 'YYYY-MM-DD HH:mm' },
   },
   {
     dataIndex: 'salesman',
@@ -474,17 +535,37 @@ function findFirstError(): { rowIndex: number; colIndex: number; message: string
     for (let c = 0; c < columns.value.length; c += 1) {
       const col = columns.value[c]
       const editor = col.editor
-      if (!editor?.validate) continue
+      // 注意判据是 `!editor` 而不是 `!editor?.validate`：配了 precision 的列
+      // 可能没有自己的 validate，但它的精度规则同样要参与提交把关。
+      if (!editor) continue
       if (typeof editor.disabled === 'function' ? editor.disabled(row) : editor.disabled) continue
-      const result = editor.validate(row[col.dataIndex], row, col)
-      if (typeof result === 'string' && result.length > 0) {
-        return { rowIndex: r, colIndex: c, message: result }
-      }
+
+      const message = validateCell(row, col)
+      if (message) return { rowIndex: r, colIndex: c, message }
     }
   }
   return null
 }
 
+/**
+ * 跑一格的**全部**校验规则，返回失败原因（`''` = 通过）。
+ *
+ * 两条规则缺一不可：
+ *   1. `editor.validate` —— 业务规则；
+ *   2. `checkPrecision` —— 组件内置的**精度**规则，而导出的就是表格里用的那个函数。
+ *      这里若只跑第 1 条，就会出现「格子红了、但保存能过」——
+ *      校验状态与提交把关不一致是最难查的那类问题，所以宁可多写这两行。
+ */
+function validateCell(row: TableRow, col: G3TableColumn<TableRow>): string {
+  const editor = col.editor
+  if (!editor) return ''
+  const precision =
+    typeof editor.precision === 'function' ? editor.precision(row) : editor.precision
+  const result =
+    editor.validate?.(row[col.dataIndex], row, col) || checkPrecision(row[col.dataIndex], precision)
+  return typeof result === 'string' ? result : ''
+}
+
 /**
  * 表格实例引用，用于「保存失败时定位到首个错误格」。
  *
@@ -532,10 +613,9 @@ const errorCount = computed(() => {
   let n = 0
   for (const row of rows.value) {
     for (const col of columns.value) {
-      const editor = col.editor
-      if (!editor?.validate) continue
-      const result = editor.validate(row[col.dataIndex], row, col)
-      if (typeof result === 'string' && result.length > 0) n += 1
+      // 与 findFirstError 用**同一个** validateCell：两处若各写一套，
+      // 汇总数与「保存时定位到的那个错」迟早对不上。
+      if (validateCell(row, col)) n += 1
     }
   }
   return n
diff --git a/code/g3soft-erp/web/tests/views/module/module-management/ModuleQueryPanel.spec.ts b/code/g3soft-erp/web/tests/views/module/module-management/ModuleQueryPanel.spec.ts
new file mode 100644
index 00000000..d6dadbdf
--- /dev/null
+++ b/code/g3soft-erp/web/tests/views/module/module-management/ModuleQueryPanel.spec.ts
@@ -0,0 +1,136 @@
+/**
+ * 查询配置面板（query JSON，schemaVersion 4）：只配工作队列页签。
+ *
+ * 这里测的是**结构与数据往返**：分组渲染、建组即建页签、编码自动派生、
+ * 组名就地改要改整组、旧的查询字段配置在回写时被清掉。
+ * G3Table 在 happy-dom 里没有真实尺寸，行内编辑与行拖拽是组件库自己的活，
+ * 用桩替换掉（本面板只负责把列定义与数据源接上去）。
+ */
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import ModuleQueryPanel from '@/views/module/module-management/ModuleQueryPanel.vue'
+import type { SchemaJson } from '@/utils/schemaJson'
+
+function schema(views: Array<Record<string, unknown>> = []): SchemaJson {
+  return { schemaVersion: 4, views }
+}
+
+/**
+ * 模拟父级 v-model:query：emit 回来要显式写回 prop，
+ * 否则复现不了「草稿回写 → 父级再传下来」这一轮往返。
+ */
+function mountPanel(views: Array<Record<string, unknown>> = []) {
+  const wrapper = mount(ModuleQueryPanel, {
+    props: {
+      query: schema(views),
+      'onUpdate:query': (value: SchemaJson) => wrapper.setProps({ query: value }),
+    },
+    global: { stubs: { G3Table: true } },
+  })
+  return wrapper
+}
+
+/** 当前草稿里的页签行（面板对外就是这份 query JSON） */
+function draftViews(wrapper: ReturnType<typeof mountPanel>): Array<Record<string, unknown>> {
+  return (wrapper.props('query') as SchemaJson).views as Array<Record<string, unknown>>
+}
+
+function groupNames(wrapper: ReturnType<typeof mountPanel>): string[] {
+  return wrapper.findAll('.mm-groups__name').map((el) => (el.element as HTMLInputElement).value)
+}
+
+/** 改组名：业务上走 change（失焦 / 回车提交），这里照同一条路触发 */
+async function renameFirstGroup(wrapper: ReturnType<typeof mountPanel>, name: string) {
+  const input = wrapper.find('.mm-groups__name')
+  await input.setValue(name)
+  await input.trigger('change')
+  await wrapper.vm.$nextTick()
+}
+
+describe('查询配置面板（工作队列页签）', () => {
+  it('按 group 归组：分组条上每组一个 chip，顺序跟着组内最小 order 走', () => {
+    const wrapper = mountPanel([
+      { code: 'sail', label: '已开航', group: '状态', order: 30 },
+      { code: 'all', label: '全部', group: '状态', order: 10 },
+      { code: 'month', label: '本月', group: '时间', order: 20 },
+    ])
+
+    expect(groupNames(wrapper)).toEqual(['状态', '时间'])
+  })
+
+  it('历史配置没写 group 的页签落到「默认」组（组从行反推，不存在无组的页签）', () => {
+    const wrapper = mountPanel([{ code: 'all', label: '全部', order: 10 }])
+
+    expect(groupNames(wrapper)).toEqual(['默认'])
+  })
+
+  it('新增页签组：建组的同时建出组内第一个页签，编码自动派生（空编码落库会被丢掉）', async () => {
+    const wrapper = mountPanel()
+
+    await wrapper.find('.mm-query__bar button').trigger('click')
+    await wrapper.vm.$nextTick()
+
+    expect(groupNames(wrapper)).toEqual(['分组 1'])
+    const views = draftViews(wrapper)
+    expect(views).toHaveLength(1)
+    expect(views[0].group).toBe('分组 1')
+    expect(views[0].code).toBe('view_1')
+    // 组里第一个页签自动成为组内默认：一个组总要有一个默认选中的
+    expect(views[0].isDefault).toBe(true)
+  })
+
+  it('再加一组时编码继续派生，不会与已有页签撞号', async () => {
+    const wrapper = mountPanel([{ code: 'view_1', label: '全部', group: '状态', order: 10 }])
+
+    await wrapper.find('.mm-query__bar button').trigger('click')
+    await wrapper.vm.$nextTick()
+
+    expect(draftViews(wrapper)[1].code).toBe('view_2')
+  })
+
+  it('组名就地改：改的是整组（组是共享实体，不能只改一行）', async () => {
+    const wrapper = mountPanel([
+      { code: 'all', label: '全部', group: '状态', order: 10 },
+      { code: 'sail', label: '已开航', group: '状态', order: 20 },
+    ])
+
+    await renameFirstGroup(wrapper, '运行状态')
+
+    expect(groupNames(wrapper)).toEqual(['运行状态'])
+    expect(draftViews(wrapper).every((row) => row.group === '运行状态')).toBe(true)
+  })
+
+  it('组名改成已存在的组名时拒绝（否则两个组会被无声合并）', async () => {
+    const wrapper = mountPanel([
+      { code: 'a', label: '全部', group: '状态', order: 10 },
+      { code: 'b', label: '本月', group: '时间', order: 20 },
+    ])
+
+    await renameFirstGroup(wrapper, '时间')
+
+    expect(groupNames(wrapper)).toEqual(['状态', '时间'])
+  })
+
+  it('回写时把不再使用的 queryFields / keywordSearch / quickFilters 一并清掉', async () => {
+    const wrapper = mountPanel()
+    // 载入一份带旧配置的 schema：适配层只认 views，其余键由回写统一清理
+    await wrapper.setProps({
+      query: {
+        schemaVersion: 3,
+        views: [{ code: 'all', label: '全部', order: 10 }],
+        keywordSearch: { fields: ['b_name'] },
+        quickFilters: [{ field: 'b_name', order: 10 }],
+        queryFields: { b_name: { component: 'input', operator: 'like' } },
+      },
+    })
+    // 触发一次回写（新增一组）
+    await wrapper.find('.mm-query__bar button').trigger('click')
+    await wrapper.vm.$nextTick()
+
+    const next = wrapper.props('query') as SchemaJson
+    expect(next.queryFields).toBeUndefined()
+    expect(next.keywordSearch).toBeUndefined()
+    expect(next.quickFilters).toBeUndefined()
+    expect(next.schemaVersion).toBe(4)
+  })
+})
diff --git a/code/g3soft-libs/.changeset/table-cell-status-shapes.md b/code/g3soft-libs/.changeset/table-cell-status-shapes.md
new file mode 100644
index 00000000..a461f12f
--- /dev/null
+++ b/code/g3soft-libs/.changeset/table-cell-status-shapes.md
@@ -0,0 +1,18 @@
+---
+'@g3soft/ui': minor
+---
+
+G3Table：校验态补「左侧语义色竖条」、禁用灰底加深一档 —— 让「格级」与「行级」状态重新分得开。
+
+- **校验态（`errorStyle: 'cell'`）新增左侧 3px 语义色竖条**（error 红 / warning 琥珀），底色浓度不变（8% / 5%）。
+  - 背景：表体的纵向列线已经去掉（见上一条 changeset）。原来「格级色块被列线围成矩形、行级是一条长带」的**形状差异**没了，校验底色退化成无边界的横带，只剩色相一个通道 —— 「这一格有问题」很容易被读成「这一段行有问题」。左侧竖条把形状还回来：竖条 = 格级，横带 = 行级。
+  - 画在 `background-image` 上，不是 `border`（进盒模型会顶高行高、破坏虚拟滚动 `translateY` 的基准），也不是 `box-shadow`（单值属性，会与库的单元格选区描边、焦点环、固定列叠色互相整条覆盖）。因此 `background-origin` 按层指定：第 1 层用 `border-box` —— 表体纯文本格有 `--cell-padding-x`（12px）内边距，用默认的 `padding-box` 竖条会飘在格子内部 12px 处。
+  - 「正在编辑的那一格让位」的既有行为不变：编辑时既无底色也无竖条，只剩语义色焦点环 + 红字。
+- **禁用（改不了）灰底从 3% 提到 6%**（暗色 4% → 8%）。灰底与斑马纹同色相、都是一条横带，原来只差约 1% 亮度，肉眼分不出「这行是条纹」还是「这格改不了」；拉开一档后可辨。整列只读 / 整列禁用 / 按行禁用三种情形共用这一套。
+- **「既禁用又校验不过」的格子仍然只显示灰**（既有决策：改不了就别再提示这里错了）。灰底规则里**显式写回**库那两层格线（`background-image: var(--bg-border-right), var(--bg-border-bottom)`）—— 竖条加在 `background-image` 第 1 层上，而 background-image 不能按层覆盖，只改 `background-color` 的话灰底上会留一条红 / 黄竖条。亮 / 暗两份灰底规则都要写（只写亮色就会出现「亮色纯灰、暗色留红条」）。
+- **注释修正**：`G3Table.vue` 里「灰底权重 (0,6,1) 高于校验态 (0,4,1)」这句是旧数字 —— 校验态选择器带 `:has()`，特异性取参数中最高者，按行禁用那条与校验态实测同为 `(0,7,1)`，胜负实际由「谁写在后面」决定。已改成准确表述并加了警告。
+- **失败原因现在有出口了**：`validate` / `validateWarning` 返回的字符串（「金额必须大于 0」）此前在 `resolveEditorStatus` 里**只被取 `.length` 判等级、内容直接丢掉** —— 业务精心写的失败原因没有任何出口，用户只知道「这格红了」。现在该结果归一为 `{ level, message }` 一次带出，挂到内容节点的 `data-validate-message` 上，表格侧 **hover 那一格**时弹一个自绘浮层显示原因（悬停格内任意位置都行，移开 / 滚动即收）。
+  - 浮层是**全表共用一个 DOM**（`v-if` + 根节点上的 `mouseover` 事件委托），常态下定时器 / 监听器 / DOM 全都不存在；落到出错格上只做一次 `getBoundingClientRect()`，且滚动即关闭、不做跟随，所以滚动路径上不会出现逐帧测量。刻意没有给每个出错格挂 Tooltip：那是每个实例两组监听器，虚拟滚动下还要随行反复挂载销毁，再叠上固定列 `sticky` 的定位与层叠，容易写出「只在某个滚动位置下错位」的问题。
+  - 委托的判定单位是**格子**（`td`）而不是事件目标的祖先链：空值格的展示 span **宽度为 0**、右对齐数字格也常只有文字那么宽，鼠标绝大多数位置落在 `td` 的内边距上，按祖先链找会静默弹不出来（实测踩到）。
+  - 有原因时该格的 `title` 会让位（原本它挂的是「值」，用于内容被省略时兜底），避免原生 tooltip 与浮层叠成两个框；`aria-label` 则拼成「金额，金额必须大于 0」供屏幕阅读器。
+- 文档（`docs/content/ui/data/table.md` 的「展示形态 `errorStyle`」与「不可改的格子」两节）同步更新。
diff --git a/code/g3soft-libs/.changeset/table-date-editor.md b/code/g3soft-libs/.changeset/table-date-editor.md
new file mode 100644
index 00000000..5758b87e
--- /dev/null
+++ b/code/g3soft-libs/.changeset/table-date-editor.md
@@ -0,0 +1,18 @@
+---
+'@g3soft/ui': minor
+---
+
+G3Table 新增日期编辑器（`editor.type: 'date'`），并为 G3DatePicker 补上无缝模式与两个对外方法。
+
+- **`editor.type: 'date'`**：点格即弹日历（不必先点输入框），也支持手输；值始终是**字符串**，不做 `Date` ↔ string 的隐式转换。
+  - `format` 同时决定面板精度与绑定值格式（默认 `YYYY-MM-DD`；写 `'YYYY-MM-DD HH:mm'` 即变成日期时间，选完要点「确定」才提交）。界面格式与存储格式不同时用 `valueFormat`。
+  - 校验 / 失败原因浮层 / 禁用灰底 / `errorStyle` 与其它编辑器完全一致，没有另开一套。
+  - 它是**唯一「只给当前格挂编辑器」**的类型：切换格时新格是重新挂载，日历才会跟着弹开。若跟着整行挂载，同行内从别的列切到日期格就不会重新挂载、面板不弹，表现为「有时弹、有时不弹」这种最难解释的不一致。顺带也更省 —— 不激活时是纯展示 span，而 DatePicker 是浮层组件。
+- **`G3DatePicker` 新增 `seamless`**：去掉触发器的 32px 下限 / 内边距 / 描边 / 圆角。与 `G3Select` 的 `seamless` 同因同解 —— 那些盒子在 Popover 内部，从表格侧写后代选择器命中不到（权重相同、顺序不可控），必须在组件自己的样式块里覆盖。不开的话 32 > 30 会把表格行顶高，看着像「格子里浮着一个小卡片」。
+- **`G3DatePicker` 新增 `defineExpose({ openPanel, commitPending })`**：前者供表格挂载后主动展开面板，后者供表格在编辑器**卸载前**把没提交的手输文本交掉。
+- **修一个「手输的日期会静默丢失」的真问题**：关闭面板时原先直接清空了内部草稿，而「点到别处」这条路径**不会**经过 `input` 的 `blur` —— 表格在 mousedown 阶段 `preventDefault`（避免点击干扰单元格选区），焦点压根没离开输入框。于是用户敲完日期点别的格，值就地消失。现在**关闭面板时先提交再收尾**；Esc 分支已在 `onKeydown` 里先把草稿清成 null，所以「按 Esc 取消」依然是取消而非提交（那个顺序不能反）。
+- 配套：playground 新增一张独立的小日期表（`table-date-wrap`）作为 e2e 宿主（没往 `table-wrap` 里加列 —— 那张表的列序被 Tab 跳格用例逐格锁着）；erp 的 `table-test` 页面把「开航日 / 截单日」两列从 `text` 换成 `date`（后者带时间精度）。
+- **手输解析不出来时不再静默丢弃**：`G3DatePicker` 新增 `invalidInput` 事件（默认无监听者，表单行为不变），表格监听它把原文**写进行数据**，再由一条内置的日期校验标红并给出原因「日期格式不正确」—— 与「金额输 0」「数量超精度」同一套立场：值不合法不等于要抹掉它。配套导出 `checkDate(value, format)`，与组件内置判定**是同一个函数**，供业务在保存前拦提交。
+  - 判定口径刻意**跟随 `G3DatePicker` 手输解析的那个 `parseDateInput`**（不是自己写一套）：否则会出现「手输时组件接受了、退回展示态又被标红」这种自相矛盾。注意**不要**换成 `parseDate` —— 它是宽松解析、会退到原生 `new Date()` 兜底，把 `2026-13-45` 这类越界文本「救活」（`parseDateInput` 里那道 `DATE_LIKE_TEXT` 保护正是拦这个的）。
+  - 顺带记录的既有口径：分隔符会被规范化（`2026/03/15` 算合法），而配了时间精度的列只给到「日」算不合法。
+- e2e 新增三条：点格弹面板并选日期写回字符串；必填校验 + 手输失焦后写回；手输非法日期时值原样保留、标红、悬停能看到原因。
diff --git a/code/g3soft-libs/.changeset/table-keyboard-arrows-enter.md b/code/g3soft-libs/.changeset/table-keyboard-arrows-enter.md
new file mode 100644
index 00000000..86e01f28
--- /dev/null
+++ b/code/g3soft-libs/.changeset/table-keyboard-arrows-enter.md
@@ -0,0 +1,25 @@
+---
+'@g3soft/ui': minor
+---
+
+G3Table 键盘：方向键显式分工（左右归输入框、上下给表格导航）、Enter 确认并下移、多行编辑器回车换行。
+
+**单击格仍直接进入编辑** —— 本组件的既有交互不变，这次只调整键盘分工与几处不符习惯的行为。
+
+- **方向键显式分工**。此前方向键**全部**被输入框吃掉（编辑器一挂上就聚焦），想改中间一位时整格跳走、想换行时又只能靠 Tab —— 两个方向都别扭。现在：
+  - **左右** → 交给输入框移动光标 / `Shift+左右` 选中文本（编辑文本的刚需，不能让出去）；
+  - **上下**（单行）→ **让给表格**导航，切到上 / 下一行的同一列**并进入编辑**（单行输入框里上下键没有任何原生用途，让出去是零损失）；
+  - `Shift+上下` → 仍归输入框（原生语义是「选中到首尾」）；
+  - `textarea` 里的上下 → 仍归输入框（要跨行移动光标）。
+  - ⚠️ 左右不能让给表格：同一个键不可能既移光标又切格。横向切换用 `Tab`（它还会跳过只读列，比按列 ±1 更贴合录入语境）。
+- **Enter（单行）= 确认 + 下移到下一行同列**（Excel / Sheets / AG Grid / Handsontable 的通行约定）。
+  - 旧行为是 `preventDefault` + `select()` —— **全选文本，且不提交**。它既不是浏览器行为（单行 `input` 的 Enter 原生是「提交表单 / 无动作」，**不换行**），也不是表格软件的行为，而且「确认」这个动作整个缺失：改完按回车值还没落库。
+  - 下一行同一列若是只读列、或那一行被按行禁用 → **跳过**，落到下面第一个可编辑格；到表尾 → **停在原地**（不循环回表头：回车一路按到底突然跳回第一行会很意外）。
+  - ⚠️ 实现上必须**显式提交**当前值：移动会让编辑器 vnode 卸载，而 DOM 元素被移除时浏览器**不派发 blur**（做日期编辑器时踩过这个坑），只靠 `onBlur` 的话敲完按回车值就丢了。
+- **Enter（`type: 'textarea'`）= 换行**（浏览器原生语义）。此前多行与单行共用同一段 `onKeydown` 且没按类型分流，导致备注这类多行格**按回车会把整段文本全选掉、根本换不了行**。
+- **`Esc` 会退出编辑态并把焦点还给该格**。此前它只让输入框失焦，而编辑态是**行级**的、那一行仍停在编辑态（表现是「Esc 一下没反应」）；更要紧的是焦点掉到 `body` —— 之后按方向键完全不经过表格，等于键盘失灵。
+- **checkbox 补上 `Space` 切换**（原生 checkbox 的切换键）；`Enter` 保留（表格用户的既有期待，连续录入时手不离 Enter）。此前只认 Enter。
+- **`date` 编辑器**按同一套分工：左右归输入框（日期是文本，用户会想改其中一段），上下给导航。
+- 配套：playground 新增 `table-keys-wrap` 小表（text / number / textarea 三列，行高给足以容纳多行编辑器）作为宿主 —— `table-wrap` 的列序被 Tab 跳格用例逐格锁着，且它里面没有多行编辑器，锁不住「单行 / 多行 Enter 语义不同」这条区分。
+- e2e 新增 7 条：方向键分工 5 条（单击即编辑 / 上下切行 / 左右移光标 / `Shift+左右` 选文本 / `textarea` 跨行）、Enter 单行确认下移、Enter 多行换行。方向键那几条断言的是**光标真的动了 / 选区真的变了**，而不只是「没跳格」。
+- 文档新增「键盘：单击即编辑，方向键分工」一节。
diff --git a/code/g3soft-libs/.changeset/table-no-vertical-lines.md b/code/g3soft-libs/.changeset/table-no-vertical-lines.md
new file mode 100644
index 00000000..5e3595b2
--- /dev/null
+++ b/code/g3soft-libs/.changeset/table-no-vertical-lines.md
@@ -0,0 +1,14 @@
+---
+'@g3soft/ui': minor
+---
+
+G3Table：表体的纵向列线关闭，表头保留一条更轻的「短竖线」列界。
+
+- **表体去掉纵向格线**：覆盖层把底座的 `--bg-border-right` / `--bg-border-left` 涂成透明渐变 —— 库给每个 `th`/`td` 铺的就是 `background-image: var(--bg-border-right), var(--bg-border-bottom)`，所以关掉这一个变量就够了。横线（`--bg-border-bottom`）与自绘圆角外框**完全不受影响**，它们走的是另外两条路径。
+  - 「按列摘线」那套已整体删除：早先为「最右列外侧线归外框管」写过 `th/td:last-child` 与右固定列的摘线规则，那个假设只在「列宽铺满容器」时成立（列宽不足时表现为「线没了 + 右侧留白」，有右固定列且横滚时更是摘错了对象）。
+- **表头保留列界，但换成「短竖线」**：`th` 自己接管 `background-image`，画一条高 `calc(100% - 8px)`（上下各留 4px）、宽 1px 的短线，颜色用新增的 `--g3-table-header-divider`（亮 8% 的黑 ≈ #e1e1e1 / 暗 12% 的白，比 `--border-color` 那档格线色轻一档）。列界仍是「认列 / 拖列宽」的落点，但在比数据行更高的表头上不会顶满上下，观感更柔和。
+  - 为什么接管**整个** `background-image` 而不是只改其中一层：`background-image` / `-size` / `-position` 都是**按层一一对应**的列表属性，而库的层数并不固定（表头首行是 top/right/bottom 三层、多级表头的其它行只有两层）——只补 size / position 会把尺寸套到错误的层上（实测把竖线铺成整格色块）。
+  - 无框模式（`bordered: false`）不受影响：规则限定在 `.stk-table.bordered` 下。
+  - 贴住外框内右缘的右固定列用 `:not(.fixed-cell--right)` 排除，避免那条线与外框 `border` 并排成 2px；「DOM 末列」不排除（它是拖拽该列宽度的落点，列宽没铺满容器时也靠它指出末列到哪儿结束）。
+- **固定列在数据区的边界改由 `fixedColShadow` 承载**：表体既无竖线，冻结列与滚过去的列又同为不透明基色、紧贴在一起，边界只剩那 10px 渐变能表达。用到左右冻结列的页面**务必**打开 `fixedColShadow`（默认仍为 `false`，不改默认值是刻意的：没有固定列的表格开它什么都画不出来；`g3soft-erp` 的订舱页早已显式开着）。
+- 同步更新：`docs/content/ui/data/table.md` 的「固定列」与「实现说明」两处；`e2e/table.spec.ts` 的两条用例（表体只剩横线一条 / 表头短竖线的尺寸、位置与色值），并顺手抽出一个 `splitCssLayers` —— 按**顶层逗号**切 CSS 列表值，替掉原先 `split(/,(?![^(]*\))/)` 那种在 `rgba(` 前会失灵的写法（它把 `linear-gradient(rgba(...), rgba(...))` 切成两层，把「两条线」数成三条）。
diff --git a/code/g3soft-libs/.changeset/table-number-precision.md b/code/g3soft-libs/.changeset/table-number-precision.md
new file mode 100644
index 00000000..2817046b
--- /dev/null
+++ b/code/g3soft-libs/.changeset/table-number-precision.md
@@ -0,0 +1,23 @@
+---
+'@g3soft/ui': minor
+---
+
+G3Table：新增 `editor.precision`（数值精度）与列级 `format`（展示格式化），并导出 `checkPrecision` / `formatNumber`。
+
+- **`editor.precision`：数值精度（小数位数）**，可传函数按行给。它同时驱动两件事，是**一处真源**：
+  - **展示**：非编辑态按精度格式化（`1200.5` → `1200.50`）；
+  - **校验**：超出精度即 error（红底 + 左侧竖条），悬停浮层显示「最多 N 位小数」—— 这是**组件内置**的规则，业务不需要写任何与精度有关的 `validate`。
+  - ⚠️ **不静默四舍五入**：用户输了 `123.456` 而精度是 2，值**仍然是** `123.456`，只是这一格被标红，由用户自己改。悄悄改成 `123.46` 会让「屏幕上的」与「落库的」不是一回事 —— 财务对账时就是「我输的不是这个」。
+  - ⚠️ **超精度时不做格式化展示**（原样裸露真实值）：按精度格式化成 `123.46` 会让屏幕完全合规、数据却不合规，用户永远发现不了自己错了。
+  - 录入时**不做实时拦截**：实时的精度过滤要与光标位置、输入法组合态、半输入态（`12.` / `-`）搏斗，是公认的坑；「输完再判」既确定又可预测。
+  - 判定用**字符串**数小数位而不是数值运算：`Math.round(v * 100) / 100` 在 `1.005` 上给出的是 `1`（`1.005 * 100 = 100.49999999999999`），而金额最容易撞上这种「看着是两位小数、二进制里不是」的值。
+- **`checkPrecision(value, precision)` 对外导出**：业务在保存前做提交拦截时必须复用**同一个函数**，否则会出现「格子红了但存档能过」这类两边不一致、又极难排查的问题。
+- **列级 `format`：展示态格式化**（只影响显示，落库值不变）。传选项对象走底座的 `formatNumber`（千分位 / `¥` 前后缀 / 万-亿缩写 / 百分比）；传函数则完全自定义（`Intl.NumberFormat` 的正解 —— 多语言的小数点与千分位符号、会计的括号负数这些 locale 规则，重写一遍必然缺选项）。小数位取 `format.decimals ?? editor.precision`。
+- **顺带解决一个缺口**：底座的 `createNumberCell` 是**纯展示**单元格，用法是 `customCell: NumberCell()`，而我们的 `resolveCustomCell` 对显式 `customCell` 是直接放行的 —— 业务一旦用它就绕过了整条编辑链路（编辑、校验、灰底、Tab 跳格、Enter/Esc 语义、草稿与失焦提交全没了）。也就是说「**可编辑的金额列**」此前没有任何合法方式做格式化展示。现在 `format` 与 `editor` 正交，两者可同时存在。
+- **门控（性能）**：`resolveCustomCell` 新增两条常驻判据 —— 配了 `precision` 的 number 列、以及配了 `format` 的**纯展示**列（后者走一个只做格式化的轻量 cell）。代价只落在**显式配了这两样**的列上，普通列照旧走库的原生 td 渲染、零组件开销。
+- 单测覆盖边界（`utils/precision.test.ts`，13 条）：空值/非数字/展示文本/科学计数法一律放行、负数符号不参与位数、`1.005` 这类浮点陷阱、非法精度配置当作没配、格式化与自定义函数的优先级。
+- **修复：右对齐列一点进编辑，文字就跳到左边。** `text-align` 本是继承属性，但**表单控件**的 UA 样式表把它覆盖成 `start` —— 实测点进金额格后 input 拿到的是 `start`（LTR 下即左对齐），于是文字与光标从右跳到左，进出编辑有明显位移（与「编辑器无缝嵌入、进出零位移」的目标正好相反）。现在表格侧按库的列对齐类（`.text-r` / `.text-c`）把 `input` / `textarea` 接回来。
+  - **没有给 `G3Input` 加 prop**：右对齐是**列**的属性（`align`），只有表格知道该不该右对齐；加在公共组件上只会多一个当前没人用的 API。将来表单里出现真实诉求再加不迟。
+  - 判据依赖库的 `.text-r` / `.text-c` 类名（实测打在 `td` 上）；库若改名这层会**静默失效**（表现只是「编辑时又变回左对齐」），代码注释里写明了排查方式。
+  - 只管 `input` / `textarea`：右对齐的 `select` 极少见，且它的对齐由触发器内部的 flex 布局决定，不是一条 `text-align` 能解决的。
+- 文档新增「数值精度与金额」一节（含保存前拦截的完整示例）。
diff --git a/code/g3soft-libs/docs/content/ui/data/table.md b/code/g3soft-libs/docs/content/ui/data/table.md
index cbae444f..3afa1b17 100644
--- a/code/g3soft-libs/docs/content/ui/data/table.md
+++ b/code/g3soft-libs/docs/content/ui/data/table.md
@@ -25,7 +25,7 @@ description: 高性能虚拟滚动表格，支持排序、固定列、多选、
 
 - **序号列与选择列已经固定在左侧**，不需要业务再配；业务列的 `fixed: 'left'` 会自动接在它们后面，`fixed: 'right'` 的列要排在 `columns` 最后。
 - **固定列必须写 `width`**：左固定列的吸附位移由「它左侧那些固定列的列宽累加」算出，缺宽度就没有位移（右固定列若不需要吸附效果可以不写，但统一写上最省心）。
-- 固定列被滚动内容遮住时才画阴影（`fixedColShadow`，默认关）。它不影响功能，但冻结列与滚过去的列底色同为白、又紧贴在一起，没有这层渐变就看不出边界在哪，业务侧建议打开。
+- **固定列的边界只剩阴影了**：表体的纵向格线已关闭（表头仍保留列界，见「实现说明」），冻结列与滚过去的列底色同为白、又紧贴在一起时，`fixedColShadow`（默认关）那 10px 渐变是唯一的边界线索。它不影响功能，但有左右冻结列时务必打开。
 
 固定列只有在**总列宽超过容器宽**时才看得出效果 —— 整表都看得见时，固定与不固定没有任何区别。
 
@@ -81,16 +81,7 @@ description: 高性能虚拟滚动表格，支持排序、固定列、多选、
 
 ## 行内编辑
 
-列上加 `editor` 即可编辑：单击单元格进入。
-
-| 按键 | 行为 |
-| --- | --- |
-| `Enter` | **全选当前内容**（便于直接覆写），不提交 |
-| `Esc` | **取消编辑**：把该行恢复到进入编辑前的值，然后退出编辑 |
-| `Tab` / `Shift+Tab` | **提交并跳到下一个 / 上一个可编辑格**（见下方「跳格」） |
-| 失焦（点别处） | **提交**并抛出 `change` |
-
-`Enter` 不做提交是刻意的：单元格里的值通常要整体替换，全选后直接输入即可，不必先手动清空。提交一律靠失焦。
+列上加 `editor` 即可编辑：**单击**单元格进入（不需要双击）。完整键位见下方「键盘：单击即编辑，方向键分工」。
 
 ### 跳格
 
@@ -114,6 +105,32 @@ Tab / Shift+Tab 只在**可编辑格**之间走动：没有 `editor` 的列、
 
 编辑器的输入值先写进内部草稿，**失焦才落库并抛出 `change`**。这样每敲一个字符不会触发父级重渲染（否则光标会丢、输入法会断）。用 `editable={false}` 可整体禁用编辑。
 
+### 键盘：单击即编辑，方向键分工
+
+**单击单元格即进入编辑**（挂上编辑器并自动聚焦，可以直接打字；同行切列时重新挂载并全选，输入即替换整格内容）。这是本组件的既有交互：少一次点击。
+
+在这个前提下，方向键必须**显式分工** —— 否则会全部被输入框吃掉，人在表格里走不动：
+
+| 按键 | 归谁 | 为什么 |
+| --- | --- | --- |
+| **左右** | 输入框（移动光标 / `Shift+左右` 选中文本） | 编辑文本的刚需：想改中间一位、想选中再覆盖 |
+| **上下**（单行） | **表格**（切到上 / 下一行的同一列，并进入编辑） | 单行输入框里上下键**没有任何原生用途**，让出去是零损失 |
+| `Shift+上下` | 输入框（选中到开头 / 结尾） | 原生的有效操作 |
+| **上下**（`textarea`） | 输入框（跨行移动光标） | 多行里那是有效操作 |
+
+其它键：
+
+| 按键 | 行为 |
+| --- | --- |
+| `Enter`（单行） | 确认 + 移到下一行同列（表尾即停，不循环） |
+| `Enter`（`textarea`） | 换行（浏览器原生语义） |
+| `Esc` | 放弃本次编辑（回滚到进入前的值），并**把焦点还给该格** —— 可以接着用上下键走 |
+| `Tab` / `Shift+Tab` | 确认并跳到下一个**可编辑**格（跳过只读列与按行禁用的格、行尾自动接下一行、两端循环） |
+| `Space`（`checkbox`） | 切换勾选（原生 checkbox 的切换键）；`Enter` 同样有效 —— 连续录入时手不用离开 Enter |
+| 失焦（点别处 / 用上下键走开） | **提交**并抛出 `change` |
+
+⚠️ **左右键不能让给表格**：它一旦用来切列，就没法在输入框里移动光标 —— 同一个键不可能既移光标又切格。横向切换请用 `Tab`（它还会跳过只读列，比按列 ±1 更贴合录入语境）。
+
 ### 编辑器形态：单元格内无外间距、无常驻边框
 
 默认（`editorSeamless`）下编辑器的**外间距为 0、自身不画常驻边框**，整格铺满、融进表格：
@@ -187,7 +204,7 @@ watch(n, (v) => { rows.value = Array.from({ length: v }, (_, i) => makeRow(i)) }
 - 整列只读 / 整列禁用的列**不会**被注入 `customCell`（走 td 上的类名），零运行时开销；
   只有「按行禁用」的列会常驻注入，代价落在这些列上；
 - 「既禁用、又校验不过」的格子显示为**灰**：既然改不了，「这里错了」提示了也没用；
-- 灰底用 `--td-bgc` 叠中性色得到，亮 / 暗主题自动跟随。
+- 灰底色是 `--td-bgc` 叠一层中性色（亮 6% / 暗 8%），亮 / 暗主题自动跟随。**它必须比斑马纹深一档**（斑马纹是 2%）：表体没有纵向列线之后，两者都是一条横带，只剩浓度能区分「这行是条纹」和「这格改不了」。
 
 <demo vue="table/editable.vue" />
 
@@ -249,13 +266,18 @@ watch(n, (v) => { rows.value = Array.from({ length: v }, (_, i) => makeRow(i)) }
 | `resizable` | `boolean` | 该列是否可拖宽；操作列 / 展开列建议设 `false` |
 | `editor` | `TableEditor<T>` | 行内编辑器，见下 |
 | `actions` | `TableAction<T>[]` | 操作列按钮 |
+| `format` | `FormatNumberOptions \| ((value, row, col) => string)` | 展示态格式化，见「数值精度与金额」 |
 | `customCell` | `(props) => VNode \| string` | 自定义单元格渲染（逃生舱），传了就不再自动包装 |
 
 ### `editor`
 
 | 字段 | 类型 | 说明 |
 | --- | --- | --- |
-| `type` | `'text' \| 'number' \| 'password' \| 'textarea' \| 'select' \| 'checkbox'` | 编辑器类型 |
+| `type` | `'text' \| 'number' \| 'date' \| 'password' \| 'textarea' \| 'select' \| 'checkbox'` | 编辑器类型 |
+| `format` | `string` | 日期格式（**只对 `date` 生效**），默认 `'YYYY-MM-DD'`。见「日期编辑器」 |
+| `valueFormat` | `string` | 绑定值格式（只对 `date`），不传时跟随 `format` |
+| `placeholder` | `string` | 占位文案（只对 `date`） |
+| `precision` | `number \| ((row) => number)` | 数值精度（小数位数），**只对 `number` 生效**。见「数值精度与金额」 |
 | `options` | `TableSelectOption[] \| ((row) => TableSelectOption[])` | select 选项，可依赖当前行其它字段 |
 | `disabled` | `boolean \| ((row) => boolean)` | 是否禁用该格编辑 |
 | `allowClear` | `boolean` | select 是否可清空，默认 `true` |
@@ -297,16 +319,129 @@ watch(n, (v) => { rows.value = Array.from({ length: v }, (_, i) => makeRow(i)) }
 
 | 值 | 效果 |
 | --- | --- |
-| `'cell'`（默认） | 单元格铺**浅红底 / 浅琥珀底**；**正在编辑的那一格例外**（见下） |
-| `'inline'` | 只在编辑器自身画文字色与 1px 内描边，**不**铺底 |
+| `'cell'`（默认） | 单元格铺**浅红底 / 浅琥珀底** + **左侧 3px 语义色竖条**；**正在编辑的那一格例外**（见下） |
+| `'inline'` | 只在编辑器自身画文字色与 1px 内描边，**不**铺底、也没有竖条 |
 
 浅红底取自设计原型，适合 ERP 明细这类以单元格为视觉单位的场景；
 若表格本身已经很密，用 `'inline'` 更克制。
 
+#### 为什么还有一条左侧竖条
+
+表体没有纵向格线（见「实现说明」），于是所有「格级」状态色都成了无边界的横带 —— 与**行级**的斑马纹 / hover / 当前行在形状上趋同，只剩色相一个通道，「这一格有问题」很容易被读成「这一段行有问题」。左侧 3px 的语义色竖条把形状还回来：**竖条 = 格级（校验），横带 = 行级（行状态）**。底色负责"远看一眼能发现"，竖条负责"看得出是哪一格"。
+
+它画在 `background-image` 上，而不是 `border` 或 `box-shadow`：
+
+- `border` 会进盒模型，td 多几 px 就把被钉在 `var(--row-height)` 的行内编辑器顶高，而行高是虚拟滚动 `translateY` 的基准；
+- `box-shadow` 是**单值**属性，在本组件里已被库的单元格选区描边、焦点环、固定列的 hover / active 叠色三家占用，谁赢谁把别人整条抹掉 —— 竖条再挤进去，就要在每一处手工合并。
+
+竖条与底色同属 `errorStyle: 'cell'`；`'inline'` 形态两者都不要。编辑态让位时（正在编辑的那一格）竖条一并消失，与底色保持一致。
+
+#### 失败原因怎么给用户看
+
+`validate` / `validateWarning` 返回的那个字符串（「金额必须大于 0」）就是失败原因。**鼠标悬停到那一格上**会弹一个自绘浮层显示它 —— 悬停格内任意位置都行，不必精确对准文字；移开或滚动即收。
+
+几件需要知道的事：
+
+- 组件**不主动弹**提示、也不拦着你往下走：底色 + 竖条负责「让你发现哪几格有问题」，浮层负责「让你知道要改成什么」，按需查看。密集录入时这是刻意的 —— 每格都弹提示会变成干扰。
+- 原生 `title` 只在**没有**校验原因时使用（它承担「内容太长被省略」的兜底）。有原因时会让位给浮层，免得两个提示框叠在一起。
+- 无障碍：有原因时该格的 `aria-label` 会拼成「金额，金额必须大于 0」，屏幕阅读器读得到。
+- 想要**保存时一次性列出所有问题**（ERP 的常见诉求），业务侧遍历 `dataSource` 自己调 `validate` 即可 —— 组件不提供 `validateAll()`，因为校验函数本来就归业务所有，包一层只是多一个 API 面：
+
+```ts
+const problems = rows.value.flatMap((row, i) =>
+  columns.value
+    .map((col) => ({ col, msg: col.editor?.validate?.(row[col.dataIndex!], row, col) }))
+    .filter((item) => typeof item.msg === 'string' && item.msg)
+    .map((item) => `第 ${i + 1} 行「${item.col.title}」${item.msg}`),
+)
+if (problems.length) message.warning(problems.join('；'))
+```
+
 **编辑态让位**（默认形态下的行为）：正在编辑的那一格**不铺校验底色**，底色回到基色，校验信号只留**语义色焦点环 + 红字**（铺着底色时输入区被染色、对比度下降，录入时「看不清」）。离开该格后底色自动回来（校验本身是按行数据派生的，值改对了自然消失）。
 
 > 早先这里还有一个右上角的 `!` 角标，**已整体去掉**（实际录入反馈）：它画的 `!` 会压到文字上 —— 右对齐的数字列最明显（数字正好顶在角标下面），而为了给它让位留出的 14px 右边距又实打实缩窄了录入区。
 
+### 数值精度与金额（`precision` / `format`）
+
+金额、数量这类数值列通常有**固定的小数位**，而且各列不同（金额 2 位、数量 3 位、汇率 6 位）。组件把这件事拆成两半：
+
+| 配置 | 管什么 |
+| --- | --- |
+| `editor.precision` | **数据的精度**（小数位数）—— 同时驱动「展示格式化」与「超精度校验」，一处真源 |
+| `col.format` | **展示细节** —— 千分位、`¥` / `元`、万-亿缩写，或 `Intl.NumberFormat` 自定义函数 |
+
+`format` 里没写 `decimals` 时取 `precision`；只有需要「显示位数 ≠ 数据精度」时才显式写它。
+
+```ts
+{
+  dataIndex: 'amount',
+  title: '金额',
+  width: 120,
+  align: 'right',
+  format: { thousands: true, prefix: '¥' },   // 展示细节
+  editor: {
+    type: 'number',
+    precision: 2,                              // 精度（可传函数按行给）
+    validate: (v) => Number(v) > 0 || '金额必须大于 0',
+  },
+}
+```
+
+用户输入 `123.456` 时会发生什么（`precision: 2`）：
+
+| | 结果 |
+| --- | --- |
+| 格子 | 红底 + 左侧竖条；悬停浮层显示「最多 2 位小数」 |
+| 显示 | `123.456` —— **不做格式化**（格式化成 `123.46` 会让屏幕合规、数据不合规） |
+| 落库的值 | `123.456` —— **组件不改你的数据**，由用户自己改成 `123.46` |
+
+三件需要知道的事：
+
+- **不静默四舍五入**是刻意的：`123.456` 悄悄存成 `123.46`，财务对账时就是「我输的不是这个」。要「自动帮你砍」的场景，业务在 `change` 里自己 round 一次即可 —— 组件不替你做这个决定。
+- **不做实时拦截**（敲到第 3 位小数就吞掉）：那要和光标位置、输入法组合态、半输入态（`12.` / `-`）搏斗，是公认的坑；「输完再判」既确定又可预测。
+- **超精度时不做格式化展示**：否则用户看到的是「合规的显示 + 不合规的数据」，永远发现不了自己错了。
+
+**保存前要拦提交**，用导出的 `checkPrecision` —— 与组件内置的是**同一个函数**，规则只有一份：
+
+```ts
+import { checkPrecision } from '@g3soft/ui'
+
+const problems = rows.value.flatMap((row, i) =>
+  columns.value.flatMap((col) => {
+    const editor = col.editor
+    if (!editor) return []
+    const precision =
+      typeof editor.precision === 'function' ? editor.precision(row) : editor.precision
+    const msg =
+      editor.validate?.(row[col.dataIndex!], row, col) ||
+      checkPrecision(row[col.dataIndex!], precision)
+    return typeof msg === 'string' && msg ? [`第 ${i + 1} 行「${col.title}」${msg}`] : []
+  }),
+)
+if (problems.length) message.warning(problems.join('；'))
+```
+
+**纯展示的金额列**（没有 `editor`）同样支持 `format`；而「小数位」这种数据层面的规则只属于可编辑列（`editor.precision`）。
+
+### 日期编辑器（`type: 'date'`）
+
+```ts
+{ dataIndex: 'etd', title: '开航日', width: 140, editor: { type: 'date' } }
+
+// 带时间精度：面板多出时间列，选完要点「确定」才提交
+{ dataIndex: 'docClose', title: '截单日', width: 140,
+  editor: { type: 'date', format: 'YYYY-MM-DD HH:mm' } }
+```
+
+- **点格即弹日历**，不必先点输入框（点格的点击落在 `td` 上，组件会主动展开面板）；也可以直接手输 `2026-03-15`。
+- **值始终是字符串**，不做 `Date` ↔ string 的隐式转换。面板精度与绑定值格式都由 `format` 决定（默认 `YYYY-MM-DD`）；界面格式与存储格式不同时写 `valueFormat`（如界面 `2026-03-15`、接口要 `20260315`）。
+- 它是**唯一「只给当前格挂编辑器」**的类型：切换格时新格重新挂载，日历才会跟着弹开。其余类型在行编辑态下整行都挂编辑器。
+- 校验、失败原因浮层、禁用灰底、`errorStyle` 与其它编辑器**完全一致**：日期列配了 `validate` 就照常出红底 + 竖条 + 悬停原因。
+- **手输解析不出来时不丢弃**：原文照常写进行数据，并走**组件内置**的日期校验 —— 红底 + 竖条 + 悬停「日期格式不正确」。这与「金额输 0」「数量超精度」是同一套立场：值不合法不等于要把它抹掉，而是要让人看见、并知道改成什么。想拦提交，用导出的 `checkDate(value, format)`，它与组件内置判定**是同一个函数**。
+- 判定口径**跟随组件**（不是另立一套）：`2026/03/15` 这种分隔符会被规范化、算合法；而配了时间精度的列只给到「日」算**不合法**（要写全 `2026-03-15 00:00`，或直接用面板点选）。
+- 列宽建议 ≥ 140，否则日期加清除按钮会挤到省略。
+- **焦点落在日历面板里**（打开即可用键盘选日期），想手输要先点一下输入框。
+
 ### `actions`
 
 | 字段 | 类型 | 说明 |
@@ -356,10 +491,10 @@ watch(n, (v) => { rows.value = Array.from({ length: v }, (_, i) => makeRow(i)) }
 - **主题通过覆盖库的 CSS 变量实现**：库把 41 个主题值都做成了 `.stk-table` 作用域内的变量，组件把它们映射到 `--g3-*` 令牌（覆盖层在 `src/table/style/_overrides.scss`）。改变量而不是逐个选择器改样式，库升级时不容易失效。
 - **区域选择按需自注册**：库的单元格区域选择是全局注册的（`registerFeature(useAreaSelection)`），不注册则 `area-selection-change` 永不触发、行内编辑失效。组件库不拥有 app 启动流程，因此**首次挂载时自动注册一次**；需要显式控制时可调用导出的 `registerTableFeatures()`。
 - **`data-testid` 透传到内层**：组件 `inheritAttrs: false`，`$attrs` 落在内层 `StkTable` 上，所以写 E2E 时按类名 `.g3-table` 定位根节点。
-- **边框：外框自绘，格线仍用底座的渐变**。组件把 `bordered` 翻成底座的 `'v'` 档（只借它的竖线），再自己补外框：
+- **边框：外框自绘，横线走底座的渐变，竖线一条都不画**。组件把 `bordered` 翻成底座的 `'v'` 档（只借它的横线），再自己补外框：
   - **外框** → 外层容器上的真 `border` + 圆角令牌（`bordered: false` 时不描边）；
   - **横线** → 把 `'v'` 档清零的 `--bg-border-bottom` 配方拿回来；
-  - **竖线** → 底座原样，只抹掉最右列那条（外侧线归外框管）。
+  - **竖线** → 表体一条不画，表头画**不占满高度的短竖线**：表体靠覆盖层把底座的 `--bg-border-right` / `--bg-border-left` 涂透明；表头则由 `th` 接管 `background-image`，画一条高 `calc(100% - 8px)`（上下各留 4px）、宽 1px 的线，颜色用比格线更轻的 `--g3-table-header-divider`（亮 8% 黑 / 暗 12% 白）。数据区因此没有纵向格线（固定列边界只剩 `fixedColShadow`，见「固定列」），表头仍一眼看得出列界与拖拽落点，又不至于顶满上下显得硬。
   为什么不全交给底座：它的外框是 `border-left` + 三段背景渐变拼的，**做不出圆角**，且其右侧 / 底部边框会因滚动条占位而消失（底座 `table/basic/bordered` 文档明确说明）。
   ⚠️ 格线**不能**改写成真 `border`：行内编辑器被钉死在 `var(--row-height)`，单元格多出 1px 边线就会被顶高 1px，而行高是虚拟滚动 `translateY` 的计算基准。背景渐变不参与盒模型。
   颜色只有 `--g3-border-color` 一个入口，亮 / 暗主题自动跟随。
diff --git a/code/g3soft-libs/packages/ui/e2e/table.spec.ts b/code/g3soft-libs/packages/ui/e2e/table.spec.ts
index 315b3799..32a03ae1 100644
--- a/code/g3soft-libs/packages/ui/e2e/table.spec.ts
+++ b/code/g3soft-libs/packages/ui/e2e/table.spec.ts
@@ -297,6 +297,7 @@ test.describe('G3Table 行内编辑：无外间距、无常驻边框', () => {
 
     const before = await rowHeights(page, '[data-testid="table-wrap"]')
 
+    // 双击进编辑（表格是「单击选中、进编辑另有其键」的两态模型，见 startEdit 的说明）
     await (await cellByTitle(page, '[data-testid="table-wrap"]', '状态')).click()
     const select = wrap.locator('.g3-table__cell-editor-root.g3-select').first()
     await expect(select).toBeVisible()
@@ -484,6 +485,105 @@ test.describe('G3Table 校验态 / 列宽拖拽 / 行高亮', () => {
     await expect(row.locator('td').nth(remarkIdx).locator('.is-editor-warning')).toHaveCount(1)
   })
 
+  /**
+   * 失败原因必须能到达用户。
+   *
+   * 背景：`resolveEditorStatus` 早先只取校验结果字符串的 `.length` 判等级、把内容丢掉 ——
+   * 业务在 `validate` 里写的失败原因（「金额必须大于 0」）因此没有任何出口，
+   * 用户只知道「这格红了」，不知道要改成什么。
+   *
+   * 这条从「内容节点上的 data 属性」一路验到「浮层真的弹出来」：属性没挂、
+   * 委托没接上、浮层被表格的 `overflow` 裁掉、文本没绑 —— 任何一环被改断都会红。
+   */
+  test('失败原因浮层：hover 出错格弹出 validate 的原因，移到普通格即收', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+
+    const rows = wrap.locator('.stk-tbody-main tr')
+    const errSpan = rows.nth(1).locator('td[data-col-key="amount"] .g3-table__cell-display')
+    const warnSpan = rows.nth(1).locator('td[data-col-key="remark"] .g3-table__cell-display')
+
+    // 原因挂在内容节点上（不是 td —— 按行变化的值打不到 td 上，见 editable.ts 的说明）
+    await expect(errSpan).toHaveAttribute('data-validate-message', '金额必须大于 0')
+    await expect(warnSpan).toHaveAttribute('data-validate-message', '建议填写备注')
+
+    // 常态下浮层压根不在 DOM 里（`v-if`）—— 这是「全表共用一个、常态零成本」的直接证据
+    const tip = page.locator('.g3-table__cell-tip')
+    await expect(tip).toHaveCount(0)
+
+    await errSpan.hover()
+    await expect(tip).toBeVisible()
+    await expect(tip).toHaveText('金额必须大于 0')
+
+    // 移到同一行的普通格（第 1 行金额是正常值）：浮层立刻收掉 ——
+    // 不能一直挂着上一格的原因
+    await rows.nth(0).locator('td[data-col-key="amount"]').hover()
+    await expect(tip).toHaveCount(0)
+
+    /**
+     * warning 走同一条通道，且**悬停格子（td）而不是那个 span**：
+     * 备注在那一行是空值，展示 span 宽度为 0，鼠标落在 td 的 padding 上 ——
+     * 这正是「按事件目标的祖先链找消息节点」会静默失效的位置。
+     * 委托改为以格子为单位反查后，这里必须能弹出来。
+     */
+    await rows.nth(1).locator('td[data-col-key="remark"]').hover()
+    await expect(tip).toHaveText('建议填写备注')
+  })
+
+  /**
+   * 数值精度（`editor.precision`）的完整行为：按精度格式化展示、超精度只标红、
+   * 且**不改数据**。
+   *
+   * playground 的「金额」列配了 `precision: 2` 与 `format: { thousands: true, prefix: '¥' }`。
+   * 这里刻意用**动态输入**造超精度值，而不是往宿主的静态数据里塞一行 ——
+   * 静态数据一改就会连带影响同页其它「error 格计数」的断言，动态输入只在本次用例内生效。
+   */
+  test('数值精度：按精度格式化展示；输多了只标红、值原样保留', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="amount"]')
+
+    // ① 展示：按 precision 补足到两位小数，叠加 format 的千分位与 ¥ 前缀
+    await expect(cell.locator('.g3-table__cell-display')).toHaveText('¥12,000.00')
+
+    /**
+     * ② 输入一个超精度的值，再点**另一个数据格**让它失焦提交。
+     *
+     * 这里不能点表头：编辑态的退出是由单元格选区变化驱动的，点表头不会退出编辑 ——
+     * 那样这一格还挂着编辑器，下面针对「展示态 span」的断言会直接找不到元素。
+     */
+    await cell.click()
+    await cell.locator('input').fill('1.2345')
+    await wrap.locator('.stk-tbody-main tr').nth(2).locator('td[data-col-key="amount"]').click()
+    await page.waitForTimeout(200)
+
+    // ③ 标红，原因是**组件内置**的（业务在这一列没写任何与精度有关的校验）
+    await expect(cell.locator('.g3-table__cell-display')).toHaveClass(/is-editor-error/)
+    await cell.hover()
+    await expect(page.locator('.g3-table__cell-tip')).toHaveText('最多 2 位小数')
+
+    /**
+     * ④ 超精度时**不做格式化展示**：按两位格式化成 `¥1.23` 会让屏幕看起来完全合规、
+     * 数据却不合规，用户永远发现不了自己错了 —— 所以这里必须是原样的 `1.2345`。
+     */
+    await expect(cell.locator('.g3-table__cell-display')).toHaveText('1.2345')
+
+    // ⑤ 值也没被四舍五入：再点开编辑，输入框里还是用户敲的那串
+    await cell.click()
+    await expect(cell.locator('input')).toHaveValue('1.2345')
+
+    /**
+     * ⑥ 编辑器的文字对齐**跟随列**（金额列是 `align: 'right'`）。
+     *
+     * 表单控件的 UA 样式把继承来的 `text-align` 覆盖成 `start`，不显式接上就会
+     * 「展示态靠右、一点进编辑就跳到左边」，光标也跟着跑到最左 —— 进出编辑的位移很扎眼。
+     */
+    await expect(cell.locator('input')).toHaveCSS('text-align', 'right')
+  })
+
   /**
    * 编辑态让位：正在编辑的校验格**不铺校验底色**，底色回到基色。
    *
@@ -603,6 +703,43 @@ test.describe('G3Table 校验态 / 列宽拖拽 / 行高亮', () => {
  * sticky 几何就会失效（表头跟着滚、分隔线错位叠线）。
  */
 test.describe('G3Table 布局：表头固定与分隔线', () => {
+  /**
+   * 按**顶层**逗号切分 CSS 列表值（`background-image` / `-size` / `-position` 都是这种）。
+   *
+   * ⚠ 不要写成 `split(/,(?![^(]*\))/)`：那种写法靠「逗号后面是否紧跟一个 `)`」判断，
+   *    一旦逗号后面是 `rgba(` 这种带括号的值就失灵 —— 括号把 `[^(]*` 截断，负向前瞻
+   *    随之成立，于是渐变**内部的**逗号（如 `linear-gradient(rgba(0,0,0,.08), rgba(0,0,0,.08))`
+   *    两个色标之间那个）被当成层分隔符，一层被切成两段（实测把「两条线」数成三条）。
+   *    括号配对计数才是可靠判据。
+   */
+  function splitCssLayers(value: string): string[] {
+    const out: string[] = []
+    let depth = 0
+    let start = 0
+    for (let i = 0; i < value.length; i++) {
+      const ch = value[i]
+      if (ch === '(') depth++
+      else if (ch === ')') depth--
+      else if (ch === ',' && depth === 0) {
+        out.push(value.slice(start, i).trim())
+        start = i + 1
+      }
+    }
+    out.push(value.slice(start).trim())
+    return out.filter(Boolean)
+  }
+
+  /** 数「真的画得出颜色」的背景层：rgb(...) 或 alpha > 0 的 rgba(...) */
+  async function visibleLineCount(locator: import('@playwright/test').Locator) {
+    const bg = await locator.evaluate((el) => getComputedStyle(el).backgroundImage)
+    return splitCssLayers(bg).filter((layer) =>
+      [...layer.matchAll(/rgba?\(([^)]+)\)/g)].some((m) => {
+        const parts = m[1].split(',').map((s) => Number(s.trim()))
+        return parts.length < 4 || parts[3] > 0
+      }),
+    ).length
+  }
+
   test('table 不被拉伸：.stk-table-main 是 flex:none（非 autoFitWidth）', async ({ page }) => {
     await page.goto('/')
     const wrap = page.locator('[data-testid="table-wrap"]')
@@ -637,7 +774,7 @@ test.describe('G3Table 布局：表头固定与分隔线', () => {
     expect(Math.abs(after!.y - before!.y)).toBeLessThan(2)
   })
 
-  test('边框自绘：库只保留竖线，横线走渐变而不是真 border', async ({ page }) => {
+  test('边框自绘：表体只剩横线走渐变，而不是真 border', async ({ page }) => {
     await page.goto('/')
     const wrap = page.locator('[data-testid="table-wrap"]')
     await wrap.scrollIntoViewIfNeeded()
@@ -646,25 +783,22 @@ test.describe('G3Table 布局：表头固定与分隔线', () => {
     const stk = wrap.locator('.stk-table').first()
     await expect(stk).toHaveClass(/bordered-v/)
 
-    /** 数「非透明的背景渐变层数」——即这一格画了几条线（不看库内部怎么拼） */
-    const lineCount = (locator: import('@playwright/test').Locator) =>
-      locator.evaluate((el) =>
-        getComputedStyle(el)
-          .backgroundImage.split(/,(?![^(]*\))/)
-          .filter((layer) => /rgb\(\d+, \d+, \d+\)/.test(layer)).length,
-      )
-
-    // 横线：`'v'` 档把 --bg-border-bottom 清零（只剩竖线一条），组件按底座配方把它
-    // 拿回来 —— 所以这里应当数出**两条**。但它**不能**是真 border：格线一进盒模型，
-    // 单元格多 1px 就会被行内编辑器顶高（行高是虚拟滚动 translateY 的基准）。
+    // 表体的竖线已被覆盖层涂透明（--bg-border-right / --bg-border-left），所以表体
+    // 每一格只剩**一条**可见渐变：组件按底座配方拿回来的那条横线。
+    // （表头是例外 —— 列界画在 th 的 background-image 上，见下一条用例。）
     const td = wrap.locator('.stk-tbody-main td').first()
-    const normalLines = await lineCount(td)
-    expect(normalLines).toBeGreaterThan(1)
-    expect(await td.evaluate((el) => getComputedStyle(el).borderBottomWidth)).toBe('0px')
+    const normalLines = await visibleLineCount(td)
+    expect(normalLines).toBe(1)
 
-    // 竖线：末列的外侧那条已被抹掉（归自绘外框管），所以比普通列**正好少一条**
+    // 末列不再「少一条」：表体竖线既然全关，末列与普通列的层数必须相等
+    // （旧断言是 normalLines - 1，那是在摘「最右列的外侧竖线」——该需求已不存在）
     const lastTd = wrap.locator('.stk-tbody-main td:last-child').first()
-    expect(await lineCount(lastTd)).toBe(normalLines - 1)
+    expect(await visibleLineCount(lastTd)).toBe(normalLines)
+
+    // 横线**不能**是真 border：格线一进盒模型，单元格多 1px 就会被行内编辑器顶高
+    // （行高是虚拟滚动 translateY 的基准）。
+    expect(await td.evaluate((el) => getComputedStyle(el).borderBottomWidth)).toBe('0px')
+    expect(await td.evaluate((el) => getComputedStyle(el).borderRightWidth)).toBe('0px')
 
     // 行高没被格线动过（30 = 默认 rowHeight，也是虚拟滚动 translateY 的基准）
     expect(
@@ -675,24 +809,47 @@ test.describe('G3Table 布局：表头固定与分隔线', () => {
     ).toBe(30)
   })
 
-  test('库自绘边框：单元格带可见的横竖渐变线', async ({ page }) => {
+  test('纵向格线：表体 td 无竖线，表头 th 的列界不占满高度且颜色更轻', async ({ page }) => {
     await page.goto('/')
     const wrap = page.locator('[data-testid="table-wrap"]')
     await wrap.scrollIntoViewIfNeeded()
 
-    // 库的 .bordered th,td 用 background-image 画 --bg-border-right / --bg-border-bottom。
-    // 这里只断言「至少有一条可见渐变线」，不锁具体层数——那是库的内部实现。
-    const layers = await wrap
-      .locator('.stk-tbody-main td')
-      .first()
-      .evaluate((el) => {
-        const bg = getComputedStyle(el).backgroundImage
-        return bg
-          .split(/,(?![^(]*\))/)
-          .map((s) => s.trim())
-          .filter((s) => /rgb\(\d+, \d+, \d+\)/.test(s) && !/rgba\(0, 0, 0, 0\)/.test(s)).length
-      })
-    expect(layers).toBeGreaterThan(0)
+    // ── 表体：一条竖线都没有（全局涂透明），只剩横线那一条。
+    // 读「变量」是因为变量就是库的输入、语义最直接，不会随库内部怎么拼 image 而失效。
+    // ⚠ 断言里**不能**出现 `var(--border-color)` 这类字面量：自定义属性的计算值会把
+    //   里面的 var() 全部替换掉（规范如此），拿到的已经是 `#d9d9d9`。
+    const td = wrap.locator('.stk-tbody-main td').first()
+    const tdVars = await td.evaluate((el) => {
+      const cs = getComputedStyle(el)
+      return {
+        right: cs.getPropertyValue('--bg-border-right').trim(),
+        left: cs.getPropertyValue('--bg-border-left').trim(),
+      }
+    })
+    expect(tdVars.right).toContain('transparent')
+    expect(tdVars.left).toContain('transparent')
+    expect(tdVars.right).not.toMatch(/rgb\(|#[0-9a-f]{3}/i)
+    expect(await visibleLineCount(td)).toBe(1)
+
+    // ── 表头：列界由组件自己接管 background-image 画（不是库的 --bg-border-right），
+    //    两层可见线 = 短竖线 + 横线。
+    const th = wrap.locator('thead th').first()
+    const thPaint = await th.evaluate((el) => {
+      const cs = getComputedStyle(el)
+      return {
+        image: cs.backgroundImage,
+        size: cs.backgroundSize,
+        position: cs.backgroundPosition,
+      }
+    })
+    expect(await visibleLineCount(th)).toBe(2)
+
+    // 不占满：竖线那层的高度是 calc(100% - 8px) —— 上下各留 4px 的呼吸位
+    expect(thPaint.size.split(',')[0].trim()).toBe('1px calc(100% - 8px)')
+    expect(thPaint.position.split(',')[0].trim()).toBe('100% 4px')
+
+    // 更轻：竖线是 8% 的黑（半透明），不是格线那种不透明色
+    expect(thPaint.image).toMatch(/rgba\(0,\s*0,\s*0,\s*0\.08\)/)
   })
 })
 
@@ -1153,6 +1310,284 @@ test.describe('G3Table 键盘跳格：Tab / Shift+Tab', () => {
  * 两个宿主覆盖两条 CSS 分支：`table-stripe-wrap`（2 行，纵向虚拟关闭 → `nth-child(even)`）
  * 与 `table-big-wrap`（5000 行 → `vt-on`，库改取 `nth-child(odd)`）。
  */
+/**
+ * 日期编辑器（`editor.type = 'date'`）。
+ *
+ * 宿主是 playground 的 `table-date-wrap` —— 单独一张小表：`table-wrap` 的列序被 Tab
+ * 跳格用例逐格锁着（amount → status → enabled → remark 的顺位），往它里面加列会连带
+ * 改一串断言。
+ *
+ * 列：订舱号(只读) / 开航日(date，默认 `YYYY-MM-DD`，配了必填校验) /
+ *     截单日(date，`'YYYY-MM-DD HH:mm'`，用来覆盖「带时间精度」的配置形态)。
+ */
+/**
+ * 方向键的分工（编辑器 vs 表格）。
+ *
+ * 本组件的交互是**单击即进入行编辑**（点一格就能直接打字，少一次点击）。在这个前提下，
+ * 方向键必须显式分工 —— 否则会全部被输入框吃掉，人在表格里根本走不动：
+ *
+ *   · **左右** → 交给输入框移动光标 / `Shift+左右` 选中文本（「想改中间一位」的刚需）；
+ *   · **上下** → 让给表格导航，切到上 / 下一行的同一列
+ *     （单行输入框里上下键**没有任何原生用途**，让出去是零损失）；
+ *   · `Shift+上下` → 仍归输入框（原生语义是「选中到首尾」）；
+ *   · `textarea` 里的上下 → 也归输入框（要跨行移动光标）。
+ *
+ * 宿主是 playground 的 `table-keys-wrap`：text / number / textarea 三列。
+ */
+test.describe('G3Table 方向键分工：左右归输入框、上下给导航', () => {
+  test('单击即进入编辑：挂上编辑器并自动聚焦', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="code"]')
+
+    await cell.click()
+    await expect(cell.locator('input')).toHaveValue('K-001')
+    await expect(cell.locator('input')).toBeFocused()
+  })
+
+  test('上下键：切到上 / 下一行的同一列（并且进编辑，可以直接接着改）', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const rows = wrap.locator('.stk-tbody-main tr')
+    const first = rows.nth(0).locator('td[data-col-key="code"]')
+
+    await first.click()
+    await page.keyboard.press('ArrowDown')
+    await expect(rows.nth(1).locator('td[data-col-key="code"] input')).toBeFocused()
+
+    // 反向同样有效（连续按能一直在这一列上下走，手不离开键盘）
+    await page.keyboard.press('ArrowUp')
+    await expect(first.locator('input')).toBeFocused()
+  })
+
+  test('左右键：在输入框内移动光标，不切格', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="qty"]')
+
+    await cell.click()
+    const input = cell.locator('input')
+    await input.fill('12345')
+
+    // 不假设 fill 之后光标落在哪，只断言「按一次左键，光标左移一位」
+    const before = await input.evaluate((el) => (el as HTMLInputElement).selectionStart)
+    await input.press('ArrowLeft')
+    const after = await input.evaluate((el) => (el as HTMLInputElement).selectionStart)
+
+    expect(after).toBe((before ?? 0) - 1)
+    await expect(input).toBeFocused()
+    // 还在同一格：左右键没有冒到表格导航上
+    await expect(cell.locator('input')).toHaveCount(1)
+  })
+
+  test('Shift+左右：留给输入框选中文本，不切格', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="code"]')
+
+    await cell.click()
+    const input = cell.locator('input')
+    // 进入编辑时编辑器会**全选**内容（为「直接输入即替换」服务），所以先记下初始选区长度
+    const before = await input.evaluate((el) => {
+      const node = el as HTMLInputElement
+      return (node.selectionEnd ?? 0) - (node.selectionStart ?? 0)
+    })
+    await input.press('Shift+ArrowLeft')
+    await input.press('Shift+ArrowLeft')
+
+    // 结果是「选区缩小了两个字符」，而不是「跳到左边那一格」
+    const after = await input.evaluate((el) => {
+      const node = el as HTMLInputElement
+      return (node.selectionEnd ?? 0) - (node.selectionStart ?? 0)
+    })
+    expect(after).toBe(before - 2)
+    await expect(input).toBeFocused()
+  })
+
+  test('textarea：上下键留给它跨行移动光标，不切格', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="note"]')
+
+    await cell.click()
+    const textarea = cell.locator('textarea')
+    await textarea.fill('第一行')
+    await textarea.press('Enter')
+    await textarea.type('第二行')
+
+    // 光标在第二行 → 按上键应当回到第一行（列号保持），而不是跳到上一行的格子里
+    await textarea.press('ArrowUp')
+    await expect(textarea).toBeFocused()
+    const caret = await textarea.evaluate((el) => (el as HTMLTextAreaElement).selectionStart)
+    // "第一行\n第二行"：第一行末尾是索引 3（"第一行" 三个字）
+    expect(caret).toBe(3)
+  })
+})
+
+/**
+ * 键盘行为：Enter 与多行编辑器。
+ *
+ *   · Enter（单行）→ 确认 + 下移到下一行同列（Excel / Sheets / AG Grid / Handsontable 的通行约定）；
+ *   · Enter（多行）→ 换行（浏览器原生；多行与单行共用一段 onKeydown，早先没按类型分流，
+ *     按回车会把整段文本全选掉、根本换不了行）。
+ *
+ * 方向键的分工（左右归输入框、上下给导航）在另一个 describe 里；宿主相同 ——
+ * `table-wrap` 的列序被 Tab 跳格用例逐格锁着，而且它里面没有多行编辑器，
+ * 锁不住「单行 / 多行 Enter 语义不同」这条区分。
+ */
+test.describe('G3Table 键盘行为：Enter 与多行编辑器', () => {
+  test('Enter（单行）：确认并下移到下一行的同一列', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const rows = wrap.locator('.stk-tbody-main tr')
+    const firstCell = rows.nth(0).locator('td[data-col-key="code"]')
+
+    await firstCell.click()
+    await firstCell.locator('input').fill('K-999')
+    await firstCell.locator('input').press('Enter')
+    await page.waitForTimeout(300)
+
+    // 值**已提交**：旧行为是「全选文本、不提交」，改完按回车值还没落库。
+    // 断言整格文本而不是 `.cell-display` —— 这一列没配 validate/precision，
+    // 非编辑态走的是库的原生 td 渲染（连我们那个 span 都没有），这是有意为之的零开销路径。
+    await expect(firstCell).toHaveText('K-999')
+    // 编辑格落到下一行的**同一列**，且焦点已经在它里面（走的是改选区那条链路）
+    await expect(rows.nth(1).locator('td[data-col-key="code"] input')).toBeFocused()
+  })
+
+  test('Enter（多行）：是换行，不是下移', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-keys-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="note"]')
+
+    await cell.click()
+    const textarea = cell.locator('textarea')
+    await textarea.fill('第一行')
+    await textarea.press('Enter')
+    await textarea.type('第二行')
+
+    // 换行符真的进去了，而且**还停在同一格**（没有跳到下一行）
+    await expect(textarea).toHaveValue('第一行\n第二行')
+    await expect(textarea).toBeFocused()
+  })
+
+})
+
+test.describe('G3Table 日期编辑器（editor.type = date）', () => {
+  test('点日期格即弹日历，选中的日期写回字符串', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-date-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const cell = wrap.locator('.stk-tbody-main tr').first().locator('td[data-col-key="etd"]')
+
+    // 展示态就是存进去的字符串，组件不做任何格式转换
+    await expect(cell.locator('.g3-table__cell-display')).toHaveText('2026-03-15')
+
+    /**
+     * ① 点格 → 自动聚焦 **且自动弹开日历面板**。
+     *
+     * 这是 `type: 'date'` 的核心交互：点格的那次点击落在 `td` 上，触发不到 DatePicker
+     * 自己的「点输入框才展开」，所以要由挂载钩子主动调它的 `openPanel()`
+     * （见 `utils/editable.ts` 的 openDatePanel）。手感与 ERP 里的日期格一致。
+     */
+    await cell.click()
+    /**
+     * 焦点**落在面板里**（CalendarPanel 的日期格是 `<button>` 且带 tabindex），
+     * 这是日历组件的常规行为：一打开就能用键盘直接选日期。
+     * 所以这里不能断言「输入框持有焦点」—— 想手输要先点一下输入框（见下一条用例）。
+     */
+    await expect(cell.locator('input')).toHaveCount(1)
+    const panel = page.locator('.g3-calendar')
+    await expect(panel).toBeVisible()
+
+    /**
+     * ② 面板里选一天 → 按 `format`（没配 valueFormat 时跟随它）写回字符串。
+     *
+     * 面板打开时定位在**当前值所在月份**，所以这一格能稳定点到同月的某一天；
+     * 空值格会落在「今天」那个月，不适合写死日期断言（那是另一条用例的事）。
+     */
+    await panel.locator('.g3-calendar__cell[data-key="2026-03-20"]').click()
+    // 选完面板自动关闭；这一格**仍在编辑态**（选值不退出编辑），所以断言输入框的值
+    await expect(panel).toBeHidden()
+    await expect(cell.locator('input')).toHaveValue('2026-03-20')
+
+    // 切到别的格退出编辑 → 展示态显示的是刚写回行数据的字符串（证明值真的落了库）
+    await wrap.locator('.stk-tbody-main tr').nth(1).locator('td[data-col-key="etd"]').click()
+    await expect(cell.locator('.g3-table__cell-display')).toHaveText('2026-03-20')
+  })
+
+  test('必填校验与手输提交：空值是 error，手输失焦后写回', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-date-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const rows = wrap.locator('.stk-tbody-main tr')
+    const empty = rows.nth(1).locator('td[data-col-key="etd"]')
+
+    // 第 2 行开航日是空串 → 列上配的 validate 判它必填，进页面就是 error
+    await expect(empty.locator('.is-editor-error')).toHaveCount(1)
+
+    // 悬停那格能看到原因：日期列同样接上了统一的那套失败原因浮层
+    await empty.hover()
+    await expect(page.locator('.g3-table__cell-tip')).toHaveText('请选择开航日')
+
+    // 手输一个合法日期，再点**另一行的日期格**让它失焦提交（DatePicker 只在「确定的时刻」emit）
+    await empty.click()
+    await empty.locator('input').fill('2026-05-01')
+    /**
+     * ⚠️ 这里必须点**可编辑格**。点只读列（订舱号）不会让编辑器失焦 ——
+     * 库在 mousedown 阶段就把只读格的事件吞了，input 一直持有焦点，
+     * 表现是「输了值但没落库」（实测踩到）。
+     */
+    await rows.nth(2).locator('td[data-col-key="etd"]').click()
+    await page.waitForTimeout(250)
+
+    await expect(empty.locator('.g3-table__cell-display')).toHaveText('2026-05-01')
+    // 值补上了，error 自然消失（校验是行数据的派生值）
+    await expect(empty.locator('.is-editor-error')).toHaveCount(0)
+  })
+
+  /**
+   * 手输非法日期。
+   *
+   * 这条锁的是「**值不丢弃**」这个决定：DatePicker 有意不为解析不出来的文本 emit
+   * （否则表单的 `v-model` 会被 `2026-13-45` 污染），表格侧在编辑器卸载时把它
+   * 原样写回行数据，再交给内置的日期校验标红 —— 与「金额输 0」是同一套立场：
+   * 值不合法不等于要抹掉它，而是要让人看见、并知道改成什么。
+   */
+  test('手输非法日期：值原样保留、标红，悬停能看到原因', async ({ page }) => {
+    await page.goto('/')
+    const wrap = page.locator('[data-testid="table-date-wrap"]')
+    await wrap.scrollIntoViewIfNeeded()
+    const rows = wrap.locator('.stk-tbody-main tr')
+    const cell = rows.first().locator('td[data-col-key="etd"]')
+
+    await cell.click()
+    await cell.locator('input').fill('2026-13-45')
+    await rows.nth(2).locator('td[data-col-key="etd"]').click()
+    await page.waitForTimeout(300)
+
+    // 上一步点第 3 行会顺手弹出它自己的日历面板 —— 那是 Teleport 到 body 的浮层，
+    // 会盖住下面要 hover 的第一行。先按 Esc 收掉（只影响刚点开的那个面板）。
+    await page.keyboard.press('Escape')
+    await page.waitForTimeout(200)
+
+    // 值原样保留（不是被丢弃成空、也不是回退成旧值），并进入 error 态
+    await expect(cell.locator('.g3-table__cell-display')).toHaveText('2026-13-45')
+    await expect(cell.locator('.is-editor-error')).toHaveCount(1)
+
+    // 原因走的是统一的那套浮层，日期列没有另做提示
+    await cell.hover()
+    await expect(page.locator('.g3-table__cell-tip')).toHaveText('日期格式不正确')
+  })
+})
+
 test.describe('G3Table 斑马纹与固定列', () => {
   /**
    * 取某一行**第一个单元格**（固定列/序号列）的底色与叠色情况。
diff --git a/code/g3soft-libs/packages/ui/playground/main.ts b/code/g3soft-libs/packages/ui/playground/main.ts
index 255b8889..8f799f19 100644
--- a/code/g3soft-libs/packages/ui/playground/main.ts
+++ b/code/g3soft-libs/packages/ui/playground/main.ts
@@ -42,6 +42,7 @@ import {
   G3Tooltip,
   G3Tree,
 } from '@g3soft/ui'
+import type { G3TableColumn, TableRow } from '@g3soft/ui'
 import '@g3soft/tokens'
 
 /**
@@ -202,8 +203,13 @@ const App = {
         title: '金额',
         width: 120,
         align: 'right',
+        // 展示：千分位 + ¥ 前缀。**小数位不写在这里**，统一由 editor.precision 给
+        format: { thousands: true, prefix: '¥' },
         editor: {
           type: 'number',
+          // 精度：两位小数。超出即 error（红底 + 左侧竖条 + 悬停浮层「最多 2 位小数」），
+          // 且**不改数据** —— E2E 用它验「输多了只标红、值原样保留」
+          precision: 2,
           // 金额必须 > 0：让「校验态全表可见」在 E2E 里有可断言的 error 数据
           validate: (v: unknown) => Number(v) > 0 || '金额必须大于 0',
         },
@@ -324,6 +330,58 @@ const App = {
      */
     const fixedActiveKey = ref<string | null>(null)
 
+    /**
+     * 日期编辑器（`editor.type = 'date'`）的宿主。
+     *
+     * 刻意**单独一张小表**，而不是往 table-wrap 里加列：那张表的列序被 Tab 跳格用例
+     * 逐格锁着（amount → status → enabled → remark 的顺位），插一列就要连带改一串断言。
+     *
+     * 两列刻意配不同格式，覆盖 `format` 的两种用法：
+     *   · 开航日 —— 默认 `YYYY-MM-DD`（面板选到「日」为止），并配必填校验；
+     *   · 截单日 —— `'YYYY-MM-DD HH:mm'`，面板会多出时间列、选完要点「确定」才提交。
+     */
+    const dateTableColumns = ref<G3TableColumn<TableRow>[]>([
+      { dataIndex: 'bookingNo', title: '订舱号', width: 120 },
+      {
+        dataIndex: 'etd',
+        title: '开航日',
+        width: 150,
+        editor: {
+          type: 'date',
+          validate: (v: unknown) => String(v ?? '').length > 0 || '请选择开航日',
+        },
+      },
+      {
+        dataIndex: 'docClose',
+        title: '截单日',
+        width: 180,
+        editor: { type: 'date', format: 'YYYY-MM-DD HH:mm' },
+      },
+    ])
+    const dateTableData = ref<TableRow[]>([
+      { id: 1, bookingNo: 'BK001', etd: '2026-03-15', docClose: '2026-03-12 18:00' },
+      // 空值行：既验 placeholder，也是「选完日期写回哪一格」的落点
+      { id: 2, bookingNo: 'BK002', etd: '', docClose: '' },
+      { id: 3, bookingNo: 'BK003', etd: '2026-04-01', docClose: '2026-03-28 12:30' },
+    ])
+
+    /**
+     * 键盘行为的宿主：三列分别覆盖「单行 text」「单行 number」「多行 textarea」。
+     *
+     * 单行与多行的 Enter 语义**不同**（确认下移 vs 换行），所以必须有一列 textarea
+     * 才能把这条区分锁住 —— table-wrap 里没有多行编辑器。
+     */
+    const keysTableColumns = ref<G3TableColumn<TableRow>[]>([
+      { dataIndex: 'code', title: '编号', width: 130, editor: { type: 'text' } },
+      { dataIndex: 'qty', title: '数量', width: 110, align: 'right', editor: { type: 'number' } },
+      { dataIndex: 'note', title: '备注（多行）', width: 260, editor: { type: 'textarea' } },
+    ])
+    const keysTableData = ref<TableRow[]>([
+      { id: 1, code: 'K-001', qty: 12, note: '第一行' },
+      { id: 2, code: 'K-002', qty: 34, note: '' },
+      { id: 3, code: 'K-003', qty: 56, note: '' },
+    ])
+
     return {
       rtl,
       toggleRtl,
@@ -337,6 +395,10 @@ const App = {
       fixedTableColumns,
       fixedTableData,
       fixedActiveKey,
+      dateTableColumns,
+      dateTableData,
+      keysTableColumns,
+      keysTableData,
       model,
       tab,
       seg,
@@ -698,6 +760,29 @@ const App = {
       <div data-testid="table-stripe-wrap" style="height: 200px; margin-top: 16px">
         <G3Table data-testid="table-stripe" :columns="plainColumns" :data-source="plainData" stripe />
       </div>
+
+      <!-- 日期编辑器（editor.type = 'date'）：点格即弹日历，值始终是字符串。
+           刻意单独一张表：table-wrap 的列序被 Tab 跳格用例逐格锁着，往它里面加列会连带改一堆断言。 -->
+      <div data-testid="table-date-wrap" style="height: 220px; margin-top: 16px">
+        <G3Table
+          data-testid="table-date"
+          :columns="dateTableColumns"
+          :data-source="dateTableData"
+          :seq="false"
+        />
+      </div>
+
+      <!-- 键盘行为的宿主：Enter 下移 / 多行换行 / 方向键归输入框。
+           同样单独一张表（理由同上），行高给足让 textarea 有地方显示多行。 -->
+      <div data-testid="table-keys-wrap" style="height: 260px; margin-top: 16px">
+        <G3Table
+          data-testid="table-keys"
+          :columns="keysTableColumns"
+          :data-source="keysTableData"
+          :seq="false"
+          :row-height="64"
+        />
+      </div>
     </section>
   </div>
   `,
diff --git a/code/g3soft-libs/packages/ui/src/date/DatePicker.vue b/code/g3soft-libs/packages/ui/src/date/DatePicker.vue
index dbd7acd0..8816072b 100644
--- a/code/g3soft-libs/packages/ui/src/date/DatePicker.vue
+++ b/code/g3soft-libs/packages/ui/src/date/DatePicker.vue
@@ -35,11 +35,20 @@ const props = withDefaults(defineProps<DatePickerProps>(), {
   disabledDate: undefined,
   timeDefault: '',
   placeholder: undefined,
+  seamless: false,
 })
 
 const emit = defineEmits<{
   'update:modelValue': [value: string]
   change: [value: string]
+  /**
+   * 手输的文本解析不出来时抛出（此时**不会** `update:modelValue`）。
+   *
+   * 默认没有任何监听者，所以表单场景的行为完全不变（非法文本不会污染 `v-model`）。
+   * 表格监听它是为了另一种取舍：它**要**把这个值写进行数据，再由自己的日期校验
+   * 标红并说明原因 —— 值不合法不等于要把它丢掉（与「金额输 0」同一套立场）。
+   */
+  invalidInput: [text: string]
 }>()
 
 const { b, e, m, is } = useNamespace('date-picker')
@@ -98,6 +107,9 @@ function submitInputText(): boolean {
   }
   if (!result.isValid || !result.date) {
     markInvalid()
+    // 把原文交给监听者（见 emits 里 invalidInput 的说明）。放在清草稿之后也不影响：
+    // text 是这一步之前就取好的局部变量。
+    emit('invalidInput', text)
     return false
   }
   commit(result.date)
@@ -198,14 +210,54 @@ function onConfirm() {
 watch(open, (value) => {
   if (value) draft.value = committed.value
   else {
-    editingText.value = null
-    invalid.value = false
+    /**
+     * 关闭面板时**先把没提交的手输文本交掉**，再收尾。
+     *
+     * 关面板最常见的原因是「点到别处」——那通常意味着用户结束了这一格的编辑，
+     * 此刻把他刚敲的日期丢掉是最糟的处理。而这条路径**不会**经过 `onBlur`：
+     * 表格在 mousedown 阶段 preventDefault（避免点击干扰选区），焦点压根没离开输入框
+     * —— 实测现象就是「敲了日期、点别的格，值没了」。
+     *
+     * ⚠️ Esc 分支（`onKeydown`）已经把 `editingText` 先清成 null 再关面板，
+     *    所以这里对「按 Esc 取消」是**空操作**。那个顺序不能反，否则取消会变成提交。
+     * ⚠️ 面板里点选日期（`onPick`）与点「确定」（`onConfirm`）都已提交过，同样是空操作。
+     * ⚠️ 注意先提交再清 `invalid`：`submitInputText` 在非法时会 `markInvalid()`，
+     *    紧接着清掉就等于用户还没看见提示就没了。
+     */
+    const submitted = submitInputText()
+    if (submitted) invalid.value = false
   }
 })
+
+/**
+ * 供表格等「点格即编辑」的场景主动展开面板。
+ *
+ * 表格里的点击落在 `td` 上（不是这个输入框），触发不到内部的 `onClick`，
+ * 所以「点日期格 → 出日历」必须由调用方显式打开：表格侧通过挂载钩子上的
+ * `vnode.component.exposed` 调它（见 `table/utils/editable.ts` 的 openDatePanel）。
+ *
+ * 只负责**打开**：关闭仍由组件自己管（选中日期、点外部、Esc 都会关）。
+ */
+defineExpose({
+  openPanel: () => {
+    if (props.disabled) return
+    open.value = true
+  },
+})
 </script>
 
 <template>
-  <div :class="[b(), { [is('disabled')]: disabled, [is('open')]: open, [is('invalid')]: invalid }]">
+  <div
+    :class="[
+      b(),
+      {
+        [is('disabled')]: disabled,
+        [is('open')]: open,
+        [is('invalid')]: invalid,
+        [is('seamless')]: seamless,
+      },
+    ]"
+  >
     <G3Popover
       :open="open"
       trigger="manual"
@@ -325,6 +377,68 @@ watch(open, (value) => {
   }
 }
 
+/**
+ * 无缝模式（`seamless`）：交给表格这类「编辑器要融进容器」的场景。
+ *
+ * 触发器的体量（32px 高 + 8px 水平内边距 + 1px 描边 + 6px 圆角）是给**表单**用的；
+ * 嵌进 30px 的表格行里就变成「一格一个悬浮小卡片」，而且 32 > 30 还会把行顶高。
+ *
+ * ⚠️ 必须写在这里，而不是外层表格样式里：触发器的真实 DOM 位置是
+ *    `div.g3-date-picker > [Popover] > span.g3-date-picker__trigger`，
+ *    从编辑器根出发的后代选择器命中不到它的 border / radius / min-height
+ *    （权重相同、顺序不可控）。与 `G3Select` 的 `is-seamless` 完全同因，
+ *    那段长注释（Select.vue 末尾）把实测证据写得更细。
+ *
+ * 只改 padding / border / radius / background，**高度交给调用方钉**（表格设成行高）。
+ */
+.#{b('date-picker')}.#{is('seamless')} {
+  /**
+   * 根容器改成 flex 拉伸。
+   *
+   * 基础样式里根是 `inline-block`，它没有能力拉伸子元素：`min-height: 0` 之后触发器
+   * 会塌到内容高度，贴着容器上沿、下方空出一截 —— 表现是「同一行里日期框比 input 偏上」。
+   * 用 `stretch` 而不是 `center`：后者只是把矮触发器居中，看着仍是「格子里浮着一个小控件」，
+   * 而 G3Input 的内层控件是被拉伸填满的（Select.vue 同一处有实测数据）。
+   */
+  display: flex;
+  align-items: stretch;
+
+  .#{e('date-picker', 'trigger')} {
+    min-height: 0;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    /**
+     * 横向间距与纯文本单元格**同源**（`--cell-padding-x`）：
+     * 编辑 / 展示切换时文字不会左右跳，也与 input / select 两个编辑器对齐。
+     */
+    padding: 0 var(--cell-padding-x, #{v('space-2', 8px)});
+    /* 撑满容器：与 G3Input 内层控件的拉伸行为对齐 */
+    width: 100%;
+    height: auto;
+
+    /* hover 不再靠描边提示（已经没有边框可变了） */
+    &:hover {
+      border-color: transparent;
+    }
+  }
+
+  /**
+   * 展开态与「手输非法」态都不在触发器上画框。
+   *
+   * 焦点环统一由外层单元格承担（`td:focus-within` 的 inset 环），这里再画一圈就会
+   * 在格内形成**第二个框** —— 正是用户反馈过的「编辑器上还有边框」。
+   * 至于手输非法：表格侧的校验信号是「红底 + 左侧竖条 + 悬停浮层」，
+   * 触发器自己再描一圈红边是多余的（而且这一列未必配了 error 样式）。
+   */
+  &.#{is('open')} .#{e('date-picker', 'trigger')},
+  &.#{is('invalid')} .#{e('date-picker', 'trigger')} {
+    border-color: transparent;
+    box-shadow: none;
+    outline: none;
+  }
+}
+
 .#{e('date-picker', 'clear')} {
   display: inline-flex;
   align-items: center;
diff --git a/code/g3soft-libs/packages/ui/src/date/types.ts b/code/g3soft-libs/packages/ui/src/date/types.ts
index 7b425a70..f67732fb 100644
--- a/code/g3soft-libs/packages/ui/src/date/types.ts
+++ b/code/g3soft-libs/packages/ui/src/date/types.ts
@@ -26,6 +26,14 @@ export interface DatePickerProps {
   timeDefault?: DateTimeDefault
   /** 占位文案；不传则不显示占位文案 */
   placeholder?: string
+  /**
+   * 无缝模式：交给表格这类「编辑器要融进容器」的场景。
+   *
+   * 触发器的体量（32px 高 + 8px 水平内边距 + 1px 描边 + 6px 圆角）是给**表单**用的，
+   * 嵌进 30px 的表格行里会变成「一格一个悬浮小卡片」，而且 32 > 30 会把行顶高。
+   * 打开后只去掉外间距与常驻边框，**高度由调用方钉**。
+   */
+  seamless?: boolean
 }
 
 export interface RangePickerProps {
diff --git a/code/g3soft-libs/packages/ui/src/table/G3Table.vue b/code/g3soft-libs/packages/ui/src/table/G3Table.vue
index 9bb8c5fe..165db8dd 100644
--- a/code/g3soft-libs/packages/ui/src/table/G3Table.vue
+++ b/code/g3soft-libs/packages/ui/src/table/G3Table.vue
@@ -48,6 +48,7 @@ import {
   nextTick,
   onBeforeUnmount,
   onMounted,
+  reactive,
   ref,
   shallowRef,
   useSlots,
@@ -56,6 +57,7 @@ import {
 import { StkTable } from 'stk-table-vue'
 import type { StkTableColumn } from 'stk-table-vue'
 import { useNamespace } from '../_composables/useNamespace'
+import { nextZIndex, releaseZIndex } from '../_utils/z-index'
 import { createSelectionColumn, isSelectionColumn, SELECTION_COLUMN_KEY } from './utils/selection'
 import {
   DRAG_ROW_COLUMN,
@@ -66,7 +68,7 @@ import {
   resolveSeqConfig,
   stripInternalColumns,
 } from './utils/column'
-import { findAdjacentEditableCell } from './utils/editable'
+import { findAdjacentEditableCell, findCellBelow } from './utils/editable'
 import type { EditableContext } from './utils/editable'
 import type {
   G3TableColumn,
@@ -657,6 +659,20 @@ const editingCtx: EditableContext<TableRow> = {
     tabJumpPendingUntil = 0
     return true
   },
+  /**
+   * Esc：退出编辑态回到就绪态。
+   *
+   * 顺带把焦点**还给单元格**：Esc 之后用户往往还想用方向键接着走（Excel 同此）。
+   * 不还的话焦点会掉到 `body` —— 下一次按键压根不经过表格，表现就是「Esc 之后
+   * 方向键失灵、连打字也进不了编辑」。用 `td[data-cs-s]`（库标在选中格上的属性）
+   * 找回那一格，它带 `tabindex="-1"`，可以编程聚焦。
+   */
+  exitEditing: () => {
+    clearActiveEditing()
+    nextTick(() => {
+      rootRef.value?.querySelector<HTMLElement>('td[data-cs-s]')?.focus?.({ preventScroll: true })
+    })
+  },
   onEditorFocus: (row) => {
     const state = getRowEditingState(row)
     if (state?.value) state.value = { ...state.value, focused: true }
@@ -703,6 +719,46 @@ const editingCtx: EditableContext<TableRow> = {
       { scrollToView: false },
     )
   },
+  /**
+   * Enter 确认后往下走一格 —— 移到**下一行的同一列**（跳过不可编辑的行）。
+   *
+   * 与 Tab 跳格同一种做法：**改选区**而不是直接 activateEditing，让底座的
+   * `area-selection-change` 链路去负责激活编辑、定位并聚焦编辑器、滚动进视口。
+   * 鼠标点击 / Tab / Enter 三条路径因此共用同一条链路，不会各写一套而行为分叉。
+   *
+   * `scrollToView` 保持默认（要滚）：回车是「往下一行走」，目标可能已经在视口外，
+   * 这与复选框那条「本来就在眼前」的场景不同。
+   */
+  moveToCellBelow: (row, col) => {
+    if (!props.editable) return false
+    const rows = (tableRef.value?.getTableData?.() ?? props.dataSource) as TableRow[]
+    const rowIndex = rows.findIndex(
+      (item) => item === row || String(getRowKey(item)) === String(getRowKey(row)),
+    )
+    const colIndex = displayColumns.value.findIndex((item) => item.dataIndex === col.dataIndex)
+    if (rowIndex < 0 || colIndex < 0) return false
+
+    const target = findCellBelow(rows, displayColumns.value, { rowIndex, colIndex })
+    // 表尾 / 下面全是不可编辑行：返回 false，编辑器原地不动（不循环回表头）
+    if (!target) return false
+
+    /**
+     * 先改选区（让库把「滚动进视口、当前行、命中测试」都处理好），**再显式进编辑**。
+     *
+     * 为什么不能只靠选区那一步：就绪态模型下 `handleAreaSelectionChange` 对鼠标 / 方向键
+     * 只负责「选中」，不再激活编辑。而 Enter 的语义是「确认，并去下一行**继续改**」——
+     * 它是唯一一个「移动 + 进编辑」的键，所以这一步得自己补上
+     * （方向键是纯移动，Tab 由它自己的链路处理）。
+     */
+    tableRef.value?.setAreaSelection?.({ begin: { row: target.rowIndex, col: target.colIndex } })
+    const nextRow = rows[target.rowIndex]
+    const nextCol = displayColumns.value[target.colIndex]
+    if (nextRow && nextCol?.editor) {
+      activateEditing(nextRow, nextCol.dataIndex)
+      tableRef.value?.setCurrentRow?.(nextRow, { silent: true })
+    }
+    return true
+  },
   /**
    * Esc 回滚：把该行所有可编辑列恢复到进入编辑态时的值。
    *
@@ -1173,8 +1229,15 @@ function handleAreaSelectionChange(ranges: unknown[]) {
     return
   }
 
-  // 非键盘导航（鼠标点击等）：立即激活。同行切换列时编辑器重挂载并恢复焦点+全选
-  // （直接输入即替换整格内容）；点击已聚焦编辑器内部则由原生行为定位光标。
+  /**
+   * 鼠标点击：**立即进入编辑**（本组件的既有交互：点一格就能直接打字，少一次点击）。
+   *
+   * 编辑器挂上并自动聚焦；同行切列时重挂载并全选（直接输入即替换整格内容）；
+   * 点击已聚焦的编辑器内部则由原生行为定位光标。
+   *
+   * 方向键的分工不在这一层，而在编辑器自己的 `onKeydown`：
+   * **左右归输入框移光标、上下让给表格导航**（见 editable.ts 的 createInput）。
+   */
   pendingEditingTarget = null
   clearEditActivateTimer()
   activateEditing(row, focusCol)
@@ -1418,6 +1481,141 @@ function handleDocumentTab(event: KeyboardEvent) {
   )
 }
 
+/* ---------- 校验原因浮层（全表共用一个） ---------- */
+
+/**
+ * 表格里的「格级」状态很多，但**原因**只在悬停时才需要 —— 所以不给每个出错格挂一个
+ * 浮层组件：密集表里那是几百个实例、每个两组监听器，虚拟滚动下还要随行反复挂载销毁，
+ * 再叠上固定列 sticky 的定位与层叠，足够写出一串「只在某个滚动位置下错位」的 bug。
+ *
+ * 改为在**表格根节点上做一次事件委托**，全表共用一个浮层 DOM。代价：
+ *   · 常态下：定时器 / 监听器 / 浮层 DOM 全都不存在（`v-if` + 只在打开期间挂关闭监听）；
+ *   · 鼠标划过任何元素：一次 `closest()` + 一次引用比较（同一格内移动直接返回）；
+ *   · 落到出错格上：一次 `getBoundingClientRect()`；滚动即关闭、**不做跟随**，
+ *     所以滚动路径上永远不会出现逐帧测量。
+ *
+ * 消息来源是内容节点上的 `data-validate-message`（见 utils/editable.ts）—— 挂在
+ * 展示 span / 编辑器根节点上而不是 `td`，因为按行变化的东西打不到 td 上
+ * （库渲染 td 时只认 `col.className`，那是整列常量，与灰底标记同理）。
+ */
+/** 悬停多久才弹：比原生 title（约 1s）快得多，又不至于划过就闪 */
+const CELL_TIP_DELAY_MS = 150
+/** 浮层与锚点格子的间距 */
+const CELL_TIP_GAP = 6
+/** 浮层单行高度（px）。真实高度要渲染完才知道，判定上下方向时按它粗估 */
+const CELL_TIP_HEIGHT = 28
+
+const cellTip = reactive({
+  open: false,
+  message: '',
+  x: 0,
+  y: 0,
+  /** true = 挂在格子下方，false = 上方 */
+  below: false,
+  zIndex: 0,
+})
+let cellTipTimer: ReturnType<typeof setTimeout> | undefined
+/**
+ * 当前浮层对应的**格子**（td）：用来跳过「同一格内反复 mouseover」的重复触发。
+ * 用格子而不是消息节点做标识，是因为委托的判定单位就是格子（见下面那个函数）。
+ */
+let cellTipCell: HTMLElement | null = null
+
+const cellTipStyle = computed(() => ({
+  left: `${cellTip.x}px`,
+  top: `${cellTip.y}px`,
+  zIndex: cellTip.zIndex,
+  // 水平居中在格子上（对齐锚点中心），垂直方向按方向上/下翻
+  transform: cellTip.below ? 'translate(-50%, 0)' : 'translate(-50%, -100%)',
+}))
+
+function unbindCellTipDismiss() {
+  window.removeEventListener('scroll', closeCellTip, true)
+  window.removeEventListener('resize', closeCellTip)
+}
+
+function closeCellTip() {
+  clearTimeout(cellTipTimer)
+  cellTipTimer = undefined
+  cellTipCell = null
+  if (!cellTip.open) return
+  cellTip.open = false
+  releaseZIndex(cellTip.zIndex)
+  cellTip.zIndex = 0
+  unbindCellTipDismiss()
+}
+
+function showCellTip(anchor: HTMLElement, message: string) {
+  // 元素已被虚拟滚动回收 / 已换行：此时 rect 会全 0，别弹
+  if (!anchor.isConnected) return
+  const rect = anchor.getBoundingClientRect()
+  if (rect.width === 0 && rect.height === 0) return
+
+  cellTipCell = anchor
+  cellTip.message = message
+  /**
+   * 上下方向：**上方放得下、且不会压住表头**才朝上。
+   *
+   * 表头是 sticky 的，数据第一行的正上方就是表头 —— 朝上会把列名整个盖掉，
+   * 而用户恰恰是盯着列名在找提示（截图里实测过：第一行的提示正好糊在「金额」上）。
+   * 所以把表头下沿也算进「上方可用空间」，装不下就翻到格子下方。
+   *
+   * `Math.max(…, 0)` 兜住「表头已滚出视口」的情况：那时只受视口顶部约束，
+   * 否则拿到的负值会让判据永远成立、提示一直挂在下方。
+   */
+  const header = rootRef.value?.querySelector('thead') as HTMLElement | null
+  const topLimit = Math.max(header?.getBoundingClientRect().bottom ?? 0, 0)
+  cellTip.below = rect.top - CELL_TIP_GAP - CELL_TIP_HEIGHT < topLimit
+  cellTip.x = rect.left + rect.width / 2
+  cellTip.y = cellTip.below ? rect.bottom + CELL_TIP_GAP : rect.top - CELL_TIP_GAP
+  // 层级走统一的 popup 档：表格若在 Modal 里，提示也要浮在弹窗之上
+  cellTip.zIndex = nextZIndex('popup')
+  cellTip.open = true
+
+  /**
+   * 关闭监听只在**打开期间**挂着 —— 常态下滚动路径上没有任何监听器。
+   * capture：表格的滚动容器不冒泡到 window，必须捕获阶段才收得到；
+   * passive：明确告诉浏览器这里不会 preventDefault，不阻塞滚动。
+   */
+  window.addEventListener('scroll', closeCellTip, { capture: true, passive: true })
+  window.addEventListener('resize', closeCellTip, { passive: true })
+}
+
+/** 事件委托入口：挂在根节点上（`mouseover` 会冒泡） */
+function handleCellTipMouseOver(event: MouseEvent) {
+  const cell = (event.target as HTMLElement | null)?.closest?.('td') as HTMLElement | null
+  // 鼠标在表头 / 表格空白处：收掉
+  if (!cell) {
+    closeCellTip()
+    return
+  }
+  // 同一格内移动会反复触发 mouseover —— 直接返回，连 querySelector 都省掉
+  if (cell === cellTipCell) return
+
+  /**
+   * 在**格子内**找消息节点，而不是从事件目标沿祖先链往上找。
+   *
+   * 这是实测踩出来的：备注列那种空值格的展示 span **宽度为 0**，右对齐的数字格
+   * 也常只有文字那么宽 —— 鼠标绝大多数位置落在 `td` 的 padding 上，此时
+   * `event.target` 就是 td 本身，祖先链里根本没有 `data-validate-message`
+   * （它挂在 span / 编辑器根上，见 editable.ts 的说明），浮层永远弹不出来。
+   * 以「格子」为单位反查，鼠标落在格内任何位置都能命中。
+   */
+  const node = cell.querySelector('[data-validate-message]') as HTMLElement | null
+  // 这一格没有校验态：立刻收掉，否则会一直挂着上一格的原因
+  if (!node) {
+    closeCellTip()
+    return
+  }
+
+  const message = node.getAttribute('data-validate-message') || ''
+  clearTimeout(cellTipTimer)
+  // 先记下格子：延迟期间移到别的出错格会重开计时，移到普通格则由上面那条收掉。
+  // 锚点用**格子**而不是那个 span：窄 span 会让浮层水平偏到一边。
+  cellTipCell = cell
+  cellTipTimer = setTimeout(() => showCellTip(cell, message), CELL_TIP_DELAY_MS)
+}
+
 /* ---------- 生命周期 ---------- */
 
 onMounted(() => {
@@ -1469,6 +1667,8 @@ onBeforeUnmount(() => {
   removeNavigationListeners()
   clearEditActivateTimer()
   pressedNavigationKeys.clear()
+  // 浮层可能正开着（连同它的定时器与 scroll / resize 监听一起收拾干净）
+  closeCellTip()
 })
 
 // 数据被父级刷新后，行对象可能整体换新，编辑态需随 key 迁移
@@ -1634,6 +1834,8 @@ const fixedPatchOff = (() => {
     ]"
     data-slot="table"
     @keydown.capture="handleKeydownCapture"
+    @mouseover="handleCellTipMouseOver"
+    @mouseleave="closeCellTip"
   >
     <StkTable
       ref="tableRef"
@@ -1678,6 +1880,19 @@ const fixedPatchOff = (() => {
         <div :class="e('empty')" role="status">暂无数据</div>
       </template>
     </StkTable>
+
+    <!--
+      校验原因浮层（全表共用一个）：显示哪个格子的原因由根节点上的 `mouseover`
+      委托切换，见 script 的「校验原因浮层」一节。
+      Teleport 到 body 有两个理由：表格根节点上是 `overflow: hidden`（留着会被裁），
+      而且浮层是 `position: fixed`，留在表格里会形成新的层叠上下文。
+      主题令牌定义在 `html` 上，所以亮 / 暗跟随不受 Teleport 影响。
+    -->
+    <Teleport to="body">
+      <div v-if="cellTip.open" :class="e('cell-tip')" :style="cellTipStyle" role="tooltip">
+        {{ cellTip.message }}
+      </div>
+    </Teleport>
   </div>
 </template>
 
@@ -1695,7 +1910,10 @@ const fixedPatchOff = (() => {
 /* 边框：`bordered` 只翻译成底座的档位（true → 'v'，false → false），真正的
    圆角外框与「横线怎么补回来」都在 `style/_overrides.scss` 的「边框」一节 ——
    为什么外框不再交给底座（做不出圆角、右侧底部边框被滚动条吃掉）、为什么格线
-   不能用真 border（会把行撑高 1px），都写在那一节，别在这里重复。 */
+   不能用真 border（会把行撑高 1px），都写在那一节，别在这里重复。
+   纵向列线的设计决定：**表体一条不画，表头画一条不占满高度的短竖线**。
+   覆盖层把底座的 --bg-border-right / --bg-border-left 对表体涂透明，表头则由 th
+   自己接管 background-image（短线 + 更轻的列界色），不在这里按列摘线。 */
 
 .#{e('table', 'inner')} {
   width: 100%;
@@ -1767,7 +1985,8 @@ const fixedPatchOff = (() => {
 .#{e('table', 'inner')}.stk-table {
   .#{e('table', 'cell-editor-root')} {
     &.g3-input,
-    &.g3-select {
+    &.g3-select,
+    &.g3-date-picker {
       width: 100%;
       /**
        * 高度必须显式钉死为行高，不能只靠 `height: 100%` 撑：
@@ -1889,7 +2108,8 @@ const fixedPatchOff = (() => {
        所以内部盒子的描边 / 圆角一律在各自组件的样式块里用 seamless 修饰类去掉
        （见 Select.vue 的 is-seamless 与 G3Select 的 seamless prop）。 */
     &.g3-input,
-    &.g3-select {
+    &.g3-select,
+    &.g3-date-picker {
       padding: 0 !important;
       border: 0 !important;
       border-radius: 0 !important;
@@ -1980,7 +2200,8 @@ const fixedPatchOff = (() => {
      * hover 只是"这里可编辑"的轻提示，主色描边会与焦点环混淆。
      */
     &.g3-input:not(.#{m('input', 'disabled')}):hover,
-    &.g3-select:hover {
+    &.g3-select:hover,
+    &.g3-date-picker:not(.g3-date-picker--disabled):hover {
       outline: 1px solid var(--border-color, #{v('border-color', #d9d9d9)});
       outline-offset: -1px;
     }
@@ -2082,6 +2303,50 @@ const fixedPatchOff = (() => {
         var(--td-bgc, #{v('bg-container', #fff)})
       );
 
+      /**
+       * ── 左侧语义色竖条：表体没有列线后，「格级状态」需要自己的形状 ──
+       *
+       * 为什么补它：列线（--bg-border-right）还在的时候，校验底色被格线围成一个
+       * 闭合矩形，与「一整条行级横带」（斑马纹 / hover / 当前行）形状天然不同 ——
+       * 眼球不必比色值就知道这是「某一格」还是「某一行」。表体的列线去掉之后，
+       * 校验底色也退化成无边界的横带，只剩色相一个通道，
+       * 「这一格有问题」很容易被读成「这一段行有问题」。
+       * 左侧 3px 竖条把形状还回来：**竖条 = 格级，横带 = 行级**，各走各的通道。
+       *
+       * 为什么走 background-image，而不是真 border 或 box-shadow：
+       *   · 真 border 进盒模型 —— td 多出几个 px，被钉在 var(--row-height) 的
+       *     行内编辑器就把整行顶高，而行高是虚拟滚动 translateY 的基准
+       *     （见 _overrides.scss 的「格线绝对不能用真 border」一节）；
+       *   · box-shadow 在本组件里已被三家占用：库的单元格选区描边、本文件的焦点环、
+       *     固定列的 hover / active 叠色（_overrides.scss 的 $cs-border 就是为把
+       *     选区描边缝进同一条声明而存在的）。它是**单值**属性，谁的规则赢了谁把
+       *     别人整条抹掉 —— 竖条再挤进去，就要在普通格 / 固定列 / hover / active /
+       *     编辑态每一处手工合并，漏一处就是「只有固定列的选中格缺竖条」这类
+       *     极难定位的 bug。
+       *   background-image 与它们**完全正交**：竖条画在背景层，box-shadow 照旧画在
+       *   盒边，谁也不用让谁。
+       *
+       * 后两层是库的格线：第 2 层（竖线）已被我们全局涂透明、实际画不出东西，
+       * 留着是因为 `background-image` 是**按层一一对应**的列表属性 —— 写全三层，
+       * 第 3 层那条横线才不会被顶掉。`background-size` 同理必须给满三个值，
+       * 只写一个会被循环套用到所有层上（库那两层会被压成 3px 宽，表头那次踩过）。
+       *
+       * 变量带 `none` 兜底：库若改版删掉这两个变量，缺省值会让整条
+       * `background-image` 变成 guaranteed-invalid 而**整体**失效（连竖条一起没），
+       * 有兜底就只是少一条线。
+       *
+       * `background-origin` 必须按层写：默认是 padding-box，而表体纯文本格有
+       * `--cell-padding-x`（12px）内边距 —— 按默认值竖条会飘在距格左缘 12px 的地方。
+       * 只把**第 1 层**改成 border-box，库那两层保持原样（否则会顺带改掉横线的绘制
+       * 区域，校验格与相邻普通格的行线就对不上了）。
+       */
+      background-image:
+        linear-gradient($color, $color),
+        var(--bg-border-right, none),
+        var(--bg-border-bottom, none);
+      background-size: 3px 100%, 100% 100%, 100% 100%;
+      background-origin: border-box, padding-box, padding-box;
+      background-repeat: no-repeat;
     }
 
     /**
@@ -2301,12 +2566,13 @@ const fixedPatchOff = (() => {
  * 权重这里同样要压过亮色规则（亮色那条是 `.g3-table .g3-table__inner.stk-table …`
  * = (0,6,2)，本条多了 `.dark` = (0,7,2)，无条件取胜，与顺序无关）。
  *
- * 比例换成「基色 + 白 4%」而不是「基色 + 黑 3%」：
- * 亮色下 3% 的黑能压暗白底；但暗色底已经是 #141414，再叠黑等于没叠
+ * 比例换成「基色 + 白 8%」而不是「基色 + 黑 6%」：
+ * 亮色下 6% 的黑能压暗白底；但暗色底已经是 #141414，再叠黑等于没叠
  * （叠完还是 #141414，肉眼零差异——灰底彻底不可见）。
  * 暗色下要表达「比底色暗一档」，物理上必须**提亮**，
- * 所以前景取 text-1（暗色下是 rgba(255,255,255,.88)），4% ≈ 亮色 3% 的感知强度。
- * 这正是用令牌而非写死 rgba(0,0,0,.03) 的价值：方向由主题自动决定。
+ * 所以前景取 text-1（暗色下是 rgba(255,255,255,.88)），8% 对应亮色 6% 的感知强度。
+ * （暗色的斑马纹是 4% 的白，这里同样要与它拉开一档，理由见亮色那段的说明。）
+ * 这正是用令牌而非写死 rgba(0,0,0,.06) 的价值：方向由主题自动决定。
  */
 .#{b('table')} .#{e('table', 'inner')}.stk-table.dark {
   /* ⚠️ 判据必须与亮色规则**完全一致**（同样的两个来源、同样的类名）。
@@ -2318,9 +2584,14 @@ const fixedPatchOff = (() => {
     td:has(> .#{e('table', 'cell-display')}.#{e('table', 'cell-readonly')}) {
     background-color: color-mix(
       in srgb,
-      v('text-1', rgba(255, 255, 255, 0.88)) 4%,
+      v('text-1', rgba(255, 255, 255, 0.88)) 8%,
       var(--td-bgc, #{v('bg-container', #141414)})
     );
+
+    /* 同亮色那条：把校验竖条一起收掉（暗色不写就会「亮色是纯灰、暗色留一条红条」，
+       正是本文件反复踩过的「只改一半」）。 */
+    background-image: var(--bg-border-right, none), var(--bg-border-bottom, none);
+    background-size: 100% 100%, 100% 100%;
   }
 }
 
@@ -2366,15 +2637,30 @@ const fixedPatchOff = (() => {
  *
  * ── 与其它状态的优先级 ──
  *
- * 底色都落在 `background-color` 上，本规则权重（(0,6,1) 起）高于校验态的红 / 黄底
- * （(0,4,1)），所以「既禁用、又校验不过」的格子显示为**灰**。这是刻意的：
+ * 状态色都落在 `background-color` 上，本规则写在**校验态规则之后**且权重不低于它，
+ * 所以「既禁用、又校验不过」的格子显示为**灰**。这是刻意的：
  * 既然这一格改不了，「这里错了」提示了也没用，用户只能去找上游数据。
  *
+ * ⚠️ 这里别按注释里的旧权重数字推断（旧文写的是「本规则 (0,6,1) 高于校验态 (0,4,1)」）：
+ *    校验态的选择器带 `:has()`，它的特异性等于**参数中最高者**，按行禁用那条
+ *    与校验态实测同为 (0,7,1) —— 胜负实际由「谁写在后面」决定。改这两条规则的
+ *    顺序前先确认这一点。
+ *
+ * ⚠️ 校验态的竖条加在 `background-image` **第 1 层**上，而 background-image
+ *    不能按层覆盖 —— 本规则必须显式写回库那两层格线（见下），
+ *    否则灰底上会留着一条红 / 黄竖条，「显示为灰」就破了一半。
+ *
  * 取色：亮色下原型是写死的 `#f8fafc`，这里改用 `--td-bgc` 叠一层中性黑，
  * 好处是暗色自动跟随（`--td-bgc` 已由覆盖层映射成 bg-container，
  * 亮 #fff / 暗 #141414），不必再手写一份暗色常量。
- * 比例 3%：2% 在浅灰表头(#f5f5f5)旁边几乎看不出，
- * 5% 又重到像「禁用」，3% 刚好形成「比白底暗、比表头浅」的中间层。
+ * 比例 6%（**表体列线去掉之后从 3% 提上来的**）：
+ * 灰底与斑马纹都是「无边界横带」，两者只能靠亮度区分 —— 而斑马纹是
+ * `--stripe-bgc`（2% 的黑 ≈ #fafafa），3% 的灰底 ≈ #f7f7f7，两者差约 1%，
+ * 中间还隔着一行白，肉眼基本分不出「这行是斑马纹」还是「这格改不了」。
+ * 以前有列线时靠「矩形 vs 长带」的形状差异兜着，列线去掉后这层保障没了，
+ * 只能靠浓度拉开：6% ≈ #efefef，与斑马纹 2% 差出可辨的一档。
+ * （与表头的 #f5f5f5 数值接近但不会混：表头是不透明实色 + 更重的字，
+ * 且两者在垂直方向上永远相邻、可以直接对比。）
  * （此比例为观感推定的档位，非实测调优值，以实际观感为准。）
  *
  * ── 为什么**不**限定 `is-editor-seamless` ──
@@ -2399,9 +2685,19 @@ const fixedPatchOff = (() => {
     td:has(> .#{e('table', 'cell-display')}.#{e('table', 'cell-readonly')}) {
     background-color: color-mix(
       in srgb,
-      v('text-1', rgba(0, 0, 0, 0.88)) 3%,
+      v('text-1', rgba(0, 0, 0, 0.88)) 6%,
       var(--td-bgc, #{v('bg-container', #fff)})
     );
+
+    /* 既「改不了」又「校验不过」的格子：连校验竖条一起收掉。
+       优先级本来由「灰底规则写在后面 + 权重不低」决定（旧行为靠这个顺序赢下
+       background-color），但竖条是校验态加在 `background-image` **第 1 层**上的 ——
+       background-image 不能按层覆盖，只改 background-color 的话，灰底上会留一条
+       红 / 黄竖条，与「既然改不了就别再提示这里错了」的既有决策冲突。
+       所以这里显式写回库那两层格线（无竖条）。
+       ⚠️ 不能图省事写 `background-image: none` —— 那会把行分隔线一起抹掉。 */
+    background-image: var(--bg-border-right, none), var(--bg-border-bottom, none);
+    background-size: 100% 100%, 100% 100%;
   }
 
   /**
@@ -2551,6 +2847,71 @@ const fixedPatchOff = (() => {
   }
 }
 
+/* ---------- 编辑器文字对齐跟随列 ---------- */
+
+/**
+ * 列右对齐（库把它落成 td 上的 `.text-r`）时，编辑器里的文字也要右对齐。
+ *
+ * 为什么必须显式写：`text-align` 本是**继承**属性，但**表单控件**的 UA 样式表给
+ * input / textarea 设了 `text-align: start`，其优先级高于继承 —— 实测点进金额格后
+ * input 拿到的是 `start`（LTR 下即左对齐），于是文字与光标从右边跳到左边，
+ * 进出编辑的位移很扎眼（与「编辑器无缝嵌入单元格、进出零位移」的目标正好相反）。
+ *
+ * 为什么放在表格侧而不是给 G3Input 加 prop：右对齐是**列**的属性（`align`），
+ * 只有表格知道；G3Input 自己无从判断该不该右对齐。将来表单里若有真实诉求，
+ * 再给 Input 加通用 prop 也不迟 —— 现在加只是让公共组件多一个没人用的 API。
+ *
+ * ⚠️ 判据用库的列对齐类名（`.text-l` / `.text-c` / `.text-r`）：它由列上的 `align`
+ *    生成、打在 **td** 上（已实测：`td.className === 'text-r'`）。库若改名，这一层会
+ *    **静默失效**（表现只是「编辑时又变回左对齐」），排查时 grep 库样式里的
+ *    `text-align` 就能定位 —— 代价可接受，好过为此在 TS 侧多加一套标记类。
+ * ⚠️ 中间档 `.text-c` 同样会跳，一起接上。
+ * ⚠️ 只管 input / textarea：右对齐的 select 极少见，而它的对齐由触发器内部的
+ *    flex 布局决定，不是一条 `text-align` 能解决的。
+ * ⚠️ 不限定 `is-editor-seamless`：列对齐与「编辑器是不是无缝形态」正交，
+ *    悬浮卡片形态下右对齐列同样会跳。
+ */
+.#{e('table', 'inner')}.stk-table {
+  .stk-tbody-main td.text-r .#{e('table', 'cell-editor-root')} :is(input, textarea) {
+    text-align: right;
+  }
+
+  .stk-tbody-main td.text-c .#{e('table', 'cell-editor-root')} :is(input, textarea) {
+    text-align: center;
+  }
+}
+
+/* ---------- 校验原因浮层 ---------- */
+
+/**
+ * 表体上 hover 出错格时弹出失败原因。全表只有这一个 DOM（`v-if` 控制），
+ * 显示哪个格子的原因由 G3Table 根节点上的 `mouseover` 委托切换 ——
+ * 为什么不做成每格一个 Tooltip，见组件 script 里「校验原因浮层」一节的性能账。
+ *
+ * 浮层语言对齐 Popover / Tooltip（同令牌、同阴影、同圆角），但更紧凑：
+ * 它只是一行解释文字，用不上气泡那 4px 内边距与 14px 字号。
+ */
+.#{e('table', 'cell-tip')} {
+  position: fixed;
+  max-width: 260px;
+  padding: 4px v('space-2', 8px);
+  border-radius: v('radius-sm', 4px);
+  background: v('bg-container', #fff);
+  color: v('text-1', rgba(0, 0, 0, 0.88));
+  font-size: v('font-size-sm', 12px);
+  line-height: v('line-height', 1.5);
+  box-shadow: v('shadow-popup', 0 6px 16px rgba(0, 0, 0, 0.12));
+  word-break: break-word;
+  /**
+   * 不接收任何鼠标事件。
+   *
+   * 浮层就悬在光标附近，一旦它能命中鼠标，就会出现「浮层挡住光标 → 触发
+   * mouseout / mouseover → 浮层闪烁」的抖动；而且被它盖住的正是我们要 hover
+   * 的那一格，命中它会直接打断委托链路。
+   */
+  pointer-events: none;
+}
+
 /* ---------- 操作列 ---------- */
 .#{e('table', 'actions-cell')} {
   display: inline-flex;
diff --git a/code/g3soft-libs/packages/ui/src/table/index.ts b/code/g3soft-libs/packages/ui/src/table/index.ts
index 008bad7f..098c8bee 100644
--- a/code/g3soft-libs/packages/ui/src/table/index.ts
+++ b/code/g3soft-libs/packages/ui/src/table/index.ts
@@ -1,5 +1,28 @@
 export { default as G3Table } from './G3Table.vue'
 export { registerTableFeatures } from './G3Table.vue'
+/**
+ * 精度判定（`''` = 通过，否则是失败原因）。
+ *
+ * 与组件内置的那条规则**是同一个函数**：业务在保存前做提交拦截时应当复用它，
+ * 而不是照着自己的列配置再写一遍 —— 两边不一致就会出现「格子红了但存档能过」
+ * （或反过来），而且极难排查。用法见 `docs/content/ui/data/table.md` 的
+ * 「数值精度与金额」一节。
+ */
+export { checkPrecision } from './utils/precision'
+/**
+ * 日期判定（`''` = 通过，否则是失败原因）。
+ *
+ * 与 `type: 'date'` 列内置的那条规则**是同一个函数**：业务在保存前做提交拦截时
+ * 应当复用它。判据与 `G3DatePicker` 解析用户手输用的是同一个 `parseDate`，
+ * 所以不会出现「组件认为合法、校验认为非法」这种两边不一致。
+ */
+export { checkDate } from './utils/date-value'
+/**
+ * 底座的数字格式化（本组件 `col.format` 的对象形态就是它），供业务在表格之外
+ * 复用同一套格式化（导出、汇总行、打印等），避免两处格式不一致。
+ */
+export { formatNumber } from 'stk-table-vue'
+export type { FormatNumberOptions } from 'stk-table-vue'
 export type {
   G3TableColumn,
   TableAction,
diff --git a/code/g3soft-libs/packages/ui/src/table/style/_overrides.scss b/code/g3soft-libs/packages/ui/src/table/style/_overrides.scss
index 5ac81d68..930fc01b 100644
--- a/code/g3soft-libs/packages/ui/src/table/style/_overrides.scss
+++ b/code/g3soft-libs/packages/ui/src/table/style/_overrides.scss
@@ -31,6 +31,26 @@
     --border-color: #{v('border-color', #d9d9d9)};
     --td-bgc: #{v('bg-container', #fff)};
 
+    // ── 纵向格线：**表体**关闭，整表只留横向行分隔线（设计决定）
+    // 库给每个 th/td 铺的是 `background-image: var(--bg-border-right), var(--bg-border-bottom)`
+    // （style.css 的 `.stk-table.bordered th, td`），所以关竖线就是把这**一个变量**
+    // 涂透明：横线（--bg-border-bottom）与自绘外框（根节点上的真 border）都不受影响。
+    // 左固定列的左边线是它在 `.fixed-cell--border-left` 分支里单独叠的
+    // --bg-border-left，一并关掉 —— 冻结列与滚过去的列之间的边界改由
+    // fixedColShadow 的渐变承载（见文件末尾「固定列」一节）。
+    // 层级：这里是 (0,3,0)，压得住库在 `.stk-table` / `.stk-table.bordered-h`
+    // 上对这两个变量的定义。
+    // ⚠ 表头是例外：它自己接管 background-image，画一条**不占满高度**的短竖线 ——
+    //    既不经过这两个变量、也不用格线色，见「边框」一节末尾。
+    --bg-border-right: linear-gradient(transparent, transparent);
+    --bg-border-left: linear-gradient(transparent, transparent);
+
+    // ── 表头列界线的颜色：比格线更轻
+    // 格线走 --border-color（#d9d9d9，不透明），在 #f5f5f5 的表头底色上偏重；
+    // 这里用同色系、只叠 8% 的黑（叠出来≈ #e1e1e1），弱一档但不至于看不见。
+    // 暗色块里换成 12% 的白（见下）。
+    --g3-table-header-divider: rgba(0, 0, 0, 0.08);
+
     // 表头 / 表尾底色：这里**不设** --th-bgc / --tf-bgc。
     // 库那两个变量是 alpha 值、且在 sticky 滚动时会透出下方行内容；
     // 改为在文件末尾直接给 th / 表尾 td 一个不透明实色（含完整原因与实测数据）。
@@ -97,6 +117,9 @@
   .#{e('table', 'inner')}.stk-table.dark {
     --border-color: #{v('border-color', #424242)};
     --td-bgc: #{v('bg-container', #141414)};
+
+    // 表头列界：暗色下换成 12% 的白（对应亮色那 8% 的黑，见文件开头的基础变量块）
+    --g3-table-header-divider: rgba(255, 255, 255, 0.12);
     // 表头 / 表尾底色改在文件末尾统一处理（不透明基底 + fill 叠加），此处不设
     --th-color: #{v('text-1', rgba(255, 255, 255, 0.88))};
     --stripe-bgc: #{v('fill', rgba(255, 255, 255, 0.04))};
@@ -137,7 +160,7 @@
 }
 
 // ==========================================================================
-// 边框：外框圆角描边 + 行分隔线由组件自绘，纵向列线仍借底座的渐变
+// 边框：外框圆角描边 + 行分隔线由组件自绘，纵向列线只在表头保留
 // --------------------------------------------------------------------------
 // 底座不用 `border` 画线，而是把四条边做成 `background-image` 渐变
 // （--bg-border-*，由 --border-color 派生），并给 `bordered` 提供三档：
@@ -146,15 +169,19 @@
 //   · 外框是「`border-left` + 三段背景渐变」拼出来的，**做不出圆角**；且底座文档
 //     （table/basic/bordered）写明：受滚动条占位影响，表格**右侧与底部的边框会
 //     消失**，需要时自行补 CSS；
-//   · 越往后越多边线要单独摘掉（最右列外侧线该归外框管，右固定列的左侧线又必须
-//     留着），而它们共用 `--border-color` 一个派生入口 —— 只能去覆盖渐变本身。
+//   · 我们只要横向行分隔线，纵向列线**只在表头保留**：表体靠横线分行、保持干净，
+//     表头的列界留着（拖拽列宽、认列都靠它，见本节末尾）。底座的 'h' 档虽然也能
+//     关表体竖线，但它顺手把外框的 `border-left` 置 none、并保留 --bg-border-top
+//     渐变（与自绘外框叠成双线），所以档位仍用 'v'，竖线改由覆盖那两个变量来关。
 //
-// 于是这里定成：**外框改用真 border 自绘，所有格线（横线 + 竖线）都保持底座的
-// 背景渐变画法**。
+// 于是这里定成：**外框改用真 border 自绘，横线保持底座的背景渐变画法，
+// 竖线对表体置透明、在表头 th 上再恢复回来**。
 //   外框 → `.g3-table.is-bordered` 上的真 `border` + 圆角令牌（外层容器已有
 //          `overflow: hidden`，圆角能把内部内容裁掉）；
 //   横线 → 把 `bordered-v` 清零的 --bg-border-bottom **恢复成底座那份配方**；
-//   竖线 → 保留底座的 --bg-border-right 渐变，只抹掉最右列那一条。
+//   竖线 → 表体 td：基础变量块的 --bg-border-right / --bg-border-left 涂透明；
+//          表头 th：本节末尾把这两个变量重设回底座配方（含左固定列的
+//          --bg-border-left 分支）。
 //
 // 组件侧只负责把 `bordered` 翻成 `true` / `'v'` / `false`（见 G3Table.vue 的
 // `:bordered` 绑定）——`'v'` 必然同时带上 `.bordered` 与 `.bordered-v` 两个类
@@ -221,21 +248,44 @@
   }
 }
 
+// ── 表头列界：自己接管 background-image，画一条**不占满高度**的短竖线
+// 为什么只给表头留列界：认列、拖列宽都落在表头上；表体靠横线与行高分行，
+// 多一条竖线只是噪音（表体已在文件开头全局置透明）。
+//
+// 为什么不用库的 --bg-border-right（它也是竖线）：
+//   · 它是**整格高**的 —— 铺满 th 的整个背景区，而表头行高比数据行还大，
+//     上下顶格在视觉上很硬。这里把线压到 `calc(100% - 8px)`、上下各留 4px。
+//   · 它的色值来自 --border-color（与格线同源），在 245 的表头底色上偏重，
+//     改用更轻的 --g3-table-header-divider（见基础变量块）。
+//
+// 为什么必须「接管整个 background-image」而不是只改其中一层：
+//   background-image / -size / -position 都是**按层一一对应**的列表属性，只想动
+//   其中一层的高度与位置，就得把 size / position 的列表也全部补齐 —— 而库那套层数
+//   本身就不固定（表头首行是 top/right/bottom 三层，多级表头的其它行只有两层），
+//   对不齐就会把某一层的尺寸套到另一层上（实测会把竖线铺成整格色块）。
+//   与其跟库的层数对齐，不如直接声明我们要的两层 —— 第 2 层仍引用库的横线配方，
+//   横向分隔线保持原样。
+//
+// ⚠ 限定 `.bordered`：无框模式（`bordered: false`）不该出现表头线（横线同理）。
+// ⚠ 排除 `.fixed-cell--right`：贴住外框内右缘的右固定列，那条线会与外框的 border
+//    并排成 2px。被排除的 th 走库的原路径（透明竖线 + 我们恢复的横线），无需另写规则。
+// ⚠ `100%` 是**物理**右缘：RTL 下这两列的归属会换边，但相邻两列之间仍然只有一条线，
+//    视觉位置不受影响。
+.#{b('table')} {
+  .#{e('table', 'inner')}.stk-table.bordered thead th:not(.fixed-cell--right) {
+    background-image:
+      linear-gradient(var(--g3-table-header-divider), var(--g3-table-header-divider)),
+      var(--bg-border-bottom);
+    background-size: 1px calc(100% - 8px), 100% 100%;
+    background-position: 100% 4px, 0 0;
+    background-repeat: no-repeat;
+  }
+}
+
 // ==========================================================================
-// 最右列竖线 / 最后一行横线：为什么不能再「按 :last-child 摘线」
+// 最后一行横线：为什么不能再「按 :last-child 摘线」
 // --------------------------------------------------------------------------
-// 老做法是给 `th:last-child, td:last-child` 把 --bg-border-right 涂成透明，
-// 指望「最右列的外侧线归外框管」。**这个假设只在「列宽铺满容器」时成立**，
-// 实测有两种常见情形会破：
-//
-//   1. 列宽之和 < 容器宽（有列没写 width、或容器被拉宽）：
-//      实测 table-wrap —— 容器内宽 1084px，列只铺到 800px，
-//      **右侧留 284px 空白，而那条竖线已被摘掉，于是「线没了 + 留白」**。
-//   2. 有右固定列且横向滚动：DOM 里 `:last-child` 是滚动区的最后一列
-//      （实测右边缘 1698px，早已滚出可视区），**视觉最右**的反而是固定列
-//      （右边缘贴住 1242px 的内缘）。摘 DOM 末列等于摘错了对象。
-//
-// 最后一行同理：横线由每个单元格自己的 --bg-border-bottom 画。
+// 横线由每个单元格自己的 --bg-border-bottom 画。
 // **判据不能是「是不是最后一行」，而是「这行的底边有没有贴住外框内底边」**——
 // 二者只有行区铺满时才等价。实测（180px 高容器）：
 //   · 铺满时：最后一行 bottom 与外框内底边重合 → 线该交给外框（否则叠成 2px）；
@@ -249,12 +299,10 @@
   background-color: v('bg-container', #fff);
 
   .#{e('table', 'inner')}.stk-table.bordered-v {
-    // ── 贴住内右缘的右固定列：自己的右线让给外框，避免两条线并排。
-    //    表头与表体都要处理 —— 实测两处都会画，且都会与外框叠。
-    th.fixed-cell--right,
-    td.fixed-cell--right {
-      --bg-border-right: linear-gradient(transparent, transparent);
-    }
+    // ── 表头右固定列不用在这里单独处理：上面那条表头列界规则已用
+    //    `:not(.fixed-cell--right)` 把它排除掉了。
+    //    「DOM 末列」**不排除**：它才是拖拽该列宽度的落点，列宽没铺满容器时也靠它
+    //    指出末列到哪儿结束（历史踩坑，见本文件 git 记录）。
 
     // ── 空态：底边线归外框。
     //    库的 `.stk-table-no-data.no-data-full` 会撑满剩余高度并**自带一条
@@ -322,6 +370,11 @@
 // ==========================================================================
 // 固定列：不透明底色 + 行状态叠色（防横向滚动时透出下方内容）
 // --------------------------------------------------------------------------
+// ⚠ 配套前提：**表体**的竖线已在文件开头的「纵向格线」块里关闭（表头仍保留 ——
+//    那是给「认列 / 拖列宽」用的），所以冻结列与滚过去的列之间在数据区没有任何
+//    格线 —— 它们的边界只剩 `fixedColShadow`（10px 渐变）能表达。用到固定列的
+//    页面务必打开这个 prop，否则两边同为不透明基色、紧贴在一起时会被读成一整列。
+//
 // 症状：鼠标悬停、或正在编辑（当前行）的那一行里，**冻结列是半透明的** ——
 //       被横向滚过去的列从冻结列底下透出来（用户报的「客户这列是透明的」；
 //       静止时不易发现，一横滚就是「透字」）。
diff --git a/code/g3soft-libs/packages/ui/src/table/types.ts b/code/g3soft-libs/packages/ui/src/table/types.ts
index 54fe81a1..5668903f 100644
--- a/code/g3soft-libs/packages/ui/src/table/types.ts
+++ b/code/g3soft-libs/packages/ui/src/table/types.ts
@@ -1,5 +1,5 @@
 import type { Component, VNode } from 'vue'
-import type { StkTableColumn } from 'stk-table-vue'
+import type { FormatNumberOptions, StkTableColumn } from 'stk-table-vue'
 
 /**
  * G3Table 类型定义。
@@ -26,7 +26,46 @@ export type TableEditorStatus = '' | 'error' | 'warning'
 
 /** 行内编辑器配置 */
 export interface TableEditor<T extends TableRow = TableRow> {
-  type: 'text' | 'number' | 'password' | 'textarea' | 'select' | 'checkbox'
+  type: 'text' | 'number' | 'password' | 'textarea' | 'select' | 'checkbox' | 'date'
+  /**
+   * 日期格式。**只对 `type: 'date'` 生效**，默认 `'YYYY-MM-DD'`。
+   *
+   * 它同时决定**面板精度**与**绑定值格式**（G3DatePicker 的语义）：
+   *   · `'YYYY-MM-DD'` → 面板选到「日」为止；
+   *   · `'YYYY-MM-DD HH:mm'` → 面板多出时间列，选完还要点「确定」才提交。
+   *
+   * 值始终是**字符串、不做 Date ↔ string 的隐式转换**（与后端常见的 `2026-03-15`
+   * 一致）；要另一种存储格式写 `valueFormat`（见下）。
+   */
+  format?: string
+  /**
+   * 绑定值格式（仅 `type: 'date'`）。不传时跟随 `format`。
+   *
+   * 只有「面板展示格式 ≠ 数据存储格式」时才需要它，例如界面显示 `2026-03-15`、
+   * 但接口要 `20260315`：`{ format: 'YYYY-MM-DD', valueFormat: 'YYYYMMDD' }`。
+   */
+  valueFormat?: string
+  /** 占位文案（仅 `type: 'date'`）。不传则不显示占位。 */
+  placeholder?: string
+  /**
+   * 数值精度（小数位数）。**只对 `type: 'number'` 生效**，不传 = 组件不做任何精度处理。
+   *
+   * 语义是「这一列的数值规范」，组件拿它管两件事：
+   *   · **展示**：非编辑态按它格式化（`1200.5` → `1200.50`）；
+   *   · **校验**：超出精度即 error（红底 + 左侧竖条），悬停浮层显示「最多 N 位小数」。
+   *
+   * ⚠️ 组件**不改你的数据**：用户输了 `123.456` 而精度是 2，值**仍然是** `123.456`，
+   *    只是这一格被标红，由用户自己改成 `123.46`。静默四舍五入会让「屏幕上看到的」
+   *    与「落库的」不是一回事 —— 财务对账时就是「我输的不是这个」。
+   * ⚠️ 精度不合法时**不做格式化展示**（原样裸露真实值）：否则按精度格式化成
+   *    `123.46`，屏幕上完全合规、数据却不合规，用户永远发现不了自己错了。
+   *
+   * 传函数可按行给不同精度（与 `disabled` 同一模式），如不同币种/单位的小数位不同。
+   *
+   * 录入时**不做实时拦截**（输到第 3 位小数就直接吞掉）：那要和光标位置、输入法
+   * 组合态、半输入态（`12.` / `-`）搏斗，是公认的坑；「输完再判」既确定又可预测。
+   */
+  precision?: number | ((row: T) => number)
   /**
    * select 的选项。
    * 传函数时接收当前行——列选项依赖同行其它列时用它（如「按目标模块列出目标字段」）。
@@ -138,6 +177,20 @@ export interface TableAction<T extends TableRow = TableRow> {
  * `dataIndex` 收紧为 `keyof T & string`：底座的 `keyof T & string` 本身就是这样，
  * 这里显式写出仅为可读性，不产生新的不兼容。
  */
+/**
+ * 展示态格式化。**只影响显示** —— 落库的值始终是原始值，别拿展示文本回写数据。
+ *
+ * 传选项对象 → 走底座的 `formatNumber`（千分位 / `¥` 前后缀 / 万-亿缩写 / 百分比）；
+ * 传函数 → 完全自定义，`Intl.NumberFormat` 是正解（多语言的小数点与千分位符号、
+ * 会计的括号负数这些 locale 规则，重写一遍必然缺选项）。
+ *
+ * 小数位**优先配在 `editor.precision` 上**（它同时管显示与校验，一处真源）；
+ * `format.decimals` 只在需要「显示位数 ≠ 数据精度」时才写，写了以它为准。
+ */
+export type TableCellFormat<T extends TableRow = TableRow> =
+  | FormatNumberOptions
+  | ((value: unknown, row: T, col: G3TableColumn<T>) => string)
+
 export type G3TableColumn<T extends TableRow = TableRow> = StkTableColumn<T> & {
   /** 该列是否允许拖拽调宽。操作列 / 展开列必须显式设 false */
   resizable?: boolean
@@ -145,6 +198,8 @@ export type G3TableColumn<T extends TableRow = TableRow> = StkTableColumn<T> & {
   editor?: TableEditor<T>
   /** 操作列按钮 */
   actions?: TableAction<T>[]
+  /** 展示态格式化（只影响显示，落库值不变） */
+  format?: TableCellFormat<T>
 }
 
 /** 行多选配置 */
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/column.ts b/code/g3soft-libs/packages/ui/src/table/utils/column.ts
index 8ecfb974..dcde481d 100644
--- a/code/g3soft-libs/packages/ui/src/table/utils/column.ts
+++ b/code/g3soft-libs/packages/ui/src/table/utils/column.ts
@@ -1,5 +1,6 @@
 import { createActionsCell } from './actions'
 import { createEditableCell, type EditableContext } from './editable'
+import { createFormatCell } from './precision'
 import { isSelectionColumn } from './selection'
 import type { G3TableColumn, TableRow } from '../types'
 
@@ -88,7 +89,7 @@ export function resolveCustomCell<T extends TableRow>(
 
   const editor = col.editor
   /**
-   * 注入 customCell 的判据（四种情况）：
+   * 注入 customCell 的判据（五种情况）：
    *
    *   1. `editingActive` —— 有行正在编辑，可编辑列都要挂编辑器；
    *   2. `checkbox` —— 始终可点，必须常驻；
@@ -98,10 +99,12 @@ export function resolveCustomCell<T extends TableRow>(
    *      走库的原生 td 渲染（连 cell-display span 都没有），
    *      它的 error/warning 就只有在点过那一行之后才可见 ——
    *      用户必须一行行点过去才能发现错误（这正是被反馈的问题）。
+   *   5. **配了 `precision`** —— 同因：精度也是「数据的状态」，而且它还要负责
+   *      非编辑态的格式化展示，不常驻就连格式化都不会生效。
    *
-   * 第 4 条的**开销可控性**：只有显式配了校验规则的列才常驻，
+   * 第 4 / 5 条的**开销可控性**：只有显式配了校验或精度的列才常驻，
    * 且常驻时走的是 displayValue（纯 span，不是编辑器组件）。
-   * 没配校验的 text/number 列仍保持原样——非编辑态零组件开销。
+   * 没配这两个的 text/number 列仍保持原样——非编辑态零组件开销。
    */
   const hasValidation = Boolean(editor?.validate || editor?.validateWarning)
   /**
@@ -113,13 +116,16 @@ export function resolveCustomCell<T extends TableRow>(
    * 按行禁用**的列上（普通 text/number 列照旧零开销）。
    */
   const hasRowDisabled = typeof editor?.disabled === 'function'
+  /** 配了精度的 number 列：非编辑态要能看出「小数位超了」，也要按精度格式化展示 */
+  const hasPrecision = Boolean(editor?.precision)
   if (
     editor &&
     (editingActive ||
       editor.type === 'checkbox' ||
       editor.type === 'select' ||
       hasValidation ||
-      hasRowDisabled)
+      hasRowDisabled ||
+      hasPrecision)
   ) {
     return {
       ...col,
@@ -127,6 +133,21 @@ export function resolveCustomCell<T extends TableRow>(
     }
   }
 
+  /**
+   * 纯展示列（**没有** `editor`）配了 `format`：注入一个只做格式化的 cell。
+   *
+   * 为什么不让业务改用底座的 `customCell: createNumberCell(...)` —— 那确实也行，
+   * 但 `format` 会因此变成「有 editor 时组件管、没 editor 时业务自己管」，
+   * 同一个字段两种行为，迟早有人踩。这里统一由组件渲染，
+   * 代价同样只落在**显式配了 format** 的列上。
+   */
+  if (!editor && col.format) {
+    return {
+      ...col,
+      customCell: createFormatCell(col) as unknown as G3TableColumn<T>['customCell'],
+    }
+  }
+
   if (col.actions?.length) {
     const actionsCell = createActionsCell(col.actions)
     if (actionsCell) {
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/date-value.test.ts b/code/g3soft-libs/packages/ui/src/table/utils/date-value.test.ts
new file mode 100644
index 00000000..c4afdf3d
--- /dev/null
+++ b/code/g3soft-libs/packages/ui/src/table/utils/date-value.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { checkDate } from './date-value'
+
+describe('checkDate', () => {
+  it('空值通过 —— 必填是 validate 的事，日期判定不越界管', () => {
+    for (const value of [null, undefined, '']) expect(checkDate(value, 'YYYY-MM-DD')).toBe('')
+  })
+
+  it('合法日期通过（含带时间精度的格式）', () => {
+    expect(checkDate('2026-03-15', 'YYYY-MM-DD')).toBe('')
+    expect(checkDate('2026-03-12 18:00', 'YYYY-MM-DD HH:mm')).toBe('')
+    // 没传 format 时按默认 YYYY-MM-DD
+    expect(checkDate('2026-03-15', undefined)).toBe('')
+  })
+
+  it('斜杠分隔也算合法 —— 组件会规范化文本，判定必须跟它一致', () => {
+    // 若这里判非法，就会出现「在格子里手输 `2026/03/15` 组件接受了、
+    // 退回展示态又被标红」这种自相矛盾。
+    expect(checkDate('2026/03/15', 'YYYY-MM-DD')).toBe('')
+  })
+
+  it('越界 / 非日期文本 → 「日期格式不正确」', () => {
+    // 月份越界最典型：用户以为输了日期，其实压根不是日期
+    expect(checkDate('2026-13-45', 'YYYY-MM-DD')).toBe('日期格式不正确')
+    expect(checkDate('2026-03-32', 'YYYY-MM-DD')).toBe('日期格式不正确')
+    expect(checkDate('abc', 'YYYY-MM-DD')).toBe('日期格式不正确')
+  })
+
+  it('带时间精度的列：只给到「日」算**不合法**（组件的既有口径，本函数跟随）', () => {
+    // 写下来是为了让后来的人知道这是"有意跟随"而不是漏了补零：
+    // 这一列想手输就得写全 `2026-03-15 00:00`，或者直接用面板点选。
+    expect(checkDate('2026-03-15', 'YYYY-MM-DD HH:mm')).toBe('日期格式不正确')
+  })
+})
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/date-value.ts b/code/g3soft-libs/packages/ui/src/table/utils/date-value.ts
new file mode 100644
index 00000000..4e3f7128
--- /dev/null
+++ b/code/g3soft-libs/packages/ui/src/table/utils/date-value.ts
@@ -0,0 +1,35 @@
+import { DEFAULT_DATE_FORMAT, parseDateInput } from '../../date'
+
+/**
+ * 日期值的判定与规范化 —— 与 `precision.ts`（数值精度）对称的一块。
+ *
+ * 为什么单独成文件：它同样是**纯函数、可单测**，而且 `checkDate` 要对外导出 ——
+ * 业务在保存前做提交拦截时必须能跑**同一套**判定（规则只藏在组件里的话，
+ * 两边迟早不一致：格子红了但存档能过、或者反过来）。
+ */
+
+/**
+ * 日期判定：返回失败原因（`''` = 通过）。
+ *
+ * 判据刻意复用 `G3DatePicker` 内部解析用户手输的那个 `parseDateInput`：两边用
+ * **同一个函数**，才不会出现「组件认为这串合法、表格校验认为它非法」这种自相矛盾。
+ *
+ * ⚠️ 不要换成 `parseDate`：它是**宽松解析**（逐格式匹配失败后还会规范化重试、
+ *    最后退到原生 `new Date()` 兜底），会把 `2026-13-45` 这类越界文本「救活」。
+ *    `parseDateInput` 里那道 `DATE_LIKE_TEXT` 保护专门就是拦这个的。
+ *
+ * 边界（与 `checkPrecision` 保持一致的取舍）：
+ *   · 空值（`null` / `undefined` / `''`）→ **通过**。必填是 `validate` 的事，日期判定不越界管；
+ *   · 非空但解析不出来 → 报错。这正是「用户敲了 `2026-13-45` 却没被拦住」那条路径。
+ *
+ * 口径跟随组件（宽松）：`format` 带时间精度时，只给到「日」的文本**算合法**
+ * （缺的时间会被补零）—— 与在格子里手输同样的文本得到的结果一致。
+ *
+ * ⚠️ 存量数据的格式必须与 `format`（或 `valueFormat`）一致，否则整列会被判非法。
+ *    后端给 `20260315` 而这里写 `YYYY-MM-DD` 就是典型误配 —— 那种情况该配 `valueFormat`。
+ */
+export function checkDate(value: unknown, format?: string): string {
+  if (value === null || value === undefined || value === '') return ''
+  const result = parseDateInput(String(value), format ?? DEFAULT_DATE_FORMAT)
+  return result.isValid ? '' : '日期格式不正确'
+}
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/editable.test.ts b/code/g3soft-libs/packages/ui/src/table/utils/editable.test.ts
index 1a7a3106..2ac05dc6 100644
--- a/code/g3soft-libs/packages/ui/src/table/utils/editable.test.ts
+++ b/code/g3soft-libs/packages/ui/src/table/utils/editable.test.ts
@@ -752,7 +752,14 @@ describe('键盘：Enter 与 Esc', () => {
     }
   }
 
-  it('Enter：阻止默认并全选内容（语义是"全选以便覆写"，不是提交）', () => {
+  /**
+   * Enter（单行）：**确认 + 下移到下一行同一列** —— Excel / Sheets / AG Grid / Handsontable
+   * 的通行约定。
+   *
+   * 旧行为是「阻止默认 + 全选内容、且**不提交**」，它既不是浏览器行为、也不是表格软件的行为，
+   * 而且「确认」这个动作整个缺失：改完按回车值还没落库。见 G3Table 的 moveToCellBelow。
+   */
+  it('Enter（单行）：提交当前值，并要求往下走一格（不再是「全选」）', () => {
     const col = makeColumn({ editor: { type: 'text' } } as never)
     const { ctx } = makeCtx()
     const event = makeKeyEvent('Enter', 'abc')
@@ -761,11 +768,70 @@ describe('键盘：Enter 与 Esc', () => {
 
     expect(event.preventDefault).toHaveBeenCalled()
     expect(event.stopPropagation).toHaveBeenCalled()
-    expect(event.target.select).toHaveBeenCalled()
-    // 关键：Enter 不该提交，也不该 blur
+    // 不再全选：那与「确认并走」的新语义冲突
+    expect(event.target.select).not.toHaveBeenCalled()
+    // 也不 blur：移动交给 G3Table（改选区那条链路），自己不负责退场
     expect(event.target.blur).not.toHaveBeenCalled()
   })
 
+  it('Enter（多行）：完全不拦 —— 浏览器原生语义就是换行', () => {
+    const col = makeColumn({ editor: { type: 'textarea' } } as never)
+    const { ctx } = makeCtx()
+    const event = makeKeyEvent('Enter', '第一行')
+
+    keydownOf(col, ctx, { id: 1, name: '第一行', status: 1 })(event)
+
+    // 多行与单行共用一段 onKeydown，早先没按类型分流：
+    // 备注这类多行格按回车会把整段文本全选掉、根本换不了行。
+    expect(event.preventDefault).not.toHaveBeenCalled()
+    expect(event.stopPropagation).not.toHaveBeenCalled()
+    expect(event.target.select).not.toHaveBeenCalled()
+  })
+
+  it('左右键：只 stopPropagation 交给输入框，不 preventDefault', () => {
+    const col = makeColumn({ editor: { type: 'text' } } as never)
+    const { ctx } = makeCtx()
+    const event = makeKeyEvent('ArrowLeft', 'abc')
+
+    keydownOf(col, ctx, { id: 1, name: 'abc', status: 1 })(event)
+
+    /**
+     * 阻止冒泡是为了**不让它冒到底座的表格导航**（否则光标被吃掉、整格跳走）；
+     * 不动默认行为是为了让浏览器照常移动光标 / 用 Shift 选文本 ——
+     * 与底座内置编辑器（custom-cells/EditableCell）的处理逐字一致。
+     */
+    expect(event.stopPropagation).toHaveBeenCalled()
+    expect(event.preventDefault).not.toHaveBeenCalled()
+  })
+
+  it('上下键（单行）：放行给表格导航，本层不做任何拦截', () => {
+    const col = makeColumn({ editor: { type: 'text' } } as never)
+    const { ctx } = makeCtx()
+    const event = makeKeyEvent('ArrowDown', 'abc')
+
+    keydownOf(col, ctx, { id: 1, name: 'abc', status: 1 })(event)
+
+    // 单行输入框里上下键没有原生用途 → 让给表格切换单元格（换行）
+    expect(event.preventDefault).not.toHaveBeenCalled()
+    expect(event.stopPropagation).not.toHaveBeenCalled()
+  })
+
+  it('上下键（多行）：必须 stopPropagation，否则会冒到表格导航上切走格子', () => {
+    const col = makeColumn({ editor: { type: 'textarea' } } as never)
+    const { ctx } = makeCtx()
+    const event = makeKeyEvent('ArrowUp', 'abc')
+
+    keydownOf(col, ctx, { id: 1, name: 'abc', status: 1 })(event)
+
+    /**
+     * 多行里上下键要**跨行移动光标**，是有效操作。
+     * ⚠️ 只「不主动放行」是不够的 —— 事件照样会冒泡到底座的选区导航上把格子切走
+     * （实测：`textarea` 里按 ↑ 变成跳到上一行的格子里，光标没动）。
+     */
+    expect(event.stopPropagation).toHaveBeenCalled()
+    expect(event.preventDefault).not.toHaveBeenCalled()
+  })
+
   it('Esc：先回滚数据，再失焦（语义是"取消"，不是提交）', () => {
     const col = makeColumn({ editor: { type: 'text' } } as never)
     const row = { id: 1, name: '已改动', status: 1 }
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/editable.ts b/code/g3soft-libs/packages/ui/src/table/utils/editable.ts
index f95cf097..4817bd76 100644
--- a/code/g3soft-libs/packages/ui/src/table/utils/editable.ts
+++ b/code/g3soft-libs/packages/ui/src/table/utils/editable.ts
@@ -1,7 +1,12 @@
 import { h, toRaw } from 'vue'
+import type { VNode } from 'vue'
+import { DEFAULT_DATE_FORMAT, G3DatePicker } from '../../date'
+import type { DateValue } from '../../date'
 import { G3Input } from '../../input'
 import { G3Select } from '../../select'
 import { useNamespace } from '../../_composables/useNamespace'
+import { checkDate } from './date-value'
+import { checkPrecision, formatDisplayValue, resolvePrecision } from './precision'
 import type {
   G3TableColumn,
   TableEditor,
@@ -79,6 +84,26 @@ export interface EditableContext<T extends TableRow> {
    * 其它编辑器不需要：它们的格子本来就得先点进编辑（那条路径已经同步过当前格）。
    */
   onEditorInteract?: (row: T, col: G3TableColumn<T>) => void
+  /**
+   * 「Enter 确认后往下走一格」：移到**下一行的同一列**（跳过不可编辑的行），
+   * 返回是否真的移动了（没有下一行可编辑格时返回 false，调用方原地不动）。
+   *
+   * 交给 G3Table 实现，是因为移动必须走**改选区**的方式 —— 底座的
+   * `area-selection-change` 那条链路已经处理好「激活编辑、定位并聚焦编辑器、
+   * 滚动进视口」，复用它与 Tab 跳格 / 鼠标点击走同一条路，
+   * 避免出现第三套行为（见 G3Table 里 handleDocumentTab 的同一段理由）。
+   */
+  moveToCellBelow?: (row: T, col: G3TableColumn<T>) => boolean
+  /**
+   * 退出编辑态（回到就绪态）。Esc 用。
+   *
+   * 为什么 blur 不够：本组件的编辑态是**行级**的（`activeEditingRow`），
+   * 输入框失焦只会让编辑器不再持有焦点、**不会**退出编辑。于是 Esc 之后那一行仍在编辑 —
+   * 表现是「Esc 一下没反应、再点回来还是编辑态」，与 Excel 的「Esc 退出编辑」不符；
+   * 更实际的影响是「打字进编辑」这类路径：行已在编辑态时编辑器不会重挂，
+   * 新设置的草稿读不进去。
+   */
+  exitEditing?: () => void
 }
 
 /* ---------- 草稿 ---------- */
@@ -88,7 +113,12 @@ function getInputDraft<T extends TableRow>(row: T, dataIndex: string): unknown {
   return drafts?.has(dataIndex) ? drafts.get(dataIndex) : row[dataIndex]
 }
 
-function setInputDraft<T extends TableRow>(row: T, dataIndex: string, value: unknown) {
+/**
+ * 写入编辑器草稿。**导出**是因为「就绪态下打字进编辑」要用它：
+ * 表格在进入编辑之前先把用户敲的那个字符放进草稿，编辑器挂载时读到的就是它
+ * （覆盖语义，与 Excel 一致）。见 G3Table 的 enterEditingAt。
+ */
+export function setInputDraft<T extends TableRow>(row: T, dataIndex: string, value: unknown) {
   let drafts = inputDrafts.get(row)
   if (!drafts) {
     drafts = new Map()
@@ -133,7 +163,13 @@ function resolveOptions<T extends TableRow>(
   return typeof editor.options === 'function' ? editor.options(row) : (editor.options ?? [])
 }
 
-function isEditorDisabled<T extends TableRow>(editor: TableEditor<T>, row: T): boolean {
+/**
+ * 这一格现在改不了吗（`editor.disabled`，可传按行函数）。
+ *
+ * **导出**供 G3Table 用：「就绪态下进编辑」要先判这一条 —— 只读 / 按行禁用的格子
+ * 不该被 Enter / 双击 / 打字带进编辑态（方向键仍可以在它上面停留，见 APG 的 grid pattern）。
+ */
+export function isEditorDisabled<T extends TableRow>(editor: TableEditor<T>, row: T): boolean {
   return typeof editor.disabled === 'function'
     ? Boolean(editor.disabled(row))
     : Boolean(editor.disabled)
@@ -213,11 +249,29 @@ function runValidator<T extends TableRow>(
   return typeof result === 'string' ? result : ''
 }
 
+/**
+ * 归一后的校验结果：**等级 + 失败原因**。
+ *
+ * 原因就是 `validate` / `validateWarning` 返回的那个字符串（「金额必须大于 0」）。
+ * 以前这里只取它的 `.length` 判等级、把内容丢掉 —— 业务在 types.ts 里精心写的
+ * 失败原因因此没有任何出口：用户只看得到「这格红了」，看不到为什么。
+ * 现在把它一起带出来，调用方挂成 `data-validate-message`，
+ * 表格侧 hover 时读它弹自绘浮层（见 G3Table 的 cellTip）。
+ *
+ * ⚠️ 仍然**只调一次**校验函数：调用方复用这一份结果，不允许为了「拿原因」
+ *    再调一遍 `validate` —— 那会让每格的校验函数在每次渲染里被调用两次，
+ *    而校验是写在业务侧的、可能有真实开销。
+ */
+interface ResolvedEditorStatus {
+  level: TableEditorStatus
+  message: string
+}
+
 function resolveEditorStatus<T extends TableRow>(
   editor: TableEditor<T>,
   row: T,
   col: G3TableColumn<T>,
-): TableEditorStatus {
+): ResolvedEditorStatus {
   /**
    * error 优先于 warning。
    *
@@ -225,12 +279,47 @@ function resolveEditorStatus<T extends TableRow>(
    * 优先级在这里统一裁决，调用方就不必在每条规则里自己比较等级。
    * 若反过来让 warning 优先，会出现「数据为空（严重）却只给个琥珀提示」的
    * 危险表现——宁可多报一次严重的。
+   *
+   * 同时命中时**消息也只带 error 那条**：用户此刻要处理的就是它，
+   * 两条一起塞进浮层反而让人分不清先改哪个。
    */
-  if (runValidator(editor.validate, 'validate', row, col).length > 0) return 'error'
-  if (runValidator(editor.validateWarning, 'validateWarning', row, col).length > 0) {
-    return 'warning'
-  }
-  return ''
+  const errorMessage = runValidator(editor.validate, 'validate', row, col)
+  if (errorMessage.length > 0) return { level: 'error', message: errorMessage }
+
+  /**
+   * `editor.precision` 是**组件内置**的一条 error 规则，排业务 `validate` 之后：
+   *
+   *   · 排在后面是因为业务规则的语义更具体（「金额必须大于 0」比「最多 2 位小数」
+   *     更能说明该改成什么），两者同时命中时先给业务那条；
+   *   · 与 `validate` 同样返回 string，所以它**天然复用**同一条链路
+   *     （单元格红底 + 左侧竖条 + 悬停浮层的原因），不需要另开一套视觉；
+   *   · 只有 `type: 'number'` 会有精度（`resolvePrecision` 已限制），
+   *     select / checkbox 拿到的永远是 `undefined`，判定为空。
+   *
+   * ⚠️ 这里只**判定**、不改数据：值原样留在 row 里（见 types.ts 的说明）。
+   */
+  const precisionError = checkPrecision(row[col.dataIndex], resolvePrecision(col, row))
+  if (precisionError.length > 0) return { level: 'error', message: precisionError }
+
+  /**
+   * 日期列内置的一条 error 规则，与 `precision` 完全对称：**值不合规范就标红、
+   * 但组件不改值**（用户敲的 `2026-13-45` 就留在行里，由他自己改）。
+   *
+   * 它接住的是「手输非法」：DatePicker 有意不为这种文本 emit（否则表单的 `v-model`
+   * 会被脏值污染），所以表格侧在编辑器卸载时把原文写回（见 createDate 的
+   * `onVnodeBeforeUnmount`），再交给这条规则把原因说出来 —— 用户看到的仍是
+   * 那套统一的「红底 + 左侧竖条 + 悬停浮层」，不需要另做提示。
+   *
+   * ⚠️ 判据必须限定 `type === 'date'`：`checkDate` 是**导出的公共函数**（刻意不绑类型），
+   *    而任何一段普通文本都解析不出日期 —— 不限定的话 `type: 'text'` 的列会满屏报错。
+   */
+  const dateError = editor.type === 'date' ? checkDate(row[col.dataIndex], editor.format) : ''
+  if (dateError.length > 0) return { level: 'error', message: dateError }
+
+  const warningMessage = runValidator(editor.validateWarning, 'validateWarning', row, col)
+  if (warningMessage.length > 0) return { level: 'warning', message: warningMessage }
+
+  return { level: '', message: '' }
 }
 
 function notifyChange<T extends TableRow>(
@@ -270,14 +359,22 @@ function displayValue<T extends TableRow>(
 ) {
   const { e, is } = useNamespace('table')
   const value = row[col.dataIndex]
+  const precision = resolvePrecision(col, row)
+  /**
+   * 展示文本的两个来源：
+   *   · select → 把值解析成选项 label（既有行为）；
+   *   · 其余 → `formatDisplayValue`：没配 `format` / `precision` 的列原样返回，
+   *     走的是**零开销路径**（多数列如此）；配了的按规则格式化，
+   *     精度不合法时原样裸露真实值（见 precision.ts 的说明）。
+   */
   const text =
     editor.type === 'select'
       ? (resolveOptions(editor, row).find((item) => String(item.value) === String(value))
           ?.label ?? value)
-      : value
+      : formatDisplayValue(value, row, col, precision)
   const content = text ?? ''
   const status = resolveEditorStatus(editor, row, col)
-  const statusClass = editorStatusClass(status, editor.errorStyle, is)
+  const statusClass = editorStatusClass(status.level, editor.errorStyle, is)
   /**
    * 按行动态禁用的格子：这里挂「不可改」标记，表格侧据此常驻灰底。
    *
@@ -311,7 +408,31 @@ function displayValue<T extends TableRow>(
         statusClass ? { [statusClass]: true } : {},
         readonly ? { [readonly]: true } : {},
       ],
-      title: String(content),
+      /**
+       * 有校验原因时**撤掉** title：原因交给表格侧的自绘浮层显示，
+       * 原生 tooltip 若同时弹出就会与浮层叠在一起（两个框、两套样式）。
+       * 没有原因时 title 仍是「值」，继续承担「内容被省略」的兜底。
+       */
+      title: status.message ? undefined : String(content),
+      /**
+       * 失败原因挂成 data 属性（**有消息才挂**：`undefined` 会让 Vue 直接移除该属性，
+       * 普通格零成本）。表格侧 hover 时读它弹自绘浮层（见 G3Table 的 cellTip）。
+       *
+       * 为什么不用原生 `title`：延迟约 1 秒、样式不可控、亮暗主题跟不上 ——
+       * 而浮层可以完全对齐本库的浮层语言。所以 `title` 留给「值太长被省略」这件事，
+       * 两者不要混在一个属性里。
+       *
+       * 为什么挂在**展示节点**上而不是 `td` 上：与灰底标记同理 —— 库渲染 td 时
+       * class / 属性只认 `col.className`（整列常量），按行变化的东西打不上去。
+       */
+      'data-validate-message': status.message || undefined,
+      /**
+       * 无障碍：把原因也说给屏幕阅读器（自绘浮层对它们不可靠）。
+       * 只在**有消息时**才拼这个字符串，普通格不为此多分配一次。
+       */
+      'aria-label': status.message
+        ? `${col.title || col.dataIndex}，${status.message}`
+        : undefined,
     },
     content as string,
   )
@@ -325,25 +446,34 @@ function createFocusHandler<T extends TableRow>(
   col: G3TableColumn<T>,
   selectText = false,
 ) {
-  return ({ component, el }: { component?: any; el?: any }) => {
-    if (!ctx.shouldFocus(row, col)) return
+  /**
+   * 返回值 = 「这一次**真的**把焦点交给了编辑器」。
+   *
+   * 日期编辑器用它决定顺手弹不弹日历面板（见 createDate）：只有「用户刚激活这一格」
+   * 的那一次才该弹，重渲染引起的重复聚焦不该弹。其余调用点忽略返回值即可 ——
+   * 所以这个改动是向后兼容的。
+   */
+  return ({ component, el }: { component?: any; el?: any }): boolean => {
+    if (!ctx.shouldFocus(row, col)) return false
     // 仅在两种场景聚焦：用户刚激活该格（一次性），或重渲染前本就持有焦点
     const pending = ctx.consumePendingFocus?.(row)
     const wasFocused = Boolean(ctx.wasFocused?.(row))
-    if (!pending && !wasFocused) return
+    if (!pending && !wasFocused) return false
 
     const input = el?.matches?.('input') ? el : el?.querySelector?.('input')
-    if (document.activeElement === input) return
+    // 焦点已经在这一格：不算「这次交给它」，否则日期面板会被重复弹开
+    if (document.activeElement === input) return false
 
     const instance = component?.exposed || component?.proxy
     const shouldSelect = selectText && (pending || wasFocused)
     const opts = shouldSelect ? { cursor: 'all', preventScroll: true } : { preventScroll: true }
     if (instance?.focus) {
       instance.focus(opts)
-      return
+      return true
     }
     input?.focus(opts)
     if (shouldSelect) input?.select()
+    return true
   }
 }
 
@@ -429,6 +559,32 @@ function activeCellClass<T extends TableRow>(
   return ctx.shouldFocus(row, col) ? is('cell-editing') : ''
 }
 
+/* 方向键的分工写在 createInput / createDate 的 onKeydown 里（左右归输入框、上下给导航），
+   没有共用常量 —— 两处的条件都带类型判断（textarea 例外），抽成集合反而更绕。 */
+
+/**
+ * 求「Enter 确认后该去哪一格」：**下一行的同一列**，跳过不可编辑的行。
+ *
+ * 为什么跳过，而不是像 Excel 那样「不管下一格能不能改都落下去」：本组件的
+ * 「选中」与「进入编辑」是一体的（点格即挂载编辑器），落到只读格上表现成
+ * 「编辑态凭空消失」，比停在原地更让人困惑 —— 与 Tab 跳格跳过只读格同一条理由。
+ *
+ * 扫到表尾没有可编辑格就返回 null（调用方原地不动）：与 Excel 到表尾即停一致，
+ * 不循环回表头（回车一路按到底突然跳回第一行会很意外）。
+ */
+export function findCellBelow<T extends TableRow>(
+  rows: T[],
+  columns: G3TableColumn<T>[],
+  from: { rowIndex: number; colIndex: number },
+): { rowIndex: number; colIndex: number } | null {
+  const editor = columns[from.colIndex]?.editor as TableEditor<T> | undefined
+  if (!editor) return null
+  for (let rowIndex = from.rowIndex + 1; rowIndex < rows.length; rowIndex += 1) {
+    if (!isEditorDisabled(editor, rows[rowIndex])) return { rowIndex, colIndex: from.colIndex }
+  }
+  return null
+}
+
 /** 编辑器到 G3Input 的 type 映射：fms 用 antdv 的 inputType，我们用自己的枚举 */
 const INPUT_TYPE_MAP: Record<string, 'default' | 'password' | 'number' | 'textarea'> = {
   text: 'default',
@@ -506,14 +662,17 @@ function createInput<T extends TableRow>(
   return h(G3Input, {
     type: INPUT_TYPE_MAP[editor.type] ?? 'default',
     modelValue: (getInputDraft(row, col.dataIndex) ?? '') as string,
-    status,
+    status: status.level,
     class: [
       e('cell-editor'),
       e('cell-editor-root'),
       activeCellClass(ctx, row, col, is),
-      editorStatusClass(status, editor.errorStyle, is),
+      editorStatusClass(status.level, editor.errorStyle, is),
     ],
-    'aria-label': col.title || col.dataIndex,
+    'aria-label': status.message
+      ? `${col.title || col.dataIndex}，${status.message}`
+      : col.title || col.dataIndex,
+    'data-validate-message': status.message || undefined,
     'onUpdate:modelValue': (value: string | number) => {
       setInputDraft(row, col.dataIndex, value)
     },
@@ -532,10 +691,66 @@ function createInput<T extends TableRow>(
     },
     onKeydown: (event: KeyboardEvent) => {
       // G3Input 根节点是包装 div，currentTarget 不是原生 input，需用 event.target
+      const input = event.target as HTMLInputElement
+
+      /**
+       * 左右键：**交给输入框**移动光标 / 选中文本（含 `Shift+左右`）。
+       *
+       * 这是编辑文本的刚需 —— 想改金额中间一位、想 Shift 选中再覆盖，都离不开它。
+       * 所以这两个键 `stopPropagation`，不让事件冒到表格的选区导航上。
+       */
+      if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+        event.stopPropagation()
+        return
+      }
+
+      /**
+       * 上下键：**单行交给表格导航**（切到上 / 下一行的同一列），**多行留给输入框**。
+       *
+       * 单行输入框里上下键**没有任何原生用途**（不移动光标、也不滚动），拿它做「换行」
+       * 是零损失的：改完按 ↓ 直接走到下一行同一列，手不用离开键盘。
+       * 左右键则相反（见上）—— 它在输入框里有明确用途，不能让出去。
+       *
+       * 两种去向的条件：
+       *   · **放行给表格**（`return`，不 stopPropagation）：单行、且没按 `Shift`
+       *     —— 按下 `Shift` 时原生语义是「选中到开头 / 结尾」，那是有效操作；
+       *   · **留给输入框**（`stopPropagation`）：`textarea` 要跨行移动光标、
+       *     或单行按了 `Shift`。
+       *
+       * ⚠️ 第二条的 `stopPropagation` 不能省：只「不主动放行」是不够的 ——
+       *    事件照样会冒泡到底座的选区导航上，把格子切走（实测踩到：
+       *    `textarea` 里按 ↑ 变成跳到上一行的格子里，光标没动）。
+       */
+      if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+        if (editor.type !== 'textarea' && !event.shiftKey) return
+        event.stopPropagation()
+        return
+      }
+
       if (event.key === 'Enter') {
+        /**
+         * 多行编辑器：Enter 就是换行（浏览器原生语义），一点都不拦。
+         * 它与单行共用这段 onKeydown，早先没按类型分流，导致备注这类多行格
+         * 按回车会把整段文本**全选**掉、根本换不了行。
+         */
+        if (editor.type === 'textarea') return
+
         event.preventDefault()
         event.stopPropagation()
-        ;(event.target as HTMLInputElement).select()
+        /**
+         * 单行：**确认 + 下移到下一行同列** —— Excel / Sheets / AG Grid /
+         * Handsontable 的通行约定，也是录入场景最顺手的动作（改完这行去下一行同一列）。
+         *
+         * ⚠️ 必须**显式提交**，不能依赖随之而来的失焦：移动会改选区 → 编辑器 vnode
+         *    被卸载，而 DOM 元素被移除时浏览器**不派发 blur**（做日期编辑器时踩过这个坑），
+         *    只靠 onBlur 的话，敲完按回车值就没了。
+         * ⚠️ 移动交给 `moveToCellBelow`（内部改选区），与 Tab 跳格同一条链路。
+         *    早先这里是 `select()` 全选 —— 那既不是浏览器行为、也不是表格软件的行为，
+         *    而且**不提交**（改完按回车，值还没落库）。
+         */
+        commitInputDraft(row, col.dataIndex, input.value)
+        notifyChange(ctx, editor, row, col, input.value)
+        ctx.moveToCellBelow?.(row, col)
       } else if (event.key === 'Escape') {
         // Esc = **放弃本次编辑**（恢复到进入编辑前的值），符合 Excel / AG Grid /
         // Handsontable / antd 的通用约定（Enter 提交、Esc 取消）。
@@ -543,11 +758,14 @@ function createInput<T extends TableRow>(
         // ⚠ 顺序与配套缺一不可：
         //   1) 置 canceling —— 让随后 onBlur 跳过提交（关键，否则回滚被用户输入覆盖）
         //   2) revertRow   —— 把行数据恢复到进入编辑时的快照
-        //   3) 清草稿 + blur —— 退出编辑态，输入框值经受控渲染回到行数据的原值
+        //   3) 清草稿 + blur —— 输入框值经受控渲染回到行数据的原值
         canceling = true
         ctx.revertRow(row)
         clearInputDraft(row, col.dataIndex)
         ;(event.target as HTMLInputElement).blur()
+        //   4) 退出编辑态（回到就绪态）—— 与 Excel 的「Esc 退出编辑」一致。
+        //      blur 本身做不到这件事：编辑态是**行级**的，失焦不等于退出编辑。
+        ctx.exitEditing?.()
       }
     },
     onClick: stop,
@@ -592,9 +810,12 @@ function createSelect<T extends TableRow>(
       e('cell-editor'),
       e('cell-editor-root'),
       activeCellClass(ctx, row, col, is),
-      editorStatusClass(status, editor.errorStyle, is),
+      editorStatusClass(status.level, editor.errorStyle, is),
     ],
-    'aria-label': col.title || col.dataIndex,
+    'aria-label': status.message
+      ? `${col.title || col.dataIndex}，${status.message}`
+      : col.title || col.dataIndex,
+    'data-validate-message': status.message || undefined,
     'onUpdate:modelValue': (value: unknown) => {
       const resolved = value ?? editor.emptyValue ?? null
       row[col.dataIndex] = resolved as T[keyof T & string]
@@ -606,6 +827,104 @@ function createSelect<T extends TableRow>(
   })
 }
 
+function createDate<T extends TableRow>(
+  row: T,
+  col: G3TableColumn<T>,
+  editor: TableEditor<T>,
+  ctx: EditableContext<T>,
+) {
+  const { e, is } = useNamespace('table')
+  const focus = createFocusHandler(ctx, row, col)
+  const status = resolveEditorStatus(editor, row, col)
+  return h(G3DatePicker, {
+    modelValue: (row[col.dataIndex] ?? null) as DateValue,
+    /**
+     * `format` 同时决定面板精度与绑定值格式（见 types.ts）。
+     * 默认给 `'YYYY-MM-DD'`：与 G3DatePicker 自己的默认一致，也和后端常见的
+     * 日期串一致；带时间精度就写 `'YYYY-MM-DD HH:mm'`，面板会多出时间列。
+     */
+    format: editor.format ?? DEFAULT_DATE_FORMAT,
+    valueFormat: editor.valueFormat,
+    placeholder: editor.placeholder,
+    clearable: editor.allowClear ?? true,
+    /**
+     * 无缝模式交给 G3DatePicker 自己处理（与 select 同因）：触发器的真实 DOM 是
+     * `div.g3-date-picker > [Popover] > span.g3-date-picker__trigger`，从表格侧写
+     * 后代选择器压不住它自己的 border / radius / min-height（权重相同、顺序不可控）。
+     */
+    seamless: ctx.isSeamless?.(),
+    class: [
+      e('cell-editor'),
+      e('cell-editor-root'),
+      activeCellClass(ctx, row, col, is),
+      editorStatusClass(status.level, editor.errorStyle, is),
+    ],
+    'aria-label': status.message
+      ? `${col.title || col.dataIndex}，${status.message}`
+      : col.title || col.dataIndex,
+    'data-validate-message': status.message || undefined,
+    /**
+     * 照 select 的路子**立即写回**，不用 input 那套草稿：
+     * G3DatePicker 内部自己管草稿（手输的半成品文本存在它的 `editingText` 里），
+     * 只在真正确定的时刻才 emit —— 手输失焦、点选日期、或带时间精度时点「确定」。
+     * 所以表格侧拿到的一定是完整值，不存在「每敲一个字符就回写行数据」的问题。
+     */
+    'onUpdate:modelValue': (value: unknown) => {
+      const resolved = value ?? editor.emptyValue ?? null
+      row[col.dataIndex] = resolved as T[keyof T & string]
+      notifyChange(ctx, editor, row, col, resolved)
+    },
+    onClick: stop,
+    /**
+     * 与 createInput 同一套分工：左右归输入框（日期是文本，用户会想改其中一段），
+     * 上下不拦、让给表格导航（切行）。
+     * 面板打开时焦点在面板里，事件源不在这个输入框上，走不到这里 —— 无需特判。
+     */
+    onKeydown: (event: KeyboardEvent) => {
+      if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') event.stopPropagation()
+    },
+    /**
+     * 挂载时聚焦，**并且**顺手把日历弹开 —— 「点日期格就出日历」是 ERP 里的常规预期
+     * （点格的那次点击落在 td 上，触发不到 G3DatePicker 自己的「点输入框才展开」）。
+     *
+     * 只在 focus 真的把焦点交出去的那一次弹（它返回值就是干这个用的）：重渲染引起的
+     * 重复聚焦不该把面板重新弹开 —— 用户可能刚选完日期把它关掉。
+     */
+    onVnodeMounted: (vnode: VNode) => {
+      if (focus(vnode)) openDatePanel(vnode)
+    },
+    /**
+     * 手输的日期解析不出来时，**把原文写进行数据** —— 由上面那条内置的日期校验
+     * 去标红并说明原因（与「金额输 0」「数量超精度」同一套处理：值不合法不等于
+     * 要把它丢掉，而是要让人看见、并知道改成什么）。
+     *
+     * 为什么必须由组件主动抛（而不是等卸载时去读输入框）：DatePicker 在解析失败时
+     * 会把内部草稿清掉、输入框随即被受控渲染回**原值**，等 vnode 卸载时再读 DOM
+     * 拿到的已经是原值了（实测踩到）。
+     *
+     * ⚠️ 只在解析失败时写：合法值走的是 `onUpdate:modelValue`（已按 `valueFormat`
+     *    格式化好），这里拿到的原文格式未必等于存储格式，不能拿来覆盖。
+     */
+    onInvalidInput: (text: string) => {
+      row[col.dataIndex] = text as T[keyof T & string]
+      notifyChange(ctx, editor, row, col, text)
+    },
+    onVnodeUpdated: focus,
+  })
+}
+
+/**
+ * 打开 VNode 上那个 G3DatePicker 的日历面板。
+ *
+ * 编辑器是**函数式渲染**、没有 setup 上下文，直接拿不到组件实例；但 vnode 上带着
+ * `component`，从它取 `exposed` 是 Vue 3 里可靠的做法（比用 DOM 去模拟点击触发器稳）。
+ * 取不到就静默跳过 —— 降级结果只是「面板要再点一下才展开」，不值得为此抛错。
+ */
+function openDatePanel(vnode: VNode) {
+  const exposed = (vnode.component as { exposed?: { openPanel?: () => void } } | null)?.exposed
+  exposed?.openPanel?.()
+}
+
 function createCheckbox<T extends TableRow>(
   row: T,
   col: G3TableColumn<T>,
@@ -623,7 +942,7 @@ function createCheckbox<T extends TableRow>(
    * 用户会以为那一列没问题。统一给类，让表格侧的选择器只写一次。
    */
   const status = resolveEditorStatus(editor, row, col)
-  const statusClass = editorStatusClass(status, editor.errorStyle, is)
+  const statusClass = editorStatusClass(status.level, editor.errorStyle, is)
   const update = (value: number) => {
     row[col.dataIndex] = value as T[keyof T & string]
     notifyChange(ctx, editor, row, col, value)
@@ -644,6 +963,8 @@ function createCheckbox<T extends TableRow>(
           [statusClass]: statusClass.length > 0,
         },
       ],
+      // 失败原因挂在这里（checkbox 的根节点，与 input / select 用同一个属性名）
+      'data-validate-message': status.message || undefined,
       onClick: stop,
       // 库在 mousedown 阶段处理选区与行编辑激活；checkbox 是始终可直接操作的控件，
       // 必须在此阶段隔离，否则第一次点击只激活编辑态、第二次才真正切换。
@@ -658,7 +979,12 @@ function createCheckbox<T extends TableRow>(
           update((event.target as HTMLInputElement).checked ? 1 : 0)
         },
         onKeydown: (event: KeyboardEvent) => {
-          if (event.key !== 'Enter') return
+          /**
+           * Space 是**原生** checkbox 的切换键（原生对 Enter 不响应）；
+           * Enter 是表格用户的既有期待（连续录入时手不离 Enter）。
+           * 两个都接：一个符合原生，一个符合表格习惯，都不会让人意外。
+           */
+          if (event.key !== 'Enter' && event.key !== ' ') return
           event.preventDefault()
           event.stopPropagation()
           const value = row[col.dataIndex] === 1 ? 0 : 1
@@ -691,6 +1017,21 @@ export function createEditableCell<T extends TableRow>(
     if (editor.type === 'checkbox') return createCheckbox(row, col, editor, ctx)
     if (!ctx.isEditing(row)) return displayValue(ctx, row, col, editor)
     if (editor.type === 'select') return createSelect(row, col, editor, ctx)
+    /**
+     * 日期是**唯一「只给当前格挂编辑器」**的类型，其余类型在行编辑态下整行都挂。
+     *
+     * 两个理由：
+     *   1. 切换格时新格是**挂载**，`onVnodeMounted` 才会发生 —— 日历面板才能跟着弹开。
+     *      若跟着整行挂载，同行内从别的列切到日期格时不会重新挂载，面板就不弹了，
+     *      表现为「有时弹、有时不弹」这种最难解释的不一致。
+     *   2. 顺带更省：日期格不激活时走纯展示（一个 span），而 DatePicker 是浮层组件，
+     *      比 input 重得多。
+     */
+    if (editor.type === 'date') {
+      return ctx.shouldFocus(row, col)
+        ? createDate(row, col, editor, ctx)
+        : displayValue(ctx, row, col, editor)
+    }
     return createInput(row, col, editor, ctx)
   }
 }
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/precision.test.ts b/code/g3soft-libs/packages/ui/src/table/utils/precision.test.ts
new file mode 100644
index 00000000..f46089a3
--- /dev/null
+++ b/code/g3soft-libs/packages/ui/src/table/utils/precision.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest'
+import type { G3TableColumn, TableRow } from '../types'
+import { checkPrecision, formatDisplayValue, resolvePrecision } from './precision'
+
+const col = (over: Partial<G3TableColumn> = {}): G3TableColumn =>
+  ({ dataIndex: 'amount', title: '金额', ...over }) as G3TableColumn
+
+const row: TableRow = { amount: 0 }
+
+describe('checkPrecision', () => {
+  it('没配精度：一律通过（组件不做任何精度干预）', () => {
+    expect(checkPrecision(1.23456, undefined)).toBe('')
+    expect(checkPrecision('abc', undefined)).toBe('')
+  })
+
+  it('空值 / 非数字 / 展示文本：不归精度管（必填与「这不是个数字」是 validate 的事）', () => {
+    for (const value of [null, undefined, '']) expect(checkPrecision(value, 2)).toBe('')
+    expect(checkPrecision('abc', 2)).toBe('')
+    // 带千分位的是展示文本、不是数据，别拿它去判精度
+    expect(checkPrecision('1,200.50', 2)).toBe('')
+    expect(checkPrecision('1e-7', 2)).toBe('')
+  })
+
+  it('精度内通过；超出即给出原因（原因里带位数，直接进悬停浮层）', () => {
+    expect(checkPrecision(12, 2)).toBe('')
+    expect(checkPrecision(12.5, 2)).toBe('')
+    expect(checkPrecision(12.56, 2)).toBe('')
+    expect(checkPrecision(12.567, 2)).toBe('最多 2 位小数')
+    // 负数：符号不参与位数计算
+    expect(checkPrecision(-12.567, 3)).toBe('')
+    expect(checkPrecision(-12.567, 2)).toBe('最多 2 位小数')
+    expect(checkPrecision('12.567', 2)).toBe('最多 2 位小数')
+    expect(checkPrecision(0, 0)).toBe('')
+    expect(checkPrecision(0.5, 0)).toBe('最多 0 位小数')
+  })
+
+  it('靠字符串数位数：1.005 这种「看着两位、二进制里不是」的值不会误判', () => {
+    /**
+     * 这是本函数不用数值运算的原因：`1.005 * 100 = 100.49999999999999`，
+     * 按 `Math.round` 那一套会被算成 `1`（即「0 位小数」）——
+     * 精度判定直接失效。字符串判定不受影响。
+     */
+    expect(checkPrecision(1.005, 3)).toBe('')
+    expect(checkPrecision(1.005, 2)).toBe('最多 2 位小数')
+  })
+})
+
+describe('resolvePrecision', () => {
+  it('只对 number 编辑器生效', () => {
+    expect(resolvePrecision(col({ editor: { type: 'text', precision: 2 } }), row)).toBeUndefined()
+    expect(resolvePrecision(col({ editor: { type: 'select', precision: 2 } }), row)).toBeUndefined()
+    expect(resolvePrecision(col(), row)).toBeUndefined()
+    expect(resolvePrecision(col({ editor: { type: 'number', precision: 2 } }), row)).toBe(2)
+  })
+
+  it('非法配置当作没配（宁可不动，也别按半截配置改校验结果）', () => {
+    expect(resolvePrecision(col({ editor: { type: 'number', precision: -1 } }), row)).toBeUndefined()
+    expect(
+      resolvePrecision(col({ editor: { type: 'number', precision: Number.NaN } }), row),
+    ).toBeUndefined()
+    expect(
+      resolvePrecision(
+        col({ editor: { type: 'number', precision: Number.POSITIVE_INFINITY } }),
+        row,
+      ),
+    ).toBeUndefined()
+  })
+
+  it('函数形态按行取值（不同行/不同币种可以有不同精度）', () => {
+    const c = col({
+      editor: { type: 'number', precision: (r) => (r.currency === 'JPY' ? 0 : 2) },
+    })
+    expect(resolvePrecision(c, { currency: 'JPY' })).toBe(0)
+    expect(resolvePrecision(c, { currency: 'CNY' })).toBe(2)
+  })
+})
+
+describe('formatDisplayValue', () => {
+  it('什么都没配：原值返回（零开销路径，不多造字符串）', () => {
+    const value = { any: 'thing' }
+    expect(formatDisplayValue(value, row, col(), undefined)).toBe(value)
+  })
+
+  it('只配精度：按小数位格式化，且**不**隐式加千分位（precision 只管小数位）', () => {
+    expect(formatDisplayValue(1200, row, col(), 2)).toBe('1200.00')
+  })
+
+  it('配了 format 对象：走底座的 formatNumber（千分位 + 前缀）', () => {
+    const c = col({ format: { thousands: true, prefix: '¥' } })
+    expect(formatDisplayValue(1200, row, c, 2)).toBe('¥1,200.00')
+  })
+
+  it('format.decimals 显式写了以它为准（需要「显示位数 ≠ 数据精度」时才写）', () => {
+    const c = col({ format: { decimals: 0 } })
+    expect(formatDisplayValue(1200.6, row, c, 2)).toBe('1,201')
+  })
+
+  it('format 是函数：完全交给业务，组件不插手显示', () => {
+    const c = col({ format: (value: unknown) => `#${value}` })
+    expect(formatDisplayValue(12, row, c, 2)).toBe('#12')
+  })
+
+  it('精度不合法：原样返回、不做任何格式化（屏幕上必须是真实值）', () => {
+    const c = col({ format: { thousands: true, prefix: '¥' } })
+    expect(formatDisplayValue(123.456, row, c, 2)).toBe(123.456)
+  })
+})
diff --git a/code/g3soft-libs/packages/ui/src/table/utils/precision.ts b/code/g3soft-libs/packages/ui/src/table/utils/precision.ts
new file mode 100644
index 00000000..4c8c27be
--- /dev/null
+++ b/code/g3soft-libs/packages/ui/src/table/utils/precision.ts
@@ -0,0 +1,123 @@
+import { formatNumber } from 'stk-table-vue'
+import type { FormatNumberOptions } from 'stk-table-vue'
+import { h } from 'vue'
+import { useNamespace } from '../../_composables/useNamespace'
+import type { G3TableColumn, TableRow } from '../types'
+
+/**
+ * 数值精度（`editor.precision`）与展示格式化（`col.format`）的唯一实现处。
+ *
+ * 抽成独立模块有两个理由：
+ *
+ *   1. 两者都是**纯函数**，与 Vue 渲染无关 —— 独立成文件才好单测。精度判定的边界
+ *      全在字符串处理上（空值/非数字/半输入态/科学计数法），用真浏览器跑 E2E 去覆盖
+ *      这些是最慢也最容易漏的验证方式。
+ *   2. `checkPrecision` 要**对外导出**：业务在保存前做提交拦截时，必须能跑同一套判定。
+ *      规则只藏在组件内部的话，业务只能自己再写一遍，两边迟早不一致 ——
+ *      要么「格子红了但存档能过」，要么「格子没红但存档被后端拒了」，两种都很难查。
+ */
+
+/**
+ * 解析某一格当前生效的精度。
+ *
+ * `precision` 只对 `number` 编辑器生效 —— 在 text 列上写它没有意义，直接忽略，
+ * 免得出现「text 列也被判小数位」这种没人预期得到的行为。
+ *
+ * 非法配置（负数 / NaN / 非数字）一律当作**没配**：宁可什么都不做，也不要拿着半截
+ * 配置去改用户的校验结果。
+ *
+ * ⚠️ 一格的一次渲染里它可能被调用**两次**（一次判校验态、一次做展示格式化），
+ * 所以业务写在 `precision` 里的函数要保持轻量 —— 与 `validate` 的约定一致。
+ */
+export function resolvePrecision<T extends TableRow>(
+  col: G3TableColumn<T>,
+  row: T,
+): number | undefined {
+  const editor = col.editor
+  if (!editor || editor.type !== 'number') return undefined
+  const raw = editor.precision
+  if (raw === undefined || raw === null) return undefined
+  const value = typeof raw === 'function' ? raw(row) : raw
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) return undefined
+  return Math.floor(value)
+}
+
+/**
+ * 精度判定：返回失败原因（`''` = 通过）。
+ *
+ * 为什么用**字符串**数小数位，而不是做数值运算：`Math.round(v * 100) / 100` 那套在
+ * `1.005` 这种值上给出的是 `1` 而不是 `1.01`（`1.005 * 100 = 100.49999999999999`），
+ * 而金额恰恰最容易撞上这种「看着是两位小数、二进制里不是」的值。
+ * `String(value)` 就是用户敲进输入框的那串十进制数字，拿它数小数点后的位数既准确，
+ * 又不会引入新的浮点误差。
+ *
+ * 边界（都是有意的）：
+ *   · 空值（`null` / `undefined` / `''`）→ **通过**。必填是 `validate` 的事，精度不越界管。
+ *   · 非数字（`abc`）→ **通过**。同上，「这不是个数字」也该由业务规则表达。
+ *   · 带千分位的字符串（`1,200.50`）→ **通过**。那是展示文本不是数据，不该拿来判精度。
+ *   · 科学计数法（`1e-7`）→ **通过**（没有小数点可数）。金额不会小到这个量级；
+ *     真到那一步，业务该用 `format` 函数自己格式化。
+ */
+export function checkPrecision(value: unknown, precision?: number): string {
+  if (precision === undefined) return ''
+  if (value === null || value === undefined || value === '') return ''
+  const text = String(value).trim()
+  // 只认纯粹的十进制数字，其余一律放行（见上方边界说明）
+  if (!/^[+-]?\d*\.?\d+$/.test(text)) return ''
+  const decimals = text.split('.')[1]?.length ?? 0
+  return decimals > precision ? `最多 ${precision} 位小数` : ''
+}
+
+/**
+ * 展示态取值：返回**格式化后的字符串，或原值**（由调用方决定要不要再 `String()`）。
+ *
+ * 优先级：
+ *   1. `format` 是函数 → 直接交给它。业务既然接管了显示，组件就不插手 ——
+ *      注意精度仍然照常参与**校验**，两者正交；
+ *   2. 精度不合法 → **原样返回**。理由见 types.ts 里 `precision` 的注释：
+ *      把 `123.456` 格式化成 `123.46` 会让屏幕完全合规、数据却不合规；
+ *   3. `format` 是对象 / 只配了 `precision` → 走底座的 `formatNumber`：
+ *      小数位取 `format.decimals ?? precision`（一处真源）；
+ *   4. 什么都没配 → 原样返回。**这是零开销路径，多数列走它。**
+ */
+export function formatDisplayValue<T extends TableRow>(
+  value: unknown,
+  row: T,
+  col: G3TableColumn<T>,
+  precision: number | undefined,
+): unknown {
+  const format = col.format
+  if (typeof format === 'function') return format(value, row, col)
+  if (precision === undefined && format === undefined) return value
+  if (checkPrecision(value, precision).length > 0) return value
+
+  const options: FormatNumberOptions = {
+    ...format,
+    decimals: format?.decimals ?? precision,
+    // 只配了 precision 时**不要**隐式打开千分位：precision 的语义只是「小数位数」，
+    // 要不要千分位是 format 的事（底座默认开，这里显式关掉，免得越界改观感）
+    thousands: format ? (format.thousands ?? true) : false,
+  }
+  return formatNumber(value, options)
+}
+
+/**
+ * 纯展示列（**没有** `editor`）配了 `format` 时用的单元格渲染。
+ *
+ * 有 `editor` 的列走 `createEditableCell`（它内部同样调 `formatDisplayValue`），
+ * 这一条只服务「不可编辑但想格式化」的列 —— `format` 的语义不该因为
+ * 「这一列能不能改」而变。
+ *
+ * 代价只落在显式配了 `format` 的列上；其它纯展示列照旧走库的原生 td 渲染路径。
+ */
+export function createFormatCell<T extends TableRow>(col: G3TableColumn<T>) {
+  const { e } = useNamespace('table')
+  return (props: { row: T; cellValue: unknown }) =>
+    h(
+      'span',
+      { class: e('cell-display') },
+      String(
+        formatDisplayValue(props.cellValue, props.row, col, resolvePrecision(col, props.row)) ?? '',
+      ),
+    )
+}