@pascal-app/editor 1.0.0-beta.5 → 1.0.0

package/src/lib/history.ts

@@ -1,4 +1,15 @@
-import { useLiveNodeOverrides, useLiveTransforms, useScene } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  emitter,
+  getHistoryDirtyNodeIds,
+  useLiveNodeOverrides,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
+import { markPerfAction } from '@pascal-app/viewer'
+import useInteractionScope from '../store/use-interaction-scope'
+import { registeredDraftingConfig } from './interaction/registered-drafting'
 
 export type HistoryCommandState = {
   canRedo: boolean
@@ -61,29 +72,92 @@ function notifyHistoryCommandListeners() {
   for (const listener of [...historyCommandListeners]) listener()
 }
 
-function refreshSceneAfterHistoryJump() {
+function capturePreviewLayout() {
+  const overrides = useLiveNodeOverrides.getState().overrides
+  if (overrides.size === 0) return null
+  const nodes = { ...useScene.getState().nodes }
+  for (const [id, values] of overrides) {
+    const node = nodes[id as AnyNodeId]
+    if (node) nodes[node.id] = { ...node, ...values } as AnyNode
+  }
+  return nodes
+}
+
+function refreshSceneAfterHistoryJump(previewLayout: Record<string, AnyNode> | null) {
+  const target = useScene.getState().nodes
+  const previewDirty = previewLayout
+    ? getHistoryDirtyNodeIds(previewLayout, target)
+    : new Set<AnyNodeId>()
+  const previewIds = new Set([
+    ...useLiveTransforms.getState().transforms.keys(),
+    ...useLiveNodeOverrides.getState().overrides.keys(),
+  ])
+  const currentPreviewLayout = capturePreviewLayout()
+  if (currentPreviewLayout) {
+    for (const id of getHistoryDirtyNodeIds(currentPreviewLayout, target)) previewDirty.add(id)
+  }
   useLiveNodeOverrides.getState().clearAll()
   useLiveTransforms.getState().clearAll()
+  // Clearing overrides can republish stair holes while a live transform still
+  // exists. Capture that final publication before clearing it too.
+  const remainingOverrides = useLiveNodeOverrides.getState().overrides
+  if (remainingOverrides.size > 0) {
+    for (const id of remainingOverrides.keys()) previewIds.add(id)
+    const remainingLayout = capturePreviewLayout()
+    if (remainingLayout) {
+      for (const id of getHistoryDirtyNodeIds(remainingLayout, target)) previewDirty.add(id)
+    }
+    useLiveNodeOverrides.getState().clearAll()
+  }
 
   const state = useScene.getState()
-  for (const node of Object.values(state.nodes)) {
+  for (const id of previewDirty) {
+    if (state.nodes[id]) state.markDirty(id)
+  }
+  for (const id of previewIds) {
+    const node = state.nodes[id as AnyNodeId]
+    if (!node) continue
     state.markDirty(node.id)
+    if (node.parentId && state.nodes[node.parentId as AnyNodeId]) {
+      state.markDirty(node.parentId as AnyNodeId)
+    }
   }
 }
 
+export function shouldCancelDraftOnHistoryJump(): boolean {
+  const scope = useInteractionScope.getState().scope
+  return registeredDraftingConfig(scope)?.cancelOnHistoryJump === true
+}
+
 export function runUndo(): HistoryCommandResult {
-  if (historyCommandDelegate) return historyCommandDelegate.undo()
+  if (shouldCancelDraftOnHistoryJump()) emitter.emit('tool:cancel')
+  if (historyCommandDelegate) {
+    const result = historyCommandDelegate.undo()
+    // Mark only real jumps: a no-op undo must not open a receipt (or
+    // interrupt one that is still settling).
+    if (result.kind !== 'empty') markPerfAction('undo')
+    return result
+  }
   if (useScene.temporal.getState().pastStates.length === 0) return { kind: 'empty' }
+  markPerfAction('undo')
+  const previewLayout = capturePreviewLayout()
   useScene.temporal.getState().undo()
-  refreshSceneAfterHistoryJump()
+  refreshSceneAfterHistoryJump(previewLayout)
   return { kind: 'applied', persistence: 'local' }
 }
 
 export function runRedo(): HistoryCommandResult {
-  if (historyCommandDelegate) return historyCommandDelegate.redo()
+  if (shouldCancelDraftOnHistoryJump()) emitter.emit('tool:cancel')
+  if (historyCommandDelegate) {
+    const result = historyCommandDelegate.redo()
+    if (result.kind !== 'empty') markPerfAction('redo')
+    return result
+  }
   if (useScene.temporal.getState().futureStates.length === 0) return { kind: 'empty' }
+  markPerfAction('redo')
+  const previewLayout = capturePreviewLayout()
   useScene.temporal.getState().redo()
-  refreshSceneAfterHistoryJump()
+  refreshSceneAfterHistoryJump(previewLayout)
   return { kind: 'applied', persistence: 'local' }
 }
 

package/src/lib/host-tree-children.test.ts

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import {
+  editorHostTreeChildrenRegistry,
+  registerEditorHostTreeChildren,
+} from './host-tree-children'
+
+describe('editorHostTreeChildrenRegistry', () => {
+  afterEach(() => editorHostTreeChildrenRegistry.reset())
+
+  test('exposes host children by scene node kind and notifies mounted trees', () => {
+    let notifications = 0
+    const unsubscribe = editorHostTreeChildrenRegistry.subscribe(() => {
+      notifications += 1
+    })
+
+    registerEditorHostTreeChildren({
+      kind: 'scan',
+      component: () => null,
+      hasChildren: (node) => node.type === 'scan',
+    })
+
+    expect(editorHostTreeChildrenRegistry.childrenForKind('scan')).toBeDefined()
+    expect(editorHostTreeChildrenRegistry.childrenForKind('wall')).toBeUndefined()
+    expect(notifications).toBe(1)
+    unsubscribe()
+  })
+})

package/src/lib/host-tree-children.ts

@@ -0,0 +1,79 @@
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import type { ComponentType } from 'react'
+
+export type EditorHostTreeChildrenProps = {
+  nodeId: AnyNodeId
+  depth: number
+  parentVisible: boolean
+}
+
+export type EditorHostTreeChildren = {
+  kind: string
+  component: ComponentType<EditorHostTreeChildrenProps>
+  hasChildren: (node: AnyNode) => boolean
+}
+
+function isDevMode(): boolean {
+  try {
+    const meta = import.meta as { env?: { DEV?: boolean } }
+    if (typeof meta?.env?.DEV === 'boolean') return meta.env.DEV
+  } catch {
+    // import.meta unavailable in some CJS contexts — fall through.
+  }
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+    return process.env.NODE_ENV !== 'production'
+  }
+  return false
+}
+
+class EditorHostTreeChildrenRegistryImpl {
+  private readonly entries = new Map<string, EditorHostTreeChildren>()
+  private readonly listeners = new Set<() => void>()
+  private revision = 0
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): number => this.revision
+
+  childrenForKind = (kind: string): EditorHostTreeChildren | undefined => this.entries.get(kind)
+
+  reset(): void {
+    this.entries.clear()
+    this.emit()
+  }
+
+  register(entry: EditorHostTreeChildren): void {
+    if (typeof entry.kind !== 'string' || entry.kind.length === 0) {
+      throw new Error('[editor:host-tree-children] kind must be a non-empty string')
+    }
+    if (this.entries.has(entry.kind)) {
+      if (isDevMode()) {
+        console.warn(
+          `[editor:host-tree-children] re-registering children for "${entry.kind}" (HMR)`,
+        )
+      } else {
+        throw new Error(
+          `[editor:host-tree-children] duplicate kind: "${entry.kind}" already registered`,
+        )
+      }
+    }
+    this.entries.set(entry.kind, entry)
+    this.emit()
+  }
+
+  private emit(): void {
+    this.revision += 1
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const editorHostTreeChildrenRegistry = new EditorHostTreeChildrenRegistryImpl()
+
+export function registerEditorHostTreeChildren(entry: EditorHostTreeChildren): void {
+  editorHostTreeChildrenRegistry.register(entry)
+}

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

@@ -22,6 +22,13 @@ const wall: HotSetCandidate = {
   exposesTop: false,
   attachClass: 'surface',
 }
+const block: HotSetCandidate = {
+  type: 'block',
+  isFloorLike: false,
+  exposesTop: true,
+  exposesSides: true,
+  attachClass: 'surface',
+}
 const ceiling: HotSetCandidate = {
   type: 'ceiling',
   isFloorLike: false,
@@ -63,8 +70,9 @@ describe('attachClassOf', () => {
 })
 
 describe('isPickableForAttach — wall-mounted (window)', () => {
-  test('only walls are eligible; floor/ceiling/tops are not', () => {
+  test('walls and block faces are eligible; floor/ceiling/tops are not', () => {
     expect(isPickableForAttach('wall', wall)).toBe(true)
+    expect(isPickableForAttach('wall', block)).toBe(true)
     expect(isPickableForAttach('wall', floor)).toBe(false)
     expect(isPickableForAttach('wall', ceiling)).toBe(false)
     expect(isPickableForAttach('wall', table)).toBe(false)
@@ -109,6 +117,7 @@ describe('isCandidateInHotSet — by scope', () => {
       nodeType: 'item',
       view: '3d' as const,
       pressDrag: false,
+      driver: 'move-tool' as const,
     }
     expect(isCandidateInHotSet(scope, surfaceClass, floor)).toBe(true)
     expect(isCandidateInHotSet(scope, surfaceClass, ceilingFan)).toBe(false)

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

@@ -30,6 +30,8 @@ export type HotSetCandidate = {
   // The candidate exposes a usable top surface (registry
   // `capabilities.surfaces.top`) — a table, a shelf, a slab.
   exposesTop: boolean
+  // The candidate declares wall-like side faces through registry surfaces.
+  exposesSides?: 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
@@ -38,7 +40,7 @@ export type HotSetCandidate = {
 // 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 === 'wall') return candidate.type === 'wall' || candidate.exposesSides === true
   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).

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

@@ -1,6 +1,10 @@
 import { describe, expect, test } from 'bun:test'
 import type { AnyNode } from '@pascal-app/core'
-import { resolveOverlayPolicy } from './overlay-policy'
+import {
+  resolveFloatingActionMenuVisibility,
+  resolveOverlayPolicy,
+  shouldShowEditingControls,
+} from './overlay-policy'
 import type { ActiveInteractionScope } from './scope'
 
 const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknown as AnyNode
@@ -13,6 +17,7 @@ const ACTIVE_SCOPES: ActiveInteractionScope[] = [
     nodeType: 'item',
     view: '3d',
     pressDrag: false,
+    driver: 'move-tool',
   },
   { kind: 'moving', node: mockNode('i1', 'item'), nodeId: 'i1', nodeType: 'item', view: '2d' },
   { kind: 'handle-drag', nodeId: 'w1', handle: 'height' },
@@ -50,3 +55,30 @@ describe('resolveOverlayPolicy', () => {
     }
   })
 })
+
+describe('shouldShowEditingControls', () => {
+  test('hides controls that can mutate a read-only scene', () => {
+    expect(shouldShowEditingControls(false)).toBe(true)
+    expect(shouldShowEditingControls(true)).toBe(false)
+  })
+})
+
+describe('resolveFloatingActionMenuVisibility', () => {
+  test('keeps the active measurement pill while hiding action buttons during a height drag', () => {
+    const visibility = resolveFloatingActionMenuVisibility(
+      { kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' },
+      true,
+    )
+
+    expect(visibility).toEqual({ root: true, actions: false })
+  })
+
+  test('hides the whole menu during interactions without an active measurement pill', () => {
+    const visibility = resolveFloatingActionMenuVisibility(
+      { kind: 'handle-drag', nodeId: 'wall_1', handle: 'elevation' },
+      false,
+    )
+
+    expect(visibility).toEqual({ root: false, actions: false })
+  })
+})

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

@@ -57,3 +57,19 @@ const ACTIVE_POLICY: OverlayPolicy = {
 export function resolveOverlayPolicy(scope: InteractionScope): OverlayPolicy {
   return isActive(scope) ? ACTIVE_POLICY : IDLE_POLICY
 }
+
+export function resolveFloatingActionMenuVisibility(
+  scope: InteractionScope,
+  hasActiveMeasurementPill: boolean,
+): { root: boolean; actions: boolean } {
+  const policy = resolveOverlayPolicy(scope)
+  const actions = policy.conflictingControls === 'shown'
+  return {
+    root: actions || (hasActiveMeasurementPill && policy.activeAffordances === 'shown'),
+    actions,
+  }
+}
+
+export function shouldShowEditingControls(readOnly: boolean): boolean {
+  return !readOnly
+}

package/src/lib/interaction/registered-drafting.ts

@@ -0,0 +1,36 @@
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type GridEvent,
+  nodeRegistry,
+} from '@pascal-app/core'
+import type { InteractionScope } from './scope'
+
+type RegisteredDraftingConfig = NonNullable<AnyNodeDefinition['drafting']>
+type SurfaceHit = NonNullable<GridEvent['surfaceHit']>
+
+export const DRAFTING_SURFACE_EXTENSION_KEY = 'pascal:editor/drafting-surface'
+
+export type DraftingSurfaceExtension = {
+  kind: SurfaceHit['kind']
+  raycast?: 'underside'
+  classifyFace?: (
+    node: AnyNode | undefined,
+    localNormal: readonly [number, number, number],
+  ) => Pick<SurfaceHit, 'face' | 'side'> | null
+}
+
+export function registeredDraftingConfig(scope: InteractionScope): RegisteredDraftingConfig | null {
+  if (scope.kind !== 'drafting') return null
+  return nodeRegistry.get(scope.tool)?.drafting ?? null
+}
+
+export function registeredDraftingSurface(
+  definition: AnyNodeDefinition,
+): DraftingSurfaceExtension | null {
+  return (
+    (definition.extensions?.[DRAFTING_SURFACE_EXTENSION_KEY] as
+      | DraftingSurfaceExtension
+      | undefined) ?? null
+  )
+}

package/src/lib/interaction/scope.ts

@@ -35,11 +35,31 @@ export type InteractionScope =
       nodeType: string
       view: InteractionView
       pressDrag: boolean
+      driver: 'move-tool' | 'registry-tool'
     }
   // 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 }
+  // Editing the internal topology of one block. This scope remains
+  // active for the whole edit-mode session so scene selection and whole-node
+  // movement cannot claim the same pointer stream.
+  | {
+      kind: 'mesh-editing'
+      nodeId: string
+      phase: 'selecting' | 'operating'
+      operator?:
+        | 'translate'
+        | 'rotate'
+        | 'scale'
+        | 'extrude'
+        | 'inset'
+        | 'merge'
+        | 'dissolve'
+        | 'loop-cut'
+        | 'bevel'
+        | 'delete'
+    }
   // 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
@@ -88,6 +108,7 @@ export function scopeNodeId(scope: InteractionScope): string | null {
     case 'placing':
     case 'moving':
     case 'handle-drag':
+    case 'mesh-editing':
     case 'reshaping':
       return scope.nodeId
     default:
@@ -111,6 +132,16 @@ export function selectionEnabled(scope: InteractionScope): boolean {
   return scope.kind === 'idle'
 }
 
+export function meshEditScope(
+  nodeId: string,
+  phase: 'selecting' | 'operating' = 'selecting',
+  operator?: Extract<InteractionScope, { kind: 'mesh-editing' }>['operator'],
+): ActiveInteractionScope {
+  return operator
+    ? { kind: 'mesh-editing', nodeId, phase, operator }
+    : { kind: 'mesh-editing', nodeId, phase }
+}
+
 // 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