@pascal-app/editor 1.0.7 → 1.1.1

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/point-ask/session.ts

@@ -18,6 +18,7 @@ import {
 } from '@pascal-app/core'
 import { sceneViewBounds, sceneViewPose } from '@pascal-app/core/agent-operations'
 import { retractNodes, useViewer } from '@pascal-app/viewer'
+import { cameraPoseStore, useFollowPascal } from '@pascal-app/viewer/ui'
 import { type Object3D, Vector2, Vector3 } from 'three'
 import {
   resolveRoofSegmentSelectionTarget,
@@ -25,9 +26,7 @@ import {
 } from '../../components/editor/selection-manager'
 import { getEditorThreeContext } from '../../components/editor/three-context-bridge'
 import { resolveEditorRoomHit } from '../../hooks/use-selected-room'
-import { cameraPoseStore } from '../../store/camera-pose-store'
 import useEditor, { getActiveContinuationContext } from '../../store/use-editor'
-import useFollowPascal from '../../store/use-follow-pascal'
 import useInteractionScope from '../../store/use-interaction-scope'
 import {
   type BubbleTarget,

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/roof-duplication.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  BaseNode,
+  LevelNode,
+  nodeRegistry,
+  nodeType,
+  objectId,
+  RoofNode,
+  RoofSegmentNode,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { z } from 'zod'
+import { duplicateRoofSubtree } from './roof-duplication'
+
+// A plugin's solved roof plane: a face of the roof holding it (`capabilities.roofs`).
+const RoofPlane = BaseNode.extend({
+  id: objectId('roofplane'),
+  type: nodeType('test:roof-plane'),
+  polygon: z.array(z.tuple([z.number(), z.number()])),
+})
+const roofPlanes = {
+  kind: 'test:roof-plane',
+  schemaVersion: 1,
+  schema: RoofPlane,
+  category: 'structure',
+  defaults: () => ({}),
+  capabilities: {
+    roofs: {
+      outline: (node: AnyNode) => (node as unknown as z.infer<typeof RoofPlane>).polygon,
+      heightAt: () => 2.9,
+    },
+  },
+} as unknown as AnyNodeDefinition
+
+const LEVEL_ID = 'level_roof-duplicate' as AnyNodeId
+const ROOF_ID = 'roof_original' as AnyNodeId
+const SEGMENT_ID = 'rseg_original' as AnyNodeId
+const PLANE_ID = 'roofplane_original' as AnyNodeId
+const POLYGON: [number, number][] = [
+  [0, 0],
+  [8, 0],
+  [8, 3],
+]
+
+let restoreRegistry = () => {}
+const previousScene = useScene.getState()
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  registerNode(roofPlanes)
+  useScene.setState({
+    nodes: {
+      [LEVEL_ID]: LevelNode.parse({ id: LEVEL_ID, children: [ROOF_ID] }) as AnyNode,
+      [ROOF_ID]: RoofNode.parse({
+        id: ROOF_ID,
+        parentId: LEVEL_ID,
+        children: [SEGMENT_ID, PLANE_ID],
+      }) as AnyNode,
+      [SEGMENT_ID]: RoofSegmentNode.parse({ id: SEGMENT_ID, parentId: ROOF_ID }) as AnyNode,
+      [PLANE_ID]: RoofPlane.parse({
+        id: PLANE_ID,
+        parentId: ROOF_ID,
+        polygon: POLYGON,
+      }) as unknown as AnyNode,
+    },
+    rootNodeIds: [LEVEL_ID],
+    collections: {},
+    dirtyNodes: new Set(),
+  } as never)
+})
+
+afterEach(() => {
+  restoreRegistry()
+  useViewer.getState().setSelection({ selectedIds: [] })
+  useScene.setState(previousScene)
+  useScene.temporal.getState().clear()
+})
+
+describe('duplicateRoofSubtree', () => {
+  test("copies the roof's faces of other kinds with it, as they stand in its frame", () => {
+    const { roof } = duplicateRoofSubtree(ROOF_ID, { mode: 'select' })
+    const nodes = useScene.getState().nodes
+    const copied = (nodes[roof.id as AnyNodeId] as RoofNode).children.map(
+      (id) => nodes[id as AnyNodeId]!,
+    )
+
+    expect(copied.map((node): string => node.type)).toEqual(['roof-segment', 'test:roof-plane'])
+    const plane = copied[1] as unknown as z.infer<typeof RoofPlane>
+    expect(plane.id).not.toBe(PLANE_ID)
+    expect(plane.id.startsWith('roofplane_')).toBe(true)
+    expect(plane.parentId).toBe(roof.id)
+    expect(plane.polygon).toEqual(POLYGON)
+    expect((nodes[ROOF_ID] as RoofNode).children).toEqual([SEGMENT_ID, PLANE_ID])
+  })
+})

