@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/editor/footprint-height-handle.tsx

@@ -0,0 +1,204 @@
+'use client'
+
+import {
+  type AnyNodeId,
+  getStoredLevelHeight,
+  type Point,
+  type SlabNode,
+  sceneRegistry,
+  upperFloorHeightControl,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { Html } from '@react-three/drei'
+import { type ThreeEvent, useFrame, useThree } from '@react-three/fiber'
+import { useRef, useState } from 'react'
+import { type Group, Plane, Vector2, Vector3 } from 'three'
+import {
+  beginFootprintHeightPreview,
+  footprintHeightMinimum,
+  footprintHeightValue,
+  THICK_FLOOR_HINT,
+  thickFloorAdvice,
+} from '../../lib/floor-footprints'
+import { formatLinearMeasurement } from '../../lib/measurements'
+import { runRoomHandleDrag } from '../../lib/room-handle-drag'
+import useEditor, { isGridSnapActive } from '../../store/use-editor'
+import useInteractionScope from '../../store/use-interaction-scope'
+import { suppressBoxSelectForPointer } from '../tools/select/box-select-state'
+import { ElevationArrows, outlineCentroid, useHandleScale } from './room-handles'
+
+export const FOOTPRINT_HEIGHT_DRAG_LABEL = 'footprint-height'
+
+const PILL =
+  'pointer-events-none flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur'
+const NOTICE =
+  'pointer-events-none max-w-72 rounded-full border border-border/60 bg-background/95 px-3 py-1 text-center text-muted-foreground text-xs shadow-md backdrop-blur-md'
+
+/** The selected footprint floor (base plate), when it is the one selection in select mode. */
+function useSelectedFootprint(): SlabNode | null {
+  const selectedId = useViewer((s) =>
+    s.selection.selectedIds.length === 1 ? s.selection.selectedIds[0] : null,
+  )
+  const enabled = useEditor((s) => s.mode === 'select')
+  const idle = useInteractionScope(
+    (s) =>
+      s.scope.kind === 'idle' ||
+      (s.scope.kind === 'handle-drag' && s.scope.handle === FOOTPRINT_HEIGHT_DRAG_LABEL),
+  )
+  const plate = useScene((s) => {
+    const node = selectedId ? s.nodes[selectedId as AnyNodeId] : undefined
+    return node?.type === 'slab' && node.plateRole === 'base' ? node : null
+  })
+  return enabled && idle ? plate : null
+}
+
+/**
+ * A selected footprint floor's one control in 3D: the rooms' arrow–cube–arrow
+ * at the middle of the footprint, dragging its height above the ground. The
+ * building follows live; the release lands as one undo step. Refused heights
+ * (core's conflict, e.g. an upper floor over another footprint) show beside it.
+ */
+export function FootprintHeightHandle() {
+  const plate = useSelectedFootprint()
+  const root = useRef<Group>(null)
+  useFrame(() => {
+    const level = plate?.parentId ? sceneRegistry.nodes.get(plate.parentId) : null
+    if (!root.current) return
+    root.current.visible = !!level
+    if (level) {
+      level.updateWorldMatrix(true, false)
+      root.current.matrix.copy(level.matrixWorld)
+    }
+  })
+  if (!plate) return null
+  return (
+    <group matrixAutoUpdate={false} ref={root}>
+      <FootprintHeightArrows plate={plate} />
+    </group>
+  )
+}
+
+function FootprintHeightArrows({ plate }: { plate: SlabNode }) {
+  const { camera, raycaster, gl } = useThree()
+  const zoom = useHandleScale()
+  const unit = useViewer((s) => s.unit)
+  const metricNotation = useViewer((s) => s.metricNotation)
+  const [hover, setHover] = useState(false)
+  const [dragValue, setDragValue] = useState<number | null>(null)
+  const [notice, setNotice] = useState<string | null>(null)
+  const [hint, setHint] = useState<string | null>(null)
+  const upper = useScene((s) => upperFloorHeightControl(s.nodes, plate) !== null)
+  const anchor: Point = outlineCentroid([plate.polygon as Point[], ...(plate.holes as Point[][])])
+  const elevation = plate.elevation
+
+  const onPointerDown = (event: ThreeEvent<PointerEvent>) => {
+    if (event.button !== 0) return
+    event.stopPropagation()
+    suppressBoxSelectForPointer(event)
+    const levelId = plate.parentId
+    const level = levelId ? sceneRegistry.nodes.get(levelId) : null
+    if (!(levelId && level)) return
+    level.updateWorldMatrix(true, false)
+    const toLocal = level.matrixWorld.clone().invert()
+    const world = new Vector3(anchor[0], elevation, anchor[1]).applyMatrix4(level.matrixWorld)
+    const normal = camera.getWorldPosition(new Vector3()).sub(world).setY(0)
+    if (normal.lengthSq() === 0) return
+    const plane = new Plane().setFromNormalAndCoplanarPoint(normal.normalize(), world)
+    const localY = (clientX: number, clientY: number) => {
+      const rect = gl.domElement.getBoundingClientRect()
+      raycaster.setFromCamera(
+        new Vector2(
+          ((clientX - rect.left) / rect.width) * 2 - 1,
+          -((clientY - rect.top) / rect.height) * 2 + 1,
+        ),
+        camera,
+      )
+      const hit = raycaster.ray.intersectPlane(plane, new Vector3())
+      return hit ? hit.applyMatrix4(toLocal).y : null
+    }
+    const startY = localY(event.nativeEvent.clientX, event.nativeEvent.clientY)
+    if (startY === null) return
+    const nodes = () => useScene.getState().nodes
+    // Heights are read against the plate as the drag found it (the preview moves it).
+    const startNodes = nodes()
+    const start = footprintHeightValue(startNodes, plate)
+    const min = footprintHeightMinimum(startNodes, plate)
+    const levelNode = nodes()[levelId as AnyNodeId]
+    const max = levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) - 0.5 : 3
+    const step = isGridSnapActive() ? 0.05 : 0.01
+    let value = start
+    const preview = beginFootprintHeightPreview(plate.id)
+    setNotice(null)
+    setDragValue(start)
+    runRoomHandleDrag({
+      label: FOOTPRINT_HEIGHT_DRAG_LABEL,
+      nodeId: plate.id,
+      levelId,
+      requires: [plate.id],
+      sample: (x, y) => {
+        const pointerY = localY(x, y)
+        if (pointerY === null) return null
+        const raw = start + pointerY - startY
+        return Math.max(min, Math.min(max, Math.round(raw / step) * step))
+      },
+      onValue: (next) => {
+        if (Math.abs(next - value) < 1e-6) return
+        // Live: the building follows, outside history until the release.
+        const refused = preview.preview(next)
+        setNotice(refused)
+        setHint(thickFloorAdvice(startNodes, plate, next) ? THICK_FLOOR_HINT : null)
+        if (!refused) value = next
+        setDragValue(next)
+      },
+      onCommit: () => {
+        setNotice(preview.commit(value))
+        setDragValue(null)
+        setHint(null)
+      },
+      onCancel: () => {
+        preview.cancel()
+        setDragValue(null)
+        setHint(null)
+      },
+    })
+  }
+
+  const shown = dragValue ?? null
+  return (
+    <group>
+      <ElevationArrows
+        anchor={[anchor[0], elevation, anchor[1]]}
+        hover={hover || shown !== null}
+        onHoverChange={setHover}
+        onPointerDown={onPointerDown}
+        zoom={zoom}
+      />
+      {(shown !== null || notice || hint) && (
+        <Html
+          center
+          position={[anchor[0], elevation + 0.75 * zoom, anchor[1]]}
+          zIndexRange={[25, 0]}
+        >
+          <div className="flex flex-col items-center gap-1" data-footprint-height-pill>
+            {shown !== null && (
+              <div className={PILL}>
+                <span className="font-medium text-foreground">
+                  {upper ? 'Floor top' : 'Foundation'}
+                </span>
+                <span className="text-muted-foreground">
+                  {formatLinearMeasurement(shown, unit, metricNotation)}
+                </span>
+              </div>
+            )}
+            {(notice ?? hint) && (
+              <div className={NOTICE} data-footprint-height-notice role="status">
+                {notice ?? hint}
+              </div>
+            )}
+          </div>
+        </Html>
+      )}
+    </group>
+  )
+}

