@pascal-app/editor 1.0.1 → 1.0.3

package/src/lib/fresh-planar-placement.ts

@@ -3,14 +3,22 @@ import {
   type AnyNodeId,
   cloneNodesInto,
   collectSubtree,
+  createSceneApi,
   type DuplicableConfig,
+  getSurfaceProvider,
   nodeRegistry,
+  resolveSurfacePlacement,
+  type SurfaceRejectReason,
   useScene,
 } from '@pascal-app/core'
+import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
+import useInteractionScope from '../store/use-interaction-scope'
+import usePlacementPreview from '../store/use-placement-preview'
 import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
 import {
   surfaceAttachmentId,
   surfaceAttachmentUpdates,
+  surfaceFramePose,
   updateSurfaceNode,
 } from './surface-attachment'
 
@@ -32,7 +40,13 @@ function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
 }
 
 export function duplicatesAsFreshSubtree(node: AnyNode): boolean {
-  return duplicableConfigFor(node)?.subtree === true
+  // A surface-local root needs the same attachment lifecycle even without descendants.
+  if (surfaceAttachmentId(node) !== null) return true
+  const policy = duplicableConfigFor(node)?.subtree
+  return (
+    policy === true ||
+    (policy === 'with-children' && 'children' in node && node.children.length > 0)
+  )
 }
 
 /**
@@ -99,57 +113,175 @@ export function createFreshPlacementSubtree(
     parentId,
   })
 
-  useScene
-    .getState()
-    .createNodes(
-      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
-    )
+  scene.applyNodeChanges({
+    create: cloned.nodes.map((node, index) =>
+      index === 0 && parentId ? { node, parentId } : { node },
+    ),
+    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceAttachmentId(subtree.root)),
+  })
 
+  const created = useScene.getState().nodes[cloned.rootId]
+  if (!created) return null
+  useInteractionScope.getState().noteSubtreeCreation(created)
   return cloned.rootId
 }
 
+export function discardFreshPlacementSubtree(rootId: AnyNodeId): void {
+  const scene = useScene.getState()
+  if (!scene.nodes[rootId]) return
+  scene.applyNodeChanges({
+    delete: [rootId],
+    update: surfaceAttachmentUpdates(rootId, null, null),
+  })
+}
+
+function namedSurfaceRejection(
+  root: AnyNode,
+  surfaceId: string | null,
+): SurfaceRejectReason | null {
+  if (surfaceId === null) return null
+  const scene = createSceneApi(useScene)
+  const host = root.parentId ? scene.get(root.parentId as AnyNodeId) : undefined
+  if (!host || !('position' in root) || !Array.isArray(root.rotation)) return 'no-surface'
+  const surface = getSurfaceProvider(host)
+    .surfaces?.(host, { scene })
+    .find((s) => s.id === surfaceId)
+  if (!surface) return 'no-surface'
+  const pose = surfaceFramePose(
+    root.parentId,
+    surfaceId,
+    root as {
+      position: [number, number, number]
+      rotation: [number, number, number]
+    },
+    false,
+  )
+  const capabilities = nodeRegistry.get(root.type)?.capabilities
+  const evaluated = isProceduralItem(root) ? evaluateRecipe(root.recipe, root.parameters) : null
+  const bounds =
+    capabilities?.dragBounds?.(root, scene.nodes()) ??
+    (evaluated
+      ? {
+          size: evaluated.dimensions,
+          center: evaluated.min.map((v, i) => (v + evaluated.max[i]!) / 2) as [
+            number,
+            number,
+            number,
+          ],
+        }
+      : undefined)
+  const size = bounds?.size ??
+    capabilities?.floorPlaced?.footprint?.(root, { nodes: scene.nodes() }).dimensions ?? [0, 0, 0]
+  const center = bounds?.center
+  const localBounds = center
+    ? {
+        min: center.map((value, axis) => value - size[axis]! / 2) as [number, number, number],
+        max: center.map((value, axis) => value + size[axis]! / 2) as [number, number, number],
+      }
+    : undefined
+  let reason: SurfaceRejectReason | null = null
+  const placement = resolveSurfacePlacement({
+    host,
+    surface,
+    childKind: root.type,
+    childId: root.id,
+    childFootprint: {
+      size,
+      rotationY: pose.rotation[1],
+      rotation: pose.rotation,
+      localBounds,
+    },
+    hit: { point: pose.position, normalWorldY: 1 },
+    origin: pose.position,
+    scene,
+    onReject: (value) => {
+      reason = value
+    },
+  })
+  if (!placement) return reason ?? 'no-surface'
+  return null
+}
+
 /**
- * Finalises a fresh catalog/duplicate draft as a single undoable creation.
- *
- * Fresh drafts already exist in the scene so renderers and move tools can
- * preview real geometry. On commit we delete that draft while history is
- * paused, then create a clean clone at the final cursor position with history
- * resumed. Undo therefore removes the placed node instead of resurrecting the
- * hidden draft at its origin.
+ * Replace the draft in one validated write. History already excludes fresh
+ * subtrees, so this records one creation without first deleting the preview.
  */
 export function commitFreshPlacementSubtree(
   rootId: AnyNodeId,
   rootPatch: Partial<AnyNode>,
+  onReject?: (reason: SurfaceRejectReason) => void,
 ): AnyNodeId | null {
   const scene = useScene.getState()
   const subtree = collectSubtree(scene.nodes, rootId)
-  if (!subtree) return null
+  if (!subtree || scene.readOnly) return null
 
-  const root = cleanPlacementMetadata({
-    ...subtree.root,
-    ...rootPatch,
-  } as AnyNode)
+  const root = cleanPlacementMetadata({ ...subtree.root, ...rootPatch } as AnyNode)
+  const surfaceId =
+    root.parentId === subtree.root.parentId ? surfaceAttachmentId(subtree.root) : null
+  const rejection = namedSurfaceRejection(root, surfaceId)
+  if (rejection) {
+    onReject?.(rejection)
+    return null
+  }
   const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
   const parentId = parentIdOf(root)
-  const cloned = cloneNodesInto([root, ...descendants], {
-    rootId,
-    parentId,
-  })
+  const cloned = cloneNodesInto([root, ...descendants], { rootId, parentId })
+  const updates = surfaceAttachmentUpdates(rootId, null, null)
+  for (const update of surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId)) {
+    const attachments = { ...(update.data as { attachments: Record<string, string> }).attachments }
+    delete attachments[rootId]
+    const previous = updates.findIndex((entry) => entry.id === update.id)
+    const merged = { id: update.id, data: { attachments } }
+    if (previous === -1) updates.push(merged)
+    else updates[previous] = merged
+  }
 
