@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/floorplan/dimension-drive.ts

@@ -1,5 +1,5 @@
 import type { AnyNode, AnyNodeId, DoorNode, WallNode, WindowNode } from '@pascal-app/core'
-import { getLinkedWallUpdates } from '@pascal-app/core'
+import { getLinkedWallUpdates, normalizeDecimalInput } from '@pascal-app/core'
 
 /**
  * Driving dimensions — WS3.
@@ -34,8 +34,9 @@ const INCHES_PER_METER = 1 / 0.0254
 export function parseDimensionInput(
   raw: string,
   unit: 'metric' | 'imperial' = 'metric',
+  locale = 'en',
 ): number | null {
-  const text = raw.trim().toLowerCase().replace(/\s+/g, ' ')
+  const text = normalizeDecimalInput(raw, locale).trim().toLowerCase().replace(/\s+/g, ' ')
   if (!text) return null
 
   // Explicit metric suffix.
@@ -119,6 +120,17 @@ export type DimensionDriveTarget =
       openingId: AnyNodeId
       wallId: AnyNodeId
     }
+  | {
+      /**
+       * The dimension runs across the wall, from one of its faces to another
+       * wall (a room width, the outside size): the whole wall slides along
+       * its normal, its neighbours following, as a push of the wall does.
+       */
+      kind: 'wall-offset'
+      wallId: AnyNodeId
+      /** Unit vector the wall travels along when the value grows. */
+      direction: DimensionPlanPoint
+    }
 
 export type DimensionDriveResolution =
   | { drivable: true; target: DimensionDriveTarget }
