@pascal-app/editor 1.0.7 → 1.1.1

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/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.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'

package/src/lib/wall-pull.ts

@@ -19,13 +19,13 @@
 
 import {
   type AnyNodeId,
-  getWallCurveFrameAt,
   getWallThickness,
   useScene,
   WALL_CONSTRUCTION_FIELDS,
   type WallNode,
   type WallPlanPoint,
   wallFollowsStorey,
+  wallPullSeed,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { create } from 'zustand'
@@ -34,15 +34,6 @@ import type { ContinuationMode } from './continuation'
 import { getWallDrawVariant, selectWallDrawVariant } from './wall-draw-variant'
 import { publishWallRunFeedback } from './wall-run-snap'
 
-/** The floor plan's affordance id for a wall end's pull grip (a `move-arrow`, variant `pull`). */
-export const WALL_PULL_AFFORDANCE = 'wall-pull'
-
-/** What a pull grip carries: the wall, and which of its ends it pulls from. */
-export type WallPullGripPayload = { wallId: string; endpoint: 'start' | 'end' }
-
-/** The grip's tooltip, in both views. */
-export const WALL_PULL_GRIP_TITLE = 'Drag to draw the next wall'
-
 export type WallPullRun = {
   /** Bumped per pull, so each view seeds its draft from it once. */
   seq: number
@@ -93,23 +84,6 @@ export function wallPullTypePatch(wall: WallNode, storeyHeight: number | null):
   return patch as Partial<WallNode>
 }
 
-/**
- * The pulled end of `wall` and the direction out of it: along the wall for a
- * straight one, along its tangent for a curved one.
- */
-export function wallPullSeed(
-  wall: Pick<WallNode, 'start' | 'end' | 'curveOffset'>,
-  endpoint: 'start' | 'end',
-): { start: WallPlanPoint; reference: WallPlanPoint } | null {
-  const start: WallPlanPoint =
-    endpoint === 'start' ? [wall.start[0], wall.start[1]] : [wall.end[0], wall.end[1]]
-  const tangent = getWallCurveFrameAt(wall as WallNode, endpoint === 'start' ? 0 : 1).tangent
-  const sign = endpoint === 'start' ? -1 : 1
-  const length = Math.hypot(tangent.x, tangent.y)
-  if (!(length > 1e-9)) return null
-  return { start, reference: [(tangent.x / length) * sign, (tangent.y / length) * sign] }
-}
-
 // What the pull changed for its run, put back when it ends.
 let restore: { shape: ContinuationMode; toolDefaults: Record<string, unknown> | null } | null = null
 let stopWatching: (() => void) | null = null

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()