@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/history.ts

@@ -19,3 +19,12 @@ export function runRedo() {
   useScene.temporal.getState().redo()
   refreshSceneAfterHistoryJump()
 }
+
+/**
+ * ⌘Z / ⌘⇧Z (undo/redo). Pointer-drag sessions intercept these in the capture
+ * phase and cancel the gesture instead — mid-drag, "undo" means "abort what my
+ * mouse is doing", never a history jump under a live pointer.
+ */
+export function isHistoryShortcut(e: KeyboardEvent) {
+  return (e.metaKey || e.ctrlKey) && (e.key === 'z' || e.key === 'Z')
+}

package/src/lib/interaction/hot-set.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import {
+  type AttachClass,
+  attachClassOf,
+  type HotSetCandidate,
+  isCandidateInHotSet,
+  isPickableForAttach,
+} from './hot-set'
+
+const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknown as AnyNode
+
+const floor: HotSetCandidate = {
+  type: 'level',
+  isFloorLike: true,
+  exposesTop: false,
+  attachClass: 'surface',
+}
+const wall: HotSetCandidate = {
+  type: 'wall',
+  isFloorLike: false,
+  exposesTop: false,
+  attachClass: 'surface',
+}
+const ceiling: HotSetCandidate = {
+  type: 'ceiling',
+  isFloorLike: false,
+  exposesTop: false,
+  attachClass: 'surface',
+}
+const table: HotSetCandidate = {
+  type: 'item',
+  isFloorLike: false,
+  exposesTop: true,
+  attachClass: 'surface',
+}
+const wallShelf: HotSetCandidate = {
+  type: 'shelf',
+  isFloorLike: false,
+  exposesTop: true,
+  attachClass: 'wall',
+}
+const ceilingFan: HotSetCandidate = {
+  type: 'item',
+  isFloorLike: false,
+  exposesTop: true,
+  attachClass: 'ceiling',
+}
+
+describe('attachClassOf', () => {
+  test('wall and wall-side collapse to wall', () => {
+    expect(attachClassOf('wall')).toBe('wall')
+    expect(attachClassOf('wall-side')).toBe('wall')
+  })
+  test('ceiling maps to ceiling', () => {
+    expect(attachClassOf('ceiling')).toBe('ceiling')
+  })
+  test('undefined/null/unknown is surface-resting', () => {
+    expect(attachClassOf(undefined)).toBe('surface')
+    expect(attachClassOf(null)).toBe('surface')
+    expect(attachClassOf('')).toBe('surface')
+  })
+})
+
+describe('isPickableForAttach — wall-mounted (window)', () => {
+  test('only walls are eligible; floor/ceiling/tops are not', () => {
+    expect(isPickableForAttach('wall', wall)).toBe(true)
+    expect(isPickableForAttach('wall', floor)).toBe(false)
+    expect(isPickableForAttach('wall', ceiling)).toBe(false)
+    expect(isPickableForAttach('wall', table)).toBe(false)
+    expect(isPickableForAttach('wall', wallShelf)).toBe(false)
+  })
+})
+
+describe('isPickableForAttach — ceiling-mounted', () => {
+  test('only ceilings are eligible', () => {
+    expect(isPickableForAttach('ceiling', ceiling)).toBe(true)
+    expect(isPickableForAttach('ceiling', wall)).toBe(false)
+    expect(isPickableForAttach('ceiling', floor)).toBe(false)
+  })
+})
+
+describe('isPickableForAttach — surface-resting (sofa / cactus)', () => {
+  test('floor is always eligible', () => {
+    expect(isPickableForAttach('surface', floor)).toBe(true)
+  })
+  test('host tops (table, wall-shelf top) are eligible', () => {
+    expect(isPickableForAttach('surface', table)).toBe(true)
+    expect(isPickableForAttach('surface', wallShelf)).toBe(true)
+  })
+  test('a wall (no top surface) is not eligible', () => {
+    expect(isPickableForAttach('surface', wall)).toBe(false)
+  })
+  test('a ceiling-mounted host (ceiling fan) is never eligible — Track E', () => {
+    expect(isPickableForAttach('surface', ceilingFan)).toBe(false)
+  })
+})
+
+describe('isCandidateInHotSet — by scope', () => {
+  const surfaceClass: AttachClass = 'surface'
+  test('idle: everything is in the hot-set (selection filtering lives elsewhere)', () => {
+    expect(isCandidateInHotSet({ kind: 'idle' }, null, ceilingFan)).toBe(true)
+  })
+  test('placing a surface item: derives from attach class', () => {
+    const scope = {
+      kind: 'placing' as const,
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d' as const,
+      pressDrag: false,
+    }
+    expect(isCandidateInHotSet(scope, surfaceClass, floor)).toBe(true)
+    expect(isCandidateInHotSet(scope, surfaceClass, ceilingFan)).toBe(false)
+  })
+  test('moving a wall-mounted item: only walls', () => {
+    const scope = {
+      kind: 'moving' as const,
+      node: mockNode('w1', 'window'),
+      nodeId: 'w1',
+      nodeType: 'window',
+      view: '2d' as const,
+    }
+    expect(isCandidateInHotSet(scope, 'wall', wall)).toBe(true)
+    expect(isCandidateInHotSet(scope, 'wall', table)).toBe(false)
+  })
+  test('non-placement active scopes target nothing in the scene', () => {
+    expect(isCandidateInHotSet({ kind: 'box-select' }, null, floor)).toBe(false)
+    expect(
+      isCandidateInHotSet({ kind: 'handle-drag', nodeId: 'x', handle: 'h' }, null, floor),
+    ).toBe(false)
+  })
+})

