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

package/src/lib/floorplan/floorplan-export.tsx

@@ -3,7 +3,10 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  type ConstructionDrawingType,
   type FloorplanGeometry,
+  type FloorplanPalette,
+  type FloorplanPoint,
   type LiveNodeOverrides,
   nodeRegistry,
   resolveBuildingForLevel,
@@ -13,14 +16,39 @@ import { useViewer } from '@pascal-app/viewer'
 import { createElement } from 'react'
 import { flushSync } from 'react-dom'
 import { createRoot } from 'react-dom/client'
+import { resolveSvgAnnotationCollisions } from '../../components/editor-2d/renderers/floorplan-annotation-layout'
 import { FloorplanGeometryRenderer } from '../../components/editor-2d/renderers/floorplan-geometry-renderer'
 import {
   buildContext,
+  collectFloorplanLinkedLevelNodes,
   floorplanLayerRank,
   getFloorplanLevelData,
   isFloorplanNodeVisible,
   splitFloorplanOverlay,
 } from '../../components/editor-2d/renderers/floorplan-registry-layer'
+import useDrawingView, { DRAWING_TYPE_OPTIONS } from '../../store/use-drawing-view'
+import useEditor from '../../store/use-editor'
+import useFloorplanAnnotationVisibility from '../../store/use-floorplan-annotation-visibility'
+import useFloorplanMode from '../../store/use-floorplan-mode'
+import {
+  type FloorplanAnnotationVisibility,
+  filterFloorplanAnnotationGeometry,
+} from './annotation-visibility'
+import { resolveNodeForDrawingType } from './drawing-coordination'
+import {
+  type FloorplanMetricNotation,
+  type FloorplanSchedule,
+  type FloorplanWallDimensionReference,
+  getFloorplanNodeExtension,
+  readFloorplanGeometryMetadata,
+} from './floorplan-extension'
+import {
+  type FloorplanMode,
+  resolveFloorplanAnnotationVisibility,
+  resolveFloorplanWallDimensionReference,
+} from './floorplan-mode'
+import { createFloorplanPdfDocument, type FloorplanPdfDocument } from './floorplan-pdfkit-document'
+import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
 import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
 
 /**
@@ -31,8 +59,9 @@ import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
  * a neutral `viewState` so nodes render in their default, unselected form.
  * Every level of the active building becomes its own page, titled with the
  * level's label, with the plan fit to the page (independent of the live
- * pan/zoom). jsPDF + svg2pdf are dynamically imported so they only load when
- * an export actually runs.
+ * pan/zoom). PDFKit is dynamically imported so it only loads when an export
+ * actually runs. Geometry and labels are emitted as native PDF vectors and
+ * text instead of being reinterpreted from browser SVG.
  *
  * `scope: 'structure'` keeps only `category === 'structure'` nodes (walls,
  * slabs, ceilings, doors, windows, stairs, columns, roofs…); `'full'` keeps
@@ -41,37 +70,101 @@ import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
 export type FloorplanExportScope = 'full' | 'structure'
 
 const SVG_NS = 'http://www.w3.org/2000/svg'
-/** Meters of margin around the plan bounds. */
-const PADDING_M = 1
+/** Minimum and proportional margin around the structural drawing bounds. */
+const MIN_PLAN_PADDING_M = 1
+const PLAN_PADDING_RATIO = 0.2
 /** PDF page margin + title band, in pt. */
 const PAGE_MARGIN_PT = 36
 const TITLE_BAND_PT = 28
+const A4_LANDSCAPE_WIDTH_PT = (297 / 25.4) * 72
+const A4_LANDSCAPE_HEIGHT_PT = (210 / 25.4) * 72
+
+const NEUTRAL_PALETTE: FloorplanPalette = {
+  selectedStroke: '#334155',
+  selectedFill: '#ffffff',
+  selectedHatch: '#334155',
+  wallHoverStroke: '#334155',
+  endpointHandleFill: '#ffffff',
+  endpointHandleStroke: '#334155',
+  endpointHandleHoverStroke: '#334155',
+  endpointHandleActiveFill: '#334155',
+  endpointHandleActiveStroke: '#334155',
+  curveHandleFill: '#ffffff',
+  curveHandleStroke: '#334155',
+  curveHandleHoverStroke: '#334155',
+  measurementStroke: '#334155',
+  measurementLabelBackground: '#ffffff',
+  measurementLabelText: '#111827',
+}
 
-// Neutral view state — no selection / hover / palette, so builders emit their
-// default appearance (the core palette only carries selection/handle colors).
+// Neutral view state — no selection / hover. A neutral palette keeps the
+// full view state (including unit preference) available to node builders.
 const NEUTRAL_VIEW_STATE = {
   selected: false,
+  purpose: 'edit',
   highlighted: false,
   hovered: false,
   moving: false,
-  palette: undefined,
+  palette: NEUTRAL_PALETTE,
 } as const
 
+export function resolveFloorplanExportViewState(
+  unit: 'metric' | 'imperial',
+  metricNotation: FloorplanMetricNotation,
+  wallDimensionReference?: FloorplanWallDimensionReference,
+  automaticDimensions = true,
+) {
+  return {
+    ...NEUTRAL_VIEW_STATE,
+    automaticDimensions,
+    unit,
+    metricNotation,
+    wallDimensionReference,
+  }
+}
+
 type ExportLevel = { id: AnyNodeId; label: string }
 
