@pascal-app/editor 0.9.1 → 0.9.2

package/src/components/editor/group-rotate-handle.tsx

@@ -3,6 +3,9 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  DEFAULT_ANGLE_STEP,
+  pauseSpaceDetection,
+  resumeSpaceDetection,
   useLiveNodeOverrides,
   useLiveTransforms,
   useScene,
@@ -11,8 +14,14 @@ import { useViewer } from '@pascal-app/viewer'
 import { createPortal, type ThreeEvent, useThree } from '@react-three/fiber'
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { OrthographicCamera, Plane, Vector2, Vector3 } from 'three'
+import { GROUP_MOVE_DRAG_LABEL, GROUP_ROTATE_DRAG_LABEL } from '../../lib/contextual-help'
+import { isHistoryShortcut } from '../../lib/history'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import useEditor from '../../store/use-editor'
+import useInteractionScope, {
+  useActiveHandleDrag,
+  useMovingNode,
+} from '../../store/use-interaction-scope'
 import { suppressBoxSelectForPointer } from '../tools/select/box-select-state'
 import {
   CORNER_OFFSET,
@@ -21,7 +30,7 @@ import {
   computeGroupBox,
   expandToComponent,
   levelFrame,
-  type Vec2,
+  rotateGroupPatches,
   type Vec3,
 } from './group-transform-shared'
 import {
@@ -31,16 +40,13 @@ import {
   createRotateArrowHandleGeometry,
   createRotateArrowHitAreaGeometry,
   GuideRing,
-  InvisibleHandleHitArea,
-  NO_RAYCAST,
   RotationGuide,
   type RotationGuideData,
   swallowNextClick,
   useArrowMaterial,
   useInvisibleHitAreaMaterial,
 } from './node-arrow-handles'
-
-const ROTATE_SNAP = Math.PI / 12 // 15°
+import { useMeshSettleEpoch } from './use-mesh-settle-epoch'
 
 /**
  * Group-rotate gizmo. When 2+ transformable nodes in the active level frame are
@@ -56,11 +62,14 @@ export function GroupRotateHandle() {
   const selectedIds = useViewer((s) => s.selection.selectedIds)
   const levelId = useViewer((s) => s.selection.levelId)
   const mode = useEditor((s) => s.mode)
-  const movingNode = useEditor((s) => s.movingNode)
+  const movingNode = useMovingNode()
+  const activeHandleDrag = useActiveHandleDrag()
   const isFloorplanHovered = useEditor((s) => s.isFloorplanHovered)
   // Re-derive participants whenever the scene mutates (e.g. after a commit).
   // Drags only touch `useLiveNodeOverrides`, so this does not fire mid-drag.
   const nodes = useScene((s) => s.nodes)
+  // Re-measure the pivot/corner once the meshes settle after a scene change.
+  const meshEpoch = useMeshSettleEpoch(nodes)
 
   const participantIds = useMemo(
     () =>
@@ -79,14 +88,20 @@ export function GroupRotateHandle() {
   )
 
   const shouldRender =
-    participantIds.length >= 2 && mode !== 'delete' && !movingNode && !isFloorplanHovered
+    participantIds.length >= 2 &&
+    mode !== 'delete' &&
+    !movingNode &&
+    !isFloorplanHovered &&
+    // Hide while the sibling move gizmo drags the group — the frozen corner
+    // this handle would sit at goes stale as the group slides under it.
+    activeHandleDrag?.label !== GROUP_MOVE_DRAG_LABEL
 
   if (!shouldRender) return null
   // Remount when the moving set changes so the rest pivot re-seeds cleanly.
-  return <GroupRotateHandleInner ids={fullIds} key={fullIds.join(',')} />
+  return <GroupRotateHandleInner ids={fullIds} key={fullIds.join(',')} meshEpoch={meshEpoch} />
 }
 
-function GroupRotateHandleInner({ ids }: { ids: string[] }) {
+function GroupRotateHandleInner({ ids, meshEpoch }: { ids: string[]; meshEpoch: number }) {
   const { camera, raycaster, gl, scene } = useThree()
   const arrowGeometry = useMemo(() => createRotateArrowHandleGeometry(), [])
   const hitGeometry = useMemo(() => createRotateArrowHitAreaGeometry(), [])
@@ -126,13 +141,26 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       box.max.z + CORNER_OFFSET,
     )
     return { pivot, corner }
-  }, [ids])
+    // biome-ignore lint/correctness/useExhaustiveDependencies: meshEpoch re-measures settled meshes
+  }, [ids, meshEpoch])
 
   if (!rest) return null
   const active = isDragging && frozenRest.current ? frozenRest.current : rest
   const corner = active.corner
 
+  const onHoverEnter = (event: ThreeEvent<PointerEvent>) => {
+    event.stopPropagation()
+    setIsHovered(true)
+    if (document.body.style.cursor !== 'grabbing') document.body.style.cursor = 'grab'
+  }
+  const onHoverLeave = (event: ThreeEvent<PointerEvent>) => {
+    event.stopPropagation()
+    setIsHovered(false)
+    if (document.body.style.cursor === 'grab') document.body.style.cursor = ''
+  }
+
   const activate = (event: ThreeEvent<PointerEvent>) => {
+    if (event.button !== 0) return
     event.stopPropagation()
     suppressBoxSelectForPointer(event)
 
@@ -166,6 +194,10 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       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])
       }
@@ -191,6 +223,11 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
     sfxEmitter.emit('sfx:item-pick')
     useViewer.getState().setInputDragging(true)
     useScene.temporal.getState().pause()
+    useInteractionScope.getState().begin({
+      kind: 'handle-drag',
+      nodeId: ids[0] ?? '',
+      handle: GROUP_ROTATE_DRAG_LABEL,
+    })
     setIsDragging(true)
 
     const onMove = (e: PointerEvent) => {
@@ -201,55 +238,31 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       let delta = angleOf(moveHit) - initialAngle
       while (delta > Math.PI) delta -= 2 * Math.PI
       while (delta < -Math.PI) delta += 2 * Math.PI
-      if (e.shiftKey) delta = Math.round(delta / ROTATE_SNAP) * ROTATE_SNAP
-
-      // Orbit each node's anchor point(s) CCW by `delta` (atan2 x→z sense) and
-      // turn its yaw by `-delta` to match three.js Y-rotation handedness (same
-      // convention as the single-item rotate handle in item/definition.ts).
-      // Endpoint nodes (walls/fences) have no yaw — swinging both endpoints
-      // around the pivot rotates them rigidly; their curveOffset sagitta is
-      // rotation-invariant, so arcs are preserved.
-      const cos = Math.cos(delta)
-      const sin = Math.sin(delta)
-      const rot = (x: number, z: number): Vec2 => {
-        const dx = x - localCenter.x
-        const dz = z - localCenter.z
-        return [localCenter.x + dx * cos - dz * sin, localCenter.z + dx * sin + dz * cos]
-      }
-      const overrideEntries: Array<readonly [string, Record<string, unknown>]> = []
+      if (!e.shiftKey) delta = Math.round(delta / DEFAULT_ANGLE_STEP) * DEFAULT_ANGLE_STEP
+
+      // Shared rigid-rotation math (also used by the keyboard group R/T);
+      // see `rotateGroupPatches` for the orbit/yaw handedness contract.
+      const overrideEntries = rotateGroupPatches(
+        starts,
+        links,
+        { x: localCenter.x, z: localCenter.z },
+        delta,
+      )
+      const patchById = new Map(overrideEntries)
       const liveTransforms = useLiveTransforms.getState()
       for (const s of starts) {
-        if (s.kind === 'endpoint') {
-          overrideEntries.push([
-            s.id,
-            { start: rot(s.start[0], s.start[1]), end: rot(s.end[0], s.end[1]) },
-          ])
-        } else {
-          const [px, pz] = rot(s.position[0], s.position[2])
-          const position: Vec3 = [px, s.position[1], pz]
-          const rotation =
-            s.kind === 'vec3'
-              ? ([s.rotation[0], s.rotation[1] - delta, s.rotation[2]] as Vec3)
-              : s.rotation - delta
-          overrideEntries.push([s.id, { position, rotation }])
-          if (s.kind === 'scalar') {
-            liveTransforms.set(s.id, { position, rotation: s.rotation - delta })
+        if (s.kind === 'scalar') {
+          const patch = patchById.get(s.id)
+          if (patch) {
+            liveTransforms.set(s.id, {
+              position: patch.position as Vec3,
+              rotation: patch.rotation as number,
+            })
           }
         }
         useScene.getState().markDirty(s.id)
       }
-
-      // Drag each linked neighbour's shared endpoint to the same rotated spot
-      // (rot is deterministic, so it lands exactly on the selected wall's
-      // rotated endpoint), keeping the junction welded; the far end stays put.
       for (const l of links) {
-        overrideEntries.push([
-          l.id,
-          {
-            start: l.startLinked ? rot(l.start[0], l.start[1]) : l.start,
-            end: l.endLinked ? rot(l.end[0], l.end[1]) : l.end,
-          },
-        ])
         useScene.getState().markDirty(l.id)
       }
       useLiveNodeOverrides.getState().setMany(overrideEntries)
@@ -289,9 +302,13 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       window.removeEventListener('pointermove', onMove)
       window.removeEventListener('pointerup', onUp)
       window.removeEventListener('pointercancel', onCancel)
+      window.removeEventListener('keydown', onKeyDown, true)
       if (document.body.style.cursor === 'grabbing') document.body.style.cursor = ''
       useScene.temporal.getState().resume()
       useViewer.getState().setInputDragging(false)
+      useInteractionScope
+        .getState()
+        .endIf((s) => s.kind === 'handle-drag' && s.handle === GROUP_ROTATE_DRAG_LABEL)
       setIsDragging(false)
       setGuide(null)
       frozenRest.current = null
@@ -316,8 +333,12 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       const updates = commitFromOverrides()
       // Resume before the commit so the single batched `updateNodes` is the
       // one tracked set — collapsing the whole group rotation into one undo.
+      // Space detection stays out: a rigid rotation of existing walls must
+      // not re-create the room's auto floors/ceilings at the new bearing.
+      pauseSpaceDetection()
       useScene.temporal.getState().resume()
       if (updates.length > 0) useScene.getState().updateNodes(updates)
+      resumeSpaceDetection()
       clearLivePreviews()
       cleanup()
     }
@@ -328,6 +349,16 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
       cleanup()
     }
 
+    // Escape / ⌘Z abort the rotate — capture phase so they win over the global
+    // use-keyboard arms (⌘Z must never history-jump under a live pointer).
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key !== 'Escape' && !isHistoryShortcut(e)) return
+      e.preventDefault()
+      e.stopPropagation()
+      swallowNextClick()
+      onCancel()
+    }
+
     dragCleanupRef.current = () => {
       clearLivePreviews()
       cleanup()
@@ -338,6 +369,7 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
     window.addEventListener('pointermove', onMove)
     window.addEventListener('pointerup', onUp)
     window.addEventListener('pointercancel', onCancel)
+    window.addEventListener('keydown', onKeyDown, true)
   }
 
   return createPortal(
@@ -348,27 +380,33 @@ function GroupRotateHandleInner({ ids }: { ids: string[] }) {
         </group>
       )}
       <group position={[corner.x, corner.y, corner.z]}>
-        <InvisibleHandleHitArea
+        {/* Fat invisible grab target (torus wrapping the arrow). A plain
+            default-layer mesh with the standard raycast — the shared
+            `InvisibleHandleHitArea` (EDITOR_LAYER + custom raycast) never
+            received pointer events in this portalled context: R3F's
+            `createPortal` gives the portal root its own fresh `Raycaster`
+            (default mask = layer 0 only), so the EDITOR_LAYER enable applied
+            to the root raycaster in `custom-camera-controls` never reaches
+            it. Harmless render-wise — the material is colorWrite:false /
+            depthWrite:false, so nothing leaks into thumbnails or the ink
+            pass. A proper fix would enable EDITOR_LAYER on the portal
+            raycaster from inside the portal. */}
+        <mesh
+          frustumCulled={false}
           geometry={hitGeometry}
           material={hitMaterial}
           onPointerDown={activate}
-          onPointerEnter={(event) => {
-            event.stopPropagation()
-            setIsHovered(true)
-            if (document.body.style.cursor !== 'grabbing') document.body.style.cursor = 'grab'
-          }}
-          onPointerLeave={(event) => {
-            event.stopPropagation()
-            setIsHovered(false)
-            if (document.body.style.cursor === 'grab') document.body.style.cursor = ''
-          }}
+          onPointerEnter={onHoverEnter}
+          onPointerLeave={onHoverLeave}
           scale={baseScale}
         />
         <mesh
           frustumCulled={false}
           geometry={arrowGeometry}
           material={arrowMaterial}
-          raycast={NO_RAYCAST}
+          onPointerDown={activate}
+          onPointerEnter={onHoverEnter}
+          onPointerLeave={onHoverLeave}
           renderOrder={1010}
           scale={scale}
         />

package/src/components/editor/group-selection-box-3d.tsx

@@ -0,0 +1,173 @@
+'use client'
+
+import { type AnyNodeId, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { type ThreeEvent, useThree } from '@react-three/fiber'
+import { useEffect, useMemo } from 'react'
+import * as THREE from 'three'
+import useEditor from '../../store/use-editor'
+import { useMovingNode } from '../../store/use-interaction-scope'
+import { useFloorplanGroupDrag } from '../editor-2d/floorplan-group-move'
+import { armGroupMove3d } from './group-move-3d'
+import {
+  classifyParticipant,
+  computeGroupBox,
+  expandToComponent,
+  levelFrame,
+} from './group-transform-shared'
+import { useMeshSettleEpoch } from './use-mesh-settle-epoch'
+
+// Matches the 2D dashed selection box's stroke.
+const BOX_COLOR = '#3b82f6'
+// Small clearance so the dashes don't z-fight the selection's outer faces.
+const BOX_PAD = 0.06
+
+/**
+ * 3D sibling of the 2D dashed group selection box: a dashed wireframe around
+ * the multi-selection's transformable participants (expanded to the welded
+ * wall/fence component) that doubles as the group's whole-volume drag
+ * handle — move cursor across it, press-drag anywhere on it slides the group,
+ * a plain click picks it up. Holding a selection modifier passes the press
+ * through so members inside can still be toggled. Rides the live drag delta
+ * so it tracks the group mid-gesture.
+ */
+export function GroupSelectionBox3D() {
+  const selectedIds = useViewer((s) => s.selection.selectedIds)
+  const levelId = useViewer((s) => s.selection.levelId)
+  const nodes = useScene((s) => s.nodes)
+  const mode = useEditor((s) => s.mode)
+  const movingNode = useMovingNode()
+  const delta = useFloorplanGroupDrag((s) => s.delta)
+  const { camera, raycaster, gl } = useThree()
+
+  const participantIds = useMemo(
+    () =>
+      selectedIds.length > 1
+        ? selectedIds.filter(
+            (id) => classifyParticipant(nodes[id as AnyNodeId], levelId, nodes) !== null,
+          )
+        : [],
+    [selectedIds, levelId, nodes],
+  )
+
+  // Re-measure once the meshes settle after a scene change (undo included).
+  const meshEpoch = useMeshSettleEpoch(nodes)
+  const box = useMemo(() => {
+    if (participantIds.length === 0) return null
+    const fullIds = expandToComponent(participantIds, nodes, levelId)
+    const world = computeGroupBox(fullIds)
+    if (!world) return null
+    const size = new THREE.Vector3()
+    world.getSize(size)
+    const center = new THREE.Vector3()
+    world.getCenter(center)
+    return {
+      size: [size.x + 2 * BOX_PAD, size.y + 2 * BOX_PAD, size.z + 2 * BOX_PAD] as [
+        number,
+        number,
+        number,
+      ],
+      center,
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: meshEpoch re-measures settled meshes
+  }, [participantIds, nodes, levelId, meshEpoch])
+
+  // Dashed wireframe. Built per box size (rare — selection / commit changes)
+  // because LineDashedMaterial measures dashes along the line, so scaling a
+  // unit box would stretch them per axis.
+  const edges = useMemo(() => {
+    if (!box) return null
+    const geometry = new THREE.EdgesGeometry(new THREE.BoxGeometry(...box.size))
+    const line = new THREE.LineSegments(
+      geometry,
+      new THREE.LineDashedMaterial({
+        color: BOX_COLOR,
+        dashSize: 0.18,
+        gapSize: 0.12,
+        opacity: 0.9,
+        transparent: true,
+      }),
+    )
+    line.computeLineDistances()
+    return line
+  }, [box])
+  useEffect(
+    () => () => {
+      if (edges) {
+        edges.geometry.dispose()
+        ;(edges.material as THREE.Material).dispose()
+      }
+    },
+    [edges],
+  )
+
+  // Mid-drag the sessions publish a level-frame delta; map it to world so the
+  // box rides the group (shared with the 2D box's store).
+  const worldOffset = useMemo(() => {
+    if (!delta) return null
+    const { matrix } = levelFrame(levelId)
+    const origin = new THREE.Vector3().applyMatrix4(matrix)
+    return new THREE.Vector3(delta[0], 0, delta[1]).applyMatrix4(matrix).sub(origin)
+  }, [delta, levelId])
+
+  if (!box || !edges || movingNode || mode !== 'select') return null
+
+  const handlePointerDown = (event: ThreeEvent<PointerEvent>) => {
+    const native = event.nativeEvent
+    if (native.button !== 0) return
+    // A selection modifier passes through so members inside the box can
+    // still be toggled in and out of the selection.
+    if (native.metaKey || native.ctrlKey || native.shiftKey || native.altKey) return
+    const { selectedIds: currentIds, levelId: currentLevelId } = useViewer.getState().selection
+    const sceneNodes = useScene.getState().nodes
+    const anchor = currentIds.find(
+      (id) => classifyParticipant(sceneNodes[id as AnyNodeId], currentLevelId, sceneNodes) !== null,
+    )
+    if (!anchor) return
+    const armed = armGroupMove3d({
+      nodeId: anchor as AnyNodeId,
+      clientX: native.clientX,
+      clientY: native.clientY,
+      pointerId: native.pointerId,
+      nativeEvent: native,
+      camera,
+      raycaster,
+      domElement: gl.domElement,
+    })
+    // Own the press: deeper hits (members, ground) must not also select.
+    if (armed) event.stopPropagation()
+  }
+
+  // Set on move (not just enter): the canvas may carry an app default
+  // cursor, and member hovers inside the box write theirs — keep 'move'
+  // asserted across the whole volume, except while a drag shows 'grabbing'.
+  const applyMoveCursor = () => {
+    const cursor = gl.domElement.style.cursor
+    if (cursor !== 'move' && cursor !== 'grabbing') gl.domElement.style.cursor = 'move'
+  }
+  const handlePointerLeave = () => {
+    if (gl.domElement.style.cursor === 'move') gl.domElement.style.cursor = ''
+  }
+
+  const position: [number, number, number] = [
+    box.center.x + (worldOffset?.x ?? 0),
+    box.center.y + (worldOffset?.y ?? 0),
+    box.center.z + (worldOffset?.z ?? 0),
+  ]
+
+  return (
+    <group position={position}>
+      <primitive object={edges} />
+      {/* Invisible whole-volume hit target — the box IS the drag handle. */}
+      <mesh
+        onPointerDown={handlePointerDown}
+        onPointerEnter={applyMoveCursor}
+        onPointerLeave={handlePointerLeave}
+        onPointerMove={applyMoveCursor}
+      >
+        <boxGeometry args={box.size} />
+        <meshBasicMaterial depthWrite={false} opacity={0} transparent />
+      </mesh>
+    </group>
+  )
+}

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

@@ -1,7 +1,12 @@
 import { beforeAll, describe, expect, test } from 'bun:test'
 import { type AnyNode, type AnyNodeDefinition, nodeRegistry, registerNode } from '@pascal-app/core'
 import { z } from 'zod'
-import { classifyParticipant, collectParticipants } from './group-transform-shared'
+import {
+  classifyParticipant,
+  collectParticipants,
+  rotateGroupPatches,
+  translateGroupPatches,
+} from './group-transform-shared'
 
 const BUILDING_SCOPED_KIND = 'group-transform-building-scoped-test'
 
@@ -171,6 +176,192 @@ describe('group transform participants', () => {
     ])
   })
 
+  test('classifies and transforms polygon kinds (slab / ceiling / zone)', () => {
+    const nodes = {
+      building_test: {
+        id: 'building_test',
+        type: 'building',
+        children: ['level_test'],
+      },
+      level_test: {
+        id: 'level_test',
+        type: 'level',
+        parentId: 'building_test',
+        children: ['slab_test', 'zone_test'],
+      },
+      slab_test: {
+        id: 'slab_test',
+        type: 'slab',
+        parentId: 'level_test',
+        polygon: [
+          [0, 0],
+          [2, 0],
+          [2, 2],
+          [0, 2],
+        ],
+        holes: [
+          [
+            [0.5, 0.5],
+            [1, 0.5],
+            [1, 1],
+          ],
+        ],
+      },
+      zone_test: {
+        id: 'zone_test',
+        type: 'zone',
+        parentId: 'level_test',
+        polygon: [
+          [0, 0],
+          [1, 0],
+          [1, 1],
+        ],
+      },
+      slab_elsewhere: {
+        id: 'slab_elsewhere',
+        type: 'slab',
+        parentId: 'level_other',
+        polygon: [
+          [0, 0],
+          [1, 0],
+          [1, 1],
+        ],
+      },
+    } as unknown as Record<string, AnyNode>
+
+    expect(classifyParticipant(nodes.slab_test, 'level_test', nodes)).toBe('polygon')
+    expect(classifyParticipant(nodes.zone_test, 'level_test', nodes)).toBe('polygon')
+    // Not in the active level frame → excluded.
+    expect(classifyParticipant(nodes.slab_elsewhere, 'level_test', nodes)).toBeNull()
+
+    const { starts, links } = collectParticipants(['slab_test', 'zone_test'], nodes, 'level_test')
+    expect(links).toEqual([])
+    expect(starts).toEqual([
+      {
+        id: 'slab_test',
+        kind: 'polygon',
+        polygon: [
+          [0, 0],
+          [2, 0],
+          [2, 2],
+          [0, 2],
+        ],
+        holes: [
+          [
+            [0.5, 0.5],
+            [1, 0.5],
+            [1, 1],
+          ],
+        ],
+      },
+      {
+        id: 'zone_test',
+        kind: 'polygon',
+        polygon: [
+          [0, 0],
+          [1, 0],
+          [1, 1],
+        ],
+        holes: null,
+      },
+    ])
+
+    // Translate: every vertex (holes included) shifts; the hole-less zone's
+    // patch never grows a `holes` field.
+    const moved = translateGroupPatches(starts, [], 1, -2)
+    expect(moved).toEqual([
+      [
+        'slab_test',
+        {
+          polygon: [
+            [1, -2],
+            [3, -2],
+            [3, 0],
+            [1, 0],
+          ],
+          holes: [
+            [
+              [1.5, -1.5],
+              [2, -1.5],
+              [2, -1],
+            ],
+          ],
+        },
+      ],
+      [
+        'zone_test',
+        {
+          polygon: [
+            [1, -2],
+            [2, -2],
+            [2, -1],
+          ],
+        },
+      ],
+    ])
+
+    // Rotate 90° in the atan2 x→z sense around the origin: (x, z) → (-z, x).
+    const rotated = rotateGroupPatches(
+      starts.filter((s) => s.id === 'zone_test'),
+      [],
+      { x: 0, z: 0 },
+      Math.PI / 2,
+    )
+    expect(rotated).toHaveLength(1)
+    const rotatedPolygon = (rotated[0]![1] as { polygon: [number, number][] }).polygon
+    const expected = [
+      [0, 0],
+      [0, 1],
+      [-1, 1],
+    ]
+    rotatedPolygon.forEach((point, i) => {
+      expect(point[0]).toBeCloseTo(expected[i]![0]!)
+      expect(point[1]).toBeCloseTo(expected[i]![1]!)
+    })
+  })
+
+  test('polygon hosts carry their attached positioned children (ceiling items)', () => {
+    const nodes = {
+      building_test: { id: 'building_test', type: 'building', children: ['level_test'] },
+      level_test: {
+        id: 'level_test',
+        type: 'level',
+        parentId: 'building_test',
+        children: ['ceiling_test'],
+      },
+      ceiling_test: {
+        id: 'ceiling_test',
+        type: 'ceiling',
+        parentId: 'level_test',
+        children: ['item_lamp'],
+        polygon: [
+          [0, 0],
+          [2, 0],
+          [2, 2],
+          [0, 2],
+        ],
+      },
+      item_lamp: {
+        id: 'item_lamp',
+        type: 'item',
+        parentId: 'ceiling_test',
+        position: [1, 2.4, 1],
+        rotation: [0, 0.5, 0],
+      },
+    } as unknown as Record<string, AnyNode>
+
+    // The lamp itself is not level-parented, so it is not an independent
+    // participant — it rides its host ceiling.
+    expect(classifyParticipant(nodes.item_lamp, 'level_test', nodes)).toBeNull()
+
+    const { starts } = collectParticipants(['ceiling_test'], nodes, 'level_test')
+    expect(starts.map((s) => s.id).sort()).toEqual(['ceiling_test', 'item_lamp'])
+
+    const moved = translateGroupPatches(starts, [], 2, 1)
+    const lampPatch = Object.fromEntries(moved).item_lamp as { position: [number, number, number] }
+    expect(lampPatch.position).toEqual([3, 2.4, 2])
+  })
+
   test('supports legacy level-parented elevators already loaded in the editor', () => {
     const nodes = {
       building_test: {