@allbluecn/web-app 0.19.2 → 0.19.4

package/src/design-engine/engine/__tests__/app-commands.test.ts

@@ -1179,3 +1179,159 @@ describe("reparentOnDrop group 落点（FS-4.3）", () => {
     expect(liveLeaf("g_1")?.parent?.id).toBe(BOARD_NODE_ID)
   })
 })
+
+// ===== 审计修复回归：拖拽 history 极性（变更前快照一次，undo 一步到位）=====
+
+/** 为 history 极性测试注入 Line/Rect/Ellipse mock（路径装饰与圆角拖拽点消费；
+ *  共享 makeMod 只有 Text.one，按测试局部扩展避免影响其他用例） */
+function installShapeMocks(): {
+  knobs: Array<{ subs: Map<string, Array<(e?: unknown) => void>> }>
+} {
+  const knobs: Array<{ subs: Map<string, Array<(e?: unknown) => void>> }> = []
+  const shapeOne = () => (config: Record<string, unknown> = {}) => ({ ...config, remove: vi.fn() })
+  ;(mod as unknown as Record<string, unknown>).Line = { one: vi.fn(shapeOne()) }
+  ;(mod as unknown as Record<string, unknown>).Rect = { one: vi.fn(shapeOne()) }
+  ;(mod as unknown as Record<string, unknown>).Ellipse = {
+    one: vi.fn((config: Record<string, unknown> = {}) => {
+      const subs = new Map<string, Array<(e?: unknown) => void>>()
+      const knob = { ...config, remove: vi.fn() }
+      ;(knob as unknown as { on: (t: string, cb: (e?: unknown) => void) => void }).on = (
+        t: string,
+        cb: (e?: unknown) => void,
+      ) => {
+        const list = subs.get(t) ?? []
+        list.push(cb)
+        subs.set(t, list)
+      }
+      knobs.push({ subs })
+      return knob
+    }),
+  }
+  // toSky 投影：sky.getWorldPointByClient 恒等（client == sky 内部坐标）
+  const sky = mod.apps[0].sky as unknown as {
+    getWorldPointByClient?: (p: { clientX: number; clientY: number }, update?: boolean) => { x: number; y: number }
+  }
+  sky.getWorldPointByClient = (p: { clientX: number; clientY: number }) => ({ x: p.clientX, y: p.clientY })
+  return { knobs }
+}
+
+function pathNode(): SceneNode {
+  return {
+    id: "p_1",
+    kind: "shape",
+    type: "path",
+    parentId: BOARD_NODE_ID,
+    name: "Path",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    props: { path: "M 0 0 L 100 0 L 50 100 Z" },
+  }
+}
+
+describe("路径锚点拖拽 history 极性", () => {
+  it("锚点拖拽只落一条变更前快照：undo 一步恢复原始 path（修复前首 Undo 为 no-op）", () => {
+    const host = {
+      getBoundingClientRect: () => ({ x: 0, y: 0 }),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    } as unknown as HTMLElement
+    const engine = new LeaferEngine(mod as never)
+    engine.mount(host)
+    installShapeMocks()
+    engine.loadDoc(docWith(pathNode()))
+    const state = trackDoc(engine)
+    expect(engine.enterPathEdit("p_1")).toBe(true)
+
+    const listeners = new Map<string, (e?: unknown) => void>()
+    for (const call of vi.mocked(host.addEventListener).mock.calls) {
+      listeners.set(call[0] as string, call[1] as (e?: unknown) => void)
+    }
+    const pointerDown = listeners.get("pointerdown")!
+    const pointerMove = listeners.get("pointermove")!
+    const pointerUp = listeners.get("pointerup")!
+
+    // 命中锚点 0 (0,0) 并拖到 (50, -10)
+    pointerDown({ button: 0, clientX: 0, clientY: 0, pointerId: 1, stopPropagation: () => {} })
+    pointerMove({ clientX: 50, clientY: -10 })
+    pointerUp()
+
+    expect(String(state.latest!.nodes.find((n) => n.id === "p_1")?.props?.path)).toContain("M 50 -10")
+    expect(engine.history.canUndo).toBe(true)
+    // 单次 undo 直接回拖拽前（栈顶不是「变更后」快照）
+    engine.undo()
+    expect(String(state.latest!.nodes.find((n) => n.id === "p_1")?.props?.path)).toContain("M 0 0 L 100 0")
+    expect(engine.history.canUndo).toBe(false)
+  })
+
+  it("面板插锚（addPathAnchorAfterSelected）落一条变更前快照：undo 一步恢复", () => {
+    const host = { getBoundingClientRect: () => ({ x: 0, y: 0 }) } as unknown as HTMLElement
+    const engine = new LeaferEngine(mod as never)
+    engine.mount(host)
+    installShapeMocks()
+    engine.loadDoc(docWith(pathNode()))
+    const state = trackDoc(engine)
+    expect(engine.enterPathEdit("p_1")).toBe(true)
+    const beforePath = String(state.latest!.nodes.find((n) => n.id === "p_1")?.props?.path)
+    const beforeCount = engine.getPathEditInfo()!.count
+
+    expect(engine.addPathAnchorAfterSelected()).toBe(true)
+    expect(engine.getPathEditInfo()!.count).toBe(beforeCount + 1)
+    expect(engine.history.canUndo).toBe(true)
+
+    engine.undo()
+    expect(String(state.latest!.nodes.find((n) => n.id === "p_1")?.props?.path)).toBe(beforePath)
+    expect(engine.history.canUndo).toBe(false)
+  })
+
+  it("纯点击锚点（未拖动）不落 history", () => {
+    const host = {
+      getBoundingClientRect: () => ({ x: 0, y: 0 }),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    } as unknown as HTMLElement
+    const engine = new LeaferEngine(mod as never)
+    engine.mount(host)
+    installShapeMocks()
+    engine.loadDoc(docWith(pathNode()))
+
+    expect(engine.enterPathEdit("p_1")).toBe(true)
+    const listeners = new Map<string, (e?: unknown) => void>()
+    for (const call of vi.mocked(host.addEventListener).mock.calls) {
+      listeners.set(call[0] as string, call[1] as (e?: unknown) => void)
+    }
+    listeners.get("pointerdown")!({ button: 0, clientX: 0, clientY: 0, pointerId: 1, stopPropagation: () => {} })
+    listeners.get("pointerup")!()
+
+    expect(engine.history.canUndo).toBe(false)
+  })
+})
+
+describe("圆角拖拽 history 极性", () => {
+  it("dragend 不再推「变更后」快照：undo 一步恢复原圆角（修复前不可撤销）", () => {
+    const engine = new LeaferEngine(mod as never)
+    engine.mount(el)
+    const { knobs } = installShapeMocks()
+    engine.loadDoc(
+      docWith(rectNode({ id: "n_1", x: 0, y: 0, width: 100, height: 50, corners: [10, 10, 10, 10] })),
+    )
+    const state = trackDoc(engine)
+    engine.select(["n_1"])
+
+    expect(knobs).toHaveLength(1)
+    const drag = knobs[0]!.subs.get("drag")!
+    const dragend = knobs[0]!.subs.get("dragend")!
+
+    // totalX=10（scale=1）→ 圆角 10 + 10 = 20
+    drag.forEach((cb) => cb({ totalX: 10, totalY: 0 }))
+    expect(state.latest!.nodes.find((n) => n.id === "n_1")?.corners).toEqual([20, 20, 20, 20])
+    expect(engine.history.canUndo).toBe(true)
+
+    dragend.forEach((cb) => cb())
+    // 单次 undo 直接回拖拽前圆角（栈顶不是「变更后」快照）
+    engine.undo()
+    expect(state.latest!.nodes.find((n) => n.id === "n_1")?.corners).toEqual([10, 10, 10, 10])
+    expect(engine.history.canUndo).toBe(false)
+  })
+})

