@pascal-app/editor 0.9.2 → 1.0.0-beta.2

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

@@ -2,6 +2,29 @@
 
 import { type FloorplanGeometry, loadAssetUrl } from '@pascal-app/core'
 import { memo, useEffect, useState } from 'react'
+import { readFloorplanGeometryMetadata } from '../../../lib/floorplan/floorplan-extension'
+import {
+  floorplanAnnotationObstacleMode,
+  isFloorplanAnnotationObstacleGeometry,
+} from './floorplan-annotation-layout'
+import {
+  FloorplanDimensionRenderer,
+  FloorplanDimensionStringRenderer,
+} from './floorplan-dimension-renderer'
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle'
+
+const STATIC_LABEL_UNITS_PER_PIXEL = 0.01
+const DOCUMENT_DEFAULT_TEXT_SIZE_PT = 8
+const DOCUMENT_ROOM_NAME_TEXT_SIZE_PT = 8
+const DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT = 7
+const DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT = 5.5
+const DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT = 7
+const DOCUMENT_DEFAULT_STROKE_WIDTH_PT = 0.5
+const DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT = 0.75
+const DOCUMENT_MARK_HEIGHT_PT = 14
+const PDF_ANNOTATION_STROKE_WIDTH_PT = 0.5
+
+type FloorplanRenderMode = 'screen' | 'pdf'
 
 /**
  * Pure-data → SVG converter. Walks a `FloorplanGeometry` tree returned by
@@ -24,16 +47,34 @@ import { memo, useEffect, useState } from 'react'
 export const FloorplanGeometryRenderer = memo(function FloorplanGeometryRenderer({
   geometry,
   pointerEventsOverride,
+  sceneRotationDeg = 0,
+  annotationUnitsPerPoint,
+  screenUnitsPerPixel,
+  renderMode = 'screen',
 }: {
   geometry: FloorplanGeometry
   pointerEventsOverride?: string
+  sceneRotationDeg?: number
+  annotationUnitsPerPoint?: number
+  screenUnitsPerPixel?: number
+  renderMode?: FloorplanRenderMode
 }) {
-  return renderNode(geometry, 0, pointerEventsOverride)
+  return renderNode(
+    geometry,
+    0,
+    pointerEventsOverride,
+    sceneRotationDeg,
+    annotationUnitsPerPoint,
+    screenUnitsPerPixel,
+    renderMode,
+  )
 })
 
 function styleAttrs(
   g: FloorplanGeometry & { kind: Exclude<FloorplanGeometry['kind'], 'group'> },
   pointerEventsOverride?: string,
+  annotationUnitsPerPoint?: number,
+  renderMode: FloorplanRenderMode = 'screen',
 ) {
   // Shared SVG attribute mapping for any styled primitive. Keeps the per-
   // primitive switch arms terse and ensures new style fields land
@@ -54,37 +95,241 @@ function styleAttrs(
     pointerEvents?: string
     cursor?: string
   }
+  const annotationMetadata = readFloorplanGeometryMetadata(g)
+  const documentStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint)
+  const vectorEffect = documentStyle.vectorEffect ?? s.vectorEffect
+  const resolvedStrokeWidth = documentStyle.strokeWidth ?? s.strokeWidth
+  const strokeWidth =
+    renderMode === 'pdf' &&
+    vectorEffect === 'non-scaling-stroke' &&
+    resolvedStrokeWidth !== undefined
+      ? Math.min(PDF_ANNOTATION_STROKE_WIDTH_PT, resolvedStrokeWidth)
+      : resolvedStrokeWidth
   return {
-    fill: s.fill ?? 'none',
+    'data-floorplan-annotation-obstacle': floorplanAnnotationObstacleMode(g),
+    'data-floorplan-annotation-role': annotationMetadata.annotationRole,
+    fill: documentStyle.fill ?? s.fill ?? 'none',
     fillOpacity: s.fillOpacity,
-    stroke: s.stroke,
-    strokeWidth: s.strokeWidth,
+    stroke: documentStyle.stroke ?? s.stroke,
+    strokeWidth,
     strokeDasharray: s.strokeDasharray,
     strokeLinecap: s.strokeLinecap,
     strokeLinejoin: s.strokeLinejoin,
     strokeOpacity: s.strokeOpacity,
     opacity: s.opacity,
-    vectorEffect: s.vectorEffect,
+    vectorEffect,
     pointerEvents: pointerEventsOverride ?? s.pointerEvents,
     style: s.cursor ? { cursor: s.cursor } : undefined,
   }
 }
 
+export function resolveDocumentFloorplanAnnotationStyle(
+  geometry: FloorplanGeometry & { kind: Exclude<FloorplanGeometry['kind'], 'group'> },
+  annotationUnitsPerPoint?: number,
+): {
+  fill?: string
+  stroke?: string
+  strokeWidth?: number
+  vectorEffect?: 'non-scaling-stroke'
+} {
+  if (annotationUnitsPerPoint === undefined) return {}
+  const styled = geometry as FloorplanGeometry & {
+    stroke?: string
+    strokeWidth?: number
+    vectorEffect?: 'non-scaling-stroke'
+  }
+  if (!styled.stroke && geometry.kind !== 'text') return {}
+
+  if (geometry.kind === 'text') {
+    const sourceFontSize = Math.max(geometry.fontSize, 1e-6)
+    const sourceStrokeWidth = geometry.strokeWidth ?? 0
+    const outlineRatio = sourceStrokeWidth > 0 ? sourceStrokeWidth / sourceFontSize : 0
+    const fontSize = documentTextFontSize(geometry, annotationUnitsPerPoint)
+    return {
+      strokeWidth:
+        geometry.stroke && outlineRatio > 0
+          ? Math.max(
+              DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT * annotationUnitsPerPoint,
+              fontSize * outlineRatio,
+            )
+          : undefined,
+    }
+  }
+
+  return {
+    strokeWidth: documentStrokeWidth(styled, annotationUnitsPerPoint),
+    vectorEffect: 'non-scaling-stroke',
+  }
+}
+
+function documentTextFontSize(
+  geometry: Extract<FloorplanGeometry, { kind: 'text' }>,
+  annotationUnitsPerPoint: number,
+): number {
+  return documentTextSizePt(geometry) * annotationUnitsPerPoint
+}
+
+function documentTextSizePt(geometry: Extract<FloorplanGeometry, { kind: 'text' }>): number {
+  switch (readFloorplanGeometryMetadata(geometry).annotationRole) {
+    case 'room-label':
+      if (geometry.fontSize >= 0.18) return DOCUMENT_ROOM_NAME_TEXT_SIZE_PT
+      if (geometry.fontSize >= 0.145) return DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT
+      return DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT
+    case 'column-center':
+    case 'stair-annotation':
+      return DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT
+    default:
+      return DOCUMENT_DEFAULT_TEXT_SIZE_PT
+  }
+}
+
+function documentStrokeWidth(
+  geometry: { strokeWidth?: number },
+  annotationUnitsPerPoint: number,
+): number {
+  return Math.max(DOCUMENT_DEFAULT_STROKE_WIDTH_PT, Math.min(1.2, geometry.strokeWidth ?? 0.5))
+}
+
+export function documentRectGeometryAttrs(
+  geometry: Extract<FloorplanGeometry, { kind: 'rect' }>,
+  annotationUnitsPerPoint?: number,
+) {
+  if (annotationUnitsPerPoint === undefined || !isAnnotationMarkRect(geometry)) {
+    return {
+      x: geometry.x,
+      y: geometry.y,
+      width: geometry.width,
+      height: geometry.height,
+      rx: geometry.rx,
+      ry: geometry.ry,
+    }
+  }
+
+  const centerX = geometry.x + geometry.width / 2
+  const centerY = geometry.y + geometry.height / 2
+  const height = DOCUMENT_MARK_HEIGHT_PT * annotationUnitsPerPoint
+  const width = Math.max(height * 1.6, (geometry.width / Math.max(geometry.height, 1e-6)) * height)
+  return {
+    x: centerX - width / 2,
+    y: centerY - height / 2,
+    width,
+    height,
+    rx: height / 2,
+    ry: height / 2,
+  }
+}
+
+function isAnnotationMarkRect(geometry: Extract<FloorplanGeometry, { kind: 'rect' }>): boolean {
+  return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.height <= 0.5
+}
+
+export function documentCircleGeometryAttrs(
+  geometry: Extract<FloorplanGeometry, { kind: 'circle' }>,
+  annotationUnitsPerPoint?: number,
+) {
+  if (annotationUnitsPerPoint === undefined || !isAnnotationMarkCircle(geometry)) {
+    return { r: geometry.r }
+  }
+  return { r: Math.max(geometry.r, (DOCUMENT_MARK_HEIGHT_PT / 2) * annotationUnitsPerPoint) }
+}
+
+function isAnnotationMarkCircle(geometry: Extract<FloorplanGeometry, { kind: 'circle' }>): boolean {
+  return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.r <= 0.25
+}
+
+export function resolveDocumentAnnotationGroupChildren(
+  children: FloorplanGeometry[],
+  annotationUnitsPerPoint?: number,
+): FloorplanGeometry[] {
+  if (annotationUnitsPerPoint === undefined) return children
+
+  const next = [...children]
+  let start = 0
+  while (start < next.length) {
+    const first = next[start]
+    if (!isDocumentTextLine(first)) {
+      start++
+      continue
+    }
+
+    let end = start + 1
+    while (end < next.length && isSameDocumentTextRun(first, next[end])) end++
+    if (end - start > 1) {
+      const run = next.slice(start, end) as Extract<FloorplanGeometry, { kind: 'text' }>[]
+      const adjusted = positionDocumentTextRun(run, annotationUnitsPerPoint)
+      for (let index = 0; index < adjusted.length; index++) {
+        const line = adjusted[index]
+        if (line) next[start + index] = line
+      }
+    }
+    start = end
+  }
+
+  return next
+}
+
+function isDocumentTextLine(
+  geometry: FloorplanGeometry | undefined,
+): geometry is Extract<FloorplanGeometry, { kind: 'text' }> {
+  return geometry?.kind === 'text' && geometry.upright === true
+}
+
+function isSameDocumentTextRun(
+  first: Extract<FloorplanGeometry, { kind: 'text' }>,
+  candidate: FloorplanGeometry | undefined,
+): candidate is Extract<FloorplanGeometry, { kind: 'text' }> {
+  return (
+    isDocumentTextLine(candidate) &&
+    Math.abs(candidate.x - first.x) < 1e-6 &&
+    candidate.textAnchor === first.textAnchor &&
+    readFloorplanGeometryMetadata(candidate).annotationRole ===
+      readFloorplanGeometryMetadata(first).annotationRole
+  )
+}
+
+function positionDocumentTextRun(
+  run: Extract<FloorplanGeometry, { kind: 'text' }>[],
+  annotationUnitsPerPoint: number,
+): Extract<FloorplanGeometry, { kind: 'text' }>[] {
+  const centerY = run.reduce((sum, line) => sum + line.y, 0) / run.length
+  const steps = run.slice(0, -1).map((line, index) => {
+    const next = run[index + 1] ?? line
+    const largerFontPt = Math.max(documentTextSizePt(line), documentTextSizePt(next))
+    return largerFontPt * 1.25 * annotationUnitsPerPoint
+  })
+  const totalHeight = steps.reduce((sum, step) => sum + step, 0)
+  let y = centerY - totalHeight / 2
+  return run.map((line, index) => {
+    if (index > 0) y += steps[index - 1] ?? 0
+    return { ...line, y }
+  })
+}
+
 function renderNode(
   g: FloorplanGeometry,
   keyHint: number,
   pointerEventsOverride?: string,
+  sceneRotationDeg = 0,
+  annotationUnitsPerPoint?: number,
+  screenUnitsPerPixel?: number,
+  renderMode: FloorplanRenderMode = 'screen',
 ): React.ReactElement | null {
   switch (g.kind) {
     case 'path':
-      return <path d={g.d} key={keyHint} {...styleAttrs(g, pointerEventsOverride)} />
+      return (
+        <path
+          d={g.d}
+          key={keyHint}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
+        />
+      )
 
     case 'polygon':
       return (
         <polygon
           key={keyHint}
           points={pointsToAttr(g.points)}
-          {...styleAttrs(g, pointerEventsOverride)}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
         />
       )
 
@@ -93,34 +338,38 @@ function renderNode(
         <polyline
           key={keyHint}
           points={pointsToAttr(g.points)}
-          {...styleAttrs(g, pointerEventsOverride)}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
         />
       )
 
-    case 'rect':
+    case 'rect': {
+      const attrs = documentRectGeometryAttrs(g, annotationUnitsPerPoint)
       return (
         <rect
-          height={g.height}
+          height={attrs.height}
           key={keyHint}
-          rx={g.rx}
-          ry={g.ry}
-          width={g.width}
-          x={g.x}
-          y={g.y}
-          {...styleAttrs(g, pointerEventsOverride)}
+          rx={attrs.rx}
+          ry={attrs.ry}
+          width={attrs.width}
+          x={attrs.x}
+          y={attrs.y}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
         />
       )
+    }
 
-    case 'circle':
+    case 'circle': {
+      const attrs = documentCircleGeometryAttrs(g, annotationUnitsPerPoint)
       return (
         <circle
           cx={g.cx}
           cy={g.cy}
           key={keyHint}
-          r={g.r}
-          {...styleAttrs(g, pointerEventsOverride)}
+          r={attrs.r}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
         />
       )
+    }
 
     case 'line':
       return (
@@ -130,25 +379,65 @@ function renderNode(
           x2={g.x2}
           y1={g.y1}
           y2={g.y2}
-          {...styleAttrs(g, pointerEventsOverride)}
+          {...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode)}
         />
       )
 
-    case 'text':
+    case 'text': {
+      const fontSize =
+        annotationUnitsPerPoint !== undefined
+          ? documentTextFontSize(g, annotationUnitsPerPoint)
+          : g.fontSize
+      const textStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint)
+      const pdfOutlinedText = renderMode === 'pdf' && g.paintOrder === 'stroke' && !!g.stroke
+      const fill =
+        pdfOutlinedText && g.fill?.toLocaleLowerCase() === '#ffffff'
+          ? g.stroke
+          : (g.fill ?? '#171717')
+      if (g.upright) {
+        return (
+          <g
+            data-floorplan-annotation-obstacle={floorplanAnnotationObstacleMode(g)}
+            key={keyHint}
+            transform={`translate(${g.x} ${g.y}) rotate(${-sceneRotationDeg})`}
+          >
+            <text
+              dominantBaseline={g.dominantBaseline ?? 'middle'}
+              fill={fill}
+              fontFamily={g.fontFamily}
+              fontSize={fontSize}
+              fontWeight={g.fontWeight}
+              opacity={g.opacity}
+              paintOrder={pdfOutlinedText ? undefined : g.paintOrder}
+              pointerEvents={pointerEventsOverride}
+              stroke={pdfOutlinedText ? undefined : g.stroke}
+              strokeLinecap={!pdfOutlinedText && g.stroke ? 'round' : undefined}
+              strokeLinejoin={!pdfOutlinedText && g.stroke ? 'round' : undefined}
+              strokeWidth={pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth)}
+              textAnchor={g.textAnchor ?? 'start'}
+              x={0}
+              y={0}
+            >
+              {g.text}
+            </text>
+          </g>
+        )
+      }
       return (
         <text
+          data-floorplan-annotation-obstacle={floorplanAnnotationObstacleMode(g)}
           dominantBaseline={g.dominantBaseline ?? 'middle'}
-          fill={g.fill ?? '#171717'}
+          fill={fill}
           fontFamily={g.fontFamily}
-          fontSize={g.fontSize}
+          fontSize={fontSize}
           fontWeight={g.fontWeight}
           key={keyHint}
           opacity={g.opacity}
-          paintOrder={g.paintOrder}
-          stroke={g.stroke}
-          strokeLinecap={g.stroke ? 'round' : undefined}
-          strokeLinejoin={g.stroke ? 'round' : undefined}
-          strokeWidth={g.strokeWidth}
+          paintOrder={pdfOutlinedText ? undefined : g.paintOrder}
+          stroke={pdfOutlinedText ? undefined : g.stroke}
+          strokeLinecap={!pdfOutlinedText && g.stroke ? 'round' : undefined}
+          strokeLinejoin={!pdfOutlinedText && g.stroke ? 'round' : undefined}
+          strokeWidth={pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth)}
           textAnchor={g.textAnchor ?? 'start'}
           pointerEvents={pointerEventsOverride}
           x={g.x}
@@ -157,6 +446,99 @@ function renderNode(
           {g.text}
         </text>
       )
+    }
+
+    case 'dimension':
+      return (
+        <FloorplanDimensionRenderer
+          geometry={g}
+          key={keyHint}
+          sceneRotationDeg={sceneRotationDeg}
+          annotationUnitsPerPoint={annotationUnitsPerPoint}
+          renderMode={renderMode}
+        />
+      )
+
+    case 'dimension-string':
+      return (
+        <FloorplanDimensionStringRenderer
+          annotationUnitsPerPoint={annotationUnitsPerPoint}
+          geometry={g}
+          key={keyHint}
+          renderMode={renderMode}
+          sceneRotationDeg={sceneRotationDeg}
+        />
+      )
+
+    case 'dimension-label': {
+      const unitsPerPixel =
+        annotationUnitsPerPoint ?? screenUnitsPerPixel ?? STATIC_LABEL_UNITS_PER_PIXEL
+      const documentMode = annotationUnitsPerPoint !== undefined
+      const outlined = g.appearance === 'outlined'
+      const pdfOutlined = outlined && renderMode === 'pdf'
+      const padX = unitsPerPixel * 6
+      const padY = unitsPerPixel * 3
+      const fontSize = unitsPerPixel * (documentMode ? 8 : outlined ? 12 : 10)
+      const textWidth = g.text.length * unitsPerPixel * 6.2
+      const plateW = textWidth + padX * 2
+      const plateH = fontSize + padY * 2
+      const degrees = resolveFloorplanLabelAngle(g.angle, sceneRotationDeg, g.screenUpright)
+      const labelTransform = `translate(${g.cx} ${g.cy}) rotate(${degrees}) translate(0 ${-(g.offsetPx ?? 0) * unitsPerPixel})`
+
+      return (
+        <g
+          data-floorplan-annotation-angle-radians={g.angle}
+          data-floorplan-annotation-default-transform={labelTransform}
+          data-floorplan-annotation-label=""
+          data-floorplan-annotation-priority="20"
+          data-floorplan-annotation-screen-upright={g.screenUpright ? 'true' : undefined}
+          data-floorplan-annotation-transform-after-rotation={`translate(0 ${
+            -(g.offsetPx ?? 0) * unitsPerPixel
+          })`}
+          data-floorplan-annotation-transform-before-rotation={`translate(${g.cx} ${g.cy})`}
+          key={keyHint}
+          pointerEvents="none"
+          transform={labelTransform}
+        >
+          {outlined && !pdfOutlined ? null : (
+            <rect
+              data-floorplan-dimension-label-plate={pdfOutlined ? '' : undefined}
+              fill="#ffffff"
+              height={plateH}
+              opacity={0.92}
+              rx={unitsPerPixel * 3}
+              ry={unitsPerPixel * 3}
+              stroke={pdfOutlined ? undefined : '#334155'}
+              strokeWidth={pdfOutlined ? undefined : unitsPerPixel * 0.5}
+              width={plateW}
+              x={-plateW / 2}
+              y={-plateH / 2}
+            />
+          )}
+          <text
+            dominantBaseline="middle"
+            fill={pdfOutlined ? '#111827' : outlined ? '#ffffff' : '#111827'}
+            fontFamily={
+              outlined && !pdfOutlined
+                ? 'system-ui, -apple-system, sans-serif'
+                : 'ui-monospace, SFMono-Regular, Menlo, monospace'
+            }
+            fontSize={fontSize}
+            fontWeight={outlined ? 500 : 600}
+            paintOrder={outlined && !pdfOutlined ? 'stroke' : undefined}
+            stroke={outlined && !pdfOutlined ? '#334155' : undefined}
+            strokeLinecap={outlined && !pdfOutlined ? 'round' : undefined}
+            strokeLinejoin={outlined && !pdfOutlined ? 'round' : undefined}
+            strokeWidth={outlined && !pdfOutlined ? fontSize * 0.35 : undefined}
+            textAnchor="middle"
+            x={0}
+            y={0}
+          >
+            {g.text}
+          </text>
+        </g>
+      )
+    }
 
     case 'image':
       return (
@@ -174,15 +556,32 @@ function renderNode(
 
     case 'group': {
       const transform = formatTransform(g.transform)
+      const children = resolveDocumentAnnotationGroupChildren(g.children, annotationUnitsPerPoint)
       return (
-        <g key={keyHint} transform={transform}>
-          {g.children.map((child, i) => renderNode(child, i, pointerEventsOverride))}
+        <g
+          data-floorplan-annotation-obstacle={
+            isFloorplanAnnotationObstacleGeometry(g) ? '' : undefined
+          }
+          key={keyHint}
+          transform={transform}
+        >
+          {children.map((child, i) =>
+            renderNode(
+              child,
+              i,
+              pointerEventsOverride,
+              sceneRotationDeg,
+              annotationUnitsPerPoint,
+              screenUnitsPerPixel,
+              renderMode,
+            ),
+          )}
         </g>
       )
     }
 
-    // The interactive primitives (hatch / hit-line / endpoint-handle /
-    // dimension-label) need the SVG context + theme palette + units-per-
+    // The remaining interactive primitives (hatch / hit-line / endpoint-handle)
+    // need the SVG context + theme palette + units-per-
     // pixel that only the registry layer has access to. They're rendered
     // by `floorplan-registry-layer.tsx`'s interactive walker instead. If
     // a caller routes one of these through this pure renderer it

package/src/components/editor-2d/renderers/floorplan-label-angle.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from 'bun:test'
-import { resolveFloorplanLabelAngle } from './floorplan-label-angle'
+import {
+  resolveFloorplanAnnotationLabelTransform,
+  resolveFloorplanAnnotationUpdate,
+  resolveFloorplanLabelAngle,
+  shouldUpdateFloorplanLabelRotation,
+  updateSvgFloorplanLabelOrientations,
+} from './floorplan-label-angle'
 
 describe('resolveFloorplanLabelAngle', () => {
   test('keeps segment labels readable while preserving their screen direction', () => {
@@ -12,4 +18,72 @@ describe('resolveFloorplanLabelAngle', () => {
     expect(resolveFloorplanLabelAngle(0, 90, true)).toBe(-90)
     expect(resolveFloorplanLabelAngle(Math.PI / 3, -35, true)).toBe(35)
   })
+
+  test('ignores sub-degree rotation changes for annotation layout', () => {
+    expect(shouldUpdateFloorplanLabelRotation(30, 30.9)).toBe(false)
+    expect(shouldUpdateFloorplanLabelRotation(30, 31)).toBe(true)
+    expect(shouldUpdateFloorplanLabelRotation(359.5, 0.25)).toBe(false)
+  })
+
+  test('updates only label orientation while preserving its layout shift', () => {
+    expect(
+      resolveFloorplanAnnotationLabelTransform({
+        afterRotation: 'translate(0 -0.2)',
+        angleRadians: 0,
+        beforeRotation: 'translate(4 6)',
+        layoutDx: 0.5,
+        layoutDy: -0.25,
+        sceneRotationDeg: 90,
+        screenUpright: true,
+      }),
+    ).toEqual({
+      defaultTransform: 'translate(4 6) rotate(-90) translate(0 -0.2)',
+      transform: 'translate(4 6) rotate(-90) translate(0 -0.2) translate(0.5 -0.25)',
+    })
+  })
+
+  test('keeps a rotation-only update out of the full collision layout path', () => {
+    expect(
+      resolveFloorplanAnnotationUpdate({
+        layoutInputsChanged: false,
+        nextRotationDeg: 45,
+        previousRotationDeg: 30,
+      }),
+    ).toEqual({
+      resolveCollisions: false,
+      updateLabelPresentation: true,
+    })
+  })
+
+  test('runs collision layout when floor-plan scene inputs change', () => {
+    expect(
+      resolveFloorplanAnnotationUpdate({
+        layoutInputsChanged: true,
+        nextRotationDeg: 30,
+        previousRotationDeg: 30,
+      }),
+    ).toEqual({
+      resolveCollisions: true,
+      updateLabelPresentation: true,
+    })
+  })
+
+  test('updates captured label references without rediscovering the DOM', () => {
+    const attributes = new Map<string, string>([['transform', 'translate(4 6) rotate(0)']])
+    const label = {
+      dataset: {
+        floorplanAnnotationAngleRadians: '0',
+        floorplanAnnotationLayoutDx: '0.5',
+        floorplanAnnotationLayoutDy: '-0.25',
+        floorplanAnnotationScreenUpright: 'true',
+        floorplanAnnotationTransformAfterRotation: '',
+        floorplanAnnotationTransformBeforeRotation: 'translate(4 6)',
+      },
+      getAttribute: (name: string) => attributes.get(name) ?? null,
+      setAttribute: (name: string, value: string) => attributes.set(name, value),
+    } as unknown as SVGGElement
+
+    expect(updateSvgFloorplanLabelOrientations([label], 90)).toBe(1)
+    expect(attributes.get('transform')).toBe('translate(4 6) rotate(-90) translate(0.5 -0.25)')
+  })
 })