@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/ceiling-region-session.test.ts

@@ -0,0 +1,179 @@
+import { afterAll, afterEach, beforeEach, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  CeilingNode,
+  clearSceneHistory,
+  LevelNode,
+  useScene,
+  ZoneNode,
+} from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import {
+  describeCeilingRegionRoom,
+  floorRegionRoomGone,
+  moveFloorRegion,
+  PICK_MATERIAL_MESSAGE,
+  pressFloorRegion,
+  releaseFloorRegion,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import type { FloorRegionPoint } from './floor-region-snap'
+import { paintRegionHoverHint, usePaintRegionMode } from './paint-region-mode'
+
+// Rectangle and Polygon on a ceiling: the floor's outline gesture, drawn on the
+// ceiling's underside, committing one region to the room (an automatic
+// ceiling) or to the ceiling (a manual one) in one undo step.
+
+const square = (x: number, z: number, size: number): [number, number][] => [
+  [x, z],
+  [x + size, z],
+  [x + size, z + size],
+  [x, z + size],
+]
+const OFF = { mode: 'off', step: 0.5 } as const
+const CLOSE = 0.2
+
+const level = LevelNode.parse({ id: 'level_ceiling_region' })
+const zone = ZoneNode.parse({
+  id: 'zone_ceiling_region',
+  name: 'Room',
+  parentId: level.id,
+  polygon: square(0, 0, 4),
+  floor: { regions: [{ id: 'rug', polygon: square(1, 1, 1), finish: 'library:tile' }] },
+})
+// A floor opening cut the room's ceiling in two; both parts are the room's.
+const west = CeilingNode.parse({
+  id: 'ceiling_west',
+  parentId: level.id,
+  polygon: [
+    [0, 0],
+    [2, 0],
+    [2, 4],
+    [0, 4],
+  ],
+  boundary: 'auto',
+  zoneId: zone.id,
+  height: 2.5,
+})
+const east = CeilingNode.parse({
+  ...west,
+  id: 'ceiling_east',
+  polygon: [
+    [2.5, 0],
+    [4, 0],
+    [4, 4],
+    [2.5, 4],
+  ],
+})
+const manual = CeilingNode.parse({
+  id: 'ceiling_manual',
+  parentId: level.id,
+  polygon: square(6, 0, 2),
+  height: 2.2,
+})
+const nodes = Object.fromEntries(
+  [level, zone, west, east, manual].map((node) => [node.id, node]),
+) as Record<string, AnyNode>
+
+const stubbed: string[] = []
+const before = useScene.getState()
+const node = <T extends AnyNode>(id: string) => useScene.getState().nodes[id as AnyNodeId] as T
+const history = () => useScene.temporal.getState().pastStates.length
+
+function drag(ceiling: CeilingNode, from: FloorRegionPoint, to: FloorRegionPoint) {
+  const room = describeCeilingRegionRoom(useScene.getState().nodes, ceiling)
+  pressFloorRegion('rectangle', room, from, OFF, CLOSE)
+  moveFloorRegion(to, OFF, CLOSE)
+  releaseFloorRegion(CLOSE)
+}
+
+beforeEach(() => {
+  globalThis.requestAnimationFrame ??= (callback) => {
+    callback(0)
+    return 0
+  }
+  globalThis.cancelAnimationFrame ??= () => {}
+  if (!globalThis.window) {
+    globalThis.window = new EventTarget() as Window & typeof globalThis
+    stubbed.push('window')
+  }
+  useScene.setState({ nodes, materials: {}, readOnly: false })
+  useScene.temporal.getState().resume()
+  clearSceneHistory()
+  useEditor.setState({
+    mode: 'material-paint',
+    activePaintMaterial: { materialPreset: 'library:blue', sourceTarget: 'ceiling' } as never,
+  })
+  usePaintRegionMode.getState().setMode('rectangle')
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+})
+afterEach(() => {
+  useScene.setState(before)
+  usePaintRegionMode.getState().setMode('surface')
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+  useEditor.setState({ mode: 'select', activePaintMaterial: null })
+})
+afterAll(async () => {
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  for (const key of stubbed.splice(0)) delete (globalThis as Record<string, unknown>)[key]
+})
+
+test('an automatic ceiling draws on every part of its room, at the plane it draws at', () => {
+  const room = describeCeilingRegionRoom(nodes, west)
+  expect(room).toMatchObject({ zoneId: zone.id, ceilingId: west.id, levelId: level.id })
+  expect(room.elevation).toBeCloseTo(2.49)
+  expect(area(room.clear)).toBeCloseTo(8 + 6)
+  expect(describeCeilingRegionRoom(nodes, manual)).toMatchObject({ zoneId: manual.id })
+})
+
+test('a rectangle on a room ceiling paints one room region, clipped to the ceiling', () => {
+  drag(west, [1, 1], [3, 3])
+  const regions = node<ZoneNode>(zone.id).ceiling?.regions ?? []
+  expect(regions).toHaveLength(1)
+  expect(regions[0]!.finish).toBe('library:blue')
+  // Across the opening gap: 1 × 2 on the west part, 0.5 × 2 on the east part.
+  expect(area([{ outer: regions[0]!.polygon, holes: [] }])).toBeGreaterThan(2.9)
+  expect(history()).toBe(1)
+  // The floor is untouched.
+  expect(node<ZoneNode>(zone.id).floor).toEqual(zone.floor)
+  expect(useFloorRegionDraft.getState().draft).toBeNull()
+})
+
+test('a polygon on a manual ceiling paints the ceiling itself', () => {
+  usePaintRegionMode.getState().setMode('polygon')
+  const room = describeCeilingRegionRoom(useScene.getState().nodes, manual)
+  for (const point of [
+    [6.2, 0.2],
+    [7.5, 0.2],
+    [7.5, 1.5],
+    [6.2, 0.2],
+  ] as FloorRegionPoint[]) {
+    pressFloorRegion('polygon', room, point, OFF, CLOSE)
+    releaseFloorRegion(CLOSE)
+  }
+  expect(node<CeilingNode>(manual.id).regions).toHaveLength(1)
+  expect(node<ZoneNode>(zone.id).ceiling).toBeUndefined()
+  expect(history()).toBe(1)
+})
+
+test('outside the ceiling, or with nothing to paint with, nothing is written', () => {
+  drag(manual, [10, 10], [12, 12])
+  expect(node<CeilingNode>(manual.id).regions).toBeUndefined()
+  useEditor.setState({ activePaintMaterial: null })
+  drag(manual, [6.5, 0.5], [7.5, 1.5])
+  expect(node<CeilingNode>(manual.id).regions).toBeUndefined()
+  expect(usePaintRegionMode.getState().notice).toBe(PICK_MATERIAL_MESSAGE)
+  expect(history()).toBe(0)
+})
+
+test('a ceiling draft ends when its ceiling goes; the hints name ceilings', () => {
+  const room = describeCeilingRegionRoom(nodes, manual)
+  pressFloorRegion('rectangle', room, [6.5, 0.5], OFF, CLOSE)
+  const { [manual.id]: _, ...rest } = nodes
+  expect(floorRegionRoomGone(rest)).toBe(true)
+  expect(floorRegionRoomGone(nodes)).toBe(false)
+  expect(paintRegionHoverHint('polygon')).toBe('Hover a floor or ceiling')
+  expect(paintRegionHoverHint('rectangle')).toBe('Hover a wall, floor or ceiling')
+})

package/src/lib/contextual-help.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, test } from 'bun:test'
-import { resolveSelectModeHelpHints } from './contextual-help'
+import { resolveRotateHandleHelpHints, resolveSelectModeHelpHints } from './contextual-help'
+
+test('rotation advertises Alt as the temporary free-rotation override', () => {
+  expect(resolveRotateHandleHelpHints(false)).toEqual([
+    { keys: ['Alt'], label: 'Hold to rotate freely', active: false },
+  ])
+  expect(resolveRotateHandleHelpHints(true)).toEqual([
+    { keys: ['Alt'], label: 'Rotating freely (no angle step)', active: true },
+  ])
+})
 
 describe('resolveSelectModeHelpHints', () => {
   test('stays hidden in idle select mode with no selection', () => {
@@ -117,4 +126,21 @@ describe('resolveSelectModeHelpHints', () => {
       },
     ])
   })
+
+  test('shows the single-side radius hint for rounded openings', () => {
+    expect(
+      resolveSelectModeHelpHints({
+        selectedCount: 1,
+        hasMovableSelection: true,
+        hasRotatableSelection: false,
+        hasOpeningRadiusSelection: true,
+        commandPressed: false,
+        shiftPressed: false,
+      }),
+    ).toContainEqual({
+      keys: ['Shift'],
+      label: 'Adjust one side’s corner radius',
+      active: false,
+    })
+  })
 })

