gis-view-webgl2 0.1.4 → 0.1.6

package/docs/steps/selftest-perf.html

@@ -28,78 +28,78 @@
 			// 拾取用的节点：线路只挂在前面 8000 个节点上，取后面的才不会被线抢走命中
 			const clearPoint = 15000
 			try {
-				const { createGisView: createGisViewRaw, QUALITY_LEVELS, QUALITY_MODES, createQualityGovernor, normalizeQualityOptions } = await import('../../src/gis-view/index.js')
-				const { normalizePointCluster, pointClusterZoomActive } = await import('../../src/gis-view/cluster.js')
-				const { createHeatmap } = await import('../../src/gis-view/heatmap.js')
-				const { normalizeDensity, renderDensityField } = await import('../../src/gis-view/density.js')
-				const clusterDefault = normalizePointCluster(true)
-				const clusterClamped = normalizePointCluster({ enabled: true, radius: 2, minPoints: 1, maxZoom: -3 })
-				check('点聚合：true 用缺省档（半径 60 / 最少 2 点 / 不限缩放）',
-					clusterDefault.enabled && clusterDefault.radius === 60 && clusterDefault.minPoints === 2 && clusterDefault.maxZoom === 0,
-					JSON.stringify(clusterDefault))
-				check('点聚合：半径 / 最少点数 / maxZoom 都夹到可用区间', clusterClamped.radius === 8 && clusterClamped.minPoints === 2 && clusterClamped.maxZoom === 0,
-					JSON.stringify(clusterClamped))
-				check('点聚合：maxZoom 按相机比例 / 基准比例判定，超过后展开',
-					pointClusterZoomActive({ enabled: true, maxZoom: 2 }, 1.5, 1) === true && pointClusterZoomActive({ enabled: true, maxZoom: 2 }, 2.1, 1) === false,
-					'1.5× 聚合 / 2.1× 展开')
-				// 性能断言是照「优化档」（限数 + 避让）测的老口径：统一带上 labelOptimize: true
-				const createGisView = (host, options = {}) => createGisViewRaw(host, { labelOptimize: true, ...options })
-				/* ---------------- 热力图语义键：只改密度画法不重采要素 ---------------- */
-				let semanticHeatmapOption = {
-					enabled: true,
-					field: 'value',
-					targets: ['point', 'line'],
-					domain: [0, 100],
-					colors: ['#0b3d91', '#ffd166', '#ff5e5e'],
-					density: { opacity: 1, layer: 'below', radius: 24 }
-				}
-				const semanticHeatmap = createHeatmap(() => semanticHeatmapOption, () => [])
-				const styleKeyBefore = semanticHeatmap.styleKey()
-				const weightKeyBefore = semanticHeatmap.weightKey()
-				semanticHeatmapOption = {
-					...semanticHeatmapOption,
-					density: { ...semanticHeatmapOption.density, opacity: 0.25, layer: 'top', radius: 40 }
-				}
-				check('热力图语义键：只改 density 的透明度 / 画层 / 核半径，样式键与权重键都不变',
-					semanticHeatmap.styleKey() === styleKeyBefore && semanticHeatmap.weightKey() === weightKeyBefore)
-				const densityOnlyStyleKey = semanticHeatmap.styleKey()
-				const densityOnlyWeightKey = semanticHeatmap.weightKey()
-				semanticHeatmapOption = { ...semanticHeatmapOption, colors: ['#123456', '#7ce0b0', '#ff8a3d'] }
-				check('热力图语义键：换色带只改样式键，权重键保持不动',
-					semanticHeatmap.styleKey() !== densityOnlyStyleKey && semanticHeatmap.weightKey() === densityOnlyWeightKey)
-				const colorWeightKey = semanticHeatmap.weightKey()
-				semanticHeatmapOption = { ...semanticHeatmapOption, field: 'score' }
-				check('热力图语义键：换取值字段时两个键都变（密度场要重新采样）',
-					semanticHeatmap.weightKey() !== colorWeightKey && semanticHeatmap.styleKey() !== densityOnlyStyleKey)
-
-				/* ---------------- 热力图密度场：透明边缘的 RGB 预乘 alpha ---------------- */
-				const premultOptions = normalizeDensity({ style: 'smooth', max: 1, radius: 6, resolution: 64, threshold: 0, core: 0 })
-				const premultPalette = {
-					bands: [[1, 0, 0, 1]],
-					smooth: [[1, 0, 0, 1], [1, 0, 0, 1]],
-					core: null
-				}
-				const premultField = renderDensityField([{ x: 0, y: 0, ratio: 1 }], premultOptions, premultPalette)
-				let premultPartial = 0
-				let premultBad = 0
-				if (premultField) {
-					for (let offset = 0; offset < premultField.pixels.length; offset += 4) {
-						const alpha = premultField.pixels[offset + 3]
-						if (alpha === 0 || alpha === 255) {
-							continue
-						}
-						premultPartial += 1
-						// 纯红色带：预乘后 R 应与 A 同值、G/B 都还是 0；旧实现固定写 R=255，透明边缘会发灰。
-						if (premultField.pixels[offset] !== alpha || premultField.pixels[offset + 1] !== 0 || premultField.pixels[offset + 2] !== 0) {
-							premultBad += 1
-						}
-					}
-				}
-				check('热力图密度场：透明边缘的 RGB 已预乘（R 跟 A 同降、G/B 为 0，不再留灰边）',
-					Boolean(premultField) && premultPartial > 0 && premultBad === 0,
-					`${premultField?.width ?? 0}×${premultField?.height ?? 0} / 半透明 ${premultPartial} 格 / 未预乘 ${premultBad} 格`)
-
-				/* ---------------- 档位表与归一（纯函数） ---------------- */
+				const { createGisView: createGisViewRaw, QUALITY_LEVELS, QUALITY_MODES, createQualityGovernor, normalizeQualityOptions } = await import('../../src/gis-view/index.js')
+				const { normalizePointCluster, pointClusterZoomActive } = await import('../../src/gis-view/cluster.js')
+				const { createHeatmap } = await import('../../src/gis-view/heatmap.js')
+				const { normalizeDensity, renderDensityField } = await import('../../src/gis-view/density.js')
+				const clusterDefault = normalizePointCluster(true)
+				const clusterClamped = normalizePointCluster({ enabled: true, radius: 2, minPoints: 1, maxZoom: -3 })
+				check('点聚合：true 用缺省档（半径 60 / 最少 2 点 / 不限缩放）',
+					clusterDefault.enabled && clusterDefault.radius === 60 && clusterDefault.minPoints === 2 && clusterDefault.maxZoom === 0,
+					JSON.stringify(clusterDefault))
+				check('点聚合：半径 / 最少点数 / maxZoom 都夹到可用区间', clusterClamped.radius === 8 && clusterClamped.minPoints === 2 && clusterClamped.maxZoom === 0,
+					JSON.stringify(clusterClamped))
+				check('点聚合：maxZoom 按相机比例 / 基准比例判定，超过后展开',
+					pointClusterZoomActive({ enabled: true, maxZoom: 2 }, 1.5, 1) === true && pointClusterZoomActive({ enabled: true, maxZoom: 2 }, 2.1, 1) === false,
+					'1.5× 聚合 / 2.1× 展开')
+				// 性能断言是照「优化档」（限数 + 避让）测的老口径：统一带上 labelOptimize: true
+				const createGisView = (host, options = {}) => createGisViewRaw(host, { labelOptimize: true, ...options })
+				/* ---------------- 热力图语义键：只改密度画法不重采要素 ---------------- */
+				let semanticHeatmapOption = {
+					enabled: true,
+					field: 'value',
+					targets: ['point', 'line'],
+					domain: [0, 100],
+					colors: ['#0b3d91', '#ffd166', '#ff5e5e'],
+					density: { opacity: 1, layer: 'below', radius: 24 }
+				}
+				const semanticHeatmap = createHeatmap(() => semanticHeatmapOption, () => [])
+				const styleKeyBefore = semanticHeatmap.styleKey()
+				const weightKeyBefore = semanticHeatmap.weightKey()
+				semanticHeatmapOption = {
+					...semanticHeatmapOption,
+					density: { ...semanticHeatmapOption.density, opacity: 0.25, layer: 'top', radius: 40 }
+				}
+				check('热力图语义键：只改 density 的透明度 / 画层 / 核半径，样式键与权重键都不变',
+					semanticHeatmap.styleKey() === styleKeyBefore && semanticHeatmap.weightKey() === weightKeyBefore)
+				const densityOnlyStyleKey = semanticHeatmap.styleKey()
+				const densityOnlyWeightKey = semanticHeatmap.weightKey()
+				semanticHeatmapOption = { ...semanticHeatmapOption, colors: ['#123456', '#7ce0b0', '#ff8a3d'] }
+				check('热力图语义键：换色带只改样式键，权重键保持不动',
+					semanticHeatmap.styleKey() !== densityOnlyStyleKey && semanticHeatmap.weightKey() === densityOnlyWeightKey)
+				const colorWeightKey = semanticHeatmap.weightKey()
+				semanticHeatmapOption = { ...semanticHeatmapOption, field: 'score' }
+				check('热力图语义键：换取值字段时两个键都变（密度场要重新采样）',
+					semanticHeatmap.weightKey() !== colorWeightKey && semanticHeatmap.styleKey() !== densityOnlyStyleKey)
+
+				/* ---------------- 热力图密度场：透明边缘的 RGB 预乘 alpha ---------------- */
+				const premultOptions = normalizeDensity({ style: 'smooth', max: 1, radius: 6, resolution: 64, threshold: 0, core: 0 })
+				const premultPalette = {
+					bands: [[1, 0, 0, 1]],
+					smooth: [[1, 0, 0, 1], [1, 0, 0, 1]],
+					core: null
+				}
+				const premultField = renderDensityField([{ x: 0, y: 0, ratio: 1 }], premultOptions, premultPalette)
+				let premultPartial = 0
+				let premultBad = 0
+				if (premultField) {
+					for (let offset = 0; offset < premultField.pixels.length; offset += 4) {
+						const alpha = premultField.pixels[offset + 3]
+						if (alpha === 0 || alpha === 255) {
+							continue
+						}
+						premultPartial += 1
+						// 纯红色带：预乘后 R 应与 A 同值、G/B 都还是 0；旧实现固定写 R=255，透明边缘会发灰。
+						if (premultField.pixels[offset] !== alpha || premultField.pixels[offset + 1] !== 0 || premultField.pixels[offset + 2] !== 0) {
+							premultBad += 1
+						}
+					}
+				}
+				check('热力图密度场：透明边缘的 RGB 已预乘（R 跟 A 同降、G/B 为 0，不再留灰边）',
+					Boolean(premultField) && premultPartial > 0 && premultBad === 0,
+					`${premultField?.width ?? 0}×${premultField?.height ?? 0} / 半透明 ${premultPartial} 格 / 未预乘 ${premultBad} 格`)
+
+				/* ---------------- 档位表与归一（纯函数） ---------------- */
 				check('QUALITY_MODES 是五档：四个固定档 + auto', QUALITY_MODES.join(',') === 'high,balanced,lean,fast,auto', QUALITY_MODES.join(','))
 				check('QUALITY_LEVELS 从高到低，越往下省得越多', QUALITY_LEVELS.length === 4 &&
 					QUALITY_LEVELS[0].glow && QUALITY_LEVELS[0].ornament && QUALITY_LEVELS[0].scale === 1 &&
@@ -144,72 +144,72 @@
 					smoothGovernor.sample(0.2, 16.7)
 				}
 				check('自动档：60Hz 的正常间隔（16.7ms）不会误判成超标', smoothGovernor.state().name === 'high', smoothGovernor.state().name)
-				const fixed = createQualityGovernor('balanced')
-				fixed.sample(50)
-				check('固定档不受帧耗时影响', fixed.state().name === 'balanced' && fixed.state().glow === false && fixed.state().scale === 1, `${fixed.state().name} glow=${fixed.state().glow}`)
-
-				/* ---------------- 视口可见性：离开视口停动画，回来再续 ---------------- */
-				const visibilityHost = document.createElement('div')
-				visibilityHost.style.cssText = 'position:fixed;left:-10000px;top:0;width:320px;height:200px'
-				document.body.append(visibilityHost)
-				const visibilityView = createGisView(visibilityHost, {
-					points: [{ id: 'visibility-point', x: 0, y: 0 }],
-					lines: [],
-					effects: { point: { radius: 16, period: 1.5, count: 1 } },
-					showGrid: false
-				})
-				visibilityView.fitView()
-				await sleep(260)
-				const hiddenAnimating = visibilityView.getStats().animating
-				visibilityHost.style.left = '0px'
-				await sleep(260)
-				const shownAnimating = visibilityView.getStats().animating
-				check('画布离开视口时连续动画停住，回到视口后再继续',
-					hiddenAnimating === false && shownAnimating === true,
-					`视口外 animating=${hiddenAnimating} / 视口内 animating=${shownAnimating}`)
-				visibilityView.destroy()
-				visibilityHost.remove()
-
-				/* ---------------- 大数据密集档：手动开关 / auto 阈值 / 效果恢复 ---------------- */
-				const denseHost = document.createElement('div')
-				denseHost.style.cssText = 'width:420px;height:280px'
-				document.querySelector('#map').append(denseHost)
-				const densePoints = Array.from({ length: 10 }, (unused, index) => ({ id: `dp-${index}`, x: index * 20, y: index % 3 * 20, name: `密集 ${index}` }))
-				const denseView = createGisView(denseHost, {
-					points: densePoints,
-					lines: [],
-					width: 420,
-					height: 280,
-					denseMode: 'on'
-				})
-				const denseOn = denseView.getStats().dense
-				check('密集档 on：读数 active / reason=manual-on，动画整体暂停', denseOn?.active === true && denseOn?.reason === 'manual-on' && denseView.getEffects().enabled === false, JSON.stringify(denseOn))
-				// 密集期间改动画配置：有效配置仍关着，但用户写的那一份要留在 options 里
-				denseView.updateOptions({ effects: { point: { radius: 12, period: 2, count: 1 } } })
-				check('密集期间下发 effects：有效配置仍暂停（用户配置留待退出后恢复）', denseView.getEffects().enabled === false && denseView.getOptions().effects?.point?.radius === 12, JSON.stringify(denseView.getEffects()))
-				denseView.updateOptions({ denseMode: 'off' })
-				await sleep(30)
-				check('密集档 off：动画按用户配置恢复', denseView.getStats().dense?.active === false && denseView.getStats().dense?.reason === 'manual-off' && denseView.getEffects().enabled === true, JSON.stringify({ dense: denseView.getStats().dense, effects: denseView.getEffects().enabled }))
-				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 6, densityThreshold: 1e9, pointThreshold: 1e9 } })
-				await sleep(240)
-				const denseAuto = denseView.getStats().dense
-				check('密集档 auto：可见节点越过 visibleThreshold 时自动进入（reason=visible）', denseAuto?.active === true && denseAuto?.reason === 'visible' && denseAuto?.visiblePoints >= 6, JSON.stringify(denseAuto))
-				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 100, densityThreshold: 20, pointThreshold: 1e9 } })
-				await sleep(240)
-				const denseDensity = denseView.getStats().dense
-				check('密集档 auto：屏幕密度越线也能进入（reason=density）', denseDensity?.active === true && denseDensity?.reason === 'density', JSON.stringify(denseDensity))
-				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 999, densityThreshold: 1e9, pointThreshold: 5 } })
-				await sleep(240)
-				const denseTotal = denseView.getStats().dense
-				check('密集档 auto：数据总量越线直接进入（reason=total）', denseTotal?.active === true && denseTotal?.reason === 'total' && denseTotal?.visiblePoints === null, JSON.stringify(denseTotal))
-				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 100, densityThreshold: 1e9, pointThreshold: 1e9 } })
-				await sleep(240)
-				const denseBelow = denseView.getStats().dense
-				check('密集档 auto：阈值以下主动退出（reason=below-threshold）', denseBelow?.active === false && denseBelow?.reason === 'below-threshold' && denseView.getEffects().enabled === true, JSON.stringify(denseBelow))
-				denseView.destroy()
-				denseHost.remove()
-
-				/* ---------------- 大数据量：建场景 / 渲染 / 拾取 / 换档 ---------------- */
+				const fixed = createQualityGovernor('balanced')
+				fixed.sample(50)
+				check('固定档不受帧耗时影响', fixed.state().name === 'balanced' && fixed.state().glow === false && fixed.state().scale === 1, `${fixed.state().name} glow=${fixed.state().glow}`)
+
+				/* ---------------- 视口可见性：离开视口停动画，回来再续 ---------------- */
+				const visibilityHost = document.createElement('div')
+				visibilityHost.style.cssText = 'position:fixed;left:-10000px;top:0;width:320px;height:200px'
+				document.body.append(visibilityHost)
+				const visibilityView = createGisView(visibilityHost, {
+					points: [{ id: 'visibility-point', x: 0, y: 0 }],
+					lines: [],
+					effects: { point: { radius: 16, period: 1.5, count: 1 } },
+					showGrid: false
+				})
+				visibilityView.fitView()
+				await sleep(260)
+				const hiddenAnimating = visibilityView.getStats().animating
+				visibilityHost.style.left = '0px'
+				await sleep(260)
+				const shownAnimating = visibilityView.getStats().animating
+				check('画布离开视口时连续动画停住，回到视口后再继续',
+					hiddenAnimating === false && shownAnimating === true,
+					`视口外 animating=${hiddenAnimating} / 视口内 animating=${shownAnimating}`)
+				visibilityView.destroy()
+				visibilityHost.remove()
+
+				/* ---------------- 大数据密集档：手动开关 / auto 阈值 / 效果恢复 ---------------- */
+				const denseHost = document.createElement('div')
+				denseHost.style.cssText = 'width:420px;height:280px'
+				document.querySelector('#map').append(denseHost)
+				const densePoints = Array.from({ length: 10 }, (unused, index) => ({ id: `dp-${index}`, x: index * 20, y: index % 3 * 20, name: `密集 ${index}` }))
+				const denseView = createGisView(denseHost, {
+					points: densePoints,
+					lines: [],
+					width: 420,
+					height: 280,
+					denseMode: 'on'
+				})
+				const denseOn = denseView.getStats().dense
+				check('密集档 on：读数 active / reason=manual-on，动画整体暂停', denseOn?.active === true && denseOn?.reason === 'manual-on' && denseView.getEffects().enabled === false, JSON.stringify(denseOn))
+				// 密集期间改动画配置：有效配置仍关着，但用户写的那一份要留在 options 里
+				denseView.updateOptions({ effects: { point: { radius: 12, period: 2, count: 1 } } })
+				check('密集期间下发 effects：有效配置仍暂停（用户配置留待退出后恢复）', denseView.getEffects().enabled === false && denseView.getOptions().effects?.point?.radius === 12, JSON.stringify(denseView.getEffects()))
+				denseView.updateOptions({ denseMode: 'off' })
+				await sleep(30)
+				check('密集档 off：动画按用户配置恢复', denseView.getStats().dense?.active === false && denseView.getStats().dense?.reason === 'manual-off' && denseView.getEffects().enabled === true, JSON.stringify({ dense: denseView.getStats().dense, effects: denseView.getEffects().enabled }))
+				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 6, densityThreshold: 1e9, pointThreshold: 1e9 } })
+				await sleep(240)
+				const denseAuto = denseView.getStats().dense
+				check('密集档 auto：可见节点越过 visibleThreshold 时自动进入（reason=visible）', denseAuto?.active === true && denseAuto?.reason === 'visible' && denseAuto?.visiblePoints >= 6, JSON.stringify(denseAuto))
+				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 100, densityThreshold: 20, pointThreshold: 1e9 } })
+				await sleep(240)
+				const denseDensity = denseView.getStats().dense
+				check('密集档 auto：屏幕密度越线也能进入（reason=density）', denseDensity?.active === true && denseDensity?.reason === 'density', JSON.stringify(denseDensity))
+				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 999, densityThreshold: 1e9, pointThreshold: 5 } })
+				await sleep(240)
+				const denseTotal = denseView.getStats().dense
+				check('密集档 auto：数据总量越线直接进入（reason=total）', denseTotal?.active === true && denseTotal?.reason === 'total' && denseTotal?.visiblePoints === null, JSON.stringify(denseTotal))
+				denseView.updateOptions({ denseMode: { mode: 'auto', visibleThreshold: 100, densityThreshold: 1e9, pointThreshold: 1e9 } })
+				await sleep(240)
+				const denseBelow = denseView.getStats().dense
+				check('密集档 auto：阈值以下主动退出（reason=below-threshold）', denseBelow?.active === false && denseBelow?.reason === 'below-threshold' && denseView.getEffects().enabled === true, JSON.stringify(denseBelow))
+				denseView.destroy()
+				denseHost.remove()
+
+				/* ---------------- 大数据量：建场景 / 渲染 / 拾取 / 换档 ---------------- */
 				const pointCount = 20000
 				const lineCount = 8000
 				const points = new Array(pointCount)
