@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/hud-title.ts

@@ -0,0 +1,109 @@
+import { type IconRef, nodeRegistry, type TerrainVerb } from '@pascal-app/core'
+import type { ContinuationMode } from './continuation'
+import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
+
+/** The contextual helper panel's header: what is in hand, and its key. */
+export type HudTitle = {
+  label: string
+  icon?: IconRef
+  shortcut?: string
+}
+
+const url = (src: string): IconRef => ({ kind: 'url', src })
+
+/** Tools with a global arming key (`use-keyboard.ts`). */
+const TOOL_SHORTCUTS: Record<string, string> = {
+  wall: 'B',
+  measurement: 'M',
+}
+
+export const SELECT_HUD_TITLE: HudTitle = {
+  label: 'Select',
+  icon: url('/icons/select.webp'),
+  shortcut: 'V',
+}
+export const PAINT_HUD_TITLE: HudTitle = { label: 'Paint', icon: url('/icons/paint.webp') }
+export const ERASE_HUD_TITLE: HudTitle = {
+  label: 'Erase',
+  icon: { kind: 'iconify', name: 'lucide:eraser' },
+}
+export const PICK_MATERIAL_HUD_TITLE: HudTitle = {
+  label: 'Pick material',
+  icon: { kind: 'iconify', name: 'lucide:pipette' },
+}
+export const ROTATE_HUD_TITLE: HudTitle = { label: 'Rotate', icon: url('/icons/rotate.webp') }
+export const MOVE_SELECTION_HUD_TITLE: HudTitle = {
+  label: 'Move selection',
+  icon: url('/icons/pan.webp'),
+}
+export const MOVE_ROOM_HUD_TITLE: HudTitle = { label: 'Move room', icon: url('/icons/room.webp') }
+export const RESIZE_HUD_TITLE: HudTitle = {
+  label: 'Resize',
+  icon: url('/icons/resize.webp'),
+}
+export const DIVIDE_ROOM_HUD_TITLE: HudTitle = {
+  label: 'Divide room',
+  icon: url('/icons/divide-room.webp'),
+}
+export const MEZZANINE_HUD_TITLE: HudTitle = {
+  label: 'Mezzanine',
+  icon: url('/icons/mezzanine.webp'),
+}
+export const OPENING_HUD_TITLE: HudTitle = {
+  label: 'Cut opening',
+  icon: { kind: 'iconify', name: 'lucide:square-dashed' },
+}
+export const TERRACE_HUD_TITLE: HudTitle = {
+  label: 'Terrace',
+  icon: url('/icons/floor.webp'),
+}
+export const SMART_MEASURE_HUD_TITLE: HudTitle = {
+  label: 'Smart measure',
+  icon: url('/icons/measure.webp'),
+  shortcut: 'M',
+}
+
+const PAINT_REGION_LABELS = {
+  rectangle: 'Paint a rectangle',
+  polygon: 'Paint a shape',
+} as const
+
+export function paintRegionHudTitle(mode: keyof typeof PAINT_REGION_LABELS): HudTitle {
+  return { label: PAINT_REGION_LABELS[mode], icon: url('/icons/paint.webp') }
+}
+
+export function terrainHudTitle(verb: TerrainVerb): HudTitle {
+  const label =
+    verb === 'raise'
+      ? 'Raise terrain'
+      : verb === 'lower'
+        ? 'Lower terrain'
+        : verb === 'flatten'
+          ? 'Level terrain'
+          : 'Smooth terrain'
+  return { label, icon: url(`/icons/terrain-${verb}.webp`) }
+}
+
+/** A kind's registry name and icon, optionally behind a verb ("Move door"). */
+export function nodeKindHudTitle(kind: string, verb?: string): HudTitle | null {
+  const presentation = nodeRegistry.get(kind)?.presentation
+  if (!presentation) return null
+  const name = presentation.label
+  return {
+    label: verb ? `${verb} ${name.toLowerCase()}` : name,
+    icon: presentation.icon,
+    shortcut: verb ? undefined : TOOL_SHORTCUTS[kind],
+  }
+}
+
+/**
+ * The armed build tool. The wall tool is named after the Rooms variant it draws
+ * (Rectangle room / Polygon room / Walls) — the tile the user picked.
+ */
+export function toolHudTitle(tool: string, wallMode: ContinuationMode): HudTitle | null {
+  if (tool === 'wall') {
+    const variant = getWallDrawVariantInfo(wallDrawVariantOf(wallMode))
+    return { label: variant.title, icon: url(variant.iconSrc), shortcut: TOOL_SHORTCUTS.wall }
+  }
+  return nodeKindHudTitle(tool)
+}

