@pascal-app/editor 0.8.0 → 0.9.2

package/src/store/use-facing-pose.ts

@@ -0,0 +1,44 @@
+// Ephemeral store for the forward-facing floor triangle shown while placing or
+// moving a node. A single editor-side overlay (`<FacingPoseIndicator>`)
+// subscribes and renders the triangle; every placement/move path publishes its
+// ghost pose here instead of drawing its own triangle. This is deliberately the
+// one renderer for the facing indicator: rendering it from inside a tool's own
+// cursor ghost (especially tools living in `@pascal-app/nodes`) left it
+// invisible, while the editor-side overlay renders reliably. Producers clear on
+// commit, cancel, and unmount.
+//
+// Poses are in the same building-local frame the tools already work in (the
+// overlay is mounted inside ToolManager's building-local group).
+
+import { create } from 'zustand'
+
+export type FacingPose = {
+  /** Ghost origin in building-local space. */
+  position: [number, number, number]
+  /** Ghost yaw (radians). The triangle inherits this so it points where the
+   *  node faces. */
+  rotationY: number
+  /** Footprint depth along the ghost's local +Z; the triangle sits just past
+   *  `center[1] + depth / 2`. */
+  depth: number
+  /** Footprint centre offset `[x, z]` in the ghost's local frame. Defaults to
+   *  the origin. Kinds whose forward edge isn't centred on the origin (e.g. a
+   *  stair, whose run starts at the entry) shift the triangle via this. */
+  center?: [number, number]
+  /** Point along local -Z (the front is the -Z side) instead of +Z. */
+  reversed?: boolean
+}
+
+type FacingPoseState = {
+  pose: FacingPose | null
+  set(pose: FacingPose): void
+  clear(): void
+}
+
+const useFacingPose = create<FacingPoseState>((set) => ({
+  pose: null,
+  set: (pose) => set({ pose }),
+  clear: () => set({ pose: null }),
+}))
+
+export default useFacingPose

package/src/store/use-fence-curve-draft.ts

@@ -0,0 +1,21 @@
+// Ephemeral store: how many points the in-progress curved-fence draft has
+// placed. Written by the 3D spline draft tool (`@pascal-app/nodes`
+// fence/tool.tsx) and read by the contextual helper so the "finish curve" hint
+// only surfaces once the user has actually started drawing. Reset on commit,
+// cancel, and unmount — never persisted, never in undo history.
+
+import { create } from 'zustand'
+
+type FenceCurveDraftState = {
+  pointCount: number
+  setPointCount(count: number): void
+  reset(): void
+}
+
+const useFenceCurveDraft = create<FenceCurveDraftState>((set) => ({
+  pointCount: 0,
+  setPointCount: (count) => set({ pointCount: count }),
+  reset: () => set({ pointCount: 0 }),
+}))
+
+export default useFenceCurveDraft

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

