@pascal-app/editor 0.8.0 → 0.9.1

package/src/lib/floorplan/stairs.ts

@@ -209,6 +209,14 @@ function getNormalizedFloorplanStairSweepAngle(stair: StairNode) {
   return baseSweepAngle
 }
 
+function clampFloorplanCircularSweepAngle(sweepAngle: number) {
+  if (Math.abs(sweepAngle) >= Math.PI * 2) {
+    return Math.sign(sweepAngle || 1) * (Math.PI * 2 - 0.001)
+  }
+
+  return sweepAngle
+}
+
 function getFloorplanSpiralLandingSweep(stair: StairNode, sweepAngle: number) {
   if (
     (stair.stairType ?? 'straight') !== 'spiral' ||
@@ -230,8 +238,11 @@ function getFloorplanSpiralLandingSweep(stair: StairNode, sweepAngle: number) {
 function getFloorplanCurvedStairHitPolygon(stair: StairNode): Point2D[] {
   const stairType = stair.stairType ?? 'straight'
   const sweepAngle = getNormalizedFloorplanStairSweepAngle(stair)
+  const visualSweepAngle = clampFloorplanCircularSweepAngle(
+    sweepAngle + getFloorplanSpiralLandingSweep(stair, sweepAngle),
+  )
   const startAngle = -stair.rotation - sweepAngle / 2
-  const endAngle = startAngle + sweepAngle + getFloorplanSpiralLandingSweep(stair, sweepAngle)
+  const endAngle = startAngle + visualSweepAngle
   const center = {
     x: stair.position[0],
     y: stair.position[2],

package/src/lib/fresh-planar-placement.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import { useScene } from '@pascal-app/core'
+import { commitFreshPlacementSubtree } from './fresh-planar-placement'
+
+type RafFn = (cb: (time: number) => void) => number
+;(globalThis as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= ((
+  cb: (time: number) => void,
+) => {
+  cb(0)
+  return 0
+}) as RafFn
+;(globalThis as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??= () => {}
+
+const LEVEL_ID = 'level_test' as AnyNodeId
+const SHELF_ID = 'shelf_draft' as AnyNodeId
+
+function level(children: AnyNodeId[]): AnyNode {
+  return {
+    id: LEVEL_ID,
+    type: 'level',
+    object: 'node',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children,
+    level: 0,
+  } as AnyNode
+}
+
+function shelf(): AnyNode {
+  return {
+    id: SHELF_ID,
+    type: 'shelf',
+    object: 'node',
+    parentId: LEVEL_ID,
+    visible: false,
+    metadata: { isNew: true, label: 'draft' },
+    children: [],
+    position: [0, 0, 0],
+    rotation: [0, 0, 0],
+    width: 1.2,
+    depth: 0.3,
+    thickness: 0.04,
+    height: 0.9,
+    style: 'wall-shelf',
+    rows: 1,
+    columns: 1,
+    withBack: false,
+    withSides: true,
+    withBottom: false,
+    bracketStyle: 'minimal',
+  } as AnyNode
+}
+
+describe('commitFreshPlacementSubtree', () => {
+  beforeEach(() => {
+    useScene.setState({
+      nodes: {
+        [LEVEL_ID]: level([SHELF_ID]),
+        [SHELF_ID]: shelf(),
+      },
+      rootNodeIds: [LEVEL_ID],
+      collections: {},
+      dirtyNodes: new Set(),
+    } as never)
+    useScene.temporal.getState().clear()
+    useScene.temporal.getState().resume()
+  })
+
+  test('commits a fresh draft as one undoable clean subtree', () => {
+    useScene.temporal.getState().pause()
+
+    const committedId = commitFreshPlacementSubtree(SHELF_ID, {
+      position: [2, 0, 3],
+      visible: true,
+    } as Partial<AnyNode>)
+
+    expect(committedId).toBeTruthy()
+    expect(committedId).not.toBe(SHELF_ID)
+    const finalId = committedId as AnyNodeId
+    expect(useScene.getState().nodes[SHELF_ID]).toBeUndefined()
+
+    const committed = useScene.getState().nodes[finalId] as
+      | (AnyNode & { position: [number, number, number]; metadata?: Record<string, unknown> })
+      | undefined
+    expect(committed?.position).toEqual([2, 0, 3])
+    expect(committed?.visible).toBe(true)
+    expect(committed?.metadata?.isNew).toBeUndefined()
+    expect(committed?.metadata?.label).toBe('draft')
+    expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([
+      finalId,
+    ])
+
+    useScene.temporal.getState().resume()
+    useScene.temporal.getState().undo()
+
+    expect(useScene.getState().nodes[finalId]).toBeUndefined()
+    expect(useScene.getState().nodes[SHELF_ID]).toBeUndefined()
+    expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([])
+  })
+})

package/src/lib/fresh-planar-placement.ts

@@ -0,0 +1,63 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  cloneNodesInto,
+  collectSubtree,
+  useScene,
+} from '@pascal-app/core'
+import { stripPlacementMetadataFlags } from './placement-metadata'
+
+function cleanPlacementMetadata<N extends AnyNode>(node: N): N {
+  return {
+    ...node,
+    metadata: stripPlacementMetadataFlags(node.metadata),
+  } as N
+}
+
+function parentIdOf(node: AnyNode): AnyNodeId | undefined {
+  const parentId = (node as { parentId?: AnyNodeId | null }).parentId
+  return parentId ?? undefined
+}
+
+/**
+ * Finalises a fresh catalog/duplicate draft as a single undoable creation.
+ *
+ * Fresh drafts already exist in the scene so renderers and move tools can
+ * preview real geometry. On commit we delete that draft while history is
+ * paused, then create a clean clone at the final cursor position with history
+ * resumed. Undo therefore removes the placed node instead of resurrecting the
+ * hidden draft at its origin.
+ */
+export function commitFreshPlacementSubtree(
+  rootId: AnyNodeId,
+  rootPatch: Partial<AnyNode>,
+): AnyNodeId | null {
+  const scene = useScene.getState()
+  const subtree = collectSubtree(scene.nodes, rootId)
+  if (!subtree) return null
+
+  const root = cleanPlacementMetadata({
+    ...subtree.root,
+    ...rootPatch,
+  } as AnyNode)
+  const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
+  const parentId = parentIdOf(root)
+  const cloned = cloneNodesInto([root, ...descendants], {
+    rootId,
+    parentId,
+  })
+
+  const temporal = useScene.temporal.getState()
+  const wasTracking = (temporal as { isTracking?: boolean }).isTracking !== false
+  if (wasTracking) temporal.pause()
+  useScene.getState().deleteNode(rootId)
+  temporal.resume()
+  useScene
+    .getState()
+    .createNodes(
+      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
+    )
+  if (!wasTracking) temporal.pause()
+
+  return cloned.rootId
+}

package/src/lib/history.ts

@@ -1,6 +1,7 @@
-import { useLiveTransforms, useScene } from '@pascal-app/core'
+import { useLiveNodeOverrides, useLiveTransforms, useScene } from '@pascal-app/core'
 
 function refreshSceneAfterHistoryJump() {
+  useLiveNodeOverrides.getState().clearAll()
   useLiveTransforms.getState().clearAll()
 
   const state = useScene.getState()

package/src/lib/level-duplication.ts

@@ -33,50 +33,62 @@ function shouldKeepNode(node: AnyNode, preset: LevelDuplicatePreset) {
   return true
 }
 
+/**
+ * Material field keys per kind, used by the `structure` duplicate preset
+ * to strip materials from the cloned subtree. Lookup table replaces the
+ * legacy per-kind switch — the Phase 6 grep gate flagged `case '<kind>':`
+ * in this file as the remaining per-kind dispatch outside the registry.
+ *
+ * Future: move this to a `capabilities.materialFields` declaration on
+ * each kind's `NodeDefinition` so adding a new kind with materials is a
+ * registry-only edit. Today the registry doesn't surface material fields
+ * in a uniform way (each kind's panel reads / writes them directly), so
+ * this map mirrors the legacy behavior 1:1.
+ */
+const MATERIAL_FIELDS_BY_KIND: Record<string, ReadonlyArray<string>> = {
+  wall: [
+    'material',
+    'materialPreset',
+    'interiorMaterial',
+    'interiorMaterialPreset',
+    'exteriorMaterial',
+    'exteriorMaterialPreset',
+  ],
+  slab: ['material', 'materialPreset'],
+  ceiling: ['material', 'materialPreset'],
+  fence: ['material', 'materialPreset'],
+  shelf: ['material', 'materialPreset'],
+  'roof-segment': ['material', 'materialPreset'],
+  'stair-segment': ['material', 'materialPreset'],
+  window: ['material', 'materialPreset'],
+  door: ['material', 'materialPreset'],
+  roof: [
+    'material',
+    'materialPreset',
+    'topMaterial',
+    'topMaterialPreset',
+    'edgeMaterial',
+    'edgeMaterialPreset',
+    'wallMaterial',
+    'wallMaterialPreset',
+  ],
+  stair: [
+    'material',
+    'materialPreset',
+    'railingMaterial',
+    'railingMaterialPreset',
+    'treadMaterial',
+    'treadMaterialPreset',
+    'sideMaterial',
+    'sideMaterialPreset',
+  ],
+}
+
 function stripMaterials(node: AnyNode): AnyNode {
+  const fields = MATERIAL_FIELDS_BY_KIND[node.type]
+  if (!fields) return node
   const next = { ...node } as Record<string, unknown>
-
-  switch (node.type) {
-    case 'wall':
-      delete next.material
-      delete next.materialPreset
-      delete next.interiorMaterial
-      delete next.interiorMaterialPreset
-      delete next.exteriorMaterial
-      delete next.exteriorMaterialPreset
-      break
-    case 'slab':
-    case 'ceiling':
-    case 'fence':
-    case 'roof-segment':
-    case 'stair-segment':
-    case 'window':
-    case 'door':
-      delete next.material
-      delete next.materialPreset
-      break
-    case 'roof':
-      delete next.material
-      delete next.materialPreset
-      delete next.topMaterial
-      delete next.topMaterialPreset
-      delete next.edgeMaterial
-      delete next.edgeMaterialPreset
-      delete next.wallMaterial
-      delete next.wallMaterialPreset
-      break
-    case 'stair':
-      delete next.material
-      delete next.materialPreset
-      delete next.railingMaterial
-      delete next.railingMaterialPreset
-      delete next.treadMaterial
-      delete next.treadMaterialPreset
-      delete next.sideMaterial
-      delete next.sideMaterialPreset
-      break
-  }
-
+  for (const field of fields) delete next[field]
   return next as AnyNode
 }
 

package/src/lib/level-name.ts

@@ -0,0 +1,11 @@
+import type { LevelNode } from '@pascal-app/core'
+
+export function getDefaultLevelName(level: number): string {
+  if (level === 0) return 'Ground Floor'
+  if (level > 0) return `Floor ${level}`
+  return `Basement ${-level}`
+}
+
+export function getLevelDisplayName(level: Pick<LevelNode, 'name' | 'level'>): string {
+  return level.name || getDefaultLevelName(level.level)
+}

package/src/lib/material-paint.ts

@@ -1,18 +1,28 @@
 'use client'
 
 import {
+  type AnyNode,
+  type AnyNodeId,
   type CeilingNode,
+  type ChimneyMaterialRole,
+  type ChimneyNode,
   type ColumnNode,
+  type DormerSurfaceMaterialRole,
   type FenceNode,
   getCatalogMaterialById,
   getEffectiveRoofSurfaceMaterial,
+  getEffectiveSegmentSurfaceMaterial,
   getEffectiveStairSurfaceMaterial,
   getEffectiveWallSurfaceMaterial,
   getLibraryMaterialIdFromRef,
   type MaterialSchema,
   type MaterialTarget,
+  nodeRegistry,
   type RoofNode,
+  type RoofSegmentNode,
+  type RoofSegmentSurfaceMaterialRole,
   type RoofSurfaceMaterialRole,
+  type ShelfNode,
   type SlabNode,
   type StairNode,
   type StairSurfaceMaterialRole,
@@ -22,7 +32,21 @@ import {
 
 export type PaintableMaterialTarget = Extract<
   MaterialTarget,
-  'wall' | 'roof' | 'stair' | 'fence' | 'column' | 'slab' | 'ceiling'
+  | 'wall'
+  | 'roof'
+  | 'stair'
+  | 'fence'
+  | 'column'
+  | 'slab'
+  | 'ceiling'
+  | 'shelf'
+  | 'chimney'
+  | 'dormer'
+  | 'box-vent'
+  | 'ridge-vent'
+  | 'turbine-vent'
+  | 'cupola'
+  | 'eyebrow-vent'
 >
 
 export type SingleSurfaceMaterialRole = 'surface'
@@ -104,6 +128,82 @@ export function buildRoofSurfaceMaterialPatch(
   }
 }
 
+/**
+ * Build a per-segment paint patch for one of the three surface roles. The
+ * segment ends up with role-specific fields set (and the legacy catch-all
+ * `material` cleared) so subsequent reads pick the role override over any
+ * parent-roof fallback.
+ */
+export function buildRoofSegmentSurfaceMaterialPatch(
+  node: RoofSegmentNode,
+  targetRole: RoofSegmentSurfaceMaterialRole,
+  material: MaterialSchema | undefined,
+  materialPreset: string | undefined,
+): Partial<RoofSegmentNode> {
+  const nextSurfaceMaterial = { material, materialPreset }
+  const nextTop =
+    targetRole === 'top' ? nextSurfaceMaterial : getEffectiveSegmentSurfaceMaterial(node, 'top')
+  const nextEdge =
+    targetRole === 'edge' ? nextSurfaceMaterial : getEffectiveSegmentSurfaceMaterial(node, 'edge')
+  const nextWall =
+    targetRole === 'wall' ? nextSurfaceMaterial : getEffectiveSegmentSurfaceMaterial(node, 'wall')
+
+  return {
+    topMaterial: nextTop.material,
+    topMaterialPreset: nextTop.materialPreset,
+    edgeMaterial: nextEdge.material,
+    edgeMaterialPreset: nextEdge.materialPreset,
+    wallMaterial: nextWall.material,
+    wallMaterialPreset: nextWall.materialPreset,
+    material: undefined,
+    materialPreset: undefined,
+  }
+}
+
+/**
+ * Clear every painted material on a node back to its default. Works for any
+ * kind without per-type knowledge: it nulls the catch-all `material` /
+ * `materialPreset` plus any role field (`*Material` / `*MaterialPreset`) that
+ * the node actually carries. For a roof it also resets every child segment, so
+ * a single call defaults the whole roof system. `updateNode` merges patches
+ * shallowly without re-validation, so the `undefined` values land as cleared
+ * fields and the renderer falls back to the theme defaults.
+ */
+export function buildResetSurfaceMaterialUpdates(
+  nodes: Record<string, AnyNode>,
+  node: AnyNode,
+): { id: AnyNodeId; data: Partial<AnyNode> }[] {
+  const clearPatch = (target: AnyNode): Partial<AnyNode> => {
+    const patch: Record<string, undefined> = {}
+    for (const key of Object.keys(target)) {
+      if (
+        key === 'material' ||
+        key === 'materialPreset' ||
+        key.endsWith('Material') ||
+        key.endsWith('MaterialPreset')
+      ) {
+        patch[key] = undefined
+      }
+    }
+    return patch as Partial<AnyNode>
+  }
+
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = [
+    { id: node.id as AnyNodeId, data: clearPatch(node) },
+  ]
+
+  if (node.type === 'roof') {
+    for (const segmentId of (node as RoofNode).children ?? []) {
+      const segment = nodes[segmentId as AnyNodeId]
+      if (segment?.type === 'roof-segment') {
+        updates.push({ id: segment.id as AnyNodeId, data: clearPatch(segment) })
+      }
+    }
+  }
+
+  return updates
+}
+
 export function buildStairSurfaceMaterialPatch(
   node: StairNode,
   targetRole: StairSurfaceMaterialRole,
@@ -133,7 +233,7 @@ export function buildStairSurfaceMaterialPatch(
 }
 
 export function buildSingleSurfaceMaterialPatch<
-  TNode extends FenceNode | ColumnNode | SlabNode | CeilingNode,
+  TNode extends FenceNode | ColumnNode | SlabNode | CeilingNode | ShelfNode,
 >(material: MaterialSchema | undefined, materialPreset: string | undefined): Partial<TNode> {
   return {
     material,
@@ -141,6 +241,29 @@ export function buildSingleSurfaceMaterialPatch<
   } as Partial<TNode>
 }
 
+// Chimney / dormer patch builders moved to
+// `@pascal-app/nodes/<kind>/paint.ts` and are wired into the kind's
+// `capabilities.paint.buildPatch`. The selection-manager invokes them
+// through the registry; no editor-side helper needed here.
+//
+// `getEffectiveChimneyMaterial` below stays because
+// `resolveActivePaintMaterialFromSelection` (also in this file) still
+// has wall / roof / stair arms that follow the same shape — they all
+// migrate together in a follow-up.
+
+export function getEffectiveChimneyMaterial(
+  node: ChimneyNode,
+  role: ChimneyMaterialRole,
+): { material: MaterialSchema | undefined; materialPreset: string | undefined } {
+  if (role === 'top') {
+    const hasTop = node.topMaterial !== undefined || node.topMaterialPreset !== undefined
+    if (hasTop) {
+      return { material: node.topMaterial, materialPreset: node.topMaterialPreset }
+    }
+  }
+  return { material: node.material, materialPreset: node.materialPreset }
+}
+
 export function resolveActivePaintMaterialFromSelection(params: {
   nodes: Record<string, any>
   selectedId: string | null
@@ -150,6 +273,8 @@ export function resolveActivePaintMaterialFromSelection(params: {
       | WallSurfaceSide
       | StairSurfaceMaterialRole
       | RoofSurfaceMaterialRole
+      | ChimneyMaterialRole
+      | DormerSurfaceMaterialRole
       | SingleSurfaceMaterialRole
   } | null
 }): ActivePaintMaterial | null {
@@ -160,22 +285,31 @@ export function resolveActivePaintMaterialFromSelection(params: {
   const selectedNode = nodes[selectedId]
   if (!selectedNode) return null
 
-  if (
-    selectedNode.type === 'wall' &&
-    (selectedMaterialTarget.role === 'interior' || selectedMaterialTarget.role === 'exterior')
-  ) {
-    const surface = getEffectiveWallSurfaceMaterial(selectedNode, selectedMaterialTarget.role)
-    return hasActivePaintMaterial({
-      material: surface.material,
-      materialPreset: surface.materialPreset,
-      sourceTarget: 'wall',
+  // Registry-driven path. Kinds that declare
+  // `capabilities.paint.getEffectiveMaterial` resolve their effective
+  // material here without an editor-side per-kind arm. Wall,
+  // chimney, dormer use this; roof / stair stay legacy below.
+  const paintCap = nodeRegistry.get(selectedNode.type)?.capabilities?.paint
+  if (paintCap?.getEffectiveMaterial) {
+    const surface = paintCap.getEffectiveMaterial({
+      node: selectedNode,
+      role: selectedMaterialTarget.role as string,
+      nodes,
     })
-      ? {
-          material: surface.material,
-          materialPreset: surface.materialPreset,
-          sourceTarget: 'wall',
-        }
-      : null
+    if (surface) {
+      const sourceTarget = selectedNode.type as PaintableMaterialTarget
+      return hasActivePaintMaterial({
+        material: surface.material,
+        materialPreset: surface.materialPreset,
+        sourceTarget,
+      })
+        ? {
+            material: surface.material,
+            materialPreset: surface.materialPreset,
+            sourceTarget,
+          }
+        : null
+    }
   }
 
   if (
@@ -184,7 +318,27 @@ export function resolveActivePaintMaterialFromSelection(params: {
       selectedMaterialTarget.role === 'edge' ||
       selectedMaterialTarget.role === 'wall')
   ) {
-    const surface = getEffectiveRoofSurfaceMaterial(selectedNode, selectedMaterialTarget.role)
+    let surface = getEffectiveRoofSurfaceMaterial(selectedNode, selectedMaterialTarget.role)
+    if (
+      selectedMaterialTarget.role === 'top' &&
+      surface.material === undefined &&
+      surface.materialPreset === undefined
+    ) {
+      const roofNode = selectedNode as RoofNode
+      const fallbackSegment = (roofNode.children ?? [])
+        .map((id: AnyNodeId) => nodes[id as AnyNodeId] as RoofSegmentNode | undefined)
+        .find(
+          (segment: RoofSegmentNode | undefined) =>
+            segment?.type === 'roof-segment' &&
+            (segment.material !== undefined || segment.materialPreset !== undefined),
+        )
+      if (fallbackSegment) {
+        surface = {
+          material: fallbackSegment.material,
+          materialPreset: fallbackSegment.materialPreset,
+        }
+      }
+    }
     return hasActivePaintMaterial({
       material: surface.material,
       materialPreset: surface.materialPreset,
@@ -218,13 +372,19 @@ export function resolveActivePaintMaterialFromSelection(params: {
       : null
   }
 
+  // Wall / chimney / dormer flow through the registry-driven path
+  // at the top of this function.
+
   if (
     (selectedNode.type === 'fence' ||
       selectedNode.type === 'column' ||
       selectedNode.type === 'slab' ||
-      selectedNode.type === 'ceiling') &&
+      selectedNode.type === 'ceiling' ||
+      selectedNode.type === 'shelf') &&
     selectedMaterialTarget.role === 'surface'
   ) {
+    // Roof vents previously lived here too; they now resolve via the
+    // registry-driven `getEffectiveMaterial` path at the top of this function.
     const target = selectedNode.type
     return hasActivePaintMaterial({
       material: selectedNode.material,
@@ -280,5 +440,37 @@ export function resolvePaintTargetFromSelection(params: {
     return 'ceiling'
   }
 
+  if (selectedNode.type === 'shelf') {
+    return 'shelf'
+  }
+
+  if (selectedNode.type === 'chimney') {
+    return 'chimney'
+  }
+
+  if (selectedNode.type === 'dormer') {
+    return 'dormer'
+  }
+
+  if (selectedNode.type === 'box-vent') {
+    return 'box-vent'
+  }
+
+  if (selectedNode.type === 'ridge-vent') {
+    return 'ridge-vent'
+  }
+
+  if (selectedNode.type === 'turbine-vent') {
+    return 'turbine-vent'
+  }
+
+  if (selectedNode.type === 'cupola') {
+    return 'cupola'
+  }
+
+  if (selectedNode.type === 'eyebrow-vent') {
+    return 'eyebrow-vent'
+  }
+
   return null
 }

package/src/lib/placement-metadata.ts

@@ -0,0 +1,29 @@
+export function getPlacementMetadataRecord(metadata: unknown): Record<string, unknown> {
+  if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+    return {}
+  }
+
+  return metadata as Record<string, unknown>
+}
+
+export function addFreshPlacementMetadata(metadata: unknown): Record<string, unknown> {
+  return {
+    ...getPlacementMetadataRecord(metadata),
+    isNew: true,
+  }
+}
+
+export function isFreshPlacementMetadata(metadata: unknown): boolean {
+  return getPlacementMetadataRecord(metadata).isNew === true
+}
+
+export function stripPlacementMetadataFlags(metadata: unknown): unknown {
+  if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+    return metadata
+  }
+
+  const nextMeta = { ...(metadata as Record<string, unknown>) }
+  delete nextMeta.isNew
+  delete nextMeta.isTransient
+  return nextMeta
+}