package/src/lib/interaction/hot-set.ts

@@ -0,0 +1,67 @@
+// The hot-set: which scene objects are raycast-eligible during an interaction.
+//
+// It is never hand-authored per interaction. It falls out of the node's
+// `asset.attachTo` plus whether a candidate exposes a top surface. "Floor item"
+// really means surface-resting: it rests on the floor *or* any host's top
+// surface. Walls and ceilings are the special attach modes. Adding a node kind
+// = set `attachTo` (or leave blank); the hot-set follows with zero per-kind
+// wiring.
+
+import type { InteractionScope } from './scope'
+
+// What a node attaches to, collapsed to the three classes the hot-set cares
+// about. `wall-side` is a wall attachment; everything without an explicit
+// `attachTo` is surface-resting.
+export type AttachClass = 'wall' | 'ceiling' | 'surface'
+
+export function attachClassOf(attachTo: string | undefined | null): AttachClass {
+  if (attachTo === 'wall' || attachTo === 'wall-side') return 'wall'
+  if (attachTo === 'ceiling') return 'ceiling'
+  return 'surface'
+}
+
+// The metadata the hot-set needs about a candidate host/surface. Derived from
+// the candidate node + its registry definition by the caller, so this module
+// stays pure and unit-testable without the scene or registry.
+export type HotSetCandidate = {
+  type: string
+  // The level floor plane / ground a surface-resting node can always rest on.
+  isFloorLike: boolean
+  // The candidate exposes a usable top surface (registry
+  // `capabilities.surfaces.top`) — a table, a shelf, a slab.
+  exposesTop: boolean
+  // The candidate's own attach class. A ceiling fan is `ceiling`: it hangs from
+  // the ceiling and must never act as a host top (Track E).
+  attachClass: AttachClass
+}
+
+// For a node whose attach class is `placed`, is `candidate` a valid
+// host/surface to pick during placement or move?
+export function isPickableForAttach(placed: AttachClass, candidate: HotSetCandidate): boolean {
+  if (placed === 'wall') return candidate.type === 'wall'
+  if (placed === 'ceiling') return candidate.type === 'ceiling'
+  // Surface-resting: the floor, or any host that exposes a top surface — but
+  // never a ceiling-mounted host (a floor lamp must not land on a ceiling fan).
+  if (candidate.isFloorLike) return true
+  if (!candidate.exposesTop) return false
+  if (candidate.attachClass === 'ceiling') return false
+  return true
+}
+
+// The hot-set predicate for a whole scope. For placing/moving it derives from
+// the moving node's attach class; for every other active scope nothing in the
+// scene is a placement target, so the body's own raycast owns the pointer.
+// `idle` returns true here — selection/phase filtering stays in the selection
+// manager; this only narrows what an *active* interaction can target.
+export function isCandidateInHotSet(
+  scope: InteractionScope,
+  placedAttachClass: AttachClass | null,
+  candidate: HotSetCandidate,
+): boolean {
+  if (scope.kind === 'idle') return true
+  if (scope.kind === 'placing' || scope.kind === 'moving') {
+    if (placedAttachClass === null) return true
+    return isPickableForAttach(placedAttachClass, candidate)
+  }
+  return false
+}

