@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/lib/continuation.ts

@@ -0,0 +1,64 @@
+export type ContinuationContext = 'wall' | 'fence' | 'point' | 'cabinet'
+export type ContinuationMode = string
+
+export const CONTINUATION_PROFILES: Record<
+  ContinuationContext,
+  {
+    options: ContinuationMode[]
+    default: ContinuationMode
+    labels: Record<string, string>
+    icons: Record<string, string>
+  }
+> = {
+  wall: {
+    options: ['room', 'single'],
+    default: 'room',
+    labels: { room: 'Room (auto-close)', single: 'Single wall' },
+    icons: { room: 'lucide:square', single: 'lucide:minus' },
+  },
+  fence: {
+    options: ['single', 'continuous', 'curved'],
+    default: 'continuous',
+    labels: {
+      continuous: 'Continuous',
+      single: 'Single fence',
+      curved: 'Curved fence',
+    },
+    icons: {
+      continuous: 'lucide:waypoints',
+      single: 'lucide:minus',
+      curved: 'lucide:spline',
+    },
+  },
+  point: {
+    options: ['once', 'repeat'],
+    default: 'once',
+    labels: { once: 'Place once', repeat: 'Place multiple' },
+    icons: { once: 'lucide:target', repeat: 'lucide:copy-plus' },
+  },
+  cabinet: {
+    options: ['single', 'continuous'],
+    default: 'single',
+    labels: { single: 'Single cabinet', continuous: 'Continuous run' },
+    icons: { single: 'lucide:minus', continuous: 'lucide:waypoints' },
+  },
+}
+
+const POINT_KINDS = new Set(['item', 'door', 'window', 'shelf', 'column'])
+
+export function nextContinuation(
+  context: ContinuationContext,
+  current: ContinuationMode,
+): ContinuationMode {
+  const profile = CONTINUATION_PROFILES[context]
+  const index = profile.options.indexOf(current)
+  if (index === -1) return profile.default
+  return profile.options[(index + 1) % profile.options.length] ?? profile.default
+}
+
+export function continuationContextOf(kind: string): ContinuationContext | null {
+  if (kind === 'wall') return 'wall'
+  if (kind === 'fence') return 'fence'
+  if (kind === 'cabinet') return 'cabinet'
+  return POINT_KINDS.has(kind) ? 'point' : null
+}