+type ExportGeometry = {
+  id: AnyNodeId
+  model: FloorplanGeometry | null
+  annotations: FloorplanGeometry | null
+}
+
+export type FloorplanPageLayout = {
+  planBox: { x: number; y: number; width: number; height: number }
+}
+
 export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<void> {
   const nodes = useScene.getState().nodes
-  const unit = useViewer.getState().unit
+  const viewer = useViewer.getState()
+  const unit = viewer.unit
+  const metricNotation = viewer.metricNotation
+  const floorplanMode = useFloorplanMode.getState().mode
+  const expertAnnotationState = useFloorplanAnnotationVisibility.getState()
+  const annotationVisibility = resolveFloorplanExportAnnotationVisibility(
+    floorplanMode,
+    expertAnnotationState.visibility,
+  )
+  const wallDimensionReference = resolveFloorplanWallDimensionReference(
+    floorplanMode,
+    expertAnnotationState.wallDimensionReference,
+  )
+  const navigationAzimuth = useEditor.getState().navigationSyncPose?.azimuth
+  const drawingType = useDrawingView.getState().drawingType
+  const annotationLayoutOverrides = useDrawingView.getState().annotationLayoutOverrides
+  const drawingLabel =
+    DRAWING_TYPE_OPTIONS.find((option) => option.id === drawingType)?.label ?? 'Floor plan'
   const levels = resolveExportLevels(nodes)
   if (levels.length === 0) {
     console.warn('[floorplan-export] no level to export')
     return
   }
 
-  const [{ jsPDF }, { svg2pdf }] = await Promise.all([import('jspdf'), import('svg2pdf.js')])
-  const doc = new jsPDF({ orientation: 'landscape', unit: 'pt', format: 'a4' })
-  const pageW = doc.internal.pageSize.getWidth()
-  const pageH = doc.internal.pageSize.getHeight()
+  const { doc, save } = await createFloorplanPdfDocument([
+    A4_LANDSCAPE_WIDTH_PT,
+    A4_LANDSCAPE_HEIGHT_PT,
+  ])
 
   const host = document.createElement('div')
   host.style.cssText =
@@ -81,53 +174,83 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
   let pageCount = 0
   try {
     for (const level of levels) {
-      const geometries = collectFloorplanGeometry(nodes, level.id, scope, unit)
-      if (geometries.length === 0) continue
-
-      // Rotate the exported plan to the same north-up orientation the on-screen
-      // 2D view uses when aligned to north (user rotation offset = 0), so a PDF
-      // points north instead of drawing raw plan-local axes.
-      const buildingId = resolveBuildingForLevel(level.id, nodes as Record<AnyNodeId, AnyNode>)
-      const building = buildingId ? nodes[buildingId] : undefined
-      const buildingRotationY = building?.type === 'building' ? (building.rotation[1] ?? 0) : 0
-      const rotationDeg = FLOORPLAN_VIEW_ROTATION_DEG - (buildingRotationY * 180) / Math.PI
-
-      const mounted = await mountFloorplanSvg(host, geometries, rotationDeg)
-      if (!mounted) continue
-
-      try {
-        if (pageCount > 0) doc.addPage()
-        pageCount++
-
-        doc.setFontSize(14)
-        doc.text(level.label, PAGE_MARGIN_PT, PAGE_MARGIN_PT + 12)
-
-        // Fit the plan into the page below the title band, preserving aspect.
-        const boxX = PAGE_MARGIN_PT
-        const boxY = PAGE_MARGIN_PT + TITLE_BAND_PT
-        const boxW = pageW - PAGE_MARGIN_PT * 2
-        const boxH = pageH - PAGE_MARGIN_PT * 2 - TITLE_BAND_PT
-        const aspect = mounted.width / mounted.height
-        let w = boxW
-        let h = w / aspect
-        if (h > boxH) {
-          h = boxH
-          w = h * aspect
+      const geometries = collectFloorplanGeometry(
+        nodes,
+        level.id,
+        scope,
+        unit,
+        metricNotation,
+        annotationVisibility,
+        drawingType,
+        wallDimensionReference,
+      )
+      const schedules = collectFloorplanSchedules(nodes, level.id, unit)
+      if (geometries.length === 0 && schedules.length === 0) continue
+      const layout = resolveFloorplanPageLayout(A4_LANDSCAPE_WIDTH_PT, A4_LANDSCAPE_HEIGHT_PT)
+
+      if (geometries.length > 0) {
+        // Preserve the live floor-plan orientation rather than forcing north-up.
+        const buildingId = resolveBuildingForLevel(level.id, nodes as Record<AnyNodeId, AnyNode>)
+        const building = buildingId ? nodes[buildingId] : undefined
+        const buildingRotationY = building?.type === 'building' ? (building.rotation[1] ?? 0) : 0
+        const rotationDeg = resolveFloorplanExportRotationDeg(buildingRotationY, navigationAzimuth)
+
+        const mounted = await mountFloorplanSvg(
+          host,
+          geometries,
+          rotationDeg,
+          annotationLayoutOverrides,
+        )
+        if (mounted) {
+          try {
+            doc.addPage([A4_LANDSCAPE_WIDTH_PT, A4_LANDSCAPE_HEIGHT_PT], 'landscape')
+            pageCount++
+
+            const screenUnitsPerPixel = resolveFloorplanScreenUnitsPerPixel(
+              mounted.width,
+              mounted.height,
+              layout.planBox.width,
+              layout.planBox.height,
+            )
+            await mounted.setScreenUnitsPerPixel(screenUnitsPerPixel)
+            const fitted = resolveFloorplanExportPlacement(
+              mounted.width,
+              mounted.height,
+              layout.planBox.x,
+              layout.planBox.y,
+              layout.planBox.width,
+              layout.planBox.height,
+            )
+            drawFloorplanPageHeader(doc, level.label, drawingLabel)
+            const model = combineGeometryList(geometries.map((geometry) => geometry.model))
+            if (model) {
+              await renderFloorplanGeometryToPdfKit(doc, model, {
+                annotationLayer: false,
+                placement: fitted,
+                rotationDeg,
+                viewport: mounted.viewport,
+              })
+            }
+            const annotations = combineGeometryList(
+              geometries.map((geometry) => geometry.annotations),
+            )
+            if (annotations) {
+              await renderFloorplanGeometryToPdfKit(doc, annotations, {
+                annotationLabelShifts: mounted.annotationLabelShifts,
+                annotationLayer: true,
+                placement: fitted,
+                rotationDeg,
+                viewport: mounted.viewport,
+              })
+            }
+          } finally {
+            mounted.cleanup()
+          }
         }
-        const x = boxX + (boxW - w) / 2
-        const y = boxY + (boxH - h) / 2
-
-        // svg2pdf doesn't honour `vector-effect: non-scaling-stroke` (which
-        // many builders use to keep door/window/stair line weights constant
-        // on screen). Left as-is, those pixel-sized widths render as
-        // metre-wide strokes — huge grey blobs. Convert them to the real-unit
-        // width that lands at the intended point weight once svg2pdf scales
-        // the plan onto the page.
-        inlineNonScalingStrokes(mounted.svg, w / mounted.width)
-
-        await svg2pdf(mounted.svg, doc, { x, y, width: w, height: h })
-      } finally {
-        mounted.cleanup()
+      }
+
+      if (schedules.length > 0) {
+        pageCount = drawFloorplanSchedulePages(doc, level.label, schedules, pageCount)
       }
     }
 
@@ -137,24 +260,314 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
     }
 
     const date = new Date().toISOString().split('T')[0]
-    doc.save(`floorplan_${scope}_${date}.pdf`)
+    await save(`${drawingType}_${scope}_${date}.pdf`)
   } finally {
     host.remove()
   }
 }
 
+export function collectFloorplanSchedules(
+  nodes: Record<string, AnyNode>,
+  levelId: AnyNodeId,
+  unit: 'metric' | 'imperial',
+): FloorplanSchedule[] {
+  const siblingsByType = new Map<string, AnyNode[]>()
+  const visit = (id: AnyNodeId) => {
+    const node = nodes[id]
+    if (!node) return
+    if (node.visible !== false) {
+      const siblings = siblingsByType.get(node.type)
+      if (siblings) siblings.push(node)
+      else siblingsByType.set(node.type, [node])
+    }
+    const children = (node as { children?: AnyNodeId[] }).children
+    if (Array.isArray(children)) for (const childId of children) visit(childId)
+  }
+  visit(levelId)
+
+  const schedules: FloorplanSchedule[] = []
+  for (const [kind, definition] of nodeRegistry.entries()) {
+    const scheduleContribution = getFloorplanNodeExtension(definition)?.schedule
+    if (!scheduleContribution) continue
+    const siblings = siblingsByType.get(kind) ?? []
+    const schedule = scheduleContribution({ siblings, nodes, levelId, unit })
+    if (schedule && schedule.rows.length > 0) schedules.push(schedule)
+  }
+  return schedules
+}
+
+export function resolveFloorplanPageLayout(
+  pageWidth: number,
+  pageHeight: number,
+): FloorplanPageLayout {
+  const planY = PAGE_MARGIN_PT + TITLE_BAND_PT
+  return {
+    planBox: {
+      x: PAGE_MARGIN_PT,
+      y: planY,
+      width: pageWidth - PAGE_MARGIN_PT * 2,
+      height: pageHeight - planY - PAGE_MARGIN_PT,
+    },
+  }
+}
+
+function drawFloorplanPageHeader(
+  doc: FloorplanPdfDocument,
+  levelLabel: string,
+  drawingLabel: string,
+): void {
+  doc.setTextColor('#111827')
+  doc.setFont('helvetica', 'bold')
+  doc.setFontSize(14)
+  doc.text(`${levelLabel} - ${drawingLabel}`, PAGE_MARGIN_PT, PAGE_MARGIN_PT + 12)
+}
+
+function drawFloorplanSchedulePages(
+  doc: FloorplanPdfDocument,
+  levelLabel: string,
+  schedules: readonly FloorplanSchedule[],
+  initialPageCount: number,
+): number {
+  const pageW = doc.internal.pageSize.getWidth()
+  const pageH = doc.internal.pageSize.getHeight()
+  const tableWidth = pageW - PAGE_MARGIN_PT * 2
+  const bottom = pageH - PAGE_MARGIN_PT
+  const headerHeight = 22
+  const rowHeight = 20
+  let pageCount = initialPageCount
+  let y = 0
+
+  const startPage = () => {
+    doc.addPage([pageW, pageH])
+    pageCount++
+    doc.setTextColor('#111827')
+    doc.setFont('helvetica', 'bold')
+    doc.setFontSize(14)
+    doc.setLineWidth(0.5)
+    doc.text(`${levelLabel} - Construction Schedules`, PAGE_MARGIN_PT, PAGE_MARGIN_PT + 12)
+    y = PAGE_MARGIN_PT + TITLE_BAND_PT + 8
+  }
+
+  const drawHeader = (schedule: FloorplanSchedule, continued: boolean) => {
+    doc.setTextColor('#111827')
+    doc.setFont('helvetica', 'bold')
+    doc.setFontSize(11)
+    doc.text(`${schedule.title}${continued ? ' (CONTINUED)' : ''}`, PAGE_MARGIN_PT, y + 11)
+    y += 18
+    doc.setFillColor('#334155')
+    doc.rect(PAGE_MARGIN_PT, y, tableWidth, headerHeight, 'F')
+    doc.setTextColor('#ffffff')
+    doc.setFontSize(8)
+    const widths = scheduleColumnWidths(schedule, tableWidth)
+    doc.setDrawColor('#64748b')
+    drawScheduleColumnDividers(doc, widths, y, headerHeight)
+    let x = PAGE_MARGIN_PT
+    schedule.columns.forEach((column, index) => {
+      const width = widths[index] ?? 0
+      doc.text(column.label, x + 4, y + 14, { maxWidth: Math.max(0, width - 8) })
+      x += width
+    })
+    y += headerHeight
+  }
+
+  startPage()
+  for (const schedule of schedules) {
+    const issueHeight = (schedule.issues?.length ?? 0) * 13
+    const minimumTableHeight = 18 + issueHeight + headerHeight + rowHeight
+    if (y + minimumTableHeight > bottom) startPage()
+
+    if (schedule.issues?.length) {
+      doc.setTextColor('#b45309')
+      doc.setFont('helvetica', 'normal')
+      doc.setFontSize(8)
+      for (const issue of schedule.issues) {
+        doc.text(`WARNING: ${issue}`, PAGE_MARGIN_PT, y + 9)
+        y += 13
+      }
+    }
+
+    drawHeader(schedule, false)
+    const widths = scheduleColumnWidths(schedule, tableWidth)
+    schedule.rows.forEach((row, rowIndex) => {
+      if (y + rowHeight > bottom) {
+        startPage()
+        drawHeader(schedule, true)
+      }
+      if (rowIndex % 2 === 1) {
+        doc.setFillColor('#f1f5f9')
+        doc.rect(PAGE_MARGIN_PT, y, tableWidth, rowHeight, 'F')
+      }
+      doc.setDrawColor('#cbd5e1')
+      doc.rect(PAGE_MARGIN_PT, y, tableWidth, rowHeight)
+      drawScheduleColumnDividers(doc, widths, y, rowHeight)
+      doc.setTextColor('#111827')
+      doc.setFont('helvetica', 'normal')
+      doc.setFontSize(8)
+      let x = PAGE_MARGIN_PT
+      schedule.columns.forEach((column, columnIndex) => {
+        const width = widths[columnIndex] ?? 0
+        const text = truncatePdfText(doc, row.cells[column.key] ?? '', Math.max(0, width - 8))
+        doc.text(text, x + 4, y + 13)
+        x += width
+      })
+      y += rowHeight
+    })
+    y += 20
+  }
+
+  return pageCount
+}
+
+function scheduleColumnWidths(schedule: FloorplanSchedule, tableWidth: number): number[] {
+  const totalWeight = schedule.columns.reduce((sum, column) => sum + (column.weight ?? 1), 0)
+  return schedule.columns.map((column) => (tableWidth * (column.weight ?? 1)) / totalWeight)
+}
+
+function drawScheduleColumnDividers(
+  doc: FloorplanPdfDocument,
+  widths: readonly number[],
+  y: number,
+  height: number,
+) {
+  let x = PAGE_MARGIN_PT
+  for (const width of widths.slice(0, -1)) {
+    x += width
+    doc.line(x, y, x, y + height)
+  }
+}
+
+function truncatePdfText(doc: FloorplanPdfDocument, value: string, maxWidth: number): string {
+  if (doc.getTextWidth(value) <= maxWidth) return value
+  let truncated = value
+  while (truncated.length > 0 && doc.getTextWidth(`${truncated}...`) > maxWidth) {
+    truncated = truncated.slice(0, -1)
+  }
+  return `${truncated}...`
+}
+
 type MountedFloorplan = {
   svg: SVGSVGElement
+  annotationLabelShifts: readonly FloorplanPoint[]
   /** Padded viewBox dimensions, in meters — used for aspect-preserving fit. */
   width: number
   height: number
+  viewport: FloorplanExportBounds
+  setScreenUnitsPerPixel: (value: number) => Promise<void>
   cleanup: () => void
 }
 
+export type FloorplanExportBounds = {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export function fitPlanToBox(
+  planWidth: number,
+  planHeight: number,
+  boxX: number,
+  boxY: number,
+  boxWidth: number,
+  boxHeight: number,
+) {
+  const aspect = planWidth / planHeight
+  let width = boxWidth
+  let height = width / aspect
+  if (height > boxHeight) {
+    height = boxHeight
+    width = height * aspect
+  }
+  return {
+    x: boxX + (boxWidth - width) / 2,
+    y: boxY + (boxHeight - height) / 2,
+    width,
+    height,
+  }
+}
+
+export function resolveFloorplanExportPlacement(
+  planWidth: number,
+  planHeight: number,
+  boxX: number,
+  boxY: number,
+  boxWidth: number,
+  boxHeight: number,
+) {
+  return fitPlanToBox(planWidth, planHeight, boxX, boxY, boxWidth, boxHeight)
+}
+
+export function resolveFloorplanExportViewport(
+  modelBounds: FloorplanExportBounds,
+): FloorplanExportBounds {
+  const padding = Math.max(
+    MIN_PLAN_PADDING_M,
+    Math.max(modelBounds.width, modelBounds.height) * PLAN_PADDING_RATIO,
+  )
+  return {
+    x: modelBounds.x - padding,
+    y: modelBounds.y - padding,
+    width: modelBounds.width + padding * 2,
+    height: modelBounds.height + padding * 2,
+  }
+}
+
+export function rotateFloorplanExportBounds(
+  bounds: FloorplanExportBounds,
+  rotationDeg: number,
+): FloorplanExportBounds {
+  const radians = (rotationDeg * Math.PI) / 180
+  const cosine = Math.cos(radians)
+  const sine = Math.sin(radians)
+  const corners = [
+    [bounds.x, bounds.y],
+    [bounds.x + bounds.width, bounds.y],
+    [bounds.x + bounds.width, bounds.y + bounds.height],
+    [bounds.x, bounds.y + bounds.height],
+  ] as const
+  const rotated = corners.map(([x, y]) => ({
+    x: x * cosine - y * sine,
+    y: x * sine + y * cosine,
+  }))
+  const minX = Math.min(...rotated.map((point) => point.x))
+  const minY = Math.min(...rotated.map((point) => point.y))
+  const maxX = Math.max(...rotated.map((point) => point.x))
+  const maxY = Math.max(...rotated.map((point) => point.y))
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+}
+
+export function resolveFloorplanScreenUnitsPerPixel(
+  modelWidth: number,
+  modelHeight: number,
+  boxWidth: number,
+  boxHeight: number,
+): number {
+  return Math.max(modelWidth / boxWidth, modelHeight / boxHeight)
+}
+
+export function resolveFloorplanExportAnnotationVisibility(
+  mode: FloorplanMode,
+  liveVisibility: FloorplanAnnotationVisibility,
+): FloorplanAnnotationVisibility {
+  return resolveFloorplanAnnotationVisibility(mode, liveVisibility, { target: 'export' })
+}
+
+export function resolveFloorplanExportRotationDeg(
+  buildingRotationY: number,
+  navigationAzimuth?: number,
+): number {
+  const userRotationDeg =
+    navigationAzimuth === undefined
+      ? 0
+      : (navigationAzimuth * 180) / Math.PI - FLOORPLAN_VIEW_ROTATION_DEG
+  return FLOORPLAN_VIEW_ROTATION_DEG + userRotationDeg - (buildingRotationY * 180) / Math.PI
+}
+
 async function mountFloorplanSvg(
   parent: HTMLElement,
-  geometries: { id: AnyNodeId; base: FloorplanGeometry }[],
+  geometries: ExportGeometry[],
   rotationDeg: number,
+  annotationLayoutOverrides = useDrawingView.getState().annotationLayoutOverrides,
 ): Promise<MountedFloorplan | null> {
   const container = document.createElement('div')
   parent.appendChild(container)
@@ -164,101 +577,163 @@ async function mountFloorplanSvg(
     container.remove()
   }
 
-  // Render a full `<svg>` as the React root child so React enters the SVG
-  // namespace at the `<svg>` tag, then mutate the DOM node afterwards —
-  // viewBox/background depend on the post-mount measured bounds.
-  flushSync(() => {
-    root.render(
-      createElement(
-        'svg',
-        { xmlns: SVG_NS },
+  const render = (screenUnitsPerPixel?: number) => {
+    flushSync(() => {
+      root.render(
         createElement(
-          'g',
-          { 'data-floorplan-content': '' },
+          'svg',
+          { xmlns: SVG_NS },
           createElement(
             'g',
-            { transform: `rotate(${rotationDeg})` },
-            geometries.map(({ id, base }) =>
-              createElement(FloorplanGeometryRenderer, { key: id, geometry: base }),
+            { 'data-floorplan-content': '' },
+            createElement(
+              'g',
+              { transform: `rotate(${rotationDeg})` },
+              createElement(
+                'g',
+                { 'data-floorplan-model': '' },
+                geometries.map(({ id, model }) =>
+                  model
+                    ? createElement(FloorplanGeometryRenderer, {
+                        key: id,
+                        geometry: model,
+                        sceneRotationDeg: rotationDeg,
+                      })
+                    : null,
+                ),
+              ),
+              createElement(
+                'g',
+                { 'data-floorplan-annotations': '' },
+                geometries.map(({ id, annotations }) =>
+                  annotations
+                    ? createElement(FloorplanGeometryRenderer, {
+                        key: id,
+                        geometry: annotations,
+                        renderMode: 'pdf',
+                        sceneRotationDeg: rotationDeg,
+                        screenUnitsPerPixel,
+                      })
+                    : null,
+                ),
+              ),
             ),
           ),
         ),
-      ),
-    )
-  })
+      )
+    })
+  }
+
+  render()
 
   // Give async asset images (item icons) a couple of frames to resolve so
   // they're included in the measured bounds and the rendered output.
   await nextFrames(2)
 
   const svg = container.querySelector('svg')
-  const content = svg?.querySelector('[data-floorplan-content]') as SVGGraphicsElement | null
-  const bbox = content?.getBBox()
-  if (!svg || !bbox || bbox.width === 0 || bbox.height === 0) {
+  if (!svg) {
     cleanup()
     return null
   }
 
-  const minX = bbox.x - PADDING_M
-  const minY = bbox.y - PADDING_M
-  const width = bbox.width + PADDING_M * 2
-  const height = bbox.height + PADDING_M * 2
-  svg.setAttribute('viewBox', `${minX} ${minY} ${width} ${height}`)
-  svg.setAttribute('width', `${width}`)
-  svg.setAttribute('height', `${height}`)
+  const modelBounds = measureFloorplanBounds(svg, '[data-floorplan-model]')
+  if (!modelBounds) {
+    cleanup()
+    return null
+  }
+  const viewport = resolveFloorplanExportViewport(
+    rotateFloorplanExportBounds(modelBounds, rotationDeg),
+  )
+  const mounted: MountedFloorplan = {
+    svg,
+    annotationLabelShifts: [],
+    width: viewport.width,
+    height: viewport.height,
+    viewport,
+    cleanup,
+    setScreenUnitsPerPixel: async (value) => {
+      render(value)
+      applyFloorplanViewport(mounted, viewport, value)
+      await nextFrames(1)
+      resolveSvgAnnotationCollisions(svg, { layoutOverrides: annotationLayoutOverrides })
+      mounted.annotationLabelShifts = readSvgAnnotationLabelShifts(svg)
+    },
+  }
+  applyFloorplanViewport(mounted, viewport)
+  return mounted
+}
 
-  const background = document.createElementNS(SVG_NS, 'rect')
-  background.setAttribute('x', `${minX}`)
-  background.setAttribute('y', `${minY}`)
-  background.setAttribute('width', `${width}`)
-  background.setAttribute('height', `${height}`)
-  background.setAttribute('fill', '#ffffff')
-  svg.insertBefore(background, svg.firstChild)
+function readSvgAnnotationLabelShifts(svg: SVGSVGElement): FloorplanPoint[] {
+  return Array.from(svg.querySelectorAll<SVGGElement>('[data-floorplan-annotation-label]')).map(
+    (label) => {
+      const x = Number(label.dataset.floorplanAnnotationLayoutDx ?? 0)
+      const y = Number(label.dataset.floorplanAnnotationLayoutDy ?? 0)
+      return [Number.isFinite(x) ? x : 0, Number.isFinite(y) ? y : 0]
+    },
+  )
+}
 
-  return { svg, width, height, cleanup }
+function measureFloorplanBounds(
+  svg: SVGSVGElement,
+  selector: string,
+): FloorplanExportBounds | null {
+  const content = svg.querySelector(selector) as SVGGraphicsElement | null
+  const bbox = content?.getBBox()
+  if (!bbox || bbox.width === 0 || bbox.height === 0) return null
+  return { x: bbox.x, y: bbox.y, width: bbox.width, height: bbox.height }
 }
 
-/**
- * Bake `vector-effect: non-scaling-stroke` widths into real user units.
- *
- * svg2pdf ignores the non-scaling hint, so a `stroke-width="1.25"` meant as
- * "1.25 screen px" would otherwise render as 1.25 metres on the page. We
- * rewrite each such width (and any dash pattern) to `px / ptPerUnit` so it
- * lands at ~`px` points once svg2pdf scales the plan by `ptPerUnit`, then drop
- * the now-misleading attribute.
- */
-function inlineNonScalingStrokes(svg: SVGSVGElement, ptPerUnit: number) {
-  if (!Number.isFinite(ptPerUnit) || ptPerUnit <= 0) return
-  for (const el of svg.querySelectorAll('[vector-effect="non-scaling-stroke"]')) {
-    const sw = el.getAttribute('stroke-width')
-    if (sw) {
-      const px = Number.parseFloat(sw)
-      if (Number.isFinite(px)) el.setAttribute('stroke-width', `${px / ptPerUnit}`)
-    }
-    const dash = el.getAttribute('stroke-dasharray')
-    if (dash) {
-      const scaled = dash
-        .split(/[\s,]+/)
-        .map((v) => {
-          const n = Number.parseFloat(v)
-          return Number.isFinite(n) ? `${n / ptPerUnit}` : v
-        })
-        .join(' ')
-      el.setAttribute('stroke-dasharray', scaled)
-    }
-    el.removeAttribute('vector-effect')
+export function resolveFloorplanMeasurementSize(
+  viewport: FloorplanExportBounds,
+  screenUnitsPerPixel: number,
+): { width: number; height: number } {
+  return {
+    width: viewport.width / screenUnitsPerPixel,
+    height: viewport.height / screenUnitsPerPixel,
   }
 }
 
+function applyFloorplanViewport(
+  mounted: MountedFloorplan,
+  viewport: FloorplanExportBounds,
+  screenUnitsPerPixel?: number,
+): void {
+  mounted.width = viewport.width
+  mounted.height = viewport.height
+  mounted.svg.setAttribute(
+    'viewBox',
+    `${viewport.x} ${viewport.y} ${viewport.width} ${viewport.height}`,
+  )
+  const measurementSize = screenUnitsPerPixel
+    ? resolveFloorplanMeasurementSize(viewport, screenUnitsPerPixel)
+    : { width: mounted.width, height: mounted.height }
+  mounted.svg.setAttribute('width', `${measurementSize.width}`)
+  mounted.svg.setAttribute('height', `${measurementSize.height}`)
+
+  mounted.svg.querySelector('[data-floorplan-background]')?.remove()
+  const background = document.createElementNS(SVG_NS, 'rect')
+  background.setAttribute('data-floorplan-background', '')
+  background.setAttribute('x', `${viewport.x}`)
+  background.setAttribute('y', `${viewport.y}`)
+  background.setAttribute('width', `${mounted.width}`)
+  background.setAttribute('height', `${mounted.height}`)
+  background.setAttribute('fill', '#ffffff')
+  mounted.svg.insertBefore(background, mounted.svg.firstChild)
+}
+
 function collectFloorplanGeometry(
   nodes: Record<string, AnyNode>,
   levelId: AnyNodeId,
   scope: FloorplanExportScope,
   unit: 'metric' | 'imperial',
-): { id: AnyNodeId; base: FloorplanGeometry }[] {
+  metricNotation: FloorplanMetricNotation,
+  annotationVisibility: FloorplanAnnotationVisibility,
+  drawingType: ConstructionDrawingType,
+  wallDimensionReference: FloorplanWallDimensionReference,
+): ExportGeometry[] {
   const noLiveOverrides = new Map<string, LiveNodeOverrides>()
   const levelNodeIdsByType = new Map<string, AnyNodeId[]>()
-  const entries: { id: AnyNodeId; node: AnyNode }[] = []
+  const entries: { id: AnyNodeId; node: AnyNode; parentOverride?: AnyNode }[] = []
 
   const visit = (id: AnyNodeId) => {
     const node = nodes[id]
@@ -274,13 +749,31 @@ function collectFloorplanGeometry(
       isFloorplanNodeVisible(node) &&
       (scope === 'full' || def.category === 'structure')
     ) {
-      entries.push({ id, node })
+      const drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
+      if (drawingNode) entries.push({ id, node: drawingNode })
     }
     const childIds = (node as { children?: AnyNodeId[] }).children
     if (Array.isArray(childIds)) for (const cid of childIds) visit(cid)
   }
   visit(levelId)
 
+  const activeLevelNode = nodes[levelId]
+  if (activeLevelNode) {
+    const collectedIds = new Set(entries.map((entry) => entry.id))
+    for (const linked of collectFloorplanLinkedLevelNodes(nodes, levelId, collectedIds)) {
+      const definition = nodeRegistry.get(linked.node.type)
+      if (
+        isFloorplanNodeVisible(linked.node) &&
+        (scope === 'full' || definition?.category === 'structure')
+      ) {
+        const drawingNode = resolveNodeForDrawingType(linked.node, nodes, drawingType)
+        if (drawingNode) {
+          entries.push({ id: linked.id, node: drawingNode, parentOverride: activeLevelNode })
+        }
+      }
+    }
+  }
+
   // Document order is paint order — sort the same way the live layer does so
   // zones sit under walls/slabs/furniture rather than on top of them.
   entries.sort((a, b) => floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type))
@@ -288,8 +781,8 @@ function collectFloorplanGeometry(
   // One-shot per-type cache for `computeFloorplanLevelData`; value type is
   // module-private to the registry layer, so let it infer.
   const levelDataCache = new Map()
-  const out: { id: AnyNodeId; base: FloorplanGeometry }[] = []
-  for (const { id, node } of entries) {
+  const out: ExportGeometry[] = []
+  for (const { id, node, parentOverride } of entries) {
     const builder = nodeRegistry.get(node.type)?.floorplan
     if (!builder) continue
     const levelData = getFloorplanLevelData(
@@ -299,15 +792,136 @@ function collectFloorplanGeometry(
       levelNodeIdsByType,
       levelDataCache,
     )
-    const ctx = buildContext(node, nodes, { ...NEUTRAL_VIEW_STATE, unit }, levelData)
+    const baseContext = buildContext(
+      node,
+      nodes,
+      resolveFloorplanExportViewState(
+        unit,
+        metricNotation,
+        wallDimensionReference,
+        annotationVisibility.automaticDimensions,
+      ),
+      levelData,
+    )
+    const ctx = parentOverride ? { ...baseContext, parent: parentOverride } : baseContext
     const geometry = builder(node, ctx)
     if (!geometry) continue
-    const { base } = splitFloorplanOverlay(geometry)
-    if (base) out.push({ id, base })
+    const visibleGeometry = filterFloorplanAnnotationGeometry(geometry, annotationVisibility)
+    if (!visibleGeometry) continue
+    const { base, overlay } = splitFloorplanOverlay(visibleGeometry)
+    const exportOverlay = overlay ? filterFloorplanExportOverlay(overlay) : null
+    const annotationOnly = isFloorplanExportAnnotationGeometry(visibleGeometry)
+    const { model, annotations } = resolveFloorplanExportNodeGeometry(
+      base,
+      exportOverlay,
+      annotationOnly,
+    )
+    if (model || annotations) out.push({ id, model, annotations })
   }
   return out
 }
 
+export function filterFloorplanExportOverlay(
+  geometry: FloorplanGeometry,
+): FloorplanGeometry | null {
+  if (FLOORPLAN_EXPORT_EDITING_KINDS.has(geometry.kind)) return null
+  if (geometry.kind !== 'group') return geometry
+
+  const children = geometry.children
+    .map(filterFloorplanExportOverlay)
+    .filter((child): child is FloorplanGeometry => child !== null)
+  if (children.length === 0) return null
+  return { ...geometry, children }
+}
+
+const FLOORPLAN_EXPORT_EDITING_KINDS = new Set<FloorplanGeometry['kind']>([
+  'endpoint-handle',
+  'midpoint-handle',
+  'edge-handle',
+  'move-handle',
+  'move-arrow',
+  'rotate-arrow',
+])
+
+type FloorplanExportOverlayPartition = {
+  model: FloorplanGeometry | null
+  annotations: FloorplanGeometry | null
+}
+
+export function resolveFloorplanExportNodeGeometry(
+  base: FloorplanGeometry | null,
+  overlay: FloorplanGeometry | null,
+  annotationOnly: boolean,
+): FloorplanExportOverlayPartition {
+  const combined = combineGeometry(base, overlay)
+  if (annotationOnly) return { model: null, annotations: combined }
+  return combined ? partitionFloorplanExportOverlay(combined) : { model: null, annotations: null }
+}
+
+export function partitionFloorplanExportOverlay(
+  geometry: FloorplanGeometry,
+): FloorplanExportOverlayPartition {
+  if (FLOORPLAN_EXPORT_EDITING_KINDS.has(geometry.kind)) {
+    return { model: null, annotations: null }
+  }
+  if (isFloorplanExportAnnotationGeometry(geometry)) {
+    return { model: null, annotations: filterFloorplanExportOverlay(geometry) }
+  }
+  if (geometry.kind !== 'group') {
+    return { model: geometry, annotations: null }
+  }
+
+  const modelChildren: FloorplanGeometry[] = []
+  const annotationChildren: FloorplanGeometry[] = []
+  for (const child of geometry.children) {
+    const partition = partitionFloorplanExportOverlay(child)
+    if (partition.model) modelChildren.push(partition.model)
+    if (partition.annotations) annotationChildren.push(partition.annotations)
+  }
+  return {
+    model:
+      modelChildren.length > 0
+        ? { kind: 'group', children: modelChildren, transform: geometry.transform }
+        : null,
+    annotations:
+      annotationChildren.length > 0
+        ? { kind: 'group', children: annotationChildren, transform: geometry.transform }
+        : null,
+  }
+}
+
+export function isFloorplanExportAnnotationGeometry(geometry: FloorplanGeometry): boolean {
+  if (
+    geometry.kind === 'text' ||
+    geometry.kind === 'dimension' ||
+    geometry.kind === 'dimension-string' ||
+    geometry.kind === 'dimension-label' ||
+    geometry.kind === 'equal-spacing-badge'
+  ) {
+    return true
+  }
+  if (readFloorplanGeometryMetadata(geometry).annotationRole) return true
+  return false
+}
+
+function combineGeometry(
+  base: FloorplanGeometry | null,
+  overlay: FloorplanGeometry | null,
+): FloorplanGeometry | null {
+  if (!base) return overlay
+  if (!overlay) return base
+  return { kind: 'group', children: [base, overlay] }
+}
+
+function combineGeometryList(
+  geometries: readonly (FloorplanGeometry | null)[],
+): FloorplanGeometry | null {
+  const children = geometries.filter((geometry): geometry is FloorplanGeometry => geometry !== null)
+  if (children.length === 0) return null
+  if (children.length === 1) return children[0] ?? null
+  return { kind: 'group', children }
+}
+
 /**
  * Levels to export, ordered bottom-to-top. The active building (the building
  * owning the selected level, or the first one found) contributes all of its