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

package/src/components/editor-2d/floorplan-registry-move-overlay.tsx

@@ -6,8 +6,11 @@ import {
   type AnyNodeId,
   bboxAnchors,
   bboxCornerAnchors,
+  createSceneApi,
   emitter,
   type FloorplanMoveTargetSession,
+  type GroupMoveSnapResult,
+  type MovableConfig,
   nodeRegistry,
   pauseSceneHistory,
   resumeSceneHistory,
@@ -20,7 +23,11 @@ import { useEffect } from 'react'
 import { commitFreshPlacementSubtree } from '../../lib/fresh-planar-placement'
 import { isHistoryShortcut } from '../../lib/history'
 import { isFreshPlacementMetadata, stripPlacementMetadataFlags } from '../../lib/placement-metadata'
-import { resolvePlanarCursorPosition } from '../../lib/planar-cursor-placement'
+import { resolvePrioritizedPlanarCursorPosition } from '../../lib/planar-cursor-placement'
+import {
+  resolveAttachmentPreviewRotation,
+  rigidPlanSvgTransform,
+} from '../../lib/rigid-plan-svg-transform'
 import { movementSfxStepKey } from '../../lib/sfx/movement-tick'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import { resolveAlignmentForFloorplanView } from '../../lib/world-grid-snap'
@@ -104,12 +111,14 @@ export function FloorplanRegistryMoveOverlay() {
     // ── Path 1 — kind-owned `floorplanMoveTarget` ───────────────────
     if (hasMoveTarget && def?.floorplanMoveTarget) {
       const sceneNodes = useScene.getState().nodes
+      const sceneApi = createSceneApi(useScene)
       const session: FloorplanMoveTargetSession = (
         def.floorplanMoveTarget as (a: {
           node: AnyNode
           nodes: Record<AnyNodeId, AnyNode>
+          sceneApi: ReturnType<typeof createSceneApi>
         }) => FloorplanMoveTargetSession
-      )({ node: movingNode, nodes: sceneNodes })
+      )({ node: movingNode, nodes: sceneNodes, sceneApi })
 
       // Capture snapshots of every affected node BEFORE the first apply
       // so the single-undo dance has a clean baseline to revert to.
@@ -544,8 +553,19 @@ export function FloorplanRegistryMoveOverlay() {
       candidateAnchors.push(...bboxAnchors(otherId, b.x, b.y, b.x + b.width, b.y + b.height))
     }
 
-    let lastSnapped: [number, number] | null = null
+    const storedRotation = (movingNode as { rotation?: unknown }).rotation
+    const originalRotation =
+      typeof storedRotation === 'number'
+        ? storedRotation
+        : Array.isArray(storedRotation)
+          ? ((storedRotation as [number?, number?, number?])[1] ?? 0)
+          : 0
+    let currentRotation = originalRotation
+    let lastSnapped: { point: [number, number]; rotation: number } | null = null
     let dragAnchor: [number, number] | null = null
+    let lastPositionValid = true
+    let forcePlace = false
+    const movableValidityConfig = (def?.capabilities?.movable as MovableConfig | undefined) ?? null
 
     // Footprint bounding box drawn around the dragged entry — the 2D
     // counterpart of the 3D `DragBoundingBox`, so a moved / duplicated node
@@ -572,22 +592,74 @@ export function FloorplanRegistryMoveOverlay() {
       if (!isPointerOverFloorplanScene(event.clientX, event.clientY)) return
       const m = toMeters(event.clientX, event.clientY)
       if (!m) return
+      forcePlace = event.altKey
 
-      // 1) Grid snap baseline. Fresh catalog placement is absolute under
-      // the cursor; existing moves preserve the cursor's grab offset. Grid
-      // follows the active snapping mode (Shift cycles it); raw cursor in
-      // any non-grid mode.
+      // 1) Wall attachment gets the raw proposal before grid/alignment. If no
+      // attachment is available, fresh placement is absolute under the cursor
+      // and existing moves preserve the cursor's grab offset before grid snap.
       const gridStep = useEditor.getState().gridSnapStep
       const snap = (value: number) =>
         isGridSnapActive() ? Math.round(value / gridStep) * gridStep : value
-      const resolved = resolvePlanarCursorPosition({
+      const groupMoveSnap = def?.capabilities?.movable?.groupMoveSnap
+      const groupMoveSnapPose = def?.capabilities?.movable?.groupMoveSnapPose
+      const gridSnapPosition = def?.capabilities?.movable?.gridSnapPosition
+      const attachmentEnabled = isGridSnapActive() || isMagneticSnapActive()
+      let attachmentRotation: number | null = null
+      const resolved = resolvePrioritizedPlanarCursorPosition({
         cursor: [m[0], m[1]],
         original: [originalPosition[0], originalPosition[2]],
         anchor: dragAnchor,
         mode: isFreshPlacement ? 'absolute' : 'relative',
-        snap,
+        snap: gridSnapPosition ? undefined : snap,
+        snapPoint:
+          isGridSnapActive() && gridSnapPosition
+            ? ([planX, planZ]) => {
+                const snappedPosition = gridSnapPosition({
+                  node: movingNode,
+                  candidatePosition: [planX, originalPosition[1], planZ],
+                  candidateRotation: originalRotation,
+                  movingIds: [movingNode.id as AnyNodeId],
+                  nodes: useScene.getState().nodes as Record<string, AnyNode>,
+                  levelId:
+                    (useViewer.getState().selection.levelId as AnyNodeId | null) ??
+                    (movingNode.parentId as AnyNodeId | undefined) ??
+                    null,
+                  gridStep,
+                })
+                return [snappedPosition[0], snappedPosition[2]]
+              }
+            : undefined,
+        resolveAttachment:
+          attachmentEnabled && (groupMoveSnapPose || groupMoveSnap)
+            ? ([planX, planZ]) => {
+                const snapArgs: Parameters<NonNullable<typeof groupMoveSnapPose>>[0] = {
+                  node: movingNode,
+                  candidatePosition: [planX, originalPosition[1], planZ],
+                  candidateRotation: currentRotation,
+                  movingIds: [movingNode.id as AnyNodeId],
+                  nodes: useScene.getState().nodes as Record<string, AnyNode>,
+                  levelId:
+                    (useViewer.getState().selection.levelId as AnyNodeId | null) ??
+                    (movingNode.parentId as AnyNodeId | undefined) ??
+                    null,
+                }
+                const snappedPosition: GroupMoveSnapResult | null = groupMoveSnapPose
+                  ? groupMoveSnapPose(snapArgs)
+                  : (() => {
+                      const position = groupMoveSnap?.(snapArgs)
+                      return position ? { position } : null
+                    })()
+                if (!snappedPosition) return null
+                attachmentRotation = snappedPosition.rotation ?? null
+                return [snappedPosition.position[0], snappedPosition.position[2]]
+              }
+            : undefined,
       })
       dragAnchor = resolved.anchor
+      currentRotation = resolveAttachmentPreviewRotation(
+        originalRotation,
+        resolved.attachmentSnapped ? attachmentRotation : null,
+      )
       const [gridX, gridZ] = resolved.point
 
       // 2) Alignment snap layered on top. Treat the grid-snapped point
@@ -598,7 +670,7 @@ export function FloorplanRegistryMoveOverlay() {
       // force-place, not a snap bypass.
       let finalX = gridX
       let finalZ = gridZ
-      if (isAlignmentGuideActive() && candidateAnchors.length > 0) {
+      if (!resolved.attachmentSnapped && isAlignmentGuideActive() && candidateAnchors.length > 0) {
         // Translate the cached local bbox to the proposed pos to get the
         // moving anchors at that location. The entry's untransformed
         // bbox is in world meters relative to the node's origin, so a
@@ -635,35 +707,35 @@ export function FloorplanRegistryMoveOverlay() {
         useAlignmentGuides.getState().clear()
       }
 
-      // 3) Kind-owned attachment snap (cabinet → wall) — 2D parity with the
-      // 3D move tool's `groupMoveSnap` pass. An attach behavior, not an
-      // alignment guide, so it runs in every snapping mode except Off.
-      const groupMoveSnap = def?.capabilities?.movable?.groupMoveSnap
-      if (groupMoveSnap && (isGridSnapActive() || isMagneticSnapActive())) {
-        const snappedPosition = groupMoveSnap({
-          node: movingNode,
-          candidatePosition: [finalX, originalPosition[1], finalZ],
-          movingIds: [movingNode.id as AnyNodeId],
-          nodes: useScene.getState().nodes as Record<string, AnyNode>,
-          levelId:
-            (useViewer.getState().selection.levelId as AnyNodeId | null) ??
-            (movingNode.parentId as AnyNodeId | undefined) ??
-            null,
-        })
-        if (snappedPosition) {
-          finalX = snappedPosition[0]
-          finalZ = snappedPosition[2]
-          useAlignmentGuides.getState().clear()
-        }
-      }
-
-      const dx = finalX - originalPosition[0]
-      const dz = finalZ - originalPosition[2]
+      const transform = rigidPlanSvgTransform({
+        from: [originalPosition[0], originalPosition[2]],
+        fromRotation: originalRotation,
+        to: [finalX, finalZ],
+        toRotation: currentRotation,
+      })
       for (const relatedEntry of relatedEntries) {
-        relatedEntry.setAttribute('transform', `translate(${dx} ${dz})`)
+        relatedEntry.setAttribute('transform', transform)
       }
-      boxEl.setAttribute('transform', `translate(${dx} ${dz})`)
-      lastSnapped = [finalX, finalZ]
+      boxEl.setAttribute('transform', transform)
+      const oldY = originalPosition[1]
+      lastPositionValid = movableValidityConfig?.isValidPosition
+        ? movableValidityConfig.isValidPosition({
+            node: {
+              ...movingNode,
+              position: [finalX, oldY, finalZ],
+              rotation: currentRotation,
+            } as AnyNode,
+            position: [finalX, oldY, finalZ],
+            rotation: currentRotation,
+            levelId:
+              (useViewer.getState().selection.levelId as AnyNodeId | null) ??
+              (movingNode.parentId as AnyNodeId | null) ??
+              null,
+            nodes: useScene.getState().nodes as Record<string, AnyNode>,
+          })
+        : true
+      boxEl.setAttribute('stroke', lastPositionValid || forcePlace ? '#22c55e' : '#ef4444')
+      lastSnapped = { point: [finalX, finalZ], rotation: currentRotation }
     }
 
     const onPointerUp = (event: PointerEvent) => {
@@ -672,9 +744,26 @@ export function FloorplanRegistryMoveOverlay() {
 
       const snapped = lastSnapped
       if (!snapped) return
-      const [sx, sz] = snapped
+      const [sx, sz] = snapped.point
       const [, oldY] = originalPosition
+      const rotation = Array.isArray(storedRotation)
+        ? [
+            (storedRotation as [number?, number?, number?])[0] ?? 0,
+            snapped.rotation,
+            (storedRotation as [number?, number?, number?])[2] ?? 0,
+          ]
+        : snapped.rotation
+      const rotationPatch = 'rotation' in movingNode ? { rotation } : {}
       setMovingNodeOrigin('2d')
+      if (!lastPositionValid && !forcePlace) {
+        for (const relatedEntry of relatedEntries) {
+          relatedEntry.removeAttribute('transform')
+        }
+        useAlignmentGuides.getState().clear()
+        setMovingNode(null)
+        swallowNextClick()
+        return
+      }
       let selectedId = movingNode.id as AnyNodeId
       if (originalPath) {
         // Polyline kinds: shift every point by the committed delta and
@@ -711,6 +800,7 @@ export function FloorplanRegistryMoveOverlay() {
             movingNode.id as AnyNodeId,
             {
               position: [sx, oldY, sz],
+              ...rotationPatch,
               metadata: stripPlacementMetadataFlags(
                 (movingNode as { metadata?: unknown }).metadata,
               ),
@@ -722,6 +812,7 @@ export function FloorplanRegistryMoveOverlay() {
           movingNode.id as AnyNodeId,
           {
             position: [sx, oldY, sz],
+            ...rotationPatch,
           } as Partial<AnyNode>,
         )
       }

package/src/components/editor-2d/renderers/floorplan-dimension-renderer.tsx

@@ -161,12 +161,14 @@ export function FloorplanDimensionRenderer({
   stroke = geometry.stroke ?? '#334155',
   annotationUnitsPerPoint,
   renderMode = 'screen',
+  onSelect,
 }: {
   geometry: DimensionGeometry
   sceneRotationDeg?: number
   stroke?: string
   annotationUnitsPerPoint?: number
   renderMode?: FloorplanDimensionRenderMode
+  onSelect?: () => void
 }): React.ReactElement | null {
   const layout = computeArchitecturalDimensionLayout(
     geometry,
@@ -200,7 +202,18 @@ export function FloorplanDimensionRenderer({
     : undefined
 
   return (
-    <g data-floorplan-dimension="" pointerEvents="none">
+    <g
+      data-floorplan-dimension=""
+      onClick={
+        onSelect
+          ? (event) => {
+              event.stopPropagation()
+              onSelect()
+            }
+          : undefined
+      }
+      pointerEvents={onSelect ? 'auto' : 'none'}
+    >
       <line
         {...lineProps}
         x1={layout.extensionStart[0]}

package/src/components/editor-2d/renderers/floorplan-geometry-renderer.test.tsx

@@ -366,4 +366,20 @@ describe('FloorplanGeometryRenderer static labels', () => {
     expect(markup).toContain('data-floorplan-annotation-obstacle="bounds"')
     expect(markup).toContain('data-floorplan-annotation-obstacle="outline"')
   })
+  test('forwards even-odd fill rules for compound plugin paths', () => {
+    const geometry = {
+      kind: 'path',
+      d: 'M0,0H4V4H0ZM1,1H3V3H1Z',
+      fill: '#3f6b2f',
+      fillRule: 'evenodd',
+    } satisfies FloorplanGeometry
+
+    const markup = renderToStaticMarkup(
+      <svg>
+        <FloorplanGeometryRenderer geometry={geometry} />
+      </svg>,
+    )
+
+    expect(markup).toContain('fill-rule="evenodd"')
+  })
 })

package/src/components/editor-2d/renderers/floorplan-geometry-renderer.tsx

@@ -83,6 +83,7 @@ function styleAttrs(
   // filtered out by the caller's type bound).
   const s = g as unknown as {
     fill?: string
+    fillRule?: 'nonzero' | 'evenodd'
     fillOpacity?: number
     stroke?: string
     strokeWidth?: number
@@ -109,6 +110,7 @@ function styleAttrs(
     'data-floorplan-annotation-obstacle': floorplanAnnotationObstacleMode(g),
     'data-floorplan-annotation-role': annotationMetadata.annotationRole,
     fill: documentStyle.fill ?? s.fill ?? 'none',
+    fillRule: s.fillRule,
     fillOpacity: s.fillOpacity,
     stroke: documentStyle.stroke ?? s.stroke,
     strokeWidth,

package/src/components/editor-2d/renderers/floorplan-placement-preview-layer.tsx

@@ -10,13 +10,16 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { memo, useMemo } from 'react'
+import { formatLinearMeasurement } from '../../../lib/measurements'
 import usePlacementPreview from '../../../store/use-placement-preview'
-import { useFloorplanRender } from '../floorplan-render-context'
+import { useFloorplanRender, useFloorplanSceneRotation } from '../floorplan-render-context'
+import { FloorplanDimensionRenderer } from './floorplan-dimension-renderer'
 import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
 
 export interface FloorplanNodePreviewProps {
   node: AnyNode
   parentNode?: AnyNode | null
+  contextNodes?: AnyNode[]
   opacity?: number
   className?: string
   selected?: boolean
@@ -33,6 +36,7 @@ export interface FloorplanNodePreviewProps {
 export const FloorplanNodePreview = memo(function FloorplanNodePreview({
   node,
   parentNode = null,
+  contextNodes: previewContextNodes = [],
   opacity = 0.5,
   className,
   selected = false,
@@ -53,6 +57,9 @@ export const FloorplanNodePreview = memo(function FloorplanNodePreview({
       ...(nodes as Record<string, AnyNode>),
       [node.id]: node,
     }
+    for (const previewNode of previewContextNodes) {
+      contextNodes[previewNode.id] = previewNode
+    }
     if (parentNode) contextNodes[parentNode.id] = parentNode
     const resolvedParent =
       parentNode ?? (node.parentId ? (contextNodes[node.parentId] ?? null) : null)
@@ -90,7 +97,18 @@ export const FloorplanNodePreview = memo(function FloorplanNodePreview({
     }
 
     return (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(node, ctx)
-  }, [highlighted, hovered, moving, node, nodes, parentNode, renderContext, selected, unit])
+  }, [
+    highlighted,
+    hovered,
+    moving,
+    node,
+    nodes,
+    parentNode,
+    previewContextNodes,
+    renderContext,
+    selected,
+    unit,
+  ])
   if (!geometry) return null
 
   return (
@@ -117,11 +135,42 @@ export const FloorplanNodePreview = memo(function FloorplanNodePreview({
 export const FloorplanPlacementPreviewLayer = memo(function FloorplanPlacementPreviewLayer() {
   const node = usePlacementPreview((s) => s.node)
   const parentNode = usePlacementPreview((s) => s.parentNode)
+  const contextNodes = usePlacementPreview((s) => s.contextNodes)
+  const dimensions = usePlacementPreview((s) => s.dimensions)
+  const activeDimensionId = usePlacementPreview((s) => s.activeDimensionId)
+  const dimensionInput = usePlacementPreview((s) => s.dimensionInput)
+  const unit = useViewer((s) => s.unit)
+  const metricNotation = useViewer((s) => s.metricNotation)
+  const sceneRotationDeg = useFloorplanSceneRotation()
   if (!node) return null
 
   return (
     <g data-floorplan-placement-preview>
-      <FloorplanNodePreview node={node} parentNode={parentNode} />
+      <FloorplanNodePreview contextNodes={contextNodes} node={node} parentNode={parentNode} />
+      <g data-floorplan-placement-dimensions>
+        {dimensions
+          .filter((dimension) => dimension.renderInFloorplan !== false)
+          .map((dimension) => (
+            <FloorplanDimensionRenderer
+              geometry={{
+                kind: 'dimension',
+                start: [dimension.start[0], dimension.start[2]],
+                end: [dimension.end[0], dimension.end[2]],
+                offsetNormal: dimension.offsetNormal,
+                offsetDistance: dimension.offsetDistance,
+                extensionOvershoot: 0.04,
+                text:
+                  dimension.id === activeDimensionId && dimensionInput
+                    ? dimensionInput
+                    : formatLinearMeasurement(dimension.value, unit, metricNotation),
+                stroke: '#6366f1',
+              }}
+              key={dimension.id}
+              onSelect={() => usePlacementPreview.getState().selectDimension(dimension.id)}
+              sceneRotationDeg={sceneRotationDeg}
+            />
+          ))}
+      </g>
     </g>
   )
 })

package/src/components/editor-2d/renderers/floorplan-registry-layer.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 import type {
   AnyNode,
   AnyNodeId,
@@ -16,7 +16,9 @@ import {
   floorplanGeometryMetadata,
 } from '../../../lib/floorplan/floorplan-extension'
 import {
+  buildFloorplanEntryGeometry,
   cancelFloorplanAffordanceDrag,
+  collectDirectFloorplanScopeNodes,
   collectFloorplanDependencyNodes,
   collectFloorplanLinkedLevelNodes,
   computeAffectedSiblingIds,
@@ -25,10 +27,185 @@ import {
   InteractiveGeometry,
   isFloorplanOpeningPlacementState,
   resolveFloorplanHandleUnitsPerPixel,
+  siteToFloorplanTransform,
   splitFloorplanOverlay,
   subscribeFloorplanAffordanceToolCancel,
 } from './floorplan-registry-layer'
 
+describe('site-scoped floorplan discovery', () => {
+  let restoreRegistry: () => void
+
+  beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    registerNode({
+      kind: 'test:site-overlay',
+      schemaVersion: 1,
+      schema: z.object({ type: z.literal('test:site-overlay') }) as never,
+      category: 'utility',
+      defaults: () => ({}) as never,
+      capabilities: {},
+      floorplanScope: 'site',
+      floorplan: (node) => {
+        const positioned = node as unknown as {
+          position?: [number, number, number]
+          rotation?: [number, number, number]
+        }
+        if (!(positioned.position && positioned.rotation)) return null
+        return {
+          kind: 'group',
+          children: [{ kind: 'circle', cx: 0, cy: 0, r: 1 }],
+          transform: {
+            translate: [positioned.position[0], positioned.position[2]],
+            rotate: positioned.rotation[1],
+          },
+        }
+      },
+    } as AnyNodeDefinition)
+  })
+
+  afterEach(() => restoreRegistry())
+
+  test('collects only direct children of the active Site', () => {
+    const activeSite = {
+      id: 'site_active',
+      type: 'site',
+      parentId: null,
+      children: ['overlay_declared'],
+    } as unknown as AnyNode
+    const nodes = {
+      [activeSite.id]: activeSite,
+      overlay_declared: {
+        id: 'overlay_declared',
+        type: 'test:site-overlay',
+        parentId: null,
+      } as unknown as AnyNode,
+      overlay_parented: {
+        id: 'overlay_parented',
+        type: 'test:site-overlay',
+        parentId: activeSite.id,
+      } as unknown as AnyNode,
+      overlay_other_site: {
+        id: 'overlay_other_site',
+        type: 'test:site-overlay',
+        parentId: 'site_other',
+      } as unknown as AnyNode,
+    }
+
+    expect(
+      collectDirectFloorplanScopeNodes(nodes, activeSite, 'site').map((node) => String(node.id)),
+    ).toEqual(['overlay_declared', 'overlay_parented'])
+  })
+  test('projects site-local coordinates through the inverse Three.js building transform', () => {
+    const transform = siteToFloorplanTransform([10, 0, 5], Math.PI / 2)
+    const [tx, ty] = transform.translate
+    const sitePoint = [10, 3] as const
+    const cos = Math.cos(transform.rotate)
+    const sin = Math.sin(transform.rotate)
+
+    expect(tx + sitePoint[0] * cos - sitePoint[1] * sin).toBeCloseTo(2)
+
+    expect(ty + sitePoint[0] * sin + sitePoint[1] * cos).toBeCloseTo(0)
+  })
+
+  test('rebuilds site geometry from a live pose and restores the committed pose when cleared', () => {
+    const site = {
+      id: 'site_active',
+      type: 'site',
+      parentId: null,
+      children: ['overlay_pond'],
+      visible: true,
+    } as unknown as AnyNode
+    const overlay = {
+      id: 'overlay_pond',
+      type: 'test:site-overlay',
+      parentId: site.id,
+      children: [],
+      visible: true,
+      position: [1, 0, 2],
+      rotation: [0, 0.25, 0],
+    } as unknown as AnyNode
+    const nodes = {
+      [site.id]: site,
+      [overlay.id]: overlay,
+    }
+    const geometryCache = new Map()
+    const liveOverrides = new Map<string, LiveNodeOverrides>()
+    const siteProjection = siteToFloorplanTransform([10, 0, 5], Math.PI / 2)
+    const common = {
+      automaticDimensions: false,
+      ctxOverrides: {
+        children: [],
+        siblings: [],
+        parent: site,
+        outputTransform: siteProjection,
+        trackAllNodes: true,
+      },
+      geometryCache,
+      highlighted: false,
+      hovered: false,
+      interactiveElevators: {},
+      levelDataCache: new Map(),
+      levelNodeIdsByType: new Map(),
+      liveOverride: undefined,
+      liveOverrides,
+      moving: true,
+      node: overlay,
+      nodeId: overlay.id,
+      nodes,
+      palette: undefined,
+      selected: false,
+      siblingEpoch: 0,
+      unit: 'metric' as const,
+      metricNotation: 'meters' as const,
+      wallDimensionReference: 'finished-faces' as const,
+      visibilityRootId: site.id,
+    }
+    const committedSnapshot = structuredClone(overlay)
+    const livePose = {
+      position: [4, 0, 5] as [number, number, number],
+      rotation: Math.PI / 3,
+    }
+
+    const liveEntry = buildFloorplanEntryGeometry({ ...common, live: livePose })
+
+    expect(liveEntry?.node).toMatchObject({
+      position: livePose.position,
+      rotation: [0, livePose.rotation, 0],
+      parentId: null,
+    })
+    expect(liveEntry?.base).toEqual({
+      kind: 'group',
+      children: [
+        {
+          kind: 'group',
+          children: [{ kind: 'circle', cx: 0, cy: 0, r: 1 }],
+          transform: { translate: [4, 5], rotate: livePose.rotation },
+        },
+      ],
+      transform: siteProjection,
+    })
+    expect(overlay).toEqual(committedSnapshot)
+
+    const committedEntry = buildFloorplanEntryGeometry({ ...common, live: undefined })
+
+    expect(committedEntry).not.toBe(liveEntry)
+    expect(committedEntry?.node).toBe(overlay)
+    expect(committedEntry?.base).toEqual({
+      kind: 'group',
+      children: [
+        {
+          kind: 'group',
+          children: [{ kind: 'circle', cx: 0, cy: 0, r: 1 }],
+          transform: { translate: [1, 2], rotate: 0.25 },
+        },
+      ],
+      transform: siteProjection,
+    })
+    expect(overlay).toEqual(committedSnapshot)
+  })
+})
+
 describe('floorplan selection handle sizing', () => {
   test('caps visual handle growth at extreme zoom-out', () => {
     expect(resolveFloorplanHandleUnitsPerPixel(0.01)).toBe(0.01)
@@ -447,12 +624,20 @@ describe('floorplan annotation overlay routing', () => {
 })
 
 describe('computeAffectedSiblingIds', () => {
+  // The cabinet fixture definitions have no `capabilities` — leaking them
+  // past this describe crashes any later test FILE that enumerates the
+  // registry (night-8 CI: pointer-support-cap.test.ts, run 32580694134).
+  let restoreRegistry: () => void
+
   beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
     nodeRegistry._reset()
     registerCabinetFloorplanDefinition('cabinet')
     registerCabinetFloorplanDefinition('cabinet-module')
   })
 
+  afterEach(() => restoreRegistry())
+
   test('propagates cabinet live overrides through the cabinet family', () => {
     const run = cabinetRun('cabinet_run', ['cabinet-module_main', 'cabinet-module_corner'])
     const module = cabinetModule('cabinet-module_main', run.id)
@@ -545,6 +730,16 @@ describe('collectFloorplanDependencyNodes', () => {
 })
 
 describe('collectFloorplanLinkedLevelNodes', () => {
+  // Same containment as computeAffectedSiblingIds above: the fixture
+  // definition has no `capabilities`, so it must not outlive this describe.
+  let restoreRegistry: () => void
+
+  beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
+  })
+
+  afterEach(() => restoreRegistry())
+
   test('projects a node onto a linked destination level with its real children', () => {
     nodeRegistry._reset()
     registerNode({