package/src/lib/roof-duplication.ts

@@ -1,13 +1,16 @@
 'use client'
 
 import {
+  type AnyNode,
   type AnyNodeId,
   collectionIdsOf,
   generateId,
+  nodeRegistry,
   type RoofNode,
   RoofNode as RoofNodeSchema,
   type RoofSegmentNode,
   RoofSegmentNode as RoofSegmentNodeSchema,
+  roofFaceOf,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -121,6 +124,23 @@ export function duplicateRoofSubtree(
     segmentSourceIds.push(childNode.id)
   }
 
+  // Its faces of other kinds (`capabilities.roofs`) are copied by their own schema, in the copy's
+  // frame as in the source's; a face that does not parse fails the copy, as a segment does.
+  const faceClones: { node: AnyNode; sourceId: AnyNodeId }[] = []
+  for (const childId of sourceRoof.children ?? []) {
+    const childNode = scene.nodes[childId as AnyNodeId]
+    const schema =
+      childNode && roofFaceOf(childNode) ? nodeRegistry.get(childNode.type)?.schema : undefined
+    if (!(childNode && schema)) continue
+    const { id: _id, ...fields } = structuredClone(childNode)
+    const node = schema.parse({
+      ...fields,
+      parentId: roofClone.id,
+      metadata: buildDuplicateMetadata(childNode.metadata),
+    }) as AnyNode
+    faceClones.push({ node, sourceId: childNode.id })
+  }
+
   // Each copy is in the collections its source is in.
   scene.createNodes([
     { node: roofClone, parentId, collectionIds: collectionIdsOf(scene.collections, sourceRoofId) },
@@ -129,6 +149,11 @@ export function duplicateRoofSubtree(
       parentId: roofClone.id as AnyNodeId,
       collectionIds: collectionIdsOf(scene.collections, segmentSourceIds[index]!),
     })),
+    ...faceClones.map(({ node, sourceId }) => ({
+      node,
+      parentId: roofClone.id as AnyNodeId,
+      collectionIds: collectionIdsOf(scene.collections, sourceId),
+    })),
   ])
 
   const nextScene = useScene.getState()
