@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/tools/item/shelf-surface-strategy-resolver.test.ts

@@ -117,39 +117,39 @@ function hit(y = 1, z = -0.1): ShelfEvent {
   } as ShelfEvent
 }
 
-test.each([
-  'grid',
-  'off',
-] as const)('midpoint keeps the first declared row and preserves X/Z with grid %s', (mode) => {
-  useEditor.getState().setSnappingMode('item', mode)
-  for (const declared of [
-    [0.5, 1.5],
-    [1.5, 0.5],
-  ]) {
-    rows = declared
-    const expected: [number, number, number] =
-      mode === 'grid' ? [0.25, rows[0]!, 0.125] : [0.37, rows[0]!, -0.1]
-    const ctx = context()
-    const entered = shelfSurfaceStrategy.enter(ctx, hit())!
-    expect(entered.nodeUpdate).toEqual({
-      position: expected,
-      parentId: host.id,
-      rotation: [0.1, 0.7, 0.3],
-    })
-    expect(entered.gridPosition).toEqual(expected)
-    expect(entered.cursorPosition).toEqual(expected)
-    const moved = shelfSurfaceStrategy.move(onShelf(ctx), hit())!
-    expect(moved.nodeUpdate).toEqual({ position: expected })
-    expect(moved.cursorPosition).toEqual(expected)
-    const committed = shelfSurfaceStrategy.click(
-      { ...onShelf(ctx), gridPosition: new Vector3(...entered.gridPosition) },
-      hit(),
-    )!
-    expect(committed.nodeUpdate.position).toEqual(expected)
-    expect(committed.nodeUpdate.parentId).toBe(host.id)
-  }
-  expect(resolver).toHaveBeenCalledTimes(6)
-})
+test.each(['grid', 'off'] as const)(
+  'midpoint keeps the first declared row and preserves X/Z with grid %s',
+  (mode) => {
+    useEditor.getState().setSnappingMode('item', mode)
+    for (const declared of [
+      [0.5, 1.5],
+      [1.5, 0.5],
+    ]) {
+      rows = declared
+      const expected: [number, number, number] =
+        mode === 'grid' ? [0.25, rows[0]!, 0.125] : [0.37, rows[0]!, -0.1]
+      const ctx = context()
+      const entered = shelfSurfaceStrategy.enter(ctx, hit())!
+      expect(entered.nodeUpdate).toEqual({
+        position: expected,
+        parentId: host.id,
+        rotation: [0.1, 0.7, 0.3],
+      })
+      expect(entered.gridPosition).toEqual(expected)
+      expect(entered.cursorPosition).toEqual(expected)
+      const moved = shelfSurfaceStrategy.move(onShelf(ctx), hit())!
+      expect(moved.nodeUpdate).toEqual({ position: expected })
+      expect(moved.cursorPosition).toEqual(expected)
+      const committed = shelfSurfaceStrategy.click(
+        { ...onShelf(ctx), gridPosition: new Vector3(...entered.gridPosition) },
+        hit(),
+      )!
+      expect(committed.nodeUpdate.position).toEqual(expected)
+      expect(committed.nodeUpdate.parentId).toBe(host.id)
+    }
+    expect(resolver).toHaveBeenCalledTimes(6)
+  },
+)
 
 test.each([
   [0.999, 0.5],
@@ -182,29 +182,29 @@ test('a full-board object is refused when grid snapping puts its centre outside
   expect(shelfSurfaceStrategy.enter(context(draft), hit(1, -0.39))).toBeNull()
 })
 
-test.each([
-  'grid',
-  'off',
-] as const)('shelf frame conversion retains exact poses with grid %s', (mode) => {
-  useEditor.getState().setSnappingMode('item', mode)
-  const mesh = sceneRegistry.nodes.get(host.id)!
-  mesh.position.set(4, 2, -3)
-  mesh.rotation.set(0, Math.PI / 3, 0)
-  mesh.updateMatrixWorld(true)
-  const event = hit(1.2)
-  const local = mesh.worldToLocal(new Vector3(...event.position))
-  const expected: [number, number, number] =
-    mode === 'grid' ? [0.25, 1.5, 0.125] : [local.x, 1.5, local.z]
-  const yaw = new Euler().setFromQuaternion(mesh.getWorldQuaternion(new Quaternion()), 'YXZ').y
-  const entered = shelfSurfaceStrategy.enter(context(), event)!
-  expect(entered.nodeUpdate).toEqual({
-    position: expected,
-    parentId: host.id,
-    rotation: [0.1, 0.7 - yaw, 0.3],
-  })
-  expect(entered.cursorPosition).toEqual(mesh.localToWorld(new Vector3(...expected)).toArray())
-  expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition).toEqual(expected)
-})
+test.each(['grid', 'off'] as const)(
+  'shelf frame conversion retains exact poses with grid %s',
+  (mode) => {
+    useEditor.getState().setSnappingMode('item', mode)
+    const mesh = sceneRegistry.nodes.get(host.id)!
+    mesh.position.set(4, 2, -3)
+    mesh.rotation.set(0, Math.PI / 3, 0)
+    mesh.updateMatrixWorld(true)
+    const event = hit(1.2)
+    const local = mesh.worldToLocal(new Vector3(...event.position))
+    const expected: [number, number, number] =
+      mode === 'grid' ? [0.25, 1.5, 0.125] : [local.x, 1.5, local.z]
+    const yaw = new Euler().setFromQuaternion(mesh.getWorldQuaternion(new Quaternion()), 'YXZ').y
+    const entered = shelfSurfaceStrategy.enter(context(), event)!
+    expect(entered.nodeUpdate).toEqual({
+      position: expected,
+      parentId: host.id,
+      rotation: [0.1, 0.7 - yaw, 0.3],
+    })
+    expect(entered.cursorPosition).toEqual(mesh.localToWorld(new Vector3(...expected)).toArray())
+    expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition).toEqual(expected)
+  },
+)
 
 test('only enter requires an upward normal; moves keep electing rows', () => {
   for (const normal of [[1, 0, 0], [0, -1, 0], undefined] as ShelfEvent['normal'][]) {

package/src/components/tools/item/use-draft-node.test.tsx

@@ -1,13 +1,19 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { beforeEach, describe, expect, spyOn, test } from 'bun:test'
 import {
   type AnyNodeId,
+  applySceneSnapshot,
   BlockNode,
   BuildingNode,
+  beginSceneHistoryPauseSession,
   getBlockFaceFrame,
+  getSceneHistoryPauseDepth,
   ItemNode,
   LevelNode,
   type NodeEvent,
+  pauseSceneHistory,
+  resumeSceneHistory,
   useScene,
+  WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { renderToString } from 'react-dom/server'
@@ -76,6 +82,232 @@ beforeEach(() => {
 })
 
 describe('useDraftNode block face commit', () => {
+  test.each(
+    (['parse', 'write'] as const).flatMap((failure) =>
+      (['retry', 'cancel', 'foreign move then cancel'] as const).map((finish) => ({
+        failure,
+        finish,
+      })),
+    ),
+  )(
+    'an adopted $failure rejection retains owned history through $finish',
+    ({ failure, finish }) => {
+      const item = ItemNode.parse({
+        parentId: LEVEL_ID,
+        position: [1, 0, 1],
+        asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+      })
+      useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
+      useScene.temporal.getState().clear()
+      const originalNodes = structuredClone(useScene.getState().nodes)
+      const draft = draftNode!
+      draft.adopt(item)
+      draft.updateSurface({ position: [2, 0, 2] }, null)
+      const commit = (position: ItemNode['position']) => {
+        const drop = beginSceneHistoryPauseSession(useScene, { gesture: item.id })
+        try {
+          return drop.commitStep(() => draft.commit({ parentId: LEVEL_ID, position }))
+        } finally {
+          drop.end()
+        }
+      }
+      const updateNodes = useScene.getState().updateNodes
+      try {
+        if (failure === 'write') {
+          useScene.setState({
+            updateNodes: (updates) => {
+              if (
+                useScene.temporal.getState().isTracking &&
+                updates.some(
+                  (update) =>
+                    update.id === item.id &&
+                    'position' in update.data &&
+                    update.data.position?.[0] === 3,
+                )
+              ) {
+                throw new Error('Rejected tracked write before publication')
+              }
+              return updateNodes(updates)
+            },
+          })
+        }
+        expect(() => commit(failure === 'parse' ? [Number.NaN, 0, 3] : [3, 0, 3])).toThrow()
+        useScene.setState({ updateNodes })
+        expect(draft.current?.id).toBe(item.id)
+        expect(useScene.getState().nodes).toEqual(originalNodes)
+        expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+        expect(useScene.temporal.getState().isTracking).toBe(true)
+        expect(getSceneHistoryPauseDepth()).toBe(0)
+
+        draft.updateSurface({ position: [4, 0, 4] }, null)
+        useScene.getState().updateNode(item.id, { name: 'Foreign rename' })
+        expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+        expect(useScene.temporal.getState().pastStates[0]?.nodes).toEqual(originalNodes)
+        const renamedNodes = {
+          ...originalNodes,
+          [item.id]: { ...originalNodes[item.id]!, name: 'Foreign rename' },
+        }
+
+        if (finish === 'retry') {
+          expect(commit([5, 0, 5])).toBe(item.id)
+          expect(draft.current).toBeNull()
+          const committedNodes = structuredClone(useScene.getState().nodes)
+          expect(committedNodes[item.id]).toMatchObject({
+            name: 'Foreign rename',
+            position: [5, 0, 5],
+          })
+          expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(committedNodes)
+        } else if (finish === 'cancel') {
+          draft.destroy()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(originalNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+        } else {
+          useScene.getState().updateNode(item.id, { position: [7, 0, 7] })
+          const foreignNodes = structuredClone(useScene.getState().nodes)
+          draft.destroy()
+          expect(useScene.getState().nodes).toEqual(foreignNodes)
+          expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(foreignNodes)
+        }
+        expect(useScene.temporal.getState().isTracking).toBe(true)
+        expect(getSceneHistoryPauseDepth()).toBe(0)
+      } finally {
+        useScene.setState({ updateNodes })
+        draft.destroy()
+      }
+    },
+  )
+
+  test('a drop on an undone host waits for a new valid placement target', () => {
+    const item = ItemNode.parse({
+      parentId: LEVEL_ID,
+      position: [1, 0, 1],
+      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+    })
+    useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+    const wall = WallNode.parse({ parentId: LEVEL_ID, start: [10, 10], end: [14, 10] })
+    useScene.getState().createNode(wall, LEVEL_ID as AnyNodeId)
+    const draft = draftNode!
+    draft.adopt(item)
+    draft.updateSurface({ parentId: wall.id, position: [2, 1, 0] }, null)
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[wall.id]).toBeUndefined()
+    expect(draft.commit({ parentId: wall.id, position: [2, 1, 0] })).toBeNull()
+    expect(draft.current).not.toBeNull()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+    expect(draft.commit({ parentId: LEVEL_ID, position: [12, 1, 10] })).toBe(item.id)
+    expect(useScene.getState().nodes[item.id]).toMatchObject({
+      parentId: LEVEL_ID,
+      position: [12, 1, 10],
+    })
+  })
+
+  test('a subscriber failure after create cannot strand a transient node', () => {
+    let createdId: AnyNodeId | undefined
+    const unsubscribe = useScene.subscribe((state) => {
+      if (createdId) return
+      const created = Object.values(state.nodes).find(
+        (node) => node.type === 'item' && node.metadata?.isTransient,
+      )
+      if (!created) return
+      createdId = created.id
+      throw new Error('subscriber rejected published draft')
+    })
+    try {
+      expect(() =>
+        draftNode!.create(new Vector3(), {
+          id: 'box',
+          name: 'Box',
+          category: 'decor',
+          thumbnail: '',
+          src: '/box.glb',
+        }),
+      ).toThrow('subscriber rejected published draft')
+    } finally {
+      unsubscribe()
+    }
+    expect(createdId).toBeDefined()
+    expect(useScene.getState().nodes[createdId!]).toBeUndefined()
+    expect((useScene.getState().nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).not.toContain(
+      createdId!,
+    )
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+    draftNode!.destroy()
+  })
+
+  test('a failed create releases its history draft so host snapshots still load', () => {
+    const createNode = spyOn(useScene.getState(), 'createNode').mockImplementation(() => {
+      throw new Error('create rejected')
+    })
+    try {
+      expect(() =>
+        draftNode!.create(new Vector3(), {
+          id: 'box',
+          name: 'Box',
+          category: 'decor',
+          thumbnail: '',
+          src: '/box.glb',
+        }),
+      ).toThrow('create rejected')
+    } finally {
+      createNode.mockRestore()
+    }
+    draftNode!.destroy()
+    const state = useScene.getState()
+    expect(() =>
+      applySceneSnapshot(
+        {
+          nodes: state.nodes,
+          rootNodeIds: state.rootNodeIds,
+          collections: state.collections,
+          materials: state.materials,
+          installedPlugins: state.installedPlugins,
+        },
+        { origin: 'host' },
+      ),
+    ).not.toThrow()
+  })
+
+  test('a rejected fresh drop keeps its draft registered until cancel', () => {
+    const fresh = ItemNode.parse({
+      parentId: LEVEL_ID,
+      metadata: { isNew: true },
+      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+    })
+    useScene.getState().createNode(fresh, LEVEL_ID as AnyNodeId)
+    const draft = draftNode!
+    draft.adopt(fresh)
+    useScene.setState({ readOnly: true })
+    expect(draft.commit({ position: [2, 0, 3] })).toBeNull()
+    useScene.setState({ readOnly: false })
+    const state = useScene.getState()
+    expect(() =>
+      applySceneSnapshot(
+        {
+          nodes: state.nodes,
+          rootNodeIds: state.rootNodeIds,
+          collections: state.collections,
+          materials: state.materials,
+          installedPlugins: state.installedPlugins,
+        },
+        { origin: 'host' },
+      ),
+    ).toThrow()
+    draft.destroy()
+  })
+
   test('persists the face host used by the placement preview', () => {
     const draft = draftNode!
     draft.create(new Vector3(0, 0, 0), {
@@ -115,6 +347,8 @@ describe('useDraftNode block face commit', () => {
       dimensions: [0.5, 0.39, 0.5],
     })!
 
+    expect(useScene.temporal.getState().isTracking).toBe(false)
+    useScene.temporal.getState().resume()
     const committedId = draft.commit({
       parentId: BLOCK_ID,
       position: [0.5, 0, 0],
@@ -142,6 +376,27 @@ describe('useDraftNode block face commit', () => {
     )
   })
 
+  test('a duplicate drops into the collections of the item it copies, in its one undo step', () => {
+    const asset = { id: 'lamp', name: 'Lamp', category: 'decor', thumbnail: '', src: '/lamp.glb' }
+    useScene.temporal.getState().pause()
+    const lamp = ItemNode.parse({ parentId: LEVEL_ID, position: [1, 0, 1], asset })
+    useScene.getState().createNode(lamp, LEVEL_ID as AnyNodeId)
+    const lightingId = useScene.getState().createCollection('Lighting', [lamp.id])
+    const lighting = useScene.getState().collections[lightingId]
+    const source = useScene.getState().nodes[lamp.id] as ItemNode
+    const draft = draftNode!
+    draft.create(new Vector3(3, 0, 3), asset, undefined, undefined, source)
+    useScene.temporal.getState().resume()
+
+    const copyId = draft.commit({ parentId: LEVEL_ID, position: [3, 0, 3] }) as AnyNodeId
+
+    expect(useScene.getState().nodes[copyId]).toMatchObject({ collectionIds: [lightingId] })
+    expect(useScene.getState().collections[lightingId]?.nodeIds).toEqual([lamp.id, copyId])
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[copyId]).toBeUndefined()
+    expect(useScene.getState().collections[lightingId]).toEqual(lighting)
+  })
+
   test('moves a block-face item to the floor as one undoable reparent', () => {
     const hosted = ItemNode.parse({
       id: 'item_hosted-potted-plant',
@@ -164,6 +419,8 @@ describe('useDraftNode block face commit', () => {
 
     const draft = draftNode!
     draft.adopt(hosted)
+    expect(useScene.temporal.getState().isTracking).toBe(false)
+    useScene.temporal.getState().resume()
     draft.commit({
       parentId: LEVEL_ID,
       position: [2, 0, 3],
@@ -202,6 +459,180 @@ describe('useDraftNode block face commit', () => {
     )
   })
 
+  test('drops onto the level when the original host was deleted mid-carry', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_host-deleted-plant',
+      parentId: BLOCK_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0.5, 0, 0],
+      blockFaceId: 'face-top',
+    })
+    useScene.getState().createNode(hosted, BLOCK_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+
+    const draft = draftNode!
+    draft.adopt(hosted)
+    draft.updateSurface({ parentId: LEVEL_ID, position: [1, 0, 1], blockFaceId: undefined }, null)
+    // A collaborator deletes the block the item came from.
+    useScene.getState().deleteNode(BLOCK_ID as AnyNodeId)
+    draft.commit({ position: [2, 0, 3] })
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[BLOCK_ID as AnyNodeId]).toBeUndefined()
+    expect(nodes[hosted.id as AnyNodeId]).toMatchObject({ parentId: LEVEL_ID, position: [2, 0, 3] })
+    expect((nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).toContain(hosted.id)
+    for (const state of useScene.temporal.getState().pastStates) {
+      const recorded = state.nodes?.[hosted.id as AnyNodeId]
+      if (recorded?.parentId) expect(state.nodes?.[recorded.parentId as AnyNodeId]).toBeDefined()
+    }
+  })
+
+  test('cancel after the original host was deleted mid-carry keeps the item on the level', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_host-deleted-cancel',
+      parentId: BLOCK_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0.5, 0, 0],
+      blockFaceId: 'face-top',
+    })
+    useScene.getState().createNode(hosted, BLOCK_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+
+    const draft = draftNode!
+    draft.adopt(hosted)
+    draft.updateSurface({ parentId: LEVEL_ID, position: [1, 0, 1], blockFaceId: undefined }, null)
+    useScene.getState().deleteNode(BLOCK_ID as AnyNodeId)
+    draft.destroy()
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[hosted.id as AnyNodeId]?.parentId).toBe(LEVEL_ID)
+    expect((nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).toContain(hosted.id)
+  })
+
+  test("cancel and drop-then-undo keep a collaborator's later position", () => {
+    const plant = ItemNode.parse({
+      id: 'item_collab-position-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(plant, LEVEL_ID as AnyNodeId)
+    const id = plant.id as AnyNodeId
+    const position = () => (useScene.getState().nodes[id] as ItemNode).position
+
+    // Escape keeps the collaborator's position.
+    useScene.temporal.getState().clear()
+    const draft = draftNode!
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    useScene.getState().updateNode(id, { position: [7, 0, 7] })
+    draft.destroy()
+    expect(position()).toEqual([7, 0, 7])
+
+    // Drop, then undo, returns to the collaborator's position.
+    useScene.temporal.getState().clear()
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    useScene.getState().updateNode(id, { position: [5, 0, 5] })
+    draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3] })
+    expect(position()).toEqual([2, 0, 3])
+    useScene.temporal.getState().undo()
+    expect(position()).toEqual([5, 0, 5])
+  })
+
+  test("the 3D drop keeps an agent's metadata edit made during the carry, in one step", () => {
+    const plant = ItemNode.parse({
+      id: 'item_agent-metadata-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(plant, LEVEL_ID as AnyNodeId)
+    const id = plant.id as AnyNodeId
+    useScene.temporal.getState().clear()
+    const draft = draftNode!
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    const metadata = useScene.getState().nodes[id]!.metadata as Record<string, unknown>
+    useScene.getState().updateNode(id, { metadata: { ...metadata, tag: 'x' } })
+    const past = useScene.temporal.getState().pastStates.length
+    // Placement strategies hand the drop the adoption-time metadata.
+    draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3], metadata: {} })
+
+    const live = useScene.getState().nodes[id] as ItemNode
+    expect(live.position).toEqual([2, 0, 3])
+    expect((live.metadata as Record<string, unknown>).tag).toBe('x')
+    expect((live.metadata as Record<string, unknown>).isTransient).toBeUndefined()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(past + 1)
+    useScene.temporal.getState().undo()
+    expect((useScene.getState().nodes[id] as ItemNode).position).toEqual([0, 0, 0])
+    expect(useScene.getState().nodes[id]?.metadata?.isTransient).toBeUndefined()
+  })
+
+  test('never resumes history that another owner is pausing', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_owned-pause-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(hosted, LEVEL_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+    pauseSceneHistory(useScene)
+    try {
+      const draft = draftNode!
+      draft.adopt(hosted)
+      draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3] })
+      draft.create(new Vector3(1, 0, 1), hosted.asset)
+      draft.commit({ parentId: LEVEL_ID, position: [1, 0, 1] })
+
+      expect(useScene.getState().nodes[hosted.id as AnyNodeId]).toMatchObject({
+        position: [2, 0, 3],
+      })
+      expect(useScene.temporal.getState().isTracking).toBe(false)
+      expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+      expect(getSceneHistoryPauseDepth()).toBe(1)
+    } finally {
+      resumeSceneHistory(useScene)
+    }
+    expect(useScene.temporal.getState().isTracking).toBe(true)
+  })
+
   test('keeps a hosted item visible through a block topology edit and its undo', () => {
     useScene.temporal.getState().pause()
     const draft = draftNode!