package/src/lib/interaction/overlay-policy.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import { resolveOverlayPolicy } from './overlay-policy'
+import type { ActiveInteractionScope } from './scope'
+
+const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknown as AnyNode
+
+const ACTIVE_SCOPES: ActiveInteractionScope[] = [
+  {
+    kind: 'placing',
+    node: mockNode('i1', 'item'),
+    nodeId: 'i1',
+    nodeType: 'item',
+    view: '3d',
+    pressDrag: false,
+  },
+  { kind: 'moving', node: mockNode('i1', 'item'), nodeId: 'i1', nodeType: 'item', view: '2d' },
+  { kind: 'handle-drag', nodeId: 'w1', handle: 'height' },
+  { kind: 'drafting', tool: 'wall' },
+  { kind: 'reshaping', nodeId: 's1', reshape: 'hole', holeIndex: 0 },
+  { kind: 'box-select' },
+  { kind: 'painting' },
+]
+
+describe('resolveOverlayPolicy', () => {
+  test('idle keeps everything shown and pickable', () => {
+    const p = resolveOverlayPolicy({ kind: 'idle' })
+    expect(p.zoneLabels).toBe('shown')
+    expect(p.contextBadges).toBe('shown')
+    expect(p.conflictingControls).toBe('shown')
+    expect(p.sceneObjectsPickable).toBe(true)
+  })
+
+  test('every active scope hides zone labels, fades badges, hides conflicting controls', () => {
+    for (const scope of ACTIVE_SCOPES) {
+      const p = resolveOverlayPolicy(scope)
+      expect(p.zoneLabels).toBe('hidden')
+      expect(p.contextBadges).toBe('faded')
+      expect(p.conflictingControls).toBe('hidden')
+      expect(p.sceneObjectsPickable).toBe(false)
+    }
+  })
+
+  test('active affordances and the contextual HUD always stay interactive', () => {
+    for (const scope of [{ kind: 'idle' } as const, ...ACTIVE_SCOPES]) {
+      const p = resolveOverlayPolicy(scope)
+      expect(p.activeAffordances).toBe('shown')
+      expect(p.contextualHudInteractive).toBe(true)
+    }
+  })
+})

package/src/lib/interaction/overlay-policy.ts

@@ -0,0 +1,59 @@
+// The overlay scope matrix — the "Sims-light" feel. During any non-idle
+// interaction, two layers behave differently:
+//
+//  - 3D scene objects stay VISIBLE but become NON-pickable (the hot-set owns
+//    what the active interaction can target). Context is preserved; you just
+//    can't grab the wrong thing.
+//  - DOM/HUD overlays step back, differentiated by how distracting they are:
+//      zone labels      -> hidden (not a primary editing concern)
+//      context badges   -> faded + pointer-events:none (hover name pills)
+//      other controls   -> hard-hidden (other objects' handles, the floating
+//                          action menu, conflicting controls)
+//
+// The active interaction's own affordances (ghost, snap guides, dimension
+// labels, the active handle) always stay — "default-off, opt-in for the active
+// action". The contextual control HUD is exempt from the pointer-events
+// step-back because it *is* the active interaction's own controls.
+
+import { type InteractionScope, isActive } from './scope'
+
+export type OverlayVisibility = 'shown' | 'faded' | 'hidden'
+
+export type OverlayPolicy = {
+  zoneLabels: OverlayVisibility
+  // Hover name pills / context badges.
+  contextBadges: OverlayVisibility
+  // Other objects' handles + the floating action menu — anything whose action
+  // would conflict with the active interaction.
+  conflictingControls: OverlayVisibility
+  // Non-active scene objects: visible always, pickable only when idle.
+  sceneObjectsPickable: boolean
+  // The active interaction's own ghost/guides/dimension labels/handle. Always
+  // shown; this field exists so consumers can assert the contract.
+  activeAffordances: 'shown'
+  // The contextual control HUD keeps pointer events even while everything else
+  // steps back, because it is the active interaction's own controls.
+  contextualHudInteractive: boolean
+}
+
+const IDLE_POLICY: OverlayPolicy = {
+  zoneLabels: 'shown',
+  contextBadges: 'shown',
+  conflictingControls: 'shown',
+  sceneObjectsPickable: true,
+  activeAffordances: 'shown',
+  contextualHudInteractive: true,
+}
+
+const ACTIVE_POLICY: OverlayPolicy = {
+  zoneLabels: 'hidden',
+  contextBadges: 'faded',
+  conflictingControls: 'hidden',
+  sceneObjectsPickable: false,
+  activeAffordances: 'shown',
+  contextualHudInteractive: true,
+}
+
+export function resolveOverlayPolicy(scope: InteractionScope): OverlayPolicy {
+  return isActive(scope) ? ACTIVE_POLICY : IDLE_POLICY
+}