package/src/components/editor/grid.tsx

@@ -1,7 +1,12 @@
 'use client'
 
 import { type AnyNodeId, emitter, type GridEvent, sceneRegistry } from '@pascal-app/core'
-import { GRID_LAYER, getSceneTheme, useViewer } from '@pascal-app/viewer'
+import {
+  GRID_LAYER,
+  getSceneTheme,
+  useImmersiveXRPresentation,
+  useViewer,
+} from '@pascal-app/viewer'
 import { useFrame } from '@react-three/fiber'
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { DoubleSide, type Mesh, PlaneGeometry, Quaternion, Vector2, Vector3 } from 'three'
@@ -10,9 +15,12 @@ import { MeshBasicNodeMaterial } from 'three/webgpu'
 import { useCeilingEvents } from '../../hooks/use-ceiling-events'
 import { useGridEvents } from '../../hooks/use-grid-events'
 import { getPlacementSurface, usesOrientedPlacementPlane } from '../../lib/active-placement-surface'
-import useEditor, { isGridSnapActive } from '../../store/use-editor'
+import { gridLocalNormal, gridLocalPoint } from '../../lib/grid-frame'
+import useEditor, { getActiveSnapContext, isGridSnapActive } from '../../store/use-editor'
 import { getMovingNode } from '../../store/use-interaction-scope'
 
