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

package/src/hooks/use-auto-save.ts

@@ -11,6 +11,40 @@ export function isSuspiciousNodeDrop(previousNodeCount: number, currentNodeCount
   return previousNodeCount > STRUCTURAL_NODE_COUNT && currentNodeCount <= STRUCTURAL_NODE_COUNT
 }
 
+/**
+ * Tracks the node count of the graph we believe is stored, which is what the
+ * accidental-wipe guard measures every write against.
+ *
+ * The distinction that matters: a graph that came from storage is authoritative
+ * and has to become the new baseline, while an edited or previewed graph must
+ * not. Seeding the baseline once at mount is not enough — the hook mounts
+ * before the scene has loaded, so it would sit at ~0 for the whole session and
+ * `isSuspiciousNodeDrop` could never fire.
+ */
+export function createStoredNodeCountTracker(initialNodeCount: number) {
+  let count = initialNodeCount
+
+  return {
+    get count() {
+      return count
+    },
+    /** A graph read from storage — it defines what "populated" means from here. */
+    trackLoadedGraph(nodeCount: number) {
+      count = nodeCount
+    },
+    /**
+     * `false` when the write would drop a populated scene to a bare scaffold,
+     * which is an accidental full deletion far more often than an intent. The
+     * caller reports the block; on `true` the write becomes the new baseline.
+     */
+    allowWrite(nodeCount: number) {
+      if (isSuspiciousNodeDrop(count, nodeCount)) return false
+      count = nodeCount
+      return true
+    },
+  }
+}
+
 export type SaveStatus = 'idle' | 'pending' | 'saving' | 'saved' | 'paused' | 'error'
 
 interface UseAutoSaveOptions {
@@ -65,7 +99,9 @@ export function useAutoSave({
   // Stable subscription to scene changes
   useEffect(() => {
     let lastNodesSnapshot = JSON.stringify(useScene.getState().nodes)
-    let lastNodeCount = Object.keys(useScene.getState().nodes).length
+    const storedNodeCount = createStoredNodeCountTracker(
+      Object.keys(useScene.getState().nodes).length,
+    )
     // Collections + scene materials are document-level state that persists with
     // the graph but lives outside `nodes`. Track them by reference (zustand
     // hands out a new object on every mutation) so a material edit or a
@@ -90,17 +126,15 @@ export function useAutoSave({
         installedPlugins,
       } as SceneGraph
 
-      // Guard: refuse to autosave if the scene went from populated to nearly empty.
-      // This catches accidental full deletions before they're persisted.
       const currentNodeCount = Object.keys(nodes).length
-      if (isSuspiciousNodeDrop(lastNodeCount, currentNodeCount)) {
+      const previousNodeCount = storedNodeCount.count
+      if (!storedNodeCount.allowWrite(currentNodeCount)) {
         console.warn(
-          `[autosave] Blocked: scene dropped from ${lastNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
+          `[autosave] Blocked: scene dropped from ${previousNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
         )
         setSaveStatus('error')
         return
       }
-      lastNodeCount = currentNodeCount
 
       isSavingRef.current = true
       pendingSaveRef.current = false
@@ -135,6 +169,7 @@ export function useAutoSave({
     const unsubscribe = useScene.subscribe((state) => {
       if (isLoadingSceneRef.current) {
         lastNodesSnapshot = JSON.stringify(state.nodes)
+        storedNodeCount.trackLoadedGraph(Object.keys(state.nodes).length)
         lastCollectionsRef = state.collections
         lastMaterialsRef = state.materials
         lastInstalledPluginsRef = state.installedPlugins
@@ -188,16 +223,16 @@ export function useAutoSave({
       if (!hasDirtyChangesRef.current) return
       const { nodes, rootNodeIds, collections, materials, installedPlugins } = useScene.getState()
       const currentNodeCount = Object.keys(nodes).length
-      if (isSuspiciousNodeDrop(lastNodeCount, currentNodeCount)) {
+      const previousNodeCount = storedNodeCount.count
+      if (!storedNodeCount.allowWrite(currentNodeCount)) {
         console.warn(
-          `[autosave] Blocked unload flush: scene dropped from ${lastNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
+          `[autosave] Blocked unload flush: scene dropped from ${previousNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
         )
         setSaveStatus('error')
         return
       }
 
       hasDirtyChangesRef.current = false
-      lastNodeCount = currentNodeCount
       const sceneGraph = {
         nodes,
         rootNodeIds,

package/src/hooks/use-keyboard.ts

@@ -36,6 +36,7 @@ import { toggleWindowOpenState } from '../lib/window-interaction'
 import useDeleteConfirmation from '../store/use-delete-confirmation'
 import useEditor, { getActiveContinuationContext, getActiveSnapContext } from '../store/use-editor'
 import useInteractionScope, { getMovingNode } from '../store/use-interaction-scope'
+import { groupCurrentSelection, ungroupCurrentSelection } from '../store/use-session-groups'
 
 // References (guide/scan) are selected via `useEditor.selectedReferenceId`, not
 // the viewer selection, so selection-based key arms (R/T rotate) need this
@@ -210,7 +211,11 @@ export const useKeyboard = ({
       }
 
       // Don't handle shortcuts if user is typing in an input
-      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+      if (
+        e.target instanceof HTMLInputElement ||
+        e.target instanceof HTMLTextAreaElement ||
+        (e.target instanceof HTMLElement && e.target.isContentEditable)
+      ) {
         return
       }
 
@@ -695,9 +700,38 @@ export const useKeyboard = ({
       }
     }
 
+    // Capture-phase Ctrl/Cmd+G so browser "Find next" cannot steal the shortcut
+    // before the editor bubble listener runs. `stopPropagation` here silences the
+    // chord for every other capture listener (floorplan hotkeys, group move,
+    // registry move overlay) — safe only because none of them claim Ctrl/Cmd+G.
+    // `e.code` keeps it on the physical G key across keyboard layouts.
+    const handleSessionGroupKeyDown = (e: KeyboardEvent) => {
+      if (
+        e.target instanceof HTMLInputElement ||
+        e.target instanceof HTMLTextAreaElement ||
+        (e.target instanceof HTMLElement && e.target.isContentEditable)
+      ) {
+        return
+      }
+      if (useDeleteConfirmation.getState().request) return
+      if (isVersionPreviewMode) return
+      if (!(e.metaKey || e.ctrlKey) || e.altKey) return
+      if (e.code !== 'KeyG') return
+
+      e.preventDefault()
+      e.stopPropagation()
+      if (e.shiftKey) {
+        ungroupCurrentSelection()
+      } else {
+        groupCurrentSelection()
+      }
+    }
+
+    window.addEventListener('keydown', handleSessionGroupKeyDown, true)
     window.addEventListener('keydown', handleKeyDown)
     window.addEventListener('keyup', handleKeyUp)
     return () => {
+      window.removeEventListener('keydown', handleSessionGroupKeyDown, true)
       window.removeEventListener('keydown', handleKeyDown)
       window.removeEventListener('keyup', handleKeyUp)
     }

package/src/index.tsx

@@ -274,6 +274,16 @@ export {
   SnapTargetBadge,
   SnapTargetIcon,
 } from './components/ui/snap-target-badge'
+export {
+  FloorplanCompassButton,
+  type FloorplanCompassButtonProps,
+} from './components/viewer/floorplan-compass-button'
+export {
+  FloorplanPreview,
+  type FloorplanPreviewProps,
+  type FloorplanPreviewScene,
+} from './components/viewer/floorplan-preview'
+export { useViewerCameraNavigationSync } from './components/viewer/use-viewer-camera-navigation-sync'
 export {
   ViewerControlsBar,
   type ViewerControlsBarProps,
@@ -282,6 +292,19 @@ export {
   ViewerSceneHeader,
   type ViewerSceneHeaderProps,
 } from './components/viewer/viewer-scene-header'
+export { ViewerStage, type ViewerStageProps } from './components/viewer/viewer-stage'
+export {
+  normalizeViewerStageModes,
+  resolveMobileViewerStageMode,
+  resolveViewerStageMode,
+  VIEWER_STAGE_MODES,
+  viewerStageIncludes3D,
+} from './components/viewer/viewer-stage-modes'
+export {
+  type ViewerStageMode,
+  ViewerStageSwitcher,
+  type ViewerStageSwitcherProps,
+} from './components/viewer/viewer-stage-switcher'
 export {
   WalkthroughHud,
   type WalkthroughHudProps,
@@ -387,10 +410,14 @@ export {
 export { commitFreshPlacementSubtree } from './lib/fresh-planar-placement'
 export { exportSceneToGlb } from './lib/glb-export'
 export {
+  getHistoryCommandState,
   type HistoryCommandDelegate,
+  type HistoryCommandResult,
+  type HistoryCommandState,
   installHistoryCommandDelegate,
   runRedo,
   runUndo,
+  subscribeHistoryCommandState,
 } from './lib/history'
 export {
   boundaryReshapeScope,

package/src/lib/contextual-help.test.ts

@@ -73,6 +73,14 @@ describe('resolveSelectModeHelpHints', () => {
         label: 'Click or drag the selection to move it as one',
       },
       { keys: ['R / T'], label: 'Rotate the selection ±45°' },
+      {
+        keys: ['Cmd/Ctrl', 'G'],
+        label: 'Group selection (session only)',
+      },
+      {
+        keys: ['Cmd/Ctrl', 'Shift', 'G'],
+        label: 'Ungroup session selection',
+      },
       {
         keys: [['Cmd/Ctrl', 'Shift'], 'Left click'],
         label: 'Add or remove objects from the selection',

package/src/lib/contextual-help.ts

@@ -93,6 +93,14 @@ export function resolveSelectModeHelpHints({
       label: 'Click or drag the selection to move it as one',
     })
     hints.push({ keys: [ROTATE_KEYS], label: 'Rotate the selection ±45°' })
+    hints.push({
+      keys: [COMMAND_KEY, 'G'],
+      label: 'Group selection (session only)',
+    })
+    hints.push({
+      keys: [COMMAND_KEY, SHIFT_KEY, 'G'],
+      label: 'Ungroup session selection',
+    })
     hints.push({
       keys: [[COMMAND_KEY, SHIFT_KEY], LEFT_CLICK],
       label: 'Add or remove objects from the selection',

package/src/lib/floorplan/floorplan-readonly.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+import { LevelNode, WallNode } from '@pascal-app/core/schema'
+import { buildFloorplanContext } from './floorplan-readonly'
+
+const viewState = {
+  selected: false,
+  unit: 'metric' as const,
+  highlighted: false,
+  hovered: false,
+  moving: false,
+  palette: undefined,
+}
+
+describe('read-only floorplan context', () => {
+  test('does not invent siblings for parentless nodes', () => {
+    const first = LevelNode.parse({ id: 'level_first', type: 'level' })
+    const second = LevelNode.parse({ id: 'level_second', type: 'level' })
+    const nodes = { [first.id]: first, [second.id]: second }
+
+    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([])
+  })
+
+  test('resolves same-kind siblings from the parent child order', () => {
+    const first = WallNode.parse({
+      id: 'wall_first',
+      type: 'wall',
+      parentId: 'level_ground',
+      start: [0, 0],
+      end: [1, 0],
+    })
+    const second = WallNode.parse({
+      id: 'wall_second',
+      type: 'wall',
+      parentId: 'level_ground',
+      start: [1, 0],
+      end: [2, 0],
+    })
+    const level = LevelNode.parse({
+      id: 'level_ground',
+      type: 'level',
+      children: [first.id, second.id],
+    })
+    const nodes = { [level.id]: level, [first.id]: first, [second.id]: second }
+
+    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([second])
+  })
+})

package/src/lib/floorplan/floorplan-readonly.ts

@@ -0,0 +1,84 @@
+import type { AnyNode, AnyNodeId, FloorplanPalette, GeometryContext } from '@pascal-app/core'
+import {
+  createFloorplanContextExtensions,
+  type FloorplanWallDimensionReference,
+} from './floorplan-extension'
+
+export type FloorplanViewState = {
+  automaticDimensions?: boolean
+  selected: boolean
+  unit: 'metric' | 'imperial'
+  metricNotation?: 'meters' | 'millimeters'
+  purpose?: 'edit' | 'document'
+  wallDimensionReference?: FloorplanWallDimensionReference
+  highlighted: boolean
+  hovered: boolean
+  moving: boolean
+  palette: FloorplanPalette | undefined
+}
+
+export function buildFloorplanContext(
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+  viewState: FloorplanViewState,
+  levelData?: unknown,
+): GeometryContext {
+  const resolve = <N = AnyNode>(id: AnyNodeId): N | undefined => nodes[id] as N | undefined
+  const childIds = (node as { children?: AnyNodeId[] }).children
+  const children = Array.isArray(childIds)
+    ? childIds.map((id) => nodes[id]).filter((child): child is AnyNode => child !== undefined)
+    : []
+  const parentId = node.parentId as AnyNodeId | null
+  const parent = parentId ? (nodes[parentId] ?? null) : null
+  let siblings: AnyNode[] = []
+  if (parent) {
+    const parentChildIds = (parent as { children?: AnyNodeId[] }).children
+    siblings = Array.isArray(parentChildIds)
+      ? parentChildIds
+          .filter((id) => id !== node.id)
+          .map((id) => nodes[id])
+          .filter((sibling): sibling is AnyNode => sibling?.type === node.type)
+      : Object.values(nodes).filter(
+          (candidate) =>
+            candidate.id !== node.id &&
+            candidate.type === node.type &&
+            candidate.parentId === node.parentId,
+        )
+  }
+
+  return {
+    resolve,
+    children,
+    siblings,
+    parent,
+    levelData,
+    extensions: createFloorplanContextExtensions({
+      automaticDimensions: viewState.automaticDimensions,
+      metricNotation: viewState.metricNotation ?? 'meters',
+      purpose: viewState.purpose ?? 'edit',
+      wallDimensionReference: viewState.wallDimensionReference,
+    }),
+    viewState: viewState.palette
+      ? {
+          selected: viewState.selected,
+          unit: viewState.unit,
+          highlighted: viewState.highlighted,
+          hovered: viewState.hovered,
+          moving: viewState.moving,
+          palette: viewState.palette,
+        }
+      : undefined,
+  }
+}
+
+export function floorplanLayerRank(type: string): number {
+  switch (type) {
+    case 'zone':
+      return 0
+    case 'slab':
+    case 'ceiling':
+      return 1
+    default:
+      return 2
+  }
+}

package/src/lib/history.test.ts

@@ -7,7 +7,13 @@ import {
   LevelNode,
   useScene,
 } from '@pascal-app/core'
-import { installHistoryCommandDelegate, runRedo, runUndo } from './history'
+import {
+  getHistoryCommandState,
+  installHistoryCommandDelegate,
+  runRedo,
+  runUndo,
+  subscribeHistoryCommandState,
+} from './history'
 
 type RafFn = (cb: (time: number) => void) => number
 ;(globalThis as unknown as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= (cb) => {
@@ -58,12 +64,28 @@ describe('editor history controller', () => {
   })
 
   test('delegates undo and redo while a host delegate is installed', () => {
-    const undo = mock(() => {})
-    const redo = mock(() => {})
-    disposeController = installHistoryCommandDelegate({ undo, redo })
+    const undo = mock(() => ({ kind: 'applied', persistence: 'queued' }) as const)
+    const redo = mock(() => ({ kind: 'empty' }) as const)
+    disposeController = installHistoryCommandDelegate({
+      getState: () => ({
+        canRedo: false,
+        canUndo: true,
+        mode: 'collaborative',
+        status: 'syncing',
+      }),
+      redo,
+      subscribe: () => () => {},
+      undo,
+    })
 
-    runUndo()
-    runRedo()
+    expect(runUndo()).toEqual({ kind: 'applied', persistence: 'queued' })
+    expect(runRedo()).toEqual({ kind: 'empty' })
+    expect(getHistoryCommandState()).toEqual({
+      canRedo: false,
+      canUndo: true,
+      mode: 'collaborative',
+      status: 'syncing',
+    })
 
     expect(undo).toHaveBeenCalledTimes(1)
     expect(redo).toHaveBeenCalledTimes(1)
@@ -72,20 +94,34 @@ describe('editor history controller', () => {
   })
 
   test('falls back to standalone Zundo undo and redo when no controller is installed', () => {
-    runUndo()
+    expect(runUndo()).toEqual({ kind: 'applied', persistence: 'local' })
     expect(levelNumber()).toBe(0)
     expect(useScene.temporal.getState().futureStates).toHaveLength(1)
 
-    runRedo()
+    expect(runRedo()).toEqual({ kind: 'applied', persistence: 'local' })
     expect(levelNumber()).toBe(1)
     expect(useScene.temporal.getState().pastStates).toHaveLength(1)
   })
 
   test('an older cleanup cannot uninstall a newer controller', () => {
     const firstUndo = mock(() => {})
-    const stopFirst = installHistoryCommandDelegate({ undo: firstUndo, redo: () => {} })
+    const delegate = (undo: () => void) => ({
+      getState: () => ({
+        canRedo: false,
+        canUndo: true,
+        mode: 'collaborative' as const,
+        status: 'ready' as const,
+      }),
+      redo: () => ({ kind: 'empty' as const }),
+      subscribe: () => () => {},
+      undo: () => {
+        undo()
+        return { kind: 'applied' as const, persistence: 'queued' as const }
+      },
+    })
+    const stopFirst = installHistoryCommandDelegate(delegate(firstUndo))
     const secondUndo = mock(() => {})
-    disposeController = installHistoryCommandDelegate({ undo: secondUndo, redo: () => {} })
+    disposeController = installHistoryCommandDelegate(delegate(secondUndo))
 
     stopFirst()
     runUndo()
@@ -93,4 +129,33 @@ describe('editor history controller', () => {
     expect(firstUndo).toHaveBeenCalledTimes(0)
     expect(secondUndo).toHaveBeenCalledTimes(1)
   })
+
+  test('publishes delegate state changes and restores standalone availability on teardown', () => {
+    const listeners = new Set<() => void>()
+    const observed: string[] = []
+    const unsubscribe = subscribeHistoryCommandState(() => {
+      observed.push(getHistoryCommandState().mode)
+    })
+    disposeController = installHistoryCommandDelegate({
+      getState: () => ({
+        canRedo: false,
+        canUndo: true,
+        mode: 'collaborative',
+        status: 'offline',
+      }),
+      redo: () => ({ kind: 'empty' }),
+      subscribe: (listener) => {
+        listeners.add(listener)
+        return () => listeners.delete(listener)
+      },
+      undo: () => ({ kind: 'applied', persistence: 'queued' }),
+    })
+
+    for (const listener of listeners) listener()
+    disposeController()
+    disposeController = () => {}
+    unsubscribe()
+
+    expect(observed).toEqual(['collaborative', 'collaborative', 'standalone'])
+  })
 })

package/src/lib/history.ts

@@ -1,19 +1,66 @@
 import { useLiveNodeOverrides, useLiveTransforms, useScene } from '@pascal-app/core'
 
+export type HistoryCommandState = {
+  canRedo: boolean
+  canUndo: boolean
+  mode: 'collaborative' | 'standalone'
+  status: 'offline' | 'ready' | 'syncing' | 'unavailable'
+}
+
+export type HistoryCommandResult =
+  | { kind: 'applied'; persistence: 'local' | 'queued' }
+  | { kind: 'empty' }
+  | { kind: 'unavailable' }
+
 export type HistoryCommandDelegate = {
-  undo: () => void
-  redo: () => void
+  getState: () => HistoryCommandState
+  redo: () => HistoryCommandResult
+  subscribe: (listener: () => void) => () => void
+  undo: () => HistoryCommandResult
 }
 
 let historyCommandDelegate: HistoryCommandDelegate | null = null
+let historyCommandDelegateSubscription: (() => void) | null = null
+const historyCommandListeners = new Set<() => void>()
 
 export function installHistoryCommandDelegate(delegate: HistoryCommandDelegate): () => void {
+  historyCommandDelegateSubscription?.()
   historyCommandDelegate = delegate
+  historyCommandDelegateSubscription = delegate.subscribe(notifyHistoryCommandListeners)
+  notifyHistoryCommandListeners()
+  return () => {
+    if (historyCommandDelegate !== delegate) return
+    historyCommandDelegateSubscription?.()
+    historyCommandDelegateSubscription = null
+    historyCommandDelegate = null
+    notifyHistoryCommandListeners()
+  }
+}
+
+export function getHistoryCommandState(): HistoryCommandState {
+  if (historyCommandDelegate) return historyCommandDelegate.getState()
+  const temporal = useScene.temporal.getState()
+  return {
+    canRedo: temporal.futureStates.length > 0,
+    canUndo: temporal.pastStates.length > 0,
+    mode: 'standalone',
+    status: 'ready',
+  }
+}
+
+export function subscribeHistoryCommandState(listener: () => void): () => void {
+  historyCommandListeners.add(listener)
+  const unsubscribeTemporal = useScene.temporal.subscribe(listener)
   return () => {
-    if (historyCommandDelegate === delegate) historyCommandDelegate = null
+    historyCommandListeners.delete(listener)
+    unsubscribeTemporal()
   }
 }
 
+function notifyHistoryCommandListeners() {
+  for (const listener of [...historyCommandListeners]) listener()
+}
+
 function refreshSceneAfterHistoryJump() {
   useLiveNodeOverrides.getState().clearAll()
   useLiveTransforms.getState().clearAll()
@@ -24,22 +71,20 @@ function refreshSceneAfterHistoryJump() {
   }
 }
 
-export function runUndo() {
-  if (historyCommandDelegate) {
-    historyCommandDelegate.undo()
-    return
-  }
+export function runUndo(): HistoryCommandResult {
+  if (historyCommandDelegate) return historyCommandDelegate.undo()
+  if (useScene.temporal.getState().pastStates.length === 0) return { kind: 'empty' }
   useScene.temporal.getState().undo()
   refreshSceneAfterHistoryJump()
+  return { kind: 'applied', persistence: 'local' }
 }
 
-export function runRedo() {
-  if (historyCommandDelegate) {
-    historyCommandDelegate.redo()
-    return
-  }
+export function runRedo(): HistoryCommandResult {
+  if (historyCommandDelegate) return historyCommandDelegate.redo()
+  if (useScene.temporal.getState().futureStates.length === 0) return { kind: 'empty' }
   useScene.temporal.getState().redo()
   refreshSceneAfterHistoryJump()
+  return { kind: 'applied', persistence: 'local' }
 }
 
 /**