package/src/lib/contextual-help.ts

@@ -11,8 +11,8 @@ export type ContextualShortcutHint = {
 }
 
 // `activeHandleDrag.label` value a rotate gizmo sets while dragging, so the
-// contextual HUD can surface the Shift = free-rotation toggle for the duration
-// (mirrors how wall drafting advertises Shift). Distinct from resize handles,
+// contextual HUD can surface the rotation snapping mode for the duration.
+// Distinct from resize handles,
 // which route their own measurement label here.
 export const ROTATE_HANDLE_DRAG_LABEL = 'rotate-handle'
 
@@ -29,15 +29,12 @@ export const RESIZE_HANDLE_DRAG_LABEL = 'resize-handle'
 export const GROUP_MOVE_DRAG_LABEL = 'group-move-handle'
 export const GROUP_ROTATE_DRAG_LABEL = 'group-rotate-handle'
 
-// Hints shown while a rotate gizmo is mid-drag: Shift bypasses the angle step
-// (free rotation), the same toggle wall drafting exposes. `active` lights the
-// pill while Shift is held.
-export function resolveRotateHandleHelpHints(shiftPressed: boolean): ContextualShortcutHint[] {
+export function resolveRotateHandleHelpHints(altPressed: boolean): ContextualShortcutHint[] {
   return [
     {
-      keys: [SHIFT_KEY],
-      label: shiftPressed ? 'Rotating freely (no angle step)' : 'Hold to rotate freely',
-      active: shiftPressed,
+      keys: [ALT_KEY],
+      label: altPressed ? 'Rotating freely (no angle step)' : 'Hold to rotate freely',
+      active: altPressed,
     },
   ]
 }
@@ -46,6 +43,7 @@ export type SelectModeHelpContext = {
   selectedCount: number
   hasMovableSelection: boolean
   hasRotatableSelection: boolean
+  hasOpeningRadiusSelection?: boolean
   commandPressed: boolean
   shiftPressed: boolean
   // When a single MEP node is selected its in-world handle rig (click a dot to
@@ -67,6 +65,7 @@ export function resolveSelectModeHelpHints({
   selectedCount,
   hasMovableSelection,
   hasRotatableSelection,
+  hasOpeningRadiusSelection = false,
   commandPressed,
   shiftPressed,
   mepSelection = null,
@@ -142,6 +141,14 @@ export function resolveSelectModeHelpHints({
     })
   }
 
+  if (hasOpeningRadiusSelection) {
+    hints.push({
+      keys: [SHIFT_KEY],
+      label: 'Adjust one side’s corner radius',
+      active: shiftPressed,
+    })
+  }
+
   hints.push({
     keys: [[COMMAND_KEY, SHIFT_KEY], LEFT_CLICK],
     label: 'Add or remove objects from the selection',

package/src/lib/continuation.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from 'bun:test'
-import { CONTINUATION_PROFILES, continuationContextOf, nextContinuation } from './continuation'
+import {
+  CONTINUATION_PROFILES,
+  continuationContextOf,
+  keyCyclableContinuationContext,
+  nextContinuation,
+} from './continuation'
 
 describe('canopy continuation', () => {
   test('maps the canopy tool to its own single and continuous profile', () => {
@@ -9,3 +14,16 @@ describe('canopy continuation', () => {
     expect(nextContinuation('canopy', 'continuous')).toBe('single')
   })
 })
+
+describe('wall drawing mode', () => {
+  test('is picked in the Build panel, never cycled by C or a HUD chip', () => {
+    expect(CONTINUATION_PROFILES.wall.options).toEqual(['room', 'single', 'rectangle'])
+    expect(keyCyclableContinuationContext('wall')).toBeNull()
+  })
+
+  test('other contexts still cycle from the keyboard', () => {
+    expect(keyCyclableContinuationContext('fence')).toBe('fence')
+    expect(keyCyclableContinuationContext('point')).toBe('point')
+    expect(keyCyclableContinuationContext(null)).toBeNull()
+  })
+})

package/src/lib/continuation.ts

@@ -8,26 +8,37 @@ export const CONTINUATION_PROFILES: Record<
     default: ContinuationMode
     labels: Record<string, string>
     icons: Record<string, string>
+    /**
+     * Picked once from the Build panel before drawing (`wall-draw-variant.ts`),
+     * never cycled by C or a HUD chip mid-draw.
+     */
+    chosenInPanel?: boolean
   }
 > = {
+  // The wall tool's drawing mode: a chain that closes into a room ('room', the
+  // Build panel's Polygon), one wall per two clicks ('single', Walls), or a
+  // two-corner box of four walls ('rectangle', Rectangle).
   wall: {
-    options: ['room', 'single'],
+    options: ['room', 'single', 'rectangle'],
     default: 'room',
-    labels: { room: 'Room (auto-close)', single: 'Single wall' },
-    icons: { room: 'lucide:square', single: 'lucide:minus' },
+    labels: { room: 'Polygon room', single: 'Walls', rectangle: 'Rectangle room' },
+    icons: { room: 'lucide:pentagon', single: 'lucide:minus', rectangle: 'lucide:square' },
+    chosenInPanel: true,
   },
   fence: {
-    options: ['single', 'continuous', 'curved'],
+    options: ['single', 'continuous', 'curved', 'freehand'],
     default: 'continuous',
     labels: {
       continuous: 'Continuous',
       single: 'Single fence',
       curved: 'Curved fence',
+      freehand: 'Freehand fence',
     },
     icons: {
       continuous: 'lucide:waypoints',
       single: 'lucide:minus',
       curved: 'lucide:spline',
+      freehand: 'lucide:scribble',
     },
   },
   point: {
@@ -62,6 +73,16 @@ export function nextContinuation(
   return profile.options[(index + 1) % profile.options.length] ?? profile.default
 }
 
+/**
+ * The context C and the HUD chip may cycle — null when there is none, or when
+ * its mode is chosen in the Build panel instead.
+ */
+export function keyCyclableContinuationContext(
+  context: ContinuationContext | null,
+): ContinuationContext | null {
+  return context && !CONTINUATION_PROFILES[context].chosenInPanel ? context : null
+}
+
 export function continuationContextOf(kind: string): ContinuationContext | null {
   if (kind === 'wall') return 'wall'
   if (kind === 'fence') return 'fence'

package/src/lib/door-interaction.ts

@@ -86,3 +86,17 @@ export function closeDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimatio
   const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
   startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, 0, options)
 }
+
+export function openDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions) {
+  const node = useScene.getState().nodes[doorId]
+  if (node?.type !== 'door' || node.openingKind === 'opening') return
+
+  if (isOperationDoorType(node.doorType)) {
+    const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState)
+    startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 1, options)
+    return
+  }
+
+  const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
+  startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, DOOR_SWING_OPEN_ANGLE, options)
+}

package/src/lib/editor-level-display.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { BuildingNode, LevelNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor, { type CaptureMode } from '../store/use-editor'
+import { showsWholeBuilding } from './editor-level-display'
+
+const building = BuildingNode.parse({ id: 'building_capture', children: [] })
+const levels = [0, 1, 2].map((level) =>
+  LevelNode.parse({ id: `level_capture_${level}`, level, parentId: building.id }),
+)
+const [ground, first, second] = levels.map((level) => level.id) as [
+  LevelNode['id'],
+  LevelNode['id'],
+  LevelNode['id'],
+]
+
+const wholeBuilding = () => {
+  const state = useEditor.getState()
+  return showsWholeBuilding({
+    isPreviewMode: state.isPreviewMode,
+    isFirstPersonMode: state.isFirstPersonMode,
+    captureMode: state.captureMode,
+    captureLevelId: state.captureLevelId,
+  })
+}
+const activeLevel = () => useViewer.getState().selection.levelId
+
+beforeEach(() => {
+  useScene.setState({
+    nodes: Object.fromEntries(
+      [{ ...building, children: levels.map((level) => level.id) }, ...levels].map((node) => [
+        node.id,
+        node,
+      ]),
+    ),
+    rootNodeIds: [building.id],
+  } as never)
+  useViewer.getState().setSelection({ buildingId: building.id, levelId: second })
+})
+afterEach(() => useEditor.getState().setCaptureMode(false))
+
+describe('capture level picker', () => {
+  test('editing hides the levels above; capture opens on the whole building', () => {
+    expect(wholeBuilding()).toBe(false)
+    useEditor.getState().setCaptureMode(true)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+    expect(wholeBuilding()).toBe(true)
+    expect(activeLevel()).toBe(second)
+  })
+
+  test('picking a level shows it and the levels below, as while editing', () => {
+    useEditor.getState().setCaptureMode(true)
+    useEditor.getState().setCaptureLevel(first)
+    expect(wholeBuilding()).toBe(false)
+    expect(activeLevel()).toBe(first)
+    useEditor.getState().setCaptureLevel(null)
+    expect(wholeBuilding()).toBe(true)
+  })
+
+  test("leaving capture restores the editor's active level and the editing rule", () => {
+    useEditor.getState().setCaptureMode(true)
+    useEditor.getState().setCaptureLevel(ground)
+    useEditor.getState().setCaptureMode(false)
+    expect(activeLevel()).toBe(second)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+    expect(wholeBuilding()).toBe(false)
+    // The next capture opens on the whole building again.
+    useEditor.getState().setCaptureMode({ mode: 'standard', crop: 'area' })
+    expect(wholeBuilding()).toBe(true)
+  })
+
+  test('a level picked outside capture is ignored', () => {
+    useEditor.getState().setCaptureLevel(ground)
+    expect(activeLevel()).toBe(second)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+  })
+
+  test('preset captures and the walkthrough keep their own rules', () => {
+    const preset: CaptureMode = { mode: 'preset', isolated: [] }
+    const base = { isPreviewMode: false, isFirstPersonMode: false, captureLevelId: null }
+    expect(showsWholeBuilding({ ...base, captureMode: preset })).toBe(false)
+    expect(showsWholeBuilding({ ...base, captureMode: { mode: 'idle' } })).toBe(false)
+    expect(
+      showsWholeBuilding({ ...base, isFirstPersonMode: true, captureMode: { mode: 'idle' } }),
+    ).toBe(true)
+    // A walk capture on a picked level still shows only that level and below.
+    expect(
+      showsWholeBuilding({
+        ...base,
+        isFirstPersonMode: true,
+        captureMode: { mode: 'standard' },
+        captureLevelId: first,
+      }),
+    ).toBe(false)
+  })
+})

package/src/lib/editor-level-display.ts

@@ -0,0 +1,48 @@
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import type { CaptureMode } from '../store/use-editor'
+
+/**
+ * Whether the editor shows every level. Preview and the walkthrough show the
+ * whole building; a scene capture shows what its level picker says (the
+ * whole building, or a level and the ones below it). A preset capture frames
+ * its isolated item and keeps the editing rule.
+ */
+export function showsWholeBuilding(state: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  captureMode: CaptureMode
+  captureLevelId: string | null
+}): boolean {
+  if (state.captureMode.mode === 'standard') return state.captureLevelId === null
+  return state.isPreviewMode || state.isFirstPersonMode
+}
+
+/**
+ * The editor's one level display: stacked, with every level above the
+ * selected one hidden — the selected level and the ones below stay, so the
+ * storey being worked on is never covered. There is no Stack / Exploded /
+ * Solo choice while editing; a mode left over from the viewer (or persisted
+ * by an older build) is set back to stacked, and kept there.
+ *
+ * The walkthrough shows the whole building, so the upper levels come back
+ * while it is on; Preview hands the display to the viewer's own floor rule
+ * (`useViewerFloorDisplay`).
+ */
+export function useEditorLevelDisplay(showWholeBuilding: boolean) {
+  useEffect(() => {
+    if (showWholeBuilding) return
+    const keepStacked = (mode: string) => {
+      if (mode !== 'stacked') useViewer.getState().setLevelMode('stacked')
+    }
+    useViewer.setState({ hideLevelsAboveSelection: true })
+    keepStacked(useViewer.getState().levelMode)
+    const unsubscribe = useViewer.subscribe((state, previous) => {
+      if (state.levelMode !== previous.levelMode) keepStacked(state.levelMode)
+    })
+    return () => {
+      unsubscribe()
+      useViewer.setState({ hideLevelsAboveSelection: false })
+    }
+  }, [showWholeBuilding])
+}

package/src/lib/editor-views.ts

@@ -0,0 +1,144 @@
+import type { IconRef, LazyComponent } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import { VIEW_2D, VIEW_3D } from '../store/view-layout'
+
+/**
+ * A view fills a pane of the stage, beside or instead of the 3D scene and the
+ * 2D plan. Hosts and plugins register views the way they register rail panels;
+ * a plugin registers as many as it needs, each tagged with its `pluginId`.
+ */
+export type EditorHostView = {
+  id: string
+  label: string
+  icon: IconRef
+  component: LazyComponent
+  /** The view exists in a project only while this plugin is installed there. */
+  pluginId?: string
+  /** Workspaces the view is offered in. Default `['edit']`, like panels. */
+  workspaces?: readonly string[]
+  description?: string
+  /** Shown in the view bar until the user unpins it. Default false: the "More views" menu only. */
+  defaultPinned?: boolean
+}
+
+/** A view as the stage needs it. The scene views have no component: the stage owns their canvases. */
+export type EditorViewDescriptor = Omit<EditorHostView, 'component'> & {
+  component?: LazyComponent
+  /** 3D and 2D: the views the level selector, tool dock and scene overlays belong to. */
+  scene?: boolean
+}
+
+export const SCENE_VIEWS: readonly EditorViewDescriptor[] = [
+  {
+    id: VIEW_3D,
+    label: '3D',
+    icon: { kind: 'url', src: '/icons/building.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+  {
+    id: VIEW_2D,
+    label: '2D',
+    icon: { kind: 'url', src: '/icons/blueprint.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+]
+
+export function isSceneView(viewId: string): boolean {
+  return viewId === VIEW_3D || viewId === VIEW_2D
+}
+
+function isDevMode(): boolean {
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+    return process.env.NODE_ENV !== 'production'
+  }
+  return false
+}
+
+class EditorHostViewRegistryImpl {
+  private readonly views = new Map<string, EditorHostView>()
+  private readonly listeners = new Set<() => void>()
+  private cached: EditorHostView[] = []
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): EditorHostView[] => this.cached
+
+  reset(): void {
+    this.views.clear()
+    this.emit()
+  }
+
+  registerView(view: EditorHostView): void {
+    if (typeof view.id !== 'string' || view.id.length === 0) {
+      throw new Error('[editor:host-views] view id must be a non-empty string')
+    }
+    if (isSceneView(view.id)) {
+      throw new Error(`[editor:host-views] "${view.id}" is a built-in view`)
+    }
+    if (this.views.has(view.id)) {
+      if (isDevMode()) {
+        console.warn(`[editor:host-views] re-registering view "${view.id}" (HMR)`)
+      } else {
+        throw new Error(`[editor:host-views] duplicate view id: "${view.id}" already registered`)
+      }
+    }
+    this.views.set(view.id, view)
+    this.emit()
+  }
+
+  private emit(): void {
+    this.cached = Array.from(this.views.values())
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const editorHostViewRegistry = new EditorHostViewRegistryImpl()
+
+export function registerEditorHostView(view: EditorHostView): void {
+  editorHostViewRegistry.registerView(view)
+}
+
+/**
+ * Show a view: focus it if it is on screen, else put it in the focused pane —
+ * or, with `beside`, split and open it next to what is there.
+ */
+export function openEditorView(viewId: string, options?: { beside?: boolean }): void {
+  useEditor.getState().showView(viewId, options)
+}
+
+/**
+ * The views a project can show in a workspace: the scene views, then every
+ * registered view offered there whose plugin (if any) is installed.
+ */
+export function availableViews({
+  registered,
+  workspaceMode,
+  installedPlugins,
+}: {
+  registered: readonly EditorViewDescriptor[]
+  workspaceMode: string
+  installedPlugins: readonly string[]
+}): EditorViewDescriptor[] {
+  return [
+    ...SCENE_VIEWS,
+    ...registered.filter(
+      (view) =>
+        (view.workspaces ?? ['edit']).includes(workspaceMode) &&
+        (!view.pluginId || installedPlugins.includes(view.pluginId)),
+    ),
+  ]
+}
+
+export function isViewPinned(
+  view: EditorViewDescriptor,
+  pinnedViews: Readonly<Record<string, boolean>>,
+): boolean {
+  return pinnedViews[view.id] ?? view.defaultPinned ?? false
+}