@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/orbit-near-plane.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, test } from 'bun:test'
+import { CLOSE_UP_NEAR, ORBIT_NEAR, orbitNearPlane } from './orbit-near-plane'
+
+describe('the orbit near plane follows the eye in', () => {
+  test("standing back it is the viewer's own; close in, a tenth of the distance; never under an inch-off look", () => {
+    expect(orbitNearPlane(40)).toBe(ORBIT_NEAR)
+    expect(orbitNearPlane(3)).toBe(ORBIT_NEAR)
+    expect(orbitNearPlane(1)).toBeCloseTo(0.1, 9)
+    expect(orbitNearPlane(0.5)).toBeCloseTo(0.05, 9)
+    expect(orbitNearPlane(0.01)).toBe(CLOSE_UP_NEAR)
+  })
+})

package/src/lib/orbit-near-plane.ts

@@ -0,0 +1,13 @@
+/** The viewer's near plane (`viewerCameraClipping`), kept while the eye stands back. */
+export const ORBIT_NEAR = 0.3
+/** How close the near plane comes in when the eye does: a casing seen from an inch off. */
+export const CLOSE_UP_NEAR = 0.01
+
+/**
+ * The near plane for an orbit `distance` from its target: a tenth of it, between `CLOSE_UP_NEAR`
+ * and the viewer's own, so zooming in on a window's trim never clips it while the eye standing
+ * back keeps the depth precision it had.
+ */
+export function orbitNearPlane(distance: number): number {
+  return Math.min(ORBIT_NEAR, Math.max(CLOSE_UP_NEAR, distance * 0.1))
+}

package/src/lib/paint-regions.test.ts

@@ -136,10 +136,11 @@ describe('paint region sub-mode', () => {
   })
 
   test('off anything it draws on, the HUD says where to go: a floor for Polygon', () => {
-    expect(paintRegionHints('polygon', null, false).map((hint) => hint.label)).toEqual([
-      'Hover a floor or ceiling',
-      'Cancel',
-    ])
+    expect(
+      paintRegionHints('polygon', null, false).map((hint) =>
+        typeof hint.label === 'string' ? hint.label : hint.label.message,
+      ),
+    ).toEqual(['Hover a floor or ceiling', 'Cancel'])
     expect(paintRegionHints('rectangle', null, false)[0]).toMatchObject({
       label: 'Hover a wall, floor or ceiling',
       active: true,
@@ -158,7 +159,9 @@ describe('paint region sub-mode', () => {
 
 test('the whole-surface HUD says what a click does; only painting teaches the held eyedropper', () => {
   const labels = (mode: Parameters<typeof paintHints>[0]) =>
-    paintHints(mode).map((hint) => hint.label)
+    paintHints(mode).map((hint) =>
+      typeof hint.label === 'string' ? hint.label : (hint.label.message ?? ''),
+    )
   expect(labels('surface')).toEqual(['Hold to pick a material'])
   expect(labels('erase')).toEqual(['Remove a painted part, or reset a surface'])
   expect(labels('erase').some((label) => /pick|colour|color|paint with/i.test(label))).toBe(false)

package/src/lib/paint-scope.test.ts

@@ -790,3 +790,56 @@ describe('generated floor plates: scopes per surface', () => {
     expect(paintScopeRole(manual, 'surface', 'room')).toBe('surface')
   })
 })
+
+describe('a surface that declares its own scopes', () => {
+  it('offers its scopes and labels and paints the role it names for the scope', () => {
+    const kind = 'paint-surface-scope-test'
+    if (!nodeRegistry.has(kind))
+      registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }) as never,
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: {
+          slots: () => [{ slotId: 'end:1', label: 'End' }],
+          paint: {
+            resolveRole: () => null,
+            buildPatch: () => ({}),
+            applyPreview: () => null,
+            roleLabel: (_node: AnyNode, role: string) => (role === 'end:1' ? 'This end' : null),
+            scopes: (_node: AnyNode, role: string) =>
+              role === 'end:1'
+                ? {
+                    scopes: ['single', 'matching'],
+                    labels: { matching: 'Every end' },
+                    roleFor: (scope: PaintScope) => (scope === 'matching' ? 'ends:all' : role),
+                  }
+                : null,
+          },
+        },
+        floorplanScope: 'level',
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+      } as unknown as AnyNodeDefinition)
+    const node = { id: 'scoped_1', type: kind } as unknown as AnyNode
+    const hover = paintHoverInfo(node, 'end:1', [])
+    expect(hover.scopes).toEqual(['single', 'matching'])
+    expect(paintScopeLabel('single', hover)).toBe('This end')
+    expect(paintScopeLabel('matching', hover)).toBe('Every end')
+    const targets = (scope: PaintScope) =>
+      resolvePaintScopeTargets({
+        node,
+        role: 'end:1',
+        scope,
+        nodes: { scoped_1: node },
+        spaces: {},
+        slotRolesOf: () => [],
+      }).map((target) => `${target.nodeId}:${target.role}`)
+    expect(targets('single')).toEqual(['scoped_1:end:1'])
+    expect(targets('matching')).toEqual(['scoped_1:ends:all'])
+    // a scope the surface does not offer paints the surface alone
+    expect(targets('room')).toEqual(['scoped_1:end:1'])
+    // other roles of the kind keep the derived set
+    expect(availablePaintScopes({ node, slotRoles: [], role: 'side' })).toEqual(['single'])
+  })
+})

package/src/lib/paint-scope.ts

@@ -55,6 +55,11 @@ function nodeOffersRoomScope(node: AnyNode): boolean {
   return nodeRegistry.get(node.type)?.capabilities?.paint?.roomScope === true
 }
 
+/** The scopes the hovered surface declares for itself (`capabilities.paint.scopes`), if any. */
+function surfaceScopes(node: AnyNode, role: string) {
+  return nodeRegistry.get(node.type)?.capabilities?.paint?.scopes?.(node, role) ?? null
+}
+
 const isFloorPlate = (node: AnyNode): boolean => node.type === 'slab' && node.boundary === 'auto'
 
 const FOOTPRINT_FACE_LABELS: Record<string, string> = {
@@ -104,6 +109,8 @@ export function availablePaintScopes(args: {
   if (args.node.type === 'wall') return ['single', 'room']
   const plate = args.role === undefined ? null : platePaintScopes(args.node, args.role)
   if (plate) return plate.scopes
+  const own = args.role === undefined ? null : surfaceScopes(args.node, args.role)
+  if (own) return own.scopes
   const scopes: PaintScope[] = ['single']
   if (args.slotRoles.length > 1) scopes.push('object')
   if (nodeHasAsset(args.node)) scopes.push('matching')
@@ -123,7 +130,7 @@ export function paintHoverInfo(node: AnyNode, role: string, slotRoles: string[])
     scopes: availablePaintScopes({ node, slotRoles, role }),
     slotLabel: paintSurfaceLabel(node, role),
     nodeNoun: node.type,
-    labels: platePaintScopes(node, role)?.labels,
+    labels: platePaintScopes(node, role)?.labels ?? surfaceScopes(node, role)?.labels,
   }
 }
 
@@ -168,12 +175,13 @@ export function paintSurfaceLabel(node: AnyNode, role: string): string {
   return slotDisplayLabel(node, role)
 }
 
-/** Display label for the hovered slot — declared label wins, else derived from the id. */
+/** Display label for the hovered slot, with a capability override for contextual copy. */
 export function slotDisplayLabel(node: AnyNode, role: string): string {
   const capabilities = nodeRegistry.get(node.type)?.capabilities
+  const roleLabel = capabilities?.paint?.roleLabel?.(node, role)
+  if (roleLabel) return roleLabel
   const declared = capabilities?.slots?.(node)?.find((slot) => slot.slotId === role)
-  if (declared) return declared.label
-  return capabilities?.paint?.roleLabel?.(node, role) ?? slotLabelFromId(role)
+  return declared?.label ?? slotLabelFromId(role)
 }
 
 // ── Fan-out resolution ──────────────────────────────────────────────────────
@@ -506,6 +514,12 @@ export function resolvePaintScopeTargets(args: {
       .map((other) => ({ nodeId: other.id, role: stepRole }))
     return targets.length ? targets : [{ nodeId: node.id as AnyNodeId, role: stepRole }]
   }
+  // A surface with its own scope set paints the role it names for the scope.
+  const own = surfaceScopes(node, role)
+  if (own) {
+    const roleFor = own.roleFor?.(effectivePaintScope(scope, own.scopes)) ?? role
+    return [{ nodeId: node.id as AnyNodeId, role: roleFor }]
+  }
   if (scope === 'single') return single
 
   // Whole object: paint every slot of the clicked node. Generic across any

package/src/lib/panel-rows.ts

@@ -65,19 +65,28 @@ export const PANEL_MODEL_EXTENSION = 'pascal:editor/panel-model'
 /**
  * A control the multi-selection inspector renders for every selected node of
  * a kind at once (derived settings the raw parametrics can't express). `value`
- * null means the selection is mixed: no option shows as active.
+ * null means the selection is mixed: no option shows as active. `segmented`
+ * suits a few short options, `select` a longer list; `readout` only shows a
+ * value the selection cannot edit here.
  */
 export type MultiPanelControl = {
   id: string
-  kind: 'segmented'
-  /** The parametrics group title the control sits in. */
+  /**
+   * The section the control sits in: a parametrics group title, or a section
+   * of its own, shown after the groups in the order controls name them.
+   */
   section: string
   label: string
-  options: ReadonlyArray<{ value: string; label: string }>
-  value: string | null
-  /** Applies to every selected node in one undo step. */
-  onChange: (value: string) => void
-}
+} & (
+  | {
+      kind: 'segmented' | 'select'
+      options: ReadonlyArray<{ value: string; label: string }>
+      value: string | null
+      /** Applies to every selected node in one undo step. */
+      onChange: (value: string) => void
+    }
+  | { kind: 'readout'; value: string; detail?: string }
+)
 
 export type NodePanelModel<N extends AnyNode = AnyNode> = {
   rows: (context: {

package/src/lib/placement-metadata.ts

@@ -17,6 +17,10 @@ export function isFreshPlacementMetadata(metadata: unknown): boolean {
   return getPlacementMetadataRecord(metadata).isNew === true
 }
 
+export function stripPlacementMetadataFlags(
+  metadata: Record<string, unknown>,
+): Record<string, unknown>
+export function stripPlacementMetadataFlags(metadata: unknown): unknown
 export function stripPlacementMetadataFlags(metadata: unknown): unknown {
   if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
     return metadata

package/src/lib/point-ask/describe-target.ts

@@ -1,25 +1,23 @@
 import {
   type AnyNode,
   area,
+  formatLinearMeasurement,
+  getAreaUnitLabel,
   getScaledDimensions,
   getWallCurveLength,
   getWallEffectiveHeightForNodes,
   getWallThickness,
   type ItemNode,
+  type LinearUnit,
+  type MetricNotation,
   resolveLevelId,
   type SlabNode,
   type StairNode,
+  squareMetersToAreaUnit,
   type WallNode,
   type WindowNode,
   type ZoneNode,
 } from '@pascal-app/core'
-import {
-  formatLinearMeasurement,
-  getAreaUnitLabel,
-  type LinearUnit,
-  type MetricNotation,
-  squareMetersToAreaUnit,
-} from '../measurements'
 import type { PointKind, PointTarget } from './types'
 
 // Point and ask names what the finger is on (the owner, 8 October): the label chip and the
@@ -115,7 +113,7 @@ const roomOfWall = (nodes: Nodes, levelId: string, wallId: string) =>
 
 function wallHeight(wall: WallNode, nodes: Nodes): number {
   try {
-    const height = getWallEffectiveHeightForNodes(wall, nodes as Record<string, AnyNode>)
+    const height = getWallEffectiveHeightForNodes(wall, nodes as Record<string, AnyNode>, 0)
     if (Number.isFinite(height) && height > 0) return height
   } catch {
     // No slab election to consult in a bare scene: the wall's own height stands.

package/src/lib/point-ask/region.ts

@@ -1,4 +1,4 @@
-import { formatLinearMeasurement } from '../measurements'
+import { formatLinearMeasurement } from '@pascal-app/core'
 import type { Rect, ScreenPoint } from './types'
 
 // A region is a view, not a selection (spec 2.3, "A region is a view, not a selection"): a

package/src/lib/print-shell-compiler.ts

@@ -148,8 +148,19 @@ function preparedWallHeight(
       },
     }
   }
+  if (Math.abs(node.endHeightOffset ?? 0) > 1e-5) {
+    return {
+      height: null,
+      diagnostic: {
+        severity: 'error',
+        code: 'unsupported_wall_print_slope',
+        message: `Wall ${node.id} has a sloped top that does not yet have a canonical printable solid.`,
+        nodeIds: [node.id],
+      },
+    }
+  }
 
-  const height = getWallEffectiveHeightForNodes(node, nodes)
+  const height = getWallEffectiveHeightForNodes(node, nodes, 0)
   if (!Number.isFinite(height) || height <= 1e-7) {
     return {
       height: null,

package/src/lib/print-wall-solids.test.ts

@@ -155,6 +155,11 @@ describe('buildPrintableWallSolids', () => {
       { effectiveHeight: 2.5 },
       { [shaped.id]: shaped },
     )
+    const sloped = buildPrintableWallSolids(
+      { ...wall, endHeightOffset: 1.0 },
+      { effectiveHeight: 2.5 },
+      { [shaped.id]: shaped },
+    )
     const terrain = buildPrintableWallSolids(
       { ...wall, children: [], fillToTerrain: true },
       { effectiveHeight: 2.5 },
@@ -172,6 +177,12 @@ describe('buildPrintableWallSolids', () => {
         diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_curve' })],
       }),
     )
+    expect(sloped).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_slope' })],
+      }),
+    )
     expect(terrain).toEqual(
       expect.objectContaining({
         status: 'blocked',

package/src/lib/print-wall-solids.ts

@@ -27,6 +27,7 @@ export type PrintWallSolidDiagnostic = {
   code:
     | 'invalid_wall_print_dimensions'
     | 'unsupported_wall_print_curve'
+    | 'unsupported_wall_print_slope'
     | 'unsupported_wall_print_terrain'
     | 'unsupported_wall_print_opening_shape'
     | 'invalid_wall_print_opening'
@@ -258,6 +259,14 @@ export function buildPrintableWallSolids(
       nodeIds: [node.id],
     })
   }
+  if (Math.abs(node.endHeightOffset ?? 0) > DIMENSION_EPSILON) {
+    diagnostics.push({
+      severity: 'error',
+      code: 'unsupported_wall_print_slope',
+      message: `Sloped wall ${node.id} does not yet have a canonical printable solid.`,
+      nodeIds: [node.id],
+    })
+  }
   if (node.fillToTerrain) {
     diagnostics.push({
       severity: 'error',

package/src/lib/reference-scale.ts

@@ -0,0 +1,83 @@
+import { formatNumber, type GuideScaleReference } from '@pascal-app/core'
+
+export type ReferenceScaleUnit = 'meters' | 'centimeters' | 'feet' | 'inches'
+
+const MAX_REFERENCE_SCALE_LABEL_LENGTH = 64
+
+/** Mirrors `GuideScaleReference.displayLength`'s `.max()` in core. */
+export const MAX_REFERENCE_SCALE_DISPLAY_LENGTH = 1_000_000
+
+export function isValidReferenceScaleDisplayLength(value: number): boolean {
+  return Number.isFinite(value) && value > 0 && value <= MAX_REFERENCE_SCALE_DISPLAY_LENGTH
+}
+
+const REFERENCE_SCALE_UNIT_LABELS: Record<ReferenceScaleUnit, string> = {
+  meters: 'm',
+  centimeters: 'cm',
+  feet: 'ft',
+  inches: 'in',
+}
+
+function formatScaleValue(value: number, unit: string, locale: string): string {
+  return `${formatNumber(value, { locale, max: 2 })} ${unit}`
+}
+
+function getReferenceScaleUnitLabel(unit: unknown): string | null {
+  if (typeof unit !== 'string' || !Object.hasOwn(REFERENCE_SCALE_UNIT_LABELS, unit)) return null
+  return REFERENCE_SCALE_UNIT_LABELS[unit as ReferenceScaleUnit]
+}
+
+function parseLegacyScaleLabel(label: string): { unit: string; value: number } | null {
+  // `\s` covers NBSP and narrow NBSP; the whitespace run and digit group are
+  // disjoint, so each repetition has exactly one way to match.
+  const match = label.trim().match(/^([+−-]?[\d.,]+(?:\s+[\d.,]+)*)\s*(m|cm|ft|in)$/i)
+  if (!match) return null
+
+  const compact = match[1]!.replace(/\s/g, '').replace('−', '-')
+  const lastDot = compact.lastIndexOf('.')
+  const lastComma = compact.lastIndexOf(',')
+  const separatorIndex = Math.max(lastDot, lastComma)
+  const trailingDigits = separatorIndex === -1 ? 0 : compact.length - separatorIndex - 1
+  const decimalSeparator =
+    separatorIndex !== -1 && trailingDigits > 0 && trailingDigits <= 2
+      ? compact[separatorIndex]
+      : null
+  const normalized = decimalSeparator
+    ? `${compact.slice(0, separatorIndex).replace(/[.,]/g, '')}.${compact
+        .slice(separatorIndex + 1)
+        .replace(/[.,]/g, '')}`
+    : compact.replace(/[.,]/g, '')
+
+  if (!/^[+-]?\d+(?:\.\d+)?$/.test(normalized)) return null
+  const value = Number(normalized)
+  return Number.isFinite(value) ? { unit: match[2]!.toLowerCase(), value } : null
+}
+
+export function createGuideScaleReference(
+  reference: Omit<GuideScaleReference, 'displayLength' | 'displayUnit' | 'label'>,
+  displayLength: number,
+  displayUnit: ReferenceScaleUnit,
+): GuideScaleReference {
+  const unitLabel = REFERENCE_SCALE_UNIT_LABELS[displayUnit]
+  const label = formatScaleValue(displayLength, unitLabel, 'en')
+  if (!isValidReferenceScaleDisplayLength(displayLength)) return { ...reference, label }
+  return { ...reference, displayLength, displayUnit, label }
+}
+
+export function formatReferenceScaleLabel(reference: GuideScaleReference, locale: string): string {
+  const unitLabel = getReferenceScaleUnitLabel(reference.displayUnit)
+  if (
+    typeof reference.displayLength === 'number' &&
+    Number.isFinite(reference.displayLength) &&
+    unitLabel
+  ) {
+    return formatScaleValue(reference.displayLength, unitLabel, locale)
+  }
+
+  const label: unknown = reference.label
+  if (typeof label !== 'string') return typeof label === 'number' ? String(label) : ''
+  if (label.length > MAX_REFERENCE_SCALE_LABEL_LENGTH) return label
+
+  const parsed = parseLegacyScaleLabel(label)
+  return parsed ? formatScaleValue(parsed.value, parsed.unit, locale) : label
+}

package/src/lib/room-assembly-overlay.ts

@@ -77,7 +77,7 @@ export function resolveRoomAssemblyHeights(
     const wall = nodes[id]
     if (wall?.type !== 'wall') continue
     const base = getWallBaseElevationForNodes(wall, sceneNodes)
-    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base))
+    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base, 0.5))
   }
   const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined
   const ceiling =

package/src/lib/room-built-on.test.ts

@@ -3,10 +3,12 @@ import {
   type AnyNode,
   BuildingNode,
   clearSceneHistory,
+  createI18n,
   createZone,
   generateId,
   initSpaceDetectionSync,
   LevelNode,
+  roomFloorElevation,
   SlabNode,
   type SlabNode as SlabNodeType,
   useScene,
@@ -23,11 +25,7 @@ import {
   setRoomRelativeFloorHeight,
   stepRoomFloorElevation,
 } from './room-construction-commands'
-import {
-  commitRoomElevation,
-  ownFloorElevationBounds,
-  roomFloorElevation,
-} from './room-handle-drag'
+import { commitRoomElevation, ownFloorElevationBounds } from './room-handle-drag'
 import { applyRoomPlan } from './room-structure-commands'
 import { showRoomNotice, useRoomTransform } from './room-transform-session'
 
@@ -67,6 +65,7 @@ const scene = (...nodes: AnyNode[]): Record<string, AnyNode> =>
 const living = zone('zone_living', 'Living', rect(0, 0, 4, 4))
 const lanai = zone('zone_lanai', 'Lanai', rect(4, 0, 6, 4))
 const keyedLanai = zone('zone_lanai', 'Lanai', rect(4, 0, 6, 4), 'floor_lanai')
+const english = createI18n()
 const length = (meters: number) => `${meters.toFixed(2)} m`
 
 describe('Built on: when the picker shows and what it offers', () => {
@@ -116,7 +115,11 @@ describe('Built on: when the picker shows and what it offers', () => {
     expect(model.shared).toBeNull()
     expect(separateFloorOffset(nodes, keyedLanai.id)).toBeNull()
     expect(
-      separateFloorSummary({ ...model, offset: separateFloorOffset(nodes, keyedLanai.id) }, length),
+      separateFloorSummary(
+        { ...model, offset: separateFloorOffset(nodes, keyedLanai.id) },
+        length,
+        english,
+      ),
     ).toBe('Lanai floor')
   })
 
@@ -159,18 +162,22 @@ describe('Built on: the Floor row summary', () => {
   const lanaiFloor = { name: 'Lanai floor' }
   test('says how a separate floor sits against the shared floor', () => {
     const shared = { name: 'Shared floor' }
-    expect(separateFloorSummary({ current: lanaiFloor, shared, offset: -0.15 }, length)).toBe(
-      'Lanai floor · 0.15 m below Shared floor',
-    )
     expect(
-      separateFloorSummary({ current: lanaiFloor, shared: { name: 'Cabin' }, offset: 0.3 }, length),
+      separateFloorSummary({ current: lanaiFloor, shared, offset: -0.15 }, length, english),
+    ).toBe('Lanai floor · 0.15 m below Shared floor')
+    expect(
+      separateFloorSummary(
+        { current: lanaiFloor, shared: { name: 'Cabin' }, offset: 0.3 },
+        length,
+        english,
+      ),
     ).toBe('Lanai floor · 0.30 m above Cabin')
-    expect(separateFloorSummary({ current: lanaiFloor, shared, offset: 0.002 }, length)).toBe(
-      'Lanai floor · level with Shared floor',
-    )
-    expect(separateFloorSummary({ current: lanaiFloor, shared: null, offset: null }, length)).toBe(
-      'Lanai floor',
-    )
+    expect(
+      separateFloorSummary({ current: lanaiFloor, shared, offset: 0.002 }, length, english),
+    ).toBe('Lanai floor · level with Shared floor')
+    expect(
+      separateFloorSummary({ current: lanaiFloor, shared: null, offset: null }, length, english),
+    ).toBe('Lanai floor')
   })
 
   test("compares the room's walking surface with the shared-floor room beside it, not plate with plate", () => {
@@ -188,7 +195,11 @@ describe('Built on: the Floor row summary', () => {
     expect(separateFloorOffset(nodes, keyedLanai.id)).toBeCloseTo(-0.3)
     const model = roomBuiltOn(nodes, keyedLanai.id)!
     expect(
-      separateFloorSummary({ ...model, offset: separateFloorOffset(nodes, keyedLanai.id) }, length),
+      separateFloorSummary(
+        { ...model, offset: separateFloorOffset(nodes, keyedLanai.id) },
+        length,
+        english,
+      ),
     ).toBe('Lanai floor · 0.30 m below Living floor')
     // Nothing shared across a wall or open side: the shared plate's top.
     expect(separateFloorOffset(scene(raised, keyedLanai, house, own), keyedLanai.id)).toBeCloseTo(

package/src/lib/room-built-on.ts

@@ -1,11 +1,12 @@
 import {
   type AnyNode,
   roomFloorChoices as coreRoomFloorChoices,
+  levelFootprints,
+  type PascalI18n,
   roomDrawnFloor,
   type SlabNode,
   type ZoneNode,
 } from '@pascal-app/core'
-import { levelFootprints } from './floor-footprints'
 
 // "Built on": which floor a room stands on. By default a room is part of its
 // connected footprint's shared floor (`floor.footprint` absent); a floor key
@@ -60,20 +61,6 @@ export function roomFloorChoices(nodes: Nodes, zoneId: string): PlateChoice[] {
     .map(({ key, plateId, name }) => ({ key, plateId, name }))
 }
 
-/**
- * The plate a room on a separate floor stands on alone: its height is that
- * plate's floor height (nothing else stands on it). Null for a room on the
- * shared floor or sharing its separate floor with other rooms.
- */
-export function roomOwnPlate(nodes: Nodes, zoneId: string): SlabNode | null {
-  const zone = nodes[zoneId]
-  if (!isRoom(zone) || !zone.floor?.footprint || zone.floor.support === 'open') return null
-  const plate = listingPlate(nodes, zone)
-  if (!plate) return null
-  const alone = !(plate.zoneIds ?? []).some((id) => id !== zoneId && isGroundRoom(nodes[id]))
-  return alone ? plate : null
-}
-
 /**
  * The shared floor beside a room on a separate floor, where it goes back to.
  * For a room on the shared floor, its own plate.
@@ -130,9 +117,26 @@ export function roomBuiltOn(nodes: Nodes, zoneId: string): RoomBuiltOnModel | nu
 export function separateFloorSummary(
   model: { current: { name: string }; shared: { name: string } | null; offset: number | null },
   length: (meters: number) => string,
+  i18n: PascalI18n,
 ): string {
   const { current, shared, offset } = model
   if (!shared || offset === null) return current.name
-  if (Math.abs(offset) < 0.005) return `${current.name} · level with ${shared.name}`
-  return `${current.name} · ${length(Math.abs(offset))} ${offset > 0 ? 'above' : 'below'} ${shared.name}`
+  const values = { current: current.name, shared: shared.name, distance: length(Math.abs(offset)) }
+  if (Math.abs(offset) < 0.005)
+    return i18n._({
+      id: 'editor.room.builtOn.levelWith',
+      message: '{current} · level with {shared}',
+      values,
+    })
+  return offset > 0
+    ? i18n._({
+        id: 'editor.room.builtOn.above',
+        message: '{current} · {distance} above {shared}',
+        values,
+      })
+    : i18n._({
+        id: 'editor.room.builtOn.below',
+        message: '{current} · {distance} below {shared}',
+        values,
+      })
 }

package/src/lib/room-construction-commands.ts

@@ -17,7 +17,9 @@ import {
   type NodeChange,
   planWallJustification,
   resolveCeilingHeight,
+  roomFloorElevation,
   roomFloorElevationFromRelative,
+  roomOwnPlate,
   roomSideFaces,
   runAsSingleSceneHistoryStep,
   type StructureConflict,
@@ -32,13 +34,12 @@ import useDeleteConfirmation, {
 } from '../store/use-delete-confirmation'
 import useEditor from '../store/use-editor'
 import { footprintHeightValue } from './floor-footprints'
-import { roomOwnPlate, roomSharedFootprint } from './room-built-on'
+import { roomSharedFootprint } from './room-built-on'
 import { roomClearPolygon, roomConstructionState, roomFloorContents } from './room-construction'
 import {
   mezzanineElevationBounds,
   ownFloorElevationBounds,
   planRoomElevation,
-  roomFloorElevation,
 } from './room-handle-drag'
 import { applyRoomPlan } from './room-structure-commands'
 import { showRoomNotice } from './room-transform-session'

package/src/lib/room-construction.test.ts

@@ -4,6 +4,7 @@ import {
   area,
   BuildingNode,
   CeilingNode,
+  ColumnNode,
   clearSceneHistory,
   createZone,
   DoorNode,
@@ -25,7 +26,12 @@ import { deleteConfirmationContent } from '../components/editor/delete-confirmat
 import { constructionActions, wallsSwitch } from '../components/ui/panels/room-construction-rows'
 import useDeleteConfirmation from '../store/use-delete-confirmation'
 import useEditor from '../store/use-editor'
-import { roomClearPolygon, roomConstructionState, roomFloorContents } from './room-construction'
+import {
+  roomClearPolygon,
+  roomConstructionState,
+  roomFloorContents,
+  roomPorchFramingCounts,
+} from './room-construction'
 import {
   addRoomConstruction,
   adoptExistingCeiling,
@@ -177,6 +183,27 @@ describe('room construction state', () => {
     expect(constructionActions(room, 'floor')).toEqual({ add: false, remove: true })
   })
 
+  test('porch framing counts the room’s generated parts by marker, across node kinds', () => {
+    const zone = nodes()[zoneId as AnyNodeId] as ZoneNode
+    const parts = [
+      ColumnNode.parse({ metadata: { porchOf: zoneId, porchPart: 'corner:0' } }),
+      ItemNode.parse({
+        ...item('item_side_post', 'Post', LEVEL, [0, 0, 0]),
+        metadata: { porchOf: zoneId, porchPart: 'side:0:1' },
+      }),
+      ColumnNode.parse({ metadata: { porchOf: zoneId, porchPart: 'beam:0' } }),
+      ColumnNode.parse({ metadata: { porchOf: 'zone_other', porchPart: 'corner:0' } }),
+      ColumnNode.parse({}),
+    ]
+    const level = nodes()[LEVEL as AnyNodeId] as LevelNode
+    const scene = {
+      ...nodes(),
+      ...Object.fromEntries(parts.map((part) => [part.id, part])),
+      [level.id]: { ...level, children: [...level.children, ...parts.map((part) => part.id)] },
+    }
+    expect(roomPorchFramingCounts(scene, zone)).toEqual({ posts: 2, beams: 1 })
+  })
+
   test('memoized per nodes identity', () => {
     expect(roomConstructionState(nodes(), zoneId)).toBe(roomConstructionState(nodes(), zoneId))
     expect(roomConstructionState(nodes(), 'zone_missing')).toBeNull()