package/src/lib/direct-manipulation.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  DEFAULT_ANGLE_STEP,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  canDirectMoveNode,
+  resolveDirectManipulationNode,
+  resolveDirectRotationDragDelta,
+  resolveMoveActionNode,
+  snapDirectRotationDelta,
+} from './direct-manipulation'
+
+function registerTestDefinition(kind: string, overrides: Partial<AnyNodeDefinition>) {
+  if (nodeRegistry.has(kind)) return
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(kind) }) as never,
+    category: 'structure',
+    defaults: () => ({ type: kind }) as never,
+    capabilities: {},
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    ...overrides,
+  } as AnyNodeDefinition)
+}
+
+describe('snapDirectRotationDelta', () => {
+  test('snaps rotation deltas to the default angle increment', () => {
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * 0.49, false)).toBe(0)
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * 0.51, false)).toBeCloseTo(
+      DEFAULT_ANGLE_STEP,
+    )
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * -1.49, false)).toBeCloseTo(
+      -DEFAULT_ANGLE_STEP,
+    )
+  })
+
+  test('keeps the raw rotation delta while free-rotating', () => {
+    const rawDelta = DEFAULT_ANGLE_STEP * 0.42
+    expect(snapDirectRotationDelta(rawDelta, true)).toBe(rawDelta)
+  })
+})
+
+describe('resolveDirectRotationDragDelta', () => {
+  test('maps horizontal pointer motion to the direct rotation delta direction', () => {
+    const radiansPerPixel = DEFAULT_ANGLE_STEP / 12
+
+    expect(resolveDirectRotationDragDelta(100, 112, radiansPerPixel, false)).toBeCloseTo(
+      -DEFAULT_ANGLE_STEP,
+    )
+    expect(resolveDirectRotationDragDelta(100, 88, radiansPerPixel, false)).toBeCloseTo(
+      DEFAULT_ANGLE_STEP,
+    )
+  })
+
+  test('keeps unsnapped drag deltas while free-rotating', () => {
+    expect(resolveDirectRotationDragDelta(100, 103, 0.1, true)).toBeCloseTo(-0.3)
+  })
+})
+
+describe('canDirectMoveNode', () => {
+  // Accepts kinds with a 3D-mountable move tool (`movable` or
+  // `affordanceTools.move`); floorplan-only movers (zone) are excluded.
+  test('rejects floorplan-only move targets (no 3D tool mounts)', () => {
+    const kind = 'direct-move-floorplan-only-test'
+    registerTestDefinition(kind, { floorplanMoveTarget: {} as never })
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+  })
+
+  test('rejects MEP kinds that own move through bespoke selection affordances', () => {
+    for (const kind of [
+      'duct-segment',
+      'duct-fitting',
+      'pipe-segment',
+      'pipe-fitting',
+      'lineset',
+      'liquid-line',
+    ]) {
+      expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+    }
+  })
+
+  test('accepts kinds with a bespoke move tool', () => {
+    const kind = 'direct-move-bespoke-tool-test'
+    registerTestDefinition(kind, {
+      affordanceTools: {
+        move: async () => ({ default: () => null }),
+      } as never,
+    })
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(true)
+  })
+
+  test('accepts nodes with the generic movable capability', () => {
+    const kind = 'direct-move-movable-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: { axes: ['x', 'z'], gridSnap: true },
+      },
+    } as Partial<AnyNodeDefinition>)
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(true)
+  })
+
+  test('rejects kinds with no registered move path', () => {
+    const kind = 'direct-move-none-test'
+    registerTestDefinition(kind, {})
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+  })
+})
+
+describe('resolveDirectManipulationNode', () => {
+  test('routes proxied members to their assembly for direct transforms', () => {
+    const group = {
+      id: 'direct_manipulation_group',
+      type: 'direct-manipulation-group-test',
+    } as unknown as AnyNode
+    const member = {
+      id: 'direct_manipulation_member',
+      type: 'direct-manipulation-member-test',
+      metadata: { nodeSelectionProxyId: group.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveDirectManipulationNode(member, {
+        [group.id]: group,
+        [member.id]: member,
+      }),
+    ).toBe(group)
+  })
+
+  test('falls back to the selected node when the proxy target is missing', () => {
+    const member = {
+      id: 'direct_manipulation_orphan_member',
+      type: 'direct-manipulation-member-test',
+      metadata: { nodeSelectionProxyId: 'missing_group' },
+    } as unknown as AnyNode
+
+    expect(resolveDirectManipulationNode(member, { [member.id]: member })).toBe(member)
+  })
+
+  test('routes parent-frame children to their rotatable parent', () => {
+    const parentKind = 'direct-manipulation-parent-frame-parent-test'
+    const childKind = 'direct-manipulation-parent-frame-child-test'
+    registerTestDefinition(parentKind, {
+      capabilities: { rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] } },
+    })
+    registerTestDefinition(childKind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+            parentRotationY: () => 0,
+            localToPlan: (_parent: AnyNode, local: readonly [number, number, number]) => [
+              local[0],
+              local[1],
+              local[2],
+            ],
+            planToLocal: (_parent: AnyNode, planX: number, localY: number, planZ: number) => [
+              planX,
+              localY,
+              planZ,
+            ],
+          },
+        },
+      },
+    })
+
+    const parent = { id: 'direct_manipulation_parent', type: parentKind } as unknown as AnyNode
+    const child = {
+      id: 'direct_manipulation_child',
+      type: childKind,
+      parentId: parent.id,
+    } as unknown as AnyNode
+
+    expect(
+      resolveDirectManipulationNode(child, {
+        [parent.id]: parent,
+        [child.id]: child,
+      }),
+    ).toBe(parent)
+  })
+})
+
+describe('resolveMoveActionNode', () => {
+  test('routes a nested same-kind child move to its host', () => {
+    const kind = 'move-action-nested-kind-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+            parentRotationY: () => 0,
+            localToPlan: (_parent: AnyNode, local: readonly [number, number, number]) => [
+              local[0],
+              local[1],
+              local[2],
+            ],
+            planToLocal: (_parent: AnyNode, planX: number, localY: number, planZ: number) => [
+              planX,
+              localY,
+              planZ,
+            ],
+          },
+        },
+      },
+    })
+    const parent = { id: 'move_action_parent', type: kind } as unknown as AnyNode
+    const child = {
+      id: 'move_action_child',
+      type: kind,
+      parentId: parent.id,
+    } as unknown as AnyNode
+
+    expect(
+      resolveMoveActionNode(child, {
+        [parent.id]: parent,
+        [child.id]: child,
+      }),
+    ).toBe(parent)
+  })
+
+  test('keeps a child independently movable when its parent is a different kind', () => {
+    const parentKind = 'move-action-parent-kind-test'
+    const childKind = 'move-action-child-kind-test'
+    registerTestDefinition(parentKind, {})
+    registerTestDefinition(childKind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+            parentRotationY: () => 0,
+            localToPlan: (_parent: AnyNode, local: readonly [number, number, number]) => [
+              local[0],
+              local[1],
+              local[2],
+            ],
+            planToLocal: (_parent: AnyNode, planX: number, localY: number, planZ: number) => [
+              planX,
+              localY,
+              planZ,
+            ],
+          },
+        },
+      },
+    })
+    const parent = { id: 'move_action_run', type: parentKind } as unknown as AnyNode
+    const child = {
+      id: 'move_action_module',
+      type: childKind,
+      parentId: parent.id,
+    } as unknown as AnyNode
+
+    expect(
+      resolveMoveActionNode(child, {
+        [parent.id]: parent,
+        [child.id]: child,
+      }),
+    ).toBe(child)
+  })
+})

