@pascal-app/editor 0.9.2 → 1.0.0-beta.2

package/src/lib/history.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BuildingNode,
+  clearSceneHistory,
+  LevelNode,
+  useScene,
+} from '@pascal-app/core'
+import { installHistoryCommandDelegate, runRedo, runUndo } from './history'
+
+type RafFn = (cb: (time: number) => void) => number
+;(globalThis as unknown as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= (cb) => {
+  cb(0)
+  return 0
+}
+;(globalThis as unknown as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??=
+  () => {}
+
+const BUILDING_ID = 'building_history_controller' as AnyNodeId
+const LEVEL_ID = 'level_history_controller' as AnyNodeId
+let disposeController = () => {}
+
+function levelNumber(): number {
+  return (useScene.getState().nodes[LEVEL_ID] as { level: number }).level
+}
+
+describe('editor history controller', () => {
+  beforeEach(() => {
+    disposeController()
+    disposeController = () => {}
+    const level = LevelNode.parse({
+      id: LEVEL_ID,
+      parentId: BUILDING_ID,
+      children: [],
+      level: 0,
+    })
+    const building = BuildingNode.parse({
+      id: BUILDING_ID,
+      parentId: null,
+      children: [LEVEL_ID],
+    })
+    useScene.setState({
+      nodes: { [BUILDING_ID]: building, [LEVEL_ID]: level },
+      rootNodeIds: [BUILDING_ID],
+      dirtyNodes: new Set<AnyNodeId>(),
+      collections: {},
+      materials: {},
+      readOnly: false,
+    } as never)
+    clearSceneHistory()
+    useScene.getState().updateNode(LEVEL_ID, { level: 1 } as Partial<AnyNode>)
+  })
+
+  afterEach(() => {
+    disposeController()
+    disposeController = () => {}
+  })
+
+  test('delegates undo and redo while a host delegate is installed', () => {
+    const undo = mock(() => {})
+    const redo = mock(() => {})
+    disposeController = installHistoryCommandDelegate({ undo, redo })
+
+    runUndo()
+    runRedo()
+
+    expect(undo).toHaveBeenCalledTimes(1)
+    expect(redo).toHaveBeenCalledTimes(1)
+    expect(levelNumber()).toBe(1)
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+  })
+
+  test('falls back to standalone Zundo undo and redo when no controller is installed', () => {
+    runUndo()
+    expect(levelNumber()).toBe(0)
+    expect(useScene.temporal.getState().futureStates).toHaveLength(1)
+
+    runRedo()
+    expect(levelNumber()).toBe(1)
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+  })
+
+  test('an older cleanup cannot uninstall a newer controller', () => {
+    const firstUndo = mock(() => {})
+    const stopFirst = installHistoryCommandDelegate({ undo: firstUndo, redo: () => {} })
+    const secondUndo = mock(() => {})
+    disposeController = installHistoryCommandDelegate({ undo: secondUndo, redo: () => {} })
+
+    stopFirst()
+    runUndo()
+
+    expect(firstUndo).toHaveBeenCalledTimes(0)
+    expect(secondUndo).toHaveBeenCalledTimes(1)
+  })
+})

package/src/lib/history.ts

@@ -1,5 +1,19 @@
 import { useLiveNodeOverrides, useLiveTransforms, useScene } from '@pascal-app/core'
 
+export type HistoryCommandDelegate = {
+  undo: () => void
+  redo: () => void
+}
+
+let historyCommandDelegate: HistoryCommandDelegate | null = null
+
+export function installHistoryCommandDelegate(delegate: HistoryCommandDelegate): () => void {
+  historyCommandDelegate = delegate
+  return () => {
+    if (historyCommandDelegate === delegate) historyCommandDelegate = null
+  }
+}
+
 function refreshSceneAfterHistoryJump() {
   useLiveNodeOverrides.getState().clearAll()
   useLiveTransforms.getState().clearAll()
@@ -11,11 +25,19 @@ function refreshSceneAfterHistoryJump() {
 }
 
 export function runUndo() {
+  if (historyCommandDelegate) {
+    historyCommandDelegate.undo()
+    return
+  }
   useScene.temporal.getState().undo()
   refreshSceneAfterHistoryJump()
 }
 
 export function runRedo() {
+  if (historyCommandDelegate) {
+    historyCommandDelegate.redo()
+    return
+  }
   useScene.temporal.getState().redo()
   refreshSceneAfterHistoryJump()
 }

package/src/lib/interaction/overlay-policy.test.ts

@@ -17,9 +17,10 @@ const ACTIVE_SCOPES: ActiveInteractionScope[] = [
   { kind: 'moving', node: mockNode('i1', 'item'), nodeId: 'i1', nodeType: 'item', view: '2d' },
   { kind: 'handle-drag', nodeId: 'w1', handle: 'height' },
   { kind: 'drafting', tool: 'wall' },
-  { kind: 'reshaping', nodeId: 's1', reshape: 'hole', holeIndex: 0 },
+  { kind: 'reshaping', nodeId: 's1', reshape: 'hole', driver: 'tool', holeIndex: 0 },
   { kind: 'box-select' },
   { kind: 'painting' },
+  { kind: 'sculpting' },
 ]
 
 describe('resolveOverlayPolicy', () => {

package/src/lib/interaction/scope.ts

@@ -13,6 +13,7 @@
 import type { AnyNode } from '@pascal-app/core'
 
 export type InteractionView = '2d' | '3d'
+export type ReshapeDriver = 'tool' | 'floorplan'
 
 // Endpoint/curve/hole/boundary edits are all "reshape the selected node" — one
 // node, one in-flight reshape. Grouping them as sub-states of `reshaping`
@@ -47,6 +48,8 @@ export type InteractionScope =
       kind: 'reshaping'
       nodeId: string
       reshape: ReshapeKind
+      // Floorplan affordances own their commit and must not mount a second 3D reshape tool.
+      driver: ReshapeDriver
       holeIndex?: number
       endpoint?: 'start' | 'end'
       index?: number
@@ -56,6 +59,13 @@ export type InteractionScope =
   | { kind: 'box-select' }
   // Material paint application.
   | { kind: 'painting' }
+  // Terrain sculpting. Held for the whole time the sculpt tool is armed, not
+  // just while the pointer is down — the same lifetime as `painting`, and for
+  // the same reason: an *active* scope is what makes every other object's
+  // handles, the floating action menu, and the zone labels step back
+  // (`resolveOverlayPolicy`). A brush that only claimed the scope between
+  // pointer-down and -up would flicker all of that back on between dabs.
+  | { kind: 'sculpting' }
 
 export type InteractionKind = InteractionScope['kind']
 
@@ -126,12 +136,14 @@ export function editingHoleInfo(
 export function holeEditScope(target: {
   nodeId: string
   holeIndex: number
+  driver?: ReshapeDriver
 }): ActiveInteractionScope {
   return {
     kind: 'reshaping',
     nodeId: target.nodeId,
     reshape: 'hole',
     holeIndex: target.holeIndex,
+    driver: target.driver ?? 'tool',
   }
 }
 
@@ -142,6 +154,14 @@ export function isCurveReshape(scope: InteractionScope): boolean {
   return scope.kind === 'reshaping' && scope.reshape === 'curve'
 }
 
+export function isToolDrivenReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.driver === 'tool'
+}
+
+export function isFloorplanDrivenReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.driver === 'floorplan'
+}
+
 // The legacy `movingWallEndpoint` / `movingFenceEndpoint` flags minus the node
 // itself (consumers fetch the node from the scene by `nodeId`; it is stable for
 // the duration of the drag).
@@ -181,31 +201,43 @@ export function reshapingNodeId(scope: InteractionScope): string | null {
 }
 
 // Builders so producers don't re-spell the discriminator at every call site.
-export function curveReshapeScope(nodeId: string): ActiveInteractionScope {
-  return { kind: 'reshaping', nodeId, reshape: 'curve' }
+export function curveReshapeScope(
+  nodeId: string,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'curve', driver }
 }
 
 export function endpointReshapeScope(
   nodeId: string,
   endpoint: 'start' | 'end',
+  driver: ReshapeDriver = 'tool',
 ): ActiveInteractionScope {
-  return { kind: 'reshaping', nodeId, reshape: 'endpoint', endpoint }
+  return { kind: 'reshaping', nodeId, reshape: 'endpoint', endpoint, driver }
 }
 
-export function controlPointReshapeScope(nodeId: string, index: number): ActiveInteractionScope {
-  return { kind: 'reshaping', nodeId, reshape: 'control-point', index }
+export function controlPointReshapeScope(
+  nodeId: string,
+  index: number,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'control-point', index, driver }
 }
 
 export function tangentReshapeScope(
   nodeId: string,
   index: number,
   side: 'in' | 'out',
+  driver: ReshapeDriver = 'tool',
 ): ActiveInteractionScope {
-  return { kind: 'reshaping', nodeId, reshape: 'tangent', index, side }
+  return { kind: 'reshaping', nodeId, reshape: 'tangent', index, side, driver }
 }
 
 // Dragging a polygon vertex/edge (slab / ceiling boundary). Drives the snapping
 // HUD (no-angle 'polygon' set) and keeps the idle select hints off-screen.
-export function boundaryReshapeScope(nodeId: string): ActiveInteractionScope {
-  return { kind: 'reshaping', nodeId, reshape: 'boundary' }
+export function boundaryReshapeScope(
+  nodeId: string,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'boundary', driver }
 }

package/src/lib/level-duplication.test.ts

@@ -11,7 +11,7 @@ import { buildLevelDuplicateCreateOps } from './level-duplication'
 
 describe('buildLevelDuplicateCreateOps', () => {
   test('parents a duplicated bootstrap level back to its building', () => {
-    const level = LevelNode.parse({ level: 0, children: [] })
+    const level = LevelNode.parse({ level: 0, height: 3.25, children: [] })
     const building = BuildingNode.parse({ children: [level.id] })
     const wall = WallNode.parse({
       parentId: level.id,
@@ -36,6 +36,7 @@ describe('buildLevelDuplicateCreateOps', () => {
 
     expect(sourceLevel.parentId).toBeNull()
     expect(levelCreateOp?.parentId).toBe(building.id)
+    expect(levelCreateOp?.node.type === 'level' ? levelCreateOp.node.height : undefined).toBe(3.25)
   })
 
   test('does not copy spawn points from the source level', () => {

package/src/lib/measurements.test.ts

@@ -72,6 +72,11 @@ describe('linear measurements', () => {
     expect(formatLinearMeasurement(3.456, 'metric')).toBe('3.46m')
   })
 
+  test('formats metric measurements in whole millimeters', () => {
+    expect(formatLinearMeasurement(3.456, 'metric', 'millimeters')).toBe('3456mm')
+    expect(formatLinearMeasurement(-0.1524, 'metric', 'millimeters')).toBe('-152mm')
+  })
+
   test('formats imperial measurements as feet and inches', () => {
     expect(formatLinearMeasurement(3.048, 'imperial')).toBe(`10'0"`)
     expect(formatLinearMeasurement(3.2004, 'imperial')).toBe(`10'6"`)

package/src/lib/measurements.ts

@@ -1,6 +1,7 @@
 import type { MeasurementPoint } from '@pascal-app/core'
 
 export type LinearUnit = 'metric' | 'imperial'
+export type MetricNotation = 'meters' | 'millimeters'
 
 export const MEASUREMENT_ACTIVE_COLOR = '#6366f1'
 export const MEASUREMENT_DANGLING_COLOR = '#dc2626'
@@ -173,7 +174,11 @@ export function formatVolumeLabel(
   return `${cubicMetersToVolumeUnit(cubicMeters, unit).toFixed(fractionDigits)}${getVolumeUnitLabel(unit)}`
 }
 
-export function formatLinearMeasurement(meters: number, unit: LinearUnit): string {
+export function formatLinearMeasurement(
+  meters: number,
+  unit: LinearUnit,
+  metricNotation: MetricNotation = 'meters',
+): string {
   if (!Number.isFinite(meters)) return '--'
 
   const absoluteMeters = Math.abs(meters)
@@ -192,6 +197,12 @@ export function formatLinearMeasurement(meters: number, unit: LinearUnit): strin
     return `${sign}${wholeFeet}'${inches}"`
   }
 
+  if (metricNotation === 'millimeters') {
+    const roundedMillimeters = Math.round(absoluteMeters * 1000)
+    const sign = meters < 0 && roundedMillimeters !== 0 ? '-' : ''
+    return `${sign}${roundedMillimeters}mm`
+  }
+
   const roundedMeters = Number.parseFloat(absoluteMeters.toFixed(2))
   const sign = meters < 0 && roundedMeters !== 0 ? '-' : ''
 

package/src/lib/quick-action-feedback.ts

@@ -0,0 +1,33 @@
+const activeAnimations = new WeakMap<HTMLElement, Animation>()
+
+export function playBlockedQuickActionFeedback(button: HTMLButtonElement, reducedMotion: boolean) {
+  const content = button.querySelector<HTMLElement>('[data-quick-action-feedback]')
+  if (!content) return
+
+  activeAnimations.get(content)?.cancel()
+  content.style.color = 'var(--destructive)'
+
+  const keyframes: Keyframe[] = reducedMotion
+    ? [{ opacity: 1 }, { opacity: 1 }]
+    : [
+        { transform: 'translateX(0)' },
+        { transform: 'translateX(-2.5px)', offset: 0.18 },
+        { transform: 'translateX(2px)', offset: 0.38 },
+        { transform: 'translateX(-1.5px)', offset: 0.58 },
+        { transform: 'translateX(1px)', offset: 0.76 },
+        { transform: 'translateX(0)' },
+      ]
+  const animation = content.animate(keyframes, {
+    duration: reducedMotion ? 240 : 320,
+    easing: 'cubic-bezier(0.22, 1, 0.36, 1)',
+  })
+
+  activeAnimations.set(content, animation)
+  void animation.finished
+    .catch(() => undefined)
+    .finally(() => {
+      if (activeAnimations.get(content) !== animation) return
+      activeAnimations.delete(content)
+      content.style.removeProperty('color')
+    })
+}

package/src/lib/quick-action-nodes.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import { collectQuickActionNodeScope } from './quick-action-nodes'
+
+function fixtureNode({
+  id,
+  parentId,
+  children = [],
+  type = 'item',
+}: {
+  id: string
+  parentId?: string
+  children?: string[]
+  type?: string
+}) {
+  return {
+    id,
+    type,
+    parentId,
+    children,
+  } as unknown as AnyNode
+}
+
+describe('collectQuickActionNodeScope', () => {
+  test('includes nested children of a selected node sibling', () => {
+    const run = fixtureNode({
+      id: 'run',
+      children: ['left-base', 'selected-base'],
+    })
+    const leftBase = fixtureNode({
+      id: 'left-base',
+      parentId: run.id,
+      children: ['expanded-wall'],
+    })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: run.id })
+    const expandedWall = fixtureNode({ id: 'expanded-wall', parentId: leftBase.id })
+    const nodes = Object.fromEntries(
+      [run, leftBase, selectedBase, expandedWall].map((node) => [node.id, node]),
+    ) as Record<AnyNodeId, AnyNode>
+
+    const collected = collectQuickActionNodeScope(nodes, selectedBase.id)
+
+    expect(collected?.[expandedWall.id as AnyNodeId]).toBe(expandedWall)
+  })
+
+  test('includes other run subtrees when the provider declares level scope', () => {
+    const level = fixtureNode({
+      id: 'level',
+      type: 'level',
+      children: ['selected-run', 'other-run'],
+    })
+    const selectedRun = fixtureNode({
+      id: 'selected-run',
+      parentId: level.id,
+      children: ['selected-base'],
+    })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: selectedRun.id })
+    const otherRun = fixtureNode({
+      id: 'other-run',
+      parentId: level.id,
+      children: ['other-base'],
+    })
+    const otherBase = fixtureNode({
+      id: 'other-base',
+      parentId: otherRun.id,
+      children: ['expanded-wall'],
+    })
+    const expandedWall = fixtureNode({ id: 'expanded-wall', parentId: otherBase.id })
+    const nodes = Object.fromEntries(
+      [level, selectedRun, selectedBase, otherRun, otherBase, expandedWall].map((node) => [
+        node.id,
+        node,
+      ]),
+    ) as Record<AnyNodeId, AnyNode>
+
+    expect(
+      collectQuickActionNodeScope(nodes, selectedBase.id)?.[expandedWall.id as AnyNodeId],
+    ).toBeUndefined()
+    expect(
+      collectQuickActionNodeScope(nodes, selectedBase.id, 'level')?.[expandedWall.id as AnyNodeId],
+    ).toBe(expandedWall)
+  })
+
+  test('fails closed when a level-scoped provider has no level ancestor', () => {
+    const run = fixtureNode({ id: 'run', children: ['selected-base'] })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: run.id })
+    const nodes = Object.fromEntries([run, selectedBase].map((node) => [node.id, node])) as Record<
+      AnyNodeId,
+      AnyNode
+    >
+
+    expect(collectQuickActionNodeScope(nodes, selectedBase.id, 'level')).toBeNull()
+  })
+})

package/src/lib/quick-action-nodes.ts

@@ -0,0 +1,47 @@
+import type { AnyNode, AnyNodeId, NodeQuickActionNodeScope } from '@pascal-app/core'
+
+export function collectQuickActionNodeScope(
+  nodes: Record<AnyNodeId, AnyNode>,
+  selectedId: string,
+  scope: NodeQuickActionNodeScope = 'family',
+): Record<AnyNodeId, AnyNode> | null {
+  const selected = nodes[selectedId as AnyNodeId]
+  if (!selected) return null
+
+  const collected: Record<AnyNodeId, AnyNode> = {}
+  const addSubtree = (rootId: string | null | undefined) => {
+    if (!rootId) return
+    const pending = [rootId]
+
+    while (pending.length > 0) {
+      const id = pending.pop()
+      if (!id || collected[id as AnyNodeId]) continue
+      const node = nodes[id as AnyNodeId]
+      if (!node) continue
+
+      collected[node.id as AnyNodeId] = node
+      for (const childId of (node as { children?: readonly string[] }).children ?? []) {
+        pending.push(childId)
+      }
+    }
+  }
+
+  if (scope === 'level') {
+    const visited = new Set<AnyNodeId>()
+    let current: AnyNode | undefined = selected
+    while (current && !visited.has(current.id as AnyNodeId)) {
+      visited.add(current.id as AnyNodeId)
+      if (current.type === 'level') {
+        addSubtree(current.id)
+        return collected
+      }
+      current = current.parentId ? nodes[current.parentId as AnyNodeId] : undefined
+    }
+    return null
+  }
+
+  addSubtree(selected.id)
+  addSubtree(selected.parentId)
+
+  return collected
+}

package/src/lib/scene-clipboard.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
@@ -8,14 +8,18 @@ import {
   type CabinetNode as CabinetNodeType,
   type LevelNode,
   MeasurementNode,
+  SceneMaterial,
+  type SceneMaterialId,
   useScene,
   WallNode,
+  WindowNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import {
   copySelectedNodesToEditorClipboard,
   getEditorClipboardSnapshot,
   pasteEditorClipboardToLevel,
+  pasteSystemEditorClipboardToLevel,
 } from './scene-clipboard'
 
 const sourceLevelId = 'level_clipboard-source' as LevelNode['id']
@@ -77,6 +81,7 @@ function seedCabinetRun() {
       [leftModule.id]: leftModule as AnyNode,
       [rightModule.id]: rightModule as AnyNode,
     },
+    materials: {},
     rootNodeIds: [sourceLevel.id, targetLevel.id],
   } as never)
   useViewer.getState().setSelection({
@@ -193,4 +198,128 @@ describe('scene clipboard', () => {
     expect(Array.isArray(anchor)).toBe(false)
     if (!Array.isArray(anchor)) expect(anchor.reference.nodeId).toBe(pastedWall.id)
   })
+
+  test('detaches a standalone copied opening so its move tool can rehost it', () => {
+    const wall = WallNode.parse({
+      id: 'wall_clipboard-window-host',
+      parentId: sourceLevelId,
+      start: [0, 0],
+      end: [3, 0],
+    })
+    const window = WindowNode.parse({
+      id: 'window_clipboard-standalone',
+      parentId: wall.id,
+      wallId: wall.id,
+      position: [1.5, 1.2, 0],
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [wall.id]),
+        [wall.id]: { ...wall, children: [window.id] },
+        [window.id]: window,
+      },
+    }))
+
+    expect(copySelectedNodesToEditorClipboard([window.id])).toBe(true)
+    const result = pasteEditorClipboardToLevel(targetLevelId)
+    expect(result?.pastedIds).toHaveLength(1)
+
+    const pastedWindow = result?.pastedIds[0]
+      ? useScene.getState().nodes[result.pastedIds[0]]
+      : undefined
+    expect(pastedWindow?.type).toBe('window')
+    if (pastedWindow?.type === 'window') {
+      expect(pastedWindow.parentId).toBe(targetLevelId)
+      expect(pastedWindow.wallId).toBeUndefined()
+      expect(pastedWindow.roofSegmentId).toBeUndefined()
+    }
+  })
+
+  test('round-trips nodes and custom scene materials through the browser clipboard', async () => {
+    let systemClipboardText = ''
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: {
+        readText: async () => systemClipboardText,
+        writeText: async (text: string) => {
+          systemClipboardText = text
+        },
+      },
+    })
+
+    const materialId = 'mat_clipboard-blue' as SceneMaterialId
+    const material = SceneMaterial.parse({
+      id: materialId,
+      name: 'Clipboard blue',
+      material: { properties: { color: '#2266dd' } },
+    })
+    const wall = WallNode.parse({
+      id: 'wall_clipboard-material',
+      parentId: sourceLevelId,
+      start: [0, 0],
+      end: [3, 0],
+      slots: { exterior: `scene:${materialId}` },
+    })
+    useScene.setState((state) => ({
+      materials: { [materialId]: material },
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [wall.id]),
+        [wall.id]: wall,
+      },
+    }))
+
+    expect(copySelectedNodesToEditorClipboard([wall.id])).toBe(true)
+    expect(systemClipboardText).toContain('pascal.scene-nodes')
+
+    useScene.setState({
+      materials: {},
+      nodes: {
+        [targetLevelId]: makeLevel(targetLevelId),
+      },
+      rootNodeIds: [targetLevelId],
+    } as never)
+    useViewer.getState().setSelection({ levelId: targetLevelId, selectedIds: [] })
+
+    const result = await pasteSystemEditorClipboardToLevel()
+    expect(result?.pastedIds).toHaveLength(1)
+    expect(result?.createdMaterialIds).toEqual([materialId])
+    expect(useScene.getState().materials[materialId]).toEqual(material)
+
+    const pastedWall = Object.values(useScene.getState().nodes).find((node) => node.type === 'wall')
+    expect(pastedWall?.type).toBe('wall')
+    if (pastedWall?.type === 'wall') {
+      expect(pastedWall.slots?.exterior).toBe(`scene:${materialId}`)
+    }
+  })
+
+  test('waits for an in-flight copy before reading the browser clipboard', async () => {
+    let systemClipboardText = 'older clipboard contents'
+    let finishWrite!: () => void
+    const readText = mock(async () => systemClipboardText)
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: {
+        readText,
+        writeText: (text: string) =>
+          new Promise<void>((resolve) => {
+            finishWrite = () => {
+              systemClipboardText = text
+              resolve()
+            }
+          }),
+      },
+    })
+
+    expect(copySelectedNodesToEditorClipboard([runId])).toBe(true)
+    const paste = pasteSystemEditorClipboardToLevel(targetLevelId)
+    await Promise.resolve()
+    expect(readText).not.toHaveBeenCalled()
+
+    finishWrite()
+    const result = await paste
+    expect(readText).toHaveBeenCalledTimes(1)
+    expect(result?.pastedIds).toHaveLength(1)
+  })
 })