@pascal-app/editor 1.0.7 → 1.1.0

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,
@@ -46,7 +49,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,
@@ -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),
       },

package/src/lib/room-push-dimensions.test.ts

@@ -2,11 +2,11 @@ import { describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   createRoomTopologyIndex,
+  formatLinearMeasurement,
   LevelNode,
   type Point,
   WallNode,
 } from '@pascal-app/core'
-import { formatLinearMeasurement } from './measurements'
 import {
   DIMENSION_FLOOR_LIFT,
   mezzanineEdgeDimensions,

package/src/lib/scene-bounds.test.ts

@@ -172,6 +172,150 @@ describe('computeSceneBoundsXZ', () => {
     expect(bounds!.center).toEqual([2, 2])
   })
 
+  describe('ancestor transforms', () => {
+    function makeBuilding(
+      id: string,
+      position: [number, number, number],
+      rotationY = 0,
+      parentId: string | null = null,
+    ): AnyNode {
+      return {
+        object: 'node',
+        id,
+        type: 'building',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        position,
+        rotation: [0, rotationY, 0],
+      } as unknown as AnyNode
+    }
+
+    function makeLevel(id: string, parentId: string): AnyNode {
+      return {
+        object: 'node',
+        id,
+        type: 'level',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        level: 0,
+      } as unknown as AnyNode
+    }
+
+    function child(node: AnyNode, parentId: string): AnyNode {
+      return { ...node, parentId } as AnyNode
+    }
+
+    function expectClose(actual: [number, number], expected: [number, number]) {
+      expect(actual[0]).toBeCloseTo(expected[0], 9)
+      expect(actual[1]).toBeCloseTo(expected[1], 9)
+    }
+
+    test('carries building-local walls and zones through a translated building', () => {
+      const nodes = [
+        makeBuilding('building_a', [100, 0, 100]),
+        makeLevel('level_a', 'building_a'),
+        child(makeWall([-5, -4], [5, -4]), 'level_a'),
+        child(
+          makeZone([
+            [-5, -4],
+            [5, -4],
+            [5, 4],
+            [-5, 4],
+          ]),
+          'level_a',
+        ),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [95, 96])
+      expectClose(bounds.max, [105, 104])
+      expectClose(bounds.center, [100, 100])
+    })
+
+    test('turns building-local geometry by the building yaw', () => {
+      // three.js Y rotation by +90°: local (x, z) → (z, −x).
+      const nodes = [
+        makeBuilding('building_r', [10, 0, 0], Math.PI / 2),
+        makeLevel('level_r', 'building_r'),
+        child(makeWall([0, 0], [8, 0]), 'level_r'),
+        child(makeWall([8, 0], [8, 2]), 'level_r'),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [10, -8])
+      expectClose(bounds.max, [12, 0])
+      expectClose(bounds.size, [2, 8])
+    })
+
+    test('composes nested positioned and rotated ancestors', () => {
+      const item = {
+        object: 'node',
+        id: 'item_host',
+        type: 'item',
+        parentId: 'level_n',
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [2, 0, 0],
+        rotation: [0, Math.PI / 2, 0],
+      } as unknown as AnyNode
+      const hosted = {
+        object: 'node',
+        id: 'item_hosted',
+        type: 'item',
+        parentId: 'item_host',
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [1, 0, 0],
+        rotation: [0, 0, 0],
+      } as unknown as AnyNode
+      // Building at (50, 50) turned 90°: the host lands at (50, 48), and the
+      // hosted item (1, 0) under a total 180° yaw lands one metre further −x.
+      const nodes = [
+        makeBuilding('building_n', [50, 0, 50], Math.PI / 2),
+        makeLevel('level_n', 'building_n'),
+        item,
+        hosted,
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [49, 48])
+      expectClose(bounds.max, [50, 50])
+    })
+
+    test('leaves geometry under an untransformed building unchanged', () => {
+      const nodes = [
+        makeBuilding('building_0', [0, 0, 0]),
+        makeLevel('level_0', 'building_0'),
+        child(makeWall([0, 0], [4, 0]), 'level_0'),
+        child(makeWall([4, 0], [4, 3]), 'level_0'),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expect(bounds.min).toEqual([0, 0])
+      expect(bounds.max).toEqual([4, 3])
+    })
+  })
+
+  test('a door on a wall is bounded by the wall, not its wall-local position', () => {
+    const wall = makeWall([50, 50], [60, 50])
+    const door = {
+      object: 'node',
+      id: 'door_1',
+      type: 'door',
+      parentId: wall.id,
+      visible: true,
+      metadata: {},
+      position: [2, 1, 0],
+    } as unknown as AnyNode
+    const bounds = computeSceneBoundsXZ([wall, door])
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min[0]).toBe(50)
+    expect(bounds!.max[0]).toBe(60)
+    expect(bounds!.center).toEqual([55, 50])
+  })
+
   test('skips non-finite coordinates', () => {
     const nodes: AnyNode[] = [makeWall([Number.NaN, 0], [4, 2]), makeWall([0, 0], [1, 1])]
     const bounds = computeSceneBoundsXZ(nodes)

package/src/lib/scene-bounds.ts

@@ -11,6 +11,7 @@
  * tree and derives an axis-aligned bounding box on the XZ (plan) plane.
  */
 
+import { turnPlanPoint, yawOf } from '@pascal-app/core'
 import type { AnyNode } from '@pascal-app/core/schema'
 
 export type SceneBoundsXZ = {
@@ -27,13 +28,19 @@ export type SceneBoundsXZ = {
 // A very small guard against degenerate bounds (e.g. a single wall of zero length).
 const MIN_BOUNDS_EXTENT = 0.0001
 
-function extendPoint(
-  acc: { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean },
-  x: unknown,
-  z: unknown,
-): void {
-  if (typeof x !== 'number' || typeof z !== 'number') return
-  if (!(Number.isFinite(x) && Number.isFinite(z))) return
+/** A node's plan frame in world XZ: local (x, z) → origin + turnPlanPoint(x, z, yaw). */
+type PlanFrame = { x: number; z: number; yaw: number }
+
+const WORLD_FRAME: PlanFrame = { x: 0, z: 0, yaw: 0 }
+
+type BoundsAcc = { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean }
+
+function extendPoint(acc: BoundsAcc, frame: PlanFrame, localX: unknown, localZ: unknown): void {
+  if (typeof localX !== 'number' || typeof localZ !== 'number') return
+  if (!(Number.isFinite(localX) && Number.isFinite(localZ))) return
+  const [tx, tz] = frame.yaw === 0 ? [localX, localZ] : turnPlanPoint(localX, localZ, frame.yaw)
+  const x = frame.x + tx
+  const z = frame.z + tz
   if (x < acc.minX) acc.minX = x
   if (x > acc.maxX) acc.maxX = x
   if (z < acc.minZ) acc.minZ = z
@@ -50,6 +57,9 @@ function extendPoint(
  *   - `polygon`      → zone, slab, site-boundary polygons.
  *   - `position`     → building/item/door/window position; uses [x, z] only.
  *
+ * Each point is in its parent's frame, so it is carried to world XZ through
+ * the ancestors' `position` and `rotation` yaw (a moved or turned building).
+ *
  * Site-node polygons are intentionally excluded when they are the default
  * 30×30 bootstrap polygon — otherwise a brand-new empty scene would frame
  * an empty square around the origin. We still include site polygons that
@@ -63,7 +73,7 @@ export function computeSceneBoundsXZ(
   const list: AnyNode[] = Array.isArray(nodes) ? nodes : Object.values(nodes)
   if (list.length === 0) return null
 
-  const acc = {
+  const acc: BoundsAcc = {
     minX: Number.POSITIVE_INFINITY,
     minZ: Number.POSITIVE_INFINITY,
     maxX: Number.NEGATIVE_INFINITY,
@@ -71,15 +81,24 @@ export function computeSceneBoundsXZ(
     hasPoint: false,
   }
 
+  const byId = new Map<string, AnyNode>()
+  for (const node of list) {
+    if (node && typeof node === 'object' && typeof node.id === 'string') byId.set(node.id, node)
+  }
+  const frameOf = createFrameResolver(byId)
+
   for (const node of list) {
     if (!node || typeof node !== 'object') continue
     const anyNode = node as unknown as Record<string, unknown>
+    // A node's own fields live in its parent's frame (a building's walls are
+    // building-local), so every point goes through the ancestors' transforms.
+    const frame = frameOf(node.parentId ?? null)
 
     // Wall / fence endpoints in level coordinates.
     const start = anyNode.start as unknown
     const end = anyNode.end as unknown
-    if (Array.isArray(start) && start.length >= 2) extendPoint(acc, start[0], start[1])
-    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, end[0], end[1])
+    if (Array.isArray(start) && start.length >= 2) extendPoint(acc, frame, start[0], start[1])
+    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, frame, end[0], end[1])
 
     // Zone / slab polygons (and explicit polygon-shaped site boundaries).
     const polygon = anyNode.polygon as unknown
@@ -88,7 +107,7 @@ export function computeSceneBoundsXZ(
       // points under `polygon.points` (a discriminated PropertyLineData shape).
       for (const point of polygon) {
         if (Array.isArray(point) && point.length >= 2) {
-          extendPoint(acc, point[0], point[1])
+          extendPoint(acc, frame, point[0], point[1])
         }
       }
     } else if (
@@ -105,16 +124,18 @@ export function computeSceneBoundsXZ(
       } else {
         for (const point of points) {
           if (Array.isArray(point) && point.length >= 2) {
-            extendPoint(acc, point[0], point[1])
+            extendPoint(acc, frame, point[0], point[1])
           }
         }
       }
     }
 
-    // Position on the XZ plane (3D position = [x, y, z]).
+    // Position on the XZ plane (3D position = [x, y, z]). A node hosted on a
+    // wall (door, window, wall item) has a wall-local position, and the
+    // wall's endpoints already bound it.
     const position = anyNode.position as unknown
-    if (Array.isArray(position) && position.length >= 3) {
-      extendPoint(acc, position[0], position[2])
+    if (Array.isArray(position) && position.length >= 3 && !isWallHosted(node, byId)) {
+      extendPoint(acc, frame, position[0], position[2])
     }
   }
 
@@ -146,6 +167,49 @@ export function computeSceneBoundsXZ(
   }
 }
 
+/**
+ * World plan frame of each node, composed down the parent chain the way the
+ * renderers nest groups: a node with a `position` (building, item) translates
+ * its children and turns them by its `rotation` yaw; nodes without one (site,
+ * level) pass their parent's frame through.
+ */
+function createFrameResolver(byId: Map<string, AnyNode>): (id: string | null) => PlanFrame {
+  const cache = new Map<string, PlanFrame>()
+  const resolving = new Set<string>()
+
+  const resolve = (id: string | null): PlanFrame => {
+    if (!id) return WORLD_FRAME
+    const cached = cache.get(id)
+    if (cached) return cached
+    const node = byId.get(id)
+    if (!node || resolving.has(id)) return WORLD_FRAME
+    resolving.add(id)
+    const parent = resolve(node.parentId ?? null)
+    resolving.delete(id)
+
+    const anyNode = node as unknown as Record<string, unknown>
+    const position = anyNode.position
+    let frame = parent
+    if (Array.isArray(position) && position.length >= 3) {
+      const px = Number.isFinite(position[0]) ? (position[0] as number) : 0
+      const pz = Number.isFinite(position[2]) ? (position[2] as number) : 0
+      const [tx, tz] = turnPlanPoint(px, pz, parent.yaw)
+      frame = { x: parent.x + tx, z: parent.z + tz, yaw: parent.yaw + yawOf(anyNode.rotation) }
+    }
+    cache.set(id, frame)
+    return frame
+  }
+
+  return resolve
+}
+
+function isWallHosted(node: AnyNode, byId: Map<string, AnyNode>): boolean {
+  const parent = node.parentId ? byId.get(node.parentId) : undefined
+  if (!parent) return false
+  const anyParent = parent as unknown as Record<string, unknown>
+  return Array.isArray(anyParent.start) && Array.isArray(anyParent.end)
+}
+
 /**
  * Matches the `SiteNode` bootstrap polygon defined in
  * `packages/core/src/schema/nodes/site.ts` (a 30×30 square at the origin).

package/src/lib/scene-clipboard.ts

@@ -6,6 +6,7 @@ import {
   generateSceneMaterialId,
   getArtifactStore,
   isDerivedNode,
+  isNodeDuplicable,
   isStoreyContent,
   type LevelNode,
   nodeRegistry,
@@ -156,7 +157,7 @@ function isClipboardRoot(
 }
 
 function isCopyableRootType(node: AnyNode) {
-  if (isDerivedNode(node)) return false
+  if (isDerivedNode(node) || !isNodeDuplicable(node)) return false
   if (COPYABLE_ROOT_TYPES.has(node.type)) return true
   const definition = nodeRegistry.get(node.type)
   return !!definition && definition.capabilities?.duplicable !== false

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

@@ -106,6 +106,8 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     roof: 'structural',
     zone: 'structural',
     block: 'structural',
+    door: 'item',
+    window: 'item',
   }
   const profileOf = (t: string) => declared[t]
   const profileOfNode = (id: string) =>
@@ -173,7 +175,7 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
   })
 
   it('an undeclared kind (no snapProfile) gets no snap context', () => {
-    expect(ctx({ kind: 'moving', nodeType: 'door' })).toBeNull()
+    expect(ctx({ kind: 'moving', nodeType: 'unknown_plugin_kind' })).toBeNull()
     expect(ctx({ kind: 'idle' }, 'build', 'shelf')).toBeNull()
   })
 
@@ -205,4 +207,24 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
       }),
     ).toBe('polygon')
   })
+  it('moving scope resolves active snap context when moving a window or door', () => {
+    expect(
+      snapContextOf({
+        scope: { kind: 'moving', nodeType: 'window' },
+        mode: 'select',
+        tool: null,
+        profileOf,
+        profileOfNode,
+      }),
+    ).toBe('item')
+    expect(
+      snapContextOf({
+        scope: { kind: 'moving', nodeType: 'door' },
+        mode: 'select',
+        tool: null,
+        profileOf,
+        profileOfNode,
+      }),
+    ).toBe('item')
+  })
 })

package/src/lib/viewer-selection.ts

@@ -11,6 +11,7 @@ import {
   type LevelNode,
   type NodeEvent,
   resolveSelectionProxyId,
+  roomFloorElevation,
   sceneRegistry,
   type UnitNode,
   type ZoneNode,
@@ -29,7 +30,6 @@ import {
 } from 'three'
 import { useBelowGrade } from './below-grade'
 import { nodeDisplayLabel } from './node-display-label'
-import { roomFloorElevation } from './room-handle-drag'
 import { type DescriptorTranslator, displayRoomName } from './room-name-messages'
 import { RoomSelectionIndex, type RoomSelectionRecord, resolveRoomHit } from './room-selection'
 import type { SelectionModifierKeys } from './selection-routing'

package/src/lib/wall-region-list.ts

@@ -1,7 +1,10 @@
 import {
   type AnyNode,
   getCatalogMaterialById,
+  getLinearUnitLabel,
   getMaterialSwatch,
+  type LinearUnit,
+  metersToLinearUnit,
   parseMaterialRef,
   roomSideFaces,
   type SceneMaterial,
@@ -11,7 +14,6 @@ import {
   type WallFaceRegion,
   type WallNode,
 } from '@pascal-app/core'
-import { getLinearUnitLabel, type LinearUnit, metersToLinearUnit } from './measurements'
 
 // Rows for the wall panel's "Paint regions" list: finish swatch + name, the
 // face in room terms when the wall has a room on exactly one side, and the

package/src/lib/window-interaction.test.ts

@@ -1,11 +1,13 @@
 import { afterEach, expect, test } from 'bun:test'
-import { useInteractive, useScene, WindowNode } from '@pascal-app/core'
 import {
   getDisplayedWindowShutterValue,
   getDisplayedWindowValue,
   openWindowOpenState,
   setWindowShuttersOpenState,
-} from '../index'
+  useInteractive,
+  useScene,
+  WindowNode,
+} from '@pascal-app/core'
 
 const originalScene = useScene.getState()
 const originalInteractive = useInteractive.getState()

package/src/store/use-editor.tsx

@@ -10,6 +10,7 @@ import {
   type ChimneyMaterialRole,
   DEFAULT_BRUSH_SETTINGS,
   type DormerSurfaceMaterialRole,
+  isMoveLocked,
   type LevelNode,
   nodeRegistry,
   type RoofSurfaceMaterialRole,
@@ -1256,6 +1257,10 @@ const useEditor = create<EditorState>()(
           set({ placementDragMode: false })
           return
         }
+        if (isMoveLocked(node)) {
+          set({ placementDragMode: false })
+          return
+        }
         const targetNode = node
         const isNew = Boolean((targetNode as { metadata?: { isNew?: boolean } }).metadata?.isNew)
         if (isNew) {