@@ -0,0 +1,101 @@
+// Ephemeral store for the 2D floor-plan's in-flight DRAFT preview state — the
+// hot, per-pointer-move values every build/edit tool republishes on `grid:move`
+// (the snapped cursor point today; wall/fence/roof draft endpoints as later
+// slices land here). It exists so those per-move updates DON'T live in
+// `FloorplanPanel`'s own `useState`: the panel is a ~10k-line component whose
+// render costs ~120-220ms, so a `setState` per move made every 2D draft tool
+// feel laggy. Producers write via `getState().setX(...)` (no panel re-render);
+// the small overlay leaves subscribe and re-render alone. Same pattern that
+// keeps stair / column / elevator placement smooth (`useStairBuildPreview`,
+// `usePlacementPreview`).
+//
+// Editor-only. Producers clear on tool-inactive, commit, and unmount.
+
+import type { WallPlanPoint } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/** Screen-space (SVG-local px) cursor point — drives the coordinate badge. */
+type SvgPoint = { x: number; y: number }
+
+type FloorplanDraftPreviewState = {
+  /** Snapped plan-XZ point under the cursor; drives the crosshair + the
+   *  cursor-following polygon-draft preview. `null` when idle. */
+  cursorPoint: WallPlanPoint | null
+  /** Screen-space cursor point driving the coordinate-indicator badge. Set on
+   *  every SVG `pointermove` while a build/select tool is active, so it's the
+   *  single hottest 2D update — keeping it out of panel state is what stops the
+   *  panel re-rendering per move. `null` when idle. */
+  cursorPosition: SvgPoint | null
+  /** Live END point of the open wall / fence / roof draft segment — the per-move
+   *  endpoint that drives the 2D draft polygon + measurement. Each is `null`
+   *  unless that tool's draft is open. The START points stay in panel state
+   *  (set per click, low-frequency). */
+  wallDraftEnd: WallPlanPoint | null
+  fenceDraftEnd: WallPlanPoint | null
+  roofDraftEnd: WallPlanPoint | null
+  /** Set the snapped cursor point. No-ops (skips the store update, so
+   *  subscribers don't re-render) when unchanged — `grid:move` fires far more
+   *  often than the snapped cell actually changes. */
+  setCursorPoint(point: WallPlanPoint | null): void
+  /** Set the screen-space cursor point (deduped on x/y). */
+  setCursorPosition(point: SvgPoint | null): void
+  setWallDraftEnd(point: WallPlanPoint | null): void
+  setFenceDraftEnd(point: WallPlanPoint | null): void
+  setRoofDraftEnd(point: WallPlanPoint | null): void
+  reset(): void
+}
+
+function setPlanPointField(
+  field: 'wallDraftEnd' | 'fenceDraftEnd' | 'roofDraftEnd',
+  point: WallPlanPoint | null,
+) {
+  return (
+    state: FloorplanDraftPreviewState,
+  ): Partial<FloorplanDraftPreviewState> | typeof state => {
+    const prev = state[field]
+    if (!point && !prev) return state
+    if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
+    return { [field]: point }
+  }
+}
+
+export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set) => ({
+  cursorPoint: null,
+  cursorPosition: null,
+  wallDraftEnd: null,
+  fenceDraftEnd: null,
+  roofDraftEnd: null,
+  setCursorPoint: (point) =>
+    set((state) => {
+      const prev = state.cursorPoint
+      if (!point && !prev) return state
+      if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
+      return { cursorPoint: point }
+    }),
+  setCursorPosition: (point) =>
+    set((state) => {
+      const prev = state.cursorPosition
+      if (!point && !prev) return state
+      if (point && prev && prev.x === point.x && prev.y === point.y) return state
+      return { cursorPosition: point }
+    }),
+  setWallDraftEnd: (point) => set(setPlanPointField('wallDraftEnd', point)),
+  setFenceDraftEnd: (point) => set(setPlanPointField('fenceDraftEnd', point)),
+  setRoofDraftEnd: (point) => set(setPlanPointField('roofDraftEnd', point)),
+  reset: () =>
+    set((state) =>
+      state.cursorPoint === null &&
+      state.cursorPosition === null &&
+      state.wallDraftEnd === null &&
+      state.fenceDraftEnd === null &&
+      state.roofDraftEnd === null
+        ? state
+        : {
+            cursorPoint: null,
+            cursorPosition: null,
+            wallDraftEnd: null,
+            fenceDraftEnd: null,
+            roofDraftEnd: null,
+          },
+    ),
+}))

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

@@ -0,0 +1,50 @@
+// Ephemeral store for the 2D floor-plan marquee (box-select) drag — the hot,
+// per-pointer-move rectangle the select tool republishes on every move. It
+// lives here, not in `FloorplanPanel`'s `useState`, for the same reason as
+// `useFloorplanDraftPreview`: the panel is a ~10k-line component whose render
+// costs ~120-220ms, so a `setState` per move made dragging a selection box
+// re-render the whole panel. Producers write via `getState()` (no panel
+// re-render); the small marquee overlay leaf subscribes and re-renders alone.
+//
+// The whole drag struct lives here (not just the moving corner) so the
+// pointer-move / -up handlers read it non-reactively via `getState()` and the
+// panel never subscribes. Editor-only; reset on pointer-up / cancel /
+// tool-inactive.
+
+import type { WallPlanPoint } from '@pascal-app/core'
+import { create } from 'zustand'
+
+export type FloorplanMarqueeDrag = {
+  pointerId: number
+  startClientX: number
+  startClientY: number
+  startPlanPoint: WallPlanPoint
+  /** Moving corner under the cursor — the only field that changes per move. */
+  currentPlanPoint: WallPlanPoint
+}
+
+type FloorplanMarqueeState = {
+  drag: FloorplanMarqueeDrag | null
+  begin(drag: FloorplanMarqueeDrag): void
+  /** Advance the moving corner. No-ops (skips the store update, so the overlay
+   *  doesn't re-render) when the snapped point is unchanged or no drag is open. */
+  setCurrent(point: WallPlanPoint): void
+  reset(): void
+}
+
+export const useFloorplanMarquee = create<FloorplanMarqueeState>((set) => ({
+  drag: null,
+  begin: (drag) => set({ drag }),
+  setCurrent: (point) =>
+    set((state) => {
+      const prev = state.drag
+      if (!prev) return state
+      if (prev.currentPlanPoint[0] === point[0] && prev.currentPlanPoint[1] === point[1]) {
+        return state
+      }
+      return { drag: { ...prev, currentPlanPoint: point } }
+    }),
+  reset: () => set((state) => (state.drag === null ? state : { drag: null })),
+}))
+
+export default useFloorplanMarquee

