@pascal-app/editor 1.0.6 → 1.0.7

package/src/lib/room-push-dimensions.test.ts

@@ -11,8 +11,10 @@ import {
   DIMENSION_FLOOR_LIFT,
   mezzanineEdgeDimensions,
   type RoomDimension,
+  type WallDimensionFaces,
   wallPushDimensionRooms,
   wallPushDimensions,
+  wallSelectionDimensions,
 } from './room-push-dimensions'
 
 // Rooms are real: the walls go through core's room topology, so the faces the
@@ -66,6 +68,20 @@ function measure(
   })
 }
 
+function selection({ nodes, walls }: Scene, wall: WallNode, faces: WallDimensionFaces) {
+  const index = createRoomTopologyIndex()
+  index.rebuildLevel(LEVEL, nodes)
+  const rooms = index.getLevelTopology(LEVEL)?.rooms ?? []
+  return wallSelectionDimensions({
+    rooms: wallPushDimensionRooms(rooms, { wallId: wall.id, t0: 0, t1: 1 }, () => 0),
+    wall,
+    walls,
+    faces,
+    resolve: (id) => nodes[id],
+    baseElevation: 0,
+  })
+}
+
 const distances = (dimensions: RoomDimension[]) =>
   dimensions.map((dimension) => Number(dimension.distance.toFixed(4)))
 
@@ -206,6 +222,27 @@ describe('two rooms sharing the moving wall', () => {
     expect(west.key).not.toBe(east.key)
   })
 
