@pascal-app/editor 1.0.3 → 1.0.5

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

@@ -2,20 +2,31 @@ import { beforeEach, describe, expect, mock, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
+  BuildingNode,
   CabinetModuleNode,
   type CabinetModuleNode as CabinetModuleNodeType,
   CabinetNode,
   type CabinetNode as CabinetNodeType,
-  type LevelNode,
+  type CollectionId,
+  ColumnNode,
+  configureArtifactStore,
+  getArtifactStore,
+  ItemNode,
+  LevelNode,
   MeasurementNode,
+  RoofNode,
+  RoofSegmentNode,
   SceneMaterial,
   type SceneMaterialId,
+  SlabNode,
   useScene,
   WallNode,
   WindowNode,
+  ZoneNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import {
+  bringBuildArtifacts,
   copySelectedNodesToEditorClipboard,
   getEditorClipboardSnapshot,
   pasteEditorClipboardToLevel,
@@ -98,12 +109,87 @@ function pastedCabinetRun() {
   return Object.values(useScene.getState().nodes).find(isPastedCabinetRun)
 }
 
+function copyScriptedWindow(projectId: string | null = 'project_clipboard-source') {
+  let text = ''
+  Object.defineProperty(navigator, 'clipboard', {
+    configurable: true,
+    value: {
+      readText: async () => text,
+      writeText: async (value: string) => {
+        text = value
+      },
+    },
+  })
+  const node = WindowNode.parse({
+    id: 'window_clipboard-scripted',
+    parentId: sourceLevelId,
+    source: {
+      kind: 'script',
+      script: 'a'.repeat(64),
+      artifact: 'b'.repeat(64),
+      manifest: { bounds: { min: [0, 0, 0], max: [1, 1, 1] }, triangles: 12 },
+    },
+  })
+  useScene.setState((state) => ({
+    nodes: {
+      ...state.nodes,
+      [node.id]: node,
+      [sourceLevelId]: makeLevel(sourceLevelId, [node.id]),
+    },
+  }))
+  useViewer.getState().setProjectId(projectId)
+  expect(copySelectedNodesToEditorClipboard([node.id])).toBe(true)
+  useViewer.getState().setProjectId('project_clipboard-target')
+  return node
+}
+
 describe('scene clipboard', () => {
   beforeEach(() => {
     seedCabinetRun()
     useScene.temporal.getState().clear()
   })
 
+  test('leaves derived room surfaces out of a group copy while retaining authored slabs', () => {
+    const derived = SlabNode.parse({
+      parentId: sourceLevelId,
+      boundary: 'auto',
+      autoFromWalls: true,
+      plateRole: 'base',
+      polygon: [
+        [0, 0],
+        [4, 0],
+        [4, 3],
+        [0, 3],
+      ],
+    })
+    const manual = SlabNode.parse({
+      parentId: sourceLevelId,
+      polygon: [
+        [5, 0],
+        [7, 0],
+        [7, 2],
+        [5, 2],
+      ],
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [derived.id]: derived,
+        [manual.id]: manual,
+      },
+    }))
+    expect(copySelectedNodesToEditorClipboard([runId, derived.id, manual.id])).toBe(true)
+    expect(getEditorClipboardSnapshot()?.rootIds).toEqual([runId, manual.id])
+    expect(getEditorClipboardSnapshot()?.nodes.some((node) => node.id === derived.id)).toBe(false)
+    const result = pasteEditorClipboardToLevel(targetLevelId)
+    expect(result?.pastedIds).toHaveLength(2)
+    expect(
+      Object.values(useScene.getState().nodes).filter(
+        (node) => node.type === 'slab' && node.parentId === targetLevelId,
+      ),
+    ).toHaveLength(1)
+  })
+
   test('copies a selected cabinet run as one subtree instead of independent modules', () => {
     const copied = copySelectedNodesToEditorClipboard([runId, leftModuleId, rightModuleId])
 
@@ -236,6 +322,274 @@ describe('scene clipboard', () => {
     }
   })
 
+  test('windows pasted with their wall fit under its top, sill at the floor when taller', () => {
+    const wall = WallNode.parse({
+      id: 'wall_clipboard-low',
+      parentId: sourceLevelId,
+      start: [0, 0],
+      end: [6, 0],
+      height: 2.5,
+    })
+    const fanlight = WindowNode.parse({
+      id: 'window_clipboard-fanlight',
+      parentId: wall.id,
+      wallId: wall.id,
+      position: [1, 1.8, 0],
+      height: 1.5,
+    })
+    const scripted = WindowNode.parse({
+      id: 'window_clipboard-tall-script',
+      parentId: wall.id,
+      wallId: wall.id,
+      position: [4, 2, 0],
+      height: 1,
+      source: {
+        kind: 'script',
+        script: 'a'.repeat(64),
+        artifact: 'b'.repeat(64),
+        manifest: { bounds: { min: [-0.5, 0, -0.1], max: [0.5, 3, 0.1] }, triangles: 12 },
+      },
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [wall.id]),
+        [wall.id]: { ...wall, children: [fanlight.id, scripted.id] },
+        [fanlight.id]: fanlight,
+        [scripted.id]: scripted,
+      },
+    }))
+
+    expect(copySelectedNodesToEditorClipboard([wall.id])).toBe(true)
+    const pastedWallId = pasteEditorClipboardToLevel(targetLevelId)!.pastedIds[0]!
+    const pasted = useScene.getState().nodes[pastedWallId] as WallNode
+    const [fanlightY, scriptedY] = pasted.children.map(
+      (id) => (useScene.getState().nodes[id as AnyNodeId] as WindowNode).position[1],
+    )
+    expect(fanlightY).toBeCloseTo(2.5 - 1.5 / 2)
+    expect(scriptedY).toBeCloseTo(3 / 2)
+  })
+
+  // A roof lives on the level above the walls that carry it: a paste puts it there, and walls
+  // pasted on the roof level's row go to the storey it covers.
+  function roofedRoomOn(levelId: LevelNode['id']) {
+    const corners: [number, number][] = [
+      [0, 0],
+      [8, 0],
+      [8, 6],
+      [0, 6],
+    ]
+    const walls = corners.map((start, i) =>
+      WallNode.parse({ parentId: levelId, start, end: corners[(i + 1) % 4], height: 2.5 }),
+    )
+    const segment = RoofSegmentNode.parse({ width: 8, depth: 6, wallHeight: 0 })
+    const roof = RoofNode.parse({
+      parentId: levelId,
+      position: [4, 2.5, 3],
+      children: [segment.id],
+    })
+    return { walls, roof, segment: { ...segment, parentId: roof.id } }
+  }
+
+  function seedHouse(...levels: LevelNode[]) {
+    const building = BuildingNode.parse({ children: levels.map((level) => level.id) })
+    const { walls, roof, segment } = roofedRoomOn(sourceLevelId)
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [...walls.map((wall) => wall.id), roof.id]),
+        ...Object.fromEntries(walls.map((wall) => [wall.id, wall])),
+        [roof.id]: roof,
+        [segment.id]: segment,
+        [building.id]: building,
+        ...Object.fromEntries(
+          levels.map((level) => [level.id, { ...level, parentId: building.id }]),
+        ),
+      },
+    }))
+    return { walls, roof }
+  }
+
+  test('walls pasted with the roof they carry: the roof lands on a new Roof level, in one undo step', () => {
+    const storey = LevelNode.parse({ level: 0 })
+    const { walls, roof } = seedHouse(storey)
+    const before = Object.keys(useScene.getState().nodes).length
+    expect(copySelectedNodesToEditorClipboard([...walls.map((wall) => wall.id), roof.id])).toBe(
+      true,
+    )
+    const { pastedIds } = pasteEditorClipboardToLevel(storey.id)!
+    const nodes = useScene.getState().nodes
+    const pastedRoof = pastedIds.map((id) => nodes[id]!).find((node) => node.type === 'roof')!
+    const roofLevel = nodes[pastedRoof.parentId as AnyNodeId] as LevelNode
+    expect(roofLevel).toMatchObject({ type: 'level', level: 1, metadata: { role: 'roof' } })
+    expect(roofLevel.children).toEqual([pastedRoof.id])
+    expect((nodes[storey.id] as LevelNode).children).toHaveLength(4)
+    useScene.temporal.getState().undo()
+    expect(Object.keys(useScene.getState().nodes)).toHaveLength(before)
+  })
+
+  test('walls pasted on the roof level go to the storey it covers, the selection with them', () => {
+    const storey = LevelNode.parse({ level: 0 })
+    const roofLevel = LevelNode.parse({ level: 1, metadata: { role: 'roof' } })
+    const { walls } = seedHouse(storey, roofLevel)
+    expect(copySelectedNodesToEditorClipboard([walls[0]!.id])).toBe(true)
+    const [pastedId] = pasteEditorClipboardToLevel(roofLevel.id)!.pastedIds
+    expect(useScene.getState().nodes[pastedId!]?.parentId).toBe(storey.id)
+    expect(useViewer.getState().selection.levelId).toBe(storey.id)
+  })
+
+  test('a retained roof pasted onto a roof level keeps its roof ownership and can be undone', () => {
+    const storey = LevelNode.parse({ level: 0 })
+    const roofLevel = LevelNode.parse({ level: 1, metadata: { role: 'roof' } })
+    seedHouse(storey, roofLevel)
+    const retained = ItemNode.parse({
+      parentId: sourceLevelId,
+      position: [1, 0.25, 2],
+      metadata: { role: 'roof' },
+      asset: {
+        id: 'retained',
+        name: 'Authored roof',
+        category: 'custom',
+        thumbnail: '',
+        src: '/roof.glb',
+      },
+      provenance: { refs: [{ ns: 'source', id: 'building/roof' }] },
+    })
+    useScene.getState().createNode(retained, sourceLevelId)
+    expect(copySelectedNodesToEditorClipboard([retained.id])).toBe(true)
+    const [pastedId] = pasteEditorClipboardToLevel(roofLevel.id)!.pastedIds
+    const pasted = useScene.getState().nodes[pastedId!] as typeof retained
+    expect(pasted.parentId).toBe(roofLevel.id)
+    expect(pasted.metadata.role).toBe('roof')
+    expect(pasted.asset).toEqual(retained.asset)
+    expect(pasted.provenance).toEqual(retained.provenance)
+    expect(useViewer.getState().selection.levelId).toBe(roofLevel.id)
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[pastedId!]).toBeUndefined()
+    expect(useScene.getState().nodes[retained.id]).toBeDefined()
+  })
+
+  // Measurements, cabinets and the like stayed on the roof level at its floor while the walls
+  // copied with them went down: a paste lands on one level.
+  test('a paste carrying walls lands whole on the storey a roof level covers', () => {
+    const storey = LevelNode.parse({ level: 0 })
+    const roofLevel = LevelNode.parse({ level: 1, metadata: { role: 'roof' } })
+    const { walls } = seedHouse(storey, roofLevel)
+    const measurement = MeasurementNode.parse({
+      parentId: sourceLevelId,
+      measurement: {
+        kind: 'distance',
+        points: [
+          [0, 0, 0],
+          [8, 0, 0],
+        ],
+      },
+    })
+    useScene.setState((state) => {
+      const source = state.nodes[sourceLevelId] as LevelNode
+      return {
+        nodes: {
+          ...state.nodes,
+          [measurement.id]: measurement,
+          [sourceLevelId]: { ...source, children: [...source.children, measurement.id] },
+        },
+      }
+    })
+    expect(copySelectedNodesToEditorClipboard([walls[0]!.id, measurement.id])).toBe(true)
+    const { pastedIds } = pasteEditorClipboardToLevel(roofLevel.id)!
+    const nodes = useScene.getState().nodes
+    expect(pastedIds.map((id) => nodes[id]?.parentId)).toEqual([storey.id, storey.id])
+    expect((nodes[roofLevel.id] as LevelNode).children).toEqual([])
+  })
+
+  // Pasted corner windows kept naming the originals, so the copies drew as plain windows that
+  // could not be joined while the originals stood.
+  test('a corner window pasted with both its walls joins its own copies; one side alone is plain', () => {
+    const south = WallNode.parse({
+      id: 'wall_clipboard-south',
+      parentId: sourceLevelId,
+      start: [0, 0],
+      end: [4, 0],
+    })
+    const east = WallNode.parse({
+      id: 'wall_clipboard-east',
+      parentId: sourceLevelId,
+      start: [4, 0],
+      end: [4, 3],
+    })
+    const onSouth = WindowNode.parse({
+      id: 'window_clipboard-south',
+      parentId: south.id,
+      wallId: south.id,
+      position: [3.4, 1.2, 0],
+      corner: { end: 'end', partnerId: 'window_clipboard-east', post: 'none' },
+    })
+    const onEast = WindowNode.parse({
+      id: 'window_clipboard-east',
+      parentId: east.id,
+      wallId: east.id,
+      position: [0.6, 1.2, 0],
+      corner: { end: 'start', partnerId: onSouth.id, post: 'none' },
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [south.id, east.id]),
+        [south.id]: { ...south, children: [onSouth.id] },
+        [east.id]: { ...east, children: [onEast.id] },
+        [onSouth.id]: onSouth,
+        [onEast.id]: onEast,
+      },
+    }))
+    const windowsOf = (wallIds: readonly AnyNodeId[]) =>
+      wallIds.flatMap((id) =>
+        (useScene.getState().nodes[id] as WallNode).children.map(
+          (child) => useScene.getState().nodes[child as AnyNodeId] as WindowNode,
+        ),
+      )
+
+    expect(copySelectedNodesToEditorClipboard([south.id, east.id])).toBe(true)
+    const [a, b] = windowsOf(pasteEditorClipboardToLevel(targetLevelId)!.pastedIds)
+    expect(a?.corner?.partnerId).toBe(b?.id)
+    expect(b?.corner?.partnerId).toBe(a?.id)
+
+    expect(copySelectedNodesToEditorClipboard([south.id])).toBe(true)
+    const [alone] = windowsOf(pasteEditorClipboardToLevel(targetLevelId)!.pastedIds)
+    expect(alone?.corner).toBeUndefined()
+  })
+
+  test('a paste keeps collection membership on both sides in one undo step, or drops collections the scene lacks', () => {
+    const collectionId = 'collection_clipboard-lighting' as CollectionId
+    const lamp = ItemNode.parse({
+      id: 'item_clipboard-lamp',
+      parentId: sourceLevelId,
+      asset: { id: 'lamp', name: 'Lamp', category: 'lighting', thumbnail: '', src: 'asset://lamp' },
+      collectionIds: [collectionId],
+    })
+    const lighting = { id: collectionId, name: 'Lighting', nodeIds: [lamp.id] }
+    useScene.setState((state) => ({
+      collections: { [collectionId]: lighting },
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [lamp.id]),
+        [lamp.id]: lamp,
+      },
+    }))
+    expect(copySelectedNodesToEditorClipboard([lamp.id])).toBe(true)
+
+    const pastedId = pasteEditorClipboardToLevel(targetLevelId)!.pastedIds[0]!
+    expect(useScene.getState().nodes[pastedId]).toMatchObject({ collectionIds: [collectionId] })
+    expect(useScene.getState().collections[collectionId]?.nodeIds).toEqual([lamp.id, pastedId])
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[pastedId]).toBeUndefined()
+    expect(useScene.getState().collections[collectionId]).toEqual(lighting)
+
+    useScene.setState({ collections: {} })
+    const elsewhereId = pasteEditorClipboardToLevel(targetLevelId)!.pastedIds[0]!
+    expect(useScene.getState().nodes[elsewhereId]).toMatchObject({ collectionIds: [] })
+    expect(useScene.getState().collections).toEqual({})
+  })
+
   test('round-trips nodes and custom scene materials through the browser clipboard', async () => {
     let systemClipboardText = ''
     Object.defineProperty(navigator, 'clipboard', {
@@ -322,4 +676,259 @@ describe('scene clipboard', () => {
     expect(readText).toHaveBeenCalledTimes(1)
     expect(result?.pastedIds).toHaveLength(1)
   })
+
+  test('a paste from another project brings its scripted nodes artifacts, or leaves the node out', async () => {
+    let systemClipboardText = ''
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: {
+        readText: async () => systemClipboardText,
+        writeText: async (text: string) => {
+          systemClipboardText = text
+        },
+      },
+    })
+    const scripted = (id: string, script: string, artifact: string) =>
+      WindowNode.parse({
+        id,
+        parentId: sourceLevelId,
+        position: [0, 1.2, 0],
+        source: {
+          kind: 'script',
+          script: script.repeat(64),
+          artifact: artifact.repeat(64),
+          manifest: { bounds: { min: [-0.5, 0, -0.1], max: [0.5, 1, 0.1] }, triangles: 12 },
+        },
+      })
+    const readable = scripted('window_clipboard-readable', 'a', 'c')
+    const unreadable = scripted('window_clipboard-unreadable', 'b', 'd')
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [readable.id, unreadable.id]),
+        [readable.id]: readable,
+        [unreadable.id]: unreadable,
+      },
+    }))
+    useViewer.getState().setProjectId('project_clipboard-source')
+    expect(copySelectedNodesToEditorClipboard([readable.id, unreadable.id])).toBe(true)
+
+    useViewer.getState().setProjectId('project_clipboard-target')
+    // The source project can no longer be read: neither its geometry nor its code comes.
+    const copyFrom = mock(async (_projectId: string, _sha256s: string[]) => [
+      unreadable.source!.script,
+      unreadable.source!.artifact,
+    ])
+    const previousStore = getArtifactStore()
+    configureArtifactStore({ ...previousStore, copyFrom })
+    try {
+      const result = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(copyFrom).toHaveBeenCalledTimes(1)
+      expect(copyFrom.mock.calls[0]![0]).toBe('project_clipboard-source')
+      expect(new Set(copyFrom.mock.calls[0]![1])).toEqual(
+        new Set([
+          readable.source!.script,
+          readable.source!.artifact,
+          unreadable.source!.script,
+          unreadable.source!.artifact,
+        ]),
+      )
+      expect(result?.refusedIds).toEqual([unreadable.id])
+      expect(result?.refusal).toBe('no-access')
+      expect(result?.pastedIds).toHaveLength(1)
+      const pasted = useScene.getState().nodes[result!.pastedIds[0]!]
+      expect(pasted?.type === 'window' && pasted.source?.artifact).toBe(readable.source!.artifact)
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test("a room copied to another project brings its floor script's artifacts", async () => {
+    let systemClipboardText = ''
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: {
+        readText: async () => systemClipboardText,
+        writeText: async (text: string) => {
+          systemClipboardText = text
+        },
+      },
+    })
+    const room = ZoneNode.parse({
+      id: 'zone_clipboard-floor-script',
+      parentId: sourceLevelId,
+      name: 'Hall',
+      polygon: [
+        [0, 0],
+        [3, 0],
+        [3, 3],
+        [0, 3],
+      ],
+      floor: {
+        script: {
+          kind: 'script',
+          script: 'e'.repeat(64),
+          artifact: 'f'.repeat(64),
+          inputs: 'key',
+          manifest: { bounds: { min: [0, 0, 0], max: [3, 0.01, 3] }, triangles: 2 },
+        },
+      },
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [room.id]),
+        [room.id]: room,
+      },
+    }))
+    useViewer.getState().setProjectId('project_clipboard-source')
+    expect(copySelectedNodesToEditorClipboard([room.id])).toBe(true)
+    useViewer.getState().setProjectId('project_clipboard-target')
+    const copyFrom = mock(async (_projectId: string, _sha256s: string[]) => [] as string[])
+    const previousStore = getArtifactStore()
+    configureArtifactStore({ ...previousStore, copyFrom })
+    try {
+      await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(new Set(copyFrom.mock.calls[0]![1])).toEqual(new Set(['e'.repeat(64), 'f'.repeat(64)]))
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test('navigation during artifact copy does not paste into the next project', async () => {
+    copyScriptedWindow()
+    const previousStore = getArtifactStore()
+    const started = Promise.withResolvers<void>()
+    const copied = Promise.withResolvers<string[]>()
+    configureArtifactStore({
+      ...previousStore,
+      copyFrom: async () => {
+        started.resolve()
+        return copied.promise
+      },
+    })
+    try {
+      const pending = pasteSystemEditorClipboardToLevel(targetLevelId)
+      await started.promise
+      useViewer.getState().setProjectId('project_clipboard-next')
+      copied.resolve([])
+      expect(await pending).toBeNull()
+      expect((useScene.getState().nodes[targetLevelId] as LevelNode).children).toEqual([])
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test('a local paste refuses missing artifacts and keeps objects whose artifacts are available', async () => {
+    const node = copyScriptedWindow()
+    const previousStore = getArtifactStore()
+    const present = new Set<string>()
+    configureArtifactStore({
+      ...previousStore,
+      copyFrom: undefined,
+      url: (sha) => (present.has(sha) ? `artifact://${sha}` : null),
+    })
+    try {
+      const missing = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(missing?.refusedIds).toEqual([node.id])
+      expect(missing?.pastedIds).toEqual([])
+      present.add(node.source!.script)
+      present.add(node.source!.artifact)
+      const available = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(available?.refusedIds).toEqual([])
+      expect(available?.pastedIds).toHaveLength(1)
+      useScene.temporal.getState().undo()
+      expect(useScene.getState().nodes[available!.pastedIds[0]!]).toBeUndefined()
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test('hosted paste requires artifact origin but does not copy again within the same project', async () => {
+    const node = copyScriptedWindow(null)
+    const previousStore = getArtifactStore()
+    const copyFrom = mock(async () => [])
+    configureArtifactStore({ ...previousStore, copyFrom })
+    try {
+      const missingOrigin = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(missingOrigin?.refusedIds).toEqual([node.id])
+      expect(missingOrigin?.pastedIds).toEqual([])
+      copyScriptedWindow('project_clipboard-target')
+      const sameProject = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(sameProject?.pastedIds).toHaveLength(1)
+      expect(copyFrom).not.toHaveBeenCalled()
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test('build files verify artifacts even when their origin is absent or names the current project', async () => {
+    const node = copyScriptedWindow()
+    const previousStore = getArtifactStore()
+    const copyFrom = mock(async (_projectId: string, _hashes: string[]) => [node.source!.script])
+    configureArtifactStore({ ...previousStore, copyFrom })
+    try {
+      for (const projectId of [undefined, 'project_clipboard-target', 'project_unreadable']) {
+        const result = await bringBuildArtifacts({
+          projectId,
+          nodes: {
+            [sourceLevelId]: makeLevel(sourceLevelId, [node.id]),
+            [node.id]: node,
+          },
+          rootNodeIds: [sourceLevelId],
+        })
+        expect(copyFrom.mock.calls.at(-1)?.[0]).toBe(projectId ?? 'project_clipboard-target')
+        expect(result.refusedIds).toEqual([node.id])
+        expect(result.build.nodes[node.id]).toBeUndefined()
+        expect((result.build.nodes[sourceLevelId] as LevelNode).children).toEqual([])
+      }
+      configureArtifactStore({ ...previousStore, copyFrom: async () => [] })
+      const available = await bringBuildArtifacts({
+        nodes: { [sourceLevelId]: makeLevel(sourceLevelId, [node.id]), [node.id]: node },
+        rootNodeIds: [sourceLevelId],
+      })
+      expect(available.refusedIds).toEqual([])
+      expect(available.build.nodes[node.id]).toEqual(node)
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
+
+  test('refusing a scripted node terminates even when another clipboard root has a cyclic parent', async () => {
+    const scripted = copyScriptedWindow()
+    const cyclic = ColumnNode.parse({
+      id: 'column_clipboard-cycle',
+      parentId: 'column_clipboard-cycle',
+    })
+    const text = JSON.stringify({
+      kind: 'pascal.scene-nodes',
+      version: 1,
+      payload: {
+        ...getEditorClipboardSnapshot(),
+        nodes: [scripted, cyclic],
+        rootIds: [scripted.id, cyclic.id],
+      },
+    })
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: { readText: async () => text },
+    })
+    const previousStore = getArtifactStore()
+    configureArtifactStore({ ...previousStore, copyFrom: async () => [scripted.source!.script] })
+    try {
+      const result = await pasteSystemEditorClipboardToLevel(targetLevelId)
+      expect(result?.refusedIds).toEqual([scripted.id])
+      expect(result?.pastedIds).toHaveLength(1)
+      expect(useScene.getState().nodes[result!.pastedIds[0]!]!.parentId).toBe(targetLevelId)
+    } finally {
+      configureArtifactStore(previousStore)
+      useViewer.getState().setProjectId(null)
+    }
+  })
 })