@pascal-app/editor 1.0.1 → 1.0.3

package/src/components/ui/sidebar/panels/settings-panel/keyboard-shortcuts-dialog.tsx

@@ -227,12 +227,12 @@ export function KeyboardShortcutsDialog() {
       <DialogTrigger asChild>
         <Button className="w-full justify-start gap-2" variant="outline">
           <Keyboard className="size-4" />
-          Keyboard Shortcuts
+          Keyboard shortcuts
         </Button>
       </DialogTrigger>
       <DialogContent className="flex max-h-[85vh] flex-col overflow-hidden p-0 sm:max-w-3xl">
         <DialogHeader className="shrink-0 border-b px-6 py-4">
-          <DialogTitle>Keyboard Shortcuts</DialogTitle>
+          <DialogTitle>Keyboard shortcuts</DialogTitle>
           <DialogDescription>
             Shortcuts are context-aware. Guided constraints are enabled by default; hold Shift
             during an active gesture to build freely.

package/src/components/ui/sidebar/panels/settings-panel/print-export-button.tsx

@@ -118,7 +118,7 @@ export function PrintExportButton({ onlyVisible }: { onlyVisible: boolean }) {
         Export 3D print STL
       </Button>
       {error && (
-        <div className="flex gap-2 text-destructive text-xs">
+        <div className="col-span-full flex gap-2 text-destructive text-xs">
           <AlertTriangle className="mt-0.5 size-4 shrink-0" />
           <span>{error}</span>
         </div>

package/src/components/viewer/floorplan-preview-visibility.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import { isVisibleInFloorplan } from './floorplan-preview-visibility'
+
+const node = (id: string, type: string, parentId: string | null, visible = true) =>
+  ({ object: 'node', id, type, parentId, visible, metadata: {} }) as unknown as AnyNode
+
+describe('isVisibleInFloorplan', () => {
+  test('a hidden Site keeps the buildings on it in the plan', () => {
+    const nodes: Record<string, AnyNode> = {
+      site_a: node('site_a', 'site', null, false),
+      building_a: node('building_a', 'building', 'site_a'),
+      level_a: node('level_a', 'level', 'building_a'),
+      wall_a: node('wall_a', 'wall', 'level_a'),
+      wall_b: node('wall_b', 'wall', 'level_a', false),
+    }
+    expect(isVisibleInFloorplan(nodes.wall_a!, nodes)).toBe(true)
+    expect(isVisibleInFloorplan(nodes.wall_b!, nodes)).toBe(false)
+    expect(isVisibleInFloorplan(nodes.site_a!, nodes)).toBe(false)
+  })
+
+  test('a hidden building or level still hides its subtree', () => {
+    const nodes: Record<string, AnyNode> = {
+      site_a: node('site_a', 'site', null),
+      building_a: node('building_a', 'building', 'site_a', false),
+      level_a: node('level_a', 'level', 'building_a'),
+      wall_a: node('wall_a', 'wall', 'level_a'),
+      building_b: node('building_b', 'building', 'site_a'),
+      level_b: node('level_b', 'level', 'building_b', false),
+      wall_b: node('wall_b', 'wall', 'level_b'),
+    }
+    expect(isVisibleInFloorplan(nodes.wall_a!, nodes)).toBe(false)
+    expect(isVisibleInFloorplan(nodes.wall_b!, nodes)).toBe(false)
+  })
+})

package/src/components/viewer/floorplan-preview-visibility.ts

@@ -0,0 +1,19 @@
+import { type AnyNode, hidesDescendants } from '@pascal-app/core'
+
+/**
+ * A node draws in the plan unless it, or an ancestor whose flag reaches its
+ * descendants, is hidden. A hidden Site keeps its buildings on the plan; see
+ * `hidesDescendants`.
+ */
+export function isVisibleInFloorplan(node: AnyNode, nodes: Record<string, AnyNode>): boolean {
+  if (node.visible === false) return false
+  const seen = new Set<string>([node.id])
+  let current: AnyNode | undefined = node.parentId ? nodes[node.parentId] : undefined
+  while (current) {
+    if (seen.has(current.id)) return true
+    seen.add(current.id)
+    if (current.visible === false && hidesDescendants(current)) return false
+    current = current.parentId ? nodes[current.parentId] : undefined
+  }
+  return true
+}

package/src/components/viewer/floorplan-preview.tsx

@@ -62,6 +62,7 @@ import {
   rotateFloorplanPoint,
   visibleFloorplanViewWidth,
 } from './floorplan-preview-navigation'
+import { isVisibleInFloorplan } from './floorplan-preview-visibility'
 
 const READ_ONLY_PALETTE: FloorplanPalette = {
   selectedStroke: '#4f46e5',
@@ -193,18 +194,6 @@ export function normalizeFloorplanPreviewNodes(
   return normalized
 }
 
-function isVisibleInFloorplan(node: AnyNode, nodes: Record<string, AnyNode>): boolean {
-  const seen = new Set<string>()
-  let current: AnyNode | undefined = node
-  while (current) {
-    if (seen.has(current.id)) return true
-    seen.add(current.id)
-    if (current.visible === false) return false
-    current = current.parentId ? nodes[current.parentId] : undefined
-  }
-  return true
-}
-
 function buildFloorplanGeometries(
   nodes: Record<string, AnyNode>,
   installedPlugins: readonly string[] | undefined,

package/src/components/viewer-zone-system.tsx

@@ -33,10 +33,14 @@ export const ViewerZoneSystem = () => {
       // Zone geometry: visible in zone mode on the right level, OR when this zone is selected.
       // The editor ZoneSystem handles the selected zone's opacity animation.
       const isSelected = id === zoneId
+      // A zone the author hid (sidebar eye) takes the group with it — this
+      // per-frame write would otherwise undo the renderer's `visible` prop.
+      const nodeVisible = zone.visible !== false
       const shouldShowGeometry =
+        nodeVisible &&
         !isCaptureMode &&
         ((structureLayer === 'zones' && !!levelId && isOnSelectedLevel) || isSelected)
-      if (!obj.visible) obj.visible = true
+      if (obj.visible !== nodeVisible) obj.visible = nodeVisible
       obj.traverse((child) => {
         if ((child as Mesh).isMesh) {
           child.visible = shouldShowGeometry
@@ -44,7 +48,8 @@ export const ViewerZoneSystem = () => {
       })
 
       // Labels: always visible on the current level (regardless of mode or zone selection)
-      const showLabel = !isCaptureMode && !zoneLabelsHidden && !!levelId && isOnSelectedLevel
+      const showLabel =
+        nodeVisible && !isCaptureMode && !zoneLabelsHidden && !!levelId && isOnSelectedLevel
       const targetOpacity = showLabel ? '1' : '0'
       const labelEl = document.getElementById(`${id}-label`)
       if (labelEl && labelEl.style.opacity !== targetOpacity) {

package/src/hooks/use-auto-save.integration.test.tsx

@@ -0,0 +1,197 @@
+import { afterEach, expect, test } from 'bun:test'
+import {
+  BuildingNode,
+  ColumnNode,
+  clearSceneHistory,
+  LevelNode,
+  SiteNode,
+  useScene,
+} from '@pascal-app/core'
+import { create } from '@react-three/test-renderer'
+import { type SaveStatus, useAutoSave } from './use-auto-save'
+
+const originalWindow = globalThis.window
+const previousScene = useScene.getState()
+let renderer: Awaited<ReturnType<typeof create>> | undefined
+
+afterEach(async () => {
+  await renderer?.unmount()
+  renderer = undefined
+  globalThis.window = originalWindow
+  useScene.setState(previousScene, true)
+  clearSceneHistory()
+})
+
+function graph(count: number) {
+  if (count === 0) return { nodes: {}, rootNodeIds: [] }
+  const columns = Array.from({ length: count - 3 }, (_, index) =>
+    ColumnNode.parse({ id: `column_autosave_${index}`, parentId: 'level_autosave' }),
+  )
+  const level = LevelNode.parse({
+    id: 'level_autosave',
+    parentId: 'building_autosave',
+    children: columns.map((node) => node.id),
+  })
+  const building = BuildingNode.parse({
+    id: 'building_autosave',
+    parentId: 'site_autosave',
+    children: [level.id],
+  })
+  const site = SiteNode.parse({ id: 'site_autosave', children: [building.id] })
+  const nodes = [site, building, level, ...columns]
+  return { nodes: Object.fromEntries(nodes.map((node) => [node.id, node])), rootNodeIds: [site.id] }
+}
+
+async function mount(
+  loadedCount: number,
+  guardAgainstSceneWipe?: boolean,
+  save?: () => Promise<void>,
+) {
+  globalThis.window = new EventTarget() as unknown as Window & typeof globalThis
+  useScene.setState({ ...graph(0), readOnly: false })
+  clearSceneHistory()
+  const writes: number[] = []
+  const statuses: SaveStatus[] = []
+  let controls: ReturnType<typeof useAutoSave> | undefined
+  function Host(props: { guardAgainstSceneWipe?: boolean; isVersionPreviewMode?: boolean }) {
+    controls = useAutoSave({
+      ...props,
+      onSave: async (scene) => {
+        writes.push(Object.keys(scene.nodes).length)
+        await save?.()
+      },
+      onSaveStatusChange: (status) => statuses.push(status),
+    })
+    return null
+  }
+  renderer = await create(<Host guardAgainstSceneWipe={guardAgainstSceneWipe} />)
+  useScene.setState(graph(loadedCount))
+  clearSceneHistory()
+  controls!.isLoadingSceneRef.current = false
+  statuses.length = 0
+  return {
+    writes,
+    statuses,
+    controls: controls!,
+    update: (props: { guardAgainstSceneWipe?: boolean; isVersionPreviewMode?: boolean }) =>
+      renderer!.update(<Host {...props} />),
+  }
+}
+
+test.each([
+  'undo',
+  'redo',
+  'delete',
+] as const)('autosave permits a 5 to 4 single-node %s', async (action) => {
+  const { writes, statuses } = await mount(5)
+  if (action === 'undo') {
+    useScene.setState(graph(4))
+    clearSceneHistory()
+    useScene.setState(graph(5))
+    useScene.temporal.getState().undo()
+  } else if (action === 'redo') {
+    useScene.getState().deleteNode('column_autosave_1')
+    useScene.temporal.getState().undo()
+    useScene.temporal.getState().redo()
+  } else {
+    useScene.getState().deleteNode('column_autosave_1')
+  }
+  expect(Object.keys(useScene.getState().nodes)).toHaveLength(4)
+  await Bun.sleep(1100)
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('autosave permits a single-node deletion on exit', async () => {
+  const { writes, statuses } = await mount(5)
+  useScene.getState().deleteNode('column_autosave_1')
+  window.dispatchEvent(new Event('pagehide'))
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+})
+
+test('autosave blocks a full wipe and resumes after an allowed edit', async () => {
+  const { writes, statuses, controls } = await mount(78)
+  useScene.setState(graph(4))
+  controls.saveNow()
+  window.dispatchEvent(new Event('pagehide'))
+  expect(statuses).toContain('error')
+  expect(writes).toEqual([])
+  useScene.setState(graph(5))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([5])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('collaboration scaffold deletion waits for persistence and reports saved', async () => {
+  const idle = Promise.withResolvers<void>()
+  const { writes, statuses } = await mount(78, false, () => idle.promise)
+  useScene.setState(graph(4))
+  await Bun.sleep(1100)
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+  expect(statuses).toEqual(['pending', 'saving'])
+  idle.resolve()
+  await Bun.sleep(0)
+  expect(statuses).toEqual(['pending', 'saving', 'saved'])
+})
+
+test.each([
+  'pagehide',
+  'unmount',
+])('collaboration scaffold deletion still flushes on %s', async (event) => {
+  const { writes, statuses } = await mount(78, false)
+  useScene.setState(graph(4))
+  if (event === 'pagehide') window.dispatchEvent(new Event(event))
+  else {
+    await renderer!.unmount()
+    renderer = undefined
+  }
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+})
+
+test('collaboration guard exemption preserves preview pause and resume', async () => {
+  const { writes, statuses, update } = await mount(78, false)
+  useScene.setState(graph(4))
+  await update({ guardAgainstSceneWipe: false, isVersionPreviewMode: true })
+  expect(statuses.at(-1)).toBe('paused')
+  await Bun.sleep(1100)
+  expect(writes).toEqual([])
+  await update({ guardAgainstSceneWipe: false, isVersionPreviewMode: false })
+  await Bun.sleep(1100)
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+  expect(statuses).not.toContain('error')
+})
+
+test('changing guard ownership recovers an error and keeps the new stored baseline', async () => {
+  const { writes, statuses, controls, update } = await mount(78)
+  useScene.setState(graph(4))
+  controls.saveNow()
+  expect(statuses.at(-1)).toBe('error')
+  await update({ guardAgainstSceneWipe: false })
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+  await update({ guardAgainstSceneWipe: true })
+  useScene.setState(graph(3))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4, 3])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('collaboration callback failures still report error', async () => {
+  const { writes, statuses, controls } = await mount(78, false, async () => {
+    throw new Error('Collaboration failed')
+  })
+  useScene.setState(graph(4))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4])
+  expect(statuses).toEqual(['pending', 'saving', 'error'])
+})

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

@@ -8,7 +8,11 @@ const AUTOSAVE_DEBOUNCE_MS = 1000
 const STRUCTURAL_NODE_COUNT = 4
 
 export function isSuspiciousNodeDrop(previousNodeCount: number, currentNodeCount: number) {
-  return previousNodeCount > STRUCTURAL_NODE_COUNT && currentNodeCount <= STRUCTURAL_NODE_COUNT
+  return (
+    previousNodeCount > STRUCTURAL_NODE_COUNT &&
+    currentNodeCount <= STRUCTURAL_NODE_COUNT &&
+    previousNodeCount - currentNodeCount > 1
+  )
 }
 
 /**
@@ -37,8 +41,8 @@ export function createStoredNodeCountTracker(initialNodeCount: number) {
      * 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
+    allowWrite(nodeCount: number, guardAgainstSceneWipe = true) {
+      if (guardAgainstSceneWipe && isSuspiciousNodeDrop(count, nodeCount)) return false
       count = nodeCount
       return true
     },
@@ -65,10 +69,14 @@ export function decideExitFlush(opts: {
   hasDirtyChanges: boolean
   storedNodeCount: number
   currentNodeCount: number
+  guardAgainstSceneWipe?: boolean
 }): ExitFlushDecision {
   if (!opts.hasDirtyChanges) return 'skip-clean'
   if (opts.isLoadingScene) return 'skip-loading'
-  if (isSuspiciousNodeDrop(opts.storedNodeCount, opts.currentNodeCount)) {
+  if (
+    opts.guardAgainstSceneWipe !== false &&
+    isSuspiciousNodeDrop(opts.storedNodeCount, opts.currentNodeCount)
+  ) {
     return 'blocked-suspicious'
   }
   return 'flush'
@@ -77,6 +85,7 @@ export function decideExitFlush(opts: {
 export type SaveStatus = 'idle' | 'pending' | 'saving' | 'saved' | 'paused' | 'error'
 
 interface UseAutoSaveOptions {
+  guardAgainstSceneWipe?: boolean
   onSave?: (scene: SceneGraph, options?: { keepalive?: boolean }) => Promise<void>
   onDirty?: () => void
   onSaveStatusChange?: (status: SaveStatus) => void
@@ -90,6 +99,7 @@ interface UseAutoSaveOptions {
  * ⚠️  Mount in exactly ONE component (the Editor).
  */
 export function useAutoSave({
+  guardAgainstSceneWipe = true,
   onSave,
   onDirty,
   onSaveStatusChange,
@@ -116,6 +126,7 @@ export function useAutoSave({
   const onDirtyRef = useRef(onDirty)
   const onSaveStatusChangeRef = useRef(onSaveStatusChange)
   const isVersionPreviewModeRef = useRef(isVersionPreviewMode)
+  const guardAgainstSceneWipeRef = useRef(guardAgainstSceneWipe)
 
   useEffect(() => {
     onSaveRef.current = onSave
@@ -129,6 +140,9 @@ export function useAutoSave({
   useEffect(() => {
     isVersionPreviewModeRef.current = isVersionPreviewMode
   }, [isVersionPreviewMode])
+  useEffect(() => {
+    guardAgainstSceneWipeRef.current = guardAgainstSceneWipe
+  }, [guardAgainstSceneWipe])
 
   const setSaveStatus = useCallback((status: SaveStatus) => {
     onSaveStatusChangeRef.current?.(status)
@@ -166,7 +180,7 @@ export function useAutoSave({
 
       const currentNodeCount = Object.keys(nodes).length
       const previousNodeCount = storedNodeCount.count
-      if (!storedNodeCount.allowWrite(currentNodeCount)) {
+      if (!storedNodeCount.allowWrite(currentNodeCount, guardAgainstSceneWipeRef.current)) {
         console.warn(
           `[autosave] Blocked: scene dropped from ${previousNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
         )
@@ -266,6 +280,7 @@ export function useAutoSave({
         hasDirtyChanges: hasDirtyChangesRef.current,
         storedNodeCount: previousNodeCount,
         currentNodeCount,
+        guardAgainstSceneWipe: guardAgainstSceneWipeRef.current,
       })
       if (decision === 'skip-clean') return
       if (decision === 'skip-loading') {
@@ -282,7 +297,7 @@ export function useAutoSave({
         return
       }
       // 'flush' — adopt the write as the new stored baseline.
-      storedNodeCount.allowWrite(currentNodeCount)
+      storedNodeCount.allowWrite(currentNodeCount, guardAgainstSceneWipeRef.current)
 
       hasDirtyChangesRef.current = false
       const sceneGraph = {

package/src/hooks/use-ceiling-events.test.ts

@@ -101,6 +101,7 @@ test.each([
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',

package/src/hooks/use-ceiling-events.ts

@@ -56,6 +56,8 @@ export function useCeilingEvents() {
   const hoveredRef = useRef<string | null>(null)
 
   useEffect(() => {
+    // XR placement is driven by the controller-ray bridge, never screen coordinates.
+    if (gl.xr.isPresenting) return
     const canvas = gl.domElement
 
     const isActive = (): boolean => {

package/src/hooks/use-grid-events.test.ts

@@ -70,6 +70,7 @@ test('grid moves throttle camera drags at 100 ms and resume immediately during t
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',
@@ -199,6 +200,7 @@ test.each([
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',

package/src/hooks/use-grid-events.ts

@@ -3,6 +3,7 @@ import {
   type EventSuffix,
   emitter,
   type GridEvent,
+  hiddenWallPointerEventsHeld,
   nodeRegistry,
   sceneRegistry,
   useScene,
@@ -58,6 +59,8 @@ export function useGridEvents(gridY: number) {
   }, [gridY])
 
   useEffect(() => {
+    // XR placement is driven by the controller-ray bridge, never screen coordinates.
+    if (gl.xr.isPresenting) return
     const canvas = gl.domElement
     setSurfaceRaycastLayers(raycaster.current.layers)
 
@@ -132,7 +135,10 @@ export function useGridEvents(gridY: number) {
       // Architectural meshes are expensive to raycast and are meaningful only
       // to an active placement/drafting interaction. Floor tools retain the
       // ordinary terrain/grid intersection without scanning every wall.
-      const surfaceHit = semanticSurfaceQueryRef.current ? getSurfaceIntersection() : null
+      const surfaceHit =
+        semanticSurfaceQueryRef.current || hiddenWallPointerEventsHeld()
+          ? getSurfaceIntersection()
+          : null
 
       // A semantic architectural hit is the authoritative cursor position.
       // Do not replace it with the terrain/grid intersection below: that would
@@ -244,16 +250,15 @@ export function useGridEvents(gridY: number) {
           : undefined,
         surfaceNormal: localNormal ? [localNormal.x, localNormal.y, localNormal.z] : undefined,
         surfaceObject: point.surface?.object,
-        surfaceHit:
-          semanticSurfaceQueryRef.current && point.surface
-            ? {
-                kind: point.surface.descriptor.kind,
-                hostId: point.surface.hostId,
-                face: classifiedFace?.face ?? 'unknown',
-                levelId: useViewer.getState().selection.levelId ?? undefined,
-                side: classifiedFace?.side,
-              }
-            : undefined,
+        surfaceHit: point.surface
+          ? {
+              kind: point.surface.descriptor.kind,
+              hostId: point.surface.hostId,
+              face: classifiedFace?.face ?? 'unknown',
+              levelId: useViewer.getState().selection.levelId ?? undefined,
+              side: classifiedFace?.side,
+            }
+          : undefined,
         nativeEvent: nativeEvent as any, // Type compatibility with ThreeEvent
       }
 

package/src/hooks/use-keyboard.test.ts

@@ -106,6 +106,13 @@ describe('rotation shortcut ownership', () => {
     expect(isToolOwnedRotation()).toBe(true)
   })
 
+  test('leaves R to the wall tool for its line / rectangle toggle, but not T', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+
+    expect(isToolOwnedRotation('r')).toBe(true)
+    expect(isToolOwnedRotation('t')).toBe(false)
+  })
+
   test('leaves R and T to a moving lean-to extension', () => {
     const leanTo = { id: 'lean_to_moving', type: 'lean-to-extension' } as unknown as AnyNode
     useInteractionScope.getState().begin({