package/src/lib/direct-manipulation.ts

@@ -0,0 +1,118 @@
+import {
+  type AnyNode,
+  type ArcResizeHandle,
+  createSceneApi,
+  DEFAULT_ANGLE_STEP,
+  type HandleDescriptor,
+  hasRegistry3DMoveTool,
+  isMovable,
+  nodeRegistry,
+  resolveSelectionProxyId,
+  type SceneApi,
+  useScene,
+} from '@pascal-app/core'
+
+function resolveHandles(node: AnyNode): HandleDescriptor<AnyNode>[] {
+  const handles = nodeRegistry.get(node.type)?.handles
+  if (!handles) return []
+  return (
+    typeof handles === 'function' ? handles(node as never) : handles
+  ) as HandleDescriptor<AnyNode>[]
+}
+
+export function getDirectRotateHandle(node: AnyNode): ArcResizeHandle<AnyNode> | null {
+  for (const handle of resolveHandles(node)) {
+    if (handle.kind === 'arc-resize' && handle.shape === 'rotate') {
+      return handle as ArcResizeHandle<AnyNode>
+    }
+  }
+  return null
+}
+
+export function canDirectRotateNode(node: AnyNode): boolean {
+  return (
+    getDirectRotateHandle(node) !== null ||
+    nodeRegistry.get(node.type)?.capabilities?.rotatable !== undefined
+  )
+}
+
+const BESPOKE_SELECTION_MOVE_KINDS = new Set([
+  'duct-segment',
+  'duct-fitting',
+  'pipe-segment',
+  'pipe-fitting',
+  'lineset',
+  'liquid-line',
+])
+
+export function canDirectMoveNode(node: AnyNode): boolean {
+  // These MEP kinds own move through bespoke selection rigs (latch cubes,
+  // directional arrows, grid-driven previews). Sending body drags/clicks
+  // through the generic direct-move handoff conflicts with that path and can
+  // leave the editor appearing frozen while their mover waits for the wrong
+  // gesture stream.
+  if (BESPOKE_SELECTION_MOVE_KINDS.has(node.type)) return false
+  // 3D direct move (Ctrl/Meta-drag, the move-cross grip) needs a move tool that
+  // mounts in 3D — distinct from `isRegistryMovable`, which also accepts
+  // floorplan-only movers (zone) for the 2D plan.
+  if (!hasRegistry3DMoveTool(node.type)) return false
+  // Bespoke movers (`affordanceTools.move`) own their constraints and often
+  // deliberately omit `capabilities.movable` — only gate registry-movable
+  // kinds on `isMovable`, so a per-node `movable.override` (e.g. a cabinet
+  // run locked behind its selection proxy) can opt out of direct move.
+  if (nodeRegistry.get(node.type)?.affordanceTools?.move) return true
+  return isMovable(node)
+}
+
+export function resolveDirectManipulationNode(
+  node: AnyNode,
+  nodes: Readonly<Record<string, AnyNode | undefined>>,
+): AnyNode {
+  const target = nodes[resolveSelectionProxyId(node, nodes)] ?? node
+  const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
+  const parent = parentFrame?.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
+  return parent && canDirectRotateNode(parent) ? parent : target
+}
+
+export function resolveMoveActionNode(
+  node: AnyNode,
+  nodes: Readonly<Record<string, AnyNode | undefined>>,
+): AnyNode {
+  const parentFrame = nodeRegistry.get(node.type)?.capabilities?.movable?.parentFrame
+  const parent = parentFrame?.resolveParent(node, nodes as Readonly<Record<string, AnyNode>>)
+  return parent?.type === node.type ? parent : node
+}
+
+export function snapDirectRotationDelta(delta: number, free: boolean): number {
+  return free ? delta : Math.round(delta / DEFAULT_ANGLE_STEP) * DEFAULT_ANGLE_STEP
+}
+
+export function resolveDirectRotationDragDelta(
+  startX: number,
+  clientX: number,
+  radiansPerPixel: number,
+  free: boolean,
+): number {
+  return snapDirectRotationDelta((startX - clientX) * radiansPerPixel, free)
+}
+
+export function resolveDirectRotationPatch(
+  node: AnyNode,
+  delta: number,
+  sceneApi: SceneApi = createSceneApi(useScene),
+): Partial<AnyNode> | null {
+  const rotateHandle = getDirectRotateHandle(node)
+  if (rotateHandle) {
+    return rotateHandle.apply(node, delta, sceneApi) as Partial<AnyNode>
+  }
+
+  const rotation = (node as { rotation?: unknown }).rotation
+  if (typeof rotation === 'number') {
+    return { rotation: rotation - delta } as Partial<AnyNode>
+  }
+  if (Array.isArray(rotation)) {
+    const [rx = 0, ry = 0, rz = 0] = rotation as [number?, number?, number?]
+    return { rotation: [rx, ry - delta, rz] } as Partial<AnyNode>
+  }
+  return null
+}