package/src/lib/interaction/scope.ts

@@ -0,0 +1,211 @@
+// The authoritative description of "what the user is currently doing".
+//
+// Before this, that question was answered by re-deriving from 7+ independent
+// `useEditor` flags (`mode`, `tool`, `movingNode`, `placementDragMode`,
+// `activeHandleDrag`, `curvingWall`, `curvingFence`, `editingHole`,
+// `movingWallEndpoint`, `movingFenceEndpoint`, …). Every overlay and pick site
+// re-derived its behaviour from a different subset, so the flags could drift
+// into illegal combinations (moving + curving at once; a stale `movingNode`
+// after a drag ended). Collapsing them into one discriminated union makes those
+// combinations unrepresentable: a scope is exactly one interaction at a time,
+// and `idle` carries no interaction payload at all.
+
+import type { AnyNode } from '@pascal-app/core'
+
+export type InteractionView = '2d' | '3d'
+
+// Endpoint/curve/hole/boundary edits are all "reshape the selected node" — one
+// 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 InteractionScope =
+  | { kind: 'idle' }
+  // Placing a fresh node (catalog/preset/build tool). `pressDrag` is the
+  // gizmo press-drag flavour (commit on release) vs click-to-place.
+  | {
+      kind: 'placing'
+      // The node being placed, carried inline: a fresh-placement / duplicate
+      // draft is not in the scene yet, so it cannot be recovered by id. Set once
+      // at `begin` and never mutated, so it is a stable reference for the gesture.
+      node: AnyNode
+      nodeId: string
+      nodeType: string
+      view: InteractionView
+      pressDrag: boolean
+    }
+  // Moving an existing node.
+  | { kind: 'moving'; node: AnyNode; nodeId: string; nodeType: string; view: InteractionView }
+  // Dragging a resize/translate/rotate handle of a selected node.
+  | { kind: 'handle-drag'; nodeId: string; handle: string }
+  // Click-to-click drafting of a polyline/polygon kind (wall/fence/slab/…).
+  | { kind: 'drafting'; tool: string }
+  // Reshaping a selected node's geometry (see ReshapeKind). `holeIndex` is set
+  // only for `reshape: 'hole'`; `endpoint` only for `reshape: 'endpoint'`.
+  | {
+      kind: 'reshaping'
+      nodeId: string
+      reshape: ReshapeKind
+      holeIndex?: number
+      endpoint?: 'start' | 'end'
+      index?: number
+      side?: 'in' | 'out'
+    }
+  // Marquee selection drag.
+  | { kind: 'box-select' }
+  // Material paint application.
+  | { kind: 'painting' }
+
+export type InteractionKind = InteractionScope['kind']
+
+export type ActiveInteractionScope = Exclude<InteractionScope, { kind: 'idle' }>
+
+export const IDLE_SCOPE: InteractionScope = { kind: 'idle' }
+
+export function isIdle(scope: InteractionScope): scope is { kind: 'idle' } {
+  return scope.kind === 'idle'
+}
+
+export function isActive(scope: InteractionScope): scope is ActiveInteractionScope {
+  return scope.kind !== 'idle'
+}
+
+// The node a scope is acting on, if any. Drafting/box-select/painting/idle
+// target no single existing node.
+export function scopeNodeId(scope: InteractionScope): string | null {
+  switch (scope.kind) {
+    case 'placing':
+    case 'moving':
+    case 'handle-drag':
+    case 'reshaping':
+      return scope.nodeId
+    default:
+      return null
+  }
+}
+
+// The node a placing/moving scope is acting on, carried inline (see the
+// `placing` variant comment). Null for every other scope. Replaces the legacy
+// `useEditor.movingNode` flag: the node lives inside the discriminated union, so
+// it cannot survive past the interaction's `end()`.
+export function movingNodeOf(scope: InteractionScope): AnyNode | null {
+  return scope.kind === 'placing' || scope.kind === 'moving' ? scope.node : null
+}
+
+// Selection/hover picking is only meaningful while idle. During any active
+// interaction the pointer belongs to that interaction's body, not to selecting
+// a different object — the picking choke point should not route a hover/click
+// to selection while this is false.
+export function selectionEnabled(scope: InteractionScope): boolean {
+  return scope.kind === 'idle'
+}
+
+// Derived views of the scope that mirror the legacy `useEditor` flags they
+// replaced. Each returns null unless that exact interaction is active, so a
+// stale payload is unrepresentable: the value is a pure function of the single
+// authoritative scope, not an independent flag that can drift out of sync.
+
+// The legacy `activeHandleDrag` flag. `label` keeps the legacy field name so
+// downstream `=== ROTATE_HANDLE_DRAG_LABEL` / `=== 'height'` checks are unchanged.
+export function handleDragInfo(scope: InteractionScope): { nodeId: string; label: string } | null {
+  return scope.kind === 'handle-drag' ? { nodeId: scope.nodeId, label: scope.handle } : null
+}
+
+// The legacy `editingHole` flag (`SurfaceHoleTarget`).
+export function editingHoleInfo(
+  scope: InteractionScope,
+): { nodeId: string; holeIndex: number } | null {
+  return scope.kind === 'reshaping' && scope.reshape === 'hole' && scope.holeIndex !== undefined
+    ? { nodeId: scope.nodeId, holeIndex: scope.holeIndex }
+    : null
+}
+
+// Build the scope payload for a hole reshape, so producers don't re-spell the
+// discriminator at every call site.
+export function holeEditScope(target: {
+  nodeId: string
+  holeIndex: number
+}): ActiveInteractionScope {
+  return {
+    kind: 'reshaping',
+    nodeId: target.nodeId,
+    reshape: 'hole',
+    holeIndex: target.holeIndex,
+  }
+}
+
+// True while the selected node's geometry is being curved (legacy
+// `curvingWall` / `curvingFence` — now one scope; the wall-vs-fence kind is
+// recovered from the reshaped node's type, looked up from the scene by nodeId).
+export function isCurveReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.reshape === 'curve'
+}
+
+// The legacy `movingWallEndpoint` / `movingFenceEndpoint` flags minus the node
+// itself (consumers fetch the node from the scene by `nodeId`; it is stable for
+// the duration of the drag).
+export function endpointReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; endpoint: 'start' | 'end' } | null {
+  return scope.kind === 'reshaping' && scope.reshape === 'endpoint' && scope.endpoint !== undefined
+    ? { nodeId: scope.nodeId, endpoint: scope.endpoint }
+    : null
+}
+
+export function controlPointReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; index: number } | null {
+  return scope.kind === 'reshaping' &&
+    scope.reshape === 'control-point' &&
+    scope.index !== undefined
+    ? { nodeId: scope.nodeId, index: scope.index }
+    : null
+}
+
+export function tangentReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; index: number; side: 'in' | 'out' } | null {
+  return scope.kind === 'reshaping' &&
+    scope.reshape === 'tangent' &&
+    scope.index !== undefined &&
+    scope.side !== undefined
+    ? { nodeId: scope.nodeId, index: scope.index, side: scope.side }
+    : null
+}
+
+// The id of the node being reshaped (any reshape kind), for the scene lookup
+// that recovers the full node payload a few consumers still need.
+export function reshapingNodeId(scope: InteractionScope): string | null {
+  return scope.kind === 'reshaping' ? scope.nodeId : null
+}
+
+// Builders so producers don't re-spell the discriminator at every call site.
+export function curveReshapeScope(nodeId: string): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'curve' }
+}
+
+export function endpointReshapeScope(
+  nodeId: string,
+  endpoint: 'start' | 'end',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'endpoint', endpoint }
+}
+
+export function controlPointReshapeScope(nodeId: string, index: number): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'control-point', index }
+}
+
+export function tangentReshapeScope(
+  nodeId: string,
+  index: number,
+  side: 'in' | 'out',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'tangent', index, side }
+}
+
+// Dragging a polygon vertex/edge (slab / ceiling boundary). Drives the snapping
+// HUD (no-angle 'polygon' set) and keeps the idle select hints off-screen.
+export function boundaryReshapeScope(nodeId: string): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'boundary' }
+}

package/src/lib/level-selection.ts

@@ -5,10 +5,10 @@ import { useViewer } from '@pascal-app/viewer'
 function getAdjacentLevelIdForDeletion(levelId: AnyNodeId): LevelNode['id'] | null {
   const { nodes } = useScene.getState()
   const level = nodes[levelId]
-  if (!level || level.type !== 'level' || !level.parentId) return null
+  if (level?.type !== 'level' || !level.parentId) return null
 
   const building = nodes[level.parentId as AnyNodeId]
-  if (!building || building.type !== 'building') return null
+  if (building?.type !== 'building') return null
 
   const siblingLevelIds = (building as BuildingNode).children.filter(
     (childId): childId is LevelNode['id'] => nodes[childId as AnyNodeId]?.type === 'level',