@pascal-app/editor 1.1.0 → 1.1.1

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

@@ -1,5 +1,6 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test'
-import useAudio from '../store/use-audio'
+import { emitter } from '@pascal-app/core'
+import { configureViewer } from '@pascal-app/viewer'
 
 type FakeContext = { id: string }
 
@@ -93,12 +94,18 @@ const fakeHowler = {
 
 mock.module('howler', () => ({ Howl: FakeHowl, Howler: fakeHowler }))
 
+const sharedSounds = await import('@pascal-app/viewer/sfx')
+const howlsOnImport = instances.length
+
+const { useAudioSettings: useAudio } = sharedSounds
+
 const { disposeSFX, playSFX, preloadSFX, startLoopSFX, stopLoopSFX, updateSFXVolumes } =
   await import('./sfx-player')
 const { disposeSFXBus, initSFXBus, sfxEmitter, triggerSFX } = await import('./sfx-bus')
 
 beforeEach(() => {
   disposeSFXBus()
+  configureViewer({ sfxBaseUrl: '/audios/sfx' })
   activeContext = { id: 'first' }
   initialState = 'loaded'
   useAudio.setState({ masterVolume: 100, muted: false, sfxVolume: 100 })
@@ -108,6 +115,7 @@ beforeEach(() => {
 
 afterAll(() => {
   disposeSFXBus()
+  configureViewer({})
   mock.restore()
 })
 
@@ -325,3 +333,66 @@ describe('SFX audio context lifecycle', () => {
     }
   })
 })
+
+describe('public viewer SFX entry', () => {
+  test('importing the public entry creates no Howl instances', () => {
+    expect(howlsOnImport).toBe(0)
+  })
+
+  test('resolves the default and configured SFX origins at playback time', () => {
+    configureViewer({})
+    sharedSounds.playSound('menuClick')
+    expect(
+      instances.some((s) => s.src === 'https://editor.pascal.app/audios/sfx/menu_click.mp3'),
+    ).toBe(true)
+    const previous = [...instances]
+    configureViewer({ sfxBaseUrl: 'https://sounds.example/custom/' })
+    sharedSounds.playSound('switchOn')
+    expect(previous.every((s) => s.unloadCount === 1)).toBe(true)
+    expect(instances.find((s) => s.playCount === 1 && s.src?.endsWith('switch_on.mp3'))?.src).toBe(
+      'https://sounds.example/custom/switch_on.mp3',
+    )
+    configureViewer({ sfxBaseUrl: '/audios/sfx' })
+    sharedSounds.playSound('switchOff')
+    expect(
+      instances.find((s) => s.playCount === 1 && s.src === '/audios/sfx/switch_off.mp3'),
+    ).toBeDefined()
+  })
+
+  test('interaction subscriptions share delivery and detach independently and idempotently', () => {
+    const first = sharedSounds.initInteractionSounds()
+    const second = sharedSounds.initInteractionSounds()
+    emitter.emit('interaction:sound', 'switch-on')
+    expect(instances.filter((s) => s.playCount === 1)).toHaveLength(1)
+    first()
+    first()
+    emitter.emit('interaction:sound', 'switch-off')
+    expect(instances.filter((s) => s.playCount === 1)).toHaveLength(2)
+    second()
+    emitter.emit('interaction:sound', 'garage')
+    expect(instances.filter((s) => s.playCount === 1)).toHaveLength(2)
+  })
+
+  test('interaction playback uses window and panel gains and the shared mute', () => {
+    const stop = sharedSounds.initInteractionSounds()
+    emitter.emit('interaction:sound', 'window-swing')
+    const swing = instances.find((s) => s.src === '/audios/sfx/door_swing.mp3')
+    expect(swing?.volumeCalls.find(([, id]) => id === 1)?.[0]).toBeCloseTo(0.6)
+    emitter.emit('interaction:sound', 'panel-open')
+    const panel = instances.find((s) => s.src === '/audios/sfx/shutters_open.mp3')
+    expect(panel?.volumeCalls.find(([, id]) => id === 1)?.[0]).toBeCloseTo(0.75)
+    useAudio.getState().setMuted(true)
+    emitter.emit('interaction:sound', 'switch-on')
+    expect(instances.find((s) => s.src === '/audios/sfx/switch_on.mp3')?.playCount).toBe(0)
+    stop()
+  })
+
+  test('viewer and editor UI cues reuse the same Howl cache and settings store', () => {
+    preloadSFX()
+    const count = instances.length
+    sharedSounds.playSound('menuHover')
+    playSFX('menuHover')
+    expect(instances).toHaveLength(count)
+    expect(instances.find((s) => s.src === '/audios/sfx/menu_hover.mp3')?.playCount).toBe(2)
+  })
+})

package/src/lib/sfx-player.ts

@@ -1,414 +1,126 @@
-import { Howl, Howler } from 'howler'
-import useAudio from '../store/use-audio'
-
-// Per-sound variation config. Playback rate also shifts pitch (one semitone ≈ 1.0595×),
-// so a rate range of ~0.88–1.12 reads as a subtle ±2 semitones — enough to kill the
-// machine-gun feeling when the same SFX fires in rapid succession.
-type SFXConfig = {
-  // One file, or several pre-rendered variations cycled round-robin per play.
-  src: string | string[]
-  // Random playback-rate range applied per play (1 = unchanged).
-  rateRange?: [number, number]
-  // Random volume multiplier range applied per play (1 = unchanged).
-  volumeRange?: [number, number]
-  // Minimum gap between two plays of this SFX. Triggers within this window
-  // are silently dropped so bursty sequences don't phase-stack into noise.
-  minIntervalMs?: number
-}
-
-type LoopSFXConfig = {
-  src: string
-  volumeMultiplier: number
-  fadeInMs?: number
-  fadeOutMs?: number
-}
-
-const DEFAULT_MIN_INTERVAL_MS = 30
-const SFX_FAILURE_BACKOFF_MS = 5_000
-const DEFAULT_LOOP_FADE_MS = 90
-
-// SFX sound definitions
-export const SFX: Record<string, SFXConfig> = {
+import {
+  disposeSounds,
+  playSound,
+  preloadSounds,
+  SOUNDS,
+  type SoundDefinition,
+  type SoundPlaybackOptions,
+  startSoundLoop,
+  stopSoundLoop,
+  updateSoundVolumes,
+} from '@pascal-app/viewer/sfx'
+
+export const SFX = {
+  ...SOUNDS,
   gridSnap: {
-    src: [
-      '/audios/sfx/grid_snap_0.mp3',
-      '/audios/sfx/grid_snap_1.mp3',
-      '/audios/sfx/grid_snap_2.mp3',
-    ],
+    src: ['grid_snap_0.mp3', 'grid_snap_1.mp3', 'grid_snap_2.mp3'],
     rateRange: [0.98, 1.02],
     volumeRange: [0.5, 0.6],
     minIntervalMs: 50,
   },
   itemDelete: {
-    src: '/audios/sfx/item_delete.mp3',
+    src: 'item_delete.mp3',
     rateRange: [0.9, 1.1],
     volumeRange: [0.9, 1.0],
   },
   itemPick: {
-    src: '/audios/sfx/item_pick.mp3',
+    src: 'item_pick.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.92, 1.0],
   },
   itemPlace: {
-    src: '/audios/sfx/item_place.mp3',
+    src: 'item_place.mp3',
     rateRange: [0.98, 1.02],
     volumeRange: [0.9, 1.0],
   },
   itemRotate: {
-    src: '/audios/sfx/item_rotate.mp3',
+    src: 'item_rotate.mp3',
     rateRange: [0.94, 1.06],
     volumeRange: [0.92, 1.0],
   },
-  // Ticks as a resize handle is dragged across snap steps. Fires in rapid
-  // succession, so it mirrors gridSnap: three variations cycled round-robin
-  // with pitch jitter and a gap so the run reads as texture, not a tone.
   resize: {
-    src: ['/audios/sfx/resize_0.mp3', '/audios/sfx/resize_1.mp3', '/audios/sfx/resize_2.mp3'],
+    src: ['resize_0.mp3', 'resize_1.mp3', 'resize_2.mp3'],
     rateRange: [0.98, 1.02],
     volumeRange: [0.26, 0.34],
     minIntervalMs: 80,
   },
-  // Fired when a structure draft begins (first click of a wall/slab/etc).
   structureBuildStart: {
-    src: '/audios/sfx/structure_build_start.mp3',
+    src: 'structure_build_start.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.88, 1.0],
   },
-  // Fired when a structure is committed (segment placed / polygon closed).
   structureBuildEnd: {
-    src: '/audios/sfx/structure_build_end.mp3',
+    src: 'structure_build_end.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.88, 1.0],
   },
   structureDelete: {
-    src: '/audios/sfx/structure_delete.mp3',
+    src: 'structure_delete.mp3',
     rateRange: [0.9, 1.1],
     volumeRange: [0.9, 1.0],
   },
   snapshotCapture: {
     // Shutter should sound consistent — no variation.
-    src: '/audios/sfx/snapshot_capture.mp3',
-  },
-  // Soft tick when hovering a main category in the Build / Items panels.
-  // Kept quiet and rate-locked so sweeping across the grid reads as texture,
-  // not a melody.
-  menuHover: {
-    src: '/audios/sfx/menu_hover.mp3',
-    rateRange: [0.98, 1.02],
-    volumeRange: [0.2, 0.3],
-    minIntervalMs: 0,
-  },
-  // Fired when a main category in the Build / Items panels is clicked.
-  menuClick: {
-    src: '/audios/sfx/menu_click.mp3',
-    rateRange: [0.98, 1.02],
-    volumeRange: [0.5, 0.6],
+    src: 'snapshot_capture.mp3',
   },
-  // Fired when a material is applied to a surface in paint mode. Painting can
-  // fire in quick succession across faces, so keep variation + a small gap.
   paintApply: {
-    src: '/audios/sfx/paint_apply.mp3',
+    src: 'paint_apply.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.85, 1.0],
     minIntervalMs: 60,
   },
-  // A three-second jingle for finishing something, not a click cue. No pitch or
-  // volume jitter — a fanfare that lands a semitone off reads as broken rather
-  // than as varied — and a gap longer than the sound itself, so two milestones
-  // that land together play once instead of phasing over each other.
   success: {
-    src: '/audios/sfx/success.mp3',
+    src: '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' },
-  // Operating the building from a viewer's callout or a walkthrough: recorded
-  // door and shutter movements; the switches and the viewer's hover, select and
-  // deselect ticks are the marketing house's synth cues (`scripts/synth-viewer-cues.ts`),
-  // already mixed against the doors, so they play at full volume without jitter.
-  doorOpen: { src: '/audios/sfx/door_open.mp3', rateRange: [0.96, 1.04], volumeRange: [0.9, 1] },
-  doorClose: { src: '/audios/sfx/door_close.mp3', rateRange: [0.96, 1.04], volumeRange: [0.9, 1] },
-  // Air moving as a leaf swings shut, ahead of the latch (`scripts/synth-viewer-cues.ts`).
-  doorSwing: { src: '/audios/sfx/door_swing.mp3', rateRange: [0.97, 1.03] },
-  garageDoor: { src: '/audios/sfx/garage_door.mp3', volumeRange: [0.9, 1] },
-  shuttersOpen: { src: '/audios/sfx/shutters_open.mp3', rateRange: [0.96, 1.04] },
-  shuttersClose: { src: '/audios/sfx/shutters_close.mp3', rateRange: [0.96, 1.04] },
-  switchOn: { src: '/audios/sfx/switch_on.mp3' },
-  switchOff: { src: '/audios/sfx/switch_off.mp3' },
-  viewerHover: { src: '/audios/sfx/viewer_hover.mp3', minIntervalMs: 95 },
-  viewerSelect: { src: '/audios/sfx/viewer_select.mp3', minIntervalMs: 90 },
-  viewerDeselect: { src: '/audios/sfx/viewer_deselect.mp3' },
-} as const
+  turnDone: { src: 'turn_done.mp3' },
+  turnFailed: { src: 'turn_failed.mp3' },
+  turnNeedsInput: { src: 'turn_needs_input.mp3' },
+} satisfies Record<string, SoundDefinition>
 
 export type SFXName = keyof typeof SFX
 
 export const LOOP_SFX = {
   terrainRaise: {
-    src: '/audios/sfx/terrain_raise.mp3',
+    src: 'terrain_raise.mp3',
+    loop: true,
     volumeMultiplier: 0.2,
   },
   terrainLower: {
-    src: '/audios/sfx/terrain_lower.mp3',
+    src: 'terrain_lower.mp3',
+    loop: true,
     volumeMultiplier: 0.2,
   },
   terrainFlatten: {
-    src: '/audios/sfx/terrain_flatten.mp3',
+    src: 'terrain_flatten.mp3',
+    loop: true,
     volumeMultiplier: 0.2,
   },
   terrainSmooth: {
-    src: '/audios/sfx/terrain_smooth.mp3',
+    src: 'terrain_smooth.mp3',
+    loop: true,
     volumeMultiplier: 0.2,
   },
-} as const satisfies Record<string, LoopSFXConfig>
+} as const satisfies Record<string, SoundDefinition>
 
 export type LoopSFXName = keyof typeof LOOP_SFX
-type CachedSFXName = SFXName | LoopSFXName
-
-function loopConfig(name: LoopSFXName): LoopSFXConfig {
-  return LOOP_SFX[name]
-}
-
-export type SFXPlaybackOptions = {
-  source?: 'local' | 'remote'
-  stereo?: number
-  volumeMultiplier?: number
-}
-
-function randomInRange([min, max]: [number, number]): number {
-  return min + Math.random() * (max - min)
-}
-
-let sfxCache = new Map<CachedSFXName, Howl[]>()
-let sfxAudioContext: AudioContext | null = null
-let sfxRetryAfter = 0
-const lastPlayedAt = new Map<SFXName, number>()
-const lastVariation = new Map<SFXName, number>()
-let activeLoop: {
-  id: number
-  name: LoopSFXName
-  sound: Howl
-  volume: number
-} | null = null
-let pendingLoop: { name: LoopSFXName; sound: Howl } | null = null
-let requestedLoop: LoopSFXName | null = null
-
-function loopVolume(name: LoopSFXName): number {
-  const { masterVolume, sfxVolume } = useAudio.getState()
-  return (masterVolume / 100) * (sfxVolume / 100) * LOOP_SFX[name].volumeMultiplier
-}
-
-function stopActiveLoop(fadeMs: number) {
-  const active = activeLoop
-  if (!active) return
-  activeLoop = null
 
-  if (fadeMs <= 0) {
-    active.sound.stop(active.id)
-    return
-  }
-
-  active.sound.once('fade', () => active.sound.stop(active.id), active.id)
-  active.sound.fade(active.volume, 0, fadeMs, active.id)
-}
-
-function unloadCachedSounds(resetPlaybackState: boolean) {
-  requestedLoop = null
-  pendingLoop = null
-  stopActiveLoop(0)
-  for (const sounds of sfxCache.values()) {
-    for (const sound of sounds) {
-      try {
-        sound.unload()
-      } catch {}
-    }
-  }
-  sfxCache.clear()
-  sfxAudioContext = null
-  if (resetPlaybackState) {
-    sfxRetryAfter = 0
-    lastPlayedAt.clear()
-    lastVariation.clear()
-  }
-}
-
-function cacheNeedsRebuild(): boolean {
-  if (sfxCache.size === 0) return true
-  if (sfxAudioContext !== Howler.ctx) return true
-  for (const sounds of sfxCache.values()) {
-    if (sounds.some((sound) => sound.state() === 'unloaded')) return true
-  }
-  return false
-}
+export type SFXPlaybackOptions = SoundPlaybackOptions
 
 export function preloadSFX() {
-  if (!cacheNeedsRebuild()) return
-  unloadCachedSounds(false)
-
-  const definitions = { ...SFX, ...LOOP_SFX }
-  for (const [name, config] of Object.entries(definitions)) {
-    const sources = Array.isArray(config.src) ? config.src : [config.src]
-    sfxCache.set(
-      name as CachedSFXName,
-      sources.map(
-        (src) =>
-          new Howl({
-            loop: name in LOOP_SFX,
-            src: [src],
-            preload: true,
-            volume: 0.5,
-          }),
-      ),
-    )
-  }
-  sfxAudioContext = Howler.ctx ?? null
+  preloadSounds([...Object.values(SFX), ...Object.values(LOOP_SFX)])
 }
 
-export function disposeSFX() {
-  unloadCachedSounds(true)
+export function playSFX(name: SFXName, options?: SFXPlaybackOptions) {
+  preloadSFX()
+  playSound(SFX[name], options)
 }
 
 export function startLoopSFX(name: LoopSFXName) {
-  const { muted } = useAudio.getState()
-  if (muted) {
-    stopLoopSFX()
-    return
-  }
-
-  requestedLoop = name
-  const current = activeLoop
-  if (current?.name === name && current.sound.playing(current.id)) return
-  if (current) stopActiveLoop(loopConfig(current.name).fadeOutMs ?? DEFAULT_LOOP_FADE_MS)
-
-  const now = performance.now()
-  if (now < sfxRetryAfter) return
-
-  try {
-    preloadSFX()
-    // A fresh Howler context rebuilds the cache and clears stale playback
-    // state. Restore this current press after that cleanup so a first-use loop
-    // can still begin when its asset finishes loading.
-    requestedLoop = name
-    const sound = sfxCache.get(name)?.[0]
-    if (!sound) return
-    if (sound.state() !== 'loaded') {
-      if (pendingLoop?.name === name && pendingLoop.sound === sound) return
-      pendingLoop = { name, sound }
-      sound.once('load', () => {
-        if (pendingLoop?.sound === sound) pendingLoop = null
-        if (requestedLoop === name) startLoopSFX(name)
-      })
-      return
-    }
-
-    const config = loopConfig(name)
-    const volume = loopVolume(name)
-    const id = sound.play()
-    sound.volume(0, id)
-    activeLoop = { id, name, sound, volume }
-    sound.fade(0, volume, config.fadeInMs ?? DEFAULT_LOOP_FADE_MS, id)
-  } catch {
-    unloadCachedSounds(false)
-    sfxRetryAfter = now + SFX_FAILURE_BACKOFF_MS
-  }
+  preloadSFX()
+  startSoundLoop(LOOP_SFX[name])
 }
 
-export function stopLoopSFX() {
-  requestedLoop = null
-  pendingLoop = null
-  const fadeMs = activeLoop ? (loopConfig(activeLoop.name).fadeOutMs ?? DEFAULT_LOOP_FADE_MS) : 0
-  stopActiveLoop(fadeMs)
-}
-
-/**
- * Play a sound effect with volume based on audio settings
- */
-export function playSFX(name: SFXName, options: SFXPlaybackOptions = {}) {
-  const config = SFX[name]!
-  const { masterVolume, sfxVolume, muted } = useAudio.getState()
-
-  if (muted) return
-
-  // Drop rapid repeats — two plays of the same SFX within minIntervalMs just
-  // smear into noise, they don't add useful information.
-  const now = performance.now()
-  if (now < sfxRetryAfter) return
-  const minInterval = config.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS
-  const source = options.source ?? 'local'
-  const playbackKey = `${source}:${name}`
-  const last = lastPlayedAt.get(playbackKey)
-  if (last !== undefined && now - last < minInterval) return
-  // Local feedback stays legible when a collaborator makes the same kind of
-  // change at nearly the same time; the quieter remote cue yields instead.
-  const lastLocal = lastPlayedAt.get(`local:${name}`)
-  if (source === 'remote' && lastLocal !== undefined && now - lastLocal < 120) return
-  lastPlayedAt.set(playbackKey, now)
-
-  try {
-    preloadSFX()
-    const sounds = sfxCache.get(name)
-    if (!sounds || sounds.length === 0) return
-
-    // Pick a random variation, avoiding an immediate repeat of the last one so
-    // consecutive plays don't land on the same file.
-    let index = Math.floor(Math.random() * sounds.length)
-    if (sounds.length > 1 && index === lastVariation.get(name)) {
-      index = (index + 1) % sounds.length
-    }
-    lastVariation.set(name, index)
-    const sound = sounds[index]!
-    // Howler queues per-play mutations while a sound is loading. If its global
-    // AudioContext is replaced before that queue drains, stereo setup can try
-    // to connect nodes from different contexts and throw asynchronously.
-    if (sound.state() !== 'loaded') return
-    const baseVolume = (masterVolume / 100) * (sfxVolume / 100)
-    const volumeJitter = config.volumeRange ? randomInRange(config.volumeRange) : 1
-    const volumeMultiplier = Number.isFinite(options.volumeMultiplier)
-      ? Math.max(0, Math.min(2, options.volumeMultiplier!))
-      : 1
-    const rate = config.rateRange ? randomInRange(config.rateRange) : 1
-    const id = sound.play()
-    sound.volume(baseVolume * volumeJitter * volumeMultiplier, id)
-    if (Number.isFinite(options.stereo)) {
-      sound.stereo(Math.max(-1, Math.min(1, options.stereo!)), id)
-    }
-    if (rate !== 1) sound.rate(rate, id)
-  } catch {
-    // Optional audio must never abort an editor input callback. Rebuild from
-    // the current Howler context after a backoff instead of retrying every pointer cue.
-    unloadCachedSounds(false)
-    sfxRetryAfter = now + SFX_FAILURE_BACKOFF_MS
-  }
-}
-
-/**
- * Update all cached SFX volumes (useful when settings change)
- */
-export function updateSFXVolumes() {
-  const { masterVolume, muted, sfxVolume } = useAudio.getState()
-  if (muted) {
-    stopLoopSFX()
-    return
-  }
-  const finalVolume = (masterVolume / 100) * (sfxVolume / 100)
-
-  try {
-    if (performance.now() < sfxRetryAfter) return
-    preloadSFX()
-    sfxCache.forEach((sounds) => {
-      sounds.forEach((sound) => {
-        sound.volume(finalVolume)
-      })
-    })
-    if (activeLoop) {
-      activeLoop.volume = loopVolume(activeLoop.name)
-      activeLoop.sound.volume(activeLoop.volume, activeLoop.id)
-    }
-  } catch {
-    unloadCachedSounds(false)
-    sfxRetryAfter = performance.now() + SFX_FAILURE_BACKOFF_MS
-  }
-}
+export const stopLoopSFX = stopSoundLoop
+export const updateSFXVolumes = updateSoundVolumes
+export const disposeSFX = disposeSounds

package/src/lib/viewer-selection.test.ts

@@ -9,6 +9,8 @@ import {
   ItemNode,
   LevelNode,
   type NodeEvent,
+  RoofNode,
+  RoofSegmentNode,
   SlabNode,
   sceneRegistry,
   UnitNode,
@@ -18,25 +20,25 @@ import {
 } from '@pascal-app/core'
 import { migrateRoomZones } from '@pascal-app/core/scene-migrations'
 import { resolveGlbPick, useViewer } from '@pascal-app/viewer'
-import { CameraControlsImpl } from '@react-three/drei'
-import { createElement } from 'react'
-import * as THREE from 'three'
-import { Group, Vector3 } from 'three'
-import { viewerHoverLabel } from '../components/viewer/viewer-hover-label'
-import { ViewerSelectionManager } from '../components/viewer/viewer-selection-manager'
-import { publishCameraPose } from '../store/camera-pose-store'
-import useEditor, { takePreviewCameraRestore } from '../store/use-editor'
-import { withSelectionHarness } from '../test-utils/selection-harness'
 import {
   frameViewerCamera,
+  publishCameraPose,
   resolveViewerClick,
   resolveViewerHover,
   selectViewerRoom,
   type ViewerSelection,
+  ViewerSelectionManager,
   viewerBreadcrumb,
+  viewerHoverLabel,
   viewerPickFromNodeEvent,
   viewerSidebarSections,
-} from './viewer-selection'
+} from '@pascal-app/viewer/ui'
+import { CameraControlsImpl } from '@react-three/drei'
+import { createElement } from 'react'
+import * as THREE from 'three'
+import { Group, Vector3 } from 'three'
+import useEditor, { takePreviewCameraRestore } from '../store/use-editor'
+import { withSelectionHarness } from '../test-utils/selection-harness'
 
 const english = {
   _: (descriptor: { id: string; message?: string }) => descriptor.message ?? descriptor.id,
@@ -164,6 +166,32 @@ describe('viewer selection rules', () => {
     }
   })
 
+  test("a roof's segment or its face of another kind selects the whole roof", () => {
+    const segment = RoofSegmentNode.parse({ id: 'rseg_main', parentId: 'roof_main' })
+    // A plugin's roof plane (`capabilities.roofs`): the click picks its roof as a segment's does.
+    const plane = {
+      object: 'node',
+      id: 'roofplane_south',
+      type: 'test:roof-plane',
+      parentId: 'roof_main',
+      visible: true,
+      metadata: {},
+    } as unknown as AnyNode
+    const roof = RoofNode.parse({
+      id: 'roof_main',
+      parentId: levelId,
+      children: [segment.id, plane.id],
+    })
+    const { nodes } = scene([roof])
+    nodes[segment.id] = segment
+    nodes[plane.id] = plane
+    for (const nodeId of [segment.id, plane.id])
+      expect(resolveViewerClick(nothing, { nodeId, point: [2, 2] }, nodes)).toMatchObject({
+        levelId,
+        selectedIds: [roof.id],
+      })
+  })
+
   test('empty space clears the room and the element and keeps the floor', () => {
     const { nodes, kitchen } = scene()
     const drilled: ViewerSelection = {

package/src/lib/wall-pull.test.ts

@@ -12,6 +12,7 @@ import {
   WallNode as WallSchema,
   wallAssemblyPatch,
   wallClosesRoom,
+  wallPullSeed,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { createWallOnCurrentLevel } from '../components/tools/wall/wall-drafting'
@@ -23,7 +24,6 @@ import {
   startWallPull,
   useWallPullRun,
   wallDraftIsRun,
-  wallPullSeed,
   wallPullTypePatch,
 } from './wall-pull'
 import { isWallRunFree, snapWallRunDraftPoint, wallRunDirection } from './wall-run-snap'