+  test('selected, a shared wall shows both room widths and no outside size, whatever the faces', () => {
+    for (const faces of ['both', 'interior', 'exterior'] as const) {
+      const dimensions = selection(rooms, middle, faces)
+      expect(dimensions.map((dimension) => dimension.faces)).toEqual(['interior', 'interior'])
+      expect(distances(dimensions).sort()).toEqual([3.8, 3.8])
+    }
+  })
+
+  test('selected, an exterior wall adds the outside size across the building', () => {
+    const east = wallAt(rooms, [8, 0], [8, 4])
+    const dimensions = selection(rooms, east, 'both')
+    const outside = dimensions.find((dimension) => dimension.faces === 'exterior')!
+    // Outer face to outer face, past the middle wall, clear of the room width's line.
+    expect(outside.distance).toBeCloseTo(8 + THICKNESS)
+    expect(outside.from[0]).toBeCloseTo(8 + THICKNESS / 2)
+    expect(outside.to[0]).toBeCloseTo(-THICKNESS / 2)
+    expect(distances(dimensions.filter((dimension) => dimension.faces === 'interior'))).toEqual([
+      3.8,
+    ])
+  })
+
   test('a push over part of the wall measures only the rooms along that part', () => {
     const dimensions = measure(rooms, middle, [1, 0], 0, { t0: 0, t1: 0.5 })
     expect(dimensions).toHaveLength(2)

package/src/lib/room-push-dimensions.ts

@@ -4,6 +4,7 @@ import {
   getWallFaceOffsets,
   isCurvedWall,
   type Point,
+  type SeparatorNode,
   type WallNode,
 } from '@pascal-app/core'
 
@@ -153,12 +154,62 @@ export function wallPushDimensionRooms(
   )
 }
 
+/**
+ * The rooms along a pushed edge of invisible walls, as `wallPushDimensionRooms`
+ * reads them along a wall: each room's stretch of the edge's separators, put
+ * on the edge's one `line` (`[0, 1]` its length), faced as that line runs.
+ */
+export function separatorEdgeDimensionRooms(
+  rooms: ReadonlyArray<{ id: string; spans: readonly BoundarySpan[] }>,
+  edge: {
+    line: Pick<SeparatorNode, 'start' | 'end'>
+    separators: ReadonlyArray<{ separatorId: string; t0: number; t1: number }>
+  },
+  resolve: (id: string) => AnyNode | undefined,
+  elevationOf: (roomId: string) => number,
+): PushDimensionRoom[] {
+  const { start, end } = edge.line
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  const lengthSq = dx * dx + dz * dz
+  if (lengthSq < 1e-12) return []
+  const members = new Set(edge.separators.map((member) => member.separatorId))
+  const along = ([x, z]: Point) => ((x - start[0]) * dx + (z - start[1]) * dz) / lengthSq
+  return rooms.flatMap((room) =>
+    room.spans.flatMap((own): PushDimensionRoom[] => {
+      const member = edge.separators.find((entry) => entry.separatorId === own.boundaryId)
+      const separator = resolve(own.boundaryId)
+      if (!member || separator?.type !== 'separator') return []
+      const t0 = Math.max(member.t0, own.t0)
+      const t1 = Math.min(member.t1, own.t1)
+      if (t1 - t0 < 1e-4) return []
+      const sx = separator.end[0] - separator.start[0]
+      const sz = separator.end[1] - separator.start[1]
+      const point = (t: number): Point => [separator.start[0] + sx * t, separator.start[1] + sz * t]
+      const [u0, u1] = [along(point(t0)), along(point(t1))]
+      // A separator drawn against the edge's line has its faces the other way round.
+      const same = sx * dx + sz * dz > 0
+      return [
+        {
+          id: room.id,
+          face: same ? own.face : own.face === 'a' ? 'b' : 'a',
+          t0: Math.min(u0, u1),
+          t1: Math.max(u0, u1),
+          others: room.spans.filter((other) => !members.has(other.boundaryId)),
+          elevation: elevationOf(room.id),
+        },
+      ]
+    }),
+  )
+}
+
 /**
  * The live dimensions of a wall push: for every room along the pushed stretch,
  * the moving face (the resting face moved `distance` along `outward` — a push
  * is a pure translation) to each facing parallel boundary of that room, read
  * through `resolve` so the preview's geometry counts. Per side of the wall:
- * nearest first, one per distinct distance, at most three.
+ * nearest first, one per distinct distance, at most three. An edge of
+ * invisible walls is measured as its one line.
  */
 export function wallPushDimensions({
   rooms,
@@ -168,7 +219,7 @@ export function wallPushDimensions({
   resolve,
 }: {
   rooms: readonly PushDimensionRoom[]
-  wall: WallNode
+  wall: WallNode | SeparatorNode
   outward: Point
   distance: number
   resolve: (id: string) => AnyNode | undefined
@@ -195,6 +246,179 @@ export function wallPushDimensions({
   )
 }
 
+/** Whether two dimensions measure the same span, either way round. */
+export function sameRoomDimension(a: RoomDimension, b: RoomDimension): boolean {
+  const near = (p: Point, q: Point) => Math.hypot(p[0] - q[0], p[1] - q[1]) < 1e-3
+  return (near(a.from, b.from) && near(a.to, b.to)) || (near(a.from, b.to) && near(a.to, b.from))
+}
+
+/** A selected wall's temporary dimension: a room width (ID) or the outside size (OD). */
+export type WallSelectionDimension = RoomDimension & { faces: 'interior' | 'exterior' }
+
+/** A selection's temporary dimension with the node it runs from: typing it moves that node. */
+export type OwnedSelectionDimension = WallSelectionDimension & { ownerId: string }
+
+/**
+ * Several selected nodes' temporary dimensions as one list, keys unique across
+ * owners. Two selected walls across one room both measure it: the width shows
+ * once, owned by the first.
+ */
+export function mergeSelectionDimensions(
+  owners: ReadonlyArray<{ ownerId: string; dimensions: readonly WallSelectionDimension[] }>,
+): OwnedSelectionDimension[] {
+  const kept: OwnedSelectionDimension[] = []
+  for (const { ownerId, dimensions } of owners)
+    for (const dimension of dimensions)
+      if (!kept.some((other) => sameRoomDimension(other, dimension)))
+        kept.push({ ...dimension, key: `${ownerId}:${dimension.key}`, ownerId })
+  return kept
+}
+
+/** Which faces a selected wall's temporary dimensions measure to. */
+export type WallDimensionFaces = 'interior' | 'exterior' | 'both'
+
+const CONNECTION_TOLERANCE = 0.03
+/** Where along the shared stretch the outside size is drawn, clear of the room widths at its middle. */
+const EXTERIOR_DIMENSION_AT = 0.25
+
+function pointSegmentDistance(p: Point, a: Point, b: Point): number {
+  const dx = b[0] - a[0]
+  const dz = b[1] - a[1]
+  const lengthSq = dx * dx + dz * dz
+  const t =
+    lengthSq < 1e-12
+      ? 0
+      : Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / lengthSq))
+  return Math.hypot(p[0] - (a[0] + dx * t), p[1] - (a[1] + dz * t))
+}
+
+function wallsTouch(left: WallNode, right: WallNode): boolean {
+  return (
+    [left.start, left.end].some(
+      (p) => pointSegmentDistance(p, right.start, right.end) <= CONNECTION_TOLERANCE,
+    ) ||
+    [right.start, right.end].some(
+      (p) => pointSegmentDistance(p, left.start, left.end) <= CONNECTION_TOLERANCE,
+    )
+  )
+}
+
+/** The walls joined to `wall` through shared corners and T junctions, itself included. */
+function connectedWalls(wall: WallNode, walls: readonly WallNode[]): WallNode[] {
+  const found = new Map<string, WallNode>([[wall.id, wall]])
+  const queue = [wall]
+  for (let current = queue.pop(); current; current = queue.pop()) {
+    for (const candidate of walls) {
+      if (found.has(candidate.id) || !wallsTouch(current, candidate)) continue
+      found.set(candidate.id, candidate)
+      queue.push(candidate)
+    }
+  }
+  return [...found.values()]
+}
+
+/**
+ * The outside size across the building from a wall's exterior face: to the
+ * far face of the farthest parallel wall of the same connected building that
+ * shares some of its length — the opposite exterior wall. Null when nothing
+ * is across (a lone wall, a curved one).
+ */
+function overallExteriorDimension(
+  wall: WallNode,
+  exteriorFace: 'a' | 'b',
+  walls: readonly WallNode[],
+): Measured | null {
+  const own = boundaryFace(wall, 0, 1, exteriorFace)
+  if (!own) return null
+  const dx = own.end[0] - own.start[0]
+  const dz = own.end[1] - own.start[1]
+  const length = Math.hypot(dx, dz)
+  const dir: Point = [dx / length, dz / length]
+  // The face's room-ward normal points out of the building here: across is its opposite.
+  const across: Point = [-own.inward[0], -own.inward[1]]
+  const along = (p: Point) => (p[0] - own.start[0]) * dir[0] + (p[1] - own.start[1]) * dir[1]
+  let best: { distance: number; lo: number; hi: number } | null = null
+  for (const other of connectedWalls(wall, walls)) {
+    if (other.id === wall.id) continue
+    for (const face of ['a', 'b'] as const) {
+      const candidate = boundaryFace(other, 0, 1, face)
+      if (!candidate) continue
+      const fx = candidate.end[0] - candidate.start[0]
+      const fz = candidate.end[1] - candidate.start[1]
+      const faceLength = Math.hypot(fx, fz)
+      if (Math.abs(dir[0] * fz - dir[1] * fx) / faceLength > PARALLEL_SIN) continue
+      const distance =
+        (candidate.start[0] - own.start[0]) * across[0] +
+        (candidate.start[1] - own.start[1]) * across[1]
+      if (distance <= MIN_GAP) continue
+      const a = along(candidate.start)
+      const b = along(candidate.end)
+      const lo = Math.max(0, Math.min(a, b))
+      const hi = Math.min(length, Math.max(a, b))
+      if (hi - lo < MIN_OVERLAP) continue
+      if (!best || distance > best.distance + SAME_DISTANCE) best = { distance, lo, hi }
+    }
+  }
+  if (!best) return null
+  const at = (u: number): Point => [own.start[0] + dir[0] * u, own.start[1] + dir[1] * u]
+  const [lo, hi] = [at(best.lo), at(best.hi)]
+  // Measured from the same end of the stretch whichever way the wall was drawn,
+  // so the walls on either side of the building put their outside size in one place.
+  const fromLo = Math.abs(lo[0] - hi[0]) > 1e-6 ? lo[0] < hi[0] : lo[1] <= hi[1]
+  const offset = (best.hi - best.lo) * EXTERIOR_DIMENSION_AT
+  const from = at(fromLo ? best.lo + offset : best.hi - offset)
+  return {
+    from,
+    to: [from[0] + across[0] * best.distance, from[1] + across[1] * best.distance],
+    distance: best.distance,
+  }
+}
+
+/**
+ * The temporary dimensions of a selected wall at rest, in 2D and 3D: the room
+ * widths a push of it shows (its face to each facing wall, both sides — ID),
+ * and for an exterior wall the outside size across the building (OD). `faces`
+ * picks which; a wall with no outside (rooms on both faces) shows its room
+ * widths whatever the choice. Each dimension runs `from` the selected wall,
+ * so typing a value moves that wall (`commitDimensionValue`).
+ */
+export function wallSelectionDimensions({
+  rooms,
+  wall,
+  walls,
+  faces,
+  resolve,
+  baseElevation,
+}: {
+  rooms: readonly PushDimensionRoom[]
+  wall: WallNode
+  /** The level's walls, for the opposite exterior wall. */
+  walls: readonly WallNode[]
+  faces: WallDimensionFaces
+  resolve: (id: string) => AnyNode | undefined
+  /** The wall's base, for a dimension with no room floor to stand on. */
+  baseElevation: number
+}): WallSelectionDimension[] {
+  const interior = wallPushDimensions({ rooms, wall, outward: [0, 0], distance: 0, resolve }).map(
+    (dimension): WallSelectionDimension => ({ ...dimension, faces: 'interior' }),
+  )
+  const roomFaces = new Set(rooms.map((room) => room.face))
+  const exteriorFace = roomFaces.size === 1 ? (roomFaces.has('a') ? 'b' : 'a') : null
+  if (!exteriorFace || faces === 'interior') return interior
+  const overall = overallExteriorDimension(wall, exteriorFace, walls)
+  const exterior: WallSelectionDimension[] = overall
+    ? [
+        {
+          ...overall,
+          key: 'exterior',
+          faces: 'exterior',
+          elevation: (rooms[0]?.elevation ?? baseElevation) + DIMENSION_FLOOR_LIFT,
+        },
+      ]
+    : []
+  return faces === 'exterior' ? exterior : [...interior, ...exterior]
+}
+
 /**
  * The live dimensions of a mezzanine edge push: the resting edge moved
  * `distance` along `outward`, to each facing parallel edge of the outline the

package/src/lib/room-selection.test.ts

@@ -868,17 +868,34 @@ describe('room drill-down state through the mounted selection manager', () => {
       expect(useViewer.getState().selection.selectedIds).toEqual(['wall_free'])
     })
   })
-  test('the 2D plan resolves walls room-first and drills on the second click', async () => {
+  test('the 2D plan gives a wall hit to the wall and a room interior to the room', async () => {
     await withRooms(async ({ left, right }) => {
-      expect(resolvePlanRoomHit('wall_west', [-0.05, 2])).toEqual(left)
+      // Without the kind's `planHitSelectsNode`, a band hit stays room-first.
       expect(resolvePlanRoomHit('wall_shared', [3.95, 2])).toEqual(left)
-      expect(resolvePlanRoomHit('wall_shared', [4.05, 2])).toEqual(right)
-      expect(resolvePlanRoomHit('wall_free', [9.95, 1])).toBeNull()
-      const hit = resolvePlanRoomHit('wall_west', [-0.05, 2])
+      // The wall definition declares it (its floor-plan extension).
+      const get = nodeRegistry.get.bind(nodeRegistry)
+      const spy = spyOn(nodeRegistry, 'get').mockImplementation(((kind: string) =>
+        kind === 'wall'
+          ? ({
+              ...get(kind),
+              extensions: { 'pascal:editor/floorplan': { planHitSelectsNode: true } },
+            } as AnyNodeDefinition)
+          : get(kind)) as typeof nodeRegistry.get)
+      try {
+        // Either half of a shared wall's band is the wall, never the room beside it.
+        expect(resolvePlanRoomHit('wall_west', [-0.05, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_shared', [3.95, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_shared', [4.05, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_free', [9.95, 1])).toBeNull()
+      } finally {
+        spy.mockRestore()
+      }
+      expect(resolvePlanRoomHit(null, [2, 2])).toEqual(left)
+      expect(resolvePlanRoomHit(null, [6, 2])).toEqual(right)
       const select = async (modifiers = plain) => {
         let selected = false
         await act(async () => {
-          selected = selectRoomFromHit(hit, modifiers, 'wall_west')
+          selected = selectRoomFromHit(resolvePlanRoomHit(null, [2, 2]), modifiers, null)
         })
         return selected
       }

package/src/lib/scene-clipboard.test.ts

@@ -744,58 +744,79 @@ describe('scene clipboard', () => {
     }
   })
 
-  test("a room copied to another project brings its floor script's artifacts", async () => {
-    let systemClipboardText = ''
-    Object.defineProperty(navigator, 'clipboard', {
-      configurable: true,
-      value: {
-        readText: async () => systemClipboardText,
-        writeText: async (text: string) => {
-          systemClipboardText = text
+  const floorScript = {
+    kind: 'script',
+    script: 'e'.repeat(64),
+    artifact: 'f'.repeat(64),
+    inputs: 'key',
+    manifest: { bounds: { min: [0, 0, 0], max: [3, 0.01, 3] }, triangles: 2 },
+  } as const
+  const square: [number, number][] = [
+    [0, 0],
+    [3, 0],
+    [3, 3],
+    [0, 3],
+  ]
+  for (const [what, host] of [
+    [
+      "a room copied to another project brings its floor script's artifacts",
+      () =>
+        ZoneNode.parse({
+          id: 'zone_clipboard-floor-script',
+          parentId: sourceLevelId,
+          name: 'Hall',
+          polygon: square,
+          floor: { script: floorScript },
+        }),
+    ],
+    [
+      "a slab copied to another project brings its surface script's artifacts",
+      () =>
+        SlabNode.parse({
+          id: 'slab_clipboard-surface-script',
+          parentId: sourceLevelId,
+          name: 'Terrace',
+          polygon: square,
+          surfaceScript: floorScript,
+        }),
+    ],
+  ] as const) {
+    test(what, async () => {
+      let systemClipboardText = ''
+      Object.defineProperty(navigator, 'clipboard', {
+        configurable: true,
+        value: {
+          readText: async () => systemClipboardText,
+          writeText: async (text: string) => {
+            systemClipboardText = text
+          },
         },
-      },
-    })
-    const room = ZoneNode.parse({
-      id: 'zone_clipboard-floor-script',
-      parentId: sourceLevelId,
-      name: 'Hall',
-      polygon: [
-        [0, 0],
-        [3, 0],
-        [3, 3],
-        [0, 3],
-      ],
-      floor: {
-        script: {
-          kind: 'script',
-          script: 'e'.repeat(64),
-          artifact: 'f'.repeat(64),
-          inputs: 'key',
-          manifest: { bounds: { min: [0, 0, 0], max: [3, 0.01, 3] }, triangles: 2 },
+      })
+      const node = host()
+      useScene.setState((state) => ({
+        nodes: {
+          ...state.nodes,
+          [sourceLevelId]: makeLevel(sourceLevelId, [node.id]),
+          [node.id]: node,
         },
-      },
+      }))
+      useViewer.getState().setProjectId('project_clipboard-source')
+      expect(copySelectedNodesToEditorClipboard([node.id])).toBe(true)
+      useViewer.getState().setProjectId('project_clipboard-target')
+      const copyFrom = mock(async (_projectId: string, _sha256s: string[]) => [] as string[])
+      const previousStore = getArtifactStore()
+      configureArtifactStore({ ...previousStore, copyFrom })
+      try {
+        await pasteSystemEditorClipboardToLevel(targetLevelId)
+        expect(new Set(copyFrom.mock.calls[0]![1])).toEqual(
+          new Set(['e'.repeat(64), 'f'.repeat(64)]),
+        )
+      } finally {
+        configureArtifactStore(previousStore)
+        useViewer.getState().setProjectId(null)
+      }
     })
-    useScene.setState((state) => ({
-      nodes: {
-        ...state.nodes,
-        [sourceLevelId]: makeLevel(sourceLevelId, [room.id]),
-        [room.id]: room,
-      },
-    }))
-    useViewer.getState().setProjectId('project_clipboard-source')
-    expect(copySelectedNodesToEditorClipboard([room.id])).toBe(true)
-    useViewer.getState().setProjectId('project_clipboard-target')
-    const copyFrom = mock(async (_projectId: string, _sha256s: string[]) => [] as string[])
-    const previousStore = getArtifactStore()
-    configureArtifactStore({ ...previousStore, copyFrom })
-    try {
-      await pasteSystemEditorClipboardToLevel(targetLevelId)
-      expect(new Set(copyFrom.mock.calls[0]![1])).toEqual(new Set(['e'.repeat(64), 'f'.repeat(64)]))
-    } finally {
-      configureArtifactStore(previousStore)
-      useViewer.getState().setProjectId(null)
-    }
-  })
+  }
 
   test('navigation during artifact copy does not paste into the next project', async () => {
     copyScriptedWindow()

package/src/lib/scene-clipboard.ts

@@ -488,14 +488,19 @@ export async function pasteSystemEditorClipboardToLevel(
   return applyClipboardPayloadToLevel(payload, targetLevel.id, refused)
 }
 
-/** The script and GLB a scripted node, a room's floor script or a wall's face scripts reference. */
+/**
+ * The script and GLB a scripted node, a room's floor script, a slab's surface script or a wall's
+ * face scripts reference.
+ */
 function artifactHashes(node: AnyNode): string[] {
   const sources =
     node.type === 'zone'
       ? [node.floor?.script]
-      : node.type === 'wall'
-        ? [node.finishScripts?.a, node.finishScripts?.b]
-        : ['source' in node ? node.source : undefined]
+      : node.type === 'slab'
+        ? [node.surfaceScript]
+        : node.type === 'wall'
+          ? [node.finishScripts?.a, node.finishScripts?.b]
+          : ['source' in node ? node.source : undefined]
   return sources.flatMap((source) =>
     typeof source === 'object' && source?.kind === 'script' ? [source.script, source.artifact] : [],
   )

package/src/lib/selection-cycle.ts

@@ -0,0 +1,63 @@
+/**
+ * Tab steps the selection through everything stacked under the pointer in the
+ * floor plan, top first: where walls
+ * overlap, or a short wall lies inside a longer one or under a marker, a click
+ * takes the top one and Tab the ones below it in turn. Shift+Tab steps back.
+ */
+
+import type { AnyNodeId } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+
+let pointer: { x: number; y: number } | null = null
+let tracking = false
+
+/** Start following the pointer, so a Tab knows where it is. Idempotent. */
+export function trackSelectionCyclePointer(): void {
+  if (tracking || typeof window === 'undefined') return
+  tracking = true
+  const follow = (event: PointerEvent) => {
+    pointer = { x: event.clientX, y: event.clientY }
+  }
+  window.addEventListener('pointermove', follow, { capture: true, passive: true })
+  window.addEventListener('pointerdown', follow, { capture: true, passive: true })
+}
+
+/** The plan nodes under a screen point, topmost first, each once. */
+export function floorplanNodesAt(x: number, y: number): string[] {
+  if (typeof document === 'undefined') return []
+  const ids: string[] = []
+  for (const element of document.elementsFromPoint(x, y)) {
+    if (!element.closest('[data-floorplan-scene]')) continue
+    const entry = element.closest<SVGGElement>('.floorplan-registry-entry[data-node-id]')
+    const id = entry?.dataset.nodeId
+    if (id && !ids.includes(id)) ids.push(id)
+  }
+  return ids
+}
+
+/**
+ * The id a Tab selects among `stack` (topmost first): the one after the
+ * current selection, or before it for Shift+Tab, wrapping round; the top one
+ * when the selection is not in the stack.
+ */
+export function nextInStack(
+  stack: readonly string[],
+  selected: readonly string[],
+  back: boolean,
+): string | null {
+  if (stack.length === 0) return null
+  const index = selected.length === 1 ? stack.indexOf(selected[0]!) : -1
+  if (index < 0) return stack[0]!
+  return stack[(index + (back ? stack.length - 1 : 1)) % stack.length]!
+}
+
+/** Select the next object under the pointer in the floor plan. True when Tab was used. */
+export function cycleSelectionAtPointer(back: boolean): boolean {
+  if (!pointer) return false
+  const stack = floorplanNodesAt(pointer.x, pointer.y)
+  const viewer = useViewer.getState()
+  const next = nextInStack(stack, viewer.selection.selectedIds, back)
+  if (!next) return false
+  viewer.setSelection({ selectedIds: [next as AnyNodeId] })
+  return true
+}