-  const surfaceId = surfaceAttachmentId(subtree.root)
+  const scope = useInteractionScope.getState()
+  const factoryCreated =
+    scope.ownedSubtree?.creation.rootId === rootId || scope.pendingSubtree?.rootId === rootId
   const temporal = useScene.temporal.getState()
-  const wasTracking = (temporal as { isTracking?: boolean }).isTracking !== false
-  if (wasTracking) temporal.pause()
-  updateSurfaceNode(rootId, {}, null)
-  useScene.getState().deleteNode(rootId)
-  temporal.resume()
-  useScene.getState().applyNodeChanges({
-    create: cloned.nodes.map((node, index) =>
-      index === 0 && parentId ? { node, parentId } : { node },
-    ),
-    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId),
-  })
-  if (!wasTracking) temporal.pause()
-
+  const wasTracking = temporal.isTracking
+  if (!factoryCreated && descendants.length === 0 && surfaceId === null) {
+    // Preserve the established root-only lifecycle for placements outside the subtree factory.
+    if (wasTracking) temporal.pause()
+    updateSurfaceNode(rootId, {}, null)
+    useScene.getState().deleteNode(rootId)
+    temporal.resume()
+    useScene.getState().applyNodeChanges({
+      create: cloned.nodes.map((node, index) =>
+        index === 0 && parentId ? { node, parentId } : { node },
+      ),
+      update: updates,
+    })
+    if (!wasTracking) temporal.pause()
+  } else {
+    temporal.resume()
+    try {
+      // applyNodeChanges validates the complete proposed graph before publishing any part of it.
+      scene.applyNodeChanges({
+        delete: [rootId],
+        create: cloned.nodes.map((node, index) =>
+          index === 0 && parentId ? { node, parentId } : { node },
+        ),
+        update: updates,
+      })
+      for (const node of [subtree.root, ...subtree.descendants]) scene.clearDirty(node.id)
+    } catch (error) {
+      // Zustand publishes before notifying subscribers. A subscriber error must restore
+      // the draft and its ownership/history, never masquerade as a placement refusal.
+      temporal.pause()
+      try {
+        if (useScene.getState() !== scene) useScene.setState(scene, true)
+      } finally {
+        useInteractionScope.setState(scope)
+        useScene.temporal.setState(temporal)
+      }
+      throw error
+    } finally {
+      if (!wasTracking) temporal.pause()
+    }
+  }
+  useInteractionScope.getState().finishSubtree(rootId)
+  if (usePlacementPreview.getState().node?.id === rootId) usePlacementPreview.getState().clear()
   return cloned.rootId
 }