+export const EDITOR_GRID_INPUT_NAME = 'pascal-editor-grid-input'
+
 // Reveal radius (m) of the cursor-local grid patch shown while placing/moving in
 // grid-snap mode — much tighter than the idle reveal so only the area you're
 // about to snap into lights up.
@@ -45,6 +53,7 @@ export const Grid = ({
   fadeStrength?: number
   revealRadius?: number
 }) => {
+  const immersive = useImmersiveXRPresentation()
   const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark')
 
   // Use slightly lighter colors for dark themes' grid to make it apparent
@@ -60,6 +69,9 @@ export const Grid = ({
   const wallCursorRef = useRef(new Vector3())
   // Scratch for deriving a moving wall-item's host normal from its mesh.
   const wallNormalRef = useRef(new Vector3())
+  const localSurfaceRef = useRef(new Vector3())
+  const localNormalRef = useRef(new Vector3())
+  const localCursorRef = useRef(new Vector3())
   // Last Y pushed to `gridY` state, so the per-frame surface follow only triggers
   // a React re-render when the height actually changes (not every frame).
   const lastGridYRef = useRef<number | null>(null)
@@ -176,10 +188,11 @@ export const Grid = ({
   // laid-flat orientation maps `positionLocal.y` to world `-Z` relative to the
   // mesh origin. The cursor is recomputed every frame from the stored world hit
   // so the reveal stays put regardless of where the mesh origin sits.
-  const lastWorldCursorRef = useRef<{ x: number; z: number } | null>(null)
+  const lastWorldCursorRef = useRef<Vector3 | null>(null)
   useEffect(() => {
     const onGridMove = (event: GridEvent) => {
-      lastWorldCursorRef.current = { x: event.position[0], z: event.position[2] }
+      lastWorldCursorRef.current ??= new Vector3()
+      lastWorldCursorRef.current.set(...event.position)
     }
 
     emitter.on('grid:move', onGridMove)
@@ -194,7 +207,12 @@ export const Grid = ({
     if (levelId) {
       const levelMesh = sceneRegistry.nodes.get(levelId)
       if (levelMesh) {
-        levelY = levelMesh.position.y
+        levelMesh.getWorldPosition(worldPosRef.current)
+        levelY = gridLocalPoint(
+          gridRef.current.parent,
+          worldPosRef.current,
+          localSurfaceRef.current,
+        ).y
       }
     }
 
@@ -229,6 +247,10 @@ export const Grid = ({
     }
 
     const gridMesh = gridRef.current
+    if (surfacePoint) {
+      surfacePoint = gridLocalPoint(gridMesh.parent, surfacePoint, localSurfaceRef.current)
+      surfaceNormal = gridLocalNormal(gridMesh.parent, surfaceNormal, localNormalRef.current)
+    }
     const onOrientedPlane = surfacePoint != null && usesOrientedPlacementPlane(surfaceNormal)
     if (onOrientedPlane && surfacePoint) {
       // Surface-anchored lattice: orient the plane into the host and pin the mesh to
@@ -269,7 +291,8 @@ export const Grid = ({
       gridMesh.quaternion.copy(HORIZONTAL_QUATERNION)
       const world = lastWorldCursorRef.current
       if (world) {
-        cursorPositionRef.current.set(world.x, -world.z)
+        const local = gridLocalPoint(gridMesh.parent, world, localCursorRef.current)
+        cursorPositionRef.current.set(local.x, -local.z)
       }
       if (lastGridYRef.current !== targetY) {
         lastGridYRef.current = targetY
@@ -293,7 +316,7 @@ export const Grid = ({
     // from the interaction scope OR the armed build tool and is true only when
     // that context resolves to grid, so it IS the gate. (Previously this also
     // required a ghost in flight, so a merely-armed draft tool showed nothing.)
-    const snapPatchVisible = isGridSnapActive()
+    const snapPatchVisible = isGridSnapActive() || (immersive && getActiveSnapContext() !== null)
     revealRadiusUniform.value = PLACEMENT_REVEAL_RADIUS
     baseAlphaUniform.value = 0
     cellSizeUniform.value = useEditor.getState().gridSnapStep
@@ -320,6 +343,7 @@ export const Grid = ({
       geometry={geometry}
       layers={GRID_LAYER}
       material={material}
+      name={EDITOR_GRID_INPUT_NAME}
       ref={gridRef}
       renderOrder={1}
     />

package/src/components/editor/group-actions.ts

@@ -18,10 +18,13 @@ import { markPerfAction, useViewer } from '@pascal-app/viewer'
 import { Plane, Vector2, Vector3 } from 'three'
 import { GROUP_MOVE_DRAG_LABEL } from '../../lib/contextual-help'
 import { clientToPlan } from '../../lib/floorplan/plan-coords'
+import { deleteSelectedSeparator, requestRoomDeletion } from '../../lib/room-structure-commands'
+import { captureElementActionOrigin, completeElementAction } from '../../lib/room-zone-routing'
 import {
   copySelectedNodesToEditorClipboard,
   duplicateNodesToLevel,
   getEditorClipboardSnapshot,
+  type PasteRefusal,
   pasteSystemEditorClipboardToLevel,
 } from '../../lib/scene-clipboard'
 import { emitDeleteSFX, sfxEmitter } from '../../lib/sfx-bus'
@@ -33,13 +36,13 @@ import useEditor, {
   isGridSnapActive,
   isMagneticSnapActive,
 } from '../../store/use-editor'
+import useFloorplanMode from '../../store/use-floorplan-mode'
 import useInteractionScope from '../../store/use-interaction-scope'
 import { useFloorplanGroupDrag } from '../editor-2d/floorplan-group-move'
 import {
   classifyParticipant,
   collectParticipants,
   computeGroupBox,
-  expandToComponent,
   groupPlanBounds,
   levelFrame,
   planBoundsCenter,
@@ -83,8 +86,8 @@ export function canGroupPickUp(): boolean {
  * until a click commits, mirroring the single-node `movingNode` flow. Returns
  * false when the selection holds no transformable participants.
  *
- * `scopeToSelection` limits the moving set to the selected participants —
- * no connected-component expansion and no welded-neighbor endpoints. The
+ * `scopeToSelection` drops the welded-neighbor endpoints, so connected walls
+ * don't stretch along with the move. The
  * Duplicate flow needs this: its clones sit EXACTLY on the originals, so
  * junction coincidence would otherwise weld the originals into the pick-up
  * and drag them along with the copies.
@@ -96,10 +99,7 @@ export function startGroupPickUp(
   const participantIds = groupParticipantIds()
   if (participantIds.length === 0) return false
   const nodes = useScene.getState().nodes
-  const fullIds = opts.scopeToSelection
-    ? participantIds
-    : expandToComponent(participantIds, nodes, levelId)
-  const collected = collectParticipants(fullIds, nodes, levelId)
+  const collected = collectParticipants(participantIds, nodes, levelId)
   // Mutable: mid-carry R/T rotates these snapshots in place.
   let starts = collected.starts
   let links = opts.scopeToSelection ? [] : collected.links
@@ -107,8 +107,8 @@ export function startGroupPickUp(
   const affectedIds: AnyNodeId[] = [...starts.map((s) => s.id), ...links.map((l) => l.id)]
 
   const { inverse: frameInv } = levelFrame(levelId)
-  const restBox = computeGroupBox(fullIds)
-  const startBounds = groupPlanBounds(restBox, starts, frameInv)
+  const restBox = computeGroupBox(participantIds)
+  const startBounds = groupPlanBounds(starts, frameInv)
   if (!startBounds) return false
   // Mutable: mid-carry R/T re-seeds the footprint around the same pivot.
   let restBounds = startBounds
@@ -460,12 +460,39 @@ function removeUnusedPasteMaterials(materialIds: SceneMaterialId[]) {
   }
 }
 
+const REFUSED_PASTE_REASONS: Record<PasteRefusal, [one: string, many: string]> = {
+  'no-access': [
+    'you no longer have access to the project it came from.',
+    'you no longer have access to the project they came from.',
+  ],
+  'no-copies': [
+    'this version is not available to copy from the source project.',
+    'these versions are not available to copy from the source project.',
+  ],
+  failed: ["it couldn't be copied. Try again.", "they couldn't be copied. Try again."],
+}
+
+/** Why scripted objects were left out of a paste, or of a build loaded from a file. */
+export function refusedObjectsNotice(
+  count: number,
+  refusal: PasteRefusal,
+  action: 'pasted' | 'loaded' = 'pasted',
+) {
+  const [one, many] = REFUSED_PASTE_REASONS[refusal]
+  return count === 1
+    ? `1 object wasn't ${action}: ${one}`
+    : `${count} objects weren't ${action}: ${many}`
+}
+
+let pastePending = false
+
 /**
  * Paste the Pascal scene payload from the browser clipboard onto the active
  * level, then carry the clones under the cursor until click-to-place. Escape
  * removes the uncommitted clones and any scene materials imported with them.
  */
 export async function pasteSelectionAndPickUp(targetLevelId?: AnyNodeId): Promise<boolean> {
+  if (pastePending) return false
   const activeScope = useInteractionScope.getState().scope
   if (activeScope.kind === 'placing' || activeScope.kind === 'moving') {
     emitter.emit('tool:cancel')
@@ -480,7 +507,18 @@ export async function pasteSelectionAndPickUp(targetLevelId?: AnyNodeId): Promis
   // above there is nothing to abandon.
   if (isBrushMode(useEditor.getState().mode)) useEditor.getState().setMode('select')
 
-  const result = await pasteSystemEditorClipboardToLevel(targetLevelId)
+  pastePending = true
+  let result: Awaited<ReturnType<typeof pasteSystemEditorClipboardToLevel>>
+  try {
+    result = await pasteSystemEditorClipboardToLevel(targetLevelId)
+  } finally {
+    pastePending = false
+  }
+  if (result?.refusal) {
+    useFloorplanMode
+      .getState()
+      .showNotice(refusedObjectsNotice(result.refusedIds.length, result.refusal))
+  }
   if (!result || result.pastedIds.length === 0) return false
 
   const discardPaste = () => {
@@ -551,7 +589,16 @@ export function cutSelectionToEditorClipboard(): boolean {
  */
 export function deleteSelection(): boolean {
   const selectedIds = useViewer.getState().selection.selectedIds as AnyNodeId[]
-  if (selectedIds.length === 0) return false
+  if (selectedIds.length === 0) {
+    const room = useEditor.getState().room
+    if (!room) return false
+    requestRoomDeletion(room.zoneId)
+    return true
+  }
+  // A drilled piece of a room (a wall, a separator, its ceiling) deleted: back to the room.
+  const origin = captureElementActionOrigin(selectedIds)
+  if (selectedIds.length === 1 && useScene.getState().nodes[selectedIds[0]!]?.type === 'separator')
+    return deleteSelectedSeparator(selectedIds[0]!, origin)
 
   const commitDelete = () => {
     const detail =
@@ -566,6 +613,7 @@ export function deleteSelection(): boolean {
     }
     useScene.getState().deleteNodes(selectedIds)
     useViewer.getState().setSelection({ selectedIds: [] })
+    completeElementAction(origin)
   }
 
   if (selectedIds.length >= BULK_DELETE_THRESHOLD) {

package/src/components/editor/group-floating-action-menu.tsx

@@ -15,7 +15,12 @@ import useSessionGroups, {
   ungroupCurrentSelection,
 } from '../../store/use-session-groups'
 import { deleteSelection, duplicateSelectionAndPickUp, startGroupPickUp } from './group-actions'
-import { classifyParticipant, computeGroupBox, expandToComponent } from './group-transform-shared'
+import {
+  classifyParticipant,
+  computeGroupBox,
+  computeGroupPlanBox,
+  levelFrame,
+} from './group-transform-shared'
 import { NodeActionMenu } from './node-action-menu'
 import { useMeshSettleEpoch } from './use-mesh-settle-epoch'
 
@@ -69,15 +74,20 @@ export function GroupFloatingActionMenu() {
   const anchor = useMemo(() => {
     void meshEpoch
     if (participantIds.length === 0) return null
-    const fullIds = expandToComponent(participantIds, nodes, levelId)
-    const box = computeGroupBox(fullIds)
+    const box = computeGroupBox(participantIds)
     if (!box) return null
-    return new THREE.Vector3(
-      (box.min.x + box.max.x) / 2,
-      box.max.y + MENU_Y_OFFSET,
-      (box.min.z + box.max.z) / 2,
-    )
-  }, [participantIds, nodes, levelId, meshEpoch])
+    // Over the level-frame box's centre (the dashed boxes' and gizmo's), so the
+    // pill stays on the box under a rotated building; the mesh box gives the top.
+    const levelId = useViewer.getState().selection.levelId
+    const plan = computeGroupPlanBox(participantIds, levelId)
+    const anchor = plan
+      ? new THREE.Vector3((plan.minX + plan.maxX) / 2, 0, (plan.minZ + plan.maxZ) / 2).applyMatrix4(
+          levelFrame(levelId).matrix,
+        )
+      : new THREE.Vector3((box.min.x + box.max.x) / 2, 0, (box.min.z + box.max.z) / 2)
+    anchor.y = box.max.y + MENU_Y_OFFSET
+    return anchor
+  }, [participantIds, meshEpoch])
 
   useFrame((state) => {
     if (!(menuScaleRef.current && groupRef.current)) return

package/src/components/editor/group-move-3d.ts

@@ -31,7 +31,6 @@ import {
   classifyParticipant,
   collectParticipants,
   computeGroupBox,
-  expandToComponent,
   type GroupPlanBounds,
   groupPlanBounds,
   levelFrame,
@@ -107,16 +106,15 @@ export function armGroupMove3d(args: {
     const participantIds = selectedIds.filter(
       (id) => classifyParticipant(nodes[id as AnyNodeId], levelId, nodes) !== null,
     )
-    // Move the full connected wall/fence component, mirroring the 2D session.
-    const fullIds = expandToComponent(participantIds, nodes, levelId)
-    const { starts, links } = collectParticipants(fullIds, nodes, levelId)
+    // Only the selection moves; connected walls stretch through `links`, as in 2D.
+    const { starts, links } = collectParticipants(participantIds, nodes, levelId)
     if (starts.length === 0) return null
     const affectedIds: AnyNodeId[] = [...starts.map((s) => s.id), ...links.map((l) => l.id)]
 
     // Horizontal drag plane at the group's base; placements live in the level
     // frame, so world-space plane hits convert through it (a rotated building
     // would otherwise drift off-axis from the cursor).
-    const restBox = computeGroupBox(fullIds)
+    const restBox = computeGroupBox(participantIds)
     if (!restBox) return null
     const plane = new Plane(new Vector3(0, 1, 0), -restBox.min.y)
     const { inverse: frameInv } = levelFrame(levelId)
@@ -136,7 +134,7 @@ export function armGroupMove3d(args: {
       if (n && !movingIdSet.has(nid)) staticNodes[nid] = n
     }
     const candidates = collectAlignmentAnchors(staticNodes, '', levelId)
-    const restBounds = groupPlanBounds(restBox, starts, frameInv)
+    const restBounds = groupPlanBounds(starts, frameInv)
     if (!restBounds) return null
     const restAnchors = bboxCornerAnchors(
       'group-move',