package/src/store/use-interaction-scope.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import {
+  type ActiveInteractionScope,
+  editingHoleInfo,
+  handleDragInfo,
+  isActive,
+  isIdle,
+  scopeNodeId,
+  selectionEnabled,
+} from '../lib/interaction/scope'
+import useInteractionScope from './use-interaction-scope'
+
+// A placing/moving scope carries the node inline. Tests only assert on id/type,
+// so a structural stand-in is enough.
+const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknown as AnyNode
+
+function reset() {
+  useInteractionScope.getState().end()
+}
+afterEach(reset)
+
+describe('use-interaction-scope state machine', () => {
+  test('starts idle', () => {
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+    expect(isIdle(useInteractionScope.getState().scope)).toBe(true)
+  })
+
+  test('begin enters an interaction; end returns to idle atomically', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'moving',
+      node: mockNode('item_1', 'item'),
+      nodeId: 'item_1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'moving',
+      node: mockNode('item_1', 'item'),
+      nodeId: 'item_1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    s.end()
+    // No interaction payload leaks past end — the scope is plain idle, so a
+    // stale nodeId/handle is unrepresentable.
+    expect(useInteractionScope.getState().scope).toEqual({ kind: 'idle' })
+    expect(scopeNodeId(useInteractionScope.getState().scope)).toBeNull()
+  })
+
+  test('begin is single-owner: a new interaction replaces the prior one', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'drafting', tool: 'wall' })
+    s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
+    const scope = useInteractionScope.getState().scope
+    expect(scope.kind).toBe('handle-drag')
+    // The prior drafting payload is gone — illegal "drafting + handle-drag"
+    // combination is unrepresentable.
+    expect(scopeNodeId(scope)).toBe('wall_1')
+  })
+
+  test('update patches the live payload of the active scope', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'placing',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+      pressDrag: false,
+    })
+    s.update({ pressDrag: true })
+    const scope = useInteractionScope.getState().scope
+    expect(scope.kind === 'placing' && scope.pressDrag).toBe(true)
+  })
+
+  test('update is a no-op when idle', () => {
+    useInteractionScope.getState().update({
+      kind: 'moving',
+      node: mockNode('x', 'item'),
+      nodeId: 'x',
+      nodeType: 'item',
+      view: '3d',
+    })
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('update cannot change which interaction is running', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'moving',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    s.update({
+      kind: 'placing',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+      pressDrag: true,
+    })
+    expect(useInteractionScope.getState().scope.kind).toBe('moving')
+  })
+
+  test('selectionEnabled only while idle', () => {
+    const s = useInteractionScope.getState()
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(true)
+    s.begin({ kind: 'box-select' })
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(false)
+    expect(isActive(useInteractionScope.getState().scope)).toBe(true)
+  })
+
+  test('end is idempotent', () => {
+    const s = useInteractionScope.getState()
+    s.end()
+    s.end()
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+})
+
+describe('derived flag views are leak-free (no parallel flags)', () => {
+  const scope = () => useInteractionScope.getState().scope
+
+  test('handleDragInfo mirrors handle-drag and clears on end', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
+    expect(handleDragInfo(scope())).toEqual({ nodeId: 'wall_1', label: 'height' })
+    s.end()
+    // After end the derived view is null — a stale activeHandleDrag is
+    // unrepresentable because it is a pure function of the single scope.
+    expect(handleDragInfo(scope())).toBeNull()
+  })
+
+  test('editingHoleInfo mirrors a hole reshape and clears on end', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'reshaping', nodeId: 'slab_1', reshape: 'hole', holeIndex: 2 })
+    expect(editingHoleInfo(scope())).toEqual({ nodeId: 'slab_1', holeIndex: 2 })
+    s.end()
+    expect(editingHoleInfo(scope())).toBeNull()
+  })
+
+  test('a non-hole reshape never reads as an editing hole', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'reshaping', nodeId: 'wall_1', reshape: 'curve' })
+    expect(editingHoleInfo(scope())).toBeNull()
+  })
+
+  test('switching interactions never leaks the prior derived view', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
+    // Single-owner replacement: the handle-drag view must vanish the instant a
+    // different interaction begins — the two cannot be simultaneously active.
+    s.begin({ kind: 'reshaping', nodeId: 'slab_1', reshape: 'hole', holeIndex: 0 })
+    expect(handleDragInfo(scope())).toBeNull()
+    expect(editingHoleInfo(scope())).toEqual({ nodeId: 'slab_1', holeIndex: 0 })
+  })
+
+  test('every active scope kind leaves at most the views it owns', () => {
+    const s = useInteractionScope.getState()
+    const kinds: ActiveInteractionScope[] = [
+      {
+        kind: 'placing',
+        node: mockNode('i', 'item'),
+        nodeId: 'i',
+        nodeType: 'item',
+        view: '3d',
+        pressDrag: false,
+      },
+      { kind: 'moving', node: mockNode('i', 'item'), nodeId: 'i', nodeType: 'item', view: '3d' },
+      { kind: 'drafting', tool: 'wall' },
+      { kind: 'box-select' },
+      { kind: 'painting' },
+    ]
+    for (const k of kinds) {
+      s.begin(k)
+      // None of these own a handle-drag or hole view.
+      expect(handleDragInfo(scope())).toBeNull()
+      expect(editingHoleInfo(scope())).toBeNull()
+    }
+    s.end()
+  })
+})