@@ -243,6 +243,35 @@
 				const refreshMs = now() - refreshStarted
 				diag('整份重排一帧', `${refreshMs.toFixed(1)} ms（引擎读数 frameMs=${big.getStats().frameMs.toFixed(2)}，drawCalls=${big.getStats().drawCalls}）`)
 				check('大数据量下一帧画得完（有 drawCalls，没有报错）', big.getStats().drawCalls > 0)
+				// getBounds() 缓存：整份解析后直接命中；定向改点 / 改线要立即失效，不能读到旧范围
+				const boundsHost = document.createElement('div')
+				document.querySelector('#map').append(boundsHost)
+				const boundsView = createGisView(boundsHost, {
+					points: [{ id: 'bp0', x: 10, y: 10 }, { id: 'bp1', x: 20, y: 20 }],
+					lines: [{ id: 'bl0', path: [[10, 10], [15, 15]] }],
+					width: 320,
+					height: 200
+				})
+				const boundsBefore = boundsView.getBounds()
+				boundsView.updatePoint('bp0', { x: -100, y: -200 })
+				const boundsAfterPoint = boundsView.getBounds()
+				boundsView.updateLine('bl0', { path: [[-300, -400], [0, 0]] })
+				const boundsAfterLine = boundsView.getBounds()
+				check('数据包围盒缓存：整份解析后命中缓存，定向改点 / 改线都会立即失效',
+					boundsBefore.minX === 10 && boundsAfterPoint.minX === -100 && boundsAfterPoint.minY === -200 && boundsAfterLine.minX === -300 && boundsAfterLine.minY === -400,
+					`${JSON.stringify(boundsBefore)} → ${JSON.stringify(boundsAfterPoint)} → ${JSON.stringify(boundsAfterLine)}`)
+				boundsAfterLine.minX = 99999
+				const boundsAfterMutation = boundsView.getBounds()
+				check('数据包围盒缓存：调用方修改返回值不会污染下一次读数',
+					boundsAfterMutation.minX === -300 && boundsAfterMutation.minY === -400,
+					JSON.stringify(boundsAfterMutation))
+				boundsView.addPoint({ id: 'bp2', x: -600, y: -700 })
+				const boundsAfterAppend = boundsView.getBounds()
+				check('数据包围盒缓存：追加到范围外的节点会立即扩大读数',
+					boundsAfterAppend.minX === -600 && boundsAfterAppend.minY === -700,
+					JSON.stringify(boundsAfterAppend))
+				boundsView.destroy()
+				boundsHost.remove()
 				// 两万个点会走发散渲染：等它铺完再拾取（没铺到的节点按设计不参与拾取）
 				const readyDeadline = now() + 8000
 				while (!big.isLayoutReady() && now() < readyDeadline) {
@@ -265,7 +294,7 @@
 				// 选中 N 个节点时每个节点的连带线路都要算一遍：从前是「N × 全部线路」的比对，
 				// 框选几千个节点、删除确认面板还没弹出来就先卡住了；现在按 id 建表、线路与通道各扫一遍。
 				const impactCount = 8000
-				big.selectFeatures(points.slice(0, impactCount).map(point => point.id))
+				big.selectFeatures(points.slice(0, impactCount).map(point => point.id))
 				const removeStarted = now()
 				const removePlan = big.requestRemove()
 				const removeMs = now() - removeStarted
@@ -274,7 +303,7 @@
 					JSON.stringify(removePlan.counts))
 				diag(`删除确认载荷（选中 ${impactCount} 点 / ${lineCount} 线）`, `${removeMs.toFixed(1)} ms`)
 				removePlan.cancel()
