Merge branch 'main' of github.com:sudhir9297/editor into feat/improvement-and-fixes

packages/core/src/events/bus.ts

@@ -13,6 +13,7 @@ import type {
   RoofSegmentNode,
   SiteNode,
   SlabNode,
+  SpawnNode,
   StairNode,
   StairSegmentNode,
   WallNode,
@@ -54,6 +55,7 @@ export type BuildingEvent = NodeEvent<BuildingNode>
 export type LevelEvent = NodeEvent<LevelNode>
 export type ZoneEvent = NodeEvent<ZoneNode>
 export type SlabEvent = NodeEvent<SlabNode>
+export type SpawnEvent = NodeEvent<SpawnNode>
 export type CeilingEvent = NodeEvent<CeilingNode>
 export type RoofEvent = NodeEvent<RoofNode>
 export type RoofSegmentEvent = NodeEvent<RoofSegmentNode>
@@ -103,10 +105,8 @@ export interface ThumbnailGenerateEvent {
 
 export interface CameraControlFitSceneEvent {
   /**
-   * XZ-plane axis-aligned bounds of the scene's geometry, computed from the
-   * scene graph (see `@pascal-app/editor`'s `computeSceneBoundsXZ`). The
-   * viewer's camera-controls listener frames the camera onto this box.
-   * Omitted values fall back to the camera's default pose.
+   * XZ-plane axis-aligned bounds for camera framing. Omitted values let the
+   * listener choose its default framing pose.
    */
   bounds?: {
     min: [number, number]
@@ -167,6 +167,7 @@ type EditorEvents = GridEvents &
   NodeEvents<'level', LevelEvent> &
   NodeEvents<'zone', ZoneEvent> &
   NodeEvents<'slab', SlabEvent> &
+  NodeEvents<'spawn', SpawnEvent> &
   NodeEvents<'ceiling', CeilingEvent> &
   NodeEvents<'roof', RoofEvent> &
   NodeEvents<'roof-segment', RoofSegmentEvent> &

packages/core/src/hooks/scene-registry/scene-registry.ts

@@ -18,6 +18,7 @@ export const sceneRegistry = {
     fence: new Set<string>(),
     item: new Set<string>(),
     slab: new Set<string>(),
+    spawn: new Set<string>(),
     zone: new Set<string>(),
     roof: new Set<string>(),
     'roof-segment': new Set<string>(),

packages/core/src/index.ts

@@ -14,6 +14,7 @@ export type {
   RoofSegmentEvent,
   SiteEvent,
   SlabEvent,
+  SpawnEvent,
   StairEvent,
   StairSegmentEvent,
   WallEvent,

packages/core/src/schema/index.ts

@@ -51,6 +51,7 @@ export { ScanNode } from './nodes/scan'
 export { SiteNode } from './nodes/site'
 export { SlabNode } from './nodes/slab'
 export type { StairSurfaceMaterialRole, StairSurfaceMaterialSpec } from './nodes/stair'
+export { SpawnNode } from './nodes/spawn'
 export {
   getEffectiveStairSurfaceMaterial,
   StairNode,

packages/core/src/schema/nodes/door.ts

@@ -77,7 +77,7 @@ export const DoorNode = BaseNode.extend({
 }).describe(dedent`Door node - a parametric door placed on a wall
   - position: center of the door in wall-local coordinate system (Y = height/2, always at floor)
   - segments: rows stacked top to bottom, each defining its own columnRatios
-  - type 'empty' = flush flat fill, 'panel' = raised/recessed panel, 'glass' = glazed
+  - type 'empty' = no leaf fill for that segment, 'panel' = raised/recessed panel, 'glass' = glazed
   - hingesSide/swingDirection: which way the door opens
   - doorCloser/panicBar: commercial and emergency hardware options
 `)

packages/core/src/schema/nodes/level.ts

@@ -8,6 +8,7 @@ import { ItemNode } from './item'
 import { RoofNode } from './roof'
 import { ScanNode } from './scan'
 import { SlabNode } from './slab'
+import { SpawnNode } from './spawn'
 import { StairNode } from './stair'
 import { WallNode } from './wall'
 import { ZoneNode } from './zone'
@@ -28,6 +29,7 @@ export const LevelNode = BaseNode.extend({
         StairNode.shape.id,
         ScanNode.shape.id,
         GuideNode.shape.id,
+        SpawnNode.shape.id,
       ]),
     )
     .default([]),

packages/core/src/schema/nodes/spawn.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod'
+import { BaseNode, nodeType, objectId } from '../base'
+
+export const SpawnNode = BaseNode.extend({
+  id: objectId('spawn'),
+  type: nodeType('spawn'),
+  position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+  rotation: z.number().default(0),
+})
+
+export type SpawnNode = z.infer<typeof SpawnNode>

packages/core/src/schema/types.ts

@@ -11,6 +11,7 @@ import { RoofSegmentNode } from './nodes/roof-segment'
 import { ScanNode } from './nodes/scan'
 import { SiteNode } from './nodes/site'
 import { SlabNode } from './nodes/slab'
+import { SpawnNode } from './nodes/spawn'
 import { StairNode } from './nodes/stair'
 import { StairSegmentNode } from './nodes/stair-segment'
 import { WallNode } from './nodes/wall'
@@ -33,6 +34,7 @@ export const AnyNode = z.discriminatedUnion('type', [
   StairSegmentNode,
   ScanNode,
   GuideNode,
+  SpawnNode,
   WindowNode,
   DoorNode,
 ])

packages/core/src/store/actions/node-actions.ts

@@ -238,27 +238,29 @@ export const createNodesAction = (
     const nextRootIds = [...state.rootNodeIds]
 
     for (const { node, parentId } of ops) {
+      const effectiveParentId = parentId ?? (node.parentId as AnyNodeId | null) ?? null
+
       // 1. Assign parentId to the child (Safe because BaseNode has parentId)
       const newNode = {
         ...node,
-        parentId: parentId ?? null,
+        parentId: effectiveParentId,
       }
 
       nextNodes[newNode.id] = newNode
 
       // 2. Update the Parent's children list
-      if (parentId && nextNodes[parentId]) {
-        const parent = nextNodes[parentId]
+      if (effectiveParentId && nextNodes[effectiveParentId]) {
+        const parent = nextNodes[effectiveParentId]
 
         // Type Guard: Check if the parent node is a container that supports children
         if ('children' in parent && Array.isArray(parent.children)) {
-          nextNodes[parentId] = {
+          nextNodes[effectiveParentId] = {
             ...parent,
             // Use Set to prevent duplicate IDs if createNode is called twice
             children: Array.from(new Set([...parent.children, newNode.id])) as any, // We don't verify child types here
           }
         }
-      } else if (!parentId) {
+      } else if (!effectiveParentId) {
         // 3. Handle Root nodes
         if (!nextRootIds.includes(newNode.id)) {
           nextRootIds.push(newNode.id)

packages/core/src/store/use-scene.ts

@@ -11,8 +11,8 @@ import { SiteNode } from '../schema/nodes/site'
 import { StairNode as StairNodeSchema } from '../schema/nodes/stair'
 import { StairSegmentNode as StairSegmentNodeSchema } from '../schema/nodes/stair-segment'
 import type { AnyNode, AnyNodeId } from '../schema/types'
-import { resetSceneHistoryPauseDepth } from './history-control'
 import * as nodeActions from './actions/node-actions'
+import { resetSceneHistoryPauseDepth } from './history-control'
 
 function getFiniteNumber(value: unknown, fallback: number) {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback
@@ -349,6 +349,67 @@ function migrateNodes(nodes: Record<string, any>): Record<string, AnyNode> {
   return patchedNodes as Record<string, AnyNode>
 }
 
+function getNodeChildIds(node: AnyNode): AnyNodeId[] {
+  if (!('children' in node) || !Array.isArray(node.children)) {
+    return []
+  }
+
+  return (node.children as unknown[])
+    .map((child) => {
+      if (typeof child === 'string') return child
+      if (child && typeof child === 'object' && 'id' in child && typeof child.id === 'string') {
+        return child.id
+      }
+      return null
+    })
+    .filter((id): id is AnyNodeId => typeof id === 'string')
+}
+
+function normalizeRootNodeIds(
+  nodes: Record<AnyNodeId, AnyNode>,
+  rootNodeIds: AnyNodeId[],
+): AnyNodeId[] {
+  const existingRootIds = rootNodeIds.filter((id) => Boolean(nodes[id]))
+  const siteRootIds = existingRootIds.filter((id) => nodes[id]?.type === 'site')
+
+  if (siteRootIds.length > 0) {
+    return siteRootIds
+  }
+
+  return existingRootIds.filter((id) => nodes[id]?.parentId === null)
+}
+
+function collectReachableNodeIds(
+  nodes: Record<AnyNodeId, AnyNode>,
+  rootNodeIds: AnyNodeId[],
+): Set<AnyNodeId> {
+  const reachable = new Set<AnyNodeId>()
+  const stack = [...rootNodeIds]
+  const childIdsByParentId = new Map<AnyNodeId, AnyNodeId[]>()
+
+  for (const node of Object.values(nodes)) {
+    if (!node.parentId) continue
+    const parentId = node.parentId as AnyNodeId
+    const children = childIdsByParentId.get(parentId) ?? []
+    children.push(node.id as AnyNodeId)
+    childIdsByParentId.set(parentId, children)
+  }
+
+  while (stack.length > 0) {
+    const id = stack.pop()
+    if (!id || reachable.has(id)) continue
+
+    const node = nodes[id]
+    if (!node) continue
+
+    reachable.add(id)
+    stack.push(...getNodeChildIds(node))
+    stack.push(...(childIdsByParentId.get(id) ?? []))
+  }
+
+  return reachable
+}
+
 export type SceneState = {
   // 1. The Data: A flat dictionary of all nodes
   nodes: Record<AnyNodeId, AnyNode>
@@ -450,9 +511,19 @@ const useScene: UseSceneStore = create<SceneState>()(
           }
         }
 
+        const normalizedRootNodeIds = normalizeRootNodeIds(cleanedNodes, rootNodeIds)
+        const reachableNodeIds = collectReachableNodeIds(cleanedNodes, normalizedRootNodeIds)
+        if (normalizedRootNodeIds.length > 0) {
+          for (const node of Object.values(cleanedNodes)) {
+            if (reachableNodeIds.has(node.id as AnyNodeId)) continue
+            console.warn('[Scene] Removing unreachable node', node.id)
+            delete cleanedNodes[node.id]
+          }
+        }
+
         set({
           nodes: cleanedNodes,
-          rootNodeIds,
+          rootNodeIds: normalizedRootNodeIds,
           dirtyNodes: new Set<AnyNodeId>(),
           collections: {},
         })

packages/core/src/systems/door/door-system.tsx

@@ -86,6 +86,7 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
     contentPadding,
     hingesSide,
   } = node
+  const hasLeafContent = segments.some((seg) => seg.type !== 'empty')
 
   // Leaf occupies the full opening (no bottom frame bar — door opens to floor)
   const leafW = width - 2 * frameThickness
@@ -146,13 +147,13 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
   // ── Leaf — contentPadding border strips (no full backing; glass areas are open) ──
   const cpX = contentPadding[0]
   const cpY = contentPadding[1]
-  if (cpY > 0) {
+  if (hasLeafContent && cpY > 0) {
     // Top strip
     addBox(mesh, baseMaterial, leafW, cpY, leafDepth, 0, leafCenterY + leafH / 2 - cpY / 2, 0)
     // Bottom strip
     addBox(mesh, baseMaterial, leafW, cpY, leafDepth, 0, leafCenterY - leafH / 2 + cpY / 2, 0)
   }
-  if (cpX > 0) {
+  if (hasLeafContent && cpX > 0) {
     const innerH = leafH - 2 * cpY
     // Left strip
     addBox(mesh, baseMaterial, cpX, innerH, leafDepth, -leafW / 2 + cpX / 2, leafCenterY, 0)
@@ -188,20 +189,22 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
     }
 
     // Column dividers within this segment
-    cx = -contentW / 2
-    for (let c = 0; c < numCols - 1; c++) {
-      cx += colWidths[c]!
-      addBox(
-        mesh,
-        baseMaterial,
-        seg.dividerThickness,
-        segH,
-        leafDepth + 0.001,
-        cx + seg.dividerThickness / 2,
-        segCenterY,
-        0,
-      )
-      cx += seg.dividerThickness
+    if (seg.type !== 'empty') {
+      cx = -contentW / 2
+      for (let c = 0; c < numCols - 1; c++) {
+        cx += colWidths[c]!
+        addBox(
+          mesh,
+          baseMaterial,
+          seg.dividerThickness,
+          segH,
+          leafDepth + 0.001,
+          cx + seg.dividerThickness / 2,
+          segCenterY,
+          0,
+        )
+        cx += seg.dividerThickness
+      }
     }
 
     // Segment content per column
@@ -225,8 +228,7 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
           addBox(mesh, baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, panelZ)
         }
       } else {
-        // 'empty' — opaque backing, no detail
-        addBox(mesh, baseMaterial, colW, segH, leafDepth, colX, segCenterY, 0)
+        // 'empty' leaves the opening unfilled
       }
     }
 
@@ -234,7 +236,7 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
   }
 
   // ── Handle ──
-  if (handle) {
+  if (hasLeafContent && handle) {
     // Convert from floor-based height to mesh-center-based Y
     const handleY = handleHeight - height / 2
     // Handle grip sits on the front face (+Z) of the leaf
@@ -250,7 +252,7 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
   }
 
   // ── Door closer (commercial hardware at top) ──
-  if (doorCloser) {
+  if (hasLeafContent && doorCloser) {
     const closerY = leafCenterY + leafH / 2 - 0.04
     // Body
     addBox(mesh, baseMaterial, 0.28, 0.055, 0.055, 0, closerY, leafDepth / 2 + 0.03)
@@ -268,13 +270,13 @@ function updateDoorMesh(node: DoorNode, mesh: THREE.Mesh) {
   }
 
   // ── Panic bar ──
-  if (panicBar) {
+  if (hasLeafContent && panicBar) {
     const barY = panicBarHeight - height / 2
     addBox(mesh, baseMaterial, leafW * 0.72, 0.04, 0.055, 0, barY, leafDepth / 2 + 0.03)
   }
 
   // ── Hinges (3 knuckle-style hinges on the hinge side) ──
-  {
+  if (hasLeafContent) {
     const hingeX = hingesSide === 'right' ? leafW / 2 - 0.012 : -leafW / 2 + 0.012
     const hingeZ = 0 // centered in leaf depth
     const hingeH = 0.1

packages/core/src/systems/stair/stair-opening-sync.ts

@@ -1,12 +1,14 @@
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync'
 import type {
   AnyNode,
   AnyNodeId,
   CeilingNode,
+  LevelNode,
   SlabNode,
   StairNode,
   StairSegmentNode,
 } from '../../schema'
+
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync'
 import { DEFAULT_WALL_HEIGHT } from '../wall/wall-footprint'
 
 type Point2D = [number, number]
@@ -34,9 +36,10 @@ type AxisAlignedRect = {
   maxZ: number
 }
 
-const CURVED_STAIR_SLAB_OPENING_RATIO = 0.8
+const CURVED_STAIR_SLAB_OPENING_RATIO = 0.9
 const STRAIGHT_STAIR_TARGET_THRESHOLD_MIN = 0.35
 const STAIR_SLAB_OPENING_TIGHTENING = 0
+const CURVED_STAIR_OPENING_STEP_PADDING = 3
 
 function clamp(value: number, min: number, max: number) {
   return Math.min(max, Math.max(min, value))
@@ -423,24 +426,39 @@ function buildUnionPolygonsFromRects(rects: AxisAlignedRect[]): Point2D[][] {
   return polygons
 }
 
-function getCurvedOpeningPolygon(stair: StairNode): Point2D[] {
-  const width = Math.max(stair.width ?? 1, 0.4)
-  const innerRadius = Math.max(0.2, stair.innerRadius ?? 0.9)
-  const outerRadius = innerRadius + width
-  const totalSweep = stair.sweepAngle ?? Math.PI / 2
-  const openingSweep =
-    Math.sign(totalSweep || 1) *
+function getCurvedOpeningStepCount(
+  stair: StairNode,
+  innerRadius: number,
+  outerRadius: number,
+  totalSweep: number,
+) {
+  const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10))
+  const stepSweep = Math.abs(totalSweep) / stepCount
+  const midRadius = Math.max((innerRadius + outerRadius) * 0.5, 0.01)
+  const treadDepth = Math.max(stepSweep * midRadius, 0.2)
+  return Math.min(
+    stepCount,
     Math.max(
-      Math.abs(totalSweep) * CURVED_STAIR_SLAB_OPENING_RATIO,
-      Math.abs(totalSweep) / Math.max(stair.stepCount ?? 1, 1),
-    )
-  const startAngle = totalSweep / 2 - openingSweep
-  const endAngle = totalSweep / 2
+      1,
+      Math.ceil(1.8 / treadDepth),
+      Math.ceil(stepCount * CURVED_STAIR_SLAB_OPENING_RATIO),
+    ),
+  )
+}
+
+function buildArcOpeningPolygon(
+  stair: StairNode,
+  innerRadius: number,
+  outerRadius: number,
+  startAngle: number,
+  endAngle: number,
+): Point2D[] {
+  const sweep = endAngle - startAngle
   const segmentCount = Math.max(
     10,
     Math.min(
       32,
-      Math.ceil(Math.abs(openingSweep) / (Math.PI / 24) + Math.max(stair.stepCount ?? 1, 1) * 0.5),
+      Math.ceil(Math.abs(sweep) / (Math.PI / 24) + Math.max(stair.stepCount ?? 1, 1) * 0.5),
     ),
   )
   const outerPoints: Point2D[] = []
@@ -448,7 +466,7 @@ function getCurvedOpeningPolygon(stair: StairNode): Point2D[] {
 
   for (let index = 0; index <= segmentCount; index++) {
     const t = index / segmentCount
-    const angle = startAngle + (endAngle - startAngle) * t
+    const angle = startAngle + sweep * t
     outerPoints.push(
       toWorldPlanPoint(stair, Math.cos(angle) * outerRadius, Math.sin(angle) * outerRadius),
     )
@@ -456,7 +474,8 @@ function getCurvedOpeningPolygon(stair: StairNode): Point2D[] {
 
   for (let index = segmentCount; index >= 0; index--) {
     const t = index / segmentCount
-    const angle = startAngle + (endAngle - startAngle) * t
+    const angle = startAngle + sweep * t
+
     innerPoints.push(
       toWorldPlanPoint(stair, Math.cos(angle) * innerRadius, Math.sin(angle) * innerRadius),
     )
@@ -465,6 +484,39 @@ function getCurvedOpeningPolygon(stair: StairNode): Point2D[] {
   return [...outerPoints, ...innerPoints]
 }
 
+function getCurvedOpeningPolygon(stair: StairNode, targetElevation?: number): Point2D[] {
+  const width = Math.max(stair.width ?? 1, 0.4)
+  const innerRadius = Math.max(0.2, stair.innerRadius ?? 0.9)
+  const outerRadius = innerRadius + width
+  const totalSweep = stair.sweepAngle ?? Math.PI / 2
+  const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10))
+  const stepHeight = Math.max(stair.totalRise ?? 2.5, 0.1) / stepCount
+  const stepSweep = totalSweep / stepCount
+  const targetThreshold = Math.max(stepHeight * 2, STRAIGHT_STAIR_TARGET_THRESHOLD_MIN)
+  const endAngle = totalSweep / 2
+
+  const fallbackStartStepIndex = Math.max(
+    0,
+    stepCount - getCurvedOpeningStepCount(stair, innerRadius, outerRadius, totalSweep),
+  )
+  let startStepIndex = fallbackStartStepIndex
+  if (typeof targetElevation === 'number') {
+    for (let index = 0; index < stepCount; index += 1) {
+      const stepTopElevation = stepHeight * (index + 1)
+      if (stepTopElevation >= targetElevation - targetThreshold) {
+        startStepIndex = Math.max(
+          0,
+          Math.min(fallbackStartStepIndex, index - CURVED_STAIR_OPENING_STEP_PADDING),
+        )
+        break
+      }
+    }
+  }
+
+  const startAngle = -totalSweep / 2 + stepSweep * startStepIndex
+  return buildArcOpeningPolygon(stair, innerRadius, outerRadius, startAngle, endAngle)
+}
+
 function getSpiralOpeningPolygon(stair: StairNode): Point2D[] {
   const radius = Math.max(0.05, stair.innerRadius ?? 0.9) + Math.max(stair.width ?? 1, 0.4)
   const segmentCount = 48
@@ -569,7 +621,7 @@ function getStairOpeningPolygons(
   }
 
   if (stair.stairType === 'curved') {
-    return [getCurvedOpeningPolygon(stair)]
+    return [getCurvedOpeningPolygon(stair, targetElevation)]
   }
 
   if (stair.stairType === 'spiral') {