package/src/store/use-interaction-scope.ts

@@ -0,0 +1,132 @@
+'use client'
+
+import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { useRef } from 'react'
+import { create } from 'zustand'
+import { useShallow } from 'zustand/react/shallow'
+import {
+  type ActiveInteractionScope,
+  controlPointReshapeInfo,
+  editingHoleInfo,
+  endpointReshapeInfo,
+  handleDragInfo,
+  IDLE_SCOPE,
+  type InteractionScope,
+  isCurveReshape,
+  movingNodeOf,
+  reshapingNodeId,
+  tangentReshapeInfo,
+} from '../lib/interaction/scope'
+
+// The authoritative interaction state machine. A single owner holds exactly one
+// scope at a time. `begin` enters an interaction (atomically replacing any prior
+// one — a single owner, no producer races), `update` narrows the live payload,
+// and `end` returns to idle atomically so no interaction payload can leak past
+// the end of its interaction. There is no setter that can leave the store in an
+// illegal half-state: the only writable shape is `InteractionScope`.
+
+export type InteractionScopeState = {
+  scope: InteractionScope
+  // Enter an interaction. If one is already active it is ended first, so the
+  // store is always single-owner.
+  begin: (scope: ActiveInteractionScope) => void
+  // Patch the current scope's payload. Ignored when idle, or when the patch's
+  // implied kind differs from the active kind — payload updates must not change
+  // which interaction is running (use `begin` for that).
+  update: (patch: Partial<ActiveInteractionScope>) => void
+  // Return to idle atomically. Both commit and cancel paths call this; the
+  // distinction (write vs revert) lives in the interaction body, not here.
+  end: () => void
+  // Return to idle only if the active scope matches `match`. Used when scope is
+  // driven from independent legacy flag clears, so clearing one flag (e.g. a
+  // fence curve) cannot stomp an unrelated active scope (e.g. a wall move).
+  endIf: (match: (scope: ActiveInteractionScope) => boolean) => void
+}
+
+const useInteractionScope = create<InteractionScopeState>((set, get) => ({
+  scope: IDLE_SCOPE,
+  begin: (scope) => set({ scope }),
+  update: (patch) =>
+    set((state) => {
+      if (state.scope.kind === 'idle') return state
+      if ('kind' in patch && patch.kind !== state.scope.kind) return state
+      return { scope: { ...state.scope, ...patch } as InteractionScope }
+    }),
+  end: () => {
+    if (get().scope.kind === 'idle') return
+    set({ scope: IDLE_SCOPE })
+  },
+  endIf: (match) => {
+    const scope = get().scope
+    if (scope.kind === 'idle') return
+    if (match(scope)) set({ scope: IDLE_SCOPE })
+  },
+}))
+
+// Derived, reference-stable views of the active scope, replacing the legacy
+// `useEditor.activeHandleDrag` / `useEditor.editingHole` flags. `useShallow`
+// keeps the result reference-stable across unrelated scope changes, so hot-path
+// subscribers (camera controls, floating menu) don't re-render on every update.
+export const useActiveHandleDrag = (): { nodeId: string; label: string } | null =>
+  useInteractionScope(useShallow((s) => handleDragInfo(s.scope)))
+
+export const useEditingHole = (): { nodeId: string; holeIndex: number } | null =>
+  useInteractionScope(useShallow((s) => editingHoleInfo(s.scope)))
+
+// Imperative (non-React) reads for event handlers / effects.
+export const getEditingHole = (): { nodeId: string; holeIndex: number } | null =>
+  editingHoleInfo(useInteractionScope.getState().scope)
+
+export const getIsCurveReshape = (): boolean => isCurveReshape(useInteractionScope.getState().scope)
+
+// Replaces the legacy `curvingWall` / `curvingFence` existence flags. The
+// wall-vs-fence distinction (both now map to one `reshaping/'curve'` scope) is
+// recovered by reading the reshaped node's type from `useReshapingNode`.
+export const useIsCurveReshape = (): boolean => useInteractionScope((s) => isCurveReshape(s.scope))
+
+// Replaces the legacy `movingWallEndpoint` / `movingFenceEndpoint` payloads,
+// minus the node (fetch it from `useReshapingNode`).
+export const useEndpointReshape = (): { nodeId: string; endpoint: 'start' | 'end' } | null =>
+  useInteractionScope(useShallow((s) => endpointReshapeInfo(s.scope)))
+
+export const useControlPointReshape = (): { nodeId: string; index: number } | null =>
+  useInteractionScope(useShallow((s) => controlPointReshapeInfo(s.scope)))
+
+export const useTangentReshape = (): { nodeId: string; index: number; side: 'in' | 'out' } | null =>
+  useInteractionScope(useShallow((s) => tangentReshapeInfo(s.scope)))
+
+// The node currently being reshaped (curve / endpoint / hole), looked up live
+// from the scene by the scope's `nodeId`. During a reshape the scene node holds
+// the same data the legacy `curvingWall` / `movingWallEndpoint.wall` carried, so
+// consumers that need the full node (affordance-tool mounts, wall-vs-fence type
+// checks) read it here instead of from a parallel flag.
+export const useReshapingNode = (): AnyNode | null => {
+  const nodeId = useInteractionScope((s) => reshapingNodeId(s.scope))
+  // Snapshot the node ONCE when the reshape begins (keyed on nodeId), like the
+  // legacy `curvingWall` / `movingWallEndpoint.wall` flags did. The affordance
+  // tools write the node live during the drag; subscribing to the live scene
+  // node would feed those writes straight back into the tool — the curve resets
+  // on pointer-stop, the endpoint drag loops and freezes. nodeId is stable for
+  // the whole gesture, so a ref snapshot stays frozen until the next reshape.
+  const snapshot = useRef<{ id: string | null; node: AnyNode | null }>({ id: null, node: null })
+  if (snapshot.current.id !== nodeId) {
+    snapshot.current = {
+      id: nodeId,
+      node: nodeId ? (useScene.getState().nodes[nodeId as AnyNodeId] ?? null) : null,
+    }
+  }
+  return snapshot.current.node
+}
+
+// The node currently being placed or moved. Replaces the legacy
+// `useEditor.movingNode` flag. Unlike `useReshapingNode`, no `useRef` snapshot is
+// needed: the node is carried inline in the scope and set once at `begin`, so it
+// is already a stable reference for the whole gesture (nothing calls `begin` mid
+// drag). Returns null whenever no placing/moving interaction is active.
+export const useMovingNode = (): AnyNode | null => useInteractionScope((s) => movingNodeOf(s.scope))
+
+// Imperative (non-React) read for event handlers / effects.
+export const getMovingNode = (): AnyNode | null =>
+  movingNodeOf(useInteractionScope.getState().scope)
+
+export default useInteractionScope