@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/editor/slab-hole-highlights.tsx

@@ -139,12 +139,12 @@ function makeHitGeometry(hole: HolePolygon, centerY: number, height: number): Bu
 
 function getSurfaceY(slab: SlabNode): number {
   const elevation = slab.elevation ?? 0.05
-  return (elevation > 0 ? elevation : 0) + SURFACE_OFFSET
+  return Math.max(elevation, 0) + SURFACE_OFFSET
 }
 
 function getHitCenterY(slab: SlabNode): number {
   const elevation = slab.elevation ?? 0.05
-  const surfaceTop = elevation > 0 ? elevation : 0
+  const surfaceTop = Math.max(elevation, 0)
   // Keep the hit box's TOP at the slab surface (never poke above it) so the
   // slab's centre thickness/height handle, which sits on top, always wins the
   // raycast over the hole's selectable area.
@@ -417,7 +417,10 @@ function SlabHoleHighlight({
     [holeIndex, metadata, slabId],
   )
 
+  // Only a release that ends a press on a hole is the hole's: any other
+  // (a handle drag let go over the hole) must reach its owner.
   const handlePointerUp = useCallback((event: ThreeEvent<PointerEvent>) => {
+    if (!restoreNodeClickSuppression) return
     releaseNodeClickSuppression()
     stopPointerPropagation(event)
   }, [])

package/src/components/editor/snapshot-capture-overlay.tsx

@@ -18,6 +18,7 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import { flushSync } from 'react-dom'
 import { useIsMobile } from '../../hooks/use-mobile'
 import { triggerSFX } from '../../lib/sfx-bus'
+import { isTypingTarget } from '../../lib/typing-target'
 import { requestWalkthroughPointerLock } from '../../lib/walkthrough-pointer-lock'
 import useEditor, {
   CAPTURE_FOV_MAX,
@@ -29,6 +30,7 @@ import useEditor, {
 import { useFirstPersonHud } from '../../store/use-first-person-hud'
 import { Slider } from '../ui/slider'
 import { WalkthroughCrosshair } from '../walkthrough-hud'
+import { CaptureLevelPicker } from './capture-level-picker'
 import { isOverlaySnapshotSave } from './snapshot-capture'
 
 // Local alias — distinct from `useEditor.captureMode` (which describes *why*
@@ -466,7 +468,7 @@ export function SnapshotCaptureOverlay({ projectId }: { projectId: string }) {
         return
       }
       if (e.key !== 'Enter') return
-      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return
+      if (isTypingTarget(e.target)) return
       e.preventDefault()
       handleCapture()
     }
@@ -565,7 +567,7 @@ export function SnapshotCaptureOverlay({ projectId }: { projectId: string }) {
   const captureDisabled = captureState !== 'idle' || (mode === 'area' && !hasSelection)
 
   return (
-    <div className="pointer-events-none absolute inset-0 z-40" ref={overlayRef}>
+    <div className="dark pointer-events-none absolute inset-0 z-40" ref={overlayRef}>
       {/* Walk / drone keep the walkthrough's centered pointer (the ring means
           E opens the door / window under it) — the capture overlay replaces
           the walkthrough HUD, so the crosshair rides along here. */}
@@ -710,6 +712,9 @@ export function SnapshotCaptureOverlay({ projectId }: { projectId: string }) {
         </div>
       )}
 
+      {/* Top-left: which levels the shot shows (the whole building by default). */}
+      {!isPreset && <CaptureLevelPicker />}
+
       {/* Top-right dismiss button (icon-only on mobile) */}
       <div className="pointer-events-auto absolute top-4 right-4">
         <button

package/src/components/editor/snapshot-capture.test.ts

@@ -1,14 +1,17 @@
 import { describe, expect, test } from 'bun:test'
-import type {
-  SnapshotCaptureFailedEvent,
-  SnapshotCapturePose,
-  ThumbnailGenerateEvent,
+import {
+  emitter,
+  type SnapshotCapturedEvent,
+  type SnapshotCaptureFailedEvent,
+  type SnapshotCapturePose,
+  type ThumbnailGenerateEvent,
 } from '@pascal-app/core'
 import { Euler, PerspectiveCamera, Quaternion, Vector3 } from 'three'
 import {
   applySnapshotCapturePose,
   captureSnapshotScene,
   createSnapshotQueue,
+  deliverSnapshot,
   enqueueSnapshotCapture,
   isOverlaySnapshotSave,
   runSnapshotCapture,
@@ -237,62 +240,61 @@ describe('snapshot request correlation', () => {
     ])
   })
 
-  test.each([
-    'standard',
-    'viewport',
-    'area',
-  ] as const)('a manual %s shutter waits for a background upload; redundant autosaves are dropped', async (captureMode) => {
-    const enqueue = createSnapshotQueue()
-    const busy = { current: false }
-    const failures: SnapshotCaptureFailedEvent[] = []
-    const events: string[] = []
-    let finishUpload!: () => void
-    const uploading = new Promise<void>((resolve) => {
-      finishUpload = resolve
-    })
-    const background = enqueue({ requestId: 'background' }, () =>
-      runSnapshotCapture(
-        'background',
-        busy,
-        async () => {
-          events.push('background rendered')
-          await uploading
-          events.push('background saved')
-        },
-        (failure) => failures.push(failure),
-      ),
-    )
-    await Promise.resolve()
-    expect(busy.current).toBe(true)
-    const autosave = enqueue({}, async () => {
-      events.push('autosave')
-    })
-    let overlayState = 'capturing'
-    const manual = enqueue({ captureMode }, () =>
-      runSnapshotCapture(
-        undefined,
-        busy,
-        async () => {
-          events.push('manual saved')
-          overlayState = 'saved'
-        },
-        (failure) => failures.push(failure),
-      ),
-    )
-    await autosave
-    expect(overlayState).toBe('capturing')
-    expect(events).toEqual(['background rendered'])
-    finishUpload()
-    await Promise.all([background, manual])
-    expect(events).toEqual(['background rendered', 'background saved', 'manual saved'])
-    expect(overlayState).toBe('saved')
-    expect(failures).toEqual([])
-    expect(busy.current).toBe(false)
-    await enqueue({}, async () => {
-      events.push('idle autosave')
-    })
-    expect(events.at(-1)).toBe('idle autosave')
-  })
+  test.each(['standard', 'viewport', 'area'] as const)(
+    'a manual %s shutter waits for a background upload; redundant autosaves are dropped',
+    async (captureMode) => {
+      const enqueue = createSnapshotQueue()
+      const busy = { current: false }
+      const failures: SnapshotCaptureFailedEvent[] = []
+      const events: string[] = []
+      let finishUpload!: () => void
+      const uploading = new Promise<void>((resolve) => {
+        finishUpload = resolve
+      })
+      const background = enqueue({ requestId: 'background' }, () =>
+        runSnapshotCapture(
+          'background',
+          busy,
+          async () => {
+            events.push('background rendered')
+            await uploading
+            events.push('background saved')
+          },
+          (failure) => failures.push(failure),
+        ),
+      )
+      await Promise.resolve()
+      expect(busy.current).toBe(true)
+      const autosave = enqueue({}, async () => {
+        events.push('autosave')
+      })
+      let overlayState = 'capturing'
+      const manual = enqueue({ captureMode }, () =>
+        runSnapshotCapture(
+          undefined,
+          busy,
+          async () => {
+            events.push('manual saved')
+            overlayState = 'saved'
+          },
+          (failure) => failures.push(failure),
+        ),
+      )
+      await autosave
+      expect(overlayState).toBe('capturing')
+      expect(events).toEqual(['background rendered'])
+      finishUpload()
+      await Promise.all([background, manual])
+      expect(events).toEqual(['background rendered', 'background saved', 'manual saved'])
+      expect(overlayState).toBe('saved')
+      expect(failures).toEqual([])
+      expect(busy.current).toBe(false)
+      await enqueue({}, async () => {
+        events.push('idle autosave')
+      })
+      expect(events.at(-1)).toBe('idle autosave')
+    },
+  )
 
   test('queues a frame dispatched by a save callback until the previous capture releases its lock', async () => {
     const enqueue = createSnapshotQueue()
@@ -420,3 +422,60 @@ describe('snapshot request correlation', () => {
     expect(failures).toEqual([])
   })
 })
+
+// An agent looks at the scene from a viewpoint of its own (`view_scene` in the hosted chat): the
+// frame is for the agent only, never a project snapshot or the project's thumbnail.
+describe('an ephemeral capture', () => {
+  const cameraData = { position: [0, 0, 0] as [number, number, number], target: null }
+
+  test('comes back to its caller on snapshot:captured and never reaches the host storage', async () => {
+    const stored: Blob[] = []
+    const received: SnapshotCapturedEvent[] = []
+    const onCaptured = (event: SnapshotCapturedEvent) => received.push(event)
+    emitter.on('snapshot:captured', onCaptured)
+    try {
+      const blob = new Blob(['frame'], { type: 'image/webp' })
+      await deliverSnapshot(
+        { requestId: 'view-1', ephemeral: true },
+        blob,
+        {
+          ...cameraData,
+          resolution: { w: 1280, h: 800 },
+          presentation: { mode: 'solo', levelId: 'level_upper' },
+        },
+        (frame) => {
+          stored.push(frame)
+        },
+      )
+      expect(stored).toEqual([])
+      expect(received).toEqual([
+        {
+          requestId: 'view-1',
+          blob,
+          width: 1280,
+          height: 800,
+          presentation: { mode: 'solo', levelId: 'level_upper' },
+        },
+      ])
+    } finally {
+      emitter.off('snapshot:captured', onCaptured)
+    }
+  })
+
+  test('an ephemeral frame with no caller to answer is stored nowhere', async () => {
+    const stored: Blob[] = []
+    await deliverSnapshot({ ephemeral: true }, new Blob(['frame']), cameraData, (frame) => {
+      stored.push(frame)
+    })
+    expect(stored).toEqual([])
+  })
+
+  test('any other capture goes to the host as before', async () => {
+    const stored: Blob[] = []
+    const blob = new Blob(['frame'])
+    await deliverSnapshot({ requestId: 'shot-1' }, blob, cameraData, (frame) => {
+      stored.push(frame)
+    })
+    expect(stored).toEqual([blob])
+  })
+})

package/src/components/editor/snapshot-capture.ts

@@ -1,8 +1,9 @@
-import type {
-  SnapshotCaptureFailedEvent,
-  SnapshotCapturePose,
-  SnapshotSavedEvent,
-  ThumbnailGenerateEvent,
+import {
+  emitter,
+  type SnapshotCaptureFailedEvent,
+  type SnapshotCapturePose,
+  type SnapshotSavedEvent,
+  type ThumbnailGenerateEvent,
 } from '@pascal-app/core'
 import { MathUtils, type PerspectiveCamera } from 'three'
 
@@ -143,3 +144,33 @@ export async function runSnapshotCapture(
     busy.current = false
   }
 }
+
+/**
+ * Where a captured frame goes: to the host, which stores it (a snapshot, the project's
+ * thumbnail), or for an ephemeral capture straight back to its caller, stored nowhere.
+ */
+export function deliverSnapshot<
+  T extends object & {
+    resolution?: { w: number; h: number }
+    presentation?: ThumbnailGenerateEvent['presentation']
+  },
+>(
+  event: Pick<ThumbnailGenerateEvent, 'requestId' | 'ephemeral'>,
+  blob: Blob,
+  cameraData: T,
+  onCapture: (blob: Blob, cameraData: T) => void | Promise<void>,
+): void | Promise<void> {
+  // An ephemeral frame is never stored: with no caller to answer, it is dropped.
+  if (event.ephemeral) {
+    if (event.requestId)
+      emitter.emit('snapshot:captured', {
+        requestId: event.requestId,
+        blob,
+        width: cameraData.resolution?.w ?? 0,
+        height: cameraData.resolution?.h ?? 0,
+        ...(cameraData.presentation ? { presentation: cameraData.presentation } : {}),
+      })
+    return
+  }
+  return onCapture(blob, cameraData)
+}