-				big.selectFeatures(null)
+				big.selectFeatures(null)
 
 				/* ---------------- 通道在场时的补点 / 删点：这一轮之前一律回落整份重建 ---------------- */
 				// 通道的成员表按线路下标记、骨架按锚点 id 定：声明逐条没变、没删到回线与锚点时走增量
@@ -382,16 +411,16 @@
 					await sleep(20)
 				}
 				await sleep(300)
-				spriteProbe.selectFeatures(['sprite-0'])
+				spriteProbe.selectFeatures(['sprite-0'])
 				await sleep(500)
-				spriteProbe.selectFeatures(null)
+				spriteProbe.selectFeatures(null)
 				await sleep(200)
 				spriteProbe.refresh()
 				await sleep(120)
 				spriteProbe.refresh()
 				await sleep(120)
 				const spriteCallsBefore = spriteProbe.getStats().drawCalls
-				spriteProbe.selectFeatures(['sprite-0'])
+				spriteProbe.selectFeatures(['sprite-0'])
 				await sleep(200)
 				const spriteCallsAfter = spriteProbe.getStats().drawCalls
 				check('贴图增量建组只多一次绘制调用（编号表与绘制序分开，新建的组不会被画两遍）', spriteCallsAfter - spriteCallsBefore === 1, `${spriteCallsBefore} → ${spriteCallsAfter}`)
@@ -581,23 +610,25 @@
 				}
 				const anchorView = createGisView(anchorHost, { points: anchorPoints, lines: anchorLines, width: 900, height: 560, label: { content: '{name}', maxCount: 200 }, lineLabel: { maxCount: 60 } })
 				await sleep(200)
-				for (let step = 0; step < 6; step += 1) {
-					anchorView.setCamera({ center: [1000 + step * 120, 700 + step * 60], scale: 1.4 })
-					// 用 rAF 等这一步（不能用 sleep）：相机停手后标签层才会照着新视口收一遍候选，
-					// sleep 期间那次「停手重排」会把签名全部量完，后面的读数就被抹平了
-					await new Promise(resolve => requestAnimationFrame(() => resolve()))
-				}
+				for (let step = 0; step < 6; step += 1) {
+					anchorView.setCamera({ center: [1000 + step * 120, 700 + step * 60], scale: 1.4 })
+					// 用 rAF 等这一步：相机每动一下标签层就照着新视口收一遍候选
+					await new Promise(resolve => requestAnimationFrame(() => resolve()))
+				}
+				// 程序化相机运动还有 160ms 的轻量画法窗口，停稳后会补一张全质量帧并再收一次候选。
+				// 先让这一帧落地，再开始计量，后面测到的才是稳态重排，而不是收尾那一帧的噪声。
+				await sleep(800)
 				const anchorStats = { reads: 0, duplicates: 0 }
