@pascal-app/editor 1.0.4 → 1.0.6

package/src/lib/print-feature-thickness.ts

@@ -1,4 +1,9 @@
-import { type AnyNode, getWallThickness } from '@pascal-app/core'
+import {
+  type AnyNode,
+  getRoofGlazing,
+  getWallThickness,
+  isGlazedRoofSegment,
+} from '@pascal-app/core'
 import {
   mergePrintExportDiagnostics,
   type PrintExportDiagnostic,
@@ -30,6 +35,10 @@ function semanticThicknessMeters(node: AnyNode): number | null {
     case 'slab':
       return node.thickness
     case 'roof-segment': {
+      if (isGlazedRoofSegment(node)) {
+        const glazing = getRoofGlazing(node)
+        return Math.min(glazing.frameWidth, glazing.frameDepth, glazing.glassThickness)
+      }
       const structuralThicknesses = [node.wallThickness, node.deckThickness + node.shingleThickness]
       if (node.roofType === 'dutch') structuralThicknesses.push(node.dutchTopRakeThickness)
       return Math.min(...structuralThicknesses)

package/src/lib/print-roof-solids.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 import { DoorNode, RoofSegmentNode, type RoofType } from '@pascal-app/core'
+import { buildPrintableRoofSegmentSolids } from '@pascal-app/editor'
 import * as THREE from 'three'
-import { buildPrintableRoofSegmentSolids } from './print-roof-solids'
 
 const ROOF_TYPES: RoofType[] = [
   'gable',
@@ -68,6 +68,21 @@ describe('buildPrintableRoofSegmentSolids', () => {
     }
   })
 
+  test("a gable's print shell reaches its gable overhang at the ends, the eaves along the sides", () => {
+    const extent = (node: RoofSegmentNode) => {
+      const mesh = onlyMesh(buildPrintableRoofSegmentSolids(node).object!)
+      mesh.geometry.computeBoundingBox()
+      const box = mesh.geometry.boundingBox!.clone()
+      mesh.geometry.dispose()
+      return box
+    }
+    const plain = extent(fixture('gable'))
+    const raked = extent(fixture('gable', { gableOverhang: 0.6 }))
+    expect(raked.max.x).toBeCloseTo(4 / 2 + 0.15 / 2 + 0.6, 6)
+    expect(raked.min.x).toBeCloseTo(-(4 / 2 + 0.15 / 2 + 0.6), 6)
+    expect(raked.max.z).toBeCloseTo(plain.max.z, 6)
+  })
+
   test('preserves segment provenance and local transform', () => {
     const node = fixture('gable', { position: [1, 2, 3], rotation: Math.PI / 3 })
     const result = buildPrintableRoofSegmentSolids(node)
@@ -131,3 +146,26 @@ describe('buildPrintableRoofSegmentSolids', () => {
     )
   })
 })
+
+for (const roofType of ['gable', 'shed', 'barrel'] as const)
+  test(`glazed ${roofType} prints pane and frame solids without an opaque roof shell`, () => {
+    const result = buildPrintableRoofSegmentSolids(
+      fixture(roofType, { roofSystem: 'glazed', wallThickness: 0 }),
+    )
+    expect(result.status).toBe('ready')
+    if (result.status !== 'ready') return
+    try {
+      expect(result.object.children.some((child) => child.name === 'print-glazing-frame')).toBe(
+        true,
+      )
+      expect(result.object.children.some((child) => child.name === 'print-glazing-pane')).toBe(true)
+      expect(result.object.children.some((child) => child.name === 'print-roof-shell')).toBe(false)
+      for (const child of result.object.children) {
+        const geometry = (child as THREE.Mesh).geometry
+        expect(geometry.getIndex()!.count).toBeGreaterThan(0)
+        expect([...geometry.getAttribute('position').array].every(Number.isFinite)).toBe(true)
+      }
+    } finally {
+      for (const child of result.object.children) (child as THREE.Mesh).geometry.dispose()
+    }
+  })

package/src/lib/print-roof-solids.ts

@@ -1,10 +1,15 @@
 import {
   type AnyNode,
+  getBarrelRoofSolidPieces,
   getConicalRoofCoverage,
+  getGlazedRoofPieceFaces,
+  getGlazedRoofPieces,
   getRoofModuleFaces,
+  getRoofSegmentDeckReach,
   getRoofShapeInsets,
   getRoofShapeRatios,
   getSegmentSlopeFrame,
+  isGlazedRoofSegment,
   nodeRegistry,
   normalizeRoofSegmentTrim,
   type RoofSegmentNode,
@@ -411,11 +416,17 @@ function buildRoofModuleGeometry(
 
 function getVolumeFaces(
   node: RoofSegmentNode,
-  options: { widthExtension: number; verticalOffset: number; isVoid: boolean },
+  options: {
+    widthExtension: number
+    /** How far it reaches along x, where a gable's rakes are; `widthExtension` when absent. */
+    rakeExtension?: number
+    verticalOffset: number
+    isVoid: boolean
+  },
 ): RoofFace[] {
   const conicalCoverage = getConicalRoofCoverage(node)
   const { activeRh, tanTheta } = getSegmentSlopeFrame(node)
-  const width = Math.max(0.01, node.width + options.widthExtension * 2)
+  const width = Math.max(0.01, node.width + (options.rakeExtension ?? options.widthExtension) * 2)
   const depth = Math.max(0.01, node.depth + options.widthExtension * 2)
   const autoDrop = options.widthExtension * tanTheta
   const wallHeight = Math.max(0.01, node.wallHeight - autoDrop + options.verticalOffset)
@@ -448,13 +459,13 @@ function getShingleOuterFaces(node: RoofSegmentNode): RoofFace[] {
   const conicalCoverage = getConicalRoofCoverage(node)
   const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(node)
   const shapeRatios = getRoofShapeRatios(node)
-  const horizontalOverhang = node.overhang * cosTheta
-  const deckExtension = node.wallThickness / 2 + horizontalOverhang
+  const reach = getRoofSegmentDeckReach(node)
+  const deckExtension = reach.z
   const deckVerticalThickness = activeRh > 0 ? node.deckThickness / cosTheta : node.deckThickness
   const deckDrop = deckExtension * tanTheta
   const shingleHorizontalThickness = node.shingleThickness * sinTheta
   const shingleVerticalThickness = node.shingleThickness * cosTheta
-  const baseWidth = Math.max(0.01, node.width + deckExtension * 2)
+  const baseWidth = Math.max(0.01, node.width + reach.x * 2)
   const baseDepth = Math.max(0.01, node.depth + deckExtension * 2)
   const baseWallHeight = node.wallHeight - deckDrop + deckVerticalThickness
   const baseRoofHeight =
@@ -529,8 +540,9 @@ function blockingDiagnostics(
     dimensions.some((value) => !Number.isFinite(value) || value < 0) ||
     node.width <= FACE_EPSILON ||
     node.depth <= FACE_EPSILON ||
-    node.wallThickness <= FACE_EPSILON ||
-    node.deckThickness + node.shingleThickness <= FACE_EPSILON
+    (!isGlazedRoofSegment(node) &&
+      (node.wallThickness <= FACE_EPSILON ||
+        node.deckThickness + node.shingleThickness <= FACE_EPSILON))
   ) {
     diagnostics.push({
       severity: 'error',
@@ -581,8 +593,28 @@ export function buildPrintableRoofSegmentSolids(
 ): PrintRoofSolidResult {
   const diagnostics = blockingDiagnostics(node, nodes)
   if (diagnostics.length > 0) return { status: 'blocked', object: null, diagnostics }
+  if (isGlazedRoofSegment(node) || node.roofType === 'barrel') {
+    const root = new THREE.Group()
+    root.name = isGlazedRoofSegment(node) ? 'print-glazed-roof-solids' : 'print-barrel-roof-solids'
+    root.userData = { pascalId: node.id }
+    root.position.set(...node.position)
+    root.rotation.y = node.rotation
+    for (const piece of isGlazedRoofSegment(node)
+      ? getGlazedRoofPieces(node)
+      : getBarrelRoofSolidPieces(node)) {
+      const geometry = geometryFromFaces(getGlazedRoofPieceFaces(piece))
+      if (!geometry) continue
+      const mesh = new THREE.Mesh(geometry)
+      mesh.name = isGlazedRoofSegment(node)
+        ? piece.slot === 0
+          ? 'print-glazing-frame'
+          : 'print-glazing-pane'
+        : 'print-roof-shell'
+      root.add(mesh)
+    }
+    return { status: 'ready', object: root, diagnostics: [] }
+  }
 
-  const { cosTheta } = getSegmentSlopeFrame(node)
   const wallOuter = getVolumeFaces(node, {
     widthExtension: node.wallThickness / 2,
     verticalOffset: 0,
@@ -593,9 +625,10 @@ export function buildPrintableRoofSegmentSolids(
     verticalOffset: 0,
     isVoid: false,
   })
-  const deckExtension = node.wallThickness / 2 + node.overhang * cosTheta
+  const reach = getRoofSegmentDeckReach(node)
   const roofInner = getVolumeFaces(node, {
-    widthExtension: deckExtension,
+    widthExtension: reach.z,
+    rakeExtension: reach.x,
     verticalOffset: 0,
     isVoid: true,
   })

package/src/lib/print-shell-compiler-manifold-core.ts

@@ -27,7 +27,7 @@ type ManifoldFactory = (config?: {
 // emscripten then locates manifold.wasm relative to the glue's own URL. Hosts
 // that can't reach the CDN (offline, CSP) pass their own URLs through
 // configureManifoldRuntime.
-const MANIFOLD_VERSION = '3.5.1'
+const MANIFOLD_VERSION = '3.5.4'
 const FALLBACK_MODULE_URL = `https://cdn.jsdelivr.net/npm/manifold-3d@${MANIFOLD_VERSION}/manifold.js`
 
 function importUntraced(specifier: string): Promise<{ default: ManifoldFactory }> {

package/src/lib/room-assembly-overlay.ts

@@ -6,9 +6,8 @@ import {
   getWallBaseElevationForNodes,
   getWallCurveFrameAt,
   getWallFaceOffsets,
-  getWallPlaneTop,
+  getWallTop,
   resolveCeilingHeight,
-  resolveWallTop,
   roomDrawnFloor,
   type WallNode,
 } from '@pascal-app/core'
@@ -78,7 +77,7 @@ export function resolveRoomAssemblyHeights(
     const wall = nodes[id]
     if (wall?.type !== 'wall') continue
     const base = getWallBaseElevationForNodes(wall, sceneNodes)
-    wallTops.set(id, resolveWallTop(wall, getWallPlaneTop(wall, levelId, sceneNodes), base))
+    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base))
   }
   const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined
   const ceiling =

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

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, jest, spyOn, test } from 'bun:test'
 import { readFileSync } from 'node:fs'
 import {
   type AnyNode,
+  type AnyNodeDefinition,
   BuildingNode,
   CeilingNode,
   createRoomTopologyIndex,
@@ -10,7 +11,9 @@ import {
   ItemNode,
   LevelNode,
   type NodeEvent,
+  nodeRegistry,
   reconcileLevelStructure,
+  registerNode,
   SlabNode,
   SpawnNode,
   StairNode,
@@ -24,11 +27,12 @@ import { useViewer } from '@pascal-app/viewer'
 import { _roots, act } from '@react-three/fiber'
 import { createElement } from 'react'
 import { Group, type LineSegments } from 'three'
+import { z } from 'zod'
 import { SelectionManager } from '../components/editor/selection-manager'
 import { cancelActiveTool, runHistoryShortcut } from '../hooks/use-keyboard'
 import { resolvePlanRoomHit, roomPickingEnabled, useSelectedRoom } from '../hooks/use-selected-room'
 import useEditor from '../store/use-editor'
-import useInteractionScope from '../store/use-interaction-scope'
+import useInteractionScope, { getMovingNode } from '../store/use-interaction-scope'
 import useSessionGroups from '../store/use-session-groups'
 import { withSelectionHarness } from '../test-utils/selection-harness'
 import { startRoomDivide } from './room-divide-session'
@@ -646,6 +650,46 @@ describe('room drill-down state through the mounted selection manager', () => {
       expect(useEditor.getState().room).toBeNull()
     })
   })
+  test('a second click on the selected crate picks it up, and that click cannot drop it', async () => {
+    jest.useFakeTimers()
+    if (!nodeRegistry.has('test-crate')) {
+      registerNode({
+        kind: 'test-crate',
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal('test-crate') }) as never,
+        category: 'furnish',
+        defaults: () => ({}),
+        capabilities: { selectable: {}, movable: { axes: ['x', 'z'] } },
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+      } as AnyNodeDefinition)
+    }
+    const crate = {
+      id: 'test-crate_a',
+      type: 'test-crate',
+      parentId: levelId,
+      position: [2, 0, 2],
+      rotation: [0, 0, 0],
+    } as unknown as AnyNode
+    await withRooms(async ({ click }) => {
+      await act(async () => {
+        useScene.setState({ nodes: { ...useScene.getState().nodes, [crate.id]: crate } })
+      })
+      await click(crate.id, [2, 2])
+      jest.advanceTimersByTime(50)
+      await click(crate.id, [2, 2])
+      expect(getMovingNode()?.id).toBe(crate.id)
+
+      // The browser's click that ends this press would otherwise commit the move in place.
+      const endingClick = new Event('click', { cancelable: true })
+      window.dispatchEvent(endingClick)
+      expect(endingClick.defaultPrevented).toBe(true)
+      const dropClick = new Event('click', { cancelable: true })
+      window.dispatchEvent(dropClick)
+      expect(dropClick.defaultPrevented).toBe(false)
+      await act(async () => useEditor.getState().setMovingNode(null))
+    })
+  })
+
   test('plan and box furniture selections end the selected room', async () => {
     await withRooms(async ({ click, left }) => {
       const chair = ItemNode.parse({

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

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, mock, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
+  BuildingNode,
   CabinetModuleNode,
   type CabinetModuleNode as CabinetModuleNodeType,
   CabinetNode,
@@ -11,14 +12,17 @@ import {
   configureArtifactStore,
   getArtifactStore,
   ItemNode,
-  type LevelNode,
+  LevelNode,
   MeasurementNode,
+  RoofNode,
+  RoofSegmentNode,
   SceneMaterial,
   type SceneMaterialId,
   SlabNode,
   useScene,
   WallNode,
   WindowNode,
+  ZoneNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import {
@@ -366,6 +370,194 @@ describe('scene clipboard', () => {
     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({
@@ -552,6 +744,59 @@ describe('scene clipboard', () => {
     }
   })
 
+  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()