@pascal-app/editor 1.0.3 → 1.0.5

package/src/store/use-floorplan-draft-preview.ts

@@ -43,6 +43,9 @@ type FloorplanDraftPreviewState = {
   /** First corner of an open rectangle-wall draft; the live cursor is the
    *  opposite corner, so the rectangle tool publishes only per click. */
   wallRectangleDraftStart: WallPlanPoint | null
+  /** Corners placed so far by an open Polygon room. Draft only — no wall is
+   *  written until the polygon completes (`lib/wall-polygon-draft.ts`). */
+  wallPolygonDraftPoints: WallPlanPoint[]
   roofDraftQuarterTurn: boolean
   polygonDraftType: FloorplanPolygonDraftType | null
   polygonDraftPoints: WallPlanPoint[]
@@ -59,6 +62,7 @@ type FloorplanDraftPreviewState = {
   setFenceDraftStart(point: WallPlanPoint | null): void
   setRoofDraftStart(point: WallPlanPoint | null): void
   setWallRectangleDraftStart(point: WallPlanPoint | null): void
+  setWallPolygonDraftPoints(points: readonly WallPlanPoint[]): void
   setRoofDraftQuarterTurn(quarterTurn: boolean): void
   setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
   reset(): void
@@ -102,6 +106,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   fenceDraftStart: null,
   roofDraftStart: null,
   wallRectangleDraftStart: null,
+  wallPolygonDraftPoints: [],
   roofDraftQuarterTurn: false,
   polygonDraftType: null,
   polygonDraftPoints: [],
@@ -126,6 +131,12 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
   setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
   setWallRectangleDraftStart: (point) => set(setPlanPointField('wallRectangleDraftStart', point)),
+  setWallPolygonDraftPoints: (points) =>
+    set((state) =>
+      planPointsEqual(state.wallPolygonDraftPoints, points)
+        ? state
+        : { wallPolygonDraftPoints: points.map(([x, z]) => [x, z]) },
+    ),
   setRoofDraftQuarterTurn: (quarterTurn) =>
     set((state) =>
       state.roofDraftQuarterTurn === quarterTurn ? state : { roofDraftQuarterTurn: quarterTurn },
@@ -147,6 +158,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
       state.fenceDraftStart === null &&
       state.roofDraftStart === null &&
       state.wallRectangleDraftStart === null &&
+      state.wallPolygonDraftPoints.length === 0 &&
       state.roofDraftQuarterTurn === false &&
       state.polygonDraftType === null &&
       state.polygonDraftPoints.length === 0
@@ -161,6 +173,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
             fenceDraftStart: null,
             roofDraftStart: null,
             wallRectangleDraftStart: null,
+            wallPolygonDraftPoints: [],
             roofDraftQuarterTurn: false,
             polygonDraftType: null,
             polygonDraftPoints: [],

package/src/store/use-floorplan-marquee.ts

@@ -13,6 +13,7 @@
 
 import type { WallPlanPoint } from '@pascal-app/core'
 import { create } from 'zustand'
+import useInteractionScope from './use-interaction-scope'
 
 export type FloorplanMarqueeDrag = {
   pointerId: number
@@ -34,7 +35,10 @@ type FloorplanMarqueeState = {
 
 export const useFloorplanMarquee = create<FloorplanMarqueeState>((set) => ({
   drag: null,
-  begin: (drag) => set({ drag }),
+  begin: (drag) => {
+    useInteractionScope.getState().begin({ kind: 'box-select' })
+    set({ drag })
+  },
   setCurrent: (point) =>
     set((state) => {
       const prev = state.drag
@@ -44,7 +48,13 @@ export const useFloorplanMarquee = create<FloorplanMarqueeState>((set) => ({
       }
       return { drag: { ...prev, currentPlanPoint: point } }
     }),
-  reset: () => set((state) => (state.drag === null ? state : { drag: null })),
+  reset: () => {
+    set((state) => {
+      if (!state.drag) return state
+      useInteractionScope.getState().endIf((scope) => scope.kind === 'box-select')
+      return { drag: null }
+    })
+  },
 }))
 
 export default useFloorplanMarquee

package/src/store/use-follow-pascal.test.ts

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { FOLLOW_PASCAL_STORAGE_KEY, useFollowPascal } from './use-follow-pascal'
+
+// Follow Pascal's switch and its pause: touching the camera pauses it and offers "Resume following";
+// a new build starts it again; the switch itself is the person's, kept across sessions.
+beforeEach(() => {
+  useFollowPascal.setState({ on: true, paused: false, building: false })
+})
+
+describe('Follow Pascal', () => {
+  test('is on until the person turns it off, and turning it off clears a pause', () => {
+    expect(useFollowPascal.getState().on).toBe(true)
+    useFollowPascal.getState().pause()
+    expect(useFollowPascal.getState().paused).toBe(true)
+    useFollowPascal.getState().setOn(false)
+    expect(useFollowPascal.getState()).toMatchObject({ on: false, paused: false })
+  })
+
+  test('a pause waits for the person, and only matters while it is on', () => {
+    useFollowPascal.setState({ on: false })
+    useFollowPascal.getState().pause()
+    expect(useFollowPascal.getState().paused).toBe(false)
+    useFollowPascal.setState({ on: true })
+    useFollowPascal.getState().pause()
+    expect(useFollowPascal.getState().paused).toBe(true)
+    useFollowPascal.getState().resume()
+    expect(useFollowPascal.getState().paused).toBe(false)
+  })
+
+  test('a build that begins takes the camera again, even after a pause', () => {
+    useFollowPascal.getState().pause()
+    useFollowPascal.getState().beginBuild()
+    expect(useFollowPascal.getState()).toMatchObject({ paused: false, building: true })
+    useFollowPascal.getState().endBuild()
+    expect(useFollowPascal.getState().building).toBe(false)
+  })
+
+  test('only the switch is kept across sessions', () => {
+    const persisted = (
+      useFollowPascal as unknown as {
+        persist: { getOptions(): { partialize?: (state: unknown) => unknown; name?: string } }
+      }
+    ).persist.getOptions()
+    expect(persisted.name).toBe(FOLLOW_PASCAL_STORAGE_KEY)
+    expect(persisted.partialize?.({ on: false, paused: true, building: true })).toEqual({
+      on: false,
+    })
+  })
+
+  test('the pill offers itself only to a paused follower during a build', () => {
+    const shows = () => {
+      const { on, paused, building } = useFollowPascal.getState()
+      return on && paused && building
+    }
+    useFollowPascal.getState().beginBuild()
+    expect(shows()).toBe(false)
+    useFollowPascal.getState().pause()
+    expect(shows()).toBe(true)
+    useFollowPascal.getState().endBuild()
+    expect(shows()).toBe(false)
+  })
+})

package/src/store/use-follow-pascal.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { create } from 'zustand'
+import { createJSONStorage, persist } from 'zustand/middleware'
+
+export const FOLLOW_PASCAL_STORAGE_KEY = 'pascal-follow-pascal'
+
+/** Reads `localStorage` on each call, so a page without it (a test, a sandbox) still has the store's persist API. */
+const browserStorage = createJSONStorage(() => ({
+  getItem: (key: string) => globalThis.localStorage?.getItem(key) ?? null,
+  setItem: (key: string, value: string) => globalThis.localStorage?.setItem(key, value),
+  removeItem: (key: string) => globalThis.localStorage?.removeItem(key),
+}))
+
+type FollowPascalState = {
+  /** The person's switch: the camera follows what a build works on. Kept across sessions. */
+  on: boolean
+  /** The person took the camera: it stays theirs until they resume or the next build begins. */
+  paused: boolean
+  /** A build is playing (set by the follower from the reveal's own words). */
+  building: boolean
+  setOn: (on: boolean) => void
+  pause: () => void
+  resume: () => void
+  beginBuild: () => void
+  endBuild: () => void
+}
+
+/** Follow Pascal's switch, its pause and whether a build is being followed. */
+const useFollowPascal = create<FollowPascalState>()(
+  persist(
+    (set, get) => ({
+      on: true,
+      paused: false,
+      building: false,
+      setOn: (on) => set({ on, paused: false }),
+      pause: () => {
+        if (get().on) set({ paused: true })
+      },
+      resume: () => set({ paused: false }),
+      beginBuild: () => set({ building: true, paused: false }),
+      endBuild: () => set({ building: false }),
+    }),
+    {
+      name: FOLLOW_PASCAL_STORAGE_KEY,
+      storage: browserStorage,
+      partialize: (state) => ({ on: state.on }),
+    },
+  ),
+)
+
+export default useFollowPascal
+export { useFollowPascal }

package/src/store/use-point-ask.ts

@@ -0,0 +1,247 @@
+'use client'
+
+import type { PointAskSubmit, PointCamera } from '@pascal-app/core'
+import { create } from 'zustand'
+import type { CompareRefusal } from '../lib/point-ask/compare'
+import { createPin, type PinEvent, type PinModel, reducePin } from '../lib/point-ask/pin-machine'
+import type { PointTarget, Rect, ScreenPoint } from '../lib/point-ask/types'
+
+// Point and ask's state (the owner, 8 October). Everything the overlay draws comes from here, and
+// everything that changes per frame (positions) is derived from it, not stored in it.
+
+export type WorldBox = { min: [number, number, number]; max: [number, number, number] }
+
+/** A pointed element with its world box, so the overlay can outline and anchor to it. */
+export type BubbleTarget = PointTarget & { box: WorldBox | null }
+
+export type PointHit = {
+  point: [number, number, number]
+  normal: [number, number, number]
+  face?: 'interior' | 'exterior' | 'top' | 'bottom'
+}
+
+export type PointHover = {
+  target: BubbleTarget
+  /** The surface the pick came through when it picked its room (the "⌥ the wall" line). */
+  ambiguous: boolean
+  hit: PointHit
+}
+
+export type PointCrop = {
+  state: 'none' | 'pending' | 'ready' | 'failed'
+  dataUrl?: string
+  width?: number
+  height?: number
+  marked?: boolean
+}
+
+/** A dragged rectangle (spec 2.3): drawn while the person drags, then settled until the ask goes or is dismissed. */
+export type RegionState = {
+  rect: Rect
+  sizeLabel: string | null
+  settled: boolean
+  /** Changes when the shutter fires, so the marquee flashes once. */
+  flashKey: number
+}
+
+/** What a region bubble is about: the rectangle, the point its tail points at, and what is in it. */
+export type BubbleArea = {
+  rect: Rect
+  click: ScreenPoint
+  ids: string[]
+  more: number
+}
+
+export type PointBubble = {
+  targets: BubbleTarget[]
+  /** Where the finger landed, world metres: the bubble's tail and the pin's spot. */
+  anchor: [number, number, number]
+  hit: PointHit
+  gesture: 'click' | 'multi' | 'region'
+  /** The moment of pointing (pointer-down), ISO. */
+  capturedAt: string
+  /** The view the person pointed from, recorded at pointer-down. */
+  camera: PointCamera | null
+  crop: PointCrop
+  draft: string
+  /** Why the last send did not go (out of credits, no chat): shown in the bubble, the draft kept. */
+  error: string | null
+  /** A region's rectangle, 0-1 of the canvas, when the gesture was a drag. */
+  region?: [number, number, number, number]
+  /** Set when the bubble is about a region: it is a view, not a selection, so it has no targets. */
+  area?: BubbleArea
+  /**
+   * Set when the bubble asks for more on what a done pin changed ("Change more"): that pin gives
+   * way while the bubble is open and goes when this ask is sent. The chips offer something else.
+   */
+  changesAsk?: { askId: string; after: string }
+}
+
+export type PinRecord = {
+  model: PinModel
+  /** The spot in the world at send, so the pin shows where it was planted when its target is gone. */
+  anchor: [number, number, number]
+  /** The same spot in the first target's own frame, so it rides along when Pascal moves the element. */
+  local: { nodeId: string; offset: [number, number, number] } | null
+  /** "Window · Kitchen, north wall": the chat chip's words. */
+  label: string
+  levelId: string | null
+  before?: PointCrop
+  after?: PointCrop
+  /** When the pin may retire (ms epoch), set once its turn ends and it is out of the person's way. */
+  retireAt: number | null
+  /** What was handed to the chat, kept for "Try again". */
+  submit?: PointAskSubmit
+  /** "Change more" was sent from this pin's card: the new ask's pin stands in for it. */
+  supersededBy?: string
+  createdAt: number
+}
+
+type PointAskState = {
+  active: boolean
+  /** A tap latched the mode; a hold keeps it only while the key is down. */
+  latched: boolean
+  hover: PointHover | null
+  alt: boolean
+  shift: boolean
+  bubble: PointBubble | null
+  /** Drafts kept per first target until the mode leaves ("no, that one" keeps the words). */
+  drafts: Record<string, string>
+  pins: Record<string, PinRecord>
+  pinOrder: string[]
+  /** The host's "Playful touches" setting: false turns the flash, ripples and sounds off. */
+  playful: boolean
+  /** Pascal is on a turn, so a new ask will wait its turn (the Send button says Queue). */
+  busy: boolean
+  /**
+   * Messages already wait in the chat's queue, or are held there after an error: a new ask goes
+   * behind them (the Send button says Queue) though no turn runs. Apart from `busy`, which says a
+   * turn runs and ends Follow Pascal and settles the pins.
+   */
+  behindQueue: boolean
+  /** The pin whose card is open (hover or focus of the pin, or its own 4 s opening). */
+  cardFor: string | null
+  /** The rectangle being dragged or just released. */
+  region: RegionState | null
+  /** The ask whose "before" is on screen while a compare control is held, or null. */
+  comparing: string | null
+  /** A hold that did not start, for its card to say why. */
+  compareRefusal: { askId: string; reason: CompareRefusal } | null
+  /** How the last bubble left, so the exit can fold into a pin (send) or just shrink (dismiss). */
+  closeKind: 'send' | 'dismiss'
+
+  setActive: (active: boolean, latched?: boolean) => void
+  setLatched: (latched: boolean) => void
+  setRegion: (region: RegionState | null) => void
+  setComparing: (askId: string | null) => void
+  setCompareRefusal: (refusal: { askId: string; reason: CompareRefusal } | null) => void
+  setModifiers: (alt: boolean, shift: boolean) => void
+  setHover: (hover: PointHover | null) => void
+  openBubble: (bubble: PointBubble) => void
+  patchBubble: (patch: Partial<PointBubble>) => void
+  closeBubble: (kind?: 'send' | 'dismiss') => void
+  rememberDraft: (key: string, text: string) => void
+  addPin: (pin: PinRecord) => void
+  patchPin: (askId: string, patch: Partial<Omit<PinRecord, 'model'>>) => void
+  dispatchPin: (askId: string, event: PinEvent) => void
+  removePin: (askId: string) => void
+  setPlayful: (playful: boolean) => void
+  setBusy: (busy: boolean) => void
+  setBehindQueue: (behindQueue: boolean) => void
+  openCard: (askId: string | null) => void
+}
+
+export const usePointAsk = create<PointAskState>((set) => ({
+  active: false,
+  latched: false,
+  hover: null,
+  alt: false,
+  shift: false,
+  bubble: null,
+  drafts: {},
+  pins: {},
+  pinOrder: [],
+  playful: true,
+  busy: false,
+  behindQueue: false,
+  cardFor: null,
+  closeKind: 'dismiss',
+  region: null,
+  comparing: null,
+  compareRefusal: null,
+
+  setActive: (active, latched = false) =>
+    set((state) =>
+      active === state.active && latched === state.latched
+        ? state
+        : active
+          ? { active, latched }
+          : { active: false, latched: false, hover: null, bubble: null, region: null, drafts: {} },
+    ),
+  setLatched: (latched) => set((state) => (state.latched === latched ? state : { latched })),
+  setRegion: (region) => set((state) => (state.region === region ? state : { region })),
+  setComparing: (comparing) =>
+    set((state) => (state.comparing === comparing ? state : { comparing })),
+  setCompareRefusal: (compareRefusal) => set({ compareRefusal }),
+  setModifiers: (alt, shift) =>
+    set((state) => (state.alt === alt && state.shift === shift ? state : { alt, shift })),
+  setHover: (hover) =>
+    set((state) => {
+      if (state.hover === hover) return state
+      if (state.hover && hover && state.hover.target.id === hover.target.id) {
+        const same =
+          state.hover.ambiguous === hover.ambiguous &&
+          state.hover.hit.point.every((v, i) => v === hover.hit.point[i])
+        if (same) return state
+      }
+      return { hover }
+    }),
+  openBubble: (bubble) => set({ bubble }),
+  patchBubble: (patch) =>
+    set((state) => (state.bubble ? { bubble: { ...state.bubble, ...patch } } : state)),
+  closeBubble: (kind = 'dismiss') =>
+    set((state) => (state.bubble ? { bubble: null, closeKind: kind } : state)),
+  rememberDraft: (key, text) =>
+    set((state) => {
+      if ((state.drafts[key] ?? '') === text) return state
+      const drafts = { ...state.drafts }
+      if (text) drafts[key] = text
+      else delete drafts[key]
+      return { drafts }
+    }),
+  addPin: (pin) =>
+    set((state) => ({
+      pins: { ...state.pins, [pin.model.askId]: pin },
+      pinOrder: [...state.pinOrder.filter((id) => id !== pin.model.askId), pin.model.askId],
+    })),
+  patchPin: (askId, patch) =>
+    set((state) => {
+      const pin = state.pins[askId]
+      return pin ? { pins: { ...state.pins, [askId]: { ...pin, ...patch } } } : state
+    }),
+  dispatchPin: (askId, event) =>
+    set((state) => {
+      const pin = state.pins[askId]
+      if (!pin) return state
+      const model = reducePin(pin.model, event)
+      return model === pin.model ? state : { pins: { ...state.pins, [askId]: { ...pin, model } } }
+    }),
+  removePin: (askId) =>
+    set((state) => {
+      if (!state.pins[askId]) return state
+      const pins = { ...state.pins }
+      delete pins[askId]
+      return { pins, pinOrder: state.pinOrder.filter((id) => id !== askId) }
+    }),
+  setPlayful: (playful) => set((state) => (state.playful === playful ? state : { playful })),
+  setBusy: (busy) => set((state) => (state.busy === busy ? state : { busy })),
+  setBehindQueue: (behindQueue) =>
+    set((state) => (state.behindQueue === behindQueue ? state : { behindQueue })),
+  openCard: (askId) => set((state) => (state.cardFor === askId ? state : { cardFor: askId })),
+}))
+
+/** Whether a new ask waits its turn: a turn runs, or messages already wait in the queue. */
+export const asksWait = (state: Pick<PointAskState, 'busy' | 'behindQueue'>) =>
+  state.busy || state.behindQueue
+
+export { createPin }

package/src/store/use-quick-measurement-hud.ts

@@ -1,6 +1,6 @@
 import type { QuickMeasurementReport } from '@pascal-app/core'
 import { create } from 'zustand'
-import type { ViewMode } from './use-editor'
+import type { VisibleScene } from './view-layout'
 
 export type QuickMeasurementHudSource = '2d' | '3d'
 
@@ -55,9 +55,9 @@ export const useQuickMeasurementHud = create<QuickMeasurementHudState>((set) =>
 
 export function selectQuickMeasurementHudEntry(
   state: QuickMeasurementHudState,
-  viewMode: ViewMode,
+  scene: VisibleScene | null,
 ): QuickMeasurementHudEntry | null {
-  const source = viewMode === 'split' ? state.activeSource : viewMode
+  const source = scene === 'split' ? state.activeSource : scene
   return source ? state.sources[source] : null
 }
 

package/src/store/use-stair-build-preview.ts

@@ -17,11 +17,20 @@ type StairBuildPreviewState = {
   point: StairPreviewPoint | null
   /** Yaw (radians), cycled by R / T. */
   rotation: number
+  length: number | null
+  stepCount: number | null
+  rise: number | null
   /** Set the snapped point. No-ops (skips the store update, so subscribers
    *  don't re-render) when the point is unchanged — `grid:move` fires far more
    *  often than the snapped cell actually changes. */
   setPoint(point: StairPreviewPoint | null): void
-  setPreview(point: StairPreviewPoint | null, rotation: number): void
+  setPreview(
+    point: StairPreviewPoint | null,
+    rotation: number,
+    rise?: number | null,
+    length?: number | null,
+    stepCount?: number | null,
+  ): void
   rotateBy(deltaRadians: number): void
   reset(): void
 }
@@ -29,6 +38,9 @@ type StairBuildPreviewState = {
 export const useStairBuildPreview = create<StairBuildPreviewState>((set) => ({
   point: null,
   rotation: 0,
+  rise: null,
+  length: null,
+  stepCount: null,
   setPoint: (point) =>
     set((state) => {
       const prev = state.point
@@ -36,18 +48,34 @@ export const useStairBuildPreview = create<StairBuildPreviewState>((set) => ({
       if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
       return { point: point ? [point[0], point[1]] : null }
     }),
-  setPreview: (point, rotation) =>
+  setPreview: (point, rotation, rise, length = null, stepCount = null) =>
     set((state) => {
       const samePoint =
         (!point && !state.point) ||
         Boolean(point && state.point && state.point[0] === point[0] && state.point[1] === point[1])
-      return samePoint && state.rotation === rotation
+      return samePoint &&
+        state.rotation === rotation &&
+        (rise === undefined || rise === state.rise) &&
+        length === state.length &&
+        stepCount === state.stepCount
         ? state
-        : { point: point ? [point[0], point[1]] : null, rotation }
+        : {
+            point: point ? [point[0], point[1]] : null,
+            rotation,
+            length,
+            stepCount,
+            rise: rise === undefined ? state.rise : rise,
+          }
     }),
   rotateBy: (deltaRadians) => set((state) => ({ rotation: state.rotation + deltaRadians })),
   reset: () =>
     set((state) =>
-      state.point === null && state.rotation === 0 ? state : { point: null, rotation: 0 },
+      state.point === null &&
+      state.rotation === 0 &&
+      state.rise === null &&
+      state.length === null &&
+      state.stepCount === null
+        ? state
+        : { point: null, rotation: 0, rise: null, length: null, stepCount: null },
     ),
 }))

package/src/store/use-wall-move-ghosts.ts

@@ -10,8 +10,10 @@ import { create } from 'zustand'
  * as translucent ghost meshes mid-drag; the 2D `wallFloorplanMoveTarget`
  * writes here so the floor-plan SVG layer can render the same hint.
  *
- * Writer: `packages/nodes/src/wall/floorplan-move.ts` (on each `apply`,
- * cleared on `commit` and by the move overlay's cleanup).
+ * Writers: `packages/nodes/src/wall/floorplan-move.ts` (on each `apply`,
+ * cleared on `commit` and by the move overlay's cleanup), and the wall push
+ * preview in `lib/room-handle-drag.ts` (the pieces a push would create,
+ * cleared when the push previews again, commits or cancels).
  * Reader: `packages/editor/src/components/editor-2d/floorplan-wall-move-ghost-layer.tsx`.
  */
 export type WallMoveGhostBridge = {