package/src/design-engine/engine/__tests__/path-anchors.test.ts

@@ -9,6 +9,7 @@ import { describe, expect, it } from "vitest"
 import {
   applyPointType,
   deleteAnchor,
+  flattenPathString,
   hitTestPathEdit,
   insertAnchorOnSegment,
   leaferCommandsToAnchors,
@@ -102,6 +103,29 @@ describe("insertAnchorOnSegment", () => {
     expect(recheck[1].x).toBeCloseTo(15.625, 1)
     expect(recheck[1].y).toBeCloseTo(56.25, 1)
   })
+
+  it("闭合曲线末段（wraparound）插锚：覆写首锚点 hIn，锚点数 +1 而非越界追加重复锚点", () => {
+    const path = "M 0 0 L 100 0 L 100 100 C 150 100 0 150 0 0 Z"
+    const { anchors, closed } = parsePathAnchors(path)
+    expect(closed).toBe(true)
+    expect(anchors).toHaveLength(3)
+    const next = insertAnchorOnSegment(anchors, 2, true)
+    // 修复前 next[count] 越界追加：首锚点出现两份，总数 +2 = 5
+    expect(next).toHaveLength(4)
+    // 首锚点（index 0）的 hIn 被 de Casteljau 更新为后半段控制点 mid3=(0,75)，
+    // 不再是陈旧值 (0,150)
+    expect(next![0].hIn).toEqual({ x: 0, y: 75 })
+    // 新锚点按 wraparound 语义插在数组末尾（段序 a2 → inserted → a0）
+    expect(next![3].hIn).toBeDefined()
+    expect(next![3].hOut).toBeDefined()
+    expect(next![3].x).toBeCloseTo(68.75, 1)
+    expect(next![3].y).toBeCloseTo(106.25, 1)
+    // round trip：无退化零长闭合段，锚点数守恒
+    const out = serializePathAnchors(next!, true)
+    const reparsed = parsePathAnchors(out)
+    expect(reparsed.closed).toBe(true)
+    expect(reparsed.anchors).toHaveLength(4)
+  })
 })
 
 describe("deleteAnchor", () => {
@@ -205,6 +229,25 @@ describe("路径编辑命中检测（client 坐标）", () => {
   })
 })
 
