@pascal-app/editor 1.0.0-beta.5 → 1.0.0

package/src/components/editor/floorplan-panel.tsx

@@ -33,6 +33,7 @@ import {
   type RoofNode,
   type RoofSegmentNode,
   resolveSlabPlacementElevation,
+  resolveTerrainWallConstructionOptions,
   type SiteNode,
   type SlabNode,
   SlabNode as SlabNodeSchema,
@@ -88,6 +89,8 @@ import {
   type FloorplanNodeTransform as SharedFloorplanNodeTransform,
   worldToFloorplanLocalPoint,
 } from '../../lib/floorplan'
+import { resolveGenericFloorplanGridEventPoint } from '../../lib/floorplan-grid-event-point'
+import type { EditorGridEvent } from '../../lib/grid-event-presentation'
 import { groundHeightAt } from '../../lib/ground-surface'
 import { guideEmitter } from '../../lib/guide-events'
 import { measurementHint, parseMeasurement } from '../../lib/measurement-parser'
@@ -148,6 +151,7 @@ import {
   isBoxSelectPointerSuppressed,
   markBoxSelectHandled,
 } from '../tools/select/box-select-state'
+import { marqueePolygon } from '../tools/select/marquee-footprint'
 import {
   type Point2 as MarqueePoint2,
   polygonsIntersect as marqueePolygonsIntersect,
@@ -184,7 +188,6 @@ import {
   chainEndJoinsExistingWall,
   createWallOnCurrentLevel,
   isSegmentLongEnough,
-  resolveTerrainWallConstructionOptions,
   snapWallDraftPoint,
   snapWallDraftPointDetailed,
   snapPointToGrid as snapWallPointToGrid,
@@ -864,7 +867,8 @@ function collectFloorplanScreenSelectionIds(rect: ScreenRect, svg: SVGSVGElement
         | { start?: unknown; end?: unknown; polygon?: unknown }
         | undefined
       if (!node) continue
-      const { start, end, polygon } = node
+      const { start, end } = node
+      const polygon = marqueePolygon(node)
       if (isMarqueeVec2(start) && isMarqueeVec2(end)) {
         dataTested.add(id)
         if (marqueeSegmentIntersectsPolygon(start, end, planQuad)) hitIdsFromData.add(id)
@@ -4673,6 +4677,7 @@ function FloorplanLinearDraftLayer({
   const wallDraftEnd = useFloorplanDraftPreview((s) => s.wallDraftEnd)
   const fenceDraftEnd = useFloorplanDraftPreview((s) => s.fenceDraftEnd)
   const roofDraftEnd = useFloorplanDraftPreview((s) => s.roofDraftEnd)
+  const roofDraftQuarterTurn = useFloorplanDraftPreview((s) => s.roofDraftQuarterTurn)
 
   const draftPolygon = useMemo(() => {
     if (
@@ -4709,6 +4714,21 @@ function FloorplanLinearDraftLayer({
     return draftPolygon ? formatPolygonPoints(draftPolygon) : null
   }, [draftPolygon, isRoofBuildActive, roofDraftEnd, roofDraftStart])
 
+  const roofDraftDirectionLine = useMemo(() => {
+    if (!(isRoofBuildActive && roofDraftStart && roofDraftEnd)) return null
+    const minX = Math.min(roofDraftStart[0], roofDraftEnd[0])
+    const maxX = Math.max(roofDraftStart[0], roofDraftEnd[0])
+    const minY = Math.min(roofDraftStart[1], roofDraftEnd[1])
+    const maxY = Math.max(roofDraftStart[1], roofDraftEnd[1])
+    if (maxX - minX < 1e-6 || maxY - minY < 1e-6) return null
+
+    const centerX = (minX + maxX) / 2
+    const centerY = (minY + maxY) / 2
+    return roofDraftQuarterTurn
+      ? { x1: centerX, y1: minY, x2: centerX, y2: maxY }
+      : { x1: minX, y1: centerY, x2: maxX, y2: centerY }
+  }, [isRoofBuildActive, roofDraftEnd, roofDraftQuarterTurn, roofDraftStart])
+
   const fenceDraftSegment = useMemo(() => {
     if (!(isFenceBuildActive && fenceDraftStart && fenceDraftEnd)) {
       return null
@@ -4887,6 +4907,19 @@ function FloorplanLinearDraftLayer({
         unitsPerPixel={unitsPerPixel}
       />
 
+      {roofDraftDirectionLine && (
+        <line
+          pointerEvents="none"
+          stroke={draftStroke}
+          strokeLinecap="round"
+          strokeWidth={unitsPerPixel * 1.5}
+          x1={toSvgX(roofDraftDirectionLine.x1)}
+          x2={toSvgX(roofDraftDirectionLine.x2)}
+          y1={toSvgY(roofDraftDirectionLine.y1)}
+          y2={toSvgY(roofDraftDirectionLine.y2)}
+        />
+      )}
+
       {draftWallMeasurement && (
         <FloorplanDraftWallMeasurement
           labelBackground={isDark ? '#0f172a' : '#ffffff'}
@@ -5063,6 +5096,9 @@ export function FloorplanPanel({
     if (building?.type !== 'building') return false
     return building.children.some((cid) => state.nodes[cid]?.type === 'level')
   })
+  // The studio workspace (renders / materials / item builder) is a clean
+  // stage — editor viewport chrome, compass included, stays out of it.
+  const isStudioWorkspace = useEditor((s) => s.workspaceMode === 'studio')
   const elevators = useScene(
     useShallow((state) => {
       const building = currentBuildingId ? state.nodes[currentBuildingId] : null
@@ -8931,12 +8967,29 @@ export function FloorplanPanel({
       const groundY = groundHeightAt(worldX, worldZ, floorplanGridWorldY)
       const worldY = groundY ?? floorplanGridWorldY
       const localY = groundY === null ? floorplanGridLocalY : groundY - buildingPosition[1]
+      const planScene =
+        nativeEvent.currentTarget.querySelector<SVGGraphicsElement>('[data-floorplan-scene]')
+      const screenMatrix = planScene?.getScreenCTM()
 
-      emitter.emit(`grid:${eventType}` as any, {
+      const gridEvent: EditorGridEvent = {
         nativeEvent: nativeEvent.nativeEvent as any,
         position: [worldX, worldY, worldZ],
         localPosition: [planPoint[0], localY, planPoint[1]],
-      })
+        screenProjection: screenMatrix
+          ? {
+              pointer: [nativeEvent.clientX, nativeEvent.clientY],
+              localToScreen: [
+                screenMatrix.a,
+                screenMatrix.b,
+                screenMatrix.c,
+                screenMatrix.d,
+                screenMatrix.e,
+                screenMatrix.f,
+              ],
+            }
+          : undefined,
+      }
+      emitter.emit(`grid:${eventType}` as any, gridEvent)
     },
     [buildingPosition, buildingRotationY, floorplanGridLocalY, floorplanGridWorldY],
   )
@@ -9400,10 +9453,14 @@ export function FloorplanPanel({
       // this exclusion the catch-all would emit `grid:move` and re-drive the
       // 3D MoveDoorTool's free-follow, fighting the overlay again.
       if (!isWallBuildActive && !isOpeningMoveActive && isFloorplanGridInteractionActive) {
-        const snappedPoint = getSnappedFloorplanPoint(planPoint)
-        emitFloorplanGridEvent('move', snappedPoint, event)
+        const eventPoint = resolveGenericFloorplanGridEventPoint({
+          point: planPoint,
+          registryToolOwnsSnapping: isRegistryToolBuildActive,
+          snap: getSnappedFloorplanPoint,
+        })
+        emitFloorplanGridEvent('move', eventPoint, event)
         setCursorPoint((previousPoint) =>
-          previousPoint && pointsEqual(previousPoint, snappedPoint) ? previousPoint : snappedPoint,
+          previousPoint && pointsEqual(previousPoint, eventPoint) ? previousPoint : eventPoint,
         )
         return
       }
@@ -9503,6 +9560,7 @@ export function FloorplanPanel({
       // stale closure and float a door symbol while the window tool is armed.
       showOpeningGhost,
       isPolygonBuildActive,
+      isRegistryToolBuildActive,
       isRoofBuildActive,
       isWallBuildActive,
       levelId,
@@ -9849,6 +9907,7 @@ export function FloorplanPanel({
     isOpeningPlacementActive: isOpeningBuildActive && !isOpeningMoveActive,
     isPolygonBuildActive,
     isRoofBuildActive,
+    registryToolOwnsSnapping: isRegistryToolBuildActive,
     isWallBuildActive,
     isZoneBuildActive,
     levelId,
@@ -10512,9 +10571,11 @@ export function FloorplanPanel({
       }
 
       if (useEditor.getState().phase !== 'site') {
-        useEditor.setState({ catalogCategory: null, mode: 'select', phase: 'site', tool: null })
+        useEditor.getState().setPhase('site')
+        useEditor.getState().armToolMode({ mode: 'select' })
+      } else {
+        selectSiteFloorplanContext()
       }
-      selectSiteFloorplanContext()
 
       const nextDraft = {
         siteId,
@@ -10596,9 +10657,11 @@ export function FloorplanPanel({
       ]
 
       if (useEditor.getState().phase !== 'site') {
-        useEditor.setState({ catalogCategory: null, mode: 'select', phase: 'site', tool: null })
+        useEditor.getState().setPhase('site')
+        useEditor.getState().armToolMode({ mode: 'select' })
+      } else {
+        selectSiteFloorplanContext()
       }
-      selectSiteFloorplanContext()
 
       const nextDraft = {
         siteId,
@@ -11107,7 +11170,8 @@ export function FloorplanPanel({
         <FloorplanRegistryActionMenu />
         <FloorplanGroupActionMenu />
 
-        {(levelNode?.type === 'level' || hasAmbientBuildingLevel) &&
+        {!isStudioWorkspace &&
+          (levelNode?.type === 'level' || hasAmbientBuildingLevel) &&
           (compassHost ? (
             createPortal(
               <FloorplanCompassButton

package/src/components/editor/grid.tsx

@@ -9,7 +9,7 @@ import { color, float, fract, fwidth, mix, positionLocal, uniform } from 'three/
 import { MeshBasicNodeMaterial } from 'three/webgpu'
 import { useCeilingEvents } from '../../hooks/use-ceiling-events'
 import { useGridEvents } from '../../hooks/use-grid-events'
-import { getPlacementSurface } from '../../lib/active-placement-surface'
+import { getPlacementSurface, usesOrientedPlacementPlane } from '../../lib/active-placement-surface'
 import useEditor, { isGridSnapActive } from '../../store/use-editor'
 import { getMovingNode } from '../../store/use-interaction-scope'
 
@@ -229,16 +229,21 @@ export const Grid = ({
     }
 
     const gridMesh = gridRef.current
-    const onWall = surfacePoint != null && Math.abs(surfaceNormal.y) < 0.5
-    if (onWall && surfacePoint) {
-      // Wall-anchored lattice: orient the plane into the wall and pin the mesh to
+    const onOrientedPlane = surfacePoint != null && usesOrientedPlacementPlane(surfaceNormal)
+    if (onOrientedPlane && surfacePoint) {
+      // Surface-anchored lattice: orient the plane into the host and pin the mesh to
       // the plane's FOOT (the point on the wall plane closest to the world origin)
       // — never the moving ghost. Sliding the opening along the wall then only
       // moves the reveal patch (the cursor uniform); the snap lattice stays put.
       // (Copying `surfacePoint` here made the grid follow the item — useless.)
       gridMesh.quaternion.setFromUnitVectors(PLANE_LOCAL_NORMAL, surfaceNormal)
       const planeOffset = surfacePoint.dot(surfaceNormal)
-      gridMesh.position.copy(surfaceNormal).multiplyScalar(planeOffset)
+      const latticeAnchor = published?.anchor ?? surfacePoint
+      gridMesh.position.copy(latticeAnchor)
+      gridMesh.position.addScaledVector(
+        surfaceNormal,
+        -latticeAnchor.dot(surfaceNormal) + planeOffset,
+      )
       // Cursor → plane-local XY: rotate (ghost − anchor) by the inverse plane
       // orientation. Both lie in the plane, so the resulting local Z is ~0.
       invQuatRef.current.copy(gridMesh.quaternion).invert()
@@ -275,8 +280,8 @@ export const Grid = ({
     // Floor grid depth-tests against the scene (ground occludes a sub-floor
     // lattice); the wall grid ignores depth so it stays visible through the wall
     // when the opening is being handled from the opposite side.
-    if (material.depthTest === onWall) {
-      material.depthTest = !onWall
+    if (material.depthTest === onOrientedPlane) {
+      material.depthTest = !onOrientedPlane
       material.needsUpdate = true
     }
 

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

@@ -14,7 +14,7 @@ import {
   useLiveTransforms,
   useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+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'
@@ -40,9 +40,11 @@ import {
   collectParticipants,
   computeGroupBox,
   expandToComponent,
+  groupPlanBounds,
   levelFrame,
-  participantExtents,
+  planBoundsCenter,
   rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
   type Vec2,
 } from './group-transform-shared'
@@ -104,46 +106,15 @@ export function startGroupPickUp(
   if (starts.length === 0) return false
   const affectedIds: AnyNodeId[] = [...starts.map((s) => s.id), ...links.map((l) => l.id)]
 
-  // Rest bounds in the level frame. Prefer the mounted meshes' world box
-  // (footprint-accurate), but fall back to the participant DATA when the
-  // meshes aren't up yet — Duplicate starts the pick-up synchronously after
-  // `createNodes`, one frame before the clones' renderers mount.
   const { inverse: frameInv } = levelFrame(levelId)
   const restBox = computeGroupBox(fullIds)
-  let minX = Number.POSITIVE_INFINITY
-  let minZ = Number.POSITIVE_INFINITY
-  let maxX = Number.NEGATIVE_INFINITY
-  let maxZ = Number.NEGATIVE_INFINITY
-  if (restBox) {
-    const boxMin = restBox.min.clone().applyMatrix4(frameInv)
-    const boxMax = restBox.max.clone().applyMatrix4(frameInv)
-    minX = Math.min(boxMin.x, boxMax.x)
-    minZ = Math.min(boxMin.z, boxMax.z)
-    maxX = Math.max(boxMin.x, boxMax.x)
-    maxZ = Math.max(boxMin.z, boxMax.z)
-  } else {
-    const reach = (x: number, z: number) => {
-      minX = Math.min(minX, x)
-      minZ = Math.min(minZ, z)
-      maxX = Math.max(maxX, x)
-      maxZ = Math.max(maxZ, z)
-    }
-    for (const s of starts) {
-      if (s.kind === 'endpoint') {
-        reach(s.start[0], s.start[1])
-        reach(s.end[0], s.end[1])
-      } else if (s.kind === 'polygon') {
-        for (const [x, z] of s.polygon) {
-          reach(x, z)
-        }
-      } else {
-        reach(s.position[0], s.position[2])
-      }
-    }
-  }
-  if (!Number.isFinite(minX)) return false
+  const startBounds = groupPlanBounds(restBox, starts, frameInv)
+  if (!startBounds) return false
+  // Mutable: mid-carry R/T re-seeds the footprint around the same pivot.
+  let restBounds = startBounds
+  let carriedRotation = 0
   // Rotation pivot for mid-carry R/T; stable across the whole pick-up.
-  const restCenter: [number, number] = [(minX + maxX) / 2, (minZ + maxZ) / 2]
+  const restCenter = planBoundsCenter(restBounds)
   // Ground plane for the 3D surface: the meshes' base when available, floor
   // level otherwise. Placements live in the level frame, so both surfaces
   // resolve into it before measuring.
@@ -157,7 +128,13 @@ export function startGroupPickUp(
     if (n && !movingIdSet.has(nid)) staticNodes[nid] = n
   }
   const candidates = collectAlignmentAnchors(staticNodes, '', levelId)
-  let restAnchors = bboxCornerAnchors('group-move', minX, minZ, maxX, maxZ)
+  let restAnchors = bboxCornerAnchors(
+    'group-move',
+    restBounds.minX,
+    restBounds.minZ,
+    restBounds.maxX,
+    restBounds.maxZ,
+  )
 
   // Cursor → level-frame plan point, whichever surface the pointer is over.
   const ndc = new Vector2()
@@ -274,18 +251,20 @@ export function startGroupPickUp(
   // the current delta — the carried group turns exactly like the idle
   // keyboard rotate, and the placement stays a single updateNodes.
   const rotateCarried = (direction: 1 | -1) => {
-    const rotated = rotateGroupSnapshots(
-      starts,
-      links,
-      { x: restCenter[0], z: restCenter[1] },
-      -direction * (Math.PI / 4),
-    )
+    const pivot = { x: restCenter[0], z: restCenter[1] }
+    const delta = -direction * (Math.PI / 4)
+    const rotated = rotateGroupSnapshots(starts, links, pivot, delta)
     starts = rotated.starts
     links = rotated.links
-    const ext = participantExtents(rotated.starts)
-    if (ext) {
-      restAnchors = bboxCornerAnchors('group-move', ext.minX, ext.minZ, ext.maxX, ext.maxZ)
-    }
+    carriedRotation += delta
+    restBounds = rotatePlanBounds(startBounds, pivot, carriedRotation)
+    restAnchors = bboxCornerAnchors(
+      'group-move',
+      restBounds.minX,
+      restBounds.minZ,
+      restBounds.maxX,
+      restBounds.maxZ,
+    )
     sfxEmitter.emit('sfx:item-rotate')
     applyDelta(lastDelta?.[0] ?? 0, lastDelta?.[1] ?? 0)
   }
@@ -575,6 +554,11 @@ export function deleteSelection(): boolean {
   if (selectedIds.length === 0) return false
 
   const commitDelete = () => {
+    const detail =
+      selectedIds.length === 1
+        ? (useScene.getState().nodes[selectedIds[0]!]?.type ?? selectedIds[0]!)
+        : String(selectedIds.length)
+    markPerfAction('delete', detail)
     if (selectedIds.length === 1) {
       emitDeleteSFX(useScene.getState().nodes[selectedIds[0]!]?.type)
     } else {

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

@@ -32,9 +32,12 @@ import {
   collectParticipants,
   computeGroupBox,
   expandToComponent,
+  type GroupPlanBounds,
+  groupPlanBounds,
   levelFrame,
-  participantExtents,
+  planBoundsCenter,
   rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
   type Vec2,
 } from './group-transform-shared'
@@ -88,6 +91,9 @@ export function armGroupMove3d(args: {
     affectedIds: AnyNodeId[]
     candidates: ReturnType<typeof collectAlignmentAnchors>
     restAnchors: ReturnType<typeof bboxCornerAnchors>
+    startBounds: GroupPlanBounds
+    restBounds: GroupPlanBounds
+    rotation: number
     restCenter: Vec2
     plane: Plane
     startLocal: Vector3
@@ -130,14 +136,14 @@ export function armGroupMove3d(args: {
       if (n && !movingIdSet.has(nid)) staticNodes[nid] = n
     }
     const candidates = collectAlignmentAnchors(staticNodes, '', levelId)
-    const boxMin = restBox.min.clone().applyMatrix4(frameInv)
-    const boxMax = restBox.max.clone().applyMatrix4(frameInv)
+    const restBounds = groupPlanBounds(restBox, starts, frameInv)
+    if (!restBounds) return null
     const restAnchors = bboxCornerAnchors(
       'group-move',
-      Math.min(boxMin.x, boxMax.x),
-      Math.min(boxMin.z, boxMax.z),
-      Math.max(boxMin.x, boxMax.x),
-      Math.max(boxMin.z, boxMax.z),
+      restBounds.minX,
+      restBounds.minZ,
+      restBounds.maxX,
+      restBounds.maxZ,
     )
 
     for (const id of affectedIds) {
@@ -154,9 +160,11 @@ export function armGroupMove3d(args: {
       nodeId,
       handle: GROUP_MOVE_DRAG_LABEL,
     })
-    // Rotation pivot for mid-drag R/T — the participant DATA extents' center.
-    const ext = participantExtents(starts)
-    const restCenter: Vec2 = ext ? [(ext.minX + ext.maxX) / 2, (ext.minZ + ext.maxZ) / 2] : [0, 0]
+    // Rotation pivot for mid-drag R/T — the START footprint's center, the same
+    // point the idle keyboard rotate and the rotate gizmos orbit. Fixed for the
+    // whole session: the snapshots are start placements, and `applyDelta` adds
+    // the live drag delta on top of them.
+    const restCenter = planBoundsCenter(restBounds)
 
     return {
       starts,
@@ -164,6 +172,9 @@ export function armGroupMove3d(args: {
       affectedIds,
       candidates,
       restAnchors,
+      startBounds: restBounds,
+      restBounds,
+      rotation: 0,
       restCenter,
       plane,
       startLocal,
@@ -245,18 +256,22 @@ export function armGroupMove3d(args: {
   // current delta — the carried group turns exactly like the idle keyboard
   // rotate, and the commit stays a single updateNodes.
   const rotateSession = (s: Session, direction: 1 | -1) => {
-    const rotated = rotateGroupSnapshots(
-      s.starts,
-      s.links,
-      { x: s.restCenter[0], z: s.restCenter[1] },
-      -direction * (Math.PI / 4),
-    )
+    const pivot = { x: s.restCenter[0], z: s.restCenter[1] }
+    const delta = -direction * (Math.PI / 4)
+    const rotated = rotateGroupSnapshots(s.starts, s.links, pivot, delta)
     s.starts = rotated.starts
     s.links = rotated.links
-    const ext = participantExtents(rotated.starts)
-    if (ext) {
-      s.restAnchors = bboxCornerAnchors('group-move', ext.minX, ext.minZ, ext.maxX, ext.maxZ)
-    }
+    // Re-fit from the start footprint at the accumulated angle: rotating the
+    // previous axis-aligned fit would inflate the box every step.
+    s.rotation += delta
+    s.restBounds = rotatePlanBounds(s.startBounds, pivot, s.rotation)
+    s.restAnchors = bboxCornerAnchors(
+      'group-move',
+      s.restBounds.minX,
+      s.restBounds.minZ,
+      s.restBounds.maxX,
+      s.restBounds.maxZ,
+    )
     sfxEmitter.emit('sfx:item-rotate')
     applyDelta(s, s.lastDelta?.[0] ?? 0, s.lastDelta?.[1] ?? 0)
   }
@@ -369,7 +384,22 @@ export function armGroupMove3d(args: {
   const onKeyDown = (e: KeyboardEvent) => {
     const key = e.key.toLowerCase()
     if ((key === 'r' || key === 't') && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey) {
-      if (!session) return
+      // Armed but still under the drag threshold: engage first (exactly what
+      // the next pointer-move would do) so the rotation lands inside this
+      // session. Falling through to the global idle arm instead would write
+      // the scene behind snapshots already captured here, and the first
+      // `applyDelta` would republish them — undoing the rotation.
+      if (!session) {
+        session = engage()
+        if (!session) {
+          // No plane hit yet: swallow the chord and keep the gesture armed so
+          // the next pointer-move can still engage; the idle arm must not run
+          // behind the snapshots captured here.
+          e.preventDefault()
+          e.stopPropagation()
+          return
+        }
+      }
       e.preventDefault()
       e.stopPropagation()
       rotateSession(session, key === 'r' ? 1 : -1)

package/src/components/editor/group-transform-shared.test.ts

@@ -4,7 +4,10 @@ import { z } from 'zod'
 import {
   classifyParticipant,
   collectParticipants,
+  planBoundsCenter,
   rotateGroupPatches,
+  rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
 } from './group-transform-shared'
 
@@ -40,6 +43,34 @@ function registerElevatorTestKind() {
   } as AnyNodeDefinition)
 }
 
+// A level holding one of each rigid placement shape: an item ([x,y,z] rotation)
+// and a column (numeric rotation).
+function placedNodes() {
+  return {
+    building_test: { id: 'building_test', type: 'building', children: ['level_test'] },
+    level_test: {
+      id: 'level_test',
+      type: 'level',
+      parentId: 'building_test',
+      children: ['item_chair', 'column_post'],
+    },
+    item_chair: {
+      id: 'item_chair',
+      type: 'item',
+      parentId: 'level_test',
+      position: [1, 0, 3],
+      rotation: [0, 0.5, 0],
+    },
+    column_post: {
+      id: 'column_post',
+      type: 'column',
+      parentId: 'level_test',
+      position: [4, 0, -1],
+      rotation: 1.25,
+    },
+  } as unknown as Record<string, AnyNode>
+}
+
 describe('group transform participants', () => {
   beforeAll(() => {
     registerBuildingScopedTestKind()
@@ -362,6 +393,53 @@ describe('group transform participants', () => {
     expect(lampPatch.position).toEqual([3, 2.4, 2])
   })
 
+  test('translate patches carry the snapshot rotation for vec3 and scalar kinds', () => {
+    const { starts } = collectParticipants(
+      ['item_chair', 'column_post'],
+      placedNodes(),
+      'level_test',
+    )
+    const patches = Object.fromEntries(translateGroupPatches(starts, [], 1, 2))
+
+    expect(patches.item_chair).toEqual({ position: [2, 0, 5], rotation: [0, 0.5, 0] })
+    expect(patches.column_post).toEqual({ position: [5, 0, 1], rotation: 1.25 })
+  })
+
+  test('a mid-drag rotation survives the next translate re-publish', () => {
+    const { starts } = collectParticipants(
+      ['item_chair', 'column_post'],
+      placedNodes(),
+      'level_test',
+    )
+    // What a mid-drag R does: turn the snapshots, then re-apply the live delta.
+    const rotated = rotateGroupSnapshots(starts, [], { x: 0, z: 0 }, Math.PI / 2)
+    const patches = Object.fromEntries(
+      translateGroupPatches(rotated.starts, rotated.links, 1, 2),
+    ) as Record<string, { position: number[]; rotation: number[] | number }>
+
+    // Orbited 90° in the atan2 x→z sense ((x, z) → (-z, x)), then slid.
+    expect(patches.item_chair!.position[0]).toBeCloseTo(-2)
+    expect(patches.item_chair!.position[2]).toBeCloseTo(3)
+    expect(patches.column_post!.position[0]).toBeCloseTo(2)
+    expect(patches.column_post!.position[2]).toBeCloseTo(6)
+    // …and the facings turned with it instead of reverting to the pre-drag yaw.
+    expect((patches.item_chair!.rotation as number[])[1]).toBeCloseTo(0.5 - Math.PI / 2)
+    expect(patches.column_post!.rotation as number).toBeCloseTo(1.25 - Math.PI / 2)
+  })
+
+  test('rotating the plan bounds keeps the footprint centred on the pivot', () => {
+    const bounds = { minX: 0, minZ: 0, maxX: 4, maxZ: 2 }
+    const [pivotX, pivotZ] = planBoundsCenter(bounds)
+    const rotated = rotatePlanBounds(bounds, { x: pivotX, z: pivotZ }, Math.PI / 2)
+
+    expect(rotated.minX).toBeCloseTo(1)
+    expect(rotated.maxX).toBeCloseTo(3)
+    expect(rotated.minZ).toBeCloseTo(-1)
+    expect(rotated.maxZ).toBeCloseTo(3)
+    expect(planBoundsCenter(rotated)[0]).toBeCloseTo(pivotX)
+    expect(planBoundsCenter(rotated)[1]).toBeCloseTo(pivotZ)
+  })
+
   test('supports legacy level-parented elevators already loaded in the editor', () => {
     const nodes = {
       building_test: {