@@ -173,7 +185,7 @@ function resolveWallDrive(
   const wallDirection = unit(subtract(wall.end, wall.start))
   if (!wallDirection) return { drivable: false, reason: 'degenerate wall' }
   if (Math.abs(cross(wallDirection, dimDirection)) > PARALLEL_TOLERANCE) {
-    return { drivable: false, reason: 'dimension is not along the wall' }
+    return resolveWallOffsetDrive(query, wall, wallDirection, dimDirection)
   }
   if ((wall as { curvature?: number }).curvature) {
     return { drivable: false, reason: 'curved walls are not drivable yet' }
@@ -209,6 +221,56 @@ function resolveWallDrive(
   }
 }
 
+/** How far off a wall's face a witness point may sit and still be on that wall. */
+const FACE_MATCH_TOLERANCE_M = 0.05
+
+/**
+ * A dimension square to the wall, with one end on it: typing a value slides
+ * the wall along its normal, away from the other end when the value grows.
+ */
+function resolveWallOffsetDrive(
+  query: DimensionDriveQuery,
+  wall: WallNode,
+  wallDirection: DimensionPlanPoint,
+  dimDirection: DimensionPlanPoint,
+): DimensionDriveResolution {
+  if (Math.abs(dot(wallDirection, dimDirection)) > PARALLEL_TOLERANCE) {
+    return { drivable: false, reason: 'dimension is neither along nor across the wall' }
+  }
+  if (wall.curveOffset) return { drivable: false, reason: 'curved walls are not drivable yet' }
+  const reach = (wall.thickness ?? 0.1) + FACE_MATCH_TOLERANCE_M
+  const onWall = (point: DimensionPlanPoint) =>
+    distanceToSegment(point, wall.start as DimensionPlanPoint, wall.end as DimensionPlanPoint) <=
+    reach
+  const startOn = onWall(query.start)
+  const endOn = onWall(query.end)
+  if (startOn === endOn) {
+    return { drivable: false, reason: 'dimension does not start or end on this wall' }
+  }
+  const direction = startOn
+    ? unit(subtract(query.start, query.end))
+    : unit(subtract(query.end, query.start))
+  if (!direction) return { drivable: false, reason: 'degenerate dimension' }
+  return {
+    drivable: true,
+    target: { kind: 'wall-offset', wallId: wall.id as AnyNodeId, direction },
+  }
+}
+
+function distanceToSegment(
+  point: DimensionPlanPoint,
+  start: DimensionPlanPoint,
+  end: DimensionPlanPoint,
+): number {
+  const segment = subtract(end, start)
+  const lengthSq = dot(segment, segment)
+  const t =
+    lengthSq <= 1e-12
+      ? 0
+      : Math.max(0, Math.min(1, dot(subtract(point, start), segment) / lengthSq))
+  return length(subtract(point, [start[0] + segment[0] * t, start[1] + segment[1] * t]))
+}
+
 function resolveOpeningDrive(
   query: DimensionDriveQuery,
   opening: DoorNode | WindowNode,
@@ -359,6 +421,9 @@ export function planDimensionDrive(args: {
 }): DimensionDrivePlan | null {
   const delta = args.nextLength - args.currentLength
   if (!Number.isFinite(delta) || Math.abs(delta) < 1e-9) return { updates: [], delta: 0 }
+  // A wall offset moves the wall with its junctions re-planned, bridges and
+  // all: that is the wall-push planner's job (`commitDimensionValue`).
+  if (args.target.kind === 'wall-offset') return null
 
   if (args.target.kind === 'opening-width') {
     const opening = args.nodes[args.target.openingId]

package/src/lib/floorplan/floorplan-export.test.ts

@@ -311,16 +311,27 @@ describe('floor plan export policy', () => {
       stairAnnotations: true,
     }
 
-    expect(resolveFloorplanExportAnnotationVisibility('expert', liveVisibility)).toEqual(
+    expect(resolveFloorplanExportAnnotationVisibility('expert', liveVisibility, true)).toEqual(
       liveVisibility,
     )
   })
 
+  test('exports no automatic dimensions while Display → Dimensions is off', () => {
+    expect(
+      resolveFloorplanExportAnnotationVisibility(
+        'expert',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        false,
+      ),
+    ).toEqual({ ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, automaticDimensions: false })
+  })
+
   test('exports only model geometry and room labels in Default', () => {
     expect(
       resolveFloorplanExportAnnotationVisibility(
         'default',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        true,
       ),
     ).toEqual({
       automaticDimensions: false,
@@ -700,7 +711,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
 
@@ -758,7 +769,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       expect(upper.map(({ id }) => id)).toEqual(['site_overlay', 'level_upper_architecture'])
@@ -775,7 +786,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       // A hidden Site hides only its own ground and boundary; the site-scoped
@@ -790,7 +801,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       expect(structure.map(({ id }) => id)).toEqual(['level_architecture'])

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

@@ -44,15 +44,11 @@ import { resolveNodeForDrawingType } from './drawing-coordination'
 import {
   type FloorplanMetricNotation,
   type FloorplanSchedule,
-  type FloorplanWallDimensionReference,
+  type FloorplanWallDimensionFaces,
   getFloorplanNodeExtension,
   readFloorplanGeometryMetadata,
 } from './floorplan-extension'
-import {
-  type FloorplanMode,
-  resolveFloorplanAnnotationVisibility,
-  resolveFloorplanWallDimensionReference,
-} from './floorplan-mode'
+import { type FloorplanMode, resolveFloorplanAnnotationVisibility } from './floorplan-mode'
 import { createFloorplanPdfDocument, type FloorplanPdfDocument } from './floorplan-pdfkit-document'
 import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
 import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
@@ -131,7 +127,7 @@ const NEUTRAL_VIEW_STATE = {
 export function resolveFloorplanExportViewState(
   unit: 'metric' | 'imperial',
   metricNotation: FloorplanMetricNotation,
-  wallDimensionReference?: FloorplanWallDimensionReference,
+  wallDimensionFaces?: FloorplanWallDimensionFaces,
   automaticDimensions = true,
 ) {
   return {
@@ -139,7 +135,7 @@ export function resolveFloorplanExportViewState(
     automaticDimensions,
     unit,
     metricNotation,
-    wallDimensionReference,
+    wallDimensionFaces,
   }
 }
 
@@ -195,10 +191,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
   const annotationVisibility = resolveFloorplanExportAnnotationVisibility(
     floorplanMode,
     expertAnnotationState.visibility,
-  )
-  const wallDimensionReference = resolveFloorplanWallDimensionReference(
-    floorplanMode,
-    expertAnnotationState.wallDimensionReference,
+    expertAnnotationState.showDimensions,
   )
   const navigationAzimuth = useEditor.getState().navigationSyncPose?.azimuth
   const drawingType = useDrawingView.getState().drawingType
@@ -232,7 +225,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
         metricNotation,
         annotationVisibility,
         drawingType,
-        wallDimensionReference,
+        expertAnnotationState.wallDimensionFaces,
         installedPlugins,
       )
       const schedules = collectFloorplanSchedules(nodes, level.id, unit, scope)
@@ -604,8 +597,12 @@ export function resolveFloorplanScreenUnitsPerPixel(
 export function resolveFloorplanExportAnnotationVisibility(
   mode: FloorplanMode,
   liveVisibility: FloorplanAnnotationVisibility,
+  dimensions: boolean,
 ): FloorplanAnnotationVisibility {
-  return resolveFloorplanAnnotationVisibility(mode, liveVisibility, { target: 'export' })
+  return resolveFloorplanAnnotationVisibility(mode, liveVisibility, {
+    target: 'export',
+    dimensions,
+  })
 }
 
 export function resolveFloorplanExportRotationDeg(
@@ -785,7 +782,7 @@ export function collectFloorplanGeometry(
   metricNotation: FloorplanMetricNotation,
   annotationVisibility: FloorplanAnnotationVisibility,
   drawingType: ConstructionDrawingType,
-  wallDimensionReference: FloorplanWallDimensionReference,
+  wallDimensionFaces: FloorplanWallDimensionFaces,
   /** `undefined` = legacy scene without install state: every loaded kind draws. */
   installedPlugins: readonly string[] | undefined,
 ): ExportGeometry[] {
@@ -907,7 +904,7 @@ export function collectFloorplanGeometry(
       resolveFloorplanExportViewState(
         unit,
         metricNotation,
-        wallDimensionReference,
+        wallDimensionFaces,
         annotationVisibility.automaticDimensions,
       ),
       levelData,

package/src/lib/floorplan/floorplan-extension.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'bun:test'
 import type { GeometryContext } from '@pascal-app/core'
 import {
   createFloorplanContextExtensions,
-  normalizeFloorplanWallDimensionReference,
+  normalizeFloorplanWallDimensionFaces,
   readFloorplanContext,
 } from './floorplan-extension'
 
@@ -17,22 +17,21 @@ function context(extensions?: Readonly<Record<string, unknown>>): GeometryContex
 }
 
 describe('floor-plan context extensions', () => {
-  test('defaults wall dimensions to finished faces', () => {
-    expect(readFloorplanContext(context()).wallDimensionReference).toBe('finished-faces')
+  test('measures walls to both faces by default', () => {
+    expect(readFloorplanContext(context()).wallDimensionFaces).toBe('both')
   })
 
-  test('carries the selected centerline or stud-face reference', () => {
-    for (const wallDimensionReference of ['centerline', 'stud-faces'] as const) {
-      const extensions = createFloorplanContextExtensions({ wallDimensionReference })
-      expect(readFloorplanContext(context(extensions)).wallDimensionReference).toBe(
-        wallDimensionReference,
-      )
+  test('carries the Measure walls choice', () => {
+    for (const wallDimensionFaces of ['interior', 'exterior', 'both'] as const) {
+      const extensions = createFloorplanContextExtensions({ wallDimensionFaces })
+      expect(readFloorplanContext(context(extensions)).wallDimensionFaces).toBe(wallDimensionFaces)
     }
   })
 
-  test('normalizes stale persisted references to the finished-face default', () => {
-    expect(normalizeFloorplanWallDimensionReference('unknown')).toBe('finished-faces')
-    expect(normalizeFloorplanWallDimensionReference(null)).toBe('finished-faces')
+  test('normalizes stale persisted values, including the retired references, to Both', () => {
+    for (const stale of ['finished-faces', 'centerline', 'stud-faces', 'unknown', null]) {
+      expect(normalizeFloorplanWallDimensionFaces(stale)).toBe('both')
+    }
   })
 
   test('lets presentation code suppress automatic annotation construction', () => {

package/src/lib/floorplan/floorplan-extension.ts

@@ -8,6 +8,7 @@ import type {
   SceneApi,
 } from '@pascal-app/core'
 import type { ComponentType } from 'react'
+import type { WallSelectionDimension } from '../room-push-dimensions'
 
 export const FLOORPLAN_NODE_EXTENSION_KEY = 'pascal:editor/floorplan'
 export const FLOORPLAN_GEOMETRY_METADATA_KEY = 'pascal:editor/floorplan'
@@ -16,8 +17,20 @@ export const FLOORPLAN_CONTEXT_EXTENSION_KEY = 'pascal:editor/floorplan'
 export type FloorplanRenderPurpose = 'edit' | 'document'
 export type FloorplanMetricNotation = 'meters' | 'millimeters'
 export type FloorplanToolMode = 'default' | 'expert'
-export type FloorplanWallDimensionReference = 'finished-faces' | 'centerline' | 'stud-faces'
-export const DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE = 'finished-faces'
+/**
+ * Display → Measure walls: which finished faces wall dimensions measure to —
+ * the interior faces (ID, the room sizes), the exterior faces (OD, the
+ * outside size) or both. Read by a selected wall's temporary dimensions in 2D
+ * and 3D and by the Expert plan's automatic dimension strings.
+ */
+export type FloorplanWallDimensionFaces = 'interior' | 'exterior' | 'both'
+export const DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES: FloorplanWallDimensionFaces = 'both'
+
+export function normalizeFloorplanWallDimensionFaces(value: unknown): FloorplanWallDimensionFaces {
+  return value === 'interior' || value === 'exterior'
+    ? value
+    : DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES
+}
 export type FloorplanAnnotationRole =
   | 'automatic-dimension'
   | 'contextual-dimension'
@@ -67,6 +80,24 @@ export type FloorplanNodeExtension<N extends AnyNode = AnyNode> = {
   preferredView?: '2d' | '3d'
   referencedSelectionAnnotationRole?: FloorplanAnnotationRole
   contextualDimensions?: (node: N, ctx: GeometryContext) => FloorplanGeometry | null
+  /**
+   * A plan hit on this kind selects the node itself, not the room it bounds
+   * (3D stays room-first). For thin boundary bands whose rooms are clickable
+   * on either side of them.
+   */
+  planHitSelectsNode?: boolean
+  /**
+   * Temporary dimensions shown while this node is selected in Select mode,
+   * alone or with others, in 2D and 3D (level-local plan points). Its
+   * `contextualDimensions` also stay in a multi-selection. Each is typeable:
+   * `commitDimensionValue` drives the node so it reads the typed value.
+   * Recomputed when the node or its level's rooms change.
+   */
+  selectionDimensions?: (args: {
+    node: N
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>
+    faces: FloorplanWallDimensionFaces
+  }) => readonly WallSelectionDimension[]
   actionMenu?: {
     canCurve?: (args: { node: N; nodes: Readonly<Record<AnyNodeId, AnyNode>> }) => boolean
     /** Buttons the kind adds to the selection's action menu (2D and 3D); each decides its own visibility. */
@@ -130,15 +161,7 @@ type FloorplanContextExtension = {
    */
   roomLabelOverlay: boolean
   metricNotation: FloorplanMetricNotation
-  wallDimensionReference: FloorplanWallDimensionReference
-}
-
-export function normalizeFloorplanWallDimensionReference(
-  value: unknown,
-): FloorplanWallDimensionReference {
-  return value === 'centerline' || value === 'stud-faces'
-    ? value
-    : DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE
+  wallDimensionFaces: FloorplanWallDimensionFaces
 }
 
 export function getFloorplanNodeExtension(
@@ -185,9 +208,7 @@ export function createFloorplanContextExtensions(
       drafting: values.drafting === true,
       roomLabelOverlay: values.roomLabelOverlay === true,
       metricNotation: values.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
-      wallDimensionReference: normalizeFloorplanWallDimensionReference(
-        values.wallDimensionReference,
-      ),
+      wallDimensionFaces: normalizeFloorplanWallDimensionFaces(values.wallDimensionFaces),
     } satisfies FloorplanContextExtension,
   }
 }
@@ -202,9 +223,7 @@ export function readFloorplanContext(ctx: GeometryContext): FloorplanContextExte
       drafting: extension.drafting === true,
       roomLabelOverlay: extension.roomLabelOverlay === true,
       metricNotation: extension.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
-      wallDimensionReference: normalizeFloorplanWallDimensionReference(
-        extension.wallDimensionReference,
-      ),
+      wallDimensionFaces: normalizeFloorplanWallDimensionFaces(extension.wallDimensionFaces),
     }
   }
   return {
@@ -213,7 +232,7 @@ export function readFloorplanContext(ctx: GeometryContext): FloorplanContextExte
     drafting: false,
     roomLabelOverlay: false,
     metricNotation: 'meters',
-    wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+    wallDimensionFaces: DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
   }
 }
 

package/src/lib/floorplan/floorplan-mode.test.ts

@@ -5,7 +5,6 @@ import {
   normalizeFloorplanMode,
   normalizeFloorplanModesByProject,
   resolveFloorplanAnnotationVisibility,
-  resolveFloorplanWallDimensionReference,
 } from './floorplan-mode'
 
 describe('floor-plan mode', () => {
@@ -115,10 +114,18 @@ describe('floor-plan mode', () => {
     })
   })
 
-  test('uses centerline dimensions only in Default', () => {
-    expect(resolveFloorplanWallDimensionReference('default', 'finished-faces')).toBe('centerline')
-    expect(resolveFloorplanWallDimensionReference('expert', 'finished-faces')).toBe(
-      'finished-faces',
-    )
+  test('Dimensions off hides automatic and contextual dimensions in both modes', () => {
+    for (const mode of ['default', 'expert'] as const) {
+      const visibility = resolveFloorplanAnnotationVisibility(
+        mode,
+        { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, contextualDimensions: true },
+        { selected: true, target: 'editor', dimensions: false },
+      )
+      expect(visibility.automaticDimensions).toBe(false)
+      expect(visibility.contextualDimensions).toBe(false)
+      // Drawn dimensions and measurements are the user's own: they stay.
+      expect(visibility.manualDimensions).toBe(true)
+      expect(visibility.measurements).toBe(true)
+    }
   })
 })

package/src/lib/floorplan/floorplan-mode.ts

@@ -2,11 +2,7 @@ import {
   type FloorplanAnnotationVisibility,
   revealFloorplanAnnotationRole,
 } from './annotation-visibility'
-import type {
-  FloorplanAnnotationRole,
-  FloorplanToolMode,
-  FloorplanWallDimensionReference,
-} from './floorplan-extension'
+import type { FloorplanAnnotationRole, FloorplanToolMode } from './floorplan-extension'
 
 export const FLOORPLAN_MODES = ['default', 'expert'] as const
 
@@ -18,6 +14,8 @@ export type FloorplanPresentationContext = {
   referencedAnnotationRole?: FloorplanAnnotationRole
   selected?: boolean
   target: 'editor' | 'export'
+  /** Display → Dimensions. Off hides the automatic and contextual dimensions in either mode. */
+  dimensions?: boolean
 }
 
 export function normalizeFloorplanMode(value: unknown): FloorplanMode {
@@ -45,6 +43,17 @@ export function resolveFloorplanAnnotationVisibility(
   mode: FloorplanMode,
   expertVisibility: FloorplanAnnotationVisibility,
   context: FloorplanPresentationContext,
+): FloorplanAnnotationVisibility {
+  const visibility = resolveModeAnnotationVisibility(mode, expertVisibility, context)
+  if (context.dimensions !== false) return visibility
+  if (!visibility.automaticDimensions && !visibility.contextualDimensions) return visibility
+  return { ...visibility, automaticDimensions: false, contextualDimensions: false }
+}
+
+function resolveModeAnnotationVisibility(
+  mode: FloorplanMode,
+  expertVisibility: FloorplanAnnotationVisibility,
+  context: FloorplanPresentationContext,
 ): FloorplanAnnotationVisibility {
   if (mode === 'expert') return expertVisibility
 
@@ -66,10 +75,3 @@ export function resolveFloorplanAnnotationVisibility(
     ? revealFloorplanAnnotationRole(visibility, context.referencedAnnotationRole)
     : visibility
 }
-
-export function resolveFloorplanWallDimensionReference(
-  mode: FloorplanMode,
-  expertReference: FloorplanWallDimensionReference,
-): FloorplanWallDimensionReference {
-  return mode === 'default' ? 'centerline' : expertReference
-}

package/src/lib/floorplan/floorplan-plugin-install.test.tsx

@@ -90,7 +90,7 @@ function exportedIds(installedPlugins: readonly string[] | undefined) {
     'meters',
     DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
     'floor-plan',
-    'finished-faces',
+    'both',
     installedPlugins,
   ).map(({ id }) => id)
 }

package/src/lib/floorplan/floorplan-readonly.ts

@@ -1,7 +1,7 @@
 import type { AnyNode, AnyNodeId, FloorplanPalette, GeometryContext } from '@pascal-app/core'
 import {
   createFloorplanContextExtensions,
-  type FloorplanWallDimensionReference,
+  type FloorplanWallDimensionFaces,
 } from './floorplan-extension'
 
 export type FloorplanViewState = {
@@ -14,7 +14,7 @@ export type FloorplanViewState = {
   drafting?: boolean
   /** Room labels drawn as screen pills (see `FloorplanContextExtension.roomLabelOverlay`). */
   roomLabelOverlay?: boolean
-  wallDimensionReference?: FloorplanWallDimensionReference
+  wallDimensionFaces?: FloorplanWallDimensionFaces
   highlighted: boolean
   hovered: boolean
   moving: boolean
@@ -65,7 +65,7 @@ export function buildFloorplanContext(
       purpose: viewState.purpose ?? 'edit',
       drafting: viewState.drafting === true,
       roomLabelOverlay: viewState.roomLabelOverlay === true,
-      wallDimensionReference: viewState.wallDimensionReference,
+      wallDimensionFaces: viewState.wallDimensionFaces,
     }),
     viewState: viewState.palette
       ? {

package/src/lib/floorplan/open-wall-ends.ts

@@ -1,11 +1,12 @@
 import {
+  formatLinearMeasurement,
+  type LinearUnit,
   type OpenWallEnd,
   planJoinOpenWallEnd,
   runAsSingleSceneHistoryStep,
   useScene,
   type WallJoinResult,
 } from '@pascal-app/core'
-import { formatLinearMeasurement, type LinearUnit } from '../measurements'
 
 const JOIN_REFUSALS: Record<Extract<WallJoinResult, { ok: false }>['reason'], string> = {
   'covered-existing-wall': 'An existing wall already covers this span',

package/src/lib/floorplan/schedules.ts

@@ -1,5 +1,5 @@
 import type { AnyNode, AnyNodeId, DoorNode, WallNode, WindowNode, ZoneNode } from '@pascal-app/core'
-import { deriveZoneQuantityReport } from '@pascal-app/core'
+import { deriveZoneQuantityReport, resolveHostedOpeningFrameDepth } from '@pascal-app/core'
 import { collectFloorplanSchedules } from './floorplan-export'
 import type { FloorplanSchedule } from './floorplan-extension'
 import { resolveMarkDetail } from './marks'
@@ -150,7 +150,7 @@ function openingRow(
         ? `${formatScheduleLength(opening.roughOpeningWidth, unit)} x ${formatScheduleLength(opening.roughOpeningHeight, unit)}`
         : null,
     material: openingMaterial(opening),
-    frame: openingFrame(opening, unit),
+    frame: openingFrame(opening, nodes, unit),
     hardware: opening.type === 'door' ? doorHardware(opening as DoorNode) : null,
     count: 1,
     remarks: remarks.join('; '),
@@ -190,10 +190,14 @@ function openingMaterial(opening: DoorNode | WindowNode): string | null {
   return null
 }
 
-function openingFrame(opening: DoorNode | WindowNode, unit: ScheduleUnit): string | null {
-  const thickness = (opening as DoorNode).frameThickness
-  const depth = (opening as DoorNode).frameDepth
-  if (typeof thickness !== 'number' || typeof depth !== 'number') return null
+function openingFrame(
+  opening: DoorNode | WindowNode,
+  nodes: Readonly<Record<string, AnyNode>>,
+  unit: ScheduleUnit,
+): string | null {
+  const thickness = opening.frameThickness
+  if (typeof thickness !== 'number') return null
+  const depth = resolveHostedOpeningFrameDepth(opening, nodes)
   return `${formatScheduleLength(thickness, unit)} / ${formatScheduleLength(depth, unit)}`
 }
 

package/src/lib/floorplan/site-plan/site-annotations.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from 'bun:test'
-import { createTerrainField, type LevelNode, quantize, type SceneSnapshot } from '@pascal-app/core'
+import {
+  createTerrainField,
+  LevelNode,
+  quantize,
+  type SceneSnapshot,
+  SlabNode,
+  ZoneNode,
+} from '@pascal-app/core'
 import { buildSitePlanDrawing, setbacksWarning } from './build-site-plan-drawing'
 import { registerSitePlanContributor } from './contributors'
 import { computeSiteCoverage } from './coverage'
@@ -14,6 +21,7 @@ import {
   streetEdgeNames,
   UNNAMED_STREET,
 } from './site-annotations'
+import { outdoorParts } from './site-parts'
 
 /** The QA lot (4121 NW 34th St, Gainesville): a through lot, NW 34th Terrace on the west edge (1), NW 34th Street on the east (3). */
 const LOT: [number, number][] = [
@@ -436,6 +444,43 @@ describe('the setbacks line a plans examiner reads', () => {
 })
 
 describe('the finish floor elevation', () => {
+  test('outdoor plates use their room type for site parts and stay out of the house floor elevation', () => {
+    const polygon: [number, number][] = [
+      [0, 0],
+      [2, 0],
+      [2, 2],
+      [0, 2],
+    ]
+    const room = ZoneNode.parse({ name: 'Deck', roomType: 'deck', polygon })
+    const plate = SlabNode.parse({
+      zoneIds: [room.id],
+      plateRole: 'sunken',
+      polygon,
+      elevation: 0.4,
+    })
+    const floor = SlabNode.parse({
+      plateRole: 'base',
+      zoneIds: [room.id],
+      polygon: [],
+      elevation: 0.05,
+    })
+    const level = LevelNode.parse({ children: [plate.id, floor.id, room.id] })
+    for (const metadata of [{}, { floor: 'porch-slab' }]) {
+      const scene = {
+        nodes: {
+          [level.id]: level,
+          [room.id]: room,
+          [plate.id]: { ...plate, metadata },
+          [floor.id]: floor,
+        },
+      } as unknown as SceneSnapshot
+      expect(outdoorParts(scene, level, null, [], [])).toMatchObject([
+        { id: plate.id, kind: 'deck', wood: true },
+      ])
+      expect(floorTops(scene, level)).toEqual({ floor: 0.05, garage: null })
+    }
+  })
+
   test('the driveway and walk (flatwork, no floor tag) never become the FF', () => {
     const nodes = {
       level_0: {

package/src/lib/floorplan/site-plan/site-annotations.ts

@@ -11,7 +11,9 @@ import {
   type AnyNodeId,
   type BuildingNode,
   type FloorplanGeometry,
+  floorPlateRoom,
   heightAt,
+  isOutdoorRoomType,
   type LevelNode,
   outwardNormal,
   type SceneSnapshot,
@@ -1072,6 +1074,7 @@ export function floorTops(
     if (n?.type !== 'slab') continue
     // the driveway and walks are paving at grade, never the finish floor
     if (flatworkKindOf(n)) continue
+    if (isOutdoorRoomType(floorPlateRoom(n, (id) => scene.nodes[id])?.roomType)) continue
     const tag = n.metadata?.floor
     const top = typeof n.elevation === 'number' ? n.elevation : 0.05
     if (tag === 'garage-slab-at-grade') garage = garage === null ? top : Math.min(garage, top)