@pascal-app/editor 1.0.5 → 1.0.7

package/src/lib/sfx-bus.ts

@@ -1,10 +1,11 @@
-import type { TerrainVerb } from '@pascal-app/core'
+import { emitter, type InteractionSound, type TerrainVerb } from '@pascal-app/core'
 import mitt from 'mitt'
 import useAudio from '../store/use-audio'
 import {
   disposeSFX,
   type LoopSFXName,
   playSFX,
+  type SFXName,
   startLoopSFX,
   stopLoopSFX,
   updateSFXVolumes,
@@ -74,6 +75,29 @@ const handleTerrainSculptStart = (verb: TerrainVerb) => startLoopSFX(TERRAIN_LOO
 const handleTerrainSculptStop = () => stopLoopSFX()
 let unsubscribeAudio: (() => void) | null = null
 
+/** Windows ride the door recordings, softer: a sash weighs less than a leaf. */
+const INTERACTION_SFX: Record<InteractionSound, [SFXName, number]> = {
+  'door-open': ['doorOpen', 1],
+  'door-swing': ['doorSwing', 1],
+  'door-close': ['doorClose', 1],
+  'window-open': ['doorOpen', 0.6],
+  'window-swing': ['doorSwing', 0.6],
+  'window-close': ['doorClose', 0.6],
+  garage: ['garageDoor', 1],
+  'shutters-open': ['shuttersOpen', 1],
+  'shutters-close': ['shuttersClose', 1],
+  // Cabinet doors and drawers: the panel recordings, as the marketing house plays its cabinets.
+  'panel-open': ['shuttersOpen', 0.75],
+  'panel-swing': ['doorSwing', 0.45],
+  'panel-close': ['shuttersClose', 0.75],
+  'switch-on': ['switchOn', 1],
+  'switch-off': ['switchOff', 1],
+}
+const handleInteractionSound = (sound: InteractionSound) => {
+  const [name, volumeMultiplier] = INTERACTION_SFX[sound]
+  playSFX(name, { volumeMultiplier })
+}
+
 /**
  * Initialize SFX Bus - connects SFX events to actual sound playback.
  * Safe to call multiple times; re-registration is a no-op once initialized.
@@ -100,6 +124,7 @@ export function initSFXBus() {
   sfxEmitter.on('sfx:turn-needs-input', handleTurnNeedsInput)
   sfxEmitter.on('sfx:terrain-sculpt-start', handleTerrainSculptStart)
   sfxEmitter.on('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
+  emitter.on('interaction:sound', handleInteractionSound)
   unsubscribeAudio = useAudio.subscribe(updateSFXVolumes)
   updateSFXVolumes()
 }
@@ -125,6 +150,7 @@ export function disposeSFXBus() {
     sfxEmitter.off('sfx:turn-needs-input', handleTurnNeedsInput)
     sfxEmitter.off('sfx:terrain-sculpt-start', handleTerrainSculptStart)
     sfxEmitter.off('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
+    emitter.off('interaction:sound', handleInteractionSound)
     unsubscribeAudio?.()
     unsubscribeAudio = null
     sfxBusInitialized = false

package/src/lib/sfx-player.ts

@@ -126,6 +126,22 @@ export const SFX: Record<string, SFXConfig> = {
   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
 
 export type SFXName = keyof typeof SFX

package/src/lib/tool-cursor-icon.ts

@@ -1,3 +1,4 @@
+import type { MessageDescriptor } from '@pascal-app/core'
 import type { ContinuationMode } from './continuation'
 import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
 
@@ -5,7 +6,10 @@ import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
  * The cursor bubble's icon for the wall tool: the Rooms variant in hand
  * (Rectangle / Polygon / Walls), the same art as the Build panel tile.
  */
-export function wallCursorIcon(mode: ContinuationMode): { label: string; iconSrc: string } {
+export function wallCursorIcon(mode: ContinuationMode): {
+  label: MessageDescriptor
+  iconSrc: string
+} {
   const variant = getWallDrawVariantInfo(wallDrawVariantOf(mode))
   return { label: variant.title, iconSrc: variant.iconSrc }
 }

package/src/lib/tool-shortcuts.ts

@@ -0,0 +1,130 @@
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import { openSidebarPanel } from './sidebar-panel'
+
+/**
+ * The single-key tools of the editor, and the keys tooltips print for them.
+ *
+ * The drafting tools (Door, Window, Stairs, Roof) sit on Shift with their
+ * letter, as the bare key was taken: W/A/S/D pan the view in 2D and 3D,
+ * R flips or rotates the selection and the armed placement, and E operates the
+ * selected door, window or cabinet. Pan stands down for those Shift chords
+ * (`claimsKeyboardPan`), and R/E still work bare as before.
+ */
+export type ToolShortcutId =
+  | 'select'
+  | 'delete'
+  | 'wall'
+  | 'item'
+  | 'zone'
+  | 'measurement'
+  | 'paint'
+  | 'terrain'
+  | 'door'
+  | 'window'
+  | 'stair'
+  | 'roof'
+
+type ArmedByChord = {
+  /** `KeyboardEvent.code`: the physical key, as pan reads it. */
+  code: string
+  shift: boolean
+}
+
+/** Keys as `ShortcutToken` names them. */
+export const TOOL_SHORTCUT_KEYS: Record<ToolShortcutId, readonly string[]> = {
+  select: ['V'],
+  delete: ['X'],
+  wall: ['B'],
+  item: ['F'],
+  zone: ['Z'],
+  measurement: ['M'],
+  paint: ['P'],
+  terrain: ['G'],
+  door: ['Shift', 'D'],
+  window: ['Shift', 'W'],
+  stair: ['Shift', 'S'],
+  roof: ['Shift', 'R'],
+}
+
+/** The tools this module arms itself; the older keys stay in `use-keyboard`. */
+const CHORDS: Partial<Record<ToolShortcutId, ArmedByChord>> = {
+  door: { code: 'KeyD', shift: true },
+  window: { code: 'KeyW', shift: true },
+  stair: { code: 'KeyS', shift: true },
+  roof: { code: 'KeyR', shift: true },
+}
+
+/** A tool's shortcut as a tooltip prints it: `Shift+D`, `B`. Null for a tool without one. */
+export function toolShortcutLabel(tool: string): string | null {
+  const keys = TOOL_SHORTCUT_KEYS[tool as ToolShortcutId]
+  return keys ? keys.join('+') : null
+}
+
+/** A tool's tooltip with its shortcut: `Door (Shift+D)`; the bare label when it has none. */
+export function withToolShortcut(label: string, tool: string | undefined): string {
+  const shortcut = tool ? toolShortcutLabel(tool) : null
+  return shortcut ? `${label} (${shortcut})` : label
+}
+
+// Gestures a held Shift modifies (free move, free rotate, force place): a Shift
+// chord there is part of the gesture, never a tool switch.
+const SHIFT_GESTURE_SCOPES = new Set([
+  'room-divide',
+  'placing',
+  'moving',
+  'handle-drag',
+  'mesh-editing',
+  'reshaping',
+  'box-select',
+  'painting',
+  'sculpting',
+  'pointing',
+])
+
+/**
+ * The tool a key press arms, or null: the physical key and Shift, with no other
+ * modifier and no repeat. A Shift chord is off while a gesture holds Shift, so
+ * Shift+WASD keeps panning there.
+ */
+export function toolShortcutForKey(
+  event: Pick<KeyboardEvent, 'code' | 'shiftKey' | 'metaKey' | 'ctrlKey' | 'altKey' | 'repeat'>,
+): ToolShortcutId | null {
+  if (event.metaKey || event.ctrlKey || event.altKey || event.repeat) return null
+  const entry = Object.entries(CHORDS).find(
+    ([, chord]) => chord.code === event.code && chord.shift === event.shiftKey,
+  )
+  if (!entry) return null
+  if (event.shiftKey && SHIFT_GESTURE_SCOPES.has(useInteractionScope.getState().scope.kind))
+    return null
+  return entry[0] as ToolShortcutId
+}
+
+/** Whether WASD pan must leave this key to a tool shortcut (Shift+W/S/D). */
+export function claimsKeyboardPan(
+  event: Pick<KeyboardEvent, 'code' | 'shiftKey' | 'metaKey' | 'ctrlKey' | 'altKey' | 'repeat'>,
+): boolean {
+  // A held key repeats: once claimed, the repeats stay claimed too. (Fields one by
+  // one: a DOM event's are getters a spread would drop.)
+  return (
+    event.shiftKey &&
+    toolShortcutForKey({
+      code: event.code,
+      shiftKey: event.shiftKey,
+      metaKey: event.metaKey,
+      ctrlKey: event.ctrlKey,
+      altKey: event.altKey,
+      repeat: false,
+    }) !== null
+  )
+}
+
+/** Arm the tool `id` names from the keyboard, as its Build panel tile does, with the panel showing. */
+export function armToolShortcut(id: ToolShortcutId): void {
+  const editor = useEditor.getState()
+  editor.setPhase('building')
+  openSidebarPanel(['build'])
+  // A raw tool, as a tile click arms it: no preset carried over from earlier.
+  editor.setToolDefaults(id, null)
+  editor.armToolMode({ mode: 'build', tool: id })
+}

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

@@ -38,6 +38,10 @@ import {
   viewerSidebarSections,
 } from './viewer-selection'
 
+const english = {
+  _: (descriptor: { id: string; message?: string }) => descriptor.message ?? descriptor.id,
+}
+
 const buildingId = 'building_viewer'
 const levelId = 'level_viewer'
 const upperId = 'level_viewer_upper'
@@ -251,10 +255,10 @@ describe('viewer rooms by name', () => {
 
   test('the hover pill names what a click would select', () => {
     const { nodes, kitchen } = scene()
-    expect(viewerHoverLabel(sofa.id, nodes)).toBe('Sofa')
-    expect(viewerHoverLabel(kitchen, nodes)).toBe('Kitchen')
-    expect(viewerHoverLabel('wall_shared', nodes)).toBe('Wall')
-    expect(viewerHoverLabel(null, nodes)).toBeNull()
+    expect(viewerHoverLabel(sofa.id, nodes, english)).toBe('Sofa')
+    expect(viewerHoverLabel(kitchen, nodes, english)).toBe('Kitchen')
+    expect(viewerHoverLabel('wall_shared', nodes, english)).toBe('Wall')
+    expect(viewerHoverLabel(null, nodes, english)).toBeNull()
   })
 })
 
@@ -262,7 +266,7 @@ describe('viewer breadcrumb', () => {
   test('an item reads floor › room › item; the room is shown, not selected', () => {
     const { nodes, kitchen } = scene()
     const selection = { buildingId, levelId, zoneId: null, selectedIds: [sofa.id] }
-    const crumbs = viewerBreadcrumb(selection as ViewerSelection, null, nodes, (id) =>
+    const crumbs = viewerBreadcrumb(selection as ViewerSelection, null, nodes, english, (id) =>
       id === sofa.id ? kitchen : null,
     )
     expect(crumbs.map((crumb) => [crumb.kind, crumb.label])).toEqual([
@@ -277,18 +281,20 @@ describe('viewer breadcrumb', () => {
     const unit = UnitNode.parse({ id: 'unit_a', name: 'Apartment A', parentId: buildingId })
     const { nodes, living } = scene([unit])
     const room = { buildingId, levelId, zoneId: living, selectedIds: [] } as ViewerSelection
-    expect(viewerBreadcrumb(room, null, nodes).map((crumb) => crumb.label)).toEqual([
+    expect(viewerBreadcrumb(room, null, nodes, english).map((crumb) => crumb.label)).toEqual([
       'House',
       'Ground floor',
       'Living',
     ])
     const floor = { ...room, zoneId: null }
-    expect(viewerBreadcrumb(floor, 'unit_a', nodes).map((crumb) => crumb.label)).toEqual([
+    expect(viewerBreadcrumb(floor, 'unit_a', nodes, english).map((crumb) => crumb.label)).toEqual([
       'House',
       'Ground floor',
       'Apartment A',
     ])
-    expect(viewerBreadcrumb(nothing, null, nodes).map((crumb) => crumb.kind)).toEqual(['building'])
+    expect(viewerBreadcrumb(nothing, null, nodes, english).map((crumb) => crumb.kind)).toEqual([
+      'building',
+    ])
   })
 })
 
@@ -305,25 +311,21 @@ describe('viewer sidebar', () => {
       ],
     })
     const plain = scene([terrace])
-    expect(viewerSidebarSections(levelId, plain.nodes).map((section) => section.kind)).toEqual([
-      'rooms',
-      'zones',
-    ])
-    expect(viewerSidebarSections(levelId, plain.nodes)[0]!.rows.map((row) => row.label)).toEqual([
-      'Kitchen',
-      'Living',
-    ])
-    expect(viewerSidebarSections(upperId, plain.nodes)).toEqual([])
+    expect(
+      viewerSidebarSections(levelId, plain.nodes, english).map((section) => section.kind),
+    ).toEqual(['rooms', 'zones'])
+    expect(
+      viewerSidebarSections(levelId, plain.nodes, english)[0]!.rows.map((row) => row.label),
+    ).toEqual(['Kitchen', 'Living'])
+    expect(viewerSidebarSections(upperId, plain.nodes, english)).toEqual([])
 
     const unit = UnitNode.parse({ id: 'unit_a', name: 'Apartment A', parentId: buildingId })
     const withUnit = scene([unit, terrace])
     withUnit.nodes.unit_a = { ...unit, members: [withUnit.kitchen as ZoneNode['id']] }
-    expect(viewerSidebarSections(levelId, withUnit.nodes).map((section) => section.kind)).toEqual([
-      'units',
-      'rooms',
-      'zones',
-    ])
-    expect(viewerSidebarSections(upperId, withUnit.nodes)).toEqual([])
+    expect(
+      viewerSidebarSections(levelId, withUnit.nodes, english).map((section) => section.kind),
+    ).toEqual(['units', 'rooms', 'zones'])
+    expect(viewerSidebarSections(upperId, withUnit.nodes, english)).toEqual([])
   })
 })
 
@@ -546,7 +548,9 @@ test('baked and parametric picks agree for room faces, mezzanine plates, doors,
   const baked = resolveGlbPick([{ object: foreign, point: new Vector3() }], identity)
   expect(resolveViewerClick(nothing, baked, nodes)).toEqual(nothing)
   expect(
-    viewerBreadcrumb(nothing, null, nodes).some((crumb) => crumb.label === 'Unpublished name'),
+    viewerBreadcrumb(nothing, null, nodes, english).some(
+      (crumb) => crumb.label === 'Unpublished name',
+    ),
   ).toBe(false)
 })
 

package/src/lib/viewer-selection.ts

@@ -30,6 +30,7 @@ import {
 import { useBelowGrade } from './below-grade'
 import { nodeDisplayLabel } from './node-display-label'
 import { roomFloorElevation } from './room-handle-drag'
+import { type DescriptorTranslator, displayRoomName } from './room-name-messages'
 import { RoomSelectionIndex, type RoomSelectionRecord, resolveRoomHit } from './room-selection'
 import type { SelectionModifierKeys } from './selection-routing'
 
@@ -455,8 +456,16 @@ export type ViewerCrumb = {
   label: string
 }
 
-export function zoneLabel(zone: ZoneNode): string {
-  return zone.name?.trim() || (zone.spaceRole === 'room' ? 'Room' : 'Zone')
+/**
+ * The viewer chrome's name for a zone, in the editor's UI language (the scene
+ * keeps its stored name). `i18n` is the caller's scoped `usePascalI18n()`.
+ */
+export function zoneLabel(zone: ZoneNode, i18n: DescriptorTranslator): string {
+  const name = zone.name?.trim()
+  if (name) return displayRoomName(name, i18n)
+  return zone.spaceRole === 'room'
+    ? i18n._({ id: 'editor.roomLabel.room', message: 'Room' })
+    : i18n._({ id: 'editor.roomLabel.zone', message: 'Zone' })
 }
 
 /**
@@ -468,6 +477,7 @@ export function viewerBreadcrumb(
   selection: ViewerSelection,
   focusedUnitId: string | null,
   nodes: ViewerNodes,
+  i18n: DescriptorTranslator,
   roomOf: (nodeId: string, levelId: string) => string | null = () => null,
 ): ViewerCrumb[] {
   const crumbs: ViewerCrumb[] = []
@@ -486,7 +496,8 @@ export function viewerBreadcrumb(
   if (unit?.type === 'unit') crumbs.push({ kind: 'unit', id: unit.id, label: unit.name })
   const roomId = selection.zoneId ?? (element ? roomOf(element.id, level.id) : null)
   const room = roomId ? nodes[roomId] : undefined
-  if (room?.type === 'zone') crumbs.push({ kind: 'room', id: room.id, label: zoneLabel(room) })
+  if (room?.type === 'zone')
+    crumbs.push({ kind: 'room', id: room.id, label: zoneLabel(room, i18n) })
   if (element) crumbs.push({ kind: 'node', id: element.id, label: nodeDisplayLabel(element) })
   return crumbs
 }
@@ -531,14 +542,18 @@ export type ViewerSidebarSection = { kind: 'units' | 'rooms' | 'zones'; rows: Vi
  * What sits under the current floor: its units, its rooms, its other zones.
  * An empty section is left out.
  */
-export function viewerSidebarSections(levelId: string, nodes: ViewerNodes): ViewerSidebarSection[] {
+export function viewerSidebarSections(
+  levelId: string,
+  nodes: ViewerNodes,
+  i18n: DescriptorTranslator,
+): ViewerSidebarSection[] {
   const zones = Object.values(nodes).filter(
     (node): node is ZoneNode =>
       node.type === 'zone' && node.parentId === levelId && node.visible !== false,
   )
   const zoneRow = (zone: ZoneNode): ViewerSidebarRow => ({
     id: zone.id,
-    label: zoneLabel(zone),
+    label: zoneLabel(zone, i18n),
     color: zone.color,
     areaM2: area([{ outer: zone.polygon, holes: zone.holes ?? [] }]),
   })

package/src/lib/wall-draw-variant.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from 'bun:test'
 import { emitter } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
+import { CONTINUATION_PROFILES } from './continuation'
 import { toolHudTitle } from './hud-title'
 import {
   getWallDrawVariant,
@@ -23,9 +24,9 @@ describe('Rooms variants', () => {
     ])
   })
 
-  test('default to the chain that closes into a room', () => {
-    expect(getWallDrawVariant()).toBe('polygon')
-    expect(wallDrawVariantOf('unknown')).toBe('polygon')
+  test('default to Rectangle', () => {
+    expect(wallDrawVariantOf(CONTINUATION_PROFILES.wall.default)).toBe('rectangle')
+    expect(wallDrawVariantOf('unknown')).toBe('rectangle')
   })
 
   test('picking one sets the wall tool drawing mode, and it sticks', () => {
@@ -61,11 +62,11 @@ describe('Rooms variants', () => {
 
   test('name the HUD after the variant in hand', () => {
     expect(toolHudTitle('wall', 'rectangle')).toEqual({
-      label: 'Rectangle room',
+      label: expect.objectContaining({ message: 'Rectangle room' }),
       icon: { kind: 'url', src: '/icons/room.webp' },
       shortcut: 'B',
     })
-    expect(toolHudTitle('wall', 'room')?.label).toBe('Polygon room')
-    expect(toolHudTitle('wall', 'single')?.label).toBe('Walls')
+    expect(toolHudTitle('wall', 'room')?.label.message).toBe('Polygon room')
+    expect(toolHudTitle('wall', 'single')?.label.message).toBe('Walls')
   })
 })

package/src/lib/wall-draw-variant.ts

@@ -1,6 +1,15 @@
-import { emitter } from '@pascal-app/core'
+import {
+  emitter,
+  type MessageDescriptor,
+  railingWallDefaults,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
 import useEditor from '../store/use-editor'
 import type { ContinuationMode } from './continuation'
+import { levelSeparatorLines } from './separator-lines'
 
 /**
  * How the wall tool draws, picked from the Build panel's Rooms group before
@@ -16,7 +25,7 @@ export type WallDrawVariantInfo = {
   /** Tile label. */
   label: string
   /** The name the HUD shows while the variant is armed. */
-  title: string
+  title: MessageDescriptor
   iconSrc: string
   /** Caption under the Rooms tiles: a bold lead, then the rest. */
   caption: { lead: string; rest: string }
@@ -27,7 +36,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'rectangle',
     mode: 'rectangle',
     label: 'Rectangle',
-    title: 'Rectangle room',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.rectangleRoom', message: 'Rectangle room' },
     iconSrc: '/icons/room.webp',
     caption: {
       lead: 'Click two corners',
@@ -38,7 +47,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'polygon',
     mode: 'room',
     label: 'Polygon',
-    title: 'Polygon room',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.polygonRoom', message: 'Polygon room' },
     iconSrc: '/icons/polygon-room.webp',
     caption: {
       lead: 'Click each corner,',
@@ -49,7 +58,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'walls',
     mode: 'single',
     label: 'Walls',
-    title: 'Walls',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.walls', message: 'Walls' },
     iconSrc: '/icons/wall.webp',
     caption: {
       lead: 'Draw one wall at a time.',
@@ -66,7 +75,7 @@ export function getWallDrawVariantInfo(variant: WallDrawVariant): WallDrawVarian
 }
 
 export function wallDrawVariantOf(mode: ContinuationMode): WallDrawVariant {
-  return WALL_DRAW_VARIANTS.find((info) => info.mode === mode)?.id ?? 'polygon'
+  return WALL_DRAW_VARIANTS.find((info) => info.mode === mode)?.id ?? 'rectangle'
 }
 
 export function getWallDrawVariant(): WallDrawVariant {
@@ -89,3 +98,95 @@ export function selectWallDrawVariant(variant: WallDrawVariant): void {
   if (editor.mode === 'build' && editor.tool === 'wall') emitter.emit('tool:cancel')
   editor.setContinuation('wall', mode)
 }
+
+/**
+ * What the wall tool draws in place of plain walls: invisible walls (room separators no wall
+ * stands on) or railings.
+ */
+export type WallLineKind = 'invisible' | 'railing'
+
+/**
+ * The Walls variant's kinds, its sub-row in the Build panel: a plain wall (room detection
+ * sides it exterior or interior), an invisible wall, or a railing.
+ */
+export type WallKind = 'standard' | WallLineKind
+
+export const WALL_KINDS: ReadonlyArray<{ id: WallKind; label: MessageDescriptor }> = [
+  {
+    id: 'standard',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.standard', message: 'Standard' },
+  },
+  {
+    id: 'invisible',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.invisible', message: 'Invisible' },
+  },
+  {
+    id: 'railing',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.railing', message: 'Railing' },
+  },
+]
+
+/** The line an invisible wall's draft is drawn at, metres. */
+export const INVISIBLE_WALL_DRAFT_THICKNESS = 0.01
+
+// Session-only, so it lives beside the persisted editor store, not in it.
+const useWallLineKindStore = create<{ lineKind: WallLineKind | null }>(() => ({
+  lineKind: null,
+}))
+
+export function getWallLineKind(): WallLineKind | null {
+  return useWallLineKindStore.getState().lineKind
+}
+
+/** The kind the Walls variant draws, for the Build panel's sub-row. */
+export function useWallKind(): WallKind {
+  return useWallLineKindStore((state) => state.lineKind ?? 'standard')
+}
+
+/**
+ * Pick what the Walls variant draws, for this session: it lasts while the wall tool draws
+ * Walls (`subscribeWallKindReset`). Switching while the tool is armed drops the in-flight
+ * draft, so a half-drawn wall never lands as another kind.
+ */
+export function selectWallKind(kind: WallKind): void {
+  const lineKind = kind === 'standard' ? null : kind
+  if (getWallLineKind() === lineKind) return
+  const editor = useEditor.getState()
+  if (editor.mode === 'build' && editor.tool === 'wall') emitter.emit('tool:cancel')
+  useWallLineKindStore.setState({ lineKind })
+}
+
+/** Back to plain walls once the wall tool is left or draws another variant. */
+export function subscribeWallKindReset(): () => void {
+  return useEditor.subscribe((state) => {
+    if (
+      state.mode === 'build' &&
+      state.tool === 'wall' &&
+      state.getContinuation('wall') === 'single'
+    )
+      return
+    if (getWallLineKind() !== null) useWallLineKindStore.setState({ lineKind: null })
+  })
+}
+
+/**
+ * What an invisible-wall draft snaps to besides walls: the current level's
+ * invisible walls, as lines (`separatorWallLine`), so a new one closes onto
+ * their ends and bodies — its old corner. Nothing while walls or railings draw.
+ */
+export function invisibleWallDraftSnapLines(): WallNode[] {
+  if (getWallLineKind() !== 'invisible') return []
+  return levelSeparatorLines(useScene.getState().nodes, useViewer.getState().selection.levelId)
+}
+
+/**
+ * The thickness the wall tool's drafts draw at: an invisible wall's line, a railing's, a
+ * placed preset's (`toolDefaults.wall`), else `fallback` (a plain wall).
+ */
+export function useWallDraftThickness(fallback: number): number {
+  const lineKind = useWallLineKindStore((state) => state.lineKind)
+  const seeded = useEditor((state) => state.toolDefaults.wall?.thickness)
+  if (lineKind === 'invisible') return INVISIBLE_WALL_DRAFT_THICKNESS
+  if (lineKind === 'railing') return railingWallDefaults().thickness
+  return typeof seeded === 'number' ? seeded : fallback
+}

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

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test'
+import { WallNode } from '@pascal-app/core'
+import { isWallNudgeKey, WALL_NUDGE_IMPERIAL, wallNudgeDistance } from './wall-nudge'
+
+const outside = { frontSide: 'exterior', backSide: 'interior' } as const
+const wall = (id: string, start: [number, number], end: [number, number]) =>
+  WallNode.parse({ id: `wall_${id}`, start, end, thickness: 0.15, ...outside })
+
+describe('wallNudgeDistance', () => {
+  const moving = wall('moving', [5, 0.3], [8, 0.3])
+
+  test('an arrow across the wall moves it one inch that way', () => {
+    const down = wallNudgeDistance(moving, [0, 1], [moving], WALL_NUDGE_IMPERIAL)
+    const up = wallNudgeDistance(moving, [0, -1], [moving], WALL_NUDGE_IMPERIAL)
+    expect(down).not.toBeNull()
+    expect(up).not.toBeNull()
+    // Signed along the move axis: both land 1 in from where the wall was, opposite ways.
+    const move = (nudge: NonNullable<typeof down>) => nudge.axis[1] * nudge.distance
+    expect(move(down!)).toBeCloseTo(0.0254, 10)
+    expect(move(up!)).toBeCloseTo(-0.0254, 10)
+  })
+
+  test('an arrow along the wall does nothing', () => {
+    expect(wallNudgeDistance(moving, [1, 0], [moving], WALL_NUDGE_IMPERIAL)).toBeNull()
+    expect(wallNudgeDistance(moving, [-1, 0], [moving], WALL_NUDGE_IMPERIAL)).toBeNull()
+  })
+
+  test('stops flush with a parallel outside wall it would pass', () => {
+    const top = wall('top', [0, 0.29], [4, 0.29])
+    const nudge = wallNudgeDistance(moving, [0, -1], [moving, top], WALL_NUDGE_IMPERIAL)!
+    expect(nudge.axis[1] * nudge.distance).toBeCloseTo(-0.01, 10)
+  })
+
+  test('a turned plan still picks the arrow nearest across the wall', () => {
+    const turned = [Math.SQRT1_2, Math.SQRT1_2] as [number, number]
+    const nudge = wallNudgeDistance(moving, turned, [moving], WALL_NUDGE_IMPERIAL)!
+    expect(nudge.axis[1] * nudge.distance).toBeCloseTo(0.0254, 10)
+  })
+})
+
+test('only the four bare arrows nudge', () => {
+  expect(['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].every(isWallNudgeKey)).toBe(true)
+  expect(isWallNudgeKey('w')).toBe(false)
+})