@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/glb-export.ts

@@ -7,6 +7,7 @@ import {
   findLevelAncestorId,
   type GeometryContext,
   getLevelDisplayName,
+  hidesDescendants,
   isNodeKindEnabled,
   isOperationDoorType,
   itemClipRegistry,
@@ -18,7 +19,9 @@ import {
   type WindowNode,
   type ZoneNode,
 } from '@pascal-app/core'
+import { evaluateRecipe } from '@pascal-app/core/procedural-items'
 import {
+  decorateProceduralEmission,
   getPascalTextureRef,
   isViewerPresentationTextureBorrowed,
   poseDoorMovingParts,
@@ -37,6 +40,8 @@ import {
 } from 'three/examples/jsm/exporters/GLTFExporter.js'
 import { createExportTextureUtils, type ExportTextureUtils } from './export-texture-utils'
 import { cloneExportUserData } from './export-user-data'
+import { isIfcRolePart } from './ifc-parts'
+import { nodeDisplayLabel } from './node-display-label'
 import {
   type CompressedTextureDecompressor,
   decompressCanonicalNormalMaps,
@@ -140,6 +145,115 @@ export function nextFrames(): Promise<void> {
   })
 }
 
+/**
+ * Export visibility, shared with the clone pruning: a hidden node hides its
+ * subtree, except a Site, which hides only its own ground (`hidesDescendants`).
+ */
+export function createExportVisibility(nodes: Record<string, AnyNode>) {
+  const visibility = new Map<string, boolean>()
+  const isVisible = (id: string, path: Set<string> = new Set()): boolean => {
+    const cached = visibility.get(id)
+    if (cached !== undefined) return cached
+    const node = nodes[id]
+    if (!node) return true
+    if (node.visible === false) {
+      visibility.set(id, false)
+      return false
+    }
+    const parentId = node.parentId
+    const parent = parentId ? nodes[parentId] : undefined
+    if (!parentId || path.has(id) || (parent && !hidesDescendants(parent))) {
+      visibility.set(id, true)
+      return true
+    }
+    path.add(id)
+    const visible = isVisible(parentId, path)
+    path.delete(id)
+    visibility.set(id, visible)
+    return visible
+  }
+  return isVisible
+}
+
+export type ExportGeometryScope = Pick<GlbExportOptions, 'onlyVisible' | 'excludedNodeTypes'>
+
+/**
+ * Included `bake: 'replace'` nodes whose live object holds no mesh yet. These
+ * kinds render collectively in the editor and mount their own geometry only
+ * while `isExporting` is set; kinds with bake hooks are rebuilt after the
+ * clone instead, and excluded or hidden nodes never reach the clone.
+ */
+export function nodesAwaitingExportGeometry(
+  nodes: Record<string, AnyNode>,
+  scope: ExportGeometryScope = {},
+): string[] {
+  const sceneState = useScene.getState()
+  const installedPlugins = sceneState.hasExplicitPluginInstallState
+    ? sceneState.installedPlugins
+    : undefined
+  const excluded = new Set(scope.excludedNodeTypes)
+  const isVisible = createExportVisibility(nodes)
+  const typeExcluded = (node: AnyNode): boolean => {
+    for (let current: AnyNode | undefined = node, guard = 0; current && guard < 64; guard++) {
+      if (excluded.has(current.type)) return true
+      current = current.parentId ? nodes[current.parentId] : undefined
+    }
+    return false
+  }
+  const pending: string[] = []
+  for (const [id, object] of sceneRegistry.nodes) {
+    const node = nodes[id]
+    if (!node) continue
+    const definition = nodeRegistry.get(node.type)
+    if (definition?.bake !== 'replace' || definition.bakeGeometry || definition.bakeGeometryAsync) {
+      continue
+    }
+    if (!isNodeKindEnabled(node.type, installedPlugins) || typeExcluded(node)) continue
+    if ((scope.onlyVisible ?? true) && !isVisible(id)) continue
+    let hasMesh = false
+    object.traverse((child) => {
+      if ((child as THREE.Mesh).isMesh) hasMesh = true
+    })
+    if (!hasMesh) pending.push(id)
+  }
+  return pending
+}
+
+/** Two animation frames, or `ms` if frames have stopped (hidden tab, test runner). */
+function nextFramesOrTimeout(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms)
+    if (typeof requestAnimationFrame !== 'function') return
+    requestAnimationFrame(() =>
+      requestAnimationFrame(() => {
+        clearTimeout(timer)
+        resolve()
+      }),
+    )
+  })
+}
+
+/**
+ * After `setExporting(true)`, let one commit land, then wait until every
+ * included replace-kind node has mounted its export geometry. Two frames are
+ * not enough: on a large scene with a busy main thread the proxies' re-render
+ * lands several frames later, and the clone would silently miss every plant.
+ * The deadline runs on its own timer, so stalled frames cannot hang an export.
+ */
+export async function waitForExportGeometry(
+  nodes: Record<string, AnyNode>,
+  scope: ExportGeometryScope = {},
+  timeoutMs = 10_000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  await nextFramesOrTimeout(Math.min(500, timeoutMs))
+  while (nodesAwaitingExportGeometry(nodes, scope).length > 0) {
+    const remaining = deadline - Date.now()
+    if (remaining <= 0) return
+    await nextFramesOrTimeout(Math.min(50, remaining))
+  }
+}
+
 type GltfExtrasDef = {
   extras?: Record<string, unknown>
 }
