@pascal-app/editor 1.0.4 → 1.0.6

package/src/store/use-corner-snap-hint.ts

@@ -0,0 +1,47 @@
+import type { CornerBlockReason } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/**
+ * What the window being placed or dragged near a wall end says: `join` when a window already waits
+ * on the other wall, `new` when one would be created, the reason when the end is not a corner a
+ * window can wrap, null away from a wall end. The tools write it; the HUD reads it, so the hint is
+ * there only inside the zone.
+ */
+export type CornerSnapHint = 'join' | 'new' | CornerBlockReason | null
+
+export const useCornerSnapHint = create<{
+  hint: CornerSnapHint
+  setHint: (hint: CornerSnapHint) => void
+}>((set) => ({
+  hint: null,
+  setHint: (hint) => set((state) => (state.hint === hint ? state : { hint })),
+}))
+
+/** One line each, in the HUD's voice: what is in the way, not what to do about it. */
+export const CORNER_BLOCK_NOTES: Record<CornerBlockReason, string> = {
+  free_end: 'No wall meets here',
+  several_walls: 'Three or more walls meet here',
+  angle: 'The walls meet at too sharp or too flat an angle',
+  curved: 'A curved wall takes no corner window',
+  curtain: 'A curtain wall takes no corner window',
+  no_room: 'No room for the matching window on the other wall',
+  in_the_way: 'Another opening is in the way at the corner',
+  too_tall: 'The window waiting there is taller than this wall',
+}
+
+export type CornerHintRow = { keys: string[]; label: string }
+
+/** The HUD rows for a hint, shared by the placement tool and the move HUD. */
+export function cornerHintRows(hint: CornerSnapHint): CornerHintRow[] {
+  if (!hint) return []
+  if (hint === 'join' || hint === 'new')
+    return [
+      {
+        keys: ['Left click'],
+        label: hint === 'join' ? 'Join as a corner window' : 'Corner window',
+      },
+      { keys: ['Alt'], label: 'Place without the corner snap' },
+    ]
+  // The HUD's notice row, as for a placement that does not fit: a note, not a key to press.
+  return [{ keys: ['!'], label: CORNER_BLOCK_NOTES[hint] }]
+}

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-stair-build-preview.ts

@@ -17,12 +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, rise?: number | null): void
+  setPreview(
+    point: StairPreviewPoint | null,
+    rotation: number,
+    rise?: number | null,
+    length?: number | null,
+    stepCount?: number | null,
+  ): void
   rotateBy(deltaRadians: number): void
   reset(): void
 }
@@ -31,6 +39,8 @@ export const useStairBuildPreview = create<StairBuildPreviewState>((set) => ({
   point: null,
   rotation: 0,
   rise: null,
+  length: null,
+  stepCount: null,
   setPoint: (point) =>
     set((state) => {
       const prev = state.point
@@ -38,24 +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, rise) =>
+  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 && (rise === undefined || rise === state.rise)
+      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,
+            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.rise === null
+      state.point === null &&
+      state.rotation === 0 &&
+      state.rise === null &&
+      state.length === null &&
+      state.stepCount === null
         ? state
-        : { point: null, rotation: 0, rise: null },
+        : { point: null, rotation: 0, rise: null, length: null, stepCount: null },
     ),
 }))