+describe("解析容错（NaN 判废）", () => {
+  it("命令参数错位（token 序列缺参数）整段判废返回空", () => {
+    // "M 10 L 20 20"：L 落在数字位 → Number("L") = NaN，修复前 NaN 坐标
+    // 直接流入布尔环与锚点模型
+    expect(flattenPathString("M 10 L 20 20")).toEqual([])
+    expect(parsePathAnchors("M 10 L 20 20")).toEqual({ anchors: [], closed: false })
+    // 缺参（命令在末尾无参数）同样判废
+    expect(flattenPathString("M 0 0 L")).toEqual([])
+  })
+
+  it("不支持的相对命令（小写 m/l/c/q）整段判废，合法路径不受影响", () => {
+    expect(flattenPathString("m 10 10 l 5 5")).toEqual([])
+    expect(parsePathAnchors("m 10 10 c 1 1 2 2 3 3")).toEqual({ anchors: [], closed: false })
+    // 合法路径正常解析（z 小写闭合仍支持）
+    expect(parsePathAnchors("M 0 0 L 10 0 z").anchors).toHaveLength(2)
+    expect(flattenPathString("M 0 0 L 10 0").length).toBeGreaterThan(0)
+  })
+})
+
 describe("leaferCommandsToAnchors / pathValueToAnchors", () => {
   it("命令数组：C 控制点 → 双侧手柄，11 闭合，收尾重复点合并", () => {
     // M 0 0 → C 50 0 100 50 100 100 → Z

package/src/design-engine/engine/app.ts

@@ -141,6 +141,7 @@ export class LeaferEngine extends ActionsEngine {
     this.appliedDoc = null
     this.docListeners.clear()
     this.selectionListeners.clear()
+    this.dragListeners.clear()
     this.toolListeners.clear()
   }
 

package/src/design-engine/engine/boolean-ops.ts

@@ -1,5 +1,9 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+import polygonClipping, { type Geom } from "polygon-clipping"
+
+import { flattenPathString, pathValueToRing, type PathEditAnchor, type Ring } from "./path-anchors"
+
 /**
  * 图形布尔运算（联集/减去/交集/排除）几何层。
  *
@@ -123,16 +127,27 @@ export function shapeOutlineOf(node: {
 }): Ring | null {
   const { width, height } = node
   // polygon/star 支持自定义点集（不规则图形真实轮廓；leafer points 为扁平
-  // [x,y,...] 或 IPointData[]，节点局部坐标）——否则按正多边形/星形采样
+  // [x,y,...] 或 IPointData[]，节点局部坐标）——否则按正多边形/星形采样。
+  // points 来自节点数据（AI record / DB 存档，不可信）：null 项直接解引用
+  // 会抛 TypeError 且非数值转 NaN 流入 polygon-clipping，逐项校验、非法跳过
   const customPoints = (): Ring | null => {
     const raw = node.props?.points
     if (!Array.isArray(raw) || raw.length < 6) return null
     const ring: Ring = []
     if (typeof raw[0] === "number") {
-      for (let i = 0; i + 1 < raw.length; i += 2) ring.push({ x: Number(raw[i]), y: Number(raw[i + 1]) })
+      for (let i = 0; i + 1 < raw.length; i += 2) {
+        const x = Number(raw[i])
+        const y = Number(raw[i + 1])
+        if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+        ring.push({ x, y })
+      }
     } else {
-      for (const point of raw as Array<{ x: number; y: number }>) {
-        ring.push({ x: Number(point.x), y: Number(point.y) })
+      for (const point of raw) {
+        if (!point || typeof point !== "object") continue
+        const x = Number((point as { x?: unknown }).x)
+        const y = Number((point as { y?: unknown }).y)
+        if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+        ring.push({ x, y })
       }
     }
     return ring.length >= 3 ? ring : null
@@ -253,9 +268,6 @@ export function booleanRingOf(node: {
   return ring.map((point) => ({ x: point.x + x, y: point.y + y }))
 }
 
-import polygonClipping, { type Geom } from "polygon-clipping"
-import { flattenPathString, pathValueToRing, type PathEditAnchor, type Ring } from "./path-anchors"
-
 /**
  * 执行布尔运算。输入每个图形一组环（世界坐标；带孔洞图形传多环），
  * zOrder 即数组顺序（index 0 最底层）。subtract 语义 = 最底层减去其上全部。
@@ -293,10 +305,14 @@ export function booleanToMultiPolygon(
   return result.map((polygon) => polygon.map(toRing))
 }
 
-/** MultiPolygon（世界坐标）→ 包围盒原点 + 相对该原点的 path 串（M/L/Z 子路径） */
+/** MultiPolygon（世界坐标）→ 包围盒原点 + 相对该原点的 path 串（M/L/Z 子路径）。
+ *  空输入早退返回零值（导出面，调用方可能无守卫直调） */
 export function multiPolygonToPath(
   polygons: Ring[][],
 ): { path: string; x: number; y: number; width: number; height: number } {
+  if (!polygons.length) {
+    return { path: "", x: 0, y: 0, width: 0, height: 0 }
+  }
   let minX = Infinity
   let minY = Infinity
   let maxX = -Infinity
@@ -311,6 +327,10 @@ export function multiPolygonToPath(
       }
     }
   }
+  // 空环集合（polygons 非空但全为空环）同样早退，避免 Infinity/NaN 外泄
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
+    return { path: "", x: 0, y: 0, width: 0, height: 0 }
+  }
   const parts: string[] = []
   for (const polygon of polygons) {
     for (const ring of polygon) {

package/src/design-engine/engine/engine-actions.ts

@@ -90,7 +90,17 @@ export class ActionsEngine extends PathEditEngine {
       on: (type: string, listener: (e?: unknown) => void) => void
     }
     if (typeof draggable.on !== "function") return
+    // 预览通道（不入 history）：首个 drag 回调先落「变更前」快照（全仓命令
+    // 统一极性），dragend 只通知不落栈——变更后快照入栈会占据栈顶让首次
+    // undo 消费在同状态快照上（no-op），圆角编辑表现为不可撤销。app 级
+    // DragEvent.START 若已覆盖本拖拽（preDragDoc 非空）则交由其 dragEnd
+    // 落栈，避免同一编辑双快照
+    let cornerDragCheckpointed = false
     draggable.on("drag", (e?: unknown) => {
+      if (!cornerDragCheckpointed) {
+        cornerDragCheckpointed = true
+        if (this.preDragDoc === null) this.history.push(this.currentDoc)
+      }
       const total = (e ?? {}) as { totalX?: number; totalY?: number }
       // 拖拽点相对角点的距离 = 圆角半径（client 位移按视口 scale 还原为 world）
       const nowPos = toSky(handleWorld)
@@ -100,8 +110,8 @@ export class ActionsEngine extends PathEditEngine {
       const dist = Math.hypot(total.totalX ?? 0, total.totalY ?? 0) / scale
       const base = node.corners ? node.corners[1] : 0
       const next = Math.max(0, Math.min(base + dist, Math.min(width, height) / 2))
-      // 预览通道（不入 history）：dragend 统一落一条。不重建装饰（重建会
-      // 中断 leafer drag 事件流），手动跟随 knob 位置
+      // 预览通道（不入 history）。不重建装饰（重建会中断 leafer drag 事件流），
+      // 手动跟随 knob 位置
       this.updateNodeGeometry(node.id, { corners: [next, next, next, next] })
       const newPos = toSky({ x: cornerWorld.x - next * k, y: cornerWorld.y + next * k })
       if (newPos) {
@@ -111,7 +121,7 @@ export class ActionsEngine extends PathEditEngine {
       }
     })
     draggable.on("dragend", () => {
-      this.history.push(this.currentDoc)
+      // checkpoint 已在首个 drag 回调落栈（变更前快照），此处只通知
       this.notifyDocChange()
     })
   }

package/src/design-engine/engine/engine-decor.ts

@@ -175,27 +175,29 @@ export class DecorEngine extends LeaferEngineBase {
   private pickMeasureSource(world: { x: number; y: number }): string | null {
     let bestId: string | null = null
     let bestDepth = -1
+    // 深度解析（含 memo）：节点自身深度 = 父深度 + 1（board/null 下第一层为 0）。
+    // 旧实现把父链深度原样赋给节点自身（缺 +1），同链各层深度相同，「最深命中」
+    // 退化为数组序后者胜；且 group 等被 continue 跳过的中间容器不入缓存，
+    // 父链回溯各自重算。此处按 id 递归解析（AI 输出可子先于父，不依赖遍历序）
     const depthOf = new Map<string, number>()
+    const depthOfId = (id: string | null, chain: Set<string>): number => {
+      if (!id || id === BOARD_NODE_ID) return -1
+      const cached = depthOf.get(id)
+      if (cached !== undefined) return cached
+      // 环形 parentId 脏数据防御：按顶层处理
+      if (chain.has(id)) return -1
+      chain.add(id)
+      const parent = this.currentDoc.nodes.find((n) => n.id === id)?.parentId ?? null
+      const depth = depthOfId(parent, chain) + 1
+      chain.delete(id)
+      depthOf.set(id, depth)
+      return depth
+    }
     for (const node of this.currentDoc.nodes) {
       if (node.id === BOARD_NODE_ID || node.kind === "group" || node.locked === true || node.visible === false) continue
       const leaf = this.nodeIndex.get(node.id)
       if (!leaf) continue
-      let depth: number
-      if (node.parentId) {
-        depth = depthOf.get(node.parentId) ?? (() => {
-          let d = 0
-          let cursor: string | null = node.parentId ?? null
-          while (cursor && cursor !== BOARD_NODE_ID) {
-            d += 1
-            cursor = this.currentDoc.nodes.find((n) => n.id === cursor)?.parentId ?? null
-          }
-          depthOf.set(node.parentId, d)
-          return d
-        })()
-      } else {
-        depth = 0
-      }
-      depthOf.set(node.id, depth)
+      const depth = depthOfId(node.parentId ?? null, new Set())
       const b = measureLeafBounds(leaf)
       if (!b) continue
       if (world.x < b.x || world.x > b.x + b.width || world.y < b.y || world.y > b.y + b.height) continue
@@ -664,24 +666,43 @@ export class DecorEngine extends LeaferEngineBase {
     if (changed) this.syncDocFromTree()
   }
 
-  /** 组 leaf 尺寸 = 孩子组空间坐标 union（组原点到最远边缘，与 groupNodes 建组口径一致） */
+  /** 组 leaf 尺寸 = 孩子组空间坐标 union（组原点到最远边缘，与 groupNodes 建组口径一致）。
+   *  子元素含负偏移（翻转/拖出原点）时以包围盒左上为新区原点归一：组 x/y 平移、
+   *  孩子反向平移，世界位置守恒——否则负坐标被裁为 0，组尺寸收缩错位 */
   private resizeGroupLeafToChildren(groupLeaf: ILeaf): void {
     const children = (groupLeaf as { children?: ILeaf[] }).children
     if (!children?.length) return
-    let maxX = 0
-    let maxY = 0
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
     for (const child of children) {
       const x = (child as { x?: number }).x ?? 0
       const y = (child as { y?: number }).y ?? 0
       const w = (child as { width?: number }).width ?? 0
       const h = (child as { height?: number }).height ?? 0
       if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+      minX = Math.min(minX, x)
+      minY = Math.min(minY, y)
       maxX = Math.max(maxX, x + w)
       maxY = Math.max(maxY, y + h)
     }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY)) return
+    const ox = Math.min(0, minX)
+    const oy = Math.min(0, minY)
+    if (ox < 0 || oy < 0) {
+      const movable = groupLeaf as unknown as { x?: number; y?: number }
+      if (movable.x !== undefined) movable.x += ox
+      if (movable.y !== undefined) movable.y += oy
+      for (const child of children) {
+        const c = child as { x?: number; y?: number }
+        if (c.x !== undefined) c.x -= ox
+        if (c.y !== undefined) c.y -= oy
+      }
+    }
     ;(groupLeaf as unknown as { set: (config: Record<string, unknown>) => void }).set({
-      width: maxX,
-      height: maxY,
+      width: maxX - ox,
+      height: maxY - oy,
     })
   }
 

package/src/design-engine/engine/engine-doc.ts

@@ -577,9 +577,14 @@ export class DocEngine extends DecorEngine {
 
   // nodeIndex 查找（构建时免费填充，O(1)）优先，miss 时回落官方 find 插件
   // findOne('#id')（Finder.getById，app.idMap 缓存）——dropTo 换父、外部改 id
-  // 导致缓存与真实树脱节时语义仍正确
+  // 导致缓存与真实树脱节时语义仍正确。选择器兜底前校验 id 字符集：节点 id
+  // 接受任意字符串（AI schema / DB 存档），含空格、引号等选择器特殊字符时
+  // findOne(`#id`) 解析失败或误配，直接视为未找到
   private findLeaf(id: string): ILeaf | undefined {
-    return this.nodeIndex.get(id) ?? this.app?.tree.findOne(`#${id}`)
+    const cached = this.nodeIndex.get(id)
+    if (cached) return cached
+    if (!/^[\w:-]+$/.test(id)) return undefined
+    return this.app?.tree.findOne(`#${id}`)
   }
 
   // 官方 zoomLayer.scaleX 即缩放的官方承载（viewport 插件 scaleOfWorld 写入）
@@ -641,6 +646,7 @@ export class DocEngine extends DecorEngine {
   }
 
   // 增量应用：返回 false 表示 diff 应用失败（调用方应回退全量重建）
+  private incrementalFailureWarned = false
   private applySceneIncremental(doc: SceneDocument): boolean {
     const prev = this.appliedDoc
     const app = this.app
@@ -752,8 +758,15 @@ export class DocEngine extends DecorEngine {
       // 6) 标签增删改名/重投影：由 syncBoardLabels 统一驱动（插件内部 diff）
       this.syncBoardLabels()
       return true
-    } catch {
-      // 增量失败兜底：全量重建保证正确性（宁可重建不可错渲染）
+    } catch (error) {
+      // 增量失败兜底：全量重建保证正确性（宁可重建不可错渲染）。零日志会让
+      // 「增量长期失败 → 性能静默退化为全量重建」无从发现，warn 一次
+      if (!this.incrementalFailureWarned) {
+        this.incrementalFailureWarned = true
+        console.warn(
+          `[design-engine] applySceneIncremental failed, falling back to full rebuild: ${error instanceof Error ? error.message : "unknown"}`,
+        )
+      }
       return false
     }
   }
@@ -794,9 +807,12 @@ export class DocEngine extends DecorEngine {
       // 重挂（applyScene 时视口未定，插件按当前变换投影，后续 fit/CHANGE 再跟随）
       this.syncBoardLabels()
 
+      // 可见性/锁定状态投影：id → node 建 Map 避免 O(n²) 全量 find
+      // （大文档全量重建路径的热点）
+      const nodeById = new Map(doc.nodes.map((candidate) => [candidate.id, candidate]))
       for (const [id, leaf] of this.nodeIndex) {
         if (id === BOARD_NODE_ID) continue
-        const node = doc.nodes.find((candidate) => candidate.id === id)
+        const node = nodeById.get(id)
         if (!node) continue
         const target = leaf as { visible?: boolean; locked?: boolean; editable?: boolean }
         target.visible = node.visible ?? true