-				const anchorSeen = new Set()
-				const anchorReads = []
-				const anchorDuplicates = []
+				const anchorSeen = new Set()
+				const anchorReads = []
+				const anchorDuplicates = []
 				const nativeAnchorRect = Element.prototype.getBoundingClientRect
 				Element.prototype.getBoundingClientRect = function (...args) {
-					if (this.classList?.contains('gis-view__label')) {
-						anchorStats.reads += 1
-						// 按标签身份（类型 + 行号 + 标签名）去重：标签节点是循环复用的，按节点去重会把「同一格换了条标签」误判成重复量
-						const anchorKey = `${this.dataset.labelKind}#${this.dataset.labelIndex}#${this.dataset.labelLabel}`
-						if (anchorSeen.has(anchorKey)) {
+					if (this.classList?.contains('gis-view__label')) {
+						anchorStats.reads += 1
+						// 按标签身份（类型 + 行号 + 标签名）去重：标签节点是循环复用的，按节点去重会把「同一格换了条标签」误判成重复量
+						const anchorKey = `${this.dataset.labelKind}#${this.dataset.labelIndex}#${this.dataset.labelLabel}`
+						if (anchorSeen.has(anchorKey)) {
 							anchorStats.duplicates += 1
 						}
 						anchorSeen.add(anchorKey)
@@ -605,9 +636,9 @@
 					return nativeAnchorRect.apply(this, args)
 				}
 				const anchorRound = () => {
-					anchorStats.reads = 0
-					anchorStats.duplicates = 0
-					anchorSeen.clear()
+					anchorStats.reads = 0
+					anchorStats.duplicates = 0
+					anchorSeen.clear()
 				}
 				try {
 					// 跑 6 轮：换锚点（anchorFallback）/ 沿线滑动（slideFallback）会让某一轮补画几十条
@@ -615,21 +646,21 @@
 					// 最后三轮盯的就是「收敛之后一次布局都不读」
 					for (let round = 0; round < 6; round += 1) {
 						anchorRound()
-						anchorView.updateOptions({ label: { content: '{name}', maxCount: 200 }, lineLabel: { maxCount: 60 } })
-						anchorReads.push(anchorStats.reads)
-						anchorDuplicates.push(anchorStats.duplicates)
+						anchorView.updateOptions({ label: { content: '{name}', maxCount: 200 }, lineLabel: { maxCount: 60 } })
+						anchorReads.push(anchorStats.reads)
+						anchorDuplicates.push(anchorStats.duplicates)
 					}
 					// 改一条视口里的标签（下标 = 76 行 × 400 列 + 150 → 世界坐标 1500, 760）：这一轮同样不该整层重量
 					anchorRound()
-					anchorView.updatePoint('a' + (76 * 400 + 150), { name: '改过的名字' })
-					anchorReads.push(anchorStats.reads)
-					anchorDuplicates.push(anchorStats.duplicates)
+					anchorView.updatePoint('a' + (76 * 400 + 150), { name: '改过的名字' })
+					anchorReads.push(anchorStats.reads)
+					anchorDuplicates.push(anchorStats.duplicates)
 				}
 				finally {
 					Element.prototype.getBoundingClientRect = nativeAnchorRect
 				}
- diag('放大后连续整层重排 · 标签量测读数', `逐轮 ${anchorReads.join(' / ')} 次 · 同一轮里重复量 ${anchorDuplicates.join(' / ')} 条（按标签身份去重；旧写法第 1 轮 2662 次里有 1235 次是把同一条标签又量了一遍）`)
-				check('稳态重排（后 3 轮）一次布局都不读（避让盒全走算术）', anchorReads.slice(3, 6).every(value => value === 0), `第 4~6 轮 ${anchorReads.slice(3, 6).join(' / ')} 次`)
+ diag('放大后连续整层重排 · 标签量测读数', `逐轮 ${anchorReads.join(' / ')} 次 · 同一轮里重复量 ${anchorDuplicates.join(' / ')} 条（按标签身份去重；旧写法第 1 轮 2662 次里有 1235 次是把同一条标签又量了一遍）`)
+				check('稳态重排（后 3 轮）一次布局都不读（避让盒全走算术）', anchorReads.slice(3, 6).every(value => value === 0), `第 4~6 轮 ${anchorReads.slice(3, 6).join(' / ')} 次`)
 				// 换落点那条路补画的新标签都是「第一次出现」，各量一次尺寸就进缓存；整段合计要有限，
 				// 真退回「每轮把所有标签都真量一遍」的老写法时这里会立刻爆掉（旧写法一轮 1299 ~ 2662 次）
 				check('稳态重排里补画的新标签只量第一次出现的那一次（合计有限、之后回零）', anchorReads.slice(1, 6).reduce((sum, value) => sum + value, 0) <= 400, `第 2~6 轮合计 ${anchorReads.slice(1, 6).reduce((sum, value) => sum + value, 0)} 次（逐轮 ${anchorReads.slice(1, 6).join(' / ')}）`)
@@ -932,7 +963,7 @@
 				removeView.setFilter({ points: { flag: 'show' }, worker: false })
 				await sleep(60)
 				const hiddenBefore = [...removeView.getFilterResult().hiddenPoints]
-				removeView.selectFeatures('d15000')
+				removeView.selectFeatures('d15000')
 				await sleep(30)
 				const removeRebuildStarted = now()
 				removeView.refresh()
@@ -967,7 +998,7 @@
 				}
 				removedFullView.setCamera(removeCamera)
 				removedFullView.setFilter({ points: { flag: 'show' }, worker: false })
-				removedFullView.selectFeatures('d15000')
+				removedFullView.selectFeatures('d15000')
 				await sleep(80)
 				const removedFullScene = removedFullView.snapshotScene()
 				const removedText = JSON.stringify(removedScene)
@@ -1065,7 +1096,7 @@
 					view.setFilter({ points: { flag: 'show' }, lines: { flag: 'show' }, worker: false })
 				}
 				await sleep(60)
-				lineOnlyView.selectFeatures('q8000')
+				lineOnlyView.selectFeatures('q8000')
 				await sleep(40)
 				let lineOnlyFallbackMs = Infinity
 				for (const id of lineOnlyRemovedIds) {
@@ -1094,7 +1125,7 @@
 				}
 				lineOnlyFullView.setCamera(lineOnlyCamera)
 				lineOnlyFullView.setFilter({ points: { flag: 'show' }, lines: { flag: 'show' }, worker: false })
-				lineOnlyFullView.selectFeatures('q8000')
+				lineOnlyFullView.selectFeatures('q8000')
 				await sleep(80)
 				const lineOnlyScene = lineOnlyView.snapshotScene()
 				const lineOnlyFullScene = lineOnlyFullView.snapshotScene()
@@ -1241,6 +1272,36 @@
 				check('样式快路径：只动线路样式，画出来的线宽照着新配置走',
 					widthAfter.length > 0 && widthAfter.every((width, index) => width > 0 && Math.abs(width - widthBefore[index] * 3) < 0.01),
 					`${widthBefore[0]} -> ${widthAfter[0]}`)
+				// 线路窄样式：只改全局线宽 / 颜色 / 透明度，逐条重算 paint 链并补槽位；dataVersion 与虚线 / 自身样式都不动
+				const lineNarrowVersion = fastView.dataVersion
+				const lineNarrowStarted = now()
+				fastView.updateLineStyle({ width: 7.5, color: '#1aa0b0', opacity: 0.66 })
+				const lineNarrowMs = now() - lineNarrowStarted
+				const lineNarrowStyle = fastView.getLineStyle(2)
+				check('线路窄样式：getLineStyle 读到新的线宽 / 颜色 / 透明度，dataVersion 不变',
+					lineNarrowStyle !== null && Math.abs(lineNarrowStyle.width - 7.5) < 1e-6 && Math.abs(lineNarrowStyle.opacity - 0.66) < 1e-6 &&
+						lineNarrowStyle.color[1] > 0.5 && lineNarrowStyle.color[2] > 0.5 && lineNarrowVersion === fastView.dataVersion,
+					`${JSON.stringify(lineNarrowStyle)} · dataVersion ${lineNarrowVersion} -> ${fastView.dataVersion}`)
+				diag('线路窄样式：2000 条只改全局线宽 / 颜色 / 透明度', `${lineNarrowMs.toFixed(2)} ms`)
+				fastView.updateLine('fl0', { width: 11, color: '#ff0000' })
+				fastView.updateLine('fl1230', { dash: 'dashed' })
+				fastView.updateLineStyle({ width: 3, color: '#33aaff', opacity: 1 })
+				const lineOwnStyle = fastView.getLineStyle(0)
+				const lineDashScene = fastView.snapshotScene()
+				check('线路窄样式：逐线自身线宽 / 颜色优先，全局换色不会覆盖它',
+					lineOwnStyle !== null && Math.abs(lineOwnStyle.width - 11) < 1e-6 && lineOwnStyle.color[0] > 0.99 && lineOwnStyle.color[1] < 0.01,
+					JSON.stringify(lineOwnStyle))
+				check('线路窄样式：只换线宽 / 颜色 / 透明度时虚线图案保持不动', lineDashScene.lines.some(line => Array.isArray(line.dash) && line.dash.length > 0))
+				// 有线路规则时窄路必须让开：规则改出来的宽度 / 颜色仍按规则走，规则外的那条跟着全局样式
+				fastView.updateOptions({ lineRules: [{ when: { id: 'fl2' }, style: { width: 8, color: '#00aa55' } }] })
+				fastView.updateLineStyle({ width: 2, color: '#888888' })
+				const lineRuleStyle = fastView.getLineStyle(2)
+				const lineGlobalStyle = fastView.getLineStyle(3)
+				check('线路窄样式：存在线路规则时回退整份解析，规则优先于新的全局线样式',
+					lineRuleStyle !== null && Math.abs(lineRuleStyle.width - 8) < 1e-6 && lineRuleStyle.color[1] > 0.6 && lineRuleStyle.color[0] < 0.01 &&
+						lineGlobalStyle !== null && Math.abs(lineGlobalStyle.width - 2) < 1e-6,
+					`规则 ${JSON.stringify(lineRuleStyle)} / 全局 ${JSON.stringify(lineGlobalStyle)}`)
+				fastView.updateOptions({ lineRules: [] })
 				// 热力图：值域色带换一份，重上色之后与「一开始就用这份色带」逐字段一致
 				const heatCount = 1200
 				const heatPoints = new Array(heatCount)
@@ -1278,63 +1339,63 @@
 				const heatFreshView = createGisView(heatFreshHost, { points: heatPoints, lines: heatLines, heatmap: heatB, width: 640, height: 380, quality: 'high' })
 				heatFreshView.setCamera({ center: [320, 200], scale: 1 })
 				const heatFreshText = JSON.stringify(heatFreshView.snapshotScene())
-				check('样式快路径：同一份热力图配置原样再发一次，值域按当前数据重算（与整份重建一致）',
-					heatRefreshedText !== heatAfter && heatRefreshedText === heatFreshText,
-					heatRefreshedText === heatFreshText ? `快照 ${heatRefreshedText.length} 字节，逐字段一致` : diffText(heatRefreshedText, heatFreshText))
-				// 密度场：只改 opacity 时复用上一份采样与贴图；换色带 / 换要素值才重烤。
-				// 判断重烤用 heatDensityStats 的对象身份：只改画法那条快路不会换它。
-				const densityOption = {
-					enabled: true,
-					field: 'value',
-					targets: ['point'],
-					domain: [0, 100],
-					colors: ['#0b3d91', '#ffd166', '#ff5e5e'],
-					density: { opacity: 1, radius: 22, resolution: 192, levels: 8 }
-				}
-				const densityHost = document.createElement('div')
-				document.querySelector('#map').append(densityHost)
-				const densityView = createGisView(densityHost, {
-					points: heatPoints,
-					lines: [],
-					heatmap: densityOption,
-					width: 640,
-					height: 380,
-					quality: 'high',
-					showGrid: false,
-					background: null
-				})
-				densityView.fitView()
-				await densityView.whenRendered()
-				await densityView.whenRendered()
-				const densityFirst = densityView.getStats().heatDensity
-				check('热力图密度场：首帧烤出有效场（有采样数、贴图尺寸非零）',
-					Boolean(densityFirst) && densityFirst.samples > 0 && densityFirst.width > 0 && densityFirst.height > 0,
-					JSON.stringify(densityFirst))
-				const opacityOption = { ...densityOption, density: { ...densityOption.density, opacity: 0.35 } }
-				const opacityStarted = now()
-				densityView.updateOptions({ heatmap: opacityOption })
-				const opacityUpdateMs = now() - opacityStarted
-				await densityView.whenRendered()
-				const densityAfterOpacity = densityView.getStats().heatDensity
-				check('热力图密度场：只改 density.opacity 不重采、不重烤（复用同一份烘焙读数）',
-					densityAfterOpacity === densityFirst)
-				const colorOption = { ...opacityOption, colors: ['#123456', '#7ce0b0', '#ff8a3d'] }
-				const colorStarted = now()
-				densityView.updateOptions({ heatmap: colorOption })
-				const colorUpdateMs = now() - colorStarted
-				await densityView.whenRendered()
-				const densityAfterColor = densityView.getStats().heatDensity
-				check('热力图密度场：换色带会重烤（生成新一份烘焙读数）',
-					densityAfterColor !== densityAfterOpacity && densityAfterColor.samples === densityAfterOpacity.samples)
-				densityView.updatePoint('h0', { value: 7 })
-				await densityView.whenRendered()
-				const densityAfterPoint = densityView.getStats().heatDensity
-				check('热力图密度场：定向 updatePoint 改要素值后场跟着重烤（不再停在旧数据上）',
-					densityAfterPoint !== densityAfterColor && densityAfterPoint.samples === densityAfterColor.samples)
-				diag('热力图密度场更新', `纯透明度 ${opacityUpdateMs.toFixed(2)} ms / 换色带 ${colorUpdateMs.toFixed(2)} ms；烘焙 ${densityAfterColor.ms.toFixed(1)} ms`)
-				densityView.destroy()
-				densityHost.remove()
-				heatFreshView.destroy()
+				check('样式快路径：同一份热力图配置原样再发一次，值域按当前数据重算（与整份重建一致）',
+					heatRefreshedText !== heatAfter && heatRefreshedText === heatFreshText,
+					heatRefreshedText === heatFreshText ? `快照 ${heatRefreshedText.length} 字节，逐字段一致` : diffText(heatRefreshedText, heatFreshText))
+				// 密度场：只改 opacity 时复用上一份采样与贴图；换色带 / 换要素值才重烤。
+				// 判断重烤用 heatDensityStats 的对象身份：只改画法那条快路不会换它。
+				const densityOption = {
+					enabled: true,
+					field: 'value',
+					targets: ['point'],
+					domain: [0, 100],
+					colors: ['#0b3d91', '#ffd166', '#ff5e5e'],
+					density: { opacity: 1, radius: 22, resolution: 192, levels: 8 }
+				}
+				const densityHost = document.createElement('div')
+				document.querySelector('#map').append(densityHost)
+				const densityView = createGisView(densityHost, {
+					points: heatPoints,
+					lines: [],
+					heatmap: densityOption,
+					width: 640,
+					height: 380,
+					quality: 'high',
+					showGrid: false,
+					background: null
+				})
+				densityView.fitView()
+				await densityView.whenRendered()
+				await densityView.whenRendered()
+				const densityFirst = densityView.getStats().heatDensity
+				check('热力图密度场：首帧烤出有效场（有采样数、贴图尺寸非零）',
+					Boolean(densityFirst) && densityFirst.samples > 0 && densityFirst.width > 0 && densityFirst.height > 0,
+					JSON.stringify(densityFirst))
+				const opacityOption = { ...densityOption, density: { ...densityOption.density, opacity: 0.35 } }
+				const opacityStarted = now()
+				densityView.updateOptions({ heatmap: opacityOption })
+				const opacityUpdateMs = now() - opacityStarted
+				await densityView.whenRendered()
+				const densityAfterOpacity = densityView.getStats().heatDensity
+				check('热力图密度场：只改 density.opacity 不重采、不重烤（复用同一份烘焙读数）',
+					densityAfterOpacity === densityFirst)
+				const colorOption = { ...opacityOption, colors: ['#123456', '#7ce0b0', '#ff8a3d'] }
+				const colorStarted = now()
+				densityView.updateOptions({ heatmap: colorOption })
+				const colorUpdateMs = now() - colorStarted
+				await densityView.whenRendered()
+				const densityAfterColor = densityView.getStats().heatDensity
+				check('热力图密度场：换色带会重烤（生成新一份烘焙读数）',
+					densityAfterColor !== densityAfterOpacity && densityAfterColor.samples === densityAfterOpacity.samples)
+				densityView.updatePoint('h0', { value: 7 })
+				await densityView.whenRendered()
+				const densityAfterPoint = densityView.getStats().heatDensity
+				check('热力图密度场：定向 updatePoint 改要素值后场跟着重烤（不再停在旧数据上）',
+					densityAfterPoint !== densityAfterColor && densityAfterPoint.samples === densityAfterColor.samples)
+				diag('热力图密度场更新', `纯透明度 ${opacityUpdateMs.toFixed(2)} ms / 换色带 ${colorUpdateMs.toFixed(2)} ms；烘焙 ${densityAfterColor.ms.toFixed(1)} ms`)
+				densityView.destroy()
+				densityHost.remove()
+				heatFreshView.destroy()
 				heatFreshHost.remove()
 				heatView.destroy()
 				heatHost.remove()
@@ -1811,18 +1872,18 @@
 				document.body.appendChild(thinHost)
 				const thinPoints = Array.from({ length: 12 }, (unused, index) => ({ id: `tp-${index}`, x: index * 10, y: index % 3 * 6, name: `小点 ${index}` }))
 				const thinLines = thinPoints.slice(1).map((point, index) => ({ id: `tl-${index}`, from: thinPoints[index].id, to: point.id }))
-				const thinView = createGisView(thinHost, {
+				const thinView = createGisView(thinHost, {
 					points: thinPoints,
 					lines: thinLines,
 					pointStyle: { size: 6 },
 					lineStyle: { width: 1 },
 					fitPadding: 20,
 					// 交互期的那几条读数（细线快路径 / 后备缓冲）靠拖动触发：平移显式打开
-					features: { pan: true }
-				})
-				// 页面底部的临时画布先滚进视口：动画与交互帧只在可见时连续推进
-				thinHost.scrollIntoView({ block: 'center', inline: 'nearest' })
-				await sleep(400)
+					features: { pan: true }
+				})
+				// 页面底部的临时画布先滚进视口：动画与交互帧只在可见时连续推进
+				thinHost.scrollIntoView({ block: 'center', inline: 'nearest' })
+				await sleep(400)
 				const thinCanvas = thinHost.querySelector('canvas')
 				const thinPointerId = 91
 				const fireThin = (type, at) => thinCanvas.dispatchEvent(new PointerEvent(type, {
@@ -1882,11 +1943,74 @@
 				thinView.updateOptions({ interactionNoMsaa: false })
 				const noMsaaOff = await statsWhilePanning()
 				check('interactionNoMsaa: false 时交互期也直接画进画布', noMsaaOff.noMsaa === false)
-				thinView.updateOptions({ interactionNoMsaa: true })
-				const noMsaaBack = await statsWhilePanning()
-				check('改回 true 又走后备缓冲（开关是每帧现读的）', noMsaaBack.noMsaa === msaaOn)
-
-				// 动画在跑的那些帧也走这一档：开一组涟漪、不碰指针，等一帧读读数（判定是 interacting || animationRunning()）
+				thinView.updateOptions({ interactionNoMsaa: true })
+				const noMsaaBack = await statsWhilePanning()
+				check('改回 true 又走后备缓冲（开关是每帧现读的）', noMsaaBack.noMsaa === msaaOn)
+
+				/* ---------------- 程序化相机运动复用交互快路径 ---------------- */
+				// zoomBy / setCamera / centerOn 不经过 beginInteraction，但同样要吃到非 MSAA 与细线那一档：
+				// 运动中的帧按轻量画法走，停稳 160ms 后自动补一张全质量静态帧。
+				await sleep(400)
+				check('相机静止时仍直接画进 MSAA 画布', thinView.getStats().noMsaa === false && thinView.getStats().thinLines === false)
+				// 运动帧只能换画法，不能降低渲染分辨率：拉长帧间隔触发旧的自适应降档条件，
+				// 只要 viewport 仍是画布尺寸，贴回就是 1:1，不会出现整幅放大后的短暂模糊。
+				const cameraGl = thinCanvas.getContext('webgl2')
+				const viewportPrototype = Object.getPrototypeOf(cameraGl)
+				const originalViewport = viewportPrototype.viewport
+				const viewportSizes = []
+				viewportPrototype.viewport = function (...args) {
+					if (this === cameraGl) {
+						viewportSizes.push([args[2], args[3]])
+					}
+					return originalViewport.apply(this, args)
+				}
+				try {
+					const motionStart = thinView.getCamera()
+					for (let step = 0; step < 5; step += 1) {
+						thinView.setCamera({
+							center: [motionStart.center[0] + step + 1, motionStart.center[1] + step],
+							scale: motionStart.scale * (1 + step * 0.01)
+						})
+						await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))
+						await sleep(35)
+					}
+					const mismatched = viewportSizes.filter(([width, height]) => width !== thinCanvas.width || height !== thinCanvas.height)
+					check('相机运动帧始终保持画布全分辨率（不会先模糊一下）',
+						viewportSizes.length > 0 && mismatched.length === 0,
+						`viewport ${viewportSizes.length} 次 · 非全尺寸 ${mismatched.length} 次 · canvas=${thinCanvas.width}x${thinCanvas.height}${mismatched.length ? ` · 最后 ${mismatched.at(-1).join('x')}` : ''}`)
+				}
+				finally {
+					viewportPrototype.viewport = originalViewport
+				}
+				await sleep(400)
+				const statsWhileCameraMoving = async (move) => {
+					move()
+					await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))
+					return thinView.getStats()
+				}
+				const cameraMoving = await statsWhileCameraMoving(() => thinView.zoomBy(1.02))
+				check('程序化 zoomBy 的运动帧走细线快路径', cameraMoving.thinLines === true,
+					`thinLines=${cameraMoving.thinLines}`)
+				check('程序化 zoomBy 的运动帧走非 MSAA 后备缓冲（画布开了 MSAA 时）',
+					cameraMoving.noMsaa === msaaOn,
+					`antialias=${msaaOn} noMsaa=${cameraMoving.noMsaa}`)
+				await sleep(400)
+				const cameraSettled = thinView.getStats()
+				check('相机停稳后回到全质量静态帧', cameraSettled.thinLines === false && cameraSettled.noMsaa === false,
+					`thinLines=${cameraSettled.thinLines} noMsaa=${cameraSettled.noMsaa}`)
+				const sameCamera = thinView.getCamera()
+				thinView.setCamera({ center: sameCamera.center, scale: sameCamera.scale })
+				await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))
+				const cameraNoop = thinView.getStats()
+				check('同一位置重复 setCamera 不会再进轻量档', cameraNoop.thinLines === false && cameraNoop.noMsaa === false,
+					`thinLines=${cameraNoop.thinLines} noMsaa=${cameraNoop.noMsaa}`)
+				thinView.updateOptions({ interactionNoMsaa: false })
+				const cameraNoMsaaOff = await statsWhileCameraMoving(() => thinView.setCamera({ center: [thinView.getCamera().center[0] + 1, thinView.getCamera().center[1]] }))
+				check('interactionNoMsaa: false 时程序化相机运动也直接画进画布', cameraNoMsaaOff.noMsaa === false)
+				thinView.updateOptions({ interactionNoMsaa: true })
+				await sleep(400)
+
+				// 动画在跑的那些帧也走这一档：开一组涟漪、不碰指针，等一帧读读数（判定是 interacting || animationRunning()）
 				thinView.updateOptions({ effects: { point: { radius: 14, period: 2, count: 1 } } })
 				await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))
 				await sleep(160)