package/src/lib/glb-export.test.ts

@@ -590,19 +590,64 @@ describe('prepareSceneForExport', () => {
     expect(animations).toHaveLength(0)
   })
 
-  test('inherits hidden Site visibility for detached declared children and their descendants', async () => {
+  test('keeps the buildings on a hidden Site and drops only the Site ground', () => {
+    // A layout authored outside the editor can hide the root Site (the
+    // renderer ignores that flag) while every node on it stays visible. The
+    // Site's own flag must stop at the Site: it is the parcel reference, not
+    // a container the building inherits visibility from.
+    const root = new THREE.Group()
+    const siteGroup = new THREE.Group()
+    const siteGround = meshWithNodeMaterial(nodeMaterial())
+    const buildingGroup = new THREE.Group()
+    const levelGroup = new THREE.Group()
+    const itemGroup = new THREE.Group()
+    itemGroup.add(meshWithNodeMaterial(nodeMaterial()))
+    levelGroup.add(itemGroup)
+    buildingGroup.add(levelGroup)
+    siteGroup.add(buildingGroup, siteGround)
+    root.add(siteGroup)
+
+    const siteId = 'site_hidden'
+    const buildingId = 'building_on_hidden_site'
+    const levelId = 'level_on_hidden_site'
+    const itemId = 'item_on_hidden_site'
+    sceneRegistry.nodes.set(siteId, siteGroup)
+    sceneRegistry.nodes.set(buildingId, buildingGroup)
+    sceneRegistry.nodes.set(levelId, levelGroup)
+    sceneRegistry.nodes.set(itemId, itemGroup)
+    const node = (id: string, type: string, parentId: string | null, visible: boolean) =>
+      ({ object: 'node', id, type, parentId, visible }) as unknown as AnyNode
+    const nodes: Record<string, AnyNode> = {
+      [siteId]: node(siteId, 'site', null, false),
+      [buildingId]: node(buildingId, 'building', siteId, true),
+      [levelId]: node(levelId, 'level', buildingId, true),
+      [itemId]: node(itemId, 'item', levelId, true),
+    }
+
+    const { scene } = prepareSceneForExport(root, nodes)
+
+    const meshes: THREE.Mesh[] = []
+    scene.traverse((object) => {
+      if ((object as THREE.Mesh).isMesh) meshes.push(object as THREE.Mesh)
+    })
+    expect(scene.getObjectByName(buildingId)).toBeDefined()
+    expect(scene.getObjectByName(itemId)).toBeDefined()
+    expect(meshes).toHaveLength(1)
+    expect(meshes[0]?.parent?.name).toBe(itemId)
+  })
+
+  test('keeps the nodes a hidden Site hosts, declared or detached, unless hidden themselves', async () => {
     const restoreRegistry = nodeRegistry._snapshot()
     try {
-      const kind = 'test:detached-site-visibility'
+      const kind = 'test:hidden-site-host'
       const childId = 'detached_site_child'
       const descendantId = 'detached_site_descendant'
       const explicitId = 'explicit_site_child'
-      const unownedId = 'unowned_site_child'
+      const hiddenChildId = 'hidden_site_child'
       const hiddenSite = SiteNode.parse({
         visible: false,
-        children: [childId, explicitId],
+        children: [childId, explicitId, hiddenChildId],
       })
-      const visibleSite = SiteNode.parse({ visible: true })
       registerNode({
         kind,
         schemaVersion: 1,
@@ -615,17 +660,19 @@ describe('prepareSceneForExport', () => {
       } as AnyNodeDefinition)
       const nodes = {
         [hiddenSite.id]: hiddenSite,
-        [visibleSite.id]: visibleSite,
         [childId]: { id: childId, type: kind, parentId: null, visible: true },
         [descendantId]: { id: descendantId, type: kind, parentId: childId, visible: true },
-        [explicitId]: { id: explicitId, type: kind, parentId: visibleSite.id, visible: true },
-        [unownedId]: { id: unownedId, type: kind, parentId: null, visible: true },
+        [explicitId]: { id: explicitId, type: kind, parentId: hiddenSite.id, visible: true },
+        [hiddenChildId]: { id: hiddenChildId, type: kind, parentId: hiddenSite.id, visible: false },
       } as unknown as Record<string, AnyNode>
-      const allIds = [childId, descendantId, explicitId, unownedId]
+      const allIds = [childId, descendantId, explicitId, hiddenChildId]
       const root = new THREE.Group()
-      for (const id of [hiddenSite.id, visibleSite.id, ...allIds]) {
+      const siteObject = new THREE.Group()
+      root.add(siteObject)
+      sceneRegistry.nodes.set(hiddenSite.id, siteObject)
+      for (const id of allIds) {
         const object = new THREE.Group()
-        root.add(object)
+        siteObject.add(object)
         sceneRegistry.nodes.set(id, object)
       }
       const exportedIds = async (onlyVisible?: boolean) => {
@@ -637,12 +684,8 @@ describe('prepareSceneForExport', () => {
         }
       }
 
-      expect(await exportedIds()).toEqual([explicitId, unownedId])
+      expect(await exportedIds()).toEqual([childId, descendantId, explicitId])
       expect(await exportedIds(false)).toEqual(allIds)
-      nodes[hiddenSite.id] = { ...hiddenSite, visible: true }
-      expect(await exportedIds()).toEqual(allIds)
-      nodes[hiddenSite.id] = hiddenSite
-      expect(await exportedIds()).toEqual([explicitId, unownedId])
     } finally {
       restoreRegistry()
     }

package/src/lib/glb-export.ts

@@ -7,6 +7,7 @@ import {
   findLevelAncestorId,
   type GeometryContext,
   getLevelDisplayName,
+  hidesDescendants,
   isNodeKindEnabled,
   isOperationDoorType,
   itemClipRegistry,
@@ -715,16 +716,6 @@ function pruneHiddenSceneNodes(
   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 = (id: string, path: Set<string>): boolean => {
     const cached = visibility.get(id)
@@ -736,8 +727,9 @@ function pruneHiddenSceneNodes(
       visibility.set(id, false)
       return false
     }
-    const parentId = node.parentId || declaredSiteParents.get(id)
-    if (!parentId || path.has(id)) {
+    const parentId = node.parentId
+    const parent = parentId ? nodes[parentId] : undefined
+    if (!parentId || path.has(id) || (parent && !hidesDescendants(parent))) {
       visibility.set(id, true)
       return true
     }
@@ -749,12 +741,33 @@ function pruneHiddenSceneNodes(
     return visible
   }
 
+  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, new Set())) continue
-    cloneByOriginal.get(original)?.removeFromParent()
+    const clone = cloneByOriginal.get(original)
+    if (!clone) continue
+    const node = nodes[id]
+    if (!node || hidesDescendants(node)) {
+      clone.removeFromParent()
+      continue
+    }
+    // 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()
+    }
   }
 }
 
+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(
   root: THREE.Object3D,
   cloneByOriginal: Map<THREE.Object3D, THREE.Object3D>,

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/interaction/scope.ts

@@ -19,7 +19,15 @@ export type ReshapeDriver = 'tool' | 'floorplan'
 // node, one in-flight reshape. Grouping them as sub-states of `reshaping`
 // (rather than four sibling scopes) keeps the union small while still making
 // "curving and hole-editing at once" unrepresentable.
-export type ReshapeKind = 'curve' | 'hole' | 'endpoint' | 'boundary' | 'control-point' | 'tangent'
+export type ReshapeKind =
+  | 'curve'
+  | 'hole'
+  | 'endpoint'
+  | 'boundary'
+  | 'control-point'
+  | 'tangent'
+  // A kind's own reshape (wall 'split'): mounted from `def.affordanceTools[reshape]`.
+  | 'split'
 
 export type InteractionScope =
   | { kind: 'idle' }

package/src/lib/keyboard-pan.test.ts

@@ -0,0 +1,62 @@
+import { afterAll, beforeAll, expect, test } from 'bun:test'
+import {
+  acceptsKeyboardPan,
+  clearKeyboardPanKeys,
+  hasKeyboardPanInput,
+  isKeyboardPanKey,
+  type KeyboardPanState,
+  keyboardPanDirection,
+  keyboardPanSpeed,
+  setKeyboardPanKey,
+} from './keyboard-pan'
+
+const idle = (): KeyboardPanState => ({
+  forward: false,
+  backward: false,
+  left: false,
+  right: false,
+})
+const key = (init: Partial<KeyboardEvent>) => ({ target: null, ...init }) as KeyboardEvent
+
+// No DOM in this runner: stand in for the element classes the editable check reads.
+const DOM_CLASSES = ['HTMLElement', 'HTMLInputElement', 'HTMLTextAreaElement', 'HTMLSelectElement']
+const stubbed: string[] = []
+beforeAll(() => {
+  const scope = globalThis as Record<string, unknown>
+  for (const name of DOM_CLASSES) {
+    if (scope[name]) continue
+    scope[name] = class {}
+    stubbed.push(name)
+  }
+})
+afterAll(() => {
+  for (const name of stubbed) delete (globalThis as Record<string, unknown>)[name]
+})
+
+test('physical WASD keys drive a screen-space direction; letters on other layouts do not', () => {
+  const state = idle()
+  expect(isKeyboardPanKey('KeyZ')).toBe(false)
+  expect(setKeyboardPanKey(state, 'KeyW', true)).toBe(true)
+  expect(setKeyboardPanKey(state, 'KeyW', true)).toBe(false)
+  setKeyboardPanKey(state, 'KeyD', true)
+  expect(keyboardPanDirection(state)).toEqual({ horizontal: 1, vertical: 1 })
+  setKeyboardPanKey(state, 'KeyA', true)
+  expect(keyboardPanDirection(state)).toEqual({ horizontal: 0, vertical: 1 })
+  clearKeyboardPanKeys(state)
+  expect(hasKeyboardPanInput(state)).toBe(false)
+})
+
+test('modifier chords stay shortcuts, and typing in a field never pans', () => {
+  expect(acceptsKeyboardPan(key({}))).toBe(true)
+  for (const modifier of ['metaKey', 'ctrlKey', 'altKey'] as const)
+    expect(acceptsKeyboardPan(key({ [modifier]: true }))).toBe(false)
+  const Input = (globalThis as unknown as { HTMLInputElement: new () => EventTarget })
+    .HTMLInputElement
+  expect(acceptsKeyboardPan(key({ target: new Input() }))).toBe(false)
+})
+
+test('speed scales with the visible width within fixed bounds', () => {
+  expect(keyboardPanSpeed(0)).toBe(2)
+  expect(keyboardPanSpeed(20)).toBeCloseTo(13)
+  expect(keyboardPanSpeed(1000)).toBe(55)
+})

package/src/lib/keyboard-pan.ts

@@ -0,0 +1,89 @@
+// WASD navigation shared by the 3D camera and the 2D floor plan, so both views
+// move the same way. Keys match by physical position (`event.code`): the
+// cluster stays under the left hand on any layout (Z/Q/S/D on AZERTY).
+
+export type KeyboardPanState = {
+  forward: boolean
+  backward: boolean
+  left: boolean
+  right: boolean
+}
+
+const KEYBOARD_PAN_VIEW_WIDTH_PER_SECOND = 0.65
+const KEYBOARD_PAN_MIN_SPEED = 2
+const KEYBOARD_PAN_MAX_SPEED = 55
+
+export function isEditableKeyboardTarget(target: EventTarget | null) {
+  return (
+    target instanceof HTMLInputElement ||
+    target instanceof HTMLTextAreaElement ||
+    target instanceof HTMLSelectElement ||
+    (target instanceof HTMLElement && target.isContentEditable)
+  )
+}
+
+export function setKeyboardPanKey(
+  state: KeyboardPanState,
+  code: string,
+  pressed: boolean,
+): boolean {
+  if (code === 'KeyW') {
+    const changed = state.forward !== pressed
+    state.forward = pressed
+    return changed
+  }
+  if (code === 'KeyS') {
+    const changed = state.backward !== pressed
+    state.backward = pressed
+    return changed
+  }
+  if (code === 'KeyA') {
+    const changed = state.left !== pressed
+    state.left = pressed
+    return changed
+  }
+  if (code === 'KeyD') {
+    const changed = state.right !== pressed
+    state.right = pressed
+    return changed
+  }
+  return false
+}
+
+export function isKeyboardPanKey(code: string): boolean {
+  return code === 'KeyW' || code === 'KeyA' || code === 'KeyS' || code === 'KeyD'
+}
+
+export function hasKeyboardPanInput(state: KeyboardPanState): boolean {
+  return state.forward || state.backward || state.left || state.right
+}
+
+export function clearKeyboardPanKeys(state: KeyboardPanState) {
+  state.forward = false
+  state.backward = false
+  state.left = false
+  state.right = false
+}
+
+/** Pan keys are ignored with a modifier held (shortcuts) or while typing. */
+export function acceptsKeyboardPan(event: KeyboardEvent) {
+  return (
+    !(event.metaKey || event.ctrlKey || event.altKey) && !isEditableKeyboardTarget(event.target)
+  )
+}
+
+/** Screen-space direction: `horizontal` +1 is right, `vertical` +1 is forward (up). */
+export function keyboardPanDirection(state: KeyboardPanState) {
+  return {
+    horizontal: (state.right ? 1 : 0) - (state.left ? 1 : 0),
+    vertical: (state.forward ? 1 : 0) - (state.backward ? 1 : 0),
+  }
+}
+
+/** World units per second for a view `viewWidth` wide. */
+export function keyboardPanSpeed(viewWidth: number) {
+  return Math.min(
+    Math.max(viewWidth * KEYBOARD_PAN_VIEW_WIDTH_PER_SECOND, KEYBOARD_PAN_MIN_SPEED),
+    KEYBOARD_PAN_MAX_SPEED,
+  )
+}