@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/sfx/movement-tick.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from 'bun:test'
+import { movementSfxStepKey } from './movement-tick'
+
+describe('movementSfxStepKey', () => {
+  test('keeps tiny free-move changes in the same bucket', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [1.01, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    ).toBe(
+      movementSfxStepKey({
+        coords: [1.04, 2.01],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    )
+  })
+
+  test('changes bucket after crossing the free-move cadence', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [1.01, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    ).not.toBe(
+      movementSfxStepKey({
+        coords: [1.16, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    )
+  })
+
+  test('uses the live grid step when grid snapping is active', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [0.24, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    ).toBe(
+      movementSfxStepKey({
+        coords: [0.21, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    )
+    expect(
+      movementSfxStepKey({
+        coords: [0.24, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    ).not.toBe(
+      movementSfxStepKey({
+        coords: [0.76, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    )
+  })
+})

package/src/lib/sfx/movement-tick.ts

@@ -0,0 +1,18 @@
+const DEFAULT_FREE_MOVEMENT_SFX_STEP_M = 0.1
+
+type MovementSfxStepKeyArgs = {
+  coords: readonly number[]
+  gridSnapActive: boolean
+  gridStep: number
+  freeStep?: number
+}
+
+export function movementSfxStepKey({
+  coords,
+  gridSnapActive,
+  gridStep,
+  freeStep = DEFAULT_FREE_MOVEMENT_SFX_STEP_M,
+}: MovementSfxStepKeyArgs): string {
+  const step = gridSnapActive && gridStep > 0 ? gridStep : freeStep
+  return coords.map((coord) => Math.round(coord / step)).join(',')
+}

package/src/lib/sfx-bus.ts

@@ -1,5 +1,5 @@
 import mitt from 'mitt'
-import { playSFX } from './sfx-player'
+import { disposeSFX, playSFX } from './sfx-player'
 
 /**
  * SFX-specific events that tools can trigger
@@ -10,12 +10,14 @@ type SFXEvents = {
   'sfx:item-pick': undefined
   'sfx:item-place': undefined
   'sfx:item-rotate': undefined
+  'sfx:resize': undefined
   'sfx:structure-build-start': undefined
   'sfx:structure-build': undefined
   'sfx:structure-delete': undefined
   'sfx:snapshot-capture': undefined
   'sfx:menu-hover': undefined
   'sfx:menu-click': undefined
+  'sfx:paint-apply': undefined
 }
 
 /**
@@ -26,6 +28,20 @@ export const sfxEmitter = mitt<SFXEvents>()
 
 let sfxBusInitialized = false
 
+const handleGridSnap = () => playSFX('gridSnap')
+const handleItemDelete = () => playSFX('itemDelete')
+const handleItemPick = () => playSFX('itemPick')
+const handleItemPlace = () => playSFX('itemPlace')
+const handleItemRotate = () => playSFX('itemRotate')
+const handleResize = () => playSFX('resize')
+const handleStructureBuildStart = () => playSFX('structureBuildStart')
+const handleStructureBuild = () => playSFX('structureBuildEnd')
+const handleStructureDelete = () => playSFX('structureDelete')
+const handleSnapshotCapture = () => playSFX('snapshotCapture')
+const handleMenuHover = () => playSFX('menuHover')
+const handleMenuClick = () => playSFX('menuClick')
+const handlePaintApply = () => playSFX('paintApply')
+
 /**
  * Initialize SFX Bus - connects SFX events to actual sound playback.
  * Safe to call multiple times; re-registration is a no-op once initialized.
@@ -33,18 +49,39 @@ let sfxBusInitialized = false
 export function initSFXBus() {
   if (sfxBusInitialized) return
   sfxBusInitialized = true
-  // Map SFX events to sound playback
-  sfxEmitter.on('sfx:grid-snap', () => playSFX('gridSnap'))
-  sfxEmitter.on('sfx:item-delete', () => playSFX('itemDelete'))
-  sfxEmitter.on('sfx:item-pick', () => playSFX('itemPick'))
-  sfxEmitter.on('sfx:item-place', () => playSFX('itemPlace'))
-  sfxEmitter.on('sfx:item-rotate', () => playSFX('itemRotate'))
-  sfxEmitter.on('sfx:structure-build-start', () => playSFX('structureBuildStart'))
-  sfxEmitter.on('sfx:structure-build', () => playSFX('structureBuildEnd'))
-  sfxEmitter.on('sfx:structure-delete', () => playSFX('structureDelete'))
-  sfxEmitter.on('sfx:snapshot-capture', () => playSFX('snapshotCapture'))
-  sfxEmitter.on('sfx:menu-hover', () => playSFX('menuHover'))
-  sfxEmitter.on('sfx:menu-click', () => playSFX('menuClick'))
+  sfxEmitter.on('sfx:grid-snap', handleGridSnap)
+  sfxEmitter.on('sfx:item-delete', handleItemDelete)
+  sfxEmitter.on('sfx:item-pick', handleItemPick)
+  sfxEmitter.on('sfx:item-place', handleItemPlace)
+  sfxEmitter.on('sfx:item-rotate', handleItemRotate)
+  sfxEmitter.on('sfx:resize', handleResize)
+  sfxEmitter.on('sfx:structure-build-start', handleStructureBuildStart)
+  sfxEmitter.on('sfx:structure-build', handleStructureBuild)
+  sfxEmitter.on('sfx:structure-delete', handleStructureDelete)
+  sfxEmitter.on('sfx:snapshot-capture', handleSnapshotCapture)
+  sfxEmitter.on('sfx:menu-hover', handleMenuHover)
+  sfxEmitter.on('sfx:menu-click', handleMenuClick)
+  sfxEmitter.on('sfx:paint-apply', handlePaintApply)
+}
+
+export function disposeSFXBus() {
+  if (sfxBusInitialized) {
+    sfxEmitter.off('sfx:grid-snap', handleGridSnap)
+    sfxEmitter.off('sfx:item-delete', handleItemDelete)
+    sfxEmitter.off('sfx:item-pick', handleItemPick)
+    sfxEmitter.off('sfx:item-place', handleItemPlace)
+    sfxEmitter.off('sfx:item-rotate', handleItemRotate)
+    sfxEmitter.off('sfx:resize', handleResize)
+    sfxEmitter.off('sfx:structure-build-start', handleStructureBuildStart)
+    sfxEmitter.off('sfx:structure-build', handleStructureBuild)
+    sfxEmitter.off('sfx:structure-delete', handleStructureDelete)
+    sfxEmitter.off('sfx:snapshot-capture', handleSnapshotCapture)
+    sfxEmitter.off('sfx:menu-hover', handleMenuHover)
+    sfxEmitter.off('sfx:menu-click', handleMenuClick)
+    sfxEmitter.off('sfx:paint-apply', handlePaintApply)
+    sfxBusInitialized = false
+  }
+  disposeSFX()
 }
 
 /**

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

@@ -0,0 +1,124 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+type FakeContext = { id: string }
+
+let activeContext: FakeContext = { id: 'first' }
+let throwOnPlay = false
+const instances: FakeHowl[] = []
+
+class FakeHowl {
+  stateValue: 'loaded' | 'unloaded' = 'loaded'
+  unloadCount = 0
+  playCount = 0
+
+  constructor(_options: unknown) {
+    instances.push(this)
+  }
+
+  play() {
+    this.playCount++
+    if (throwOnPlay) throw new DOMException('stale graph', 'InvalidAccessError')
+    return 1
+  }
+
+  volume() {
+    return this
+  }
+
+  rate() {
+    return this
+  }
+
+  state() {
+    return this.stateValue
+  }
+
+  unload() {
+    this.unloadCount++
+    this.stateValue = 'unloaded'
+    return null
+  }
+}
+
+const fakeHowler = {
+  get ctx() {
+    return activeContext
+  },
+}
+
+mock.module('howler', () => ({ Howl: FakeHowl, Howler: fakeHowler }))
+mock.module('../store/use-audio', () => ({
+  default: {
+    getState: () => ({ masterVolume: 100, muted: false, sfxVolume: 100 }),
+  },
+}))
+
+const { disposeSFX, playSFX, preloadSFX } = await import('./sfx-player')
+const { disposeSFXBus, initSFXBus, triggerSFX } = await import('./sfx-bus')
+
+beforeEach(() => {
+  disposeSFXBus()
+  activeContext = { id: 'first' }
+  throwOnPlay = false
+  instances.length = 0
+})
+
+afterAll(() => {
+  disposeSFXBus()
+  mock.restore()
+})
+
+describe('SFX audio context lifecycle', () => {
+  test('reuses the preloaded cache while the Howler context is unchanged', () => {
+    preloadSFX()
+    const initialCount = instances.length
+
+    playSFX('itemDelete')
+
+    expect(instances).toHaveLength(initialCount)
+  })
+
+  test('rebuilds every cached Howl before playing against a new context', () => {
+    preloadSFX()
+    const oldSounds = [...instances]
+    const initialCount = instances.length
+    activeContext = { id: 'second' }
+
+    playSFX('itemDelete')
+
+    expect(oldSounds.every((sound) => sound.unloadCount === 1)).toBe(true)
+    expect(instances.length).toBe(initialCount * 2)
+    expect(instances.slice(initialCount).some((sound) => sound.playCount === 1)).toBe(true)
+  })
+
+  test('contains a stale graph failure and backs off instead of rebuilding per cue', () => {
+    preloadSFX()
+    const initialCount = instances.length
+    throwOnPlay = true
+
+    expect(() => playSFX('menuHover')).not.toThrow()
+    expect(instances.slice(0, initialCount).every((sound) => sound.unloadCount === 1)).toBe(true)
+
+    throwOnPlay = false
+    playSFX('menuHover')
+    expect(instances.length).toBe(initialCount)
+  })
+
+  test('disposes idempotently and recreates sounds after remount', () => {
+    preloadSFX()
+    const initialCount = instances.length
+
+    disposeSFX()
+    disposeSFX()
+    playSFX('itemDelete')
+
+    expect(instances.length).toBe(initialCount * 2)
+  })
+
+  test('does not let an emitted SFX failure escape an editor callback', () => {
+    initSFXBus()
+    throwOnPlay = true
+
+    expect(() => triggerSFX('sfx:item-delete')).not.toThrow()
+  })
+})

package/src/lib/sfx-player.ts

@@ -1,4 +1,4 @@
-import { Howl } from 'howler'
+import { Howl, Howler } from 'howler'
 import useAudio from '../store/use-audio'
 
 // Per-sound variation config. Playback rate also shifts pitch (one semitone ≈ 1.0595×),
@@ -14,13 +14,10 @@ type SFXConfig = {
   // 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
-  // Random stereo pan per play — max absolute offset (0 = center, 1 = hard
-  // right). A small value like 0.15 keeps things centred but adds just enough
-  // spread to stop repeats from stacking on the same point in the field.
-  panJitter?: number
 }
 
 const DEFAULT_MIN_INTERVAL_MS = 30
+const SFX_FAILURE_BACKOFF_MS = 5_000
 
 // SFX sound definitions
 export const SFX: Record<string, SFXConfig> = {
@@ -32,52 +29,53 @@ export const SFX: Record<string, SFXConfig> = {
     ],
     rateRange: [0.98, 1.02],
     volumeRange: [0.5, 0.6],
-    panJitter: 0.15,
     minIntervalMs: 50,
   },
   itemDelete: {
     src: '/audios/sfx/item_delete.mp3',
     rateRange: [0.9, 1.1],
     volumeRange: [0.9, 1.0],
-    panJitter: 0.05,
   },
   itemPick: {
     src: '/audios/sfx/item_pick.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.92, 1.0],
-    panJitter: 0.15,
   },
   itemPlace: {
     src: '/audios/sfx/item_place.mp3',
     rateRange: [0.98, 1.02],
     volumeRange: [0.9, 1.0],
-    panJitter: 0.15,
   },
   itemRotate: {
     src: '/audios/sfx/item_rotate.mp3',
     rateRange: [0.94, 1.06],
     volumeRange: [0.92, 1.0],
-    panJitter: 0.15,
+  },
+  // 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'],
+    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',
     rateRange: [0.95, 1.05],
     volumeRange: [0.88, 1.0],
-    panJitter: 0.15,
   },
   // Fired when a structure is committed (segment placed / polygon closed).
   structureBuildEnd: {
     src: '/audios/sfx/structure_build_end.mp3',
     rateRange: [0.95, 1.05],
     volumeRange: [0.88, 1.0],
-    panJitter: 0.15,
   },
   structureDelete: {
     src: '/audios/sfx/structure_delete.mp3',
     rateRange: [0.9, 1.1],
     volumeRange: [0.9, 1.0],
-    panJitter: 0.08,
   },
   snapshotCapture: {
     // Shutter should sound consistent — no variation.
@@ -90,7 +88,6 @@ export const SFX: Record<string, SFXConfig> = {
     src: '/audios/sfx/menu_hover.mp3',
     rateRange: [0.98, 1.02],
     volumeRange: [0.2, 0.3],
-    panJitter: 0.1,
     minIntervalMs: 0,
   },
   // Fired when a main category in the Build / Items panels is clicked.
@@ -98,7 +95,14 @@ export const SFX: Record<string, SFXConfig> = {
     src: '/audios/sfx/menu_click.mp3',
     rateRange: [0.98, 1.02],
     volumeRange: [0.5, 0.6],
-    panJitter: 0.1,
+  },
+  // 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',
+    rateRange: [0.95, 1.05],
+    volumeRange: [0.85, 1.0],
+    minIntervalMs: 60,
   },
 } as const
 
@@ -108,71 +112,105 @@ function randomInRange([min, max]: [number, number]): number {
   return min + Math.random() * (max - min)
 }
 
-// Preload all SFX sounds. Each variation gets its own Howl so they can overlap
-// and be cycled round-robin.
-const sfxCache = new Map<SFXName, Howl[]>()
+let sfxCache = new Map<SFXName, Howl[]>()
+let sfxAudioContext: AudioContext | null = null
+let sfxRetryAfter = 0
 const lastPlayedAt = new Map<SFXName, number>()
 const lastVariation = new Map<SFXName, number>()
 
-// Initialize all sounds
-Object.entries(SFX).forEach(([name, config]) => {
-  const sources = Array.isArray(config.src) ? config.src : [config.src]
-  const sounds = sources.map(
-    (src) =>
-      new Howl({
-        src: [src],
-        preload: true,
-        volume: 0.5, // Will be adjusted by the bus
-      }),
-  )
-  sfxCache.set(name as SFXName, sounds)
-})
+function unloadCachedSounds(resetPlaybackState: boolean) {
+  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 function preloadSFX() {
+  if (!cacheNeedsRebuild()) return
+  unloadCachedSounds(false)
+
+  for (const [name, config] of Object.entries(SFX)) {
+    const sources = Array.isArray(config.src) ? config.src : [config.src]
+    sfxCache.set(
+      name as SFXName,
+      sources.map(
+        (src) =>
+          new Howl({
+            src: [src],
+            preload: true,
+            volume: 0.5,
+          }),
+      ),
+    )
+  }
+  sfxAudioContext = Howler.ctx ?? null
+}
+
+export function disposeSFX() {
+  unloadCachedSounds(true)
+}
 
 /**
  * Play a sound effect with volume based on audio settings
  */
 export function playSFX(name: SFXName) {
-  const sounds = sfxCache.get(name)
-  if (!sounds || sounds.length === 0) {
-    console.warn(`SFX not found: ${name}`)
-    return
-  }
   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 last = lastPlayedAt.get(name)
   if (last !== undefined && now - last < minInterval) return
   lastPlayedAt.set(name, now)
 
-  // 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]!
-
-  const { masterVolume, sfxVolume, muted } = useAudio.getState()
-
-  if (muted) return
-
-  // Calculate final volume (masterVolume and sfxVolume are 0-100)
-  const baseVolume = (masterVolume / 100) * (sfxVolume / 100)
-  const volumeJitter = config.volumeRange ? randomInRange(config.volumeRange) : 1
-  const rate = config.rateRange ? randomInRange(config.rateRange) : 1
-
-  // Apply per-play variation using the returned sound id so overlapping plays
-  // don't fight over shared properties on the Howl.
-  const id = sound.play()
-  sound.volume(baseVolume * volumeJitter, id)
-  if (rate !== 1) sound.rate(rate, id)
-  if (config.panJitter) {
-    const pan = (Math.random() * 2 - 1) * config.panJitter
-    sound.stereo(pan, id)
+  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]!
+    const baseVolume = (masterVolume / 100) * (sfxVolume / 100)
+    const volumeJitter = config.volumeRange ? randomInRange(config.volumeRange) : 1
+    const rate = config.rateRange ? randomInRange(config.rateRange) : 1
+    const id = sound.play()
+    sound.volume(baseVolume * volumeJitter, 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
   }
 }
 
@@ -183,9 +221,16 @@ export function updateSFXVolumes() {
   const { masterVolume, sfxVolume } = useAudio.getState()
   const finalVolume = (masterVolume / 100) * (sfxVolume / 100)
 
-  sfxCache.forEach((sounds) => {
-    sounds.forEach((sound) => {
-      sound.volume(finalVolume)
+  try {
+    if (performance.now() < sfxRetryAfter) return
+    preloadSFX()
+    sfxCache.forEach((sounds) => {
+      sounds.forEach((sound) => {
+        sound.volume(finalVolume)
+      })
     })
-  })
+  } catch {
+    unloadCachedSounds(false)
+    sfxRetryAfter = performance.now() + SFX_FAILURE_BACKOFF_MS
+  }
 }

package/src/lib/slab-plan-snap.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, WallNode } from '@pascal-app/core'
+import useWallSnapIndicator from '../store/use-wall-snap-indicator'
+import { resolveSlabEdgeBandSnap } from './slab-plan-snap'
+
+function sceneWithWall(thickness = 0.1) {
+  const wall = WallNode.parse({ start: [0, 0], end: [4, 0], thickness })
+  const nodes: Record<string, AnyNode> = { [wall.id]: wall }
+  return { wall, nodes }
+}
+
+describe('resolveSlabEdgeBandSnap', () => {
+  test('magnetic: an edge inside the wall band sticks to the centerline and shows the beacon', () => {
+    const { wall, nodes } = sceneWithWall()
+    useWallSnapIndicator.getState().clear()
+
+    const snap = resolveSlabEdgeBandSnap({
+      edge: [
+        [0.5, 0.08],
+        [3.5, 0.08],
+      ],
+      nodes,
+      referencePoint: [1, 0.08],
+      magnetic: true,
+    })
+
+    expect(snap).not.toBeNull()
+    expect(snap!.wallId).toBe(wall.id)
+    expect(snap!.edge[0][1]).toBeCloseTo(0)
+    expect(snap!.edge[1][1]).toBeCloseTo(0)
+
+    const beacon = useWallSnapIndicator.getState().point
+    expect(beacon).not.toBeNull()
+    expect(beacon!.kind).toBe('wall')
+    expect(beacon!.wallIds).toEqual([wall.id])
+    // Beacon hugs the reference point projected onto the snapped edge.
+    expect(beacon!.x).toBeCloseTo(1)
+    expect(beacon!.z).toBeCloseTo(0)
+  })
+
+  test('non-magnetic: only the tight connect stick remains', () => {
+    const { nodes } = sceneWithWall()
+
+    // 8cm off the centerline: inside the band but beyond the connect radius.
+    expect(
+      resolveSlabEdgeBandSnap({
+        edge: [
+          [0.5, 0.08],
+          [3.5, 0.08],
+        ],
+        nodes,
+        magnetic: false,
+      }),
+    ).toBeNull()
+    expect(useWallSnapIndicator.getState().point).toBeNull()
+
+    // 4cm: genuinely dropped on the wall — still sticks.
+    expect(
+      resolveSlabEdgeBandSnap({
+        edge: [
+          [0.5, 0.04],
+          [3.5, 0.04],
+        ],
+        nodes,
+        magnetic: false,
+      }),
+    ).not.toBeNull()
+  })
+
+  test('clears the beacon when the edge leaves every band', () => {
+    const { nodes } = sceneWithWall()
+
+    resolveSlabEdgeBandSnap({
+      edge: [
+        [0.5, 0.05],
+        [3.5, 0.05],
+      ],
+      nodes,
+      magnetic: true,
+    })
+    expect(useWallSnapIndicator.getState().point).not.toBeNull()
+
+    resolveSlabEdgeBandSnap({
+      edge: [
+        [0.5, 1.5],
+        [3.5, 1.5],
+      ],
+      nodes,
+      magnetic: true,
+    })
+    expect(useWallSnapIndicator.getState().point).toBeNull()
+  })
+})