@@ -1927,12 +2051,11 @@
 					const targetFlag = thinView.getStats().noMsaa
 					thinView.updateOptions({ interactionNoMsaa: false })
 					thinView.refresh({ reflow: false })
-					const direct = readAll()
-					const directFlag = thinView.getStats().noMsaa
-					fireThin('pointerup', thinAt)
-					thinView.updateOptions({ interactionNoMsaa: true })
-					let differing = 0
-					let totalDelta = 0
+					const direct = readAll()
+					const directFlag = thinView.getStats().noMsaa
+					thinView.updateOptions({ interactionNoMsaa: true })
+					let differing = 0
+					let totalDelta = 0
 					for (let index = 0; index < withTarget.length; index += 1) {
 						const delta = Math.abs(withTarget[index] - direct[index])
 						totalDelta += delta
@@ -1941,10 +2064,53 @@
 						}
 					}
 					const thinPixels = thinCanvas.width * thinCanvas.height
-					check('后备缓冲那一帧与直接画的那一帧画面基本一致（差别只在抗锯齿边缘）',
-						targetFlag === true && directFlag === false && differing / 4 < thinPixels * 0.2 && totalDelta / withTarget.length < 4,
-						`${(differing / 4 / thinPixels * 100).toFixed(1)}% 像素有差 · 平均差 ${(totalDelta / withTarget.length).toFixed(2)}`);
-				}
+					check('后备缓冲那一帧与直接画的那一帧画面基本一致（差别只在抗锯齿边缘）',
+						targetFlag === true && directFlag === false && differing / 4 < thinPixels * 0.2 && totalDelta / withTarget.length < 4,
+						`${(differing / 4 / thinPixels * 100).toFixed(1)}% 像素有差 · 平均差 ${(totalDelta / withTarget.length).toFixed(2)}`);
+					// 细线快路径现在走专用的轻量片元管线：同一交互状态再切回四边形，颜色与位置必须对得上，
+					// 差别只能来自 1 设备像素线宽 / 端点圆头，不能把整批线画丢、画黑或画成别的颜色。
+					thinView.updateOptions({ interactionThinLines: false })
+					thinView.refresh({ reflow: false })
+					const quad = readAll()
+					const quadFlag = thinView.getStats().thinLines
+					thinView.updateOptions({ interactionThinLines: true })
+					let thinDiffering = 0
+					let thinTotalDelta = 0
+					let thinInk = 0
+					let quadInk = 0
+					const background = [quad[0], quad[1], quad[2]]
+					for (let index = 0; index < quad.length; index += 4) {
+						const thinDelta = Math.max(
+							Math.abs(withTarget[index] - background[0]),
+							Math.abs(withTarget[index + 1] - background[1]),
+							Math.abs(withTarget[index + 2] - background[2])
+						)
+						const quadDelta = Math.max(
+							Math.abs(quad[index] - background[0]),
+							Math.abs(quad[index + 1] - background[1]),
+							Math.abs(quad[index + 2] - background[2])
+						)
+						if (thinDelta > 12) {
+							thinInk += 1
+						}
+						if (quadDelta > 12) {
+							quadInk += 1
+						}
+						for (let channel = 0; channel < 4; channel += 1) {
+							const delta = Math.abs(quad[index + channel] - withTarget[index + channel])
+							thinTotalDelta += delta
+							if (delta > 0) {
+								thinDiffering += 1
+							}
+						}
+					}
+					check('细线快路径与四边形画法位置 / 颜色一致（差别只在 1px 线宽边缘）',
+						targetFlag === true && quadFlag === false && thinInk > 100 && quadInk > 100 &&
+							thinInk / quadInk > 0.5 && thinInk / quadInk < 2 &&
+							thinDiffering / 4 < thinPixels * 0.2 && thinTotalDelta / quad.length < 4,
+						`${(thinDiffering / 4 / thinPixels * 100).toFixed(1)}% 像素有差 · 平均差 ${(thinTotalDelta / quad.length).toFixed(2)} · 线像素 ${thinInk}/${quadInk}`)
+					fireThin('pointerup', thinAt)
+				}
 				/* ---------------- 拖通道拐点：整条通道每帧重算的账（3000 回线不再是每次指针移动 140 ms） ---------------- */
 				// 老写法：拐点批次每帧整份重建 —— 通道里任一回线被选中就按整条通道的成员解析一遍把手，
 				// 3000 ~ 5000 回线的通道每次 pointermove 要 140 ms 上下（拖动时每帧一次，画面直接卡住）。