package/src/lib/hydration-gated-storage.ts

@@ -0,0 +1,49 @@
+import { createJSONStorage, type PersistStorage } from 'zustand/middleware'
+
+/**
+ * localStorage for a persisted store that rehydrates on mount (`skipHydration`).
+ *
+ * `persist` saves the whole stored state on every `set`. A save before the
+ * store has hydrated would replace the stored preferences with the defaults
+ * before they are read (a host component's own mount effect runs first), so
+ * those writes stay in memory and rehydrate merges the stored blob over them:
+ * host code that sets a persisted field before then has to wait for
+ * `persist.onFinishHydration`. After that, a save of the blob this tab already
+ * holds is skipped, so an update that changes no preference never replaces
+ * what another tab saved since. A blob that cannot be read counts as none:
+ * hydration still finishes, on the defaults, and the next save replaces it.
+ */
+export function hydrationGatedStorage<S>(
+  hasHydrated: () => boolean,
+): PersistStorage<S> | undefined {
+  let held: string | null = null
+  const storage = createJSONStorage<S>(() => {
+    const local = window.localStorage
+    return {
+      getItem: (name) => {
+        held = local.getItem(name)
+        return held
+      },
+      setItem: (name, value) => {
+        if (!hasHydrated() || value === held) return
+        held = value
+        local.setItem(name, value)
+      },
+      removeItem: (name) => {
+        held = null
+        local.removeItem(name)
+      },
+    }
+  })
+  if (!storage) return undefined
+  return {
+    ...storage,
+    getItem: (name) => {
+      try {
+        return storage.getItem(name)
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/src/lib/ifc-export.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, sceneRegistry } from '@pascal-app/core'
+import * as THREE from 'three'
+import { collectIfcMeshes, exportPreparedSceneToIfc, ifcFileName } from './ifc-export'
+
+const node = (id: string, type: string, parentId: string | null = null) =>
+  ({
+    object: 'node',
+    id,
+    type,
+    parentId,
+    visible: true,
+    metadata: {},
+    children: [],
+  }) as unknown as AnyNode
+
+function identity(object: THREE.Object3D, id: string) {
+  object.userData = { pascalId: id }
+  return object
+}
+
+describe('collectIfcMeshes', () => {
+  const nodes: Record<string, AnyNode> = {
+    level_a: node('level_a', 'level'),
+    wall_a: { ...node('wall_a', 'wall', 'level_a'), start: [0, 0], end: [1, 0] } as AnyNode,
+    item_a: node('item_a', 'item', 'level_a'),
+  }
+
+  function scene() {
+    const root = new THREE.Group()
+    const level = identity(new THREE.Group(), 'level_a')
+    level.position.y = 3
+    root.add(level)
+
+    const wall = identity(
+      new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshStandardMaterial()),
+      'wall_a',
+    )
+    level.add(wall)
+
+    const item = identity(new THREE.Group(), 'item_a')
+    item.position.set(2, 0, 0)
+    level.add(item)
+    const geometry = new THREE.BoxGeometry(1, 1, 1)
+    // BoxGeometry has six material groups (one per face).
+    const red = new THREE.MeshStandardMaterial({ color: new THREE.Color('#ff0000') })
+    const glass = new THREE.MeshStandardMaterial({ transparent: true, opacity: 0.25 })
+    const materials = [red, red, red, red, glass, glass]
+    const child = new THREE.Mesh(geometry, materials)
+    item.add(child)
+    const hidden = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshStandardMaterial())
+    hidden.visible = false
+    item.add(hidden)
+    return root
+  }
+
+  test('bakes world transforms per owning node and skips parametric kinds', () => {
+    const { meshes: parts, renderedNodeIds } = collectIfcMeshes(scene(), nodes)
+    expect([...parts.keys()]).toEqual(['item_a'])
+    expect([...renderedNodeIds].sort()).toEqual(['item_a', 'wall_a'])
+    const itemParts = parts.get('item_a')!
+    expect(itemParts).toHaveLength(6)
+    const xs: number[] = []
+    const ys: number[] = []
+    for (const part of itemParts) {
+      expect(part.indices!.length % 3).toBe(0)
+      expect(part.positions.length).toBe(4 * 3)
+      for (let i = 0; i < part.positions.length; i += 3) {
+        xs.push(part.positions[i]!)
+        ys.push(part.positions[i + 1]!)
+      }
+    }
+    expect(Math.min(...xs)).toBeCloseTo(1.5)
+    expect(Math.max(...xs)).toBeCloseTo(2.5)
+    expect(Math.min(...ys)).toBeCloseTo(2.5)
+    expect(Math.max(...ys)).toBeCloseTo(3.5)
+    const [r, g, b] = itemParts[0]!.color!
+    expect([r, g, b].map((channel) => Math.round(channel * 1000) / 1000)).toEqual([1, 0, 0])
+    expect(itemParts[5]!.opacity).toBe(0.25)
+  })
+
+  test('feeds the IFC writer', () => {
+    const { data, warnings } = exportPreparedSceneToIfc(scene(), nodes, { projectName: 'Demo' })
+    expect(data).toContain("FILE_SCHEMA(('IFC4'));")
+    expect(data).toContain('IFCFURNISHINGELEMENT(')
+    expect(data).toContain('IFCTRIANGULATEDFACESET(')
+    expect(warnings).toEqual([])
+  })
+})
+
+describe('export warnings', () => {
+  test('flag nodes drawn in the editor that reached the file without geometry', () => {
+    const nodes: Record<string, AnyNode> = {
+      level_a: node('level_a', 'level'),
+      item_ghost: node('item_ghost', 'item', 'level_a'),
+      marker_a: node('marker_a', 'item', 'level_a'),
+    }
+    // Live editor objects: the item draws on the scene layer; the marker only
+    // on an overlay layer, like the spawn point.
+    const drawn = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshStandardMaterial())
+    const overlay = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshStandardMaterial())
+    overlay.layers.set(5)
+    sceneRegistry.nodes.set('item_ghost', drawn)
+    sceneRegistry.nodes.set('marker_a', overlay)
+    try {
+      const { warnings } = exportPreparedSceneToIfc(new THREE.Group(), nodes, {})
+      expect(warnings).toEqual([
+        '1 object has no exportable geometry and was left out of the IFC file.',
+      ])
+    } finally {
+      sceneRegistry.nodes.delete('item_ghost')
+      sceneRegistry.nodes.delete('marker_a')
+    }
+  })
+})
+
+describe('visibility default', () => {
+  test('a hidden wall is left out when no option is given, as scene preparation does', () => {
+    const nodes: Record<string, AnyNode> = {
+      level_a: node('level_a', 'level'),
+      wall_hidden: {
+        ...node('wall_hidden', 'wall', 'level_a'),
+        visible: false,
+        start: [0, 0],
+        end: [3, 0],
+      } as AnyNode,
+    }
+    expect(exportPreparedSceneToIfc(new THREE.Group(), nodes, {}).data).not.toContain('IFCWALL(')
+    expect(
+      exportPreparedSceneToIfc(new THREE.Group(), nodes, { onlyVisible: false }).data,
+    ).toContain('IFCWALL(')
+  })
+})
+
+describe('ifcFileName', () => {
+  test('uses a filesystem-safe project name', () => {
+    expect(ifcFileName('House: v2/final', 'model')).toBe('House- v2-final.ifc')
+    expect(ifcFileName('  ', 'model_2026-09-30')).toBe('model_2026-09-30.ifc')
+    expect(ifcFileName(undefined, 'model')).toBe('model.ifc')
+  })
+})
+
+test('material groups retain their surface owner and semantic subpart', () => {
+  const owner = node('item_owner', 'item')
+  const child = node('item_child', 'item', owner.id)
+  const root = identity(new THREE.Group(), owner.id)
+  const geometry = new THREE.BoxGeometry()
+  const material = new THREE.MeshStandardMaterial()
+  const mesh = new THREE.Mesh(
+    geometry,
+    Array.from({ length: 6 }, () => material),
+  )
+  mesh.userData = {
+    surfaceNodeIds: [child.id, child.id, owner.id, owner.id, owner.id, owner.id],
+    pascalIfcRole: 'railing',
+    pascalIfcParts: [
+      { start: 0, count: 6, role: 'railing' },
+      { start: 6, count: 30, role: 'handrail' },
+    ],
+  }
+  root.add(mesh)
+  const { meshes, renderedNodeIds } = collectIfcMeshes(root, {
+    [owner.id]: owner,
+    [child.id]: child,
+  })
+  expect(meshes.get(child.id)).toHaveLength(2)
+  expect(meshes.get(owner.id)).toHaveLength(4)
+  expect(meshes.get(child.id)![0]!.role).toBe('railing')
+  expect(meshes.get(child.id)![1]!.role).toBe('handrail')
+  expect(meshes.get(owner.id)!.every((part) => part.role === 'handrail')).toBe(true)
+  expect(renderedNodeIds.has(child.id)).toBe(true)
+  geometry.dispose()
+  material.dispose()
+})