package/src/lib/door-interaction.ts

@@ -15,7 +15,7 @@ type DoorOpenAnimationOptions = {
   persist?: boolean
 }
 
-function getDisplayedDoorValue(
+export function getDisplayedDoorValue(
   doorId: AnyNodeId,
   field: keyof DoorInteractiveState,
   nodeValue: number | undefined,

package/src/lib/editor-api.ts

@@ -1,33 +1,20 @@
-import type { AnyNode, EditorApi, FenceNode, WallNode } from '@pascal-app/core'
+import type { AnyNode, EditorApi } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
-
-type EditorState = ReturnType<typeof useEditor.getState>
-type EndpointEngager = (node: AnyNode, endpoint: 'start' | 'end', editor: EditorState) => void
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  controlPointReshapeScope,
+  endpointReshapeScope,
+  tangentReshapeScope,
+} from './interaction/scope'
 
 /**
- * Per-kind endpoint-move engagement. Kinds whose 2D endpoint drag
- * needs its own store field (wall ↔ `movingWallEndpoint`, fence ↔
- * `movingFenceEndpoint`) register their bridge here. The dispatcher
- * is a table lookup rather than an `if (type === 'wall')` chain so
- * adding a new endpoint-draggable kind is a one-line entry instead
- * of a new branch. Each entry casts the generic `AnyNode` to its
- * concrete kind — the lookup key already guarantees the type.
- */
-const endpointEngagers: Record<string, EndpointEngager> = {
-  wall: (node, endpoint, editor) =>
-    editor.setMovingWallEndpoint({ wall: node as WallNode, endpoint }),
-  fence: (node, endpoint, editor) =>
-    editor.setMovingFenceEndpoint({ fence: node as FenceNode, endpoint }),
-}
-
-/**
- * Concrete {@link EditorApi} backed by `useEditor`. Descriptors call into
- * editor state through this interface; the editor owns the actual setter
- * names so core stays decoupled.
+ * Concrete {@link EditorApi} backed by `useEditor` + the interaction scope.
+ * Descriptors call into editor state through this interface; the editor owns
+ * the actual store wiring so core stays decoupled.
  *
- * `engageMove` clears any in-progress endpoint drag or curve gesture so
- * the move tool takes over cleanly — mirrors the legacy bookkeeping that
- * lived inside `WallMoveArrowHandle.activateWallMove` / `FenceMoveArrowHandle`.
+ * `engageMove` no longer clears any in-progress endpoint drag or curve gesture:
+ * `setMovingNode` begins the `moving` scope, and the scope is single-owner, so
+ * it atomically replaces any prior reshape — there is no separate flag to reset.
  */
 export function createEditorApi(): EditorApi {
   return {
@@ -39,10 +26,6 @@ export function createEditorApi(): EditorApi {
       // cast lets registry-driven move kinds through without forcing a
       // schema-level type widening.
       editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
-      editor.setMovingWallEndpoint(null)
-      editor.setMovingFenceEndpoint(null)
-      editor.setCurvingWall(null)
-      editor.setCurvingFence(null)
     },
     engageMoveDrag(node: AnyNode) {
       const editor = useEditor.getState()
@@ -50,13 +33,18 @@ export function createEditorApi(): EditorApi {
       // it at setup and wires its commit-on-release listener.
       editor.setPlacementDragMode(true)
       editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
-      editor.setMovingWallEndpoint(null)
-      editor.setMovingFenceEndpoint(null)
-      editor.setCurvingWall(null)
-      editor.setCurvingFence(null)
     },
     engageEndpointMove(node: AnyNode, endpoint: 'start' | 'end') {
-      endpointEngagers[node.type]?.(node, endpoint, useEditor.getState())
+      // Endpoint reshape is kind-agnostic: the scope carries the node id + which
+      // endpoint, and consumers recover the node from the scene. Adding a new
+      // endpoint-draggable kind needs no entry here.
+      useInteractionScope.getState().begin(endpointReshapeScope(node.id, endpoint))
+    },
+    engageControlPointMove(node: AnyNode, index: number) {
+      useInteractionScope.getState().begin(controlPointReshapeScope(node.id, index))
+    },
+    engageTangentMove(node: AnyNode, index: number, side: 'in' | 'out') {
+      useInteractionScope.getState().begin(tangentReshapeScope(node.id, index, side))
     },
   }
 }

package/src/lib/elevation-guides.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, CeilingNode, LevelNode, SlabNode } from '@pascal-app/core'
+import useElevationGuides from '../store/use-elevation-guides'
+import {
+  clearStructuralElevationGuide,
+  collectElevationSnapTargets,
+  publishStructuralElevationGuide,
+  resolveElevationSnapMatch,
+  resolveStructuralElevationSnap,
+} from './elevation-guides'
+
+function structuralScene() {
+  const rawLevel = LevelNode.parse({ level: 0, height: 3 })
+  const slab = SlabNode.parse({
+    parentId: rawLevel.id,
+    polygon: [
+      [2, -1],
+      [4, -1],
+      [4, 1],
+      [2, 1],
+    ],
+    elevation: 0.6,
+    thickness: 0.2,
+  })
+  const ceiling = CeilingNode.parse({
+    parentId: rawLevel.id,
+    polygon: [
+      [-4, -1],
+      [-2, -1],
+      [-2, 1],
+      [-4, 1],
+    ],
+    height: 2.4,
+  })
+  const level = { ...rawLevel, children: [slab.id, ceiling.id] }
+  const nodes: Record<string, AnyNode> = {
+    [level.id]: level,
+    [slab.id]: slab,
+    [ceiling.id]: ceiling,
+  }
+  return { ceiling, level, nodes, slab }
+}
+
+describe('elevation guides', () => {
+  test('collects the level, slab faces, and ceiling plane on the source level', () => {
+    const { level, nodes, slab } = structuralScene()
+    const targets = collectElevationSnapTargets(
+      { nodeId: 'wall_moving', levelId: level.id, anchor: [0, 0] },
+      nodes,
+    )
+
+    expect(targets.map((target) => [target.label, target.elevation])).toEqual([
+      ['Level', 0],
+      ['Slab top', 0.6],
+      ['Slab underside', 0.39999999999999997],
+      ['Ceiling', 2.4],
+    ])
+
+    const withoutSelf = collectElevationSnapTargets(
+      { nodeId: slab.id, levelId: level.id, anchor: [0, 0] },
+      nodes,
+    )
+    expect(withoutSelf.some((target) => target.id.startsWith(slab.id))).toBe(false)
+  })
+
+  test('snaps inside the Y tolerance and leaves values outside it alone', () => {
+    const { level, nodes } = structuralScene()
+    const source = { nodeId: 'wall_moving', levelId: level.id, anchor: [0, 0] } as const
+
+    expect(resolveStructuralElevationSnap(source, 0.54, nodes)).toBe(0.6)
+    expect(resolveStructuralElevationSnap(source, 0.49, nodes)).toBe(0.49)
+    expect(resolveStructuralElevationSnap(source, 2.34, nodes)).toBe(2.4)
+  })
+
+  test('uses plan distance to disambiguate datums at the same elevation', () => {
+    const match = resolveElevationSnapMatch(
+      1,
+      [0, 0],
+      [
+        { id: 'far', elevation: 1, anchor: [10, 0], label: 'Far' },
+        { id: 'near', elevation: 1, anchor: [2, 0], label: 'Near' },
+      ],
+    )
+
+    expect(match?.target.id).toBe('near')
+  })
+
+  test('publishes one owner-scoped guide only while exactly aligned', () => {
+    const { level, nodes } = structuralScene()
+    const source = { nodeId: 'wall_moving', levelId: level.id, anchor: [0, 0] } as const
+    useElevationGuides.setState({ guide: null })
+
+    publishStructuralElevationGuide(source, 0.6, nodes)
+    expect(useElevationGuides.getState().guide).toMatchObject({
+      ownerId: 'wall_moving',
+      elevation: 0.6,
+      label: 'Slab top',
+      direction: [1, 0],
+    })
+
+    clearStructuralElevationGuide('someone_else')
+    expect(useElevationGuides.getState().guide).not.toBeNull()
+
+    publishStructuralElevationGuide(source, 0.7, nodes)
+    expect(useElevationGuides.getState().guide).toBeNull()
+  })
+})