@@ -1964,17 +2130,17 @@
 					channelLines.push({ id: `cm-${index}`, from: 'p1', to: 'p2' })
 					channelLineIds.push(`cm-${index}`)
 				}
-				const channelView = createGisView(channelHost, {
+				const channelView = createGisView(channelHost, {
 					points: channelPoints,
 					lines: channelLines,
 					channels: [{ id: 'ch-cost', from: 'p1', to: 'p2', lineIds: channelLineIds, path: [[100, 30]] }],
 					fitPadding: 20,
-					waypointEditable: true
-				})
-				channelView.selectFeatures('cm-0')
-				// 拐点拖动靠真实指针命中：先把这张临时画布滚进视口，别让命中坐标落在视口外
-				channelHost.scrollIntoView({ block: 'center', inline: 'nearest' })
-				await sleep(200)
+					waypointEditable: true
+				})
+				channelView.selectFeatures('cm-0')
+				// 拐点拖动靠真实指针命中：先把这张临时画布滚进视口，别让命中坐标落在视口外
+				channelHost.scrollIntoView({ block: 'center', inline: 'nearest' })
+				await sleep(200)
 				const channelCanvas = channelHost.querySelector('canvas')
 				const channelWaypoint = channelView.getWaypoints(0).find(item => item.pathIndex === 1)
 				const channelSkeletonBefore = channelView.getChannelGroups('ch-cost')[0].skeleton.map(coordinate => coordinate[0])
@@ -2049,136 +2215,187 @@
 				const goCostBest = Math.min(...goCostMerge)
 				diag('分组编辑（2 万回线、只写 groups 的通道，合并一次）', `最快 ${goCostBest.toFixed(1)} ms`)
 				check('2 万回线的通道合并分组：40 ms 以内（成员池一次建表 + 集合去重，老的逐条 includes 是平方级）', goCostBest < 40, `最快 ${goCostBest.toFixed(1)} ms`)
-				check('只写 groups 的通道合并之后成员一条不少（2 万条只走声明，不靠顶层 lineIds）', goCostMergedLines === goCostCount, `${goCostMergedLines} / ${goCostCount}`)
-
-				/* ---------------- 点聚合：展示成员、拾取、点击语义与 maxZoom ---------------- */
-				const clusterPointCount = 12000
-				const clusterRandom = (() => {
-					let seed = 20261021
-					return () => {
-						seed = (seed * 1664525 + 1013904223) % 4294967296
-						return seed / 4294967296
-					}
-				})()
-				const clusterCenters = [[0, 0], [120, 0], [60, 90]]
-				// 留出几个远离簇中心的点，覆盖 getClusters() 的单成员分支；它们仍计入总点数。
-				const clusterIsolated = [
-					[-360, -170], [380, -170], [-360, 200], [380, 200],
-					[-440, 20], [460, 20], [20, -220], [20, 240]
-				]
-				const clusterPoints = new Array(clusterPointCount)
-				for (let index = 0; index < clusterPointCount; index += 1) {
-					const isolatedIndex = index - (clusterPointCount - clusterIsolated.length)
-					if (isolatedIndex >= 0) {
-						clusterPoints[index] = {
-							id: `cp${index}`,
-							x: clusterIsolated[isolatedIndex][0],
-							y: clusterIsolated[isolatedIndex][1],
-							name: `独立点 ${index}`
-						}
-						continue
-					}
-					const center = clusterCenters[index % clusterCenters.length]
-					clusterPoints[index] = {
-						id: `cp${index}`,
-						x: center[0] + (clusterRandom() - 0.5) * 24,
-						y: center[1] + (clusterRandom() - 0.5) * 24,
-						name: `聚合点 ${index}`
-					}
-				}
-				const clusterHost = document.createElement('div')
-				clusterHost.style.cssText = 'width:640px;height:380px'
-				document.body.appendChild(clusterHost)
-				let clusterEvents = 0
-				let plainEvents = 0
-				let lastClusterPayload = null
-				const clusterView = createGisView(clusterHost, {
-					points: clusterPoints,
-					width: 640,
-					height: 380,
-					pointStyle: { size: 4 },
-					features: 'view',
-					fitPadding: 24,
-					pointCluster: { enabled: true, radius: 60, minPoints: 2 }
-				})
-				clusterView.on('clusterClick', payload => {
-					clusterEvents += 1
-					lastClusterPayload = payload
-				})
-				clusterView.on('click', () => {
-					plainEvents += 1
-				})
-				await clusterView.whenRendered()
-				const clusterStats = clusterView.getStats()
-				check('点聚合：一万二千点建出多成员圆，统计口径自洽',
-					clusterStats.clusterCount > 0 && clusterStats.clusterPointCount >= clusterStats.clusterCount && clusterStats.clusterMs >= 0,
-					JSON.stringify({ clusterCount: clusterStats.clusterCount, clusterPointCount: clusterStats.clusterPointCount, clusterMs: clusterStats.clusterMs }))
-				check('点聚合：getPointCluster() 给出归一化配置与 active',
-					clusterView.getPointCluster()?.active === true && clusterView.getPointCluster()?.radius === 60,
-					JSON.stringify(clusterView.getPointCluster()))
-				const clusterGroups = clusterView.getClusters()
-				const multiClusters = clusterGroups.filter(item => item.count > 1)
-				const singletonGroups = clusterGroups.filter(item => item.count === 1)
-				check('点聚合：getClusters() 含单成员，单成员 count=1、多成员 id 以 cluster: 开头',
-					singletonGroups.length > 0 && multiClusters.length > 0 && singletonGroups.every(item => item.count === 1 && item.pointIndexes.length === 1) && multiClusters.every(item => item.id.startsWith('cluster:')),
-					`${clusterGroups.length} 组（${singletonGroups.length} 单成员 / ${multiClusters.length} 多成员）`)
-				check('点聚合：原始数据与 getData() 一条不少',
-					clusterView.getData().points.length === clusterPointCount && clusterView.listPoints({ visibleOnly: false }).length === clusterPointCount,
-					`getData ${clusterView.getData().points.length} / listPoints ${clusterView.listPoints({ visibleOnly: false }).length}`)
-				const visibleSingletons = clusterView.listPoints({ visibleOnly: true })
-				let visitedSingletons = 0
-				clusterView.forEachPointInView(clusterView.getViewRect(), () => {
-					visitedSingletons += 1
-				})
-				check('点聚合：聚合内部成员不出现在 visibleOnly / forEachPointInView',
-					visibleSingletons.length === clusterPointCount - clusterStats.clusterPointCount && visitedSingletons === visibleSingletons.length,
-					`可见 ${visibleSingletons.length} / 遍历 ${visitedSingletons} / 隐藏 ${clusterStats.clusterPointCount}`)
-				const clusterPick = clusterView.pick(multiClusters[0].screen[0], multiClusters[0].screen[1])
-				check('点聚合：聚合圆拾取返回 type=cluster，带 count / pointIds / bounds',
-					clusterPick?.type === 'cluster' && clusterPick.count >= 2 && clusterPick.pointIds.length === clusterPick.count && Boolean(clusterPick.bounds),
-					JSON.stringify({ type: clusterPick?.type, count: clusterPick?.count, ids: clusterPick?.pointIds?.length }))
-				const selectionProbe = visibleSingletons[0]
-				clusterView.selectFeatures([selectionProbe.item.id])
-				await clusterView.whenRendered()
-				const selectedBefore = clusterView.getSelections().map(entry => entry.item?.id ?? entry.index).join(',')
-				const clusterCanvas = clusterHost.querySelector('canvas')
-				// 合成指针事件使用真实客户端坐标：先把画布滚进视口，避免 clientY 落在窗口外
-				clusterCanvas.scrollIntoView({ block: 'center' })
-				await sleep(50)
-				const clickPick = clusterView.pick(multiClusters[0].screen[0], multiClusters[0].screen[1])
-				const clickScreen = clickPick?.screen ?? multiClusters[0].screen
-				const clickClient = clusterView.screenToClient(clickScreen[0], clickScreen[1])
-				const fireCluster = type => clusterCanvas.dispatchEvent(new PointerEvent(type, {
-					bubbles: true, cancelable: true, pointerId: 93, pointerType: 'mouse', button: 0,
-					buttons: type === 'pointerup' ? 0 : 1, clientX: clickClient[0], clientY: clickClient[1]
-				}))
-				fireCluster('pointerdown')
-				fireCluster('pointerup')
-				await sleep(30)
-				const selectedAfter = clusterView.getSelections().map(entry => entry.item?.id ?? entry.index).join(',')
+				check('只写 groups 的通道合并之后成员一条不少（2 万条只走声明，不靠顶层 lineIds）', goCostMergedLines === goCostCount, `${goCostMergedLines} / ${goCostCount}`)
+
+				/* ---------------- 点聚合：展示成员、拾取、点击语义与 maxZoom ---------------- */
+				const clusterPointCount = 12000
+				const clusterRandom = (() => {
+					let seed = 20261021
+					return () => {
+						seed = (seed * 1664525 + 1013904223) % 4294967296
+						return seed / 4294967296
+					}
+				})()
+				const clusterCenters = [[0, 0], [120, 0], [60, 90]]
+				// 留出几个远离簇中心的点，覆盖 getClusters() 的单成员分支；它们仍计入总点数。
+				const clusterIsolated = [
+					[-360, -170], [380, -170], [-360, 200], [380, 200],
+					[-440, 20], [460, 20], [20, -220], [20, 240]
+				]
+				const clusterPoints = new Array(clusterPointCount)
+				for (let index = 0; index < clusterPointCount; index += 1) {
+					const isolatedIndex = index - (clusterPointCount - clusterIsolated.length)
+					if (isolatedIndex >= 0) {
+						clusterPoints[index] = {
+							id: `cp${index}`,
+							x: clusterIsolated[isolatedIndex][0],
+							y: clusterIsolated[isolatedIndex][1],
+							name: `独立点 ${index}`
+						}
+						continue
+					}
+					const center = clusterCenters[index % clusterCenters.length]
+					clusterPoints[index] = {
+						id: `cp${index}`,
+						x: center[0] + (clusterRandom() - 0.5) * 24,
+						y: center[1] + (clusterRandom() - 0.5) * 24,
+						name: `聚合点 ${index}`
+					}
+				}
+				const clusterHost = document.createElement('div')
+				clusterHost.style.cssText = 'width:640px;height:380px'
+				document.body.appendChild(clusterHost)
+				let clusterEvents = 0
+				let plainEvents = 0
+				let lastClusterPayload = null
+				const clusterView = createGisView(clusterHost, {
+					points: clusterPoints,
+					width: 640,
+					height: 380,
+					pointStyle: { size: 4 },
+					features: 'view',
+					fitPadding: 24,
+					pointCluster: { enabled: true, radius: 60, minPoints: 2 }
+				})
+				clusterView.on('clusterClick', payload => {
+					clusterEvents += 1
+					lastClusterPayload = payload
+				})
+				clusterView.on('click', () => {
+					plainEvents += 1
+				})
+				await clusterView.whenRendered()
+				const clusterStats = clusterView.getStats()
+				check('点聚合：一万二千点建出多成员圆，统计口径自洽',
+					clusterStats.clusterCount > 0 && clusterStats.clusterPointCount >= clusterStats.clusterCount && clusterStats.clusterMs >= 0,
+					JSON.stringify({ clusterCount: clusterStats.clusterCount, clusterPointCount: clusterStats.clusterPointCount, clusterMs: clusterStats.clusterMs }))
+				check('点聚合：getPointCluster() 给出归一化配置与 active',
+					clusterView.getPointCluster()?.active === true && clusterView.getPointCluster()?.radius === 60,
+					JSON.stringify(clusterView.getPointCluster()))
+				const clusterGroups = clusterView.getClusters()
+				const multiClusters = clusterGroups.filter(item => item.count > 1)
+				const singletonGroups = clusterGroups.filter(item => item.count === 1)
+				check('点聚合：getClusters() 含单成员，单成员 count=1、多成员 id 以 cluster: 开头',
+					singletonGroups.length > 0 && multiClusters.length > 0 && singletonGroups.every(item => item.count === 1 && item.pointIndexes.length === 1) && multiClusters.every(item => item.id.startsWith('cluster:')),
+					`${clusterGroups.length} 组（${singletonGroups.length} 单成员 / ${multiClusters.length} 多成员）`)
+				check('点聚合：原始数据与 getData() 一条不少',
+					clusterView.getData().points.length === clusterPointCount && clusterView.listPoints({ visibleOnly: false }).length === clusterPointCount,
+					`getData ${clusterView.getData().points.length} / listPoints ${clusterView.listPoints({ visibleOnly: false }).length}`)
+				const visibleSingletons = clusterView.listPoints({ visibleOnly: true })
+				let visitedSingletons = 0
+				clusterView.forEachPointInView(clusterView.getViewRect(), () => {
+					visitedSingletons += 1
+				})
+				check('点聚合：聚合内部成员不出现在 visibleOnly / forEachPointInView',
+					visibleSingletons.length === clusterPointCount - clusterStats.clusterPointCount && visitedSingletons === visibleSingletons.length,
+					`可见 ${visibleSingletons.length} / 遍历 ${visitedSingletons} / 隐藏 ${clusterStats.clusterPointCount}`)
+				const clusterPick = clusterView.pick(multiClusters[0].screen[0], multiClusters[0].screen[1])
+				check('点聚合：聚合圆拾取返回 type=cluster，带 count / pointIds / bounds',
+					clusterPick?.type === 'cluster' && clusterPick.count >= 2 && clusterPick.pointIds.length === clusterPick.count && Boolean(clusterPick.bounds),
+					JSON.stringify({ type: clusterPick?.type, count: clusterPick?.count, ids: clusterPick?.pointIds?.length }))
+				const selectionProbe = visibleSingletons[0]
+				clusterView.selectFeatures([selectionProbe.item.id])
+				await clusterView.whenRendered()
+				const selectedBefore = clusterView.getSelections().map(entry => entry.item?.id ?? entry.index).join(',')
+				const clusterCanvas = clusterHost.querySelector('canvas')
+				// 合成指针事件使用真实客户端坐标：先把画布滚进视口，避免 clientY 落在窗口外
+				clusterCanvas.scrollIntoView({ block: 'center' })
+				await sleep(50)
+				const clickPick = clusterView.pick(multiClusters[0].screen[0], multiClusters[0].screen[1])
+				const clickScreen = clickPick?.screen ?? multiClusters[0].screen
+				const clickClient = clusterView.screenToClient(clickScreen[0], clickScreen[1])
+				const fireCluster = type => clusterCanvas.dispatchEvent(new PointerEvent(type, {
+					bubbles: true, cancelable: true, pointerId: 93, pointerType: 'mouse', button: 0,
+					buttons: type === 'pointerup' ? 0 : 1, clientX: clickClient[0], clientY: clickClient[1]
+				}))
+				fireCluster('pointerdown')
+				fireCluster('pointerup')
+				await sleep(30)
+				const selectedAfter = clusterView.getSelections().map(entry => entry.item?.id ?? entry.index).join(',')
 				check('点聚合：点击聚合只发 clusterClick，不发普通 click，选中集不变',
 					clusterEvents === 1 && plainEvents === 0 && selectedAfter === selectedBefore && lastClusterPayload?.action?.type === 'clusterClick' && lastClusterPayload?.action?.data?.type === 'cluster',
 					`clusterClick=${clusterEvents} click=${plainEvents} 选中 ${selectedBefore} → ${selectedAfter} action=${lastClusterPayload?.action?.type} clickPick=${clickPick?.type ?? 'null'} clickScreen=${clickScreen.map(value => value.toFixed(1)).join(',')} client=${clickClient.map(value => value.toFixed(1)).join(',')}`)
 				const fitScale = clusterView.getCamera().scale
-				clusterView.updateOptions({ pointCluster: { enabled: true, radius: 60, minPoints: 2, maxZoom: 2 } })
-				clusterView.setCamera({ scale: fitScale * 3 })
-				await clusterView.whenRendered()
-				const zoomedStats = clusterView.getStats()
-				check('点聚合：缩放超过 maxZoom 后展开原始点（active=false、聚合圆清空）',
-					clusterView.getPointCluster()?.active === false && zoomedStats.clusterCount === 0 && clusterView.listPoints({ visibleOnly: true }).length === clusterPointCount,
-					JSON.stringify({ active: clusterView.getPointCluster()?.active, clusterCount: zoomedStats.clusterCount, visible: clusterView.listPoints({ visibleOnly: true }).length }))
+				// 聚合成员在相机运动期会推迟重算；这一档没有线、又显式关掉非 MSAA 后备缓冲，
+				// 当前帧不会画出任何轻量几何 —— 停稳计时器仍必须补一帧，不能把聚合结果留在旧缩放档。
+				const clustersBeforeCamera = clusterView.getStats().clusterCount
+				clusterView.updateOptions({ interactionNoMsaa: false })
+				clusterView.setCamera({ scale: fitScale * 0.55 })
+				await sleep(420)
+				const clustersAfterCamera = clusterView.getStats().clusterCount
+				check('点聚合：程序化相机停稳后一定补算成员（没有轻量帧也不例外）',
+					clustersAfterCamera < clustersBeforeCamera,
+					`${clustersBeforeCamera} → ${clustersAfterCamera}`)
 				clusterView.setCamera({ scale: fitScale })
-				await clusterView.whenRendered()
-				clusterView.updateOptions({ pointCluster: false })
-				await clusterView.whenRendered()
-				const disabledStats = clusterView.getStats()
-				check('点聚合：关掉之后原始点全部恢复，getPointCluster().enabled=false',
-					clusterView.getPointCluster()?.enabled === false && clusterView.getPointCluster()?.active === false && disabledStats.clusterCount === 0 && disabledStats.clusterPointCount === 0,
-					JSON.stringify({ cluster: clusterView.getPointCluster(), stats: { count: disabledStats.clusterCount, points: disabledStats.clusterPointCount } }))
-				clusterView.destroy()
-				clusterHost.remove()
-
-				thinView.destroy()
+				await sleep(420)
+				clusterView.updateOptions({ interactionNoMsaa: true })
+				clusterView.updateOptions({ pointCluster: { enabled: true, radius: 60, minPoints: 2, maxZoom: 2 } })
+				clusterView.setCamera({ scale: fitScale * 3 })
+				await clusterView.whenRendered()
+				const zoomedStats = clusterView.getStats()
+				check('点聚合：缩放超过 maxZoom 后展开原始点（active=false、聚合圆清空）',
+					clusterView.getPointCluster()?.active === false && zoomedStats.clusterCount === 0 && clusterView.listPoints({ visibleOnly: true }).length === clusterPointCount,
+					JSON.stringify({ active: clusterView.getPointCluster()?.active, clusterCount: zoomedStats.clusterCount, visible: clusterView.listPoints({ visibleOnly: true }).length }))
+				clusterView.setCamera({ scale: fitScale })
+				await clusterView.whenRendered()
+				clusterView.updateOptions({ pointCluster: false })
+				await clusterView.whenRendered()
+				const disabledStats = clusterView.getStats()
+				check('点聚合：关掉之后原始点全部恢复，getPointCluster().enabled=false',
+					clusterView.getPointCluster()?.enabled === false && clusterView.getPointCluster()?.active === false && disabledStats.clusterCount === 0 && disabledStats.clusterPointCount === 0,
+					JSON.stringify({ cluster: clusterView.getPointCluster(), stats: { count: disabledStats.clusterCount, points: disabledStats.clusterPointCount } }))
+				clusterView.destroy()
+				clusterHost.remove()
+
+				/* ---------------- 同一批点线数据原样回灌：两半都没换时别白解析 ---------------- */
+				// 组件把同一批对象原样再交一次是常规写法（刷新配置 / 只换别的选项时顺带带上 data）。
+				// 这里量 5 次取中位；每次回灌之后数据、线路实例数与相机都必须原样。
+				big.fitView(0)
+				big.refresh()
+				big.refresh()
+				const refeedPoints = big.getData().points
+				const refeedLines = big.getData().lines
+				const refeedInstances = big.getStats().lineInstances
+				const refeedStarted = now()
+				const refeedSamples = []
+				for (let round = 0; round < 5; round += 1) {
+					const started = now()
+					big.updateOptions({ points: refeedPoints, lines: refeedLines })
+					refeedSamples.push(now() - started)
+				}
+				refeedSamples.sort((left, right) => left - right)
+				const refeedMs = refeedSamples[Math.floor(refeedSamples.length / 2)]
+				const refeedData = big.getData()
+				check('同一批点线原样回灌：条数 / 线路实例数都不变（解析结果可以整半沿用）',
+					refeedData.points.length === pointCount && refeedData.lines.length === lineCount && big.getStats().lineInstances === refeedInstances,
+					JSON.stringify({ points: refeedData.points.length, lines: refeedData.lines.length, instances: big.getStats().lineInstances, expected: refeedInstances }))
+				diag(`同一批点线原样回灌（${pointCount} 点 / ${lineCount} 线）`, `中位 ${refeedMs.toFixed(1)} ms（5 次：${refeedSamples.map(value => value.toFixed(1)).join(' / ')}；总观测 ${(now() - refeedStarted).toFixed(1)} ms）`)
+				// 同一批数据回灌不能让通道几何停在上一轮：声明没换时沿用，换了骨架必须照常重推
+				big.updateOptions({ channels: [{ id: 'reuse-guard', from: 'p0', to: 'p1', lineIds: ['l0', 'l1'], path: [[20, 20]] }] })
+				const guardBefore = big.getChannelGroupWaypoints('reuse-guard')
+				big.updateOptions({ points: refeedPoints, lines: refeedLines })
+				const guardAfter = big.getChannelGroupWaypoints('reuse-guard')
+				check('同一批点线回灌：通道声明没换时，回线派生折线原样保留',
+					JSON.stringify(guardBefore?.lines?.map(line => line.path)) === JSON.stringify(guardAfter?.lines?.map(line => line.path)),
+					JSON.stringify({ before: guardBefore?.lines?.map(line => line.waypoints), after: guardAfter?.lines?.map(line => line.waypoints) }))
+				big.updateOptions({ channels: [{ id: 'reuse-guard', from: 'p0', to: 'p1', lineIds: ['l0', 'l1'], path: [[80, 80]] }] })
+				const guardChanged = big.getChannelGroupWaypoints('reuse-guard')
+				check('同一批点线回灌：换通道骨架时线路那一半不能沿用旧几何',
+					JSON.stringify(guardChanged?.lines?.map(line => line.waypoints)) !== JSON.stringify(guardAfter?.lines?.map(line => line.waypoints)),
+					JSON.stringify({ before: guardAfter?.lines?.map(line => line.waypoints), after: guardChanged?.lines?.map(line => line.waypoints) }))
+				big.updateOptions({ channels: [] })
+
+				thinView.destroy()
 				thinHost.remove()
 				big.destroy()
 				bigHost.remove()