package/src/store/view-layout.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, describe, expect, test } from 'bun:test'
-import { availableViews, editorHostViewRegistry, registerEditorHostView } from '../lib/editor-views'
+import {
+  availableViews,
+  editorHostViewRegistry,
+  registerEditorHostView,
+  unregisterEditorHostView,
+} from '../lib/editor-views'
 import useEditor, { normalizePersistedEditorUiState } from './use-editor'
 import {
   activeViewLayout,
@@ -129,6 +134,27 @@ describe('layouts saved before views', () => {
 })
 
 describe('registered views', () => {
+  test('dismissing a document removes it from both workspace layouts, including a hidden split pane', () => {
+    registerEditorHostView({
+      id: 'document:test',
+      label: 'Plan.pdf',
+      icon: { kind: 'iconify', name: 'lucide:file' },
+      component: async () => ({ default: () => null }),
+    })
+    useEditor.getState().showView('document:test', { beside: true })
+    useEditor.getState().setWorkspaceMode('studio')
+    useEditor
+      .getState()
+      .setViewLayout({ ...DEFAULT_VIEW_LAYOUT, panes: [VIEW_3D, 'document:test'] })
+    useEditor.getState().setViewPinned('document:test', true)
+    unregisterEditorHostView('document:test')
+    expect(editorHostViewRegistry.getSnapshot()).toEqual([])
+    expect(useEditor.getState().pinnedViews['document:test']).toBeUndefined()
+    expect(layout().panes).toEqual([VIEW_3D, VIEW_2D])
+    useEditor.getState().setWorkspaceMode('edit')
+    expect(layout()).toMatchObject({ split: false, panes: [VIEW_3D, VIEW_2D] })
+  })
+
   test('a plugin view is offered only where its plugin is installed and its workspace matches', () => {
     registerEditorHostView({
       id: 'acme:pets',

package/src/store/view-layout.ts

@@ -113,7 +113,10 @@ export function withSplitToggled(layout: ViewLayout): ViewLayout {
  */
 export function withoutView(layout: ViewLayout, viewId: string): ViewLayout {
   const pane = paneOfView(layout, viewId)
-  if (pane === null) return layout
+  if (pane === null) {
+    if (layout.panes[1] !== viewId) return layout
+    return { ...layout, panes: [layout.panes[0], layout.panes[0] === VIEW_3D ? VIEW_2D : VIEW_3D] }
+  }
   const kept = layout.split ? layout.panes[pane === 0 ? 1 : 0] : VIEW_3D
   return { ...layout, split: false, panes: [kept, kept === VIEW_3D ? VIEW_2D : VIEW_3D], focus: 0 }
 }

package/src/test-utils/render-current-markup.tsx

@@ -0,0 +1,16 @@
+import { spyOn } from 'bun:test'
+import React, { type ReactElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+
+/** Server-renders `element` from the stores' current state, not the startup state a server render reads. */
+export function renderCurrentMarkup(element: ReactElement): string {
+  const useSyncExternalStore = React.useSyncExternalStore
+  const serverSnapshot = spyOn(React, 'useSyncExternalStore').mockImplementation(
+    (subscribe, getSnapshot) => useSyncExternalStore(subscribe, getSnapshot, getSnapshot),
+  )
+  try {
+    return renderToStaticMarkup(element)
+  } finally {
+    serverSnapshot.mockRestore()
+  }
+}

package/src/components/tools/stair/stair-click-guard.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { createStairCommitGate, swallowFollowUpBrowserClick } from './stair-click-guard'
-
-describe('createStairCommitGate', () => {
-  test('allows commits until the session exits', () => {
-    const gate = createStairCommitGate()
-    expect(gate.shouldCommit()).toBe(true)
-    // Repeat continuation: consecutive commits stay allowed.
-    expect(gate.shouldCommit()).toBe(true)
-  })
-
-  test('refuses every trigger after a single-continuation exit', () => {
-    const gate = createStairCommitGate()
-    expect(gate.shouldCommit()).toBe(true)
-    gate.markExited()
-    // The native follow-up click / stray node click of the same gesture.
-    expect(gate.shouldCommit()).toBe(false)
-    expect(gate.shouldCommit()).toBe(false)
-  })
-})
-
-describe('swallowFollowUpBrowserClick', () => {
-  test('stops exactly one follow-up click', () => {
-    const target = new EventTarget()
-    swallowFollowUpBrowserClick(target)
-
-    let firstStopped = 0
-    const first = new Event('click', { cancelable: true })
-    Object.defineProperty(first, 'stopPropagation', { value: () => firstStopped++ })
-    target.dispatchEvent(first)
-    expect(firstStopped).toBe(1)
-    expect(first.defaultPrevented).toBe(true)
-
-    // `once: true` — the next click of the next gesture passes through.
-    let secondStopped = 0
-    const second = new Event('click', { cancelable: true })
-    Object.defineProperty(second, 'stopPropagation', { value: () => secondStopped++ })
-    target.dispatchEvent(second)
-    expect(secondStopped).toBe(0)
-    expect(second.defaultPrevented).toBe(false)
-  })
-
-  test('disarms after the timeout when no click follows', async () => {
-    const target = new EventTarget()
-    swallowFollowUpBrowserClick(target, 5)
-    await new Promise((resolve) => setTimeout(resolve, 15))
-
-    let stopped = 0
-    const late = new Event('click', { cancelable: true })
-    Object.defineProperty(late, 'stopPropagation', { value: () => stopped++ })
-    target.dispatchEvent(late)
-    expect(stopped).toBe(0)
-  })
-
-  test('no-ops without a window-like target', () => {
-    expect(() => swallowFollowUpBrowserClick(undefined)).not.toThrow()
-  })
-})

package/src/components/tools/stair/stair-click-guard.ts

@@ -1,72 +0,0 @@
-/**
- * Guards for the stair tool's commit triggers.
- *
- * One physical validation click can reach the stair tool's commit handler
- * twice: node-surface clicks (`slab:click`, `wall:click`, …) are synthesized
- * on *pointerup* by the viewer (`use-node-events`), while `grid:click` rides
- * the browser's native *click* event from a canvas-level DOM listener
- * (`use-grid-events`) that deliberately ignores R3F stopPropagation — and
- * after a single-continuation commit the tool's emitter subscriptions survive
- * until React unmounts it, which lands only after that native click. Without
- * these guards a validation click over any node surface (a deck or floor
- * slab, a wall, another stair) created TWO stairs from one click.
- *
- * Same hazard and same countermeasures as
- * `packages/nodes/src/shared/floor-placement.ts` (`stopPlacementCommitPropagation`)
- * and the `committed` flag in `move-registry-node-tool.tsx` — reimplemented
- * here because `@pascal-app/editor` cannot depend on `@pascal-app/nodes`.
- */
-
-export type StairCommitGate = {
-  /** True while the armed session may still commit. */
-  shouldCommit: () => boolean
-  /**
-   * Mark the session exited (single continuation): every further click
-   * trigger reaching the still-subscribed handler — the native follow-up
-   * click, a stray second node click — is refused.
-   */
-  markExited: () => void
-}
-
-export function createStairCommitGate(): StairCommitGate {
-  let exited = false
-  return {
-    shouldCommit: () => !exited,
-    markExited: () => {
-      exited = true
-    },
-  }
-}
-
-type ClickSwallowTarget = {
-  addEventListener: (
-    type: string,
-    listener: (event: Event) => void,
-    options?: AddEventListenerOptions,
-  ) => void
-  removeEventListener: (
-    type: string,
-    listener: (event: Event) => void,
-    options?: EventListenerOptions,
-  ) => void
-}
-
-/**
- * Eat the one native browser `click` that follows a pointerup-synthesized
- * node click, before it reaches the canvas `grid:click` listener (capture
- * phase on window runs first). Needed in repeat continuation too, where the
- * tool stays armed and the gate above must keep allowing one commit per
- * gesture. Self-disarms after the click or `timeoutMs`, whichever first.
- */
-export function swallowFollowUpBrowserClick(
-  target: ClickSwallowTarget | undefined = typeof window === 'undefined' ? undefined : window,
-  timeoutMs = 300,
-): void {
-  if (!target) return
-  const swallow = (event: Event) => {
-    event.stopPropagation()
-    event.preventDefault()
-  }
-  target.addEventListener('click', swallow, { capture: true, once: true })
-  setTimeout(() => target.removeEventListener('click', swallow, { capture: true }), timeoutMs)
-}