gis-view-webgl2 0.1.3 → 0.1.5

package/docs/demos/api-index.js

@@ -7,8 +7,8 @@
  * 源码或文档改过之后重跑一遍；`node docs/steps/check-doc-coverage.mjs` 会对账。
  */
 
-/** { members: 253, methods: 250, properties: 3, options: 95, sections: 16 } */
-export const API_SUMMARY = {"members":253,"methods":250,"properties":3,"options":95,"sections":16}
+/** { members: 257, methods: 254, properties: 3, options: 96, sections: 16 } */
+export const API_SUMMARY = {"members":257,"methods":254,"properties":3,"options":96,"sections":16}
 
 /** 实例成员，按 docs/GisView.md「参数速查」的分组排 */
 export const API_SECTIONS = [
@@ -50,9 +50,9 @@ export const API_SECTIONS = [
 			{ name: "zoomBy", kind: "method", params: "factor: number 缩放倍数（> 1 放大、< 1 缩小）；origin?: [number, number] 缩放中心（画布 CSS 像素，缺省画布中心）", returns: "this", doc: "相对缩放，origin 为画布 CSS 像素锚点（缺省视口中心）", examples: [{"group":"相机与视图","code":"// zoomBy(factor, origin?)：按倍数缩放；origin 是画布 CSS 像素的缩放中心\nview.zoomBy(1.5)\nview.zoomBy(0.5, [320, 200])\n","from":"header"}] },
 			{ name: "zoomTo", kind: "method", params: "scale: number 目标缩放值（世界单位 → CSS 像素的比例）；origin?: [x, y] 缩放中心", returns: "this", doc: "直接设成指定比例（像素 / 世界单位）", examples: [{"group":"相机与视图","code":"// zoomTo(scale, origin?)：直接给目标比例（世界单位 → CSS 像素）\nview.zoomTo(12)\n","from":"header"}] },
 			{ name: "zoomToBounds", kind: "method", params: "bounds: GisViewBounds 要装进画面的世界矩形 [minX, minY, maxX, maxY]（也认 { minX, minY, maxX, maxY }）；padding?: number 四周留白", returns: "this", doc: "把一段世界坐标矩形适应到视图内，退化成一点时只居中不改比例", examples: [{"group":"相机与视图","code":"// zoomToBounds(bounds, padding?)：把世界矩形装进画面（数组与对象写法都认）\nview.zoomToBounds([0, 0, 400, 200], 40)\nview.zoomToBounds({ minX: 116, minY: 39, maxX: 117, maxY: 40 })\n","from":"header"}] },
-			{ name: "focusOn", kind: "method", params: "target: GisViewFocusTargets 要对准的东西：id / { type: 'point' | 'line' | 'channel' | 'group', id | index } / { channelId }（整条通道）/ { type: 'group', channelId?, groupId } / [x, y] 坐标 / 矩形 / { lngLat } / { center }，或者一批（数组取整体包围盒）。字符串按「先节点、再线路」，裸字符串不能表示通道；同 id 用显式 type 消歧，分组必须用 type: 'group'（groupId 全局唯一时可省略 channelId）。四种显式类型共用同一套包围盒适配，没有额外放大倍率；maxZoom 只给单点 / 单线这类零面积目标补最小范围。options?: GisViewFocusOptions：scale 直接给比例、center: true 只居中且不动比例、padding 要四周留白（CSS 像素，缺省 40）、maxZoom 限制这次适配的最大比例、select 顺带选中（true 选这次目标，也可另给一批写法）、mode 决定怎么并进当前选中集。目标认不出来或参数非法时什么都不做", returns: "this（相机更新后发 onCameraChange；select 生效时另发 onSelect / onSelectChange）", doc: "把视角移到目标上：单条（搜索命中 / 要素 id / { type: 'point' | 'line' | 'channel', id | index } / { channelId } 整条通道 / { type: 'group', channelId?, groupId } / 坐标 / 矩形 / { lngLat }）或一批（数组取整体包围盒 —— 搜到三个节点就是这三个点的中心当屏幕中心）；字符串先节点后线路，裸字符串不表示通道，同 id 用 type 消歧，分组必须显式写 type: 'group'（全局唯一 groupId 可省略通道）；节点 / 线路 / 通道 / 分组共用同一套范围适配，不额外放大。options 认 scale、center: true（只居中、比例一点不动）、padding、maxZoom、select（顺带选中这批，mode 决定怎么并进当前选中集）", examples: [{"group":"相机与视图","code":"// focusOn(target, options?)：对准一个或多个目标（id / 显式类型 / 坐标 / 矩形 / 搜索命中 / 一批）\nview.focusOn('a')\nview.focusOn(['a', 'b'], { padding: 60, maxZoom: 8, select: true })\nview.focusOn({ type: 'point', id: 'a' })               // 节点与线路同 id 时显式消歧\nview.focusOn({ type: 'line', id: 'a' })\nview.focusOn({ type: 'channel', channelId: 'c1' })     // 通道也可以直接写 { channelId: 'c1' }\nview.focusOn({ type: 'group', channelId: 'c1', groupId: 'c1::2' })\nview.focusOn({ type: 'group', groupId: 'global-group' }) // groupId 全局唯一时可省略通道\nview.focusOn([120, 80], { center: true })              // 只居中，比例不动\nview.focusOn({ lngLat: [116.4, 39.9] })\n","from":"header"}] },
-			{ name: "search", kind: "method", params: "input: string | GisViewSearchOptions 关键字，或 { keyword, scope, fields, limit } 这类选项（scope 可选 'points' / 'lines' / 'channels'，也认它们的数组）—— 只返回结果、不动视角，要定位就自己调 focusOn(result.hits, …)", returns: "GisViewSearchResult", doc: "按关键字搜索节点 / 线路 / 通道并返回命中（不动视角：要不要聚焦由调用方自己调 focusOn），见「搜索与定位」", examples: [{"group":"相机与视图","code":"// search(input) / searchAsync(input)：搜索（只返回结果、不动视角）\nconst hits = view.search('甲站')\nconst scoped = view.search({ keyword: '甲', scope: ['points', 'channels'], limit: 10 })\nview.focusOn(hits.hits, { maxZoom: 8 })                // 命中集直接丢给 focusOn\nconst asyncHits = await view.searchAsync('甲站')       // 大表走 Worker；stale 说明这一份不作数了\n","from":"header"}] },
-			{ name: "searchAsync", kind: "method", params: "同上", returns: "Promise<GisViewSearchResult>：多一个 worker（是不是在 Worker 里算的）与 stale（回来时数据已经改过、或又搜过一次，这一份不作数了）", doc: "同一份口径的异步版：数据量大时把扫描放进 Worker（10 万点 / 10 万线下同步要占主线程 40 ms 上下的那一段），返回 Promise<GisViewSearchResult>；结果带 worker 与 stale 两个字段，见「异步搜索」", examples: [{"group":"相机与视图","code":"// search(input) / searchAsync(input)：搜索（只返回结果、不动视角）\nconst hits = view.search('甲站')\nconst scoped = view.search({ keyword: '甲', scope: ['points', 'channels'], limit: 10 })\nview.focusOn(hits.hits, { maxZoom: 8 })                // 命中集直接丢给 focusOn\nconst asyncHits = await view.searchAsync('甲站')       // 大表走 Worker；stale 说明这一份不作数了\n","from":"header"}] },
+			{ name: "focusOn", kind: "method", params: "target: GisViewFocusTargets 要对准的东西：id / { type: 'point' | 'line' | 'channel' | 'group', id | index } / { channelId }（整条通道）/ { type: 'group', channelId?, groupId } / [x, y] 坐标 / 矩形 / { lngLat } / { center }，或者一批（数组取整体包围盒）。字符串按「先节点、再线路」，裸字符串不能表示通道；同 id 用显式 type 消歧，分组必须用 type: 'group'（groupId 全局唯一时可省略 channelId）。缺省只居中、比例一点不动；options.zoom: true 才按解析出的真实范围适配，四类目标共用这一条、没有额外放大倍率；scale 优先级高于 zoom，maxZoom 只给单点 / 单线这类零面积目标补最小范围。options?: GisViewFocusOptions：zoom: true 显式适配、scale 直接给比例、center: true 显式只居中（与缺省一致）、padding 要四周留白（CSS 像素，缺省 40）、maxZoom 限制这次适配的最大比例、select 顺带选中（true 选这次目标，也可另给一批写法）、mode 决定怎么并进当前选中集。目标认不出来或参数非法时什么都不做", returns: "this（相机更新后发 onCameraChange；select 生效时另发 onSelect / onSelectChange）", doc: "把视角移到目标上：单条（搜索命中 / 要素 id / { type: 'point' | 'line' | 'channel', id | index } / { channelId } 整条通道 / { type: 'group', channelId?, groupId } / 坐标 / 矩形 / { lngLat }）或一批（数组取整体包围盒 —— 搜到三个节点就是这三个点的中心当屏幕中心）；字符串先节点后线路，裸字符串不表示通道，同 id 用 type 消歧，分组必须显式写 type: 'group'（全局唯一 groupId 可省略通道）。缺省只居中、比例一点不动；options.zoom: true 才按解析出的真实范围适配（节点 / 线路 / 通道 / 分组共用这一条，不额外放大），scale 优先级高于 zoom。options 还认 center: true（显式只居中，与缺省一致）、padding、maxZoom、select（顺带选中这批，mode 决定怎么并进当前选中集）", examples: [{"group":"相机与视图","code":"// focusOn(target, options?)：对准一个或多个目标（id / 显式类型 / 坐标 / 矩形 / 搜索命中 / 一批）\nview.focusOn('a')                                      // 缺省只居中，比例不动\nview.focusOn('a', { zoom: true, maxZoom: 8 })          // 显式按范围适配\nview.focusOn(['a', 'b'], { zoom: true, padding: 60, select: true })\nview.focusOn({ type: 'point', id: 'a' })               // 节点与线路同 id 时显式消歧\nview.focusOn({ type: 'line', id: 'a' })\nview.focusOn({ type: 'channel', channelId: 'c1' })     // 通道也可以直接写 { channelId: 'c1' }\nview.focusOn({ type: 'group', channelId: 'c1', groupId: 'c1::2' })\nview.focusOn({ type: 'group', groupId: 'global-group' }) // groupId 全局唯一时可省略通道\nview.focusOn([120, 80], { center: true })              // 显式只居中（与缺省一致）\nview.focusOn({ lngLat: [116.4, 39.9] })\n","from":"header"}] },
+			{ name: "search", kind: "method", params: "input: string | GisViewSearchOptions 关键字，或 { keyword, scope, fields, limit } 这类选项。scope 可选 'points' / 'lines' / 'channels' / 'groups'，也认与 focusOn 一致的单数别名 'point' / 'line' / 'channel' / 'group' 及数组；省略或写错时四类全搜。limit 对每一类分别计数。返回的 groups / hits 带分组命中（channelIndex / groupId / groupIndex，item 是轻量快照）—— 只返回结果、不动视角，要定位就自己调 focusOn(result.hits, …)", returns: "GisViewSearchResult：keyword / scope / points / lines / channels / groups / hits / total / truncated / durationMs", doc: "按关键字搜索节点 / 线路 / 通道 / 通道分组并返回命中：scope 认复数的 points / lines / channels / groups，也认与 focusOn 一致的单数别名 point / line / channel / group；结果分 points / lines / channels / groups 四类，分组命中带 channelIndex / groupId / groupIndex，可直接交给 focusOn / selectFeatures。不动视角：要不要聚焦由调用方自己调 focusOn，见「搜索与定位」", examples: [{"group":"相机与视图","code":"// search(input) / searchAsync(input)：搜索（只返回结果、不动视角）\nconst hits = view.search('甲站')\nconst scoped = view.search({ keyword: '甲', scope: ['points', 'channels', 'groups'], limit: 10 })\nconst groupHits = view.search({ keyword: 'c1::2', scope: 'group' }) // 单数别名与 focusOn 一致\nview.focusOn(groupHits.groups[0], { zoom: true, select: true }) // 按整组范围适配并选中成员回线\nview.focusOn(hits.hits, { zoom: true, maxZoom: 8 })    // 命中集直接丢给 focusOn\nconst asyncHits = await view.searchAsync('甲站')       // 大表走 Worker；stale 说明这一份不作数了\n","from":"header"}] },
+			{ name: "searchAsync", kind: "method", params: "同上；分组范围的当前轻量快照会随请求交给 Worker", returns: "Promise<GisViewSearchResult>：多一个 worker（是不是在 Worker 里算的）与 stale（回来时数据已经改过、或又搜过一次，这一份不作数了）", doc: "同一份口径的异步版：数据量大时把扫描放进 Worker（10 万点 / 10 万线下同步要占主线程 40 ms 上下的那一段），返回 Promise<GisViewSearchResult>；结果带 worker 与 stale 两个字段，见「异步搜索」", examples: [{"group":"相机与视图","code":"// search(input) / searchAsync(input)：搜索（只返回结果、不动视角）\nconst hits = view.search('甲站')\nconst scoped = view.search({ keyword: '甲', scope: ['points', 'channels', 'groups'], limit: 10 })\nconst groupHits = view.search({ keyword: 'c1::2', scope: 'group' }) // 单数别名与 focusOn 一致\nview.focusOn(groupHits.groups[0], { zoom: true, select: true }) // 按整组范围适配并选中成员回线\nview.focusOn(hits.hits, { zoom: true, maxZoom: 8 })    // 命中集直接丢给 focusOn\nconst asyncHits = await view.searchAsync('甲站')       // 大表走 Worker；stale 说明这一份不作数了\n","from":"header"}] },
 			{ name: "setCamera", kind: "method", params: "camera: Partial<GisViewCamera> 要改的相机字段 { x, y, scale }（只写一个也行）", returns: "this", doc: "读写 { center, scale }", examples: [{"group":"相机与视图","code":"// setCamera(camera) / getCamera()：读写相机（只写一个字段也行）\nview.setCamera({ scale: 10 })\nview.setCamera({ x: 200, y: 120 })\nconst camera = view.getCamera()\n","from":"header"}] },
 			{ name: "getCamera", kind: "method", params: "无", returns: "GisViewCamera", doc: "读写 { center, scale }", examples: [{"group":"相机与视图","code":"// setCamera(camera) / getCamera()：读写相机（只写一个字段也行）\nview.setCamera({ scale: 10 })\nview.setCamera({ x: 200, y: 120 })\nconst camera = view.getCamera()\n","from":"header"}] },
 			{ name: "getZoomBaseScale", kind: "method", params: "无", returns: "number 缩放联动的基准比例（pointZoomScale / lineZoomScale 共用那一份；缺省是首次适应视图时的 camera.scale）", doc: "读 / 重定缩放联动的基准比例（缺省是首次适应视图时的比例）：不传参数就取当下相机的比例 —— 把现在这一屏当成「原样大小」，之后放大缩小都从它算倍数；配合 pointZoomScale / lineZoomScale 使用", examples: [{"group":"相机与视图","code":"// getZoomBaseScale() / setZoomBaseScale(scale?)：缩放联动的基准比例（配合 pointZoomScale / lineZoomScale）\nconst zoomBase = view.getZoomBaseScale()     // 基准（缺省首次适应视图时的 camera.scale）\nview.setZoomBaseScale()                      // 以当下这一屏为「原样大小」，之后放大缩小都从它算倍数\nview.setZoomBaseScale(2.5)                   // 也可以直接给一个比例\n","from":"header"}] },
@@ -61,6 +61,7 @@ export const API_SECTIONS = [
 			{ name: "getViewport", kind: "method", params: "无", returns: "{ cssWidth, cssHeight, pixelRatio, displayScale }：画布 CSS 尺寸、设备像素比与渲染分辨率比例", doc: "/** * 当前视口。", examples: [{"group":"相机与视图","code":"// getBounds() / getViewRect() / getViewport()：数据范围 / 视口世界矩形 / 画布尺寸读数\nconst dataBounds = view.getBounds()\nconst viewRect = view.getViewRect()\nconst { cssWidth, cssHeight, pixelRatio } = view.getViewport()\n","from":"header"}] },
 			{ name: "getViewRect", kind: "method", params: "无", returns: "GisViewBounds", doc: "当前可视范围的世界坐标矩形；自建缩略图 / 坐标读数用它换算视口框，内置鹰眼图见「鹰眼图」", examples: [{"group":"相机与视图","code":"// getBounds() / getViewRect() / getViewport()：数据范围 / 视口世界矩形 / 画布尺寸读数\nconst dataBounds = view.getBounds()\nconst viewRect = view.getViewRect()\nconst { cssWidth, cssHeight, pixelRatio } = view.getViewport()\n","from":"header"}] },
 			{ name: "isLayoutReady", kind: "method", params: "无", returns: "boolean", doc: "大数据发散渲染（progressiveInit）是否已经铺完；没铺完时标签与拾取只看得到已经画出去的那部分", examples: [{"group":"相机与视图","code":"// isLayoutReady()：容器量到尺寸、首批布局完成没有\nconst layoutReady = view.isLayoutReady()\n","from":"header"}] },
+			{ name: "getMinimapElement", kind: "method", params: "无", returns: "HTMLElement | null 鹰眼图根节点（没配 minimap 时为 null）；外部整图拖动 / 自定义手势用它，配合 minimap.container 可挂到外部宿主", doc: "鹰眼图根节点（没配 minimap 时为 null）：接整图拖动或自定义手势；配合 minimap.container 挂到外部宿主时拿到的仍是同一根节点", examples: [{"group":"相机与视图","code":"// getMinimapElement()：拿鹰眼图根节点做整图拖动 / 自定义手势（没配 minimap 时为 null）\nconst minimapElement = view.getMinimapElement()\n","from":"header"}] },
 			{ name: "getMinimapZoom", kind: "method", params: "无", returns: "number", doc: "读 / 写鹰眼图自身的倍数：set 夹在 minimap.minZoom ~ maxZoom 之间，zoomMinimapBy 以画布 CSS 像素 origin 为锚点缩放（缺省小图中心），没配 minimap 时是空操作", examples: [{"group":"相机与视图","code":"// getMinimapZoom() / setMinimapZoom(zoom) / zoomMinimapBy(factor, origin?)：鹰眼图缩放\nview.setMinimapZoom(4)\nview.zoomMinimapBy(1.25)\nconst minimapZoom = view.getMinimapZoom()\n","from":"header"}] },
 			{ name: "setMinimapZoom", kind: "method", params: "zoom: number 鹰眼图的目标倍数（被 minimap.minZoom / maxZoom 夹住）", returns: "this", doc: "读 / 写鹰眼图自身的倍数：set 夹在 minimap.minZoom ~ maxZoom 之间，zoomMinimapBy 以画布 CSS 像素 origin 为锚点缩放（缺省小图中心），没配 minimap 时是空操作", examples: [{"group":"相机与视图","code":"// getMinimapZoom() / setMinimapZoom(zoom) / zoomMinimapBy(factor, origin?)：鹰眼图缩放\nview.setMinimapZoom(4)\nview.zoomMinimapBy(1.25)\nconst minimapZoom = view.getMinimapZoom()\n","from":"header"}] },
 			{ name: "zoomMinimapBy", kind: "method", params: "factor: number 倍数；origin?: [x, y] 以小图里的哪个点为中心（缺省小图中心）", returns: "this", doc: "读 / 写鹰眼图自身的倍数：set 夹在 minimap.minZoom ~ maxZoom 之间，zoomMinimapBy 以画布 CSS 像素 origin 为锚点缩放（缺省小图中心），没配 minimap 时是空操作", examples: [{"group":"相机与视图","code":"// getMinimapZoom() / setMinimapZoom(zoom) / zoomMinimapBy(factor, origin?)：鹰眼图缩放\nview.setMinimapZoom(4)\nview.zoomMinimapBy(1.25)\nconst minimapZoom = view.getMinimapZoom()\n","from":"header"}] },
@@ -176,7 +177,7 @@ export const API_SECTIONS = [
 			{ name: "getWaypoints", kind: "method", params: "lineIndex?: number 只看这一条线路（不传给全部）", returns: "GisViewWaypointInfo[]", doc: "当前显示中的拐点（受 waypointVisibility 影响），带坐标与选中态", examples: [{"group":"拐点与通道","code":"// getWaypoints(lineIndex?) / getParallelGroups()：拐点清单 / 新增拐点集合\nconst waypoints = view.getWaypoints()\nconst waypointsOfLine = view.getWaypoints(0)           // 只看这一条线（线路下标）\nconst parallelGroups = view.getParallelGroups()\n","from":"header"}] },
 			{ name: "getParallelGroups", kind: "method", params: "无", returns: "GisViewParallelGroup[]", doc: "新增拐点集合：被加过 / 拖过拐点的通道与线路，结构与 test.json 的 parallel_groups 一致", examples: [{"group":"拐点与通道","code":"// getWaypoints(lineIndex?) / getParallelGroups()：拐点清单 / 新增拐点集合\nconst waypoints = view.getWaypoints()\nconst waypointsOfLine = view.getWaypoints(0)           // 只看这一条线（线路下标）\nconst parallelGroups = view.getParallelGroups()\n","from":"header"}] },
 			{ name: "getChannels", kind: "method", params: "无", returns: "GisViewChannelInfo[]", doc: "通道运行时状态：骨架折线、每条回线的偏移、推导出来的折线路径与间距；分组之后一个通道的每个分组各一条，带 channelId / channelIndex（id 是分组 id）", examples: [{"group":"拐点与通道","code":"// getChannels() / getChannelMembers() / getChannelsInView()：通道全量几何 / 只成员与偏移 / 视口里的通道\nconst channelGeometries = view.getChannels()\nconst channelMembers = view.getChannelMembers()\nconst channelsInView = view.getChannelsInView()\n","from":"header"}] },
-			{ name: "getChannelMembers", kind: "method", params: "无", returns: "GisViewChannelMembers[]：每条通道（分组之后每组各一条）的 { channelId, channelIndex, lineIndexes, offsets } —— 只要成员下标与偏移、不复制骨架 / 折线，自建覆盖层按通道分流绘制用它；整份几何（含 paths）用 getChannels()", doc: "通道成员表：每个通道的成员下标与各自的偏移（不复制几何），需要按通道分流绘制时用它（内置鹰眼图的「一个通道只画一根」就按它挑中间那条）", examples: [{"group":"拐点与通道","code":"// getChannels() / getChannelMembers() / getChannelsInView()：通道全量几何 / 只成员与偏移 / 视口里的通道\nconst channelGeometries = view.getChannels()\nconst channelMembers = view.getChannelMembers()\nconst channelsInView = view.getChannelsInView()\n","from":"header"}] },
+			{ name: "getChannelMembers", kind: "method", params: "无", returns: "GisViewChannelMembers[]：每条通道（分组之后每组各一条）的 { channelId, channelIndex, lineIndexes, offsets } —— 只要成员下标与偏移、不复制骨架 / 折线，自建覆盖层按通道分流绘制用它；整份几何（含 paths）用 getChannels()", doc: "通道成员表：每个通道的成员下标与各自的偏移（不复制几何），需要按通道分流绘制时用它（内置鹰眼图的「一个通道只画一根」按它取当前可见成员，再逐顶点平均成居中代表线）", examples: [{"group":"拐点与通道","code":"// getChannels() / getChannelMembers() / getChannelsInView()：通道全量几何 / 只成员与偏移 / 视口里的通道\nconst channelGeometries = view.getChannels()\nconst channelMembers = view.getChannelMembers()\nconst channelsInView = view.getChannelsInView()\n","from":"header"}] },
 			{ name: "getChannelGroups", kind: "method", params: "channelId?: string | number 只看这一条通道（不传给全部）", returns: "GisViewChannelGroupInfo[]", doc: "通道分组现状：每组的成员（下标 + 线路 id）、骨架与可以直接写回声明的中间拐点（path）；不传 channelId 返回所有分组，见「通道分组」", examples: [{"group":"拐点与通道","code":"// getChannelGroups(channelId?) / getChannelGroupWaypoints(channelId?, groupId?)：分组现状 / 某一组的拐点\nconst groups = view.getChannelGroups('c1')\nconst allGroups = view.getChannelGroups()\nconst groupWaypoints = view.getChannelGroupWaypoints('c1', 'c1::2')\n","from":"header"}] },
 			{ name: "getChannelGroupWaypoints", kind: "method", params: "channelId?: string | number 通道 id（不传取「当前分组」所在的通道）；groupId?: string | number 分组 id（不传取这条通道的第一组）", returns: "GisViewChannelGroupWaypoints | null：整组共用的 path（给后端那一份）+ lines[] 每条回线偏移后的 path / waypoints", doc: "一个分组的拐点现状：整组共用的骨架与中间拐点（path，给后端就是这一份）+ 组里每条回线按各自车道偏移后的折线与拐点（lines[].waypoints）；channelId 不传取「当前分组」所在的通道、groupId 不传取第一组，见「分组拐点」", examples: [{"group":"拐点与通道","code":"// getChannelGroups(channelId?) / getChannelGroupWaypoints(channelId?, groupId?)：分组现状 / 某一组的拐点\nconst groups = view.getChannelGroups('c1')\nconst allGroups = view.getChannelGroups()\nconst groupWaypoints = view.getChannelGroupWaypoints('c1', 'c1::2')\n","from":"header"}] },
 			{ name: "getLineChannel", kind: "method", params: "ref: GisViewFeatureRef 线路定位（id、lines 下标或 { id } / { index }）", returns: "{ lineIndex, channelId, channelIndex, channel, groupId, group }；这条线不在任何通道里时 null", doc: "这条线路属于哪条通道：getLineChannel('line-a')（id）/ getLineChannel(12)（lines 下标）给 { lineIndex, channelId, channelIndex, channel, groupId, group }，不在通道里返回 null。点了一条回线想知道它归哪条通道 / 哪一组时用它，不必自己扫通道定义", examples: [{"group":"拐点与通道","code":"// getLineChannel(ref)：这条线属于哪条通道 / 哪个分组（独立线路给 null）\nconst channelOfLine = view.getLineChannel('l1')\n","from":"header"}] },
@@ -193,21 +194,21 @@ export const API_SECTIONS = [
 			{ name: "addChannelGroupWaypoint", kind: "method", params: "channelId 通道 id；groupId 分组 id；coordinate 新拐点世界坐标", returns: "this", doc: "给某个分组加拐点、把这一组单独拉走：不给坐标就按默认位置放一个（第 n 组沿法线往外让 n 档），其余分组一根拐点都不动，见「分组拐点」", examples: [{"group":"拐点与通道","code":"// addChannelGroupWaypoint(channelId, groupId, coordinate) / removeChannelGroupWaypoint(channelId, groupId, pathIndex)\nview.addChannelGroupWaypoint('c1', 'c1::2', [200, 120])\nview.removeChannelGroupWaypoint('c1', 'c1::2', 1)\n","from":"header"}] },
 			{ name: "removeChannelGroupWaypoint", kind: "method", params: "channelId / groupId / pathIndex 要删的骨架顶点下标", returns: "this", doc: "删掉某个分组的拐点（缺省删最后一个）", examples: [{"group":"拐点与通道","code":"// addChannelGroupWaypoint(channelId, groupId, coordinate) / removeChannelGroupWaypoint(channelId, groupId, pathIndex)\nview.addChannelGroupWaypoint('c1', 'c1::2', [200, 120])\nview.removeChannelGroupWaypoint('c1', 'c1::2', 1)\n","from":"header"}] },
 			{ name: "runChannelAction", kind: "method", params: "actionId: GisViewChannelActionId 动作名（'select-group' / 'deselect-group' / 'add-waypoint' / 'remove-waypoint' / 'split' / 'merge'，见 getChannelContext().actions）；options?: GisViewChannelActionOptions 动作自己的参数（groupId / lineId / coordinate…）", returns: "GisViewChannelContext | null", doc: "执行右键交互框里的动作：select-group / deselect-group / add-waypoint / remove-waypoint / split / merge（options 带 channelId / groupId / coordinate / pathIndex / size），返回执行之后的上下文", examples: [{"group":"拐点与通道","code":"// setCurrentChannelGroup(channelId, groupId) / runChannelAction(actionId, options?)：当前分组与动作\nview.setCurrentChannelGroup('c1', 'c1::2')\nview.setCurrentChannelGroup('c1', null)                // 不选中\nview.runChannelAction('select-group', { groupId: 'c1::2' })\nview.runChannelAction('split', { lineId: 'l2' })\n","from":"header"}] },
-			{ name: "beginAddChannel", kind: "method", params: "options?: GisViewChannelDraftOptions 草稿配置：from（预指定起点，下一步只选终点）/ kind / circuits / autoCommit / continuous / chain / name / lineId / id / lineProps / linePropsByMember / lineItems（第二段）/ routing / path（中间拐点）/ channelProps / channelDraftStyle（本次草稿的预览样式）/ handoff（交接模式）/ select（点中的节点顺手选中，走 onSelect 那一套）/ originalEvent", returns: "this（只负责那条示例假通道，真正新增走 addChannel）", doc: "进入「新增通道」：缺省点两个节点选起点 / 终点，或由 options.from 预指定起点、只需再点终点；options 还支持 kind（'channel' 新建通道 / 'line' 新建独立线路，缺省 'channel'）/ circuits（一次加几条，缺省 1）/ autoCommit / continuous / chain / name / lineId / id / lineProps / linePropsByMember / lineItems（第二段，连同线路一起新建）/ routing（'straight' / 'orthogonal'）/ path（中间拐点）/ channelProps / channelDraftStyle（本次草稿的预览样式）/ handoff（交接模式：ready 发完收起草稿，自己调 addChannel 落地）/ select（点中的节点顺手选中）/ originalEvent，见「新增通道」", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "getAddChannelDraft", kind: "method", params: "无", returns: "GisViewChannelDraftPayload | null", doc: "当前新增通道草稿（两个节点的信息与可选方案），没有草稿时为 null", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "updateAddChannelStyle", kind: "method", params: "patch?: GisViewChannelDraftStyle | null 字段级合并的预览样式（箭头位置 / 多回线间距 / 自绘等）；传 null 回到全局 channelDraftStyle", returns: "this", doc: "字段级合并当前草稿的预览样式（color / width / dot / dotColor / arrow / arrowSize / arrowPositions / arrowReverse / arrowColor / circuitSpacing / opacity / customDraw）；传 null 回到全局 channelDraftStyle，没有草稿时什么也不做", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "continueAddChannel", kind: "method", params: "options?: GisViewChannelDraftOptions 开下一段草稿（写法与 beginAddChannel 一致，不传就沿用这一段原来的）", returns: "this", doc: "开下一段草稿：连续模式落地时内部自动调（发 phase: 'restart'），也可以手动调；草稿已经退出时按 options 重新进来", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "cancelAddChannel", kind: "method", params: "无", returns: "this（收掉草稿并补一条 phase: 'cancel'）", doc: "取消新增通道（草稿期间按 Esc 等价，会补一条 phase: 'cancel'）", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "endAddChannel", kind: "method", params: "无", returns: "this（静默收掉视图上的示例假通道 / 线路，数据不动、不补事件）", doc: "结束新增通道：静默收掉视图上的示例假通道 / 线路（不补 cancel 事件），数据一个字节都不改 —— 结束事件里决定「不新建了」就用它", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
-			{ name: "commitAddChannel", kind: "method", params: "resolution?: GisViewChannelAddResolution 落地方式（'channel' / 'line'，缺省看草稿）；options?: GisViewChannelAddInput 要覆盖的字段（name / circuits / colors / lineWidth / routing / path…）", returns: "GisViewChannelAddResult", doc: "", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?) / commitAddChannel(resolution?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 预指定起点：接下来只点终点\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\nview.commitAddChannel()                                // 两个节点选完后落地（resolution 缺省用推荐方案）\nview.commitAddChannel({ type: 'joinGroup', groupId: 'c1::2' })  // 指定方案\nview.continueAddChannel({ kind: 'line' })              // 连续模式下开下一段（也能换这一段加什么）\nview.cancelAddChannel()                                // 取消（Esc / 右键等价）\n","from":"header"}] },
+			{ name: "beginAddChannel", kind: "method", params: "options?: GisViewChannelDraftOptions 草稿配置：from（预指定起点，下一步只选终点）/ kind / circuits / autoCommit / continuous / chain / name / lineId / id / lineProps / linePropsByMember / lineItems（第二段）/ routing / path（中间拐点）/ channelProps / channelDraftStyle（本次草稿的预览样式，含 dots 与 layer）/ handoff（交接模式）/ select（点中的节点顺手选中，走 onSelect 那一套）/ originalEvent", returns: "this（只负责那条示例假通道，真正新增走 commitAddChannel / addChannel）", doc: "进入「新增通道」：缺省点两个节点选起点 / 终点，或由 options.from 预指定起点、只需再点终点；options 还支持 kind（'channel' 新建通道 / 'line' 新建独立线路，缺省 'channel'）/ circuits（一次加几条，缺省 1）/ autoCommit / continuous / chain / name / lineId / id / lineProps / linePropsByMember / lineItems（第二段，连同线路一起新建）/ routing（'straight' / 'orthogonal'）/ path（中间拐点）/ channelProps / channelDraftStyle（本次草稿的预览样式，含 dots / layer）/ handoff（交接模式：ready 发完收起草稿，自己调 addChannel 落地）/ select（点中的节点顺手选中）/ originalEvent，见「新增通道」", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?)","from":"header"}] },
+			{ name: "getAddChannelDraft", kind: "method", params: "无", returns: "GisViewChannelDraftPayload | null", doc: "当前新增通道草稿（两个节点的信息与可选方案），没有草稿时为 null", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?)","from":"header"}] },
+			{ name: "updateAddChannelStyle", kind: "method", params: "patch?: GisViewChannelDraftStyle | null 字段级合并的预览样式（箭头位置 / 多回线间距 / 两端 dots / 层级 layer / 自绘等）；传 null 回到全局 channelDraftStyle", returns: "this", doc: "字段级合并当前草稿的预览样式（color / width / dot / dotColor / dots / layer / arrow / arrowSize / arrowPositions / arrowReverse / arrowColor / circuitSpacing / opacity / customDraw）；传 null 回到全局 channelDraftStyle，没有草稿时什么也不做", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?)","from":"header"}] },
+			{ name: "continueAddChannel", kind: "method", params: "options?: GisViewChannelDraftOptions 开下一段草稿（写法与 beginAddChannel 一致，不传就沿用这一段原来的）", returns: "this", doc: "开下一段草稿：连续模式落地时内部自动调（发 phase: 'restart'），也可以手动调；草稿已经退出时按 options 重新进来", examples: [{"group":"拐点与通道","code":"// beginAddChannel(options?) / getAddChannelDraft() / updateAddChannelStyle(patch?) / continueAddChannel(options?)","from":"header"}] },
+			{ name: "cancelAddChannel", kind: "method", params: "无", returns: "this（收掉草稿并补一条 phase: 'cancel'）", doc: "取消新增通道（草稿期间按 Esc 等价，会补一条 phase: 'cancel'）", examples: [{"group":"拐点与通道","code":"// commitAddChannel(input?, options?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9,\n    // 两端示例点：false 全关；对象可统一 size / color / shape，from / to 再分别覆盖\n    dots: { size: 5, shape: 'square', from: { color: '#2f6fd0' }, to: { color: '#d9544d' } },\n    layer: 'below-points' // 示例线 / 箭头 / customDraw 画在真实节点之下；示例点仍在节点之后\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 只预指定起点：接下来只点终点（没有 from + to 的写法）\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\n","from":"header"}] },
+			{ name: "endAddChannel", kind: "method", params: "无", returns: "this（静默收掉视图上的示例假通道 / 线路，数据不动、不补事件）", doc: "结束新增通道：静默收掉视图上的示例假通道 / 线路（不补 cancel 事件），数据一个字节都不改 —— 结束事件里决定「不新建了」就用它", examples: [{"group":"拐点与通道","code":"// commitAddChannel(input?, options?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9,\n    // 两端示例点：false 全关；对象可统一 size / color / shape，from / to 再分别覆盖\n    dots: { size: 5, shape: 'square', from: { color: '#2f6fd0' }, to: { color: '#d9544d' } },\n    layer: 'below-points' // 示例线 / 箭头 / customDraw 画在真实节点之下；示例点仍在节点之后\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 只预指定起点：接下来只点终点（没有 from + to 的写法）\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\n","from":"header"}] },
+			{ name: "commitAddChannel", kind: "method", params: "input?: GisViewChannelAddResolution | GisViewChannel | GisViewLine | GisViewChannelAddCommitInput，五种写法：① 不传 / null = 用草稿 preferred；② 旧 resolution：字符串或只含非 undefined 的 type / groupId / groupIndex / channelId 的对象；③ 直接线路对象：没有 lineIds 数组，且写了 kind: 'line' / path / from / to / start / end 之一，业务字段与自己的 lineProps 透传到新线路；④ 直接通道对象：Array.isArray(lineIds) 且没有容器键，lineIds 逐条作新回线 id 种子、groups 作分组声明、自己的 lineProps 对所有新回线生效，其余字段进 channelProps，缺省 resolution: 'newChannel'；⑤ 容器：出现 channel / line / lines / lineData / lineItems / channelGroups / group / channelProps / resolution 任一键（只写 lineProps 也算）。容器里 line 缺省是独立线路，lines 是成员表（给了几条建几条，空数组沿用草稿）；channel.lineIds 只在没有 lines 时当种子。字段优先级：from / to = 顶层 → channel → line → lineItems 第一个对象项（裸 id 跳过）→ 草稿；path = 顶层 → line → channel → 草稿；分组 = channelGroups → group → channel.groups；容器 lineProps = 草稿 → 顶层 → line.lineProps → 逐条，不读 channel.lineProps；channelProps = 草稿 → channel 业务字段 → 顶层 channelProps。直接线路 / 直接通道对象默认新建，要并进已有分组必须用容器并显式写 resolution。options?: { auto?: boolean; continuous?: boolean; originalEvent?: Event | null }：auto 只标记自动提交，continuous: false 强制本次后结束，originalEvent 带回重开的草稿。ready 的方案对象不能整条回传，只取 { type, groupId, groupIndex, channelId } 子集。调用前草稿必须 ready，否则不写数据；没有草稿的程序化新增用 addChannel / addLine。完整示例见「10 通道编辑与新增」与「18 逐方法示例」", returns: "GisViewChannelAddResult", doc: "把已 ready 的草稿落到数据上。input 有五类：不传（用草稿 preferred）、旧 resolution（字符串，或只含 type / groupId / groupIndex / channelId 的对象）、直接线路对象（有 from / to / path / kind: 'line' 等线路形状）、直接通道对象（必须有 lineIds，缺省新建通道）、容器 { channel?, line?, lines?, lineData?, lineItems?, channelGroups?, group?, channelProps?, lineProps?, resolution?, ... }。对象字段优先、没写的沿用草稿；line 缺省表示独立线路，lines 才是成员回线表；直接通道对象缺省新建，直接线路对象缺省按独立线路落地，要并进已有分组必须用容器并显式写 resolution。options?: { auto?, continuous?, originalEvent? } 只影响本次事件与连续草稿。方案读数不能整条回传，只取 { type, groupId, groupIndex, channelId }。完整字段优先级与示例见「10 通道编辑与新增」的 commitAddChannel / 对象直传", examples: [{"group":"拐点与通道","code":"// commitAddChannel(input?, options?) / cancelAddChannel() / endAddChannel()\nview.beginAddChannel({\n  kind: 'channel',\n  circuits: 3,\n  channelDraftStyle: {\n    color: '#2f6fd0', width: 2.5, arrow: true, arrowSize: 14, arrowPositions: [0, 0.5, 1],\n    circuitSpacing: 12, opacity: 0.9,\n    // 两端示例点：false 全关；对象可统一 size / color / shape，from / to 再分别覆盖\n    dots: { size: 5, shape: 'square', from: { color: '#2f6fd0' }, to: { color: '#d9544d' } },\n    layer: 'below-points' // 示例线 / 箭头 / customDraw 画在真实节点之下；示例点仍在节点之后\n  }\n}) // 点两个节点：第一个起点、第二个终点；通道 3 回时预览也画 3 条平行回线\nview.beginAddChannel({ from: 'station-a' })            // 只预指定起点：接下来只点终点（没有 from + to 的写法）\nconst draft = view.getAddChannelDraft()                // 草稿读数（跟随光标的预览、两个节点、方案表与实际 style）\nview.updateAddChannelStyle({ arrowPositions: [0.25, 0.75], arrowReverse: true }) // 字段级合并，只改箭头\nview.updateAddChannelStyle(null)                       // 回到全局 channelDraftStyle\n","from":"header"},{"group":"拐点与通道","code":"// commitAddChannel 只负责把已 ready 的草稿落地；没有草稿的程序化新增用 addChannel / addLine。","from":"header"}] },
 			{ name: "getChannelAddOptions", kind: "method", params: "from / to 两端节点 id；count?: number 回数（缺省 1）；kind?: 'channel' | 'line'（缺省 'channel'）", returns: "GisViewChannelAddPlan | null", doc: "两个节点之间的新增方案：新通道 / 新分组 / 并进某一组 / 无法添加；count 是这一次要加的回数（余量按它判），kind: 'line' 时方案表为空（独立线路不挑方案）", examples: [{"group":"拐点与通道","code":"// getChannelAddOptions(from, to, count?, kind?)：两个节点之间能怎么加（界面拿它让用户选）\nconst plan = view.getChannelAddOptions('a', 'b', 2)\nconst linePlan = view.getChannelAddOptions('a', 'b', 1, 'line')\n","from":"header"}] },
 			{ name: "getChannelBetween", kind: "method", params: "from / to 两端节点 id", returns: "GisViewChannelBetween | null", doc: "两个节点之间的通道读数（只读）：有通道时 hasChannel: true，channelId / channelIndex / groupCount / currentGroupId 与 groups / group / channel（id / name / lineIds / 分组明细）都给全；没有通道时 hasChannel: false、channel: null、groups: []，端点认不出来返回 null —— 与 getChannelAddOptions 的读数同一份，界面做「这两个点之间已经有通道 / 有几组」的判断用它，不必算方案表", examples: [{"group":"拐点与通道","code":"// getChannelBetween(from, to)：只要通道读数 —— 有没有通道 / 几组 / 当前哪组（不做方案判断，端点认不出返回 null）\nconst between = view.getChannelBetween('a', 'b')\nif (between?.hasChannel) {\n  console.log(between.channelId, between.groupCount, between.groups.map(group => group.id), between.currentGroupId)\n}\n","from":"header"}] },
-			{ name: "addChannel", kind: "method", params: "channel: GisViewChannelAddSpec 通道信息 { from, to, name?, id?, lineData?, group? }（后两个是第二 / 第三段写在对象上的别名）；lineData?: GisViewChannelLineData 线路数组（Partial<GisViewLine> / string / number 的一条或一批，按每项 id 建 lineIds）；group?: GisViewChannelAddGroup | GisViewChannelAddGroup[] 可选分组信息 { id?, lineIds?, path? }。旧写法 addChannel(input, lineItems?)（GisViewChannelAddInput：circuits / resolution / channelId / groupId / groupIndex / kind / routing / path 那套）照样认；path 是中间拐点，独立线路落地成完整折线、通道只写骨架拐点", returns: "GisViewChannelAddResult（channelLineIds 是落地后通道的完整成员表，独立线路为 null）", doc: "程序化新增通道（新签名，只新建）：第一段通道信息（from / to / name / id / path 等通道字段），第二段线路数组 line_data —— 一条或一批（字符串 / 数字按 id 认），按每项 id 建 lineIds，第三段可选分组信息（{ id?, lineIds?, path? }，单个 / 一组一个）—— 第二段 / 第三段显式给了才走这条新路；两个节点之间已经有通道时整条失败（reason 指路下面两条）。旧写法 addChannel(input, lineItems?)（带 circuits / resolution / channelId / groupId / groupIndex / kind，或只写 { from, to }）照样认：按方案表新建或并进已有通道，第二段 lineItems 给了几条就建几条", examples: [{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
+			{ name: "addChannel", kind: "method", params: "channel: GisViewChannelAddSpec 通道信息 { from, to, name?, id?, lineData?, group? }（后两个是第二 / 第三段写在对象上的别名）；lineData?: GisViewChannelLineData 线路数组（Partial<GisViewLine> / string / number 的一条或一批，按每项 id 建 lineIds）；group?: GisViewChannelAddGroup | GisViewChannelAddGroup[] 可选分组信息 { id?, lineIds?, path? }。旧写法 addChannel(input, lineItems?)（GisViewChannelAddInput：circuits / resolution / channelId / groupId / groupIndex / kind / routing / path 那套）照样认；path 是中间拐点，独立线路落地成完整折线、通道只写骨架拐点", returns: "GisViewChannelAddResult（channelLineIds 是落地后通道的完整成员表，独立线路为 null）", doc: "程序化新增通道（新签名，只新建）：第一段通道信息（from / to / name / id / path 等通道字段），第二段线路数组 line_data —— 一条或一批（字符串 / 数字按 id 认），按每项 id 建 lineIds，第三段可选分组信息（{ id?, lineIds?, path? }，单个 / 一组一个）—— 第二段 / 第三段显式给了才走这条新路；两个节点之间已经有通道时整条失败（reason 指路下面两条）。旧写法 addChannel(input, lineItems?)（带 circuits / resolution / channelId / groupId / groupIndex / kind，或只写 { from, to }）照样认：按方案表新建或并进已有通道，第二段 lineItems 给了几条就建几条", examples: [{"group":"拐点与通道","code":"// commitAddChannel 只负责把已 ready 的草稿落地；没有草稿的程序化新增用 addChannel / addLine。","from":"header"},{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
 			{ name: "addChannelGroupLines", kind: "method", params: "channelId 目标通道 id；lineData?: GisViewChannelLineData 这次新建的线路数组（按每项 id 建回线）；group?: GisViewChannelAddGroup 新分组信息 { id?, path? }（缺省 ${通道 id}::N、不带拐点）", returns: "GisViewChannelAddResult", doc: "给已有通道新加一组回线（原 addChannel 的 newGroup 那一支）：第二段线路数组 line_data 按每项 id 建回线，groupInfo（{ id?, path? }）给新分组的 id 与中间拐点，缺省 ${通道 id}::N、不带拐点；通道 / 线路认不出来时 ok: false + reason", examples: [{"group":"拐点与通道","code":"// 已经有通道时用拆出来的两条（语义直说，不用自己拼 resolution）\nview.addChannelGroupLines('c1', [{ id: 'm-5' }], { id: 'c1::3' })     // 新加一组\nview.joinChannelGroupLines('c1', 'c1::2', [{ id: 'm-6' }])            // 并进某一组（序号 1 也认）\nconsole.log(joined.channelLineIds)   // 更新后这条通道的完整成员表（lineIds）\n","from":"code"}] },
 			{ name: "addChannelGroups", kind: "method", params: "channelId 目标通道 id；groups: GisViewChannelAddGroupInput | GisViewChannelAddGroupInput[] 每项 { id?, path?, lineData? | lines? | lineItems? }（线路数据与 addChannel 第二段同一份写法）；options?: { emit?: boolean; label?: string } emit: false 只落地不通知", returns: "GisViewAddChannelGroupsResult", doc: "给已有通道一次新加多组回线：groups 每项 { id?, path?, lineData | lines | lineItems }，线路数据与 addChannel 第二段同一份写法；逐组落地但只记一步历史、只发一条 addChannelGroups 数据变更，返回 { ok, reason, count, results, lineIds, groupIds, groups }，options.emit: false 只落地不通知", examples: [{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
 			{ name: "joinChannelGroupLines", kind: "method", params: "channelId 目标通道 id；groupId?: string | number 并进哪一组（认分组 id 也认序号，从 0 起；不传挑第一个还有余量的分组）；lineData?: GisViewChannelLineData 这次新建的线路数组", returns: "GisViewChannelAddResult", doc: "把新回线并进已有通道的某一组（原 addChannel 的 joinGroup 那一支）：第二段线路数组 line_data，groupId 认分组 id 也认序号（从 0 起、按声明顺序），不传就挑第一个还有余量的分组", examples: [{"group":"拐点与通道","code":"// 已经有通道时用拆出来的两条（语义直说，不用自己拼 resolution）\nview.addChannelGroupLines('c1', [{ id: 'm-5' }], { id: 'c1::3' })     // 新加一组\nview.joinChannelGroupLines('c1', 'c1::2', [{ id: 'm-6' }])            // 并进某一组（序号 1 也认）\nconsole.log(joined.channelLineIds)   // 更新后这条通道的完整成员表（lineIds）\n","from":"code"}] },
 			{ name: "addChannels", kind: "method", params: "input: GisViewChannelAddInput | GisViewChannelAddInput[] 一条或一批声明（每条与 addChannel 同一套写法；routing: 'orthogonal' 自动正交折线，path 是中间拐点，独立线路落地成完整 path、通道只写骨架）；options?: { emit?: boolean } emit: false 只改数据不发 dataChange", returns: "GisViewAddChannelsResult", doc: "addChannel 的批量版：一次新增多条通道 / 独立线路（每条是新签名或旧写法，逐条各自认；每项的 routing / path 走同一套解析，path 是中间拐点），逐条落地但只重排一次场景、只记一步历史、只发一条 addChannels 数据变更；返回 { ok, count, results, lineIds, channelIds, items }，失败条目在各自的 reason 里说明原因、不影响其余条目，options.emit: false 时不发 onDataChange，见「动态换数据与加载完成」", examples: [{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
-			{ name: "addLine", kind: "method", params: "input: GisViewChannelAddInput 同上（等价 addChannel({ ...input, kind: 'line' })；routing: 'orthogonal' 自动正交折线，path 是中间拐点，落地成含两端的完整折线）；第二段 GisViewChannelLineData 与 addChannel 的线路数组同一份 —— 每项可以只写一个 id（裸字符串 / 数字按 { id } 收）、写对象给逐条字段，不写就按 from-to-序号 自动编号", returns: "GisViewChannelAddResult", doc: "/** * 程序化新增独立线路（不挂通道）。", examples: [{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
+			{ name: "addLine", kind: "method", params: "input: GisViewChannelAddInput 同上（等价 addChannel({ ...input, kind: 'line' })；routing: 'orthogonal' 自动正交折线，path 是中间拐点，落地成含两端的完整折线）；第二段 GisViewChannelLineData 与 addChannel 的线路数组同一份 —— 每项可以只写一个 id（裸字符串 / 数字按 { id } 收）、写对象给逐条字段，不写就按 from-to-序号 自动编号", returns: "GisViewChannelAddResult", doc: "/** * 程序化新增独立线路（不挂通道）。", examples: [{"group":"拐点与通道","code":"// commitAddChannel 只负责把已 ready 的草稿落地；没有草稿的程序化新增用 addChannel / addLine。","from":"header"},{"group":"拐点与通道","code":"// addChannel(spec, lineData?, group?) / addChannels(input, options?) / addChannelGroups(channelId, groups, options?) / addLine(input)：程序化新增\nconst channelAdd = view.addChannel({ from: 'a', to: 'b', name: '二号通道', path: [[200, 120]] }, [{ id: 'm-1' }, { id: 'm-2' }])\nconst manyChannels = view.addChannels([{ from: 'a', to: 'b', circuits: 1 }, { from: 'b', to: 'a', circuits: 2, kind: 'line' }])\nconst manyGroups = view.addChannelGroups('c1', [\n  { id: 'c1::4', path: [[130, 70]], lineData: [{ id: 'm-7' }, { id: 'm-8' }] },\n  { path: [[150, 90]], lines: ['m-9'] }\n])\nconsole.log(manyGroups.count, manyGroups.lineIds, manyGroups.groupIds)\nconst lineAdd = view.addLine({ from: 'a', to: 'b', name: '三回' })","from":"header"}] },
 			{ name: "removeLine", kind: "method", params: "lineId: string | number 要删的线路 id", returns: "GisViewRemoveLineResult", doc: "移除一条线路（撤销刚落地的新增线路）：挂在通道上的回线会从通道声明里一起摘掉，通道空了整条删掉，返回 { ok, line, lineId, index, channelId, removedChannel }", examples: [{"group":"拐点与通道","code":"// removeLine(lineId) / removeLines(lineIds) / removeChannel(channelId)：删线路 / 删多条 / 删整条通道\nview.removeLine('l1')\nview.removeLines(['l1', 'l2'])\nview.removeLines('l1')                                 // 单条也认\nview.removeChannel('c1')","from":"header"}] },
 			{ name: "removeLines", kind: "method", params: "lineIds: string | number | 数组 一次删多条", returns: "GisViewRemoveLinesResult", doc: "一次移除多条线路（传数组或单条 id）：通道声明与分组跟着收拾、删空的通道整条走，返回 { ok, lineIds, indexes, lines, entries, removedChannels }", examples: [{"group":"拐点与通道","code":"// removeLine(lineId) / removeLines(lineIds) / removeChannel(channelId)：删线路 / 删多条 / 删整条通道\nview.removeLine('l1')\nview.removeLines(['l1', 'l2'])\nview.removeLines('l1')                                 // 单条也认\nview.removeChannel('c1')","from":"header"}] },
 			{ name: "removeChannel", kind: "method", params: "channelId 通道 id", returns: "GisViewRemoveChannelResult", doc: "移除整条通道：它名下的回线一条条摘掉，返回 { ok, channelId, lineIds, lines, removedChannel }", examples: [{"group":"拐点与通道","code":"// removeLine(lineId) / removeLines(lineIds) / removeChannel(channelId)：删线路 / 删多条 / 删整条通道\nview.removeLine('l1')\nview.removeLines(['l1', 'l2'])\nview.removeLines('l1')                                 // 单条也认\nview.removeChannel('c1')","from":"header"}] },
@@ -298,9 +299,9 @@ export const API_SECTIONS = [
 	{
 		title: "筛选",
 		items: [
-			{ name: "setFilter", kind: "method", params: "filter: GisViewFilterInput | null 筛选条件：完整格式 { points, lines, cascade, worker }；只筛节点时可以简写成节点条件本身；传 null 等于清空", returns: "this", doc: "设置或清空筛选条件（传 null 清空）：完整格式 { points, lines, cascade, worker }，只筛节点时可以简写成节点条件本身；见「筛选」", examples: [{"group":"筛选","code":"// setFilter(filter)：设筛选条件（只筛节点可以写简写）；传 null 等于清空\nview.setFilter({ vn_kv: { gte: 525 } })\nview.setFilter({ points: { station_type: 'coal' }, lines: { vn_kv: { gte: 525 } }, cascade: 'binding' })\nview.setFilter(null)\n","from":"header"}] },
-			{ name: "getFilter", kind: "method", params: "无", returns: "GisViewFilter | null", doc: "当前条件与最近一次结果：隐藏的点 / 线下标、可见数量、是否用了 Worker、耗时", examples: [{"group":"筛选","code":"// getFilter() / getFilterResult()：当前条件（副本）/ 最近一次结果\nview.setFilter(null)\nconst filter = view.getFilter()\nconst filterResult = view.getFilterResult()   // { hiddenPoints, hiddenLines, visiblePoints, visibleLines, worker, durationMs }","from":"header"}] },
-			{ name: "getFilterResult", kind: "method", params: "无", returns: "GisViewFilterResult | null", doc: "当前条件与最近一次结果：隐藏的点 / 线下标、可见数量、是否用了 Worker、耗时", examples: [{"group":"筛选","code":"// getFilter() / getFilterResult()：当前条件（副本）/ 最近一次结果\nview.setFilter(null)\nconst filter = view.getFilter()\nconst filterResult = view.getFilterResult()   // { hiddenPoints, hiddenLines, visiblePoints, visibleLines, worker, durationMs }","from":"header"}] },
+			{ name: "setFilter", kind: "method", params: "filter: GisViewFilterInput | null 筛选条件：完整格式 { points, lines, cascade, mode, worker }；只筛节点时可以简写成节点条件本身；传 null 等于清空。mode: 'hide'（缺省）只隐藏、不删数据、不清空选中集；mode: 'remove' 删除筛选结果，只发一条 filterRemove 与最终一条 onFilter", returns: "this", doc: "设置或清空筛选条件（传 null 清空）：完整格式 { points, lines, cascade, mode, worker }，只筛节点时可以简写成节点条件本身。mode: 'hide'（缺省）只隐藏、不删数据、也不清空选中集；mode: 'remove' 把筛选结果从数据里删掉，只发一条 filterRemove 数据变更与最终一条 onFilter，见「筛选」", examples: [{"group":"筛选","code":"// setFilter(filter)：设筛选条件（只筛节点可以写简写）；传 null 等于清空；默认只隐藏\nview.setFilter({ vn_kv: { gte: 525 } })\nview.setFilter({ points: { station_type: 'coal' }, lines: { vn_kv: { gte: 525 } }, cascade: 'binding' })\nview.setFilter(null)\n","from":"header"}] },
+			{ name: "getFilter", kind: "method", params: "无", returns: "GisViewFilter | null", doc: "当前条件与最近一次结果：隐藏的点 / 线下标、可见数量、是否用了 Worker、耗时", examples: [{"group":"筛选","code":"// getFilter() / getFilterResult()：当前条件（副本）/ 最近一次结果\nview.setFilter(null)\nconst filter = view.getFilter()\nconst filterResult = view.getFilterResult()   // hide 模式是隐藏下标；remove 完成后 hidden 为空","from":"header"}] },
+			{ name: "getFilterResult", kind: "method", params: "无", returns: "GisViewFilterResult | null", doc: "当前条件与最近一次结果：隐藏的点 / 线下标、可见数量、是否用了 Worker、耗时", examples: [{"group":"筛选","code":"// getFilter() / getFilterResult()：当前条件（副本）/ 最近一次结果\nview.setFilter(null)\nconst filter = view.getFilter()\nconst filterResult = view.getFilterResult()   // hide 模式是隐藏下标；remove 完成后 hidden 为空","from":"header"}] },
 		]
 	},
 	{
@@ -310,6 +311,9 @@ export const API_SECTIONS = [
 			{ name: "once", kind: "method", params: "与 on 同一套事件名与载荷；只触发一次，回调跑完自动摘掉。返回的取消函数可提前撤销；即使提前取消，重复调用也安全", returns: "() => void 取消订阅", doc: "订阅事件（与 options 里的回调同一条，可以挂多条）：返回取消订阅的函数；'*' 订阅全部事件，回调拿到 (载荷, 事件名)，见「事件订阅」", examples: [{"group":"事件、开关与历史","code":"// on(name, handler) / once(name, handler) / off(name, handler?)：订阅（'*' 订阅全部）\nconst offData = view.on('dataChange', payload => sync(payload))\nview.on('*', (payload, name) => log(name, payload))\nview.once('dataRendered', payload => { loading = false })\nview.off('dataChange')                // 摘掉这个事件的全部回调\nview.off('dataChange', sync)          // 只摘掉这一个（返回摘掉几条）\n","from":"header"}] },
 			{ name: "off", kind: "method", params: "name 事件名（也认 '*'）；handler? 只摘掉这一个回调，不传 = 摘掉这个事件的全部订阅", returns: "number 摘掉几条（没摘到返回 0）", doc: "取消订阅：不传 handler 就摘掉这个事件的全部订阅，返回摘掉几条", examples: [{"group":"事件、开关与历史","code":"// on(name, handler) / once(name, handler) / off(name, handler?)：订阅（'*' 订阅全部）\nconst offData = view.on('dataChange', payload => sync(payload))\nview.on('*', (payload, name) => log(name, payload))\nview.once('dataRendered', payload => { loading = false })\nview.off('dataChange')                // 摘掉这个事件的全部回调\nview.off('dataChange', sync)          // 只摘掉这一个（返回摘掉几条）\n","from":"header"}] },
 			{ name: "use", kind: "method", params: "plugin: GisViewPlugin（(view, context) => hook，与 options.plugins 的写法一致）：立即执行一次，返回卸载函数 —— 调它跑插件自己的 destroy（重复调用只清一次，实例销毁之后也安全）", returns: "() => void 卸载", doc: "运行时挂一个插件（写法与 options.plugins 里的一项一致）：调用即执行，返回幂等的卸载函数（跑插件自己的 destroy），见「插件」", examples: [{"group":"事件、开关与历史","code":"// use(plugin)：运行时挂插件（立即执行一次，返回卸载函数）\nconst dispose = view.use((view, context) => ({ destroy() { /* 插件自己的清理；context.apiVersion 当前为 1 */ } }))\ndispose()\n","from":"header"}] },
+			{ name: "registerCommand", kind: "method", params: "name: string 命令名（会 trim，同名覆盖）；handler: GisViewCommandHandler<Payload, Value> 同步处理函数 (payload, context) => Value，context 是冻结的 { view, name }。名字为空 / handler 不是函数只报 warning、不注册；视图销毁后注册不生效", returns: "() => void 幂等注销；同名已被后来者覆盖时不会误删新命令", doc: "注册一个实例命令：handler(payload, context) 同步执行，context 是冻结的 { view, name }；同名覆盖，返回幂等的注销函数，旧卸载函数不会误删后来注册的同名命令，见「实例命令」", examples: [{"group":"事件、开关与历史","code":"// registerCommand(name, handler) / executeCommand(name, payload?) / listCommands()：实例级业务命令\nconst disposeCommand = view.registerCommand('focusHighestLoad', (payload = {}, context) => {\n  const threshold = Number(payload.threshold ?? 0.8)\n  const target = view.getData().points\n    .filter(point => Number(point.max_loading_rate ?? 0) >= threshold)\n    .sort((left, right) => Number(right.max_loading_rate ?? 0) - Number(left.max_loading_rate ?? 0))[0]\n  if (!target) return { focused: false, threshold }\n  context.view.focusOn(target.id, { select: true, zoom: true, maxZoom: 12 })\n  return { focused: true, id: target.id, command: context.name }\n})\nconst commandResult = view.executeCommand('focusHighestLoad', { threshold: 0.85 })\nconst commandNames = view.listCommands()   // ['focusHighestLoad']\ndisposeCommand()                           // 幂等卸载；同名覆盖时不会误删新命令\n","from":"header"}] },
+			{ name: "executeCommand", kind: "method", params: "name: string 命令名；payload?: unknown 原样交给 handler", returns: "GisViewCommandResult<Value>：{ ok: true, name, value } / { ok: false, name, reason }（未注册 / 名字非法 / handler 抛错）", doc: "执行实例命令：成功给 { ok: true, name, value }；名字非法 / 未注册 / handler 抛错给 { ok: false, name, reason }，见「实例命令」", examples: [{"group":"事件、开关与历史","code":"// registerCommand(name, handler) / executeCommand(name, payload?) / listCommands()：实例级业务命令\nconst disposeCommand = view.registerCommand('focusHighestLoad', (payload = {}, context) => {\n  const threshold = Number(payload.threshold ?? 0.8)\n  const target = view.getData().points\n    .filter(point => Number(point.max_loading_rate ?? 0) >= threshold)\n    .sort((left, right) => Number(right.max_loading_rate ?? 0) - Number(left.max_loading_rate ?? 0))[0]\n  if (!target) return { focused: false, threshold }\n  context.view.focusOn(target.id, { select: true, zoom: true, maxZoom: 12 })\n  return { focused: true, id: target.id, command: context.name }\n})\nconst commandResult = view.executeCommand('focusHighestLoad', { threshold: 0.85 })\nconst commandNames = view.listCommands()   // ['focusHighestLoad']\ndisposeCommand()                           // 幂等卸载；同名覆盖时不会误删新命令\n","from":"header"}] },
+			{ name: "listCommands", kind: "method", params: "无", returns: "string[] 当前注册的命令名（按注册顺序；同名覆盖不改变位置）", doc: "当前注册着哪些实例命令（按注册顺序；同名覆盖不改变原来的位置）", examples: [{"group":"事件、开关与历史","code":"// registerCommand(name, handler) / executeCommand(name, payload?) / listCommands()：实例级业务命令\nconst disposeCommand = view.registerCommand('focusHighestLoad', (payload = {}, context) => {\n  const threshold = Number(payload.threshold ?? 0.8)\n  const target = view.getData().points\n    .filter(point => Number(point.max_loading_rate ?? 0) >= threshold)\n    .sort((left, right) => Number(right.max_loading_rate ?? 0) - Number(left.max_loading_rate ?? 0))[0]\n  if (!target) return { focused: false, threshold }\n  context.view.focusOn(target.id, { select: true, zoom: true, maxZoom: 12 })\n  return { focused: true, id: target.id, command: context.name }\n})\nconst commandResult = view.executeCommand('focusHighestLoad', { threshold: 0.85 })\nconst commandNames = view.listCommands()   // ['focusHighestLoad']\ndisposeCommand()                           // 幂等卸载；同名覆盖时不会误删新命令\n","from":"header"}] },
 			{ name: "getFeatures", kind: "method", params: "无", returns: "GisViewFeatureState", doc: "读当前生效的功能开关（跟随详细配置的也解析成 true / false）/ 换一份（预设名 / 开关表 / true / false），换完立刻生效并发一条 onFeatureChange", examples: [{"group":"事件、开关与历史","code":"// getFeatures() / setFeatures(next)：功能开关的读 / 写（预设名 / 开关表 / 布尔值）\nconst features = view.getFeatures()\nview.setFeatures('view')              // 'edit' / 'view' / 'static'\nview.setFeatures({ drag: false })     // 单个开关\nview.setFeatures(true)                // 全开\n","from":"header"}] },
 			{ name: "setFeatures", kind: "method", params: "next: GisViewFeaturesInput 预设名（'edit' / 'view' / 'static'）、开关表或布尔值", returns: "this", doc: "读当前生效的功能开关（跟随详细配置的也解析成 true / false）/ 换一份（预设名 / 开关表 / true / false），换完立刻生效并发一条 onFeatureChange", examples: [{"group":"事件、开关与历史","code":"// getFeatures() / setFeatures(next)：功能开关的读 / 写（预设名 / 开关表 / 布尔值）\nconst features = view.getFeatures()\nview.setFeatures('view')              // 'edit' / 'view' / 'static'\nview.setFeatures({ drag: false })     // 单个开关\nview.setFeatures(true)                // 全开\n","from":"header"}] },
 			{ name: "undo", kind: "method", params: "无：从撤销 / 重做栈回放一步；会同步数据、发 history 与对应的 dataChange，并更新相机以外的运行时读数", returns: "GisViewHistoryStepResult | null：{ type, label, canUndo, canRedo }；历史没开或栈空时为 null", doc: "撤销 / 重做一步：返回 { type, label, canUndo, canRedo }，历史没开或没得撤销 / 重做时返回 null", examples: [{"group":"事件、开关与历史","code":"// undo() / redo() / canUndo() / canRedo()：撤销 / 重做（历史的开关在 options.history）\nview.undo()\nview.redo()\nconst canGoBack = view.canUndo()\nconst canGoForward = view.canRedo()\n","from":"header"}] },
@@ -363,7 +367,7 @@ export const API_OPTIONS = [
 	{ name: "channelTangentInset", type: "number | null", defaultValue: "null", doc: "两端切点往节点里收多少 CSS 像素：缺省（null）按成员回线里最粗那条的线宽收，线因此不会从节点边缘探出去；0 表示切点正好落在节点边上，负数外收（切点往节点外让、回线整段比节点宽）；单个通道可用 tangentInset 覆盖；内收两侧合计最多收掉节点宽度的 40%，外收单侧最多让出 50%" },
 	{ name: "channelMaxGroups", type: "number", defaultValue: "0", doc: "一条通道最多几个分组（0 表示不限）：新增通道时用来判断还能不能变成新分组，见「新增通道」" },
 	{ name: "channelGroupMaxLines", type: "number", defaultValue: "0", doc: "一个分组最多几条回线（0 表示不限）：新增通道时用来判断还能不能并进某一组，见「新增通道」" },
-	{ name: "channelDraftStyle", type: "GisViewChannelDraftStyle", defaultValue: "蓝色 2px + 两端圆点，箭头关闭", doc: "新增通道草稿预览的全局样式：color / width / dot / dotColor / arrow / arrowSize / arrowPositions / arrowReverse / arrowColor / circuitSpacing / opacity / customDraw；beginAddChannel({ channelDraftStyle }) 可按这一次草稿覆盖，updateAddChannelStyle(patch) 可在草稿期间增量修改" },
+	{ name: "channelDraftStyle", type: "GisViewChannelDraftStyle", defaultValue: "蓝色 2px + 两端圆点，箭头关闭", doc: "新增通道草稿预览的全局样式：color / width / dot / dotColor / dots（false 关示例点，或 { show, size, color, shape, from, to } 分端配置；示例点固定在点中的节点中心）/ layer（'above' 默认，'below-points' 让示例线 / 箭头 / customDraw 位于真实节点之下）/ arrow / arrowSize / arrowPositions / arrowReverse / arrowColor / circuitSpacing / opacity / customDraw；beginAddChannel({ channelDraftStyle }) 可按这一次草稿覆盖，updateAddChannelStyle(patch) 可在草稿期间增量修改" },
 	{ name: "webglLayers", type: "GisViewWebGLLayer[]", defaultValue: "[]", doc: "WebGL 自定义绘制层：每层提供 draw({ gl, canvas, viewport, camera, frame, project, unproject, requestRender })，在内置内容之后按 order 绘制；运行时也可用 addWebGLLayer / updateWebGLLayer / removeWebGLLayer 维护" },
 	{ name: "background", type: "GisViewBackground", defaultValue: "浅色底", doc: "背景层，支持底色、图片与 GeoJSON" },
 	{ name: "pointStyle", type: "GisViewPointStyle", defaultValue: "见下", doc: "点的默认样式，可被单个点覆盖；运行时按字段合并用 updatePointStyle(patch)（updateOptions({ pointStyle }) 是整份换）" },
@@ -381,8 +385,8 @@ export const API_OPTIONS = [
 	{ name: "labelStates", type: "GisViewLabelState[]", defaultValue: "无", doc: "标签的运行时状态（getLabelStates() 的那一份：拖出来的偏移、改过的内容与样式、运行时加的标签、隐藏覆盖）：创建时喂回来就回显，等价于创建之后调 setLabelStates(states)；updateOptions({ labelStates }) 同样认。exportData({ format: 'input' }) 的结果里就叫 labelStates，存档 → 回灌直接接上" },
 	{ name: "graphics", type: "GisViewGraphic[]", defaultValue: "无", doc: "与节点无关的扩展图形：按世界坐标放 SVG 路径 / 图片 / Canvas，支持锚点、偏移、旋转、透明度、zIndex 与 scaleWithView；位于画布之上、标签之下，运行时用 addGraphic / addGraphics / updateGraphic / removeGraphic / clearGraphics 增删改，见「扩展图形（graphic）」" },
 	{ name: "tooltip", type: "GisViewTooltipOptions", defaultValue: "无", doc: "悬停提示：点 / 线 / 通道分别配置内容，见「悬浮提示」" },
-	{ name: "minimap", type: "GisViewMinimapOptions | null", defaultValue: "无", doc: "内置鹰眼图：位置、尺寸、节点 / 线路 / 视口框三份样式与交互都可配，extent 决定小图按数据范围还是「数据 ∪ 底图」铺（默认 auto，GeoJSON 底图不会缩成一个点），zoomable 打开后小图自身可整体放大缩小（空白处拖动可以平移小图或直接框选让主图显示过去，每格倍率 zoomStep），通道还能只画一根；小图同样支持规则（pointRules / lineRules，缺省沿用主图规则的颜色与层级），可以只画某几层（levels）、关掉分层叠画（layered）、按三组系数给节点与线路定尺寸（整体倍数 pointSizeScale / lineWidthScale、跟随小图倍数 pointZoomScale / lineZoomScale（只在小图自身倍数 ≠ 1 时起作用）、跟随主视图地图倍数 pointMapZoomScale / lineMapZoomScale），视口框与框选矩形的颜色 / 背景 / 边框 / 圆角也能配（boxStyle / selectStyle），extent 还能直接写死一份世界范围、容器可加 className / style、layers 按 placement 分数据前 / 数据后、段内按 order 拆出多层自绘内容（旧 draw 钩子仍兼容并排在最后）、onInteraction 在手势结束时给出类型 / 世界坐标 / 相机、maxPixelRatio 限制备份倍率上限，不配则不产生任何 DOM，见「鹰眼图」" },
-	{ name: "filter", type: "GisViewFilterInput | null", defaultValue: "无", doc: "初始筛选条件，等价于创建之后调用 setFilter，见「筛选」" },
+	{ name: "minimap", type: "GisViewMinimapOptions | null", defaultValue: "无", doc: "内置鹰眼图：位置、尺寸、节点 / 线路 / 视口框三份样式与交互都可配，extent 决定小图按数据范围还是「数据 ∪ 底图」铺（默认 auto，GeoJSON 底图不会缩成一个点），extentFollowCamera 默认 false、打开后才允许 auto 范围随相机收窄。zoomable 三态互斥：false 关闭、true 手动缩放小图自身、'follow' 让整体范围跟随主图（followZoomScale 是主图倍数的指数，跟随模式下 setMinimapZoom / zoomMinimapBy 不抢控制权）；空白处拖动可平移小图或直接框选让主图显示过去（dragAction，box 不依赖缩放，手动模式下 Ctrl / ⌘ 才切换动作），每格倍率 zoomStep。通道还能只画一根；小图同样支持规则（pointRules / lineRules，缺省沿用主图规则的颜色、层级、最终节点尺寸与图标、样式链线宽，节点 / 线路尺寸按两边视口比例缩放且不受主图相机倍数影响），可以只画某几层（levels）、关掉分层叠画（layered）、按三组系数给节点与线路定尺寸（整体倍数 pointSizeScale / lineWidthScale 对自有与继承要素都生效；跟随小图倍数 pointZoomScale / lineZoomScale 在小图自身放大时也作用于继承要素；跟随主视图地图倍数 pointMapZoomScale / lineMapZoomScale 只作用于自有规则 / 样式），视口框与框选矩形的颜色 / 背景 / 边框 / 圆角也能配（boxStyle / selectStyle），extent 还能直接写死一份世界范围、容器可加 className / style、layers 按 placement 分数据前 / 数据后、段内按 order 拆出多层自绘内容（旧 draw 钩子仍兼容并排在最后）、onInteraction 在手势结束时给出类型 / 世界坐标 / 相机、maxPixelRatio 限制备份倍率上限，不配则不产生任何 DOM，见「鹰眼图」" },
+	{ name: "filter", type: "GisViewFilterInput | null", defaultValue: "无", doc: "初始筛选条件，等价于创建之后调用 setFilter；mode 缺省 'hide'，写 'remove' 则删除不命中的要素，见「筛选」" },
 	{ name: "filterWorker", type: "boolean | GisViewFilterWorkerOptions", defaultValue: "{ threshold: 20000 }", doc: "筛选是否用 Web Worker 计算：默认点 + 线总数超过阈值才用，false 表示始终同步算" },
 	{ name: "searchWorker", type: "boolean | GisViewSearchWorkerOptions", defaultValue: "{ threshold: 20000 }", doc: "[异步搜索](14-视图与筛选.md#搜索与定位)是否用 Web Worker 计算：默认点 + 线总数超过阈值才用，false 表示 searchAsync 也同步算；同步的 search 一直在主线程算，不受这一项影响" },
 	{ name: "pointHoverStyle", type: "GisViewPointStyle", defaultValue: "无", doc: "点的悬停 / 选中样式；没配就不改变外观（悬停仍然触发回调与提示、选中仍然进选中集合），要反馈就自己配一份" },
@@ -402,6 +406,7 @@ export const API_OPTIONS = [
 	{ name: "fitSpacing", type: "boolean | GisViewFitSpacingOptions", defaultValue: "关", doc: "适应视图的节点间距兜底：true 用 { minDistance: 24, maxZoom: 0 }，对象可改最小中心距（CSS 像素）与相对普通适应比例的上限（0 表示不限）；只在首次默认适应与 fitView() 生效，远处孤立点允许落到视口外，见「适应视图的节点间距（fitSpacing）」" },
 	{ name: "boxSelect", type: "boolean", defaultValue: "false", doc: "是否允许按住框选快捷键（shortcuts.boxSelect，默认 Shift）拖动鼠标框选要素；缺省关，写 boxSelect: true 或 features: { boxSelect: true } 才开。框选默认只收节点，selectionKinds 可把线路 / 通道也纳入" },
 	{ name: "multiSelect", type: "boolean", defaultValue: "false", doc: "多选开关：打开后不用按修饰键，直接单击节点 / 线路就取反累加选中（与按住 shortcuts.multiSelect 点击同一套行为、同一个 multiSelectStyle；取反那一下不经过 onClick，onSelectChange.action.type 是 toggleSelect）；缺省关，关着时多选走框选（boxSelect）与按住多选快捷键（默认 Ctrl / ⌘）。运行时 updateOptions({ multiSelect }) 切换只重画一帧、不重排场景" },
+	{ name: "selectTrigger", type: "'click' | 'dblClick'", defaultValue: "'click'", doc: "选中触发方式：click 第一次单击就改选中集；dblClick 第一下只派发 onClick，等双击判定命中的第二下才改选中集，并同时派发 onClick 与 onDblClick。Ctrl / ⌘ 多选与 multiSelect 在双击模式下同样等第二下才取反。运行时走 updateOptions({ selectTrigger })，只重画一帧、不重排场景" },
 	{ name: "selectionKinds", type: "GisViewSelectionKindsInput", defaultValue: "无（框选只收节点；Ctrl 多选收节点 / 线路 / 通道）", doc: "框选与 Ctrl / 多选点击的类型过滤：'point' 节点、'line' 通道外的独立线路、'channel' 通道回线；可写数组任意组合，'all' / true 全开，false / null 全关。通道回线只归 channel 管，通道外的线路只归 line 管；通道回线仍按 channelSelectMode 摊开。不写时保留旧口径；普通单选与 select / selectFeatures 不受它限制。运行时走 updateOptions({ selectionKinds })，见「框选」与「选择类型过滤」" },
 	{ name: "selectionBoxStyle", type: "GisViewSelectionBoxStyle", defaultValue: "蓝底 0.16 透明 + 1px 蓝框", doc: "框选矩形的填充与边框：fill、fillOpacity、stroke、strokeWidth" },
 	{ name: "selectionOnTop", type: "boolean", defaultValue: "true", doc: "选中的节点 / 拖动中的整组 / 待确认合并的目标节点，以及选中线路所在的整条通道，是否画在所有要素之上（与 zIndex 无关），见「选中 / 拖动的层级」" },

package/docs/demos/demos.js

@@ -161,7 +161,7 @@ export const DEMOS = [
 		id: 'extension',
 		title: '扩展能力',
 		group: 'data',
-		blurb: '四个扩展点同屏：view.use 运行时插件、自定义图元、自定义条件运算符与 defineExportFormat 业务导出。',
+		blurb: '六个扩展点同屏：view.use 运行时插件、自定义图元、自定义条件运算符、defineExportFormat 业务导出、WebGL 自定义层与实例命令。',
 		doc: DOC_EXTEND,
 		component: () => import('./ExtensionDemo.vue')
 	},

package/docs/demos/gis-view-demo/GisViewDemoCardHeader.vue

@@ -22,6 +22,7 @@ const {
 					<p>这一轮补上三块：① 通道可以分组了——默认一条通道一组，「拆分分组」按每组几条回线把它拆开（第一组沿用当前拐点、新分组的线路不带拐点），「合并分组」把其余分组并进第一组（被并入的线路跟随第一组的拐点，第一组没有拐点就一条都不带），加点 / 拖点只作用于同一分组，分组声明写回 channels[].groups；② 鹰眼图也支持规则——「规则沿用主图」只搬颜色与层级（主图的像素尺寸不会搬过来），「按电压单独配色」给小图自己配一份（半径缩到 1 ~ 2.6px、高电压用方块、zIndex 沿用电压分档），「分层」控制分层叠画、层级下拉只画某几层，「放大节点 / 放大线路」让节点与线路跟着小图自身的倍数放大（滚轮或 － / ＋ 都算）；③ 定向更新——updatePoint / updateLine / updateChannel 改一个节点、线路或通道就重渲染相关的视图，只重解析受影响的那一小片，其余要素与缓存一个字节都不动，鹰眼图与标签覆盖层跟着重画。</p>
 					<p>热力图这一轮把节点那一层补上了：合成数据的节点与线路都按一张「热区场」随机生成 max_loading_rate（在数据范围里撒 4 ~ 6 个热区，节点取自己坐标处的场值、线路取两端中点处的场值 —— 画出来是几团往外化开的色斑，而不是均匀噪点），作用对象因此可以切「节点 + 线路 + 通道」/「只按节点上色」/「线路 + 通道回线」/「只按通道自己的值」四档；面板上的「重新随机一份热力数据」能在任意数据集上现生成一份（换种子、按当前节点范围重建场，只改字段值，坐标与拓扑一动不动），真实数据 new.json 的节点本来没有这一列、线路那一列又恒为 1.5，点一下就能立刻看到热力。作用对象带上节点时图标不再跟着换：图标符号写了 tint（逐实例着色），填充按白色烘焙、由热力色逐实例染上，描边写 currentStrokeColor 不参与染色 —— 形状与描边还是那张图标，只是填充跟着值走；贴图缓存键里因此不再有逐点的热力色，900 节点时绘制调用仍然在 36 上下（以前一个节点一张贴图时会涨到约 1500，10 万级直接把主线程烤住），想看「完全不参与热力图」的效果就把节点从作用对象里去掉 —— 图标本身不会变成内置圆 / 方块。</p>
 					<p>这一轮补上六件事：① <b>节点复制</b>——按住 Alt（面板上可以改成别的键）点一个节点，复制品立刻压在源节点上跟着鼠标走，松开左键（不再看 Alt 什么时候松）或再点一下落地；也可以点面板上的「先点按钮再选节点」再点一个节点（复制品落在它旁边），或者选中节点按 Ctrl+C、把鼠标移到目标位置按 Ctrl+V。复制全程走 <b>onPointCopy</b>：start / move / commit / end / cancel（复制到剪贴板另发一条 clipboard），落地前的 commit 阶段可以 payload.cancel() 撤掉、payload.update() / setItem() 改数据，id 与整份数据由 copy.createId / copy.createItem 定；落地之后的 end 阶段还能 payload.revert() 整份回滚（面板上「复制后模拟接口失败」那个勾就是它）。② <b>节点合并</b>——把一个节点拖到另一个节点上（碰撞按两个节点画在屏幕上的半径之和 + merge.distance 判，整组拖动不参与），<b>组件不弹任何对话框</b>：pending 停在原地等使用方裁决，面板上的「合并确认」三档分别是「停住（由这个自写弹层来确认）」/ false 直接合并 / 函数返回 Promise（先调接口再决定，resolve(false) 取消）；确认会先推进到 confirm 阶段并把合并结果给你（可以改，也可以在这一步因为「接口失败」整份撤掉），确认之后来源节点的数据并进目标（缺省 { ...来源, ...目标 }，可用 merge.createItem 整份接管）、<b>尺寸取双方最大、图标优先目标</b>、绑在它上面的线路改绑、合并出来的自环与零长线删掉；两端因此撞成同一条的通道按 merge.channelGroups 处理（各自保留分组 / 合成一个分组，自环的整条删），读数里会带上改端点的通道数与并掉的通道数。取消或接口失败则把拖动的节点与跟随它的线路还原回原位，并补发一条拖拽结束。③ <b>所有快捷键都能改</b>——options.shortcuts 按动作配（框选 / 多选 / 加点 / 复制 / 复制到剪贴板 / 粘贴 / 取消 / 删除 / 适应视图），写法是纯修饰键（ctrl / meta / shift / alt / mod）、组合键（ctrl+c）、单键（escape / 0）或数组，写 false 表示不绑定；面板「视图 · 交互」里那四个下拉就是改框选 / 多选 / 加点 / 复制的修饰键——比如把框选改成 Shift，之后 Shift + 拖动才出选框，按住 Shift 时连光标变体也跟着走。④ <b>选中抬层</b>——selectionOnTop（缺省开）把选中的节点、拖动中的整组、待确认合并的目标节点与选中线路所在的整条通道画在所有要素之上：选中了就一定看得见，与 zIndex 无关；关掉就完全按 zIndex 与数据顺序画。⑤ <b>删除（Delete）</b>——选中拐点 / 线路 / 节点之后按 Delete（或面板上的「删除选中」）先出一份删除载荷：要删什么、连带什么、能按哪些范围删。<b>组件不弹界面</b>：pending 停在原地等 <b>confirm(scope)</b> / cancel()，Esc 也能取消；范围三档是「只删选中的线路」/「删除整个分组」/「删除整条通道」（后两档只在删的是通道回线、且这条通道分过组时才有），选中的拐点与节点一律一起删 —— <b>删节点会连挂在它身上的线路、以及拿它当端点的整条通道一起删</b>，载荷里的 lineCount / channelCount 就是这份连带读数；确认之后整段合成一条历史，撤销一步全回来；开关是 features.remove，快捷键照样走 shortcuts.remove（可以单独配成 shift+delete 之类）。⑥ <b>通道选中模式</b>——channelSelectMode 决定点中一条通道回线时选中什么：line（缺省，只选这一条）/ group（连它所在分组一起）/ channel（整条通道一起）；在 group / channel 下 Ctrl + 点击是<b>整批取反</b>，通道以外的线路永远只选它自己。它只影响「下一次点选怎么摊开」，切换走 updateOptions，场景一个字节都不用重排。面板「视图 · 复制合并」里那两项就是它们。</p>
+					<p>定位口径这一轮统一了：<code>focusOn(target)</code> 缺省只把中心移到目标上，比例一点不动；要按目标范围适配必须显式写 <code>{ zoom: true }</code>，可再配 <code>padding</code> / <code>maxZoom</code>。节点、线路、通道与分组走同一条规则，搜索面板与画布菜单里需要适配的按钮都已经写成显式开启。</p>
 				</div>
 				<span class="demo-badge">WebGL2 · 无内置 GUI</span>
 			</div>

package/docs/demos/gis-view-demo/GisViewDemoStage.vue

@@ -4,8 +4,8 @@ const {
 	containerRef, stageRef, isFullscreen, fullscreenSupported, toggleFullscreen, viewRef, selectionCount, stats,
 	qualityBadge, cursorText, hostZoom, zoomText, pointerText, screenText, lngLatText, canvasMenu, closeCanvasMenu,
 	canvasMenuStyle, canvasMenuRows, runCanvasMenuAction, pointSizeScale, lineWidthScale, minimapSize,
-	minimapEnabled, minimapShowLines, minimapExtent, minimapZoomable, minimapDragAction, minimapChannelCircuits,
-	minimapZoomStep, zoomMinimap, minimapRuleMode, minimapLayered, minimapLevels, minimapCascade, minimapPointSize,
+	minimapEnabled, minimapShowLines, minimapExtent, minimapExtentFollowCamera, minimapZoomMode, minimapFollowZoomScale,
+	minimapDragAction, minimapChannelCircuits, minimapZoomStep, zoomMinimap, minimapRuleMode, minimapLayered, minimapLevels, minimapCascade, minimapPointSize,
 	minimapLineWidth, minimapPointZoom, minimapLineZoom, minimapPointMapZoom, minimapLineMapZoom, minimapBoxFill,
 	minimapBoxFillOpacity, minimapBoxStroke, minimapBoxStrokeWidth, minimapBoxStrokeStyle, minimapBoxRadius,
 	minimapDrawLayer, minimapSummary, minimapLayerOptions, heatDensityText, channelMenu, closeChannelMenu,
@@ -105,6 +105,10 @@ const {
 							<option value="data">范围：只看数据</option>
 							<option value="background">范围：只看底图</option>
 						</select>
+						<label class="demo-minimap-switch" title="extent=auto 时是否允许范围随相机收窄；默认关，避免包围盒与视口框自己跳">
+							<input v-model="minimapExtentFollowCamera" type="checkbox" :disabled="!minimapEnabled || minimapExtent !== 'auto'" />
+							范围跟相机
+						</label>
 						<label class="demo-minimap-switch">
 							<input v-model="minimapEnabled" type="checkbox" />
 							鹰眼
@@ -117,22 +121,27 @@ const {
 							<input v-model="minimapChannelCircuits" type="checkbox" />
 							回线
 						</label>
-						<label class="demo-minimap-switch">
-							<input v-model="minimapZoomable" type="checkbox" />
-							可缩放
-						</label>
-						<select v-model="minimapDragAction" :disabled="!minimapEnabled || !minimapZoomable" title="开了可缩放之后，小图空白处拖动的动作（按住 Ctrl / ⌘ 拖动是另一个）">
+						<select v-model="minimapZoomMode" :disabled="!minimapEnabled" title="缩放模式：关闭 / 手动缩放小图 / 整体范围跟随主图；手动与跟随互斥">
+							<option value="off">缩放：关闭</option>
+							<option value="manual">缩放：手动</option>
+							<option value="follow">缩放：跟随主图</option>
+						</select>
+						<select v-model="minimapDragAction" :disabled="!minimapEnabled" title="小图空白处拖动的动作：pan 平移小图内容（需手动缩放），box 直接框选（不依赖缩放开关）；只有手动缩放时 Ctrl / ⌘ 才切换另一个动作">
 							<option value="pan">拖动＝平移小图</option>
 							<option value="box">拖动＝框选</option>
 						</select>
-						<select v-model.number="minimapZoomStep" :disabled="!minimapEnabled || !minimapZoomable" title="每一次放大 / 缩小的倍率（滚轮一格与 － / ＋ 按钮）">
+						<label class="demo-minimap-switch" title="zoomable=follow 时主图相对基准倍数的指数：1 同倍率、0.5 为主图放大 4 倍时小图放大 2 倍、0 不随主图变化">
+							跟随指数
+							<input v-model.number="minimapFollowZoomScale" type="number" min="0" max="2" step="0.1" :disabled="!minimapEnabled || minimapZoomMode !== 'follow'" />
+						</label>
+						<select v-model.number="minimapZoomStep" :disabled="!minimapEnabled || minimapZoomMode !== 'manual'" title="每一次放大 / 缩小的倍率（滚轮一格与 － / ＋ 按钮；只用于手动缩放）">
 							<option :value="1.2">步进 1.2</option>
 							<option :value="1.4">步进 1.4</option>
 							<option :value="1.8">步进 1.8</option>
 							<option :value="2">步进 2</option>
 						</select>
-						<button type="button" :disabled="!minimapEnabled || !minimapZoomable" @click="zoomMinimap(1 / minimapZoomStep)">－</button>
-						<button type="button" :disabled="!minimapEnabled || !minimapZoomable" @click="zoomMinimap(minimapZoomStep)">＋</button>
+						<button type="button" :disabled="!minimapEnabled || minimapZoomMode !== 'manual'" @click="zoomMinimap(1 / minimapZoomStep)">－</button>
+						<button type="button" :disabled="!minimapEnabled || minimapZoomMode !== 'manual'" @click="zoomMinimap(minimapZoomStep)">＋</button>
 					</div>
 					<div class="demo-minimap-toolbar demo-minimap-toolbar--rules">
 						<select v-model="minimapRuleMode" :disabled="!minimapEnabled" title="小图的规则：沿用主图（只取颜色与层级）/ 按电压单独配一份（半径、形状、层级都在内）/ 完全不用规则">
@@ -163,7 +172,7 @@ const {
 							放大线路
 							<input v-model.number="minimapLineZoom" type="number" min="0" max="1" step="0.1" :disabled="!minimapEnabled" />
 						</label>
-						<span class="demo-control-hint">「放大节点 / 放大线路」跟的是<strong>小图自身</strong>的倍数：要勾上「可缩放」再滚轮 / ＋－ 放大鹰眼图才看得到效果（改这两个值时这里会自动打开）；要让节点 / 线路跟着<strong>主视图</strong>的缩放走，用下面的「节点跟主图 / 线路跟主图」（pointMapZoomScale）。</span>
+						<span class="demo-control-hint">「放大节点 / 放大线路」跟的是<strong>小图自身</strong>的倍数：要勾上「可缩放」再滚轮 / ＋－ 放大鹰眼图才看得到效果（改这两个值时这里会自动打开）。沿用主图规则时，节点 / 线路先按两边视口比例缩放，<strong>主视图缩放不会改变它们的大小</strong>；下面的「节点跟主图 / 线路跟主图」只作用于小图自有规则 / 样式。</span>
 						<label class="demo-minimap-switch" title="节点半径的整体倍数：与主视图的 pointSizeScale 同名同义（常数倍数，与小图倍数无关）">
 							整体节点
 							<input v-model.number="minimapPointSize" type="number" min="0" max="4" step="0.2" :disabled="!minimapEnabled" />
@@ -172,13 +181,13 @@ const {
 							整体线路
 							<input v-model.number="minimapLineWidth" type="number" min="0" max="4" step="0.2" :disabled="!minimapEnabled" />
 						</label>
-						<label class="demo-minimap-switch" title="节点半径跟着主视图的地图倍数放大：0 不跟随、1 同倍率、0.5 是主图放大 4 倍节点放大 2 倍（基准缺省取主图适应视图时的比例）">
+						<label class="demo-minimap-switch" title="小图自有规则 / 样式的节点半径跟着主视图的地图倍数放大：0 不跟随、1 同倍率；沿用主图规则的节点不吃这一份">
 							节点跟主图
-							<input v-model.number="minimapPointMapZoom" type="number" min="0" max="1" step="0.1" :disabled="!minimapEnabled" />
+							<input v-model.number="minimapPointMapZoom" type="number" min="0" max="1" step="0.1" :disabled="!minimapEnabled || minimapRuleMode === 'inherit'" />
 						</label>
-						<label class="demo-minimap-switch" title="线路宽度跟着主视图的地图倍数放大：0 不跟随、1 同倍率">
+						<label class="demo-minimap-switch" title="小图自有规则 / 样式的线路宽度跟着主视图的地图倍数放大：0 不跟随、1 同倍率；沿用主图线宽不吃这一份">
 							线路跟主图
-							<input v-model.number="minimapLineMapZoom" type="number" min="0" max="1" step="0.1" :disabled="!minimapEnabled" />
+							<input v-model.number="minimapLineMapZoom" type="number" min="0" max="1" step="0.1" :disabled="!minimapEnabled || minimapRuleMode === 'inherit'" />
 						</label>
 					</div>
 					<div class="demo-minimap-toolbar demo-minimap-toolbar--box">
@@ -212,7 +221,7 @@ const {
 							自定义层
 						</label>
 					</div>
-					<span class="demo-minimap-hint">内置鹰眼图 · 拖框移视图 · 空白处长按后跟随（没开「可缩放」时）· 开了「可缩放」：滚轮按步进放大缩小（Ctrl / ⌘ + 滚轮留给主图）、空白处拖动按上面的选择平移小图或直接框选、关掉「回线」一个通道只画一根 · 范围三档：自动（数据 ∪ 底图，GeoJSON 底图不会缩成一点）/ 只看数据 / 只看底图 · 规则：沿用主图（节点取主图的描边色，不再是白点）/ 按电压单独配（半径与形状也换）/ 不用，分层叠画可以关，层级可以只看某几层 · 尺寸三组系数与主视图对应：整体节点 / 整体线路是常数倍数，放大节点 / 放大线路跟着小图自身的倍数，节点跟主图 / 线路跟主图跟着主视图的地图倍数 · 视口框与框选矩形的底色、不透明度、边框（颜色 / 宽度 / 线型）与圆角都能调 · 「自定义层」是 draw 钩子的示例：每帧按小图坐标画指北针与范围中心十字</span>
+					<span class="demo-minimap-hint">内置鹰眼图 · 拖框移视图 · 缩放模式：关闭 / 手动缩放小图 / 跟随主图，手动与跟随互斥 · 手动模式滚轮按步进缩放小图（Ctrl / ⌘ + 滚轮留给主图），跟随模式按指数随主图倍数整体变化；「拖动＝框选」不依赖缩放开关 · 空白处长按后跟随只在未手动缩放时走 · 范围三档：自动（数据 ∪ 底图）/ 只看数据 / 只看底图，「范围跟相机」默认关 · 规则：沿用主图 / 按电压单独配 / 不用；分层、层级、三组尺寸系数都能调 · 视口框与框选矩形的底色、不透明度、边框与圆角都能调 · 「自定义层」是 draw 钩子的示例</span>
 					</details>
 				</div>
 			</div>

package/docs/demos/gis-view-demo/panels/OpsPanels.vue

@@ -109,7 +109,7 @@ const {
 								<button type="button" @click="probeApi('listPoints')">listPoints({ limit: 5 })</button>
 								<button type="button" @click="probeApi('listLines')">listLines({ inView: true })</button>
 								<button type="button" @click="probeApi('bounds')">getElementBounds(选中)</button>
-								<button type="button" @click="probeApi('locate')">focusOn(选中, { maxZoom: 8 })</button>
+								<button type="button" @click="probeApi('locate')">focusOn(选中, { zoom: true, maxZoom: 8 })</button>
 								<button type="button" @click="probeApi('contextAt')">getContextAt(光标处)</button>
 								<button type="button" @click="probeApi('viewState')">getViewState()</button>
 							</div>
@@ -118,7 +118,7 @@ const {
 								<pre v-if="apiReadout" class="demo-groups">{{ apiReadout }}</pre>
 							</div>
 							<div class="demo-controls">
-								<span class="demo-control-hint">整份实例 API（{{ API_SUMMARY.members }} 个成员：{{ API_SUMMARY.methods }} 个方法 + {{ API_SUMMARY.properties }} 个属性；另有 {{ API_SUMMARY.options }} 个 options 键）按文档的 12 个分组列全 —— 清单由 <code>node docs/steps/gen-api-index.mjs</code> 从 <code>src/gis-view/create.js</code> 与 <code>docs/GisView.md</code> 的两张表生成，<code>check-doc-coverage.mjs</code> 会对账，因此搜索框里的每一条都能在文档里查到逐个方法的参数与返回。搜不到想要的名字，多半是它还没写进文档。</span>
+								<span class="demo-control-hint">整份实例 API（{{ API_SUMMARY.members }} 个成员：{{ API_SUMMARY.methods }} 个方法 + {{ API_SUMMARY.properties }} 个属性；另有 {{ API_SUMMARY.options }} 个 options 键）按文档的 {{ API_SUMMARY.sections }} 个分组列全 —— 清单由 <code>node docs/steps/gen-api-index.mjs</code> 从 <code>src/gis-view/create.js</code> 与 <code>docs/GisView.md</code> 的两张表生成，<code>check-doc-coverage.mjs</code> 会对账，因此搜索框里的每一条都能在文档里查到逐个方法的参数与返回。搜不到想要的名字，多半是它还没写进文档。</span>
 							</div>
 							<div class="demo-controls demo-api-search">
 								<input v-model="apiQuery" type="search" placeholder="搜成员名 / 参数 / 返回 / 说明（例如 focusOn、通道、Promise、历史）" />