@@ -368,7 +482,10 @@ function startSceneExportPreparation(
 
   for (const [id, original] of registryEntries) {
     const node = nodes[id]
-    if (!node) continue
+    if (!node) {
+      excludedObjects.add(original)
+      continue
+    }
     const installedPlugins = sceneState.hasExplicitPluginInstallState
       ? sceneState.installedPlugins
       : undefined
@@ -481,10 +598,18 @@ function finishSceneExportPreparation(preparation: SceneExportPreparation): GlbE
     if (clone) identityNodes.add(clone)
   }
 
-  pruneNonRenderableMeshes(scene, identityNodes)
+  const warnings = pruneNonRenderableMeshes(scene, identityNodes)
   sanitizeMaterialGroups(scene, identityNodes)
   convertMaterials(scene, options.textures ?? 'embed', options.purpose ?? 'viewer')
 
+  for (const [id, original] of registryEntries) {
+    const node = nodes[id]
+    const clone = cloneByOriginal.get(original)
+    if (node?.type !== 'procedural-item' || !clone) continue
+    const lights = evaluateRecipe(node.recipe, node.parameters).lights
+    decorateProceduralEmission(clone, lights, true)
+  }
+
   const retainedCloneByOriginal = retainedClones(scene, cloneByOriginal)
   const keepClips = options.animations
     ? options.animations === 'keep'
@@ -492,13 +617,20 @@ function finishSceneExportPreparation(preparation: SceneExportPreparation): GlbE
   const animation = keepClips
     ? bakeAnimationClips(retainedCloneByOriginal, nodes, registryEntries)
     : { clips: [], clipNamesByNode: new Map<string, string[]>() }
+  if (!keepClips) {
+    for (const [id, original] of registryEntries) {
+      const node = nodes[id]
+      const clone = retainedCloneByOriginal.get(original)
+      if (node?.type === 'procedural-item' && clone) bakeRegistryAnimationClips(node, clone)
+    }
+  }
   stampIdentity(scene, retainedCloneByOriginal, nodes, animation.clipNamesByNode, registryEntries)
 
   let disposed = false
   return {
     scene,
     animations: animation.clips,
-    warnings: [],
+    warnings,
     dispose: () => {
       if (disposed) return
       disposed = true
@@ -714,45 +846,33 @@ function pruneHiddenSceneNodes(
   nodes: Record<string, AnyNode>,
   registryEntries: readonly RegistryEntry[],
 ) {
-  const visibility = new Map<string, boolean>()
-  const declaredSiteParents = new Map<string, string>()
-  for (const node of Object.values(nodes)) {
-    if (node.type !== 'site' || !('children' in node) || !Array.isArray(node.children)) continue
-    for (const childId of node.children) {
-      const child = nodes[childId]
-      if (child && !child.parentId && !declaredSiteParents.has(childId)) {
-        declaredSiteParents.set(childId, node.id)
-      }
-    }
-  }
+  const isVisible = createExportVisibility(nodes)
 
-  const isVisible = (id: string, path: Set<string>): boolean => {
-    const cached = visibility.get(id)
-    if (cached !== undefined) return cached
+  const nodeClones = new Set<THREE.Object3D>()
+  for (const [, original] of registryEntries) {
+    const clone = cloneByOriginal.get(original)
+    if (clone) nodeClones.add(clone)
+  }
 
+  for (const [id, original] of registryEntries) {
+    if (isVisible(id)) continue
+    const clone = cloneByOriginal.get(original)
+    if (!clone) continue
     const node = nodes[id]
-    if (!node) return true
-    if (node.visible === false) {
-      visibility.set(id, false)
-      return false
+    if (!node || hidesDescendants(node)) {
+      clone.removeFromParent()
+      continue
     }
-    const parentId = node.parentId || declaredSiteParents.get(id)
-    if (!parentId || path.has(id)) {
-      visibility.set(id, true)
-      return true
+    // Drop the hidden Site's own ground fill and boundary; keep what it hosts.
+    for (const child of [...clone.children]) {
+      if (!hostsSceneNode(child, nodeClones)) child.removeFromParent()
     }
-
-    path.add(id)
-    const visible = isVisible(parentId, path)
-    path.delete(id)
-    visibility.set(id, visible)
-    return visible
   }
+}
 
-  for (const [id, original] of registryEntries) {
-    if (isVisible(id, new Set())) continue
-    cloneByOriginal.get(original)?.removeFromParent()
-  }
+function hostsSceneNode(object: THREE.Object3D, nodeClones: Set<THREE.Object3D>): boolean {
+  if (nodeClones.has(object)) return true
+  return object.children.some((child) => hostsSceneNode(child, nodeClones))
 }
 
 function retainedClones(
@@ -889,7 +1009,16 @@ const PLACEHOLDER_MATERIAL = new THREE.MeshBasicMaterial({ visible: false })
  */
 function pruneNonRenderableMeshes(root: THREE.Object3D, identityNodes: Set<THREE.Object3D>) {
   const toRemove: THREE.Object3D[] = []
+  const warnings: string[] = []
   root.traverse((object) => {
+    if (toRemove.some((ancestor) => isDescendantOf(object, ancestor))) return
+    if (typeof object.userData.pascalExportRefusal === 'string') {
+      warnings.push(
+        `Skipped ${object.name || object.userData.pascalId || 'object'}: ${object.userData.pascalExportRefusal}`,
+      )
+      toRemove.push(object)
+      return
+    }
     if (object.userData.pascalExport === 'strip') {
       toRemove.push(object)
       return
@@ -948,6 +1077,7 @@ function pruneNonRenderableMeshes(root: THREE.Object3D, identityNodes: Set<THREE
   for (const object of toRemove) {
     object.removeFromParent()
   }
+  return warnings
 }
 
 /**
@@ -1329,15 +1459,19 @@ function bakeAnimationClips(
     const target = cloneByOriginal.get(original)
     if (!node || !target) continue
 
+    // A window or door built from a script carries its clips like an authored item.
+    const scripted = (node.type === 'door' || node.type === 'window') && node.source
     const clip =
       bakeRegistryAnimationClips(node, target) ??
-      (node.type === 'door'
-        ? bakeDoorClip(id, node, target)
-        : node.type === 'window'
-          ? bakeWindowClip(id, node as WindowNode, target)
-          : node.type === 'item'
-            ? bakeItemClip(id, target)
-            : null)
+      (scripted
+        ? bakeItemClip(id, target)
+        : node.type === 'door'
+          ? bakeDoorClip(id, node, target)
+          : node.type === 'window'
+            ? bakeWindowClip(id, node as WindowNode, target)
+            : node.type === 'item'
+              ? bakeItemClip(id, target)
+              : null)
 
     if (clip) {
       const nodeClips = Array.isArray(clip) ? clip : [clip]
@@ -1360,44 +1494,47 @@ function bakeRegistryAnimationClips(
 }
 
 /**
- * Re-emit a catalog item's ambient clip (e.g. a fan's spin) onto the baked
- * subtree. The source clip targets the item GLB's nodes by name (`lamp_018`);
- * since every fan shares those names, we rebind each track to the specific
- * cloned node's uuid so multiple fans animate independently. The clip is named
- * per node (`<id>: loop`) so the baked viewer can drive each one on its own.
+ * Re-emit an item's clips (a fan's spin, an authored object's motions) onto the
+ * baked subtree. Source clips target the item GLB's nodes by name (`lamp_018`);
+ * since every instance shares those names, we rebind each track to the
+ * specific cloned node's uuid so instances animate independently. Clips are
+ * named per node (`<id>: <name>`; the viewer drives `<id>: loop`).
  */
-function bakeItemClip(id: string, itemObject: THREE.Object3D): THREE.AnimationClip | null {
-  const entry = itemClipRegistry.get(id)
-  if (!entry) return null
+function bakeItemClip(id: string, itemObject: THREE.Object3D): THREE.AnimationClip[] | null {
+  const entries = itemClipRegistry.get(id)
+  if (!entries?.length) return null
 
-  const tracks: THREE.KeyframeTrack[] = []
   // The catalog node names (e.g. "lamp_018") repeat across every instance of the
   // item, and the glTF export→import roundtrip rebinds clip tracks by node name —
-  // so a shared name would make all fans share one clip. Uniquify the targeted
-  // node's name per item once, then bind tracks by its (stable) uuid.
+  // so a shared name would make all fans share one clip. Uniquify each targeted
+  // node's name per item once (clips may share targets), then bind by uuid.
   const renamed = new Map<string, THREE.Object3D>()
-  for (const track of entry.clip.tracks) {
-    const dot = track.name.lastIndexOf('.')
-    if (dot < 0) continue
-    const targetName = track.name.slice(0, dot)
-    const property = track.name.slice(dot + 1)
-    let targetNode = renamed.get(targetName)
-    if (!targetNode) {
-      const found = itemObject.getObjectByName(targetName)
-      if (!found) continue
-      found.name = `${id}__${targetName}`
-      renamed.set(targetName, found)
-      targetNode = found
+  const clips: THREE.AnimationClip[] = []
+  for (const entry of entries) {
+    const tracks: THREE.KeyframeTrack[] = []
+    for (const track of entry.clip.tracks) {
+      const dot = track.name.lastIndexOf('.')
+      if (dot < 0) continue
+      const targetName = track.name.slice(0, dot)
+      const property = track.name.slice(dot + 1)
+      let targetNode = renamed.get(targetName)
+      if (!targetNode) {
+        const found = itemObject.getObjectByName(targetName)
+        if (!found) continue
+        found.name = `${id}__${targetName}`
+        renamed.set(targetName, found)
+        targetNode = found
+      }
+      const retargeted = track.clone()
+      retargeted.name = `${targetNode.uuid}.${property}`
+      tracks.push(retargeted)
     }
-    const retargeted = track.clone()
-    retargeted.name = `${targetNode.uuid}.${property}`
-    tracks.push(retargeted)
+    if (tracks.length === 0) continue
+    const clip = new THREE.AnimationClip(`${id}: ${entry.name}`, entry.clip.duration, tracks)
+    clip.userData = { loop: entry.loop }
+    clips.push(clip)
   }
-
-  if (tracks.length === 0) return null
-  const clip = new THREE.AnimationClip(`${id}: loop`, entry.clip.duration, tracks)
-  clip.userData = { loop: entry.loop }
-  return clip
+  return clips.length > 0 ? clips : null
 }
 
 /**
@@ -1636,42 +1773,6 @@ function bakeWindowClip(
  * (e.g. `pascalSwingLeaf`, cached-material flags) leaks into glTF extras — the
  * file describes itself with exactly the fields a consumer needs.
  */
-/**
- * Human-readable label for a baked node, mirroring the viewer's `getNodeName`:
- * an explicit name wins, items fall back to their catalog asset name, other
- * kinds to a capitalized type. Levels override this with their display name.
- */
-function nodeDisplayLabel(node: AnyNode): string {
-  if (node.name) return node.name
-  switch (node.type) {
-    case 'item':
-      return (node as { asset?: { name?: string } }).asset?.name || 'Item'
-    case 'wall':
-      return 'Wall'
-    case 'door':
-      return 'Door'
-    case 'window':
-      return 'Window'
-    case 'cabinet':
-    case 'cabinet-module':
-      return 'Cabinet'
-    case 'slab':
-      return 'Slab'
-    case 'ceiling':
-      return 'Ceiling'
-    case 'roof':
-      return 'Roof'
-    case 'fence':
-      return 'Fence'
-    case 'column':
-      return 'Column'
-    case 'stair':
-      return 'Stairs'
-    default:
-      return node.type
-  }
-}
-
 function stampIdentity(
   scene: THREE.Object3D,
   cloneByOriginal: Map<THREE.Object3D, THREE.Object3D>,
@@ -1682,8 +1783,43 @@ function stampIdentity(
   scene.traverse((object) => {
     const presentationId = object.userData.pascalPresentationId
     const label = object.userData.label
+    const motion = object.userData.proceduralMotion as
+      | {
+          nodeId: string
+          partId: string
+          groupId: string
+          kind: 'hinge' | 'slide' | 'spin'
+          clip?: string
+          activeWindow?: [number, number]
+        }
+      | undefined
+    const surfaceNodeIds = object.userData.surfaceNodeIds
+    const ifcRole = object.userData.pascalIfcRole
+    const ifcParts = object.userData.pascalIfcParts
+    const slotId = object.userData.slotId
     object.userData =
       typeof presentationId === 'string' ? { pascalPresentationId: presentationId, label } : {}
+    if (
+      Array.isArray(surfaceNodeIds) &&
+      surfaceNodeIds.every((id) => typeof id === 'string' && nodes[id])
+    )
+      object.userData.surfaceNodeIds = surfaceNodeIds
+    if (typeof ifcRole === 'string') object.userData.pascalIfcRole = ifcRole
+    if (Array.isArray(ifcParts) && ifcParts.every(isIfcRolePart))
+      object.userData.pascalIfcParts = ifcParts
+    if (typeof slotId === 'string') object.userData.slotId = slotId
+    if (motion) {
+      object.userData.proceduralMotion = {
+        nodeId: motion.nodeId,
+        partId: motion.partId,
+        groupId: motion.groupId,
+        kind: motion.kind,
+        ...(motion.clip && clipNamesByNode.get(motion.nodeId)?.includes(motion.clip)
+          ? { clip: motion.clip }
+          : {}),
+        ...(motion.activeWindow ? { activeWindow: motion.activeWindow } : {}),
+      }
+    }
   })
 
   for (const [id, original] of registryEntries) {
@@ -1708,21 +1844,15 @@ function stampIdentity(
       extras.label = getLevelDisplayName(node as LevelNode)
       target.visible = true
     }
-    // Only nodes that actually baked an open clip are openable. A cased opening
-    // (no leaf), fixed window, or static cabinet produces no clip, so it stays
-    // unflagged — the file never claims a part opens when nothing moves.
-    if (clipNamesByNode.get(id)?.some((name) => name.endsWith(': open'))) {
-      const clipNames = clipNamesByNode.get(id)
-      if (clipNames?.length) {
-        extras.openable = true
-        extras.clips = clipNames
-      }
-    }
-    // Items with a baked ambient clip (a fan's spin) carry the clip name but no
-    // `openable` flag — nothing opens; the clip just loops.
-    if (node.type === 'item') {
-      const clipNames = clipNamesByNode.get(id)
-      if (clipNames?.length) extras.clips = clipNames
+    // Every node that baked clips lists them, whatever its kind, so the viewer
+    // can play them. Only nodes that actually baked an open clip are openable. A
+    // cased opening (no leaf), fixed window, or static cabinet produces no clip,
+    // so it stays unflagged — the file never claims a part opens when nothing
+    // moves; an ambient loop (a fan's spin) is listed without the flag.
+    const clipNames = clipNamesByNode.get(id)
+    if (clipNames?.length) {
+      if (clipNames.some((name) => name.endsWith(': open'))) extras.openable = true
+      extras.clips = clipNames
     }
     if (node.type === 'zone') {
       // Zone fills are stripped from the bake; /viewer rebuilds the room from
@@ -1730,6 +1860,7 @@ function stampIdentity(
       // `onlyVisible` keeps it even when the editor had zones hidden at export.
       const zone = node as ZoneNode
       extras.polygon = zone.polygon
+      if (zone.holes?.length) extras.holes = zone.holes
       extras.color = zone.color
       target.visible = true
     }
@@ -1741,6 +1872,6 @@ function stampIdentity(
       extras.rotation = (node as { rotation?: number }).rotation ?? 0
       target.visible = true
     }
-    target.userData = extras
+    target.userData = { ...target.userData, ...extras }
   }
 }

package/src/lib/grid-frame.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from 'bun:test'
+import { Group, Vector3 } from 'three'
+import { gridLocalNormal, gridLocalPoint } from './grid-frame'
+
+test('grid floor and cursor stay in model coordinates after God-view pan, scale and yaw', () => {
+  const root = new Group()
+  root.position.set(2, 4, -3)
+  root.rotation.y = Math.PI / 3
+  root.scale.setScalar(0.2)
+  root.updateMatrixWorld(true)
+  const local = new Vector3(3, 2.5, 7)
+  const world = root.localToWorld(local.clone())
+  expect(gridLocalPoint(root, world, new Vector3()).distanceTo(local)).toBeLessThan(1e-8)
+  const normal = new Vector3(1, 0, 0).transformDirection(root.matrixWorld)
+  expect(
+    gridLocalNormal(root, normal, new Vector3()).distanceTo(new Vector3(1, 0, 0)),
+  ).toBeLessThan(1e-8)
+  expect(world.distanceTo(local)).toBeGreaterThan(1)
+})

package/src/lib/grid-frame.ts

@@ -0,0 +1,18 @@
+import type { Object3D, Vector3 } from 'three'
+
+// Placement surfaces are world-space; the grid lives under the scalable XR
+// scene root. Keep its lattice and reveal in that root's model coordinates.
+export function gridLocalPoint(parent: Object3D | null, world: Vector3, target: Vector3) {
+  target.copy(world)
+  if (parent) {
+    parent.updateWorldMatrix(true, false)
+    parent.worldToLocal(target)
+  }
+  return target
+}
+
+export function gridLocalNormal(parent: Object3D | null, normal: Vector3, target: Vector3) {
+  target.copy(normal)
+  if (parent) target.transformDirection(parent.matrixWorld.clone().invert())
+  return target
+}

package/src/lib/history.test.ts

@@ -217,6 +217,9 @@ describe('standalone history source invalidation', () => {
       const { Group, Mesh, MeshBasicMaterial, BoxGeometry } = await importShared('three')
       const viewer = await importShared('@pascal-app/viewer')
       const { captureChangedNodes, runBatchFrame, resetNodeBatchState } = await import(${JSON.stringify(resolve(import.meta.dir, '../../../nodes/src/shared/node-batch/system.tsx'))})
+      // The node batch reads each kind's \`capabilities.batchable\` from the registry.
+      const { doorBatchable } = await import(${JSON.stringify(resolve(import.meta.dir, '../../../nodes/src/shared/node-batch/batchable.ts'))})
+      core.nodeRegistry._register({ kind: 'door', schemaVersion: 1, capabilities: { batchable: doorBatchable } })
       const root = new Group()
       core.sceneRegistry.nodes.set(level.id, root)
       core.sceneRegistry.byType.level.add(level.id)
@@ -260,6 +263,9 @@ describe('standalone history source invalidation', () => {
       const { Group, Mesh, MeshBasicMaterial, BoxGeometry } = await importShared('three')
       const viewer = await importShared('@pascal-app/viewer')
       const { captureChangedNodes, runBatchFrame, resetNodeBatchState } = await import(${JSON.stringify(resolve(import.meta.dir, '../../../nodes/src/shared/node-batch/system.tsx'))})
+      // The node batch reads each kind's \`capabilities.batchable\` from the registry.
+      const { doorBatchable } = await import(${JSON.stringify(resolve(import.meta.dir, '../../../nodes/src/shared/node-batch/batchable.ts'))})
+      core.nodeRegistry._register({ kind: 'door', schemaVersion: 1, capabilities: { batchable: doorBatchable } })
       const root = new Group()
       core.sceneRegistry.nodes.set(level.id, root)
       core.sceneRegistry.byType.level.add(level.id)

package/src/lib/history.ts

@@ -9,6 +9,7 @@ import {
 } from '@pascal-app/core'
 import { markPerfAction } from '@pascal-app/viewer'
 import useInteractionScope from '../store/use-interaction-scope'
+import { cancelGestures } from './gesture-lifecycle'
 import { registeredDraftingConfig } from './interaction/registered-drafting'
 
 export type HistoryCommandState = {
@@ -130,6 +131,9 @@ export function shouldCancelDraftOnHistoryJump(): boolean {
 }
 
 export function runUndo(): HistoryCommandResult {
+  // A history jump under a live gesture would land on its paused baseline;
+  // every history command, not only the keyboard's, ends it first.
+  cancelGestures('history')
   if (shouldCancelDraftOnHistoryJump()) emitter.emit('tool:cancel')
   if (historyCommandDelegate) {
     const result = historyCommandDelegate.undo()
@@ -147,6 +151,9 @@ export function runUndo(): HistoryCommandResult {
 }
 
 export function runRedo(): HistoryCommandResult {
+  // A history jump under a live gesture would land on its paused baseline;
+  // every history command, not only the keyboard's, ends it first.
+  cancelGestures('history')
   if (shouldCancelDraftOnHistoryJump()) emitter.emit('tool:cancel')
   if (historyCommandDelegate) {
     const result = historyCommandDelegate.redo()