gis-view-webgl2 0.1.0 → 0.1.2

package/docs/steps/selftest-scale.html

@@ -34,7 +34,7 @@
 			try {
 				const {
 					createGisView, createConditionMatcher,
-					registerConditionOperator, unregisterConditionOperator, hasConditionOperator, listConditionOperators
+					defineConditionOperator, registerConditionOperator, unregisterConditionOperator, hasConditionOperator, listConditionOperators
 				} = await import('../../src/gis-view/index.js')
 				const { compileCondition } = await import('../../src/gis-view/condition.js')
 				const { createPointGrid, createSegmentGrid } = await import('../../src/gis-view/utils.js')
@@ -148,12 +148,14 @@
 				check('regex 带 g 标志时逐条判定不来回翻转（编译时去掉 g / y）', ['站A', '站B', '站C', '站D'].every(id => globalRegex({ id }) === true), ['站A', '站B', '站C', '站D'].map(id => globalRegex({ id })).join(' / '))
 				/* 2.8 自定义运算符：注册之后显式条件 / 简写映射 / 规则 / 筛选都认；注销按认不出来处理；重名与坏工厂只报 onWarning */
 				const operatorWarnings = []
-				const operatorView = createGisView(host(400, 240), {
+				const operatorHost = host(400, 240)
+				const operatorView = createGisView(operatorHost, {
 					points: [
-						{ id: 'op0', x: 0, y: 0, vn_kv: 4 },
-						{ id: 'op1', x: 100, y: 0, vn_kv: 5 },
-						{ id: 'op2', x: 200, y: 0, vn_kv: 6 }
+						{ id: 'op0', x: 0, y: 0, vn_kv: 4, name: '偶数甲' },
+						{ id: 'op1', x: 100, y: 0, vn_kv: 5, name: '奇数乙' },
+						{ id: 'op2', x: 200, y: 0, vn_kv: 6, name: '偶数丙' }
 					],
+					label: { content: '{name}', when: { vn_kv: { isEven: true } } },
 					filterWorker: false,
 					onWarning: payload => operatorWarnings.push(typeof payload === 'string' ? payload : payload?.message ?? '')
 				})
@@ -181,6 +183,10 @@
 				check('自定义运算符：规则与筛选当场按新注册表重编译（偶数那条上色、奇数那条被筛掉）',
 					operatorHits === 2 && operatorView.getFilterResult().hiddenPoints.length === 1 && operatorView.getFilterResult().hiddenPoints[0] === 1,
 					`上色 ${operatorHits} 条 / 隐藏 ${JSON.stringify(operatorView.getFilterResult().hiddenPoints)}`)
+				const operatorLabels = () => [...operatorHost.querySelectorAll('.gis-view__label[data-label-kind="point"]')]
+				check('自定义运算符：注册之后标签 when 也按新注册表重编译（偶数两条标签出现）',
+					operatorLabels().length === 2 && operatorLabels().every(node => node.textContent.includes('偶数')),
+					operatorLabels().map(node => node.textContent).join(' / '))
 				const operatorCountBefore = operatorView.listOperators().length
 				operatorView.registerOperator('gte', value => () => true)
 				operatorView.registerOperator('', value => () => true)
@@ -197,6 +203,51 @@
 				registerConditionOperator('probeOp', value => () => true)
 				check('自定义运算符：模块级注册与实例读的是同一份表，注销之后两边一起消失',
 					hasConditionOperator('probeOp') === true && operatorView.listOperators().length === 15 && operatorView.unregisterOperator('probeOp') === true && hasConditionOperator('probeOp') === false)
+				const scopedOperator = value => current => current === value
+				const scopedOffA = defineConditionOperator('scopedOp', scopedOperator)
+				const scopedOffB = defineConditionOperator('scopedOp', scopedOperator)
+				const staleOperatorRemoval = scopedOffA()
+				const scopedOperatorSurvived = hasConditionOperator('scopedOp') &&
+					createConditionMatcher({ vn_kv: { scopedOp: 4 } })({ vn_kv: 4 }) === true
+				const activeOperatorRemoval = scopedOffB()
+				const repeatedOperatorRemoval = scopedOffB()
+				check('自定义运算符：同名后注册覆盖时旧清理函数不误删（工厂相同也算新注册），新清理函数正常摘除且幂等',
+					staleOperatorRemoval === false && scopedOperatorSurvived && activeOperatorRemoval === true &&
+					repeatedOperatorRemoval === false && hasConditionOperator('scopedOp') === false,
+					JSON.stringify({ stale: staleOperatorRemoval, survived: scopedOperatorSurvived, active: activeOperatorRemoval, repeated: repeatedOperatorRemoval }))
+				/* 2.9 标签条件的编译缓存：两条不同的 when 轮流求值时，单条缓存会每帧反复落空；
+				   按条件对象身份缓存之后，首次排版各编译一次，后续相机变化只查表。 */
+				let countedCompiles = 0
+				const offCounted = defineConditionOperator('countedLabelOp', value => {
+					countedCompiles += 1
+					return current => (Number(current) % 2 === 0) === (value === true)
+				})
+				const countedHost = host(400, 240)
+				const countedPoints = Array.from({ length: 24 }, (_, index) => ({
+					id: `counted-${index}`,
+					x: (index % 6) * 32,
+					y: Math.floor(index / 6) * 28,
+					vn_kv: index,
+					name: `缓存 ${index}`
+				}))
+				const countedView = createGisView(countedHost, {
+					points: countedPoints,
+					filterWorker: false,
+					label: [
+						{ id: 'even', content: '偶 {name}', when: { vn_kv: { countedLabelOp: true } } },
+						{ id: 'odd', content: '奇 {name}', when: { vn_kv: { countedLabelOp: false } } }
+					]
+				})
+				await settle(160)
+				const countedFirst = countedCompiles
+				const countedCamera = countedView.getCamera()
+				countedView.setCamera({ center: [...countedCamera.center], scale: countedCamera.scale * 3 })
+				await settle(160)
+				check('标签条件缓存：多条不同 when 共用运算符时按对象各自复用（首轮只编译两条，相机变化不再重编译）',
+					countedFirst >= 2 && countedFirst <= 4 && countedCompiles === countedFirst,
+					`首轮 ${countedFirst} 次 / 相机变化后 ${countedCompiles} 次 / 标签 ${countedHost.querySelectorAll('.gis-view__label[data-label-kind="point"]').length} 个`)
+				countedView.destroy()
+				offCounted()
 				operatorView.destroy()
 				/* 2.5 筛选的数组简写：字段值写数组 = 「等于其中之一」（in），字段本身是数组时按「有交集」算 */
 				const arrayPoints = [
@@ -251,6 +302,28 @@
 				byCoordinate.updatePoint('a1', { x: 100, y: 0 })
 				check('坐标联动：点挪回去，线又出来', byCoordinate.getFilterResult().hiddenLines.length === 0, `隐藏线 ${byCoordinate.getFilterResult().hiddenLines.length}`)
 				byCoordinate.destroy()
+				/* 3.2 重复节点 id：引擎端点、筛选投影与按 id 定位统一只认第一条 */
+				const duplicatePointView = createGisView(host(400, 240), {
+					points: [
+						{ id: 'pdup', x: 0, y: 0, vn_kv: 525 },
+						{ id: 'pdup', x: 100, y: 0, vn_kv: 525 },
+						{ id: 'keep', x: 300, y: 0, vn_kv: 525 },
+						{ id: 'gone', x: 0, y: 0, vn_kv: 100 }
+					],
+					lines: [{ id: 'dup-line', from: 'pdup', to: 'keep', vn_kv: 525 }],
+					filterWorker: false
+				})
+				await settle()
+				const duplicatePath = duplicatePointView.getLine('dup-line')?.path ?? []
+				duplicatePointView.setFilter({ points: { vn_kv: { gte: 525 } }, cascade: 'coordinate' })
+				await settle()
+				const duplicateFilterResult = duplicatePointView.getFilterResult()
+				check('重复节点 id：线路端点 / 筛选投影 / 按 id 定位都只认第一条（不是最后一条）',
+					duplicatePath[0]?.[0] === 0 && duplicatePath[0]?.[1] === 0 &&
+					JSON.stringify(duplicateFilterResult.hiddenPoints) === JSON.stringify([3]) &&
+					JSON.stringify(duplicateFilterResult.hiddenLines) === JSON.stringify([0]),
+					JSON.stringify({ path: duplicatePath, hiddenPoints: duplicateFilterResult.hiddenPoints, hiddenLines: duplicateFilterResult.hiddenLines }))
+				duplicatePointView.destroy()
 				/* 3.5 主视图筛选 cascade：被筛掉的节点仍然当锚点用（几何不跟着筛选断，连不连线由 cascade 决定）。
 				   通道回线也是普通线路，从前一端节点被筛掉时整条通道连回线一起消失，cascade 怎么写都没用 */
 				const cascadePoints = [
@@ -338,6 +411,11 @@
 				pointGrid.build([{ x: 0, y: 0 }, { x: 10, y: 10 }, { x: 100, y: 100 }])
 				const boxed = pointGrid.query(5, 5, 15, 15, [])
 				check('点网格照旧：框选只取范围内的格子，远处的点不进候选', boxed.includes(1) && !boxed.includes(2), `候选 ${JSON.stringify(boxed)}`)
+				const boxedEstimate = pointGrid.estimate(5, 5, 15, 15)
+				const cappedGrid = createPointGrid()
+				cappedGrid.build([{ x: 0, y: 0 }, { x: 100, y: 100 }, { x: 200, y: 200 }, { x: 300, y: 300 }])
+				const cappedEstimate = cappedGrid.estimate(0, 0, 300, 300, 0)
+				check('点网格 estimate 与 query 同口径、可提前封顶（不建候选数组也能判断值不值得走网格）', boxedEstimate === boxed.length && boxedEstimate === 2 && cappedEstimate > 0 && cappedEstimate < 4, '估计 ' + boxedEstimate + ' / 候选 ' + boxed.length + ' · 封顶 ' + cappedEstimate + ' / 全量 4')
 				/* 5. 拾取：换了线段索引之后，点与线（含长线）都还拾得到 */
 				const pickPoints = [
 					{ id: 'k0', x: 0, y: 0, name: '甲' },
@@ -368,6 +446,20 @@
 				check('改过字段之后按新值搜得到、旧值搜不到', renamed.points.length === 1 && stale.points.length === 0, `新 ${renamed.points.length} / 旧 ${stale.points.length}`)
 				const byCoordinateHit = view.search({ keyword: '1234.5' }).points
 				check('坐标也参与搜索（缓存里有 x / y）', byCoordinateHit.length === 1 && byCoordinateHit[0].id === 's7', `命中 ${byCoordinateHit.length} 个`)
+				const invalidLimit = view.search({ keyword: '站', limit: Number.NaN })
+				const stringFields = view.search({ keyword: '站', fields: 'name', limit: 5 })
+				check('搜索选项归一：坏 limit 回落到缺省上限，fields 不是数组时不让字符串被拆成逐字字段',
+					invalidLimit.points.length === 200 && invalidLimit.truncated === true && stringFields.points.length === 5,
+					JSON.stringify({ invalid: invalidLimit.points.length, fields: stringFields.points.length }))
+				const styleFieldSearchView = createGisView(host(240, 160), {
+					points: [{ id: 'sf', x: 0, y: 0, name: '普通节点', symbol: 'marker-triangle' }],
+					showGrid: false
+				})
+				const styleFieldHits = styleFieldSearchView.search({ keyword: 'marker-triangle', fields: ['symbol'] })
+				check('搜索显式 fields 指名符号 / 样式字段时不走跳过这些字段的文本缓存预筛',
+					styleFieldHits.points.length === 1 && styleFieldHits.points[0].field === 'symbol',
+					JSON.stringify(styleFieldHits.points.map(hit => ({ field: hit.field, value: hit.value }))))
+				styleFieldSearchView.destroy()
 				const beforeSearch = JSON.stringify(view.getFilterResult().hiddenPoints.length)
 				view.search({ keyword: '站', limit: 5 })
 				check('搜索不改筛选（只找出来，不隐藏）', JSON.stringify(view.getFilterResult().hiddenPoints.length) === beforeSearch, `隐藏点 ${beforeSearch}`)
@@ -461,6 +553,23 @@
 				check('异步搜索：通道整条命中（Worker 那边照样认得出它是哪条）', channelAsync.channels.length === 1 && hitShape(channelAsync) === hitShape(channelView.search({ keyword: '示例通道' })))
 				const memberAsync = await channelView.searchAsync({ keyword: '第二回' })
 				check('异步搜索：命中通道里的回线时带上第几回与它在 lines 里的下标', memberAsync.channels[0]?.memberIndex === 1 && memberAsync.channels[0]?.memberLineIndex === 1 && memberAsync.channels[0]?.memberLineId === 'c2', JSON.stringify({ index: memberAsync.channels[0]?.memberIndex, line: memberAsync.channels[0]?.memberLineId }))
+				const duplicateChannelView = createGisView(host(), {
+					points: [{ id: 'da', x: -100, y: 0 }, { id: 'db', x: 100, y: 0 }],
+					lines: [
+						{ id: 'dup', from: 'da', to: 'db', name: '重复第一回' },
+						{ id: 'dup', from: 'db', to: 'da', name: '重复第二回' }
+					],
+					channels: [{ id: 'dup-ch', name: '重复成员', lineIds: ['dup', 'dup'] }],
+					searchWorker: { threshold: 1 },
+					showGrid: false
+				})
+				const duplicateSync = duplicateChannelView.search({ keyword: '重复第一回' })
+				const duplicateAsync = await duplicateChannelView.searchAsync({ keyword: '重复第一回' })
+				check('异步搜索：重复线路 id 与同步搜索同一口径（只认第一条，通道成员下标一致）',
+					duplicateAsync.channels[0]?.memberIndex === 0 && duplicateAsync.channels[0]?.memberLineIndex === 0 &&
+					duplicateAsync.channels[0]?.memberLineId === 'dup' && hitShape(duplicateAsync) === hitShape(duplicateSync),
+					JSON.stringify({ member: duplicateAsync.channels[0]?.memberIndex, line: duplicateAsync.channels[0]?.memberLineIndex, sync: hitShape(duplicateSync), async: hitShape(duplicateAsync) }))
+				duplicateChannelView.destroy()
 				// 通道自己的字段改过（updateChannel）：Worker 手里那份副本要整份作废重交，
 				// 否则新名字搜不到、旧名字还搜得到 —— 与同步 search 的「结果逐字段一致」当场破掉
 				channelView.updateChannel('ch-1', { name: '改过名的通道' })
@@ -499,7 +608,8 @@
 						...(index % 3 === 0 ? { effect: { period: 2, size: 8, color: '#ff0000' } } : null)
 					}
 				}
-				const bigView = createGisView(host(640, 380), { points: bigPoints, lines: bigLines, quality: 'high', showGrid: false })
+				// 这一组核对发散渲染的槽位账，不测自动降级；显式关掉密集档，避免默认 auto 在 160 ms 后暂停动效干扰计数
+				const bigView = createGisView(host(640, 380), { points: bigPoints, lines: bigLines, quality: 'high', showGrid: false, denseMode: 'off' })
 				const bigDeadline = Date.now() + 30000
 				while (!bigView.isLayoutReady() && Date.now() < bigDeadline) {
 					await settle(50)
@@ -533,7 +643,7 @@
 				check('挪端点之后装饰跟着路径走（只动那一条线的装饰）', !!(movedAt && Math.abs(movedAt[0] - movedSpot[0]) < 0.5 && Math.abs(movedAt[1] - movedSpot[1]) < 0.5), movedAt ? `${movedIndexes.length} 个装饰挪了 → ${movedAt.join(',')}（期望 ${movedSpot.map(value => value.toFixed(1)).join(',')}）` : `${movedIndexes.length} 个装饰挪了（期望 1 个）`)
 				// 抬层：选一个排在很后面的点，它要压到装饰与所有 zIndex 层之上（发散渲染的前缀账接着用）
 				const raisedItem = bigPoints[28000]
-				bigView.select(raisedItem.id)
+				bigView.selectFeatures(raisedItem.id)
 				await settle()
 				const raisedScene = bigView.snapshotScene({ background: false })
 				const raisedSpot = bigView.project(raisedItem.x, raisedItem.y)

package/docs/steps/selftest-select.html

@@ -294,14 +294,14 @@
 				check('selectionKinds 只开 point：Ctrl 点击普通线路不改选中集', ckInfo().pointCount === 2 && ckInfo().lineCount === 0 && ckInfo().channelCount === 0, JSON.stringify({ points: ckInfo().pointCount, lines: ckInfo().lineCount, channels: ckInfo().channelCount }))
 
 				ckView.updateOptions({ selectionKinds: ['line'] })
-				ckView.select(null)
+				ckView.selectFeatures(null)
 				await ckClick(0, 82, { ctrlKey: true })
 				check('selectionKinds 只开 line：Ctrl 点击通道外线路生效', ckInfo().lineCount === 1 && ckInfo().channelCount === 0 && ckView.isSelected('ck-solo'), JSON.stringify({ lines: ckInfo().lineCount, channels: ckInfo().channelCount, ids: ckInfo().ids }))
 				await ckClick(-130, 0, { ctrlKey: true })
 				check('selectionKinds 只开 line：Ctrl 点击节点与通道回线不改选中集', ckInfo().lineCount === 1 && ckInfo().pointCount === 0 && ckInfo().channelCount === 0 && ckView.isSelected('ck-solo'), JSON.stringify({ points: ckInfo().pointCount, lines: ckInfo().lineCount, channels: ckInfo().channelCount }))
 
 				ckView.updateOptions({ selectionKinds: ['channel'] })
-				ckView.select(null)
+				ckView.selectFeatures(null)
 				await ckClick(0, -82, { ctrlKey: true })
 				check('selectionKinds 只开 channel：Ctrl 点击通道回线生效（节点与通道外线路不动）', ckInfo().lineCount === 1 && ckInfo().channelCount === 1 && ckInfo().pointCount === 0 && ckView.isSelected('ck-ch-line') && !ckView.isSelected('ck-solo'), JSON.stringify({ points: ckInfo().pointCount, lines: ckInfo().lineCount, channels: ckInfo().channelCount, ids: ckInfo().ids }))
 				await ckClick(-130, 0, { ctrlKey: true })
@@ -309,11 +309,15 @@
 				check('selectionKinds 只开 channel：Ctrl 点击节点 / 通道外线路都不改选中集', ckInfo().lineCount === 1 && ckInfo().channelCount === 1 && ckInfo().pointCount === 0 && ckView.isSelected('ck-ch-line'), JSON.stringify({ points: ckInfo().pointCount, lines: ckInfo().lineCount, channels: ckInfo().channelCount }))
 
 				ckView.updateOptions({ selectionKinds: ['point', 'line', 'channel'] })
-				ckView.select(null)
+				ckView.selectFeatures(null)
 				await ckClick(-130, 0, { ctrlKey: true })
 				await ckClick(0, 82, { ctrlKey: true })
 				await ckClick(0, -82, { ctrlKey: true })
 				check('selectionKinds 三类全开：一次 Ctrl 多选可混合累加节点 / 线路 / 通道', ckInfo().pointCount === 1 && ckInfo().lineCount === 2 && ckInfo().channelCount === 1 && ckView.isSelected('ck-a') && ckView.isSelected('ck-solo') && ckView.isSelected('ck-ch-line'), JSON.stringify({ points: ckInfo().pointCount, lines: ckInfo().lineCount, channels: ckInfo().channelCount, ids: ckInfo().ids }))
+				ckView.updateOptions({ selectionKinds: 'all' })
+				ckView.selectInBox({ x: 0, y: 0, width: ckBox.width, height: ckBox.height })
+				const ckBoxedInfo = ckView.getSelectionData()
+				check('selectInBox：线路框选与通道摊开沿用同一份判定（整框一次收下节点 / 独立线路 / 通道回线）', ckBoxedInfo.count === 4 && ckBoxedInfo.pointCount === 2 && ckBoxedInfo.lineCount === 2 && ckBoxedInfo.channelCount === 1, JSON.stringify({ items: ckBoxedInfo.count, points: ckBoxedInfo.pointCount, lines: ckBoxedInfo.lineCount, channels: ckBoxedInfo.channelCount }))
 				ckView.destroy()
 				ckHost.remove()
 
@@ -350,18 +354,21 @@
 				check('按通道写法选上整条通道：两条回线都进来', dzView.getSelectionData().count === 2 && dzView.getSelectionData().channelCount === 1, dzIds())
 				dzView.deselect({ type: 'channel', channelId: 'dz-ch' })
 				check('deselect(通道写法)：整条通道的两条回线一起取消', dzView.getSelectionData().count === 0 && dzView.getSelections().length === 0, dzIds())
-				dzView.select('dz-a').select('dz-solo', { mode: 'add' })
-				check('select(refs, options) 与 selectFeatures 同一份 options：链式 add 把两个都选上', dzView.getSelectionData().count === 2 && dzView.isSelected('dz-a') && dzView.isSelected('dz-solo'), dzIds())
-				dzView.select('dz-a', { mode: 'remove' })
-				check('select(refs, { mode: \'remove\' })：与 deselect(refs) 同一件事', dzView.getSelectionData().count === 1 && !dzView.isSelected('dz-a') && dzView.isSelected('dz-solo'), dzIds())
+				dzView.selectFeatures('dz-a').selectFeatures('dz-solo', { mode: 'add' })
+				check('selectFeatures(refs, options) 的链式 add 把两个都选上', dzView.getSelectionData().count === 2 && dzView.isSelected('dz-a') && dzView.isSelected('dz-solo'), dzIds())
+				dzView.selectFeatures('dz-a', { mode: 'remove' })
+				check('selectFeatures(refs, { mode: \'remove\' })：与 deselect(refs) 同一件事', dzView.getSelectionData().count === 1 && !dzView.isSelected('dz-a') && dzView.isSelected('dz-solo'), dzIds())
 				const dzChangesBeforeEmpty = dzChanges.length
 				dzView.deselect([])
 				check('deselect(空数组)：没有目标，什么都不做（也不发选中集变更）', dzView.getSelectionData().count === 1 && dzChanges.length === dzChangesBeforeEmpty, `${dzIds()} / 新增 ${dzChanges.length - dzChangesBeforeEmpty} 条变更`)
 				dzChanges.length = 0
 				dzView.deselect()
-				check('deselect() 不传目标 = 取消全部（= select(null)）', dzView.getSelectionData().count === 0 && dzChanges.length === 1 && dzChanges[0].action?.type === 'clearSelection' && dzChanges[0].cause === 'api', `${dzIds()} / ${dzChanges.length} 条变更 / ${dzChanges[0]?.action?.type}`)
-				const dzChained = dzView.select('dz-a')
-				check('取消全部的老写法 select(null) 也清空，接口都返回实例本身（可以接着链式调）', dzChained === dzView && dzView.select(null) === dzView && dzView.getSelectionData().count === 0, dzIds())
+				check('deselect() 不传目标 = 取消全部（= selectFeatures(null)）', dzView.getSelectionData().count === 0 && dzChanges.length === 1 && dzChanges[0].action?.type === 'clearSelection' && dzChanges[0].cause === 'api', `${dzIds()} / ${dzChanges.length} 条变更 / ${dzChanges[0]?.action?.type}`)
+				const dzChained = dzView.selectFeatures('dz-a')
+				check('selectFeatures(null) 也清空，接口都返回实例本身（可以接着链式调）', dzChained === dzView && dzView.selectFeatures(null) === dzView && dzView.getSelectionData().count === 0, dzIds())
+				check('重复入口已收口：select / updatePoints / updateLines / updateChannels 都不在实例上',
+					dzView.select === undefined && dzView.updatePoints === undefined && dzView.updateLines === undefined && dzView.updateChannels === undefined,
+					JSON.stringify({ select: typeof dzView.select, updatePoints: typeof dzView.updatePoints, updateLines: typeof dzView.updateLines, updateChannels: typeof dzView.updateChannels }))
 				dzView.destroy()
 				dzHost.remove()
 
@@ -419,20 +426,20 @@
 				// 状态样式是后配的：空闲预热 200ms 之后才排（见「状态样式预热」），这一刻新贴图一定还没烤出来 ——
 				// 节点必须拿上一份配色的贴图顶着画，而不是整个不画
 				iconView.updateOptions({ pointSelectStyle: { color: '#e01f1f' } })
-				iconView.select('icon-a')
+				iconView.selectFeatures('icon-a')
 				const heldOn = pixelAt(await iconFrame(), iconAt(0))
 				check('第一次选中 SVG 符号：新贴图还没烤好时先顶上一种配色（不会闪没）', isBlue(heldOn), heldOn.join(','))
 				const settledIcon = await iconFrame(260)
 				check('第一次选中 SVG 符号：烤好之后换成选中样式色（红）', isRed(pixelAt(settledIcon, iconAt(0))), pixelAt(settledIcon, iconAt(0)).join(','))
 				check('第一次选中 SVG 符号：没选中的那一个不受影响（还是自己的配色）', isBlue(pixelAt(settledIcon, iconAt(120))), pixelAt(settledIcon, iconAt(120)).join(','))
-				iconView.select(null)
+				iconView.selectFeatures(null)
 				// 空闲预热：全局状态样式 × 实际用到的贴图组合提前烤好，第一次选中 / 悬停不给烘焙时间也是状态色
 				let prewarmedSelect = false
 				for (let attempt = 0; attempt < 60 && !prewarmedSelect; attempt += 1) {
-					iconView.select('icon-a')
+					iconView.selectFeatures('icon-a')
 					prewarmedSelect = isRed(pixelAt(await iconFrame(), iconAt(0)))
 					if (!prewarmedSelect) {
-						iconView.select(null)
+						iconView.selectFeatures(null)
 						await settle(60)
 					}
 				}
@@ -441,7 +448,7 @@
 				check('getSymbolCombos：状态样式会用到的组合也收进来（喂回 prebake.combos 不重不漏）',
 					iconCombos.some(combo => combo.color === '#e01f1f' && combo.symbol === svgIcon) && iconCombos.some(combo => combo.color === '#1f9d3a' && combo.symbol === svgIcon),
 					JSON.stringify(iconCombos.map(combo => combo.color)))
-				iconView.select(null)
+				iconView.selectFeatures(null)
 				iconView.hoverAt(iconBox.left + iconAt(0)[0], iconBox.top + iconAt(0)[1])
 				const hoveredIcon = pixelAt(await iconFrame(), iconAt(0))
 				check('第一次悬停 SVG 符号：不给烘焙时间也是悬停样式色（绿）', isGreen(hoveredIcon), hoveredIcon.join(','))
@@ -534,7 +541,7 @@
 					}
 				}
 				check('同配方不同尺寸：底色贴图到位后两个节点都是底色描边', strokeColorAt(dualBase, dualSmall) === 'base' && strokeColorAt(dualBase, dualBig) === 'base', `${strokeColorAt(dualBase, dualSmall)} / ${strokeColorAt(dualBase, dualBig)}`)
-				dualView.select('dual-a')
+				dualView.selectFeatures('dual-a')
 				await settle(30)
 				// 小节点的选中贴图还在烤（占位贴图在位）：这一刻把同配方、另一个尺寸的大节点也选上
 				dualView.selectFeatures(['dual-a', 'dual-b'])
@@ -559,4 +566,4 @@
 			document.title = results.some(text => text.startsWith('FAIL') || text.startsWith('ERROR')) ? 'FAIL' : 'PASS'
 		</script>
 	</body>
-</html>
+</html>

package/docs/steps/step-10-full.js

@@ -144,7 +144,7 @@ export const createFullView = (target, options = {}) => {
 		fitView: () => view.fitView(),
 		zoomBy: factor => view.zoomBy(factor),
 		setCamera: camera => view.setCamera(camera),
-		select: input => view.select(input),
+		select: input => view.selectFeatures(input),
 		destroy: () => view.destroy()
 	}
 }

package/docs//346/216/245/345/217/243/345/215/217/350/256/256.md

@@ -33,6 +33,8 @@
 
 服务端必须校验请求头与 body：`Idempotency-Key === opId`、`If-Match === "v" + baseVersion`。不一致返回 `400 BAD_REQUEST`，不要猜以哪一个为准。
 
+仓库里的假后端已经把这三条落实成可执行契约：缺头、头和 body 不一致、`baseVersion` 不是有限数字都返回 `400 BAD_REQUEST`；同一个 `opId` 换了请求体会返回 `409 IDEMPOTENCY_CONFLICT`，且版本不前进。`docs/steps/selftest-demos.html` 直接对这四种情况做断言，接入真实网关时可以拿它当最小联调用例。
+
 ### 2.2 公共 body 字段
 
 | 字段 | 类型 | 必填 | 说明 |
@@ -71,8 +73,8 @@ HTTP `200 OK`：
 | `traceId` | `string` | 全链路追踪 id |
 | `serverTime` | ISO 8601 | 服务端处理完成时间 |
 | `data.operation` | `string` | 实际执行的操作，例如 `copy.batch` |
-| `data.version` | `number` | 成功落库后的新版本；客户端下一次请求用它作 `baseVersion` |
-| `data.idempotent` | `boolean` | `true` 表示命中幂等缓存，没有第二次写库 |
+| `data.version` | `number` | 第一次落库后的版本；客户端下一次请求用它作 `baseVersion`。幂等回放仍是这个版本，可能低于服务端当前版本 |
+| `data.idempotent` | `boolean` | `true` 表示命中幂等缓存，没有第二次写库；资源映射按第一次响应，但不要把本地基线退回到 `data.version` |
 | `data.appliedAt` | ISO 8601 | 第一次真正落库的时间；回放时不变 |
 | `data.transactionId` | `string` | 本次事务 / 版本记录 id，可用于审计 |
 | `data.result` | `object` | 各接口自己的资源级结果，见后文 |
@@ -323,7 +325,7 @@ HTTP `409 Conflict` 示例：
   "channelId": "channel-a",
   "action": { "type": "splitGroups", "groupIds": ["channel-a", "channel-a::2"] },
   "groups": [
-    { "id": "channel-a", "lineIds": ["line-0", "line-1"], "path": [[18.0, 10.2], [20.5, 11.1]] },
+    { "id": "channel-a", "lineIds": ["line-0", "line-1"], "path": [[18.0, 10.2], [20.5, 11.1]], "waypointOffsets": { "1": [1.2, -0.8] } },
     { "id": "channel-a::2", "lineIds": ["line-2"], "path": [] }
   ],
   "baseVersion": 12,
@@ -335,10 +337,11 @@ HTTP `409 Conflict` 示例：
 | --- | --- | --- |
 | `channelId` | `string \| number` | 通道 id，必须与路径参数一致 |
 | `action` | `object` | 审计用动作：`splitGroups` / `mergeGroups` / `moveLine` / `addGroup` / `setGroups`；服务端不应依赖它恢复数据 |
-| `groups` | `Array<{ id, lineIds, path }>` | **整份**分组声明；顺序就是后续回线排布顺序 |
+| `groups` | `Array<{ id, lineIds, path, waypointOffsets? }>` | **整份**分组声明；顺序就是后续回线排布顺序 |
 | `groups[].id` | `string \| number` | 分组稳定 id |
 | `groups[].lineIds` | `Array<string \| number>` | 这一组包含的回线 id；同一条回线在整份声明里只能出现一次 |
 | `groups[].path` | `[number, number][]` | 分组公共骨架的中间拐点；`[]` 是合法的「直连」，不能当成没提交 |
+| `groups[].waypointOffsets` | `Record<string, [number, number] \| { x, y }>` | `vertex` 拖动的分组刚性偏移：键是含首尾端点的骨架顶点序号（只认中间拐点），值是组内所有回线共用的世界坐标增量；省略或空对象表示不带偏移 |
 
 `groups` 至少保留一组。若业务允许空通道，建议另走 `DELETE /gis/channels/{channelId}`，不要把空分组声明当作删除通道的隐式约定。
 
@@ -348,7 +351,7 @@ HTTP `409 Conflict` 示例：
 {
   "channelId": "channel-a",
   "groups": [
-    { "id": "channel-a", "lineIds": ["line-0", "line-1"], "path": [[18.0, 10.2], [20.5, 11.1]] },
+    { "id": "channel-a", "lineIds": ["line-0", "line-1"], "path": [[18.0, 10.2], [20.5, 11.1]], "waypointOffsets": { "1": [1.2, -0.8] } },
     { "id": "channel-a::2", "lineIds": ["line-2"], "path": [] }
   ],
   "groupCount": 2,
@@ -356,11 +359,11 @@ HTTP `409 Conflict` 示例：
 }
 ```
 
-服务端应校验 channel 存在、`lineIds` 全部属于这条通道且不重复、每个 `path` 点都是有限数值；返回落库后的整份快照，前端用 `groups` 覆盖本地对应通道。
+服务端应校验 channel 存在、`lineIds` 全部属于这条通道且不重复、每个 `path` 点都是有限数值，以及 `waypointOffsets` 的键都落在中间拐点、值都是有限增量；返回落库后的整份快照，前端用 `groups` 覆盖本地对应通道。
 
 ### 5.2 `PATCH /gis/channels/{channelId}/groups/waypoints`
 
-覆盖一条通道里某一组的**公共骨架**。`path` 只包含中间拐点，两端由通道绑定的节点补齐。拖动过程中 `phase: 'start' / 'move'` 不发请求，只在 `add` / `remove` / `end` 发一条。
+覆盖一条通道里某一组的**公共骨架与分组刚性偏移**。`path` 只包含中间拐点，两端由通道绑定的节点补齐；`waypointOffsets` 是 `channelWaypointDragMode: 'vertex'` 拖出来的按骨架序号偏移。拖动过程中 `phase: 'start' / 'move'` 不发请求，只在 `add` / `remove` / `end` 发一条。
 
 请求体：
 
@@ -370,6 +373,7 @@ HTTP `409 Conflict` 示例：
   "channelId": "channel-a",
   "groupId": "channel-a::2",
   "path": [[18.0, 10.2], [20.5, 11.1]],
+  "waypointOffsets": { "1": [1.2, -0.8] },
   "phase": "end",
   "scope": "group",
   "baseVersion": 12,
@@ -382,8 +386,9 @@ HTTP `409 Conflict` 示例：
 | `channelId` | `string \| number` | 通道 id |
 | `groupId` | `string \| number` | 分组 id |
 | `path` | `[number, number][]` | 整份公共骨架的中间拐点；空数组表示直连 |
+| `waypointOffsets` | `Record<string, [number, number] \| { x, y }>` | 分组刚性偏移：键按含首尾端点的骨架序号算，只接受中间拐点；省略或空对象表示普通平行骨架 |
 | `phase` | `'add' \| 'remove' \| 'end'` | 实际落地阶段；`select` / `start` / `move` 不应发请求 |
-| `scope` | `'group'` | 公共骨架的存储范围；组内每条回线的偏移拐点是由它派生的，不单独落库 |
+| `scope` | `'group'` | 公共骨架与分组刚性偏移的存储范围；组内每条回线的车道偏移是由它派生的，不单独落库 |
 
 响应 `data.result`：
 
@@ -391,10 +396,13 @@ HTTP `409 Conflict` 示例：
 {
   "target": { "type": "channelGroup", "channelId": "channel-a", "groupId": "channel-a::2", "scope": "group" },
   "path": [[18.0, 10.2], [20.5, 11.1]],
+  "waypointOffsets": { "1": [1.2, -0.8] },
   "pointCount": 2
 }
 ```
 
+服务端必须把 `path` 与 `waypointOffsets` 一起落库并一起返回：只收 `path` 会丢掉非平行拖动结果，刷新后分组又回到旧骨架。
+
 ### 5.3 `PATCH /gis/lines/{lineId}/path`
 
 覆盖独立线路的整条折线。与通道分组不同，这里 `path` **包含首尾端点**，因为独立线路不依赖通道节点补端点。
@@ -428,7 +436,7 @@ HTTP `409 Conflict` 示例：
 
 1. 组件先在本地生成新节点 / 线路 / 通道并落地，拿到 `revert()` 或整批回滚入口。
 2. 从复制载荷组 `points / lines / channels / lineChannels`，连同 `baseVersion`、`opId` 提交。
-3. 200：接受 `data.version` 作为新基线；按 `idMap` 对账资源 id；清掉失败重试状态。
+3. 200：按 `data.version` 推进本地基线（用 `Math.max(已知版本, data.version)`，幂等回放不能把基线往回退）；按 `idMap` 对账资源 id；清掉失败重试状态。
 4. 网络 / 500：本地结果保留，用**同一个 opId** 原样重试。
 5. 409：先拉最新 / 按业务 rebase；确认后生成**新的 opId** 再提交。
 6. 永久 4xx：调用复制载荷的 `revert()`，把整批本地结果收回。
@@ -444,12 +452,152 @@ HTTP `409 Conflict` 示例：
 ### 6.3 通道分组 / 拐点
 
 1. 只在真实落地的 `add` / `remove` / `end` 发请求；`start` / `move` 的中间态不发。
-2. 请求体永远是操作完成后的**整份** `groups` 或 `path`，从 `view.getChannelGroups()` / `view.getChannelGroupWaypoints()` 重新读。
+2. 请求体永远是操作完成后的**整份** `groups`，或成对的 `path` + `waypointOffsets`，从 `view.getChannelGroups()` / `view.getChannelGroupWaypoints()` 重新读。
 3. 同一条通道的写请求串行发送；拖动期间只保留最后一个 `end`。
-4. 成功用响应里的 `groups` / `path` 覆盖本地快照；如果服务端做了归一化，以服务端为准。
+4. 成功用响应里的 `groups` / `path` / `waypointOffsets` 覆盖本地快照；如果服务端做了归一化，以服务端为准。
 5. 409 优先使用错误包里的 `data.current` 做局部恢复；没有 `current` 时先拉最新文档。
 
-### 6.4 重试与版本
+### 6.4 前端落地映射：拿到 `data.result` 之后
+
+响应字段不要从顶层猜：成功统一读 `response.body.data`，资源级结果在 `data.result`；失败统一读 `response.body.data` 里的 `currentVersion` / `current` / `conflict`。
+
+```js
+const payload = response.body                 // fetch(...).then(r => r.json())
+if (payload.code !== 'OK') {
+  throw new Error(`${payload.code}: ${payload.message}`)
+}
+// 幂等回放的 version 是第一次落库的版本，可能低于本地已知版本；只前进、不回退。
+const version = Math.max(knownVersion, payload.data.version)
+knownVersion = version                         // 下一次请求的 baseVersion
+const result = payload.data.result            // 各接口自己的资源结果
+const replayed = payload.data.idempotent      // true = 幂等回放，不要重复应用资源
+```
+
+#### 复制：按 `idMap` 改写引用，按 `counts` 对账
+
+```js
+const { created, counts, idMap } = result
+const pointMap = new Map(idMap.points.map(item => [String(item.clientId), item.id]))
+const lineMap = new Map(idMap.lines.map(item => [String(item.clientId), item.id]))
+const channelMap = new Map(idMap.channels.map(item => [String(item.clientId), item.id]))
+
+// 服务端保留客户端 id 时映射是恒等的；只有 id 真的变了才需要改写本地引用。
+const nextPoints = request.body.points.map(point => ({
+  ...point,
+  id: pointMap.get(String(point.id)) ?? point.id
+}))
+const nextLines = request.body.lines.map(line => ({
+  ...line,
+  id: lineMap.get(String(line.id)) ?? line.id,
+  from: pointMap.get(String(line.from)) ?? line.from,
+  to: pointMap.get(String(line.to)) ?? line.to
+}))
+const nextChannels = request.body.channels.map(channel => {
+  const id = channelMap.get(String(channel.id)) ?? channel.id
+  const groups = (channel.groups ?? []).map(group => ({
+    ...group,
+    id: group.id === channel.id ? id : group.id,
+    lineIds: group.lineIds.map(lineId => lineMap.get(String(lineId)) ?? lineId)
+  }))
+  return {
+    ...channel,
+    id,
+    from: pointMap.get(String(channel.from)) ?? channel.from,
+    to: pointMap.get(String(channel.to)) ?? channel.to,
+    lineIds: (channel.lineIds ?? groups.flatMap(group => group.lineIds)).map(lineId => lineMap.get(String(lineId)) ?? lineId),
+    groups
+  }
+})
+
+if (counts.points !== nextPoints.length || counts.lines !== nextLines.length || counts.channels !== nextChannels.length) {
+  throw new Error('服务端 counts 与本地复制结果不一致：先拉最新文档再 rebase，不要继续编辑')
+}
+view.updateData(nextPoints, nextLines, nextChannels)
+```
+
+`created` 是服务端实际落库的资源摘要，适合做列表刷新 / 审计；`counts` 用来和请求体的 `points / lines / channels` 长度对账；`idMap` 是唯一可靠的 id 改写来源。幂等回放时 `replayed === true`，资源已经存在，**不要再插入一遍**，只接受 `version` 与这份映射。
+
+#### 合并：按响应 id 集合核对本地已合并结果
+
+```js
+const { retainedPointIds, removedPointIds, removedLineIds, removedChannelIds } = result
+// 本地在确认合并时已经落地；这里做的是对账，不是把整笔事务再执行一遍。
+const ids = new Set(view.getData().points.map(point => String(point.id)))
+const missingRetained = retainedPointIds.filter(id => !ids.has(String(id)))
+if (missingRetained.length) {
+  throw new Error(`服务端保留了本地不存在的节点：${missingRetained.join(', ')}（拉最新文档）`)
+}
+// 正常成功路径什么都不用删；只有重放 / 重连后的补偿分支才按服务端事务集合清理残留。
+if (compensating) {
+  view.removePoints(removedPointIds)
+  view.removeLines(removedLineIds)
+  for (const id of removedChannelIds) {
+    view.removeChannel(id)
+  }
+}
+```
+
+正常成功路径不要主动再删一次：`mergeSelectedPoints` / 拖拽确认已经在本地完成合并，响应只用于确认 `retainedPointIds` 仍存在、被删集合确实不在。只有补偿 / 重连场景才按 `removedPointIds` / `removedLineIds` / `removedChannelIds` 清理残留；顺序是先节点、再线路、最后通道，组件会顺手收拾绑定关系。
+
+#### 分组：用响应 `groups` 整份覆盖
+
+```js
+// groups 是服务端落库后的完整快照，直接覆盖这条通道；path: [] 必须原样保留为直连。
+view.updateChannel(result.channelId, { groups: result.groups })
+```
+
+不要按本地 `action` 再推导一次「哪一组被挪空」；服务端可能重排分组 id、补默认骨架或修正回线顺序，`result.groups` 才是最终声明。`groupCount` / `lineCount` 与 `groups` 对不上时视为响应损坏，先拉最新文档。
+
+#### 拐点：按 `target` 精确覆盖
+
+```js
+if (result.target.type === 'channelGroup') {
+  // 通道分组的 path 只含中间拐点；group 写法精确指向这一组，不会误改第一组。
+  view.updateChannel(result.target.channelId, {
+    group: { id: result.target.groupId, path: result.path }
+  })
+}
+else if (result.target.type === 'line') {
+  // 独立线路的 path 含首尾端点，正好是 updateLine({ path }) 的写法。
+  view.updateLine(result.target.lineId, { path: result.path })
+}
+```
+
+`path: []` 是合法结果（直连），不要用 `if (result.path)` 判断后跳过。通道分组和独立线路的 `path` 口径不同：前者只写中间拐点，后者是整条折线；把两者混用会把首尾端点写进分组骨架。
+
+#### 409：先局部恢复，再用新版本 / 新 `opId` rebase
+
+```js
+const failure = response.body.data
+const current = failure.current
+if (current?.groups) {
+  view.updateChannel(current.channelId, { groups: current.groups })
+}
+else if (current?.target?.type === 'channelGroup') {
+  view.updateChannel(current.target.channelId, {
+    group: { id: current.target.groupId, path: current.path }
+  })
+}
+else if (current?.target?.type === 'line') {
+  view.updateLine(current.target.lineId, { path: current.path })
+}
+else {
+  // 没有资源快照：按业务拉最新文档，整份灌回。
+  view.importData(await fetchLatestDocument())
+}
+
+const opId = crypto.randomUUID()              // rebase 是一次新提交，不能复用旧 opId
+const nextBody = {
+  ...rebuildRequestFromCurrentView(),          // 从恢复后的视图重新读整份 groups / path + waypointOffsets
+  baseVersion: failure.currentVersion,
+  opId
+}
+// 请求头同步换：Idempotency-Key = opId，If-Match = `"v${failure.currentVersion}"`
+```
+
+`data.current` 只保证是**这一笔操作涉及资源**的最新快照（通道分组 / 拐点能直接给；复制 / 合并通常没有），不要把它当成整份文档。`VERSION_CONFLICT` 可以 rebase；`IDEMPOTENCY_CONFLICT` 不可以，它是客户端把同一个 `opId` 用在了不同请求体上，必须换新 `opId` 重新组请求。
+
+### 6.5 重试与版本
 
 | 场景 | opId | baseVersion | 本地数据 |
 | --- | --- | --- | --- |
@@ -461,7 +609,7 @@ HTTP `409 Conflict` 示例：
 
 重试要有退避（例如 300ms / 800ms / 2s）和上限。幂等缓存的保留时间建议至少覆盖客户端最大重试窗口，例如 24 小时；跨天的长事务另存审计记录。
 
-## 7. 后端落库清单
+## 8. 后端落库清单
 
 - **幂等表**：`(tenant_id, actor_id, op_id)` 唯一；保存请求哈希、HTTP 状态、响应 JSON、应用后的版本、创建时间。回放直接返回第一次响应并把 `data.idempotent` 改成 `true`。
 - **版本锁**：事务开始时 `SELECT ... FOR UPDATE` 锁定文档版本；或 `UPDATE document SET version = version + 1 WHERE id = ? AND version = ?`，影响行数为 0 就返回 409。
@@ -469,23 +617,23 @@ HTTP `409 Conflict` 示例：
 - **事务边界**：成功应用与幂等记录、版本推进在同一个数据库事务里提交；否则会出现「数据已写但幂等表没写」的重复应用风险。
 - **稳定 id**：所有分组、线路、通道都优先按 id 对账，不要用数组下标当业务主键。客户端生成 id 时，后端要校验唯一性。
 - **空 `path`**：是合法值，表示直连。校验时只检查「是否是数组 + 坐标是否有限」，不要用 truthy 判断吞掉空数组。
-- **响应快照**：分组 / 拐点接口返回落库后的最新 `groups` / `path`；复制返回 `idMap`；合并返回事务实际涉及的 id 集合。
+- **响应快照**：分组 / 拐点接口返回落库后的最新 `groups` / `path` / `waypointOffsets`；复制返回 `idMap`；合并返回事务实际涉及的 id 集合。
 - **审计**：记录 `requestId` / `traceId` / `opId` / `transactionId` / `actor` / 资源 id，日志里不要只记一个 URL。
 - **顺序**：同文档的写请求按版本串行；客户端也应对同一条通道 / 同一份文档做串行化，避免多个成功响应相互覆盖。
 
-## 8. Demo 对照
+## 9. Demo 对照
 
 | 演示页 | 操作 | 请求 | 响应里重点看 |
 | --- | --- | --- | --- |
 | 批量复制与合并 | 框选后复制 | `POST /gis/copies/batch` | `transactionId`、`created`、`counts`、`idMap` |
 | 批量复制与合并 | 拖拽 / 选中后合并 | `POST /gis/merges` | `retainedPointIds`、`removedPointIds`、删线 / 删通道 id |
 | 通道与数据 | 拆 / 并 / 挪回线 / 新建组 | `PATCH /gis/channels/{id}/groups` | `groups` 最新快照、`groupCount`、`lineCount` |
-| 通道与数据 | 通道分组加 / 删 / 拖拐点 | `PATCH /gis/channels/{id}/groups/waypoints` | `target`、`path`、`pointCount` |
+| 通道与数据 | 通道分组加 / 删 / 拖拐点 | `PATCH /gis/channels/{id}/groups/waypoints` | `target`、`path`、`waypointOffsets`、`pointCount` |
 | 通道与数据 | 独立线路拐点 | `PATCH /gis/lines/{id}/path` | `target`、`path`、`pointCount` |
 
 两个演示的面板都提供：正常 200、网络失败、服务端 500、版本冲突 409；“重试最近失败请求”保留原 `opId`，「重放最近成功请求」用于验证幂等回放不推进版本。请求预览区会同时打印请求头、body、HTTP 状态与完整响应包。
 
-## 9. 最小验收用例
+## 10. 最小验收用例
 
 1. 同一复制请求连续提交两次：第二次 HTTP 200、`data.idempotent: true`、版本不再增加、资源不重复。
 2. 复制请求网络失败后原样重试：服务端只落一次，返回与第一次一致的 `transactionId` / 资源 id。
@@ -494,3 +642,5 @@ HTTP `409 Conflict` 示例：
 5. 删除分组最后一个拐点：请求 `path: []` 被接受，服务端落库为直连。
 6. 合并事务中任何一条线路校验失败：节点、线路、通道全部回滚，版本不前进。
 7. 同一文档两笔并发写：只有一笔成功推进版本，另一笔得到 409，不出现静默覆盖。
+8. 请求头与 body 不一致：`Idempotency-Key` 不等于 `body.opId`，或 `If-Match` 不等于 `"v" + baseVersion`，返回 `400 BAD_REQUEST`，版本不前进。
+9. 同一个 `opId` 换一份请求体：返回 `409 IDEMPOTENCY_CONFLICT`，不返回第一次的成功结果，版本不前进。

package/docs//346/225/260/346/215/256/346/240/274/345/274/217.md

@@ -14,7 +14,7 @@
 | [拐点装饰与样式](format/03-%E6%8B%90%E7%82%B9%E8%A3%85%E9%A5%B0%E4%B8%8E%E6%A0%B7%E5%BC%8F.md) | waypoints / decorations / 偏移与颜色样式 |
 | [通道与标签](format/04-%E9%80%9A%E9%81%93%E4%B8%8E%E6%A0%87%E7%AD%BE.md) | channels、分组与 parallel_groups、labels |
 | [条件语法](format/05-%E6%9D%A1%E4%BB%B6%E8%AF%AD%E6%B3%95.md) | 写函数 / `{ field, op, value }` / `{ 字段: 值 }` 三种写法 |
-| [导入导出与标准文档](format/06-%E5%AF%BC%E5%85%A5%E5%AF%BC%E5%87%BA%E4%B8%8E%E6%A0%87%E5%87%86%E6%96%87%E6%A1%A3.md) | exportData 的四种格式与接收 == 导出的 full |
+| [导入导出与标准文档](format/06-%E5%AF%BC%E5%85%A5%E5%AF%BC%E5%87%BA%E4%B8%8E%E6%A0%87%E5%87%86%E6%96%87%E6%A1%A3.md) | exportData 的内置五档、自定义导出格式与接收 == 导出的 full |
 | [事件载荷与示例数据](format/07-%E4%BA%8B%E4%BB%B6%E8%BD%BD%E8%8D%B7%E4%B8%8E%E7%A4%BA%E4%BE%8B%E6%95%B0%E6%8D%AE.md) | 事件载荷速查 + 示例数据 + 性能与兼容 |
 
 ## 快速跳转