package/src/lib/ifc-export.ts

@@ -0,0 +1,201 @@
+import { type AnyNode, bakePolicyOf, type Collection, sceneRegistry } from '@pascal-app/core'
+import { buildIfcExport, type IfcMeshPart } from '@pascal-app/ifc-converter/export'
+import { SCENE_LAYER } from '@pascal-app/viewer'
+import * as THREE from 'three'
+import { isIfcRolePart } from './ifc-parts'
+
+// Kinds the IFC writer always rebuilds parametrically from node data; their
+// rendered triangles are never read, so skip copying them. (Slabs are copied:
+// pools and legacy zero-thickness slabs export their rendered shape.)
+const PARAMETRIC_KINDS = new Set(['site', 'building', 'level', 'wall', 'ceiling', 'zone'])
+
+function owningNodeId(object: THREE.Object3D): string | null {
+  for (let current: THREE.Object3D | null = object; current; current = current.parent) {
+    const id = current.userData?.pascalId
+    if (typeof id === 'string') return id
+  }
+  return null
+}
+
+function materialColor(
+  material: THREE.Material | undefined,
+): Pick<IfcMeshPart, 'color' | 'opacity'> {
+  const color = (material as THREE.MeshStandardMaterial | undefined)?.color
+  const rgb = color ? color.getRGB(new THREE.Color(), THREE.SRGBColorSpace) : null
+  return {
+    color: rgb ? [rgb.r, rgb.g, rgb.b] : undefined,
+    opacity: material?.transparent ? material.opacity : 1,
+  }
+}
+
+/**
+ * World-space triangles per node from a prepared export scene (identity
+ * stamped, instancing expanded, deformation frozen, reflected winding fixed).
+ * Each material group becomes one part with only the vertices it uses.
+ * `renderedNodeIds` lists every node that drew at least one triangle.
+ */
+export function collectIfcMeshes(
+  root: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+): { meshes: Map<string, IfcMeshPart[]>; renderedNodeIds: Set<string> } {
+  root.updateMatrixWorld(true)
+  const parts = new Map<string, IfcMeshPart[]>()
+  const renderedNodeIds = new Set<string>()
+  const vertex = new THREE.Vector3()
+
+  root.traverseVisible((object) => {
+    const mesh = object as THREE.Mesh
+    if (!mesh.isMesh) return
+    const position = mesh.geometry?.getAttribute('position')
+    if (!position || position.count < 3) return
+    const nodeId = owningNodeId(mesh)
+    const node = nodeId ? nodes[nodeId] : undefined
+    if (!node) return
+    renderedNodeIds.add(node.id)
+    if (PARAMETRIC_KINDS.has(node.type)) return
+
+    const geometry = mesh.geometry
+    const drawStart = geometry.drawRange.start
+    const drawEnd = Math.min(
+      geometry.index ? geometry.index.count : position.count,
+      drawStart + geometry.drawRange.count,
+    )
+    const indexAt = (i: number) => (geometry.index ? geometry.index.getX(i) : i)
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material]
+    const groups =
+      Array.isArray(mesh.material) && geometry.groups.length > 0
+        ? geometry.groups
+        : [{ start: drawStart, count: drawEnd - drawStart, materialIndex: 0 }]
+
+    const roleParts = Array.isArray(mesh.userData.pascalIfcParts)
+      ? mesh.userData.pascalIfcParts.filter(isIfcRolePart)
+      : []
+    const semanticGroups = groups.flatMap((group) => {
+      const end = group.start + group.count
+      const boundaries = [
+        ...new Set([
+          group.start,
+          end,
+          ...roleParts
+            .flatMap((part: { start: number; count: number }) => [
+              part.start,
+              part.start + part.count,
+            ])
+            .filter((offset: number) => offset > group.start && offset < end),
+        ]),
+      ].sort((a, b) => a - b)
+      return boundaries.slice(0, -1).map((start, index) => ({
+        ...group,
+        start,
+        count: boundaries[index + 1]! - start,
+        role: roleParts.find(
+          (part: { start: number; count: number }) =>
+            start >= part.start && start < part.start + part.count,
+        )?.role as string | undefined,
+      }))
+    })
+    for (const group of semanticGroups) {
+      const surfaceId = mesh.userData.surfaceNodeIds?.[group.materialIndex ?? 0]
+      const owner = typeof surfaceId === 'string' && nodes[surfaceId] ? nodes[surfaceId]! : node
+      let role: string | undefined = group.role
+      for (let current: THREE.Object3D | null = mesh; current; current = current.parent) {
+        if (role === undefined && typeof current.userData.pascalIfcRole === 'string') {
+          role = current.userData.pascalIfcRole
+          break
+        }
+      }
+      const material = materials[group.materialIndex ?? 0]
+      if (!material || material.visible === false) continue
+      const start = Math.max(group.start, drawStart)
+      const end = Math.min(group.start + group.count, drawEnd)
+      const remap = new Map<number, number>()
+      const positions: number[] = []
+      const indices: number[] = []
+      for (let i = start; i + 2 < end; i += 3) {
+        for (let corner = 0; corner < 3; corner++) {
+          const source = indexAt(i + corner)
+          let target = remap.get(source)
+          if (target === undefined) {
+            target = remap.size
+            remap.set(source, target)
+            vertex.fromBufferAttribute(position, source).applyMatrix4(mesh.matrixWorld)
+            positions.push(vertex.x, vertex.y, vertex.z)
+          }
+          indices.push(target)
+        }
+      }
+      if (indices.length === 0) continue
+      const list = parts.get(owner.id) ?? []
+      list.push({
+        role,
+        positions: new Float32Array(positions),
+        indices: new Uint32Array(indices),
+        ...materialColor(material),
+      })
+      parts.set(owner.id, list)
+      renderedNodeIds.add(owner.id)
+    }
+  })
+  return { meshes: parts, renderedNodeIds }
+}
+
+/**
+ * Whether the live editor draws `nodeId`: a visible scene-layer mesh under its
+ * registered object, or a collectively rendered (`bake: 'replace'`) kind whose
+ * instances live outside that object. Overlay-only markers (spawn point,
+ * camera shots) draw nothing here.
+ */
+function drawnInEditor(nodeId: string, nodes: Record<string, AnyNode>): boolean {
+  const node = nodes[nodeId]
+  const live = sceneRegistry.nodes.get(nodeId)
+  if (!node || !live) return false
+  if (bakePolicyOf(node.type) === 'replace') return true
+  let drawn = false
+  live.traverseVisible((object) => {
+    const mesh = object as THREE.Mesh
+    if (drawn || !mesh.isMesh || !object.layers.isEnabled(SCENE_LAYER)) return
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material]
+    const count = mesh.geometry?.getAttribute('position')?.count ?? 0
+    if (count >= 3 && materials.some((material) => material?.visible !== false)) drawn = true
+  })
+  return drawn
+}
+
+export function ifcFileName(projectName: string | undefined, fallback: string): string {
+  const base = projectName?.replace(/[\\/:*?"<>|]+/g, '-').trim()
+  return `${base || fallback}.ifc`
+}
+
+export function exportPreparedSceneToIfc(
+  root: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  options: {
+    collections?: Readonly<Record<string, Collection>>
+    projectName?: string
+    onlyVisible?: boolean
+    excludedNodeTypes?: readonly string[]
+  },
+): { data: string; warnings: string[] } {
+  const { meshes, renderedNodeIds } = collectIfcMeshes(root, nodes)
+  const { ifc, summary } = buildIfcExport({
+    nodes,
+    collections: options.collections,
+    meshes,
+    projectName: options.projectName,
+    // Same default as scene preparation, which already pruned hidden meshes.
+    onlyVisible: options.onlyVisible ?? true,
+    excludedNodeTypes: options.excludedNodeTypes,
+  })
+  // Report everything that is on screen yet did not reach the file; markers
+  // that draw nothing (spawn point, camera shots) are skipped silently.
+  const missing = summary.skipped.filter(
+    (skip) => renderedNodeIds.has(skip.nodeId) || drawnInEditor(skip.nodeId, nodes),
+  ).length
+  const warnings =
+    missing > 0
+      ? [
+          `${missing} ${missing === 1 ? 'object has' : 'objects have'} no exportable geometry and ${missing === 1 ? 'was' : 'were'} left out of the IFC file.`,
+        ]
+      : []
+  return { data: ifc, warnings }
+}

package/src/lib/ifc-parts.ts

@@ -0,0 +1,15 @@
+export type IfcRolePart = { start: number; count: number; role: string }
+
+export function isIfcRolePart(value: unknown): value is IfcRolePart {
+  if (!value || typeof value !== 'object') return false
+  const part = value as IfcRolePart
+  return (
+    Number.isInteger(part.start) &&
+    part.start >= 0 &&
+    part.start % 3 === 0 &&
+    Number.isInteger(part.count) &&
+    part.count > 0 &&
+    part.count % 3 === 0 &&
+    typeof part.role === 'string'
+  )
+}

package/src/lib/inspector-expanded.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, expect, test } from 'bun:test'
+
+const saved = Object.getOwnPropertyDescriptor(globalThis, 'localStorage')
+afterEach(() => {
+  if (saved) Object.defineProperty(globalThis, 'localStorage', saved)
+  else Reflect.deleteProperty(globalThis, 'localStorage')
+})
+
+function stubStorage(storage: Partial<Storage>) {
+  Object.defineProperty(globalThis, 'localStorage', { configurable: true, value: storage })
+}
+
+let fresh = 0
+/** A new instance of the module, reading storage as a page load would. */
+const load = () => import(`./inspector-expanded.ts?load=${++fresh}`)
+
+test('expanding once opens every later panel expanded, across a reload, until folded', async () => {
+  const values = new Map<string, string>()
+  stubStorage({
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => void values.set(key, value),
+  })
+  const first = await load()
+  expect(first.useInspectorExpanded.getState().expanded).toBe(false)
+  first.useInspectorExpanded.getState().setExpanded(true)
+  expect((await load()).useInspectorExpanded.getState().expanded).toBe(true)
+  first.useInspectorExpanded.getState().setExpanded(false)
+  expect((await load()).useInspectorExpanded.getState().expanded).toBe(false)
+})
+
+test('without usable storage the panel opens folded and expanding still works', async () => {
+  stubStorage({
+    getItem: () => {
+      throw new Error('blocked')
+    },
+    setItem: () => {
+      throw new Error('blocked')
+    },
+  })
+  const { useInspectorExpanded } = await load()
+  expect(useInspectorExpanded.getState().expanded).toBe(false)
+  useInspectorExpanded.getState().setExpanded(true)
+  expect(useInspectorExpanded.getState().expanded).toBe(true)
+})

package/src/lib/inspector-expanded.ts

@@ -0,0 +1,36 @@
+import { create } from 'zustand'
+
+// One choice for every right-side inspector panel (room, wall, item…): opened
+// expanded or folded to its header, kept per viewer until they fold it again.
+// Its own key, read when the module loads: the editor's persisted preferences
+// rehydrate after the first render, too late for a panel that opens with the
+// editor. Storage can be missing or refuse (private windows, blocked site
+// data); the panel then opens folded, as it always has.
+const STORAGE_KEY = 'pascal-editor:inspector-expanded'
+
+function readExpanded(): boolean {
+  try {
+    return globalThis.localStorage?.getItem(STORAGE_KEY) === 'true'
+  } catch {
+    return false
+  }
+}
+
+function writeExpanded(expanded: boolean) {
+  try {
+    globalThis.localStorage?.setItem(STORAGE_KEY, String(expanded))
+  } catch {
+    // Not remembered this time; the panel still follows the choice until reload.
+  }
+}
+
+export const useInspectorExpanded = create<{
+  expanded: boolean
+  setExpanded: (expanded: boolean) => void
+}>((set) => ({
+  expanded: readExpanded(),
+  setExpanded: (expanded) => {
+    writeExpanded(expanded)
+    set({ expanded })
+  },
+}))

package/src/lib/interaction/scope.ts

@@ -19,10 +19,35 @@ export type ReshapeDriver = 'tool' | 'floorplan'
 // node, one in-flight reshape. Grouping them as sub-states of `reshaping`
 // (rather than four sibling scopes) keeps the union small while still making
 // "curving and hole-editing at once" unrepresentable.
-export type ReshapeKind = 'curve' | 'hole' | 'endpoint' | 'boundary' | 'control-point' | 'tangent'
+export type ReshapeKind =
+  | 'curve'
+  | 'hole'
+  | 'endpoint'
+  | 'boundary'
+  | 'control-point'
+  | 'tangent'
+  // A kind's own reshape (wall 'split'): mounted from `def.affordanceTools[reshape]`.
+  | 'split'
 
 export type InteractionScope =
   | { kind: 'idle' }
+  | {
+      kind: 'room-divide'
+      nodeId: string
+      levelId: string
+      // The placed points. The first lies on the room's boundary (an open cut)
+      // or inside the room (an island loop); the rest are free points.
+      points: [number, number][]
+      // The boundary the first point sits on, when it sits on one.
+      startBoundaryId?: string
+      // The live point under the pointer and what clicking it would do: start
+      // the path, add a point, finish on the boundary (`edge`), or close the loop.
+      end: [number, number] | null
+      endKind?: 'start' | 'point' | 'edge' | 'close'
+      endBoundaryId?: string
+      valid: boolean
+      message?: string
+    }
   // Placing a fresh node (catalog/preset/build tool). `pressDrag` is the
   // gizmo press-drag flavour (commit on release) vs click-to-place.
   | {
@@ -105,6 +130,7 @@ export function isActive(scope: InteractionScope): scope is ActiveInteractionSco
 // target no single existing node.
 export function scopeNodeId(scope: InteractionScope): string | null {
   switch (scope.kind) {
+    case 'room-divide':
     case 'placing':
     case 'moving':
     case 'handle-drag':