@pascal-app/editor 1.0.4 → 1.0.5

package/src/lib/scene-clipboard.ts

@@ -6,14 +6,18 @@ import {
   generateSceneMaterialId,
   getArtifactStore,
   isDerivedNode,
+  isStoreyContent,
   type LevelNode,
   nodeRegistry,
   type ParsedBuildJson,
   remapMeasurementReferences,
+  runAsSingleSceneHistoryStep,
   SceneMaterial,
   type SceneMaterialId,
   type StairNode,
   scriptedSize,
+  seatRoofs,
+  storeyOf,
   useScene,
 } from '@pascal-app/core'
 import { clampDoorToWall, clampWindowToWall } from '@pascal-app/core/building'
@@ -258,6 +262,13 @@ function remapNodeReferences(
     }
   }
 
+  // A corner window pasted with its partner joins the partner's copy; pasted alone, it is plain.
+  if (clone.type === 'window' && clone.corner) {
+    const partnerId = idMap.get(clone.corner.partnerId as AnyNodeId)
+    if (partnerId) clone.corner = { ...clone.corner, partnerId }
+    else delete clone.corner
+  }
+
   if (clone.type === 'stair') {
     const nextLevelId = getNextLevelId(targetLevel, nodes)
     ;(clone as StairNode).fromLevelId = targetLevel.id
@@ -477,11 +488,17 @@ export async function pasteSystemEditorClipboardToLevel(
   return applyClipboardPayloadToLevel(payload, targetLevel.id, refused)
 }
 
+/** The script and GLB a scripted node, a room's floor script or a wall's face scripts reference. */
 function artifactHashes(node: AnyNode): string[] {
-  const source = 'source' in node ? node.source : undefined
-  return typeof source === 'object' && source.kind === 'script'
-    ? [source.script, source.artifact]
-    : []
+  const sources =
+    node.type === 'zone'
+      ? [node.floor?.script]
+      : node.type === 'wall'
+        ? [node.finishScripts?.a, node.finishScripts?.b]
+        : ['source' in node ? node.source : undefined]
+  return sources.flatMap((source) =>
+    typeof source === 'object' && source?.kind === 'script' ? [source.script, source.artifact] : [],
+  )
 }
 
 /**
@@ -582,11 +599,21 @@ function applyClipboardPayloadToLevel(
   targetLevelId?: AnyNodeId,
   { ids: refused, reason: refusal }: Refused = NONE_REFUSED,
 ): PasteResult | null {
-  const targetLevel = getPasteTargetLevel(targetLevelId)
-  if (!targetLevel) return null
+  const aimedLevel = getPasteTargetLevel(targetLevelId)
+  if (!aimedLevel) return null
   const payload = refused.size > 0 ? withoutRefusedSubtrees(copied, refused) : copied
 
   const scene = useScene.getState()
+  // A paste lands on one level. On a roof level, one carrying anything a storey holds (walls,
+  // rooms, items, cabinets, …) goes to the storey it covers, whole: the row in view was the roof's,
+  // the plan is the storey's, and a roof in it that bears there is seated back up.
+  const rootIdSet = new Set(payload.rootIds)
+  const targetLevel = payload.nodes.some(
+    (node) => rootIdSet.has(node.id as AnyNodeId) && isStoreyContent(node.type, node.metadata),
+  )
+    ? ((scene.nodes[storeyOf(scene.nodes, aimedLevel.id) as AnyNodeId] as LevelNode | undefined) ??
+      aimedLevel)
+    : aimedLevel
   const idMap = new Map<AnyNodeId, AnyNodeId>()
   const materialIdMap = new Map<SceneMaterialId, SceneMaterialId>()
   const materialsToCreate: SceneMaterial[] = []
@@ -607,7 +634,6 @@ function applyClipboardPayloadToLevel(
     materialsToCreate.push({ ...material, id: nextId })
   }
 
-  const rootIdSet = new Set(payload.rootIds)
   const pastedNodes: AnyNode[] = []
   const skippedIds: AnyNodeId[] = []
 
@@ -646,12 +672,10 @@ function applyClipboardPayloadToLevel(
     }
   }
 
-  for (const material of materialsToCreate) {
-    scene.addSceneMaterial(material)
-  }
   const sourceIds = new Map([...idMap].map(([source, copy]) => [copy, source]))
-  scene.createNodes(
-    pastedNodes.map((node) => ({
+  // A roof pasted onto the walls that carry it goes to the level above them, in the paste itself.
+  const { changes } = seatRoofs(scene.nodes, {
+    create: pastedNodes.map((node) => ({
       node,
       parentId: (node.parentId as AnyNodeId | null) ?? undefined,
       // A copy is in its source's collections; an item brings them in its own `collectionIds`.
@@ -659,15 +683,21 @@ function applyClipboardPayloadToLevel(
         collectionIds: collectionIdsOf(scene.collections, sourceIds.get(node.id as AnyNodeId)!),
       }),
     })),
-  )
+  })
+  runAsSingleSceneHistoryStep(useScene, () => {
+    for (const material of materialsToCreate) scene.addSceneMaterial(material)
+    scene.applyNodeChanges(changes)
+  })
 
+  const nodes = useScene.getState().nodes
   const pastedNodeIds = new Set(pastedNodes.map((node) => node.id as AnyNodeId))
   const pastedRootIds = payload.rootIds
     .map((rootId) => idMap.get(rootId))
     .filter((id): id is AnyNodeId => !!id && pastedNodeIds.has(id))
+  const rootLevel = nodes[(nodes[pastedRootIds[0]!]?.parentId ?? '') as AnyNodeId]
 
   useViewer.getState().setSelection({
-    levelId: targetLevel.id,
+    levelId: rootLevel?.type === 'level' ? rootLevel.id : targetLevel.id,
     selectedIds: pastedRootIds,
   })
 

package/src/lib/selection-routing.ts

@@ -98,7 +98,7 @@ export function resolveCanvasSelectionNode({
   const proxiedTarget = nodes[resolveSelectionProxyId(node, nodes)] ?? node
   let target = shouldBypassSelectionProxy(node, proxiedTarget) ? node : proxiedTarget
   const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
-  if (parentFrame) {
+  if (parentFrame && !parentFrame.independent) {
     const parent = parentFrame.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
     if (parent && selectedIds.length === 1 && selectedIds[0] === parent.id) {
       target = parent

package/src/lib/sfx-bus.ts

@@ -28,6 +28,9 @@ type SFXEvents = {
   'sfx:menu-click': undefined
   'sfx:paint-apply': undefined
   'sfx:success': undefined
+  'sfx:turn-done': undefined
+  'sfx:turn-failed': undefined
+  'sfx:turn-needs-input': undefined
   'sfx:terrain-sculpt-start': TerrainVerb
   'sfx:terrain-sculpt-stop': undefined
 }
@@ -58,6 +61,9 @@ const handleMenuHover = () => playSFX('menuHover')
 const handleMenuClick = () => playSFX('menuClick')
 const handlePaintApply = () => playSFX('paintApply')
 const handleSuccess = () => playSFX('success')
+const handleTurnDone = () => playSFX('turnDone')
+const handleTurnFailed = () => playSFX('turnFailed')
+const handleTurnNeedsInput = () => playSFX('turnNeedsInput')
 const TERRAIN_LOOP_BY_VERB = {
   raise: 'terrainRaise',
   lower: 'terrainLower',
@@ -89,9 +95,13 @@ export function initSFXBus() {
   sfxEmitter.on('sfx:menu-click', handleMenuClick)
   sfxEmitter.on('sfx:paint-apply', handlePaintApply)
   sfxEmitter.on('sfx:success', handleSuccess)
+  sfxEmitter.on('sfx:turn-done', handleTurnDone)
+  sfxEmitter.on('sfx:turn-failed', handleTurnFailed)
+  sfxEmitter.on('sfx:turn-needs-input', handleTurnNeedsInput)
   sfxEmitter.on('sfx:terrain-sculpt-start', handleTerrainSculptStart)
   sfxEmitter.on('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
   unsubscribeAudio = useAudio.subscribe(updateSFXVolumes)
+  updateSFXVolumes()
 }
 
 export function disposeSFXBus() {
@@ -110,6 +120,9 @@ export function disposeSFXBus() {
     sfxEmitter.off('sfx:menu-click', handleMenuClick)
     sfxEmitter.off('sfx:paint-apply', handlePaintApply)
     sfxEmitter.off('sfx:success', handleSuccess)
+    sfxEmitter.off('sfx:turn-done', handleTurnDone)
+    sfxEmitter.off('sfx:turn-failed', handleTurnFailed)
+    sfxEmitter.off('sfx:turn-needs-input', handleTurnNeedsInput)
     sfxEmitter.off('sfx:terrain-sculpt-start', handleTerrainSculptStart)
     sfxEmitter.off('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
     unsubscribeAudio?.()

package/src/lib/sfx-player.test.ts

@@ -1,10 +1,10 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test'
+import useAudio from '../store/use-audio'
 
 type FakeContext = { id: string }
 
 let activeContext: FakeContext = { id: 'first' }
 let initialState: 'loaded' | 'loading' = 'loaded'
-let muted = false
 let throwOnPlay = false
 const instances: FakeHowl[] = []
 
@@ -92,12 +92,6 @@ const fakeHowler = {
 }
 
 mock.module('howler', () => ({ Howl: FakeHowl, Howler: fakeHowler }))
-mock.module('../store/use-audio', () => ({
-  default: {
-    getState: () => ({ masterVolume: 100, muted, sfxVolume: 100 }),
-    subscribe: () => () => {},
-  },
-}))
 
 const { disposeSFX, playSFX, preloadSFX, startLoopSFX, stopLoopSFX, updateSFXVolumes } =
   await import('./sfx-player')
@@ -107,7 +101,7 @@ beforeEach(() => {
   disposeSFXBus()
   activeContext = { id: 'first' }
   initialState = 'loaded'
-  muted = false
+  useAudio.setState({ masterVolume: 100, muted: false, sfxVolume: 100 })
   throwOnPlay = false
   instances.length = 0
 })
@@ -118,6 +112,51 @@ afterAll(() => {
 })
 
 describe('SFX audio context lifecycle', () => {
+  test('editor startup warms assets without playing and repeated init does not duplicate delivery', () => {
+    initSFXBus()
+    const warmed = [...instances]
+    expect(warmed.length).toBeGreaterThan(0)
+    expect(warmed.every((sound) => sound.playCount === 0)).toBe(true)
+    initSFXBus()
+    expect(instances).toHaveLength(warmed.length)
+    triggerSFX('sfx:item-place')
+    expect(instances.reduce((sum, sound) => sum + sound.playCount, 0)).toBe(1)
+  })
+
+  test('a one-shot requested before loading is dropped, not replayed on load', () => {
+    initialState = 'loading'
+    initSFXBus()
+    triggerSFX('sfx:item-place')
+    for (const sound of instances) sound.finishLoading()
+    expect(instances.every((sound) => sound.playCount === 0)).toBe(true)
+    // A different fresh cue avoids relying on the per-name repeat clock.
+    triggerSFX('sfx:structure-build')
+    expect(instances.reduce((sum, sound) => sum + sound.playCount, 0)).toBe(1)
+  })
+
+  test('muted startup neither starts audio nor consumes a later fresh cue', () => {
+    useAudio.setState({ muted: true })
+    initSFXBus()
+    triggerSFX('sfx:item-place')
+    expect(instances.every((sound) => sound.playCount === 0)).toBe(true)
+    useAudio.setState({ muted: false })
+    updateSFXVolumes()
+    triggerSFX('sfx:item-place')
+    expect(instances.reduce((sum, sound) => sum + sound.playCount, 0)).toBe(1)
+  })
+
+  test('cleanup detaches delivery and unloads resources once, then remount plays once', () => {
+    initSFXBus()
+    const warmed = [...instances]
+    disposeSFXBus()
+    disposeSFXBus()
+    triggerSFX('sfx:item-place')
+    expect(warmed.every((sound) => sound.playCount === 0 && sound.unloadCount === 1)).toBe(true)
+    initSFXBus()
+    triggerSFX('sfx:item-place')
+    expect(instances.reduce((sum, sound) => sum + sound.playCount, 0)).toBe(1)
+  })
+
   test('reuses the preloaded cache while the Howler context is unchanged', () => {
     preloadSFX()
     const initialCount = instances.length
@@ -234,7 +273,7 @@ describe('SFX audio context lifecycle', () => {
     startLoopSFX('terrainLower')
     const lower = instances.find((sound) => sound.loop && sound.playCount === 1)
 
-    muted = true
+    useAudio.setState({ muted: true })
     updateSFXVolumes()
 
     expect(lower?.fadeCalls.at(-1)).toEqual([0.2, 0, 90, 1])
@@ -263,4 +302,26 @@ describe('SFX audio context lifecycle', () => {
 
     expect(lower?.playCount).toBe(0)
   })
+
+  test('turn cues play at the master and effects volume, and not in a muted tab', () => {
+    const cues = ['sfx:turn-done', 'sfx:turn-failed', 'sfx:turn-needs-input'] as const
+    useAudio.setState({ masterVolume: 50, muted: true, sfxVolume: 40 })
+    initSFXBus()
+
+    for (const cue of cues) triggerSFX(cue)
+    expect(instances.every((sound) => sound.playCount === 0)).toBe(true)
+
+    useAudio.setState({ muted: false })
+    for (const cue of cues) triggerSFX(cue)
+
+    const played = instances.filter((sound) => sound.playCount === 1)
+    expect(played.map((sound) => sound.src)).toEqual([
+      '/audios/sfx/turn_done.mp3',
+      '/audios/sfx/turn_failed.mp3',
+      '/audios/sfx/turn_needs_input.mp3',
+    ])
+    for (const sound of played) {
+      expect(sound.volumeCalls.find(([, id]) => id === 1)?.[0]).toBeCloseTo(0.2)
+    }
+  })
 })

package/src/lib/sfx-player.ts

@@ -120,6 +120,12 @@ export const SFX: Record<string, SFXConfig> = {
     src: '/audios/sfx/success.mp3',
     minIntervalMs: 3_000,
   },
+  // An agent's turn, heard from another tab or another app: it ended with its work done, it failed,
+  // or it waits on the person. Two-note chimes (`scripts/synth-turn-cues.ts`), so no jitter, as for
+  // `success`. The host plays each once per turn; no gap here could tell two turns from one.
+  turnDone: { src: '/audios/sfx/turn_done.mp3' },
+  turnFailed: { src: '/audios/sfx/turn_failed.mp3' },
+  turnNeedsInput: { src: '/audios/sfx/turn_needs_input.mp3' },
 } as const
 
 export type SFXName = keyof typeof SFX

package/src/lib/stair-levels.test.ts

@@ -37,6 +37,31 @@ describe('stair level helpers', () => {
     expect(plan?.createdLevel?.parentId).toBe(building.id)
   })
 
+  // Every generated one-storey house has a Roof level: the stair tool sent its flight up into it.
+  test('climbs to a new storey under the roof level, which moves up over it', () => {
+    const ground = LevelNode.parse({ level: 0, children: [] })
+    const roofLevel = LevelNode.parse({ level: 1, children: [], metadata: { role: 'roof' } })
+    const building = BuildingNode.parse({ children: [ground.id, roofLevel.id] })
+    const nodes = {
+      [building.id]: building,
+      [ground.id]: { ...ground, parentId: building.id },
+      [roofLevel.id]: { ...roofLevel, parentId: building.id },
+    } as Record<AnyNodeId, AnyNode>
+
+    const plan = resolveStairDestinationLevel({
+      createMissing: true,
+      fromLevelId: ground.id,
+      nodes,
+    })
+
+    expect(plan?.toLevel.id).toBe(plan?.createdLevel?.id)
+    expect(plan?.createdLevel?.level).toBe(1)
+    expect(plan?.liftedLevels).toEqual([{ id: roofLevel.id, data: { level: 2 } }])
+    expect(resolveStairDestinationLevel({ fromLevelId: ground.id, nodes })?.toLevel.id).toBe(
+      ground.id,
+    )
+  })
+
   test('uses the nearest higher sibling level instead of creating one', () => {
     const building = BuildingNode.parse({})
     const ground = LevelNode.parse({ level: 0, parentId: building.id })

package/src/lib/stair-levels.ts

@@ -6,6 +6,8 @@ import {
   type LevelNode as LevelNodeType,
   resolveBuildingForLevel,
   type StairNode,
+  servesAsRoofLevel,
+  storeyInsertIndex,
 } from '@pascal-app/core'
 
 function sortLevelsByHeight(levels: LevelNodeType[]) {
@@ -141,30 +143,46 @@ export function resolveStairDestinationLevel({
     nodes as Record<AnyNodeId, AnyNode>,
   )
   const levels = getBuildingLevelsForLevel(nodes, fromLevel.id)
-  const nextExistingLevel = levels.find((level) => level.level > fromLevel.level) ?? null
+  // A stair rises to a storey: the roof level over the top one is not a floor to climb to.
+  const nextExistingLevel =
+    levels.find((level) => level.level > fromLevel.level && !servesAsRoofLevel(nodes, level)) ??
+    null
   if (nextExistingLevel) {
     return {
       buildingId,
       createdLevel: null,
       fromLevel,
       levels,
+      liftedLevels: [],
       toLevel: nextExistingLevel,
     }
   }
 
   if (createMissing && buildingId) {
+    // The new storey goes under the roof level, which moves up over it.
+    const { floorIndex, shift } = storeyInsertIndex(nodes, buildingId)
     const createdLevel = LevelNode.parse({
       children: [],
       height: DEFAULT_LEVEL_HEIGHT,
-      level: fromLevel.level + 1,
+      level: floorIndex,
       parentId: buildingId,
     })
+    const lifted = new Map(shift.map(({ id, data }) => [id, data.level]))
 
     return {
       buildingId,
       createdLevel,
       fromLevel,
-      levels: sortLevelsByHeight([...levels, createdLevel]),
+      levels: sortLevelsByHeight([
+        ...levels.map((level) =>
+          lifted.has(level.id) ? { ...level, level: lifted.get(level.id)! } : level,
+        ),
+        createdLevel,
+      ]),
+      liftedLevels: shift.map(({ id, data }) => ({
+        id: id as AnyNodeId,
+        data: data as Partial<AnyNode>,
+      })),
       toLevel: createdLevel,
     }
   }
@@ -174,6 +192,7 @@ export function resolveStairDestinationLevel({
     createdLevel: null,
     fromLevel,
     levels,
+    liftedLevels: [],
     toLevel: fromLevel,
   }
 }

package/src/lib/terrace-draft.ts

@@ -53,7 +53,8 @@ const OPEN_GROUND = 500
  * Why a terrace outline cannot be built, or its plan: an outdoor room of the
  * outline, closed with separators where no wall runs, without a ceiling.
  * Core refuses an outline over a room (the same rule MCP's outdoor
- * `create_room` follows) and names the room.
+ * `create_room` follows) and names the room, except the numbered room its
+ * walls enclose exactly: a walled courtyard, which becomes the terrace.
  */
 export function planTerrace(
   nodes: Record<string, AnyNode>,

package/src/lib/viewer-selection.ts

@@ -27,6 +27,7 @@ import {
   Sphere,
   Vector3,
 } from 'three'
+import { useBelowGrade } from './below-grade'
 import { nodeDisplayLabel } from './node-display-label'
 import { roomFloorElevation } from './room-handle-drag'
 import { RoomSelectionIndex, type RoomSelectionRecord, resolveRoomHit } from './room-selection'
@@ -222,13 +223,15 @@ export function resolveViewerHover(
 
 /**
  * The current floor reads as the editor shows it: the levels above it step
- * aside (in the stacked display) so its rooms are in view and in reach. Mount
- * it in the surface's DOM tree, beside the editor's own level display, so one
- * hands the flag to the other in order.
+ * aside (in the stacked display) so its rooms are in view and in reach, and the
+ * ground is veiled over it when it lies below grade. Mount it in the surface's DOM tree,
+ * beside the editor's own level display, so one hands the flag to the other in
+ * order.
  */
 export function useViewerFloorDisplay() {
   // A walkthrough tours the whole building.
   const walking = useViewer((s) => s.walkthroughMode)
+  useBelowGrade(!walking)
   useEffect(() => {
     if (walking) return
     useViewer.setState({ hideLevelsAboveSelection: true })
@@ -344,14 +347,13 @@ function expandByZone(target: Box3, zone: ZoneNode, source: ViewerSource) {
   }
 }
 
-/** The frame request for a node: its saved view, else the box it spans. */
+/** The frame request for a node: the box it spans, and its saved view when it has one. */
 function viewerFrameEvent(id: string, source: ViewerSource): CameraControlFrameEvent | null {
   const node = source.nodes[id]
   if (!node) return null
   const saved = node.camera
-  if (saved?.position && saved.target) {
-    return { bounds: null, pose: { position: saved.position, target: saved.target } }
-  }
+  const pose =
+    saved?.position && saved.target ? { position: saved.position, target: saved.target } : null
   box.makeEmpty()
   if (node.type === 'zone') expandByZone(box, node, source)
   else if (node.type === 'unit') {
@@ -363,8 +365,16 @@ function viewerFrameEvent(id: string, source: ViewerSource): CameraControlFrameE
     const object = source.objectFor(id)
     if (object) box.setFromObject(object)
   }
-  if (box.isEmpty()) return null
-  return { bounds: { min: box.min.toArray(), max: box.max.toArray() } }
+  const bounds = box.isEmpty() ? null : { min: box.min.toArray(), max: box.max.toArray() }
+  if (pose) return { bounds, pose }
+  return bounds ? { bounds } : null
+}
+
+/** Framing glides to its pose, or jumps there when the person asks for reduced motion. */
+export function framingAnimates(): boolean {
+  return !(
+    typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
+  )
 }
 
 export function frameViewerNode(id: string, source: ViewerSource) {
@@ -426,13 +436,14 @@ export function frameViewerCamera(
       : undefined,
   )
   if (!pose) return
-  control.setLookAt(...pose.position, ...pose.target, true)
+  const animate = framingAnimates()
+  control.setLookAt(...pose.position, ...pose.target, animate)
   if ((camera as OrthographicCamera).isOrthographicCamera && event.bounds && !event.pose) {
     box.min.set(...event.bounds.min)
     box.max.set(...event.bounds.max)
     box.getBoundingSphere(frameSphere)
     frameSphere.radius = Math.max(frameSphere.radius * 1.3, 1)
-    control.fitToSphere(frameSphere, true)
+    control.fitToSphere(frameSphere, animate)
   }
 }
 

package/src/lib/wall-placement-pointer.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from 'bun:test'
+import { Group, Vector3 } from 'three'
+import {
+  createWallPointerTracker,
+  wallPointerInParent,
+  wallSideAtPointer,
+} from './wall-placement-pointer'
+
+test('keeps the grab offset across a pointer gap on the original face', () => {
+  const pointer = createWallPointerTracker({ wallId: 'wall_a', side: 'front', position: [4, 2] })
+  expect(pointer.resolve('wall_a', 'front', [3, 1])).toEqual([4, 2])
+  pointer.leave()
+  expect(pointer.resolve('wall_a', 'front', [5, 3])).toEqual([6, 4])
+})
+test('a different wall or face permanently releases the old grab offset', () => {
+  for (const [wall, side] of [
+    ['wall_b', 'front'],
+    ['wall_a', 'back'],
+  ] as const) {
+    const pointer = createWallPointerTracker({ wallId: 'wall_a', side: 'front', position: [4, 2] })
+    pointer.resolve('wall_a', 'front', [3, 1])
+    expect(pointer.resolve(wall, side, [5, 3])).toEqual([5, 3])
+    expect(pointer.resolve('wall_a', 'front', [6, 4])).toEqual([6, 4])
+  }
+})
+test('a committed floor placement releases the original wall grab', () => {
+  const pointer = createWallPointerTracker({ wallId: 'wall_a', position: [4, 2] })
+  pointer.resolve('wall_a', 'front', [3, 1])
+  pointer.forget()
+  expect(pointer.resolve('wall_a', 'front', [5, 3])).toEqual([5, 3])
+})
+test('reads the pointer in the rotated wall parent and identifies its face', () => {
+  const parent = new Group()
+  parent.position.set(3, 1, 5)
+  parent.rotation.y = Math.PI / 2
+  parent.updateMatrixWorld(true)
+  const world = parent.localToWorld(new Vector3(2, 3, -0.1))
+  const local = wallPointerInParent(world.toArray(), parent)
+  expect(local[0]).toBeCloseTo(2)
+  expect(local[1]).toBeCloseTo(3)
+  expect(wallSideAtPointer(local)).toBe('back')
+})

package/src/lib/wall-placement-pointer.ts

@@ -0,0 +1,57 @@
+import { type Object3D, Vector3 } from 'three'
+
+type WallSide = 'front' | 'back'
+type Point = readonly [number, number]
+
+/** Keep the grabbed point only on its original face; new hosts follow the cursor. */
+export function createWallPointerTracker(source?: {
+  wallId: string | null
+  side?: WallSide
+  position: readonly number[]
+}) {
+  let forgotten = !source
+  let grabOffset: { x: number; y: number } | null = null
+  let anchor: { wallId: string; side: WallSide; x: number; y: number } | null = null
+  return {
+    resolve(wallId: string, side: WallSide, point: Point): [number, number] {
+      if (!anchor || anchor.wallId !== wallId || anchor.side !== side) {
+        const preserve =
+          !forgotten && source?.wallId === wallId && (!source.side || source.side === side)
+        if (!preserve) forgotten = true
+        if (preserve && !grabOffset) {
+          grabOffset = { x: source!.position[0]! - point[0], y: source!.position[1]! - point[1] }
+        }
+        anchor = {
+          wallId,
+          side,
+          x: preserve ? grabOffset!.x : 0,
+          y: preserve ? grabOffset!.y : 0,
+        }
+      }
+      return [point[0] + anchor.x, point[1] + anchor.y]
+    },
+    leave() {
+      anchor = null
+    },
+    forget() {
+      anchor = null
+      grabOffset = null
+      forgotten = true
+    },
+  }
+}
+
+/** Measure the hit in the same parent frame that renders the placed child. */
+export function wallPointerInParent(
+  worldPoint: readonly number[],
+  parent: Object3D,
+): [number, number, number] {
+  parent.updateWorldMatrix(true, false)
+  const point = parent.worldToLocal(new Vector3(worldPoint[0], worldPoint[1], worldPoint[2]))
+  return [point.x, point.y, point.z]
+}
+
+/** Collision mesh winding can differ from the wall frame; the hit identifies the touched side. */
+export function wallSideAtPointer(point: readonly number[]): WallSide {
+  return point[2]! >= 0 ? 'front' : 'back'
+}

package/src/lib/window-changes.ts

@@ -0,0 +1,35 @@
+import { type AnyNode, type AnyNodeId, useScene, type WindowNode } from '@pascal-app/core'
+
+/**
+ * Write what Wrap the corner, Merge windows or a placement at a corner planned: one batch, so one
+ * undo step, with the windows and the walls that carry them marked for rebuild.
+ */
+export function writeWindowChanges(changes: {
+  create: WindowNode | null
+  updates: Record<string, Partial<WindowNode>>
+  remove: readonly string[]
+}) {
+  const scene = useScene.getState()
+  const parents = new Set<string>()
+  for (const id of [...Object.keys(changes.updates), ...changes.remove]) {
+    const parentId = scene.nodes[id as AnyNodeId]?.parentId
+    if (parentId) parents.add(parentId)
+  }
+  scene.applyNodeChanges({
+    create: changes.create
+      ? [{ node: changes.create, parentId: changes.create.parentId as AnyNodeId }]
+      : [],
+    update: Object.entries(changes.updates).map(([id, data]) => ({
+      id: id as AnyNodeId,
+      data: data as Partial<AnyNode>,
+    })),
+    delete: changes.remove as AnyNodeId[],
+  })
+  const after = useScene.getState()
+  for (const id of Object.keys(changes.updates)) after.dirtyNodes.add(id as AnyNodeId)
+  if (changes.create) {
+    after.dirtyNodes.add(changes.create.id as AnyNodeId)
+    if (changes.create.parentId) parents.add(changes.create.parentId)
+  }
+  for (const id of parents) after.dirtyNodes.add(id as AnyNodeId)
+}