@@ -148,12 +173,12 @@ export function duplicateRoofSubtree(
 
   const segmentIds = segmentClones.map((segment) => segment.id)
   const createdChildIds = (createdRoof.children ?? []) as AnyNodeId[]
-  const missingSegmentId = segmentIds.find(
-    (segmentId) => !createdChildIds.includes(segmentId as AnyNodeId),
+  const missingChildId = [...segmentIds, ...faceClones.map(({ node }) => node.id)].find(
+    (childId) => !createdChildIds.includes(childId as AnyNodeId),
   )
-  if (missingSegmentId) {
+  if (missingChildId) {
     throw new Error(
-      `Duplicated roof "${createdRoof.id}" is missing cloned segment "${missingSegmentId}"`,
+      `Duplicated roof "${createdRoof.id}" is missing cloned child "${missingChildId}"`,
     )
   }
 
@@ -206,7 +231,7 @@ export function clearRoofDuplicateMetadata(
 
   for (const childId of roofNode.children ?? []) {
     const childNode = scene.nodes[childId as AnyNodeId]
-    if (childNode?.type !== 'roof-segment') {
+    if (!childNode) {
       continue
     }
 

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

@@ -8,6 +8,7 @@ import {
   generateId,
   initSpaceDetectionSync,
   LevelNode,
+  roomFloorElevation,
   SlabNode,
   type SlabNode as SlabNodeType,
   useScene,
@@ -24,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'
 

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

@@ -1,12 +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
@@ -61,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.

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-controls-phase6.test.ts

@@ -9,6 +9,7 @@ import {
   generateId,
   initSpaceDetectionSync,
   LevelNode,
+  roomFloorElevation,
   structureChangeBatch,
   useLiveNodeOverrides,
   useScene,
@@ -33,7 +34,6 @@ import {
   getActiveRoomHandleDrag,
   planRoomPush,
   previewRoomPush,
-  roomFloorElevation,
   roomPushHandles,
   runRoomHandleDrag,
   selectedWallDimensions,

package/src/lib/room-handle-drag.ts

@@ -16,12 +16,15 @@ import {
   type Point,
   planWallDivision,
   resolveMovedWallSupportSlabPatch,
+  roomFloorElevation,
+  roomOwnPlate,
   runAsSingleSceneHistoryStep,
   SEPARATOR_JOIN_REACH,
   type SeparatorNode,
   type SeparatorSpan,
   type StructureNodes,
   type StructurePlan,
+  separatorFloorElevation,
   setRoomFloorConstruction,
   setWallGeometry,
   setZoneEdges,
@@ -31,8 +34,9 @@ import {
   useLiveNodeOverrides,
   useScene,
   type WallNode,
+  type WallPushArrowPayload,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { isTypingTarget, useViewer } from '@pascal-app/viewer'
 import type { Ray } from 'three'
 import { create } from 'zustand'
 import { ARROW_COLOR } from '../components/editor/handles/handle-arrow'
@@ -46,7 +50,6 @@ import { clientToPlan } from './floorplan/plan-coords'
 import { beginGesture } from './gesture-lifecycle'
 import { isHistoryShortcut } from './history'
 import { MEZZANINE_FAILED_MESSAGE, mezzanineConflictMessage } from './mezzanine-messages'
-import { roomOwnPlate } from './room-built-on'
 import {
   mezzanineEdgeDimensions,
   type RoomDimension,
@@ -62,7 +65,6 @@ import { applyRoomPlan } from './room-structure-commands'
 import { levelSeparatorLines, separatorWallLine } from './separator-lines'
 import { sfxEmitter } from './sfx-bus'
 import { type SpatialPointerId, spatialPointerInput } from './spatial-pointer-input'
-import { isTypingTarget } from './typing-target'
 import {
   nearestWallParallelTarget,
   publishWallParallelGuide,
@@ -146,19 +148,6 @@ export const useRoomHandleDrag = create<{ drag: RoomHandleDrag | null }>(() => (
 
 type Nodes = Record<string, AnyNode>
 
-/** The walking surface of a room: its own elevation, else its plate's. */
-export function roomFloorElevation(nodes: Nodes, zoneId: string): number {
-  const zone = nodes[zoneId]
-  if (zone?.type !== 'zone') return 0
-  const own = roomOwnPlate(nodes, zoneId)
-  if (own) return own.elevation
-  if (typeof zone.floor?.elevation === 'number') return zone.floor.elevation
-  const plate = Object.values(nodes).find(
-    (node) => node.type === 'slab' && node.zoneIds?.includes(zoneId),
-  )
-  return plate?.type === 'slab' ? (plate.elevation ?? 0.05) : 0.05
-}
-
 /**
  * The stretch of a wall a push moves: `[0, 1]` is the whole wall (its
  * neighbours follow through the junction planner), anything shorter is split
@@ -206,7 +195,7 @@ function wallPushHandle(
   const offsets = getWallFaceOffsets(wall)
   const face = side === 'a' ? offsets.a : -offsets.b
   const offset = Math.max(face + HANDLE_OFFSET, HANDLE_MIN_OFFSET)
-  const wallHeight = getWallEffectiveHeightForNodes(wall, nodes)
+  const wallHeight = getWallEffectiveHeightForNodes(wall, nodes, 0.5)
   return {
     key,
     wallId: wall.id,
@@ -396,14 +385,6 @@ export function separatorPushHandles(separator: SeparatorNode, floor = 0): WallP
   })
 }
 
-/** The floor an invisible wall lies on: the walking surface of a room it closes, else 0. */
-export function separatorFloorElevation(nodes: Nodes, separatorId: string): number {
-  const zone = Object.values(nodes).find(
-    (node) => node.type === 'zone' && node.boundarySeparatorIds.includes(separatorId),
-  )
-  return zone ? roomFloorElevation(nodes, zone.id) : 0
-}
-
 /**
  * Snaps a push the way the wall move always has: the wall's reference line
  * (not the travel) lands on the grid lattice along its normal, so an off-grid
@@ -642,7 +623,7 @@ function previewPushPlan(
             start: change.node.start,
             end: change.node.end,
             thickness: change.node.thickness ?? 0.1,
-            height: getWallEffectiveHeightForNodes(change.node, nodes),
+            height: getWallEffectiveHeightForNodes(change.node, nodes, 0),
           },
         ]
       : []
@@ -1403,7 +1384,7 @@ export function beginWallGroupPush(wallIds: readonly string[], levelId: string):
       {
         wall,
         base,
-        top: base + getWallEffectiveHeightForNodes(wall, nodes),
+        top: base + getWallEffectiveHeightForNodes(wall, nodes, 0),
         normal: wallPushNormal(wall),
         rooms: pushDimensionRooms(nodes, levelId, { wallId: wall.id, t0: 0, t1: 1 }, base),
       },
@@ -1488,16 +1469,6 @@ export function wallPointAt(wall: WallNode, t: number): Point {
   return [frame.point.x, frame.point.y]
 }
 
-/**
- * The affordance a floor-plan `move-arrow` carries to be a wall push arrow;
- * its payload is a `WallPushArrowPayload`. The floor plan starts
- * `runFloorplanWallPush` for it instead of a registry affordance session.
- */
-export const WALL_PUSH_AFFORDANCE = 'wall-push'
-
-/** A wall's or an invisible wall's side arrow: `wallId` is either. */
-export type WallPushArrowPayload = { wallId: string; side: 'a' | 'b' }
-
 type PlanPointer = (clientX: number, clientY: number) => readonly [number, number] | null
 
 /** The pointer's plan position measured along an arrow's outward normal from its spot. */

package/src/lib/room-name-catalog.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import { type AnyNode, ZoneNode } from '@pascal-app/core'
+import { ROOM_NAME_MESSAGES } from '@pascal-app/viewer/ui'
 import {
   MEZZANINE_NAME_SECTION,
   numberedRoomName,
@@ -8,7 +9,7 @@ import {
   roomNameSections,
   roomNameUseCount,
 } from './room-name-catalog'
-import { ROOM_NAME_MESSAGES, ROOM_NAME_SECTION_TITLES } from './room-name-messages'
+import { ROOM_NAME_SECTION_TITLES } from './room-name-messages'
 
 const square: [number, number][] = [
   [0, 0],

package/src/lib/room-name-messages.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, test } from 'bun:test'
 import { type AnyNode, type MessageDescriptor, ZoneNode } from '@pascal-app/core'
+import { displayRoomName, editedRoomName } from '@pascal-app/viewer/ui'
 import { roomNameOptions } from '../components/ui/panels/room-name-options'
 import { roomNameSections } from './room-name-catalog'
-import { displayRoomName, editedRoomName, localizedRoomNameSections } from './room-name-messages'
+import { localizedRoomNameSections } from './room-name-messages'
 
 const FRENCH: Record<string, string> = {
   'editor.roomName.bedroom': 'Chambre',