@pascal-app/core 0.5.0 → 0.5.1

package/dist/events/bus.d.ts

@@ -1,5 +1,5 @@
 import type { ThreeEvent } from '@react-three/fiber';
-import type { BuildingNode, CeilingNode, DoorNode, ItemNode, LevelNode, RoofNode, RoofSegmentNode, SiteNode, SlabNode, StairNode, StairSegmentNode, WallNode, WindowNode, ZoneNode } from '../schema';
+import type { BuildingNode, CeilingNode, DoorNode, FenceNode, ItemNode, LevelNode, RoofNode, RoofSegmentNode, SiteNode, SlabNode, StairNode, StairSegmentNode, WallNode, WindowNode, ZoneNode } from '../schema';
 import type { AnyNode } from '../schema/types';
 export interface GridEvent {
     /** World-space intersection point on the grid plane. */
@@ -21,6 +21,7 @@ export interface NodeEvent<T extends AnyNode = AnyNode> {
     nativeEvent: ThreeEvent<PointerEvent>;
 }
 export type WallEvent = NodeEvent<WallNode>;
+export type FenceEvent = NodeEvent<FenceNode>;
 export type ItemEvent = NodeEvent<ItemNode>;
 export type SiteEvent = NodeEvent<SiteNode>;
 export type BuildingEvent = NodeEvent<BuildingNode>;
@@ -74,7 +75,7 @@ type ThumbnailEvents = {
     'thumbnail:before-capture': undefined;
     'thumbnail:after-capture': undefined;
 };
-type EditorEvents = GridEvents & NodeEvents<'wall', WallEvent> & NodeEvents<'item', ItemEvent> & NodeEvents<'site', SiteEvent> & NodeEvents<'building', BuildingEvent> & NodeEvents<'level', LevelEvent> & NodeEvents<'zone', ZoneEvent> & NodeEvents<'slab', SlabEvent> & NodeEvents<'ceiling', CeilingEvent> & NodeEvents<'roof', RoofEvent> & NodeEvents<'roof-segment', RoofSegmentEvent> & NodeEvents<'stair', StairEvent> & NodeEvents<'stair-segment', StairSegmentEvent> & NodeEvents<'window', WindowEvent> & NodeEvents<'door', DoorEvent> & CameraControlEvents & ToolEvents & PresetEvents & ThumbnailEvents;
+type EditorEvents = GridEvents & NodeEvents<'wall', WallEvent> & NodeEvents<'fence', FenceEvent> & NodeEvents<'item', ItemEvent> & NodeEvents<'site', SiteEvent> & NodeEvents<'building', BuildingEvent> & NodeEvents<'level', LevelEvent> & NodeEvents<'zone', ZoneEvent> & NodeEvents<'slab', SlabEvent> & NodeEvents<'ceiling', CeilingEvent> & NodeEvents<'roof', RoofEvent> & NodeEvents<'roof-segment', RoofSegmentEvent> & NodeEvents<'stair', StairEvent> & NodeEvents<'stair-segment', StairSegmentEvent> & NodeEvents<'window', WindowEvent> & NodeEvents<'door', DoorEvent> & CameraControlEvents & ToolEvents & PresetEvents & ThumbnailEvents;
 export declare const emitter: import("mitt").Emitter<EditorEvents>;
 export {};
 //# sourceMappingURL=bus.d.ts.map

package/dist/events/bus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bus.d.ts","sourceRoot":"","sources":["../../src/events/bus.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bus.d.ts","sourceRoot":"","sources":["../../src/events/bus.ts"],"names":[],"mappings":"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"}

package/dist/hooks/scene-registry/scene-registry.d.ts

@@ -7,6 +7,7 @@ export declare const sceneRegistry: {
         ceiling: Set<string>;
         level: Set<string>;
         wall: Set<string>;
+        fence: Set<string>;
         item: Set<string>;
         slab: Set<string>;
         zone: Set<string>;

package/dist/hooks/scene-registry/scene-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-registry.d.ts","sourceRoot":"","sources":["../../../src/hooks/scene-registry/scene-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;IAyBxB,gFAAgF;;CAOjF,CAAA;AAED,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,OAAO,aAAa,CAAC,MAAM,EACvC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,QAkBrC"}
+{"version":3,"file":"scene-registry.d.ts","sourceRoot":"","sources":["../../../src/hooks/scene-registry/scene-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;IA0BxB,gFAAgF;;CAOjF,CAAA;AAED,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,OAAO,aAAa,CAAC,MAAM,EACvC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,QAkBrC"}

package/dist/hooks/scene-registry/scene-registry.js

@@ -11,6 +11,7 @@ export const sceneRegistry = {
         ceiling: new Set(),
         level: new Set(),
         wall: new Set(),
+        fence: new Set(),
         item: new Set(),
         slab: new Set(),
         zone: new Set(),

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { BuildingEvent, CameraControlEvent, CeilingEvent, DoorEvent, EventSuffix, GridEvent, ItemEvent, LevelEvent, NodeEvent, RoofEvent, RoofSegmentEvent, SiteEvent, SlabEvent, StairEvent, StairSegmentEvent, WallEvent, WindowEvent, ZoneEvent, } from './events/bus';
+export type { BuildingEvent, CameraControlEvent, CeilingEvent, DoorEvent, EventSuffix, FenceEvent, GridEvent, ItemEvent, LevelEvent, NodeEvent, RoofEvent, RoofSegmentEvent, SiteEvent, SlabEvent, StairEvent, StairSegmentEvent, WallEvent, WindowEvent, ZoneEvent, } from './events/bus';
 export { emitter, eventSuffixes } from './events/bus';
 export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
 export { pointInPolygon, spatialGridManager } from './hooks/spatial-grid/spatial-grid-manager';
@@ -10,6 +10,7 @@ export { baseMaterial, glassMaterial } from './materials';
 export * from './schema';
 export { type ControlValue, type ItemInteractiveState, useInteractive, } from './store/use-interactive';
 export { default as useLiveTransforms, type LiveTransform } from './store/use-live-transforms';
+export { FenceSystem } from './systems/fence/fence-system';
 export { clearSceneHistory, default as useScene } from './store/use-scene';
 export { CeilingSystem } from './systems/ceiling/ceiling-system';
 export { DoorSystem } from './systems/door/door-system';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,aAAa,EACb,WAAW,GACZ,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAA;AAC9F,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,KAAK,EACV,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACzD,cAAc,UAAU,CAAA;AACxB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,EAAE,iBAAiB,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC1D,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,oBAAoB,EACpB,KAAK,OAAO,EACZ,UAAU,EACV,KAAK,aAAa,GACnB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAC7D,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC9F,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,aAAa,EACb,WAAW,GACZ,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAA;AAC9F,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,KAAK,EACV,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACzD,cAAc,UAAU,CAAA;AACxB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC1D,OAAO,EAAE,iBAAiB,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC1D,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,oBAAoB,EACpB,KAAK,OAAO,EACZ,UAAU,EACV,KAAK,aAAa,GACnB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAC7D,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC9F,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -9,6 +9,7 @@ export { baseMaterial, glassMaterial } from './materials';
 export * from './schema';
 export { useInteractive, } from './store/use-interactive';
 export { default as useLiveTransforms } from './store/use-live-transforms';
+export { FenceSystem } from './systems/fence/fence-system';
 export { clearSceneHistory, default as useScene } from './store/use-scene';
 export { CeilingSystem } from './systems/ceiling/ceiling-system';
 export { DoorSystem } from './systems/door/door-system';

package/dist/schema/index.d.ts

@@ -5,6 +5,7 @@ export { DEFAULT_MATERIALS, MaterialPreset, MaterialProperties, MaterialSchema,
 export { BuildingNode } from './nodes/building';
 export { CeilingNode } from './nodes/ceiling';
 export { DoorNode, DoorSegment } from './nodes/door';
+export { FenceBaseStyle, FenceNode, FenceStyle } from './nodes/fence';
 export { GuideNode } from './nodes/guide';
 export type { AnimationEffect, Asset, AssetInput, Control, Effect, Interactive, LightEffect, SliderControl, TemperatureControl, ToggleControl, } from './nodes/item';
 export { getScaledDimensions, ItemNode } from './nodes/item';
@@ -14,7 +15,7 @@ export { RoofSegmentNode, RoofType } from './nodes/roof-segment';
 export { ScanNode } from './nodes/scan';
 export { SiteNode } from './nodes/site';
 export { SlabNode } from './nodes/slab';
-export { StairNode } from './nodes/stair';
+export { StairNode, StairRailingMode, StairTopLandingMode, StairType } from './nodes/stair';
 export { AttachmentSide, StairSegmentNode, StairSegmentType } from './nodes/stair-segment';
 export { WallNode } from './nodes/wall';
 export { WindowNode } from './nodes/window';

package/dist/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAExF,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EACV,eAAe,EACf,KAAK,EACL,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAW,EACX,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,aAAa,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAC1F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAExF,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EACV,eAAe,EACf,KAAK,EACL,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAW,EACX,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,aAAa,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC3F,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAC1F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA"}

package/dist/schema/index.js

@@ -9,6 +9,7 @@ export { DEFAULT_MATERIALS, MaterialPreset, MaterialProperties, MaterialSchema,
 export { BuildingNode } from './nodes/building';
 export { CeilingNode } from './nodes/ceiling';
 export { DoorNode, DoorSegment } from './nodes/door';
+export { FenceBaseStyle, FenceNode, FenceStyle } from './nodes/fence';
 export { GuideNode } from './nodes/guide';
 export { getScaledDimensions, ItemNode } from './nodes/item';
 export { LevelNode } from './nodes/level';
@@ -18,7 +19,7 @@ export { ScanNode } from './nodes/scan';
 // Nodes
 export { SiteNode } from './nodes/site';
 export { SlabNode } from './nodes/slab';
-export { StairNode } from './nodes/stair';
+export { StairNode, StairRailingMode, StairTopLandingMode, StairType } from './nodes/stair';
 export { AttachmentSide, StairSegmentNode, StairSegmentType } from './nodes/stair-segment';
 export { WallNode } from './nodes/wall';
 export { WindowNode } from './nodes/window';

package/dist/schema/nodes/fence.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const FenceStyle: z.ZodEnum<{
+    slat: "slat";
+    rail: "rail";
+    privacy: "privacy";
+}>;
+export declare const FenceBaseStyle: z.ZodEnum<{
+    floating: "floating";
+    grounded: "grounded";
+}>;
+export declare const FenceNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"fence">>;
+    start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    height: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    baseHeight: z.ZodDefault<z.ZodNumber>;
+    postSpacing: z.ZodDefault<z.ZodNumber>;
+    postSize: z.ZodDefault<z.ZodNumber>;
+    topRailHeight: z.ZodDefault<z.ZodNumber>;
+    groundClearance: z.ZodDefault<z.ZodNumber>;
+    edgeInset: z.ZodDefault<z.ZodNumber>;
+    baseStyle: z.ZodDefault<z.ZodEnum<{
+        floating: "floating";
+        grounded: "grounded";
+    }>>;
+    color: z.ZodDefault<z.ZodString>;
+    style: z.ZodDefault<z.ZodEnum<{
+        slat: "slat";
+        rail: "rail";
+        privacy: "privacy";
+    }>>;
+}, z.core.$strip>;
+export type FenceNode = z.infer<typeof FenceNode>;
+//# sourceMappingURL=fence.d.ts.map

package/dist/schema/nodes/fence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU;;;;EAAsC,CAAA;AAC7D,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAE9D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/fence.js

@@ -0,0 +1,29 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const FenceStyle = z.enum(['slat', 'rail', 'privacy']);
+export const FenceBaseStyle = z.enum(['floating', 'grounded']);
+export const FenceNode = BaseNode.extend({
+    id: objectId('fence'),
+    type: nodeType('fence'),
+    start: z.tuple([z.number(), z.number()]),
+    end: z.tuple([z.number(), z.number()]),
+    height: z.number().default(1.8),
+    thickness: z.number().default(0.08),
+    baseHeight: z.number().default(0.22),
+    postSpacing: z.number().default(2),
+    postSize: z.number().default(0.1),
+    topRailHeight: z.number().default(0.04),
+    groundClearance: z.number().default(0),
+    edgeInset: z.number().default(0.015),
+    baseStyle: FenceBaseStyle.default('grounded'),
+    color: z.string().default('#ffffff'),
+    style: FenceStyle.default('slat'),
+}).describe(dedent `
+  Fence node - used to represent a fence segment in the building/site level coordinate system
+  - start/end: fence endpoints in level coordinate system
+  - height/thickness: overall fence dimensions in meters
+  - baseHeight/postSpacing/postSize/topRailHeight: exact geometric controls from the plan3D fence model
+  - groundClearance/edgeInset/baseStyle: fence support and inset configuration
+  - color/style: visual appearance options
+  `);

package/dist/schema/nodes/level.d.ts

@@ -17,7 +17,7 @@ export declare const LevelNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type LevelNode = z.infer<typeof LevelNode>;

package/dist/schema/nodes/level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBAyBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAYvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA0BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -2,6 +2,7 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { CeilingNode } from './ceiling';
+import { FenceNode } from './fence';
 import { GuideNode } from './guide';
 import { RoofNode } from './roof';
 import { ScanNode } from './scan';
@@ -15,6 +16,7 @@ export const LevelNode = BaseNode.extend({
     children: z
         .array(z.union([
         WallNode.shape.id,
+        FenceNode.shape.id,
         ZoneNode.shape.id,
         SlabNode.shape.id,
         CeilingNode.shape.id,

package/dist/schema/nodes/stair.d.ts

@@ -1,4 +1,22 @@
 import { z } from 'zod';
+export declare const StairRailingMode: z.ZodEnum<{
+    none: "none";
+    left: "left";
+    right: "right";
+    both: "both";
+}>;
+export declare const StairType: z.ZodEnum<{
+    straight: "straight";
+    curved: "curved";
+    spiral: "spiral";
+}>;
+export declare const StairTopLandingMode: z.ZodEnum<{
+    none: "none";
+    integrated: "integrated";
+}>;
+export type StairRailingMode = z.infer<typeof StairRailingMode>;
+export type StairType = z.infer<typeof StairType>;
+export type StairTopLandingMode = z.infer<typeof StairTopLandingMode>;
 export declare const StairNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -50,6 +68,32 @@ export declare const StairNode: z.ZodObject<{
     }, z.core.$strip>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    stairType: z.ZodDefault<z.ZodEnum<{
+        straight: "straight";
+        curved: "curved";
+        spiral: "spiral";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    totalRise: z.ZodDefault<z.ZodNumber>;
+    stepCount: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    innerRadius: z.ZodDefault<z.ZodNumber>;
+    sweepAngle: z.ZodDefault<z.ZodNumber>;
+    topLandingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        integrated: "integrated";
+    }>>;
+    topLandingDepth: z.ZodDefault<z.ZodNumber>;
+    showCenterColumn: z.ZodDefault<z.ZodBoolean>;
+    showStepSupports: z.ZodDefault<z.ZodBoolean>;
+    railingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        left: "left";
+        right: "right";
+        both: "both";
+    }>>;
+    railingHeight: z.ZodDefault<z.ZodNumber>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>>>;
 }, z.core.$strip>;
 export type StairNode = z.infer<typeof StairNode>;

package/dist/schema/nodes/stair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AAEjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AACjD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/stair.js

@@ -3,6 +3,9 @@ import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
 import { StairSegmentNode } from './stair-segment';
+export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
+export const StairType = z.enum(['straight', 'curved', 'spiral']);
+export const StairTopLandingMode = z.enum(['none', 'integrated']);
 export const StairNode = BaseNode.extend({
     id: objectId('stair'),
     type: nodeType('stair'),
@@ -10,13 +13,41 @@ export const StairNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
+    stairType: StairType.default('straight'),
+    width: z.number().default(1.0),
+    totalRise: z.number().default(2.5),
+    stepCount: z.number().default(10),
+    thickness: z.number().default(0.25),
+    fillToFloor: z.boolean().default(true),
+    innerRadius: z.number().default(0.9),
+    sweepAngle: z.number().default(Math.PI / 2),
+    topLandingMode: StairTopLandingMode.default('none'),
+    topLandingDepth: z.number().default(0.9),
+    showCenterColumn: z.boolean().default(true),
+    showStepSupports: z.boolean().default(true),
+    railingMode: StairRailingMode.default('none'),
+    railingHeight: z.number().default(0.92),
     // Child stair segment IDs
     children: z.array(StairSegmentNode.shape.id).default([]),
 }).describe(dedent `
   Stair node - a container for stair segments.
-  Acts as a group that holds one or more StairSegmentNodes (flights and landings).
-  Segments chain together based on their attachmentSide to form complex staircase shapes.
+  Acts as a group that either holds one or more StairSegmentNodes (straight stairs)
+  or stores stair-level geometry properties for curved stairs.
   - position: center position of the stair group
   - rotation: rotation around Y axis
-  - children: array of StairSegmentNode IDs
+  - stairType: straight (segment-based), curved (arc-based), or spiral
+  - width: stair width
+  - totalRise: total stair height
+  - stepCount: number of visible steps
+  - thickness: stair slab / tread thickness
+  - fillToFloor: whether the stair mass fills down to the floor or uses tread thickness only
+  - innerRadius: inner curve radius for curved stairs
+  - sweepAngle: total curved stair sweep in radians
+  - topLandingMode: optional integrated top landing for spiral stairs
+  - topLandingDepth: depth used to size the integrated spiral top landing
+  - showCenterColumn: whether spiral stairs render a center column
+  - showStepSupports: whether spiral stairs render step support brackets
+  - railingMode: whether to render railings and on which side(s)
+  - railingHeight: top height of the railing above the stair surface
+  - children: array of StairSegmentNode IDs for straight stairs
   `);

package/dist/schema/types.d.ts

@@ -175,7 +175,7 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -241,6 +241,44 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
         interior: "interior";
         exterior: "exterior";
     }>>;
+}, z.core.$strip>, z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"fence">>;
+    start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    height: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    baseHeight: z.ZodDefault<z.ZodNumber>;
+    postSpacing: z.ZodDefault<z.ZodNumber>;
+    postSize: z.ZodDefault<z.ZodNumber>;
+    topRailHeight: z.ZodDefault<z.ZodNumber>;
+    groundClearance: z.ZodDefault<z.ZodNumber>;
+    edgeInset: z.ZodDefault<z.ZodNumber>;
+    baseStyle: z.ZodDefault<z.ZodEnum<{
+        floating: "floating";
+        grounded: "grounded";
+    }>>;
+    color: z.ZodDefault<z.ZodString>;
+    style: z.ZodDefault<z.ZodEnum<{
+        slat: "slat";
+        rail: "rail";
+        privacy: "privacy";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -630,6 +668,32 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    stairType: z.ZodDefault<z.ZodEnum<{
+        straight: "straight";
+        curved: "curved";
+        spiral: "spiral";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    totalRise: z.ZodDefault<z.ZodNumber>;
+    stepCount: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    innerRadius: z.ZodDefault<z.ZodNumber>;
+    sweepAngle: z.ZodDefault<z.ZodNumber>;
+    topLandingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        integrated: "integrated";
+    }>>;
+    topLandingDepth: z.ZodDefault<z.ZodNumber>;
+    showCenterColumn: z.ZodDefault<z.ZodBoolean>;
+    showStepSupports: z.ZodDefault<z.ZodBoolean>;
+    railingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        left: "left";
+        right: "right";
+        both: "both";
+    }>>;
+    railingHeight: z.ZodDefault<z.ZodNumber>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>>>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -691,9 +755,9 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     height: z.ZodDefault<z.ZodNumber>;
     stepCount: z.ZodDefault<z.ZodNumber>;
     attachmentSide: z.ZodDefault<z.ZodEnum<{
-        front: "front";
         left: "left";
         right: "right";
+        front: "front";
     }>>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;
     thickness: z.ZodDefault<z.ZodNumber>;

package/dist/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAkBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAmBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/types.js

@@ -2,6 +2,7 @@ import z from 'zod';
 import { BuildingNode } from './nodes/building';
 import { CeilingNode } from './nodes/ceiling';
 import { DoorNode } from './nodes/door';
+import { FenceNode } from './nodes/fence';
 import { GuideNode } from './nodes/guide';
 import { ItemNode } from './nodes/item';
 import { LevelNode } from './nodes/level';
@@ -20,6 +21,7 @@ export const AnyNode = z.discriminatedUnion('type', [
     BuildingNode,
     LevelNode,
     WallNode,
+    FenceNode,
     ItemNode,
     ZoneNode,
     SlabNode,

package/dist/store/use-scene.js

@@ -284,7 +284,7 @@ useScene.temporal.subscribe((state) => {
                             // Mark sibling nodes dirty so they can update their geometry
                             // (e.g. adjacent walls need to recalculate miter/junction geometry)
                             const parent = currentNodes[parentId];
-                            if (parent && 'children' in parent) {
+                            if (parent && 'children' in parent && Array.isArray(parent.children)) {
                                 for (const childId of parent.children) {
                                     markDirty(childId);
                                 }

package/dist/systems/fence/fence-system.d.ts

@@ -0,0 +1,2 @@
+export declare const FenceSystem: () => null;
+//# sourceMappingURL=fence-system.d.ts.map

package/dist/systems/fence/fence-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AA+HA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}

package/dist/systems/fence/fence-system.js

@@ -0,0 +1,120 @@
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
+import useScene from '../../store/use-scene';
+function getStyleDefaults(style) {
+    if (style === 'privacy') {
+        return { spacingFactor: 0.42, postFactor: 1.35, baseFactor: 1.2, topFactor: 1.2 };
+    }
+    if (style === 'rail') {
+        return { spacingFactor: 0.68, postFactor: 0.8, baseFactor: 0.85, topFactor: 0.85 };
+    }
+    return { spacingFactor: 0.3, postFactor: 0.55, baseFactor: 1, topFactor: 0.75 };
+}
+function createFenceParts(fence) {
+    const parts = [];
+    const length = Math.max(Math.hypot(fence.end[0] - fence.start[0], fence.end[1] - fence.start[1]), 0.01);
+    const panelDepth = Math.max(fence.thickness, 0.03);
+    const clearance = Math.max(fence.groundClearance, 0);
+    const styleDefaults = getStyleDefaults(fence.style);
+    const baseHeight = Math.max(fence.baseHeight * styleDefaults.baseFactor, 0.04);
+    const topRailHeight = Math.max(fence.topRailHeight * styleDefaults.topFactor, 0.01);
+    const verticalHeight = Math.max(fence.height - baseHeight - topRailHeight, 0.08);
+    const postWidth = Math.max(fence.postSize * styleDefaults.postFactor, 0.01);
+    const spacing = Math.max(fence.postSpacing * styleDefaults.spacingFactor, postWidth * 1.2);
+    const edgeInset = Math.max(fence.edgeInset ?? 0.015, 0.005);
+    const isFloating = fence.baseStyle === 'floating';
+    const baseY = isFloating ? clearance : 0;
+    const effectiveBaseHeight = baseHeight;
+    if (!isFloating) {
+        parts.push({
+            position: [0, baseY + effectiveBaseHeight / 2, 0],
+            scale: [length, effectiveBaseHeight, panelDepth * 1.05],
+        });
+        parts.push({
+            position: [0, baseY + effectiveBaseHeight + verticalHeight * 0.15, 0],
+            scale: [length, topRailHeight * 0.8, panelDepth * 0.35],
+        });
+    }
+    const count = Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1);
+    const step = count > 1 ? (length - edgeInset * 2) / (count - 1) : 0;
+    const startX = -length / 2 + edgeInset;
+    const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
+    for (let index = 0; index < count; index += 1) {
+        const x = count === 1 ? 0 : startX + step * index;
+        let posX = x;
+        const isEdgePost = index === 0 || index === count - 1;
+        if (count > 1) {
+            if (index === 0)
+                posX = -length / 2 + edgeInset + postWidth / 2;
+            else if (index === count - 1)
+                posX = length / 2 - edgeInset - postWidth / 2;
+        }
+        const postHeight = isFloating && isEdgePost
+            ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
+            : verticalHeight;
+        const postY = isFloating && isEdgePost ? postHeight / 2 : verticalY;
+        parts.push({
+            position: [posX, postY, 0],
+            scale: [postWidth, postHeight, Math.max(panelDepth * 0.35, 0.012)],
+        });
+    }
+    parts.push({
+        position: [0, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, 0],
+        scale: [length, topRailHeight, Math.max(panelDepth * 0.55, 0.018)],
+    });
+    if (isFloating) {
+        parts.push({
+            position: [0, baseY + effectiveBaseHeight + topRailHeight / 2, 0],
+            scale: [length, topRailHeight, Math.max(panelDepth * 0.55, 0.018)],
+        });
+    }
+    return parts;
+}
+function generateFenceGeometry(fence) {
+    const parts = createFenceParts(fence);
+    const geometries = parts.map((part) => {
+        const geometry = new THREE.BoxGeometry(1, 1, 1);
+        geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
+        geometry.translate(part.position[0], part.position[1], part.position[2]);
+        return geometry;
+    });
+    const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
+    geometries.forEach((geometry) => geometry.dispose());
+    merged.computeVertexNormals();
+    return merged;
+}
+function updateFenceGeometry(fenceId) {
+    const node = useScene.getState().nodes[fenceId];
+    if (!node || node.type !== 'fence')
+        return;
+    const mesh = sceneRegistry.nodes.get(fenceId);
+    if (!mesh)
+        return;
+    const newGeometry = generateFenceGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeometry;
+    const centerX = (node.start[0] + node.end[0]) / 2;
+    const centerZ = (node.start[1] + node.end[1]) / 2;
+    const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
+    mesh.position.set(centerX, 0, centerZ);
+    mesh.rotation.set(0, -angle, 0);
+}
+export const FenceSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'fence')
+                return;
+            updateFenceGeometry(id);
+            clearDirty(id);
+        });
+    }, 4);
+    return null;
+};

package/dist/systems/stair/stair-system.js

@@ -246,14 +246,16 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
     const mergedMesh = group.getObjectByName('merged-stair');
     if (!mergedMesh)
         return;
+    if (stairNode.stairType === 'curved' || stairNode.stairType === 'spiral') {
+        replaceMeshGeometry(mergedMesh, createEmptyGeometry());
+        return;
+    }
     const children = stairNode.children ?? [];
     const segments = children
         .map((childId) => nodes[childId])
         .filter((n) => n?.type === 'stair-segment');
     if (segments.length === 0) {
-        mergedMesh.geometry.dispose();
-        mergedMesh.geometry = new THREE.BufferGeometry();
-        mergedMesh.geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+        replaceMeshGeometry(mergedMesh, createEmptyGeometry());
         return;
     }
     // Compute chained transforms for segments
@@ -271,11 +273,8 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         geo.applyMatrix4(_matrix);
         geometries.push(geo);
     }
-    const merged = mergeGeometries(geometries, false);
-    if (merged) {
-        mergedMesh.geometry.dispose();
-        mergedMesh.geometry = merged;
-    }
+    const merged = mergeGeometries(geometries, false) ?? createEmptyGeometry();
+    replaceMeshGeometry(mergedMesh, merged);
     // Dispose individual geometries
     for (const geo of geometries) {
         geo.dispose();
@@ -332,6 +331,312 @@ function rotateXZ(x, z, angle) {
     const sin = Math.sin(angle);
     return [x * cos + z * sin, -x * sin + z * cos];
 }
+function createEmptyGeometry() {
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    return geometry;
+}
+function replaceMeshGeometry(mesh, geometry) {
+    mesh.geometry.dispose();
+    mesh.geometry = geometry;
+}
+function generateStairRailingGeometry(stairNode, segments, transforms) {
+    const railingMode = stairNode.railingMode ?? 'none';
+    if (railingMode === 'none') {
+        return createEmptyGeometry();
+    }
+    const railHeight = Math.max(0.5, stairNode.railingHeight ?? 0.92);
+    const midRailHeight = Math.max(railHeight * 0.45, 0.35);
+    const railRadius = 0.022;
+    const postRadius = 0.018;
+    const inset = 0.06;
+    const landingInset = 0.08;
+    const geometries = [];
+    const segmentRailPaths = buildStairRailPaths(segments, transforms, railingMode, inset, landingInset);
+    for (const segmentRailPath of segmentRailPaths) {
+        for (const sidePath of segmentRailPath.sidePaths) {
+            const points = sidePath.points;
+            if (points.length === 0)
+                continue;
+            geometries.push(...buildBalusterGeometries(points, railHeight, postRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(points, railHeight, railRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(points, midRailHeight, railRadius * 0.8));
+        }
+    }
+    for (let index = 1; index < segmentRailPaths.length; index++) {
+        const previousPath = segmentRailPaths[index - 1];
+        const currentPath = segmentRailPaths[index];
+        if (!(previousPath && currentPath && currentPath.connectFromPrevious))
+            continue;
+        if (previousPath.segment.segmentType === 'landing')
+            continue;
+        for (const sidePath of currentPath.sidePaths) {
+            if (currentPath.segment.segmentType === 'landing')
+                continue;
+            const currentPoint = sidePath.points[0];
+            if (!currentPoint)
+                continue;
+            const previousSidePath = [...previousPath.sidePaths]
+                .map((entry) => ({
+                entry,
+                distance: entry.points.length
+                    ? entry.points[entry.points.length - 1].distanceTo(currentPoint)
+                    : Number.POSITIVE_INFINITY,
+            }))
+                .sort((left, right) => left.distance - right.distance)[0]?.entry;
+            const previousPoint = previousSidePath && previousSidePath.points.length > 0
+                ? previousSidePath.points[previousSidePath.points.length - 1]
+                : null;
+            if (!(previousPoint && currentPoint))
+                continue;
+            const connectorPoints = [previousPoint, currentPoint];
+            geometries.push(...buildOffsetRailSegmentGeometries(connectorPoints, railHeight, railRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(connectorPoints, midRailHeight, railRadius * 0.8));
+        }
+    }
+    const merged = mergeGeometries(geometries, false) ?? createEmptyGeometry();
+    for (const geometry of geometries) {
+        geometry.dispose();
+    }
+    return merged;
+}
+function buildStairRailPaths(segments, transforms, railingMode, inset, landingInset) {
+    const layouts = computeStairRailLayouts(segments, transforms);
+    if (railingMode === 'both') {
+        const isStraightLineDoubleLandingLayout = segments.length === 4 &&
+            segments[0]?.segmentType === 'stair' &&
+            segments[1]?.segmentType === 'landing' &&
+            segments[2]?.segmentType === 'stair' &&
+            segments[2]?.attachmentSide === 'front' &&
+            segments[3]?.segmentType === 'landing' &&
+            segments[3]?.attachmentSide === 'front';
+        return layouts.map((layout, index) => {
+            const segment = layout.segment;
+            const previousSegment = index > 0 ? segments[index - 1] : undefined;
+            const nextSegment = index < segments.length - 1 ? segments[index + 1] : undefined;
+            const hideLandingRailing = segment.segmentType === 'landing' &&
+                previousSegment?.segmentType === 'stair' &&
+                nextSegment?.segmentType === 'stair';
+            const visualTurnSide = nextSegment?.attachmentSide;
+            const sideCandidates = hideLandingRailing
+                ? visualTurnSide === 'left'
+                    ? ['front', 'right']
+                    : visualTurnSide === 'right'
+                        ? ['front', 'left']
+                        : ['left', 'right']
+                : segment.segmentType === 'landing'
+                    ? nextSegment?.segmentType === 'landing' && visualTurnSide === 'left'
+                        ? ['front', 'right']
+                        : nextSegment?.segmentType === 'landing' && visualTurnSide === 'right'
+                            ? ['front', 'left']
+                            : visualTurnSide === 'left'
+                                ? ['right']
+                                : visualTurnSide === 'right'
+                                    ? ['left']
+                                    : ['left', 'right']
+                    : ['left', 'right'];
+            const sidePaths = sideCandidates
+                .map((side) => buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset))
+                .filter((entry) => entry !== null);
+            return {
+                segment,
+                sidePaths: isStraightLineDoubleLandingLayout && index === 1
+                    ? (['left', 'right']
+                        .map((side) => buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset))
+                        .filter((entry) => entry !== null))
+                    : sidePaths,
+                connectFromPrevious: index > 0 &&
+                    !(previousSegment?.segmentType === 'landing' && segment.segmentType === 'landing'),
+            };
+        });
+    }
+    const isStraightLineDoubleLandingLayout = segments.length === 4 &&
+        segments[0]?.segmentType === 'stair' &&
+        segments[1]?.segmentType === 'landing' &&
+        segments[2]?.segmentType === 'stair' &&
+        segments[2]?.attachmentSide === 'front' &&
+        segments[3]?.segmentType === 'landing' &&
+        segments[3]?.attachmentSide === 'front';
+    const resolved = [];
+    layouts.forEach((layout, index) => {
+        const segment = layout.segment;
+        const previousSegment = index > 0 ? segments[index - 1] : undefined;
+        const nextSegment = index < segments.length - 1 ? segments[index + 1] : undefined;
+        const nextAttachmentSide = nextSegment?.attachmentSide;
+        const isMiddleLandingBetweenFlights = segment.segmentType === 'landing' &&
+            previousSegment?.segmentType === 'stair' &&
+            nextSegment?.segmentType === 'stair';
+        const suppressLandingRailing = segment.segmentType === 'landing' &&
+            nextSegment?.segmentType === 'landing' &&
+            nextAttachmentSide === railingMode;
+        const landingContinuesOnPreferredSide = segment.segmentType === 'landing'
+            ? nextAttachmentSide == null ||
+                nextAttachmentSide === 'front' ||
+                nextAttachmentSide === railingMode
+            : true;
+        const sidePaths = suppressLandingRailing
+            ? []
+            : segment.segmentType !== 'landing'
+                ? [
+                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                ]
+                : isStraightLineDoubleLandingLayout
+                    ? [
+                        buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                    ]
+                    : isMiddleLandingBetweenFlights && railingMode === 'left'
+                        ? nextAttachmentSide === 'right'
+                            ? [
+                                buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                buildSegmentRailPath(layout, 'left', previousSegment, nextSegment, inset, landingInset),
+                            ]
+                            : []
+                        : isMiddleLandingBetweenFlights && railingMode === 'right'
+                            ? nextAttachmentSide === 'left'
+                                ? [
+                                    buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                    buildSegmentRailPath(layout, 'right', previousSegment, nextSegment, inset, landingInset),
+                                ]
+                                : []
+                            : nextSegment?.segmentType === 'landing' &&
+                                nextAttachmentSide != null &&
+                                nextAttachmentSide !== 'front' &&
+                                nextAttachmentSide !== railingMode
+                                ? [
+                                    buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                                ]
+                                : [
+                                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                                ];
+        resolved.push({
+            segment,
+            sidePaths: sidePaths.filter((entry) => entry !== null),
+            connectFromPrevious: index > 0 &&
+                !suppressLandingRailing &&
+                sidePaths.length > 0 &&
+                (segment.segmentType === 'landing' ? landingContinuesOnPreferredSide : true),
+        });
+    });
+    return resolved;
+}
+function computeStairRailLayouts(segments, transforms) {
+    return segments.map((segment, index) => {
+        const transform = transforms[index];
+        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
+        return {
+            center: [transform.position[0] + centerOffsetX, transform.position[2] + centerOffsetZ],
+            elevation: transform.position[1],
+            rotation: transform.rotation,
+            segment,
+        };
+    });
+}
+function buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset) {
+    const segment = layout.segment;
+    const segmentSteps = Math.max(1, segment.segmentType === 'landing' ? 1 : segment.stepCount);
+    const segmentStepDepth = segment.length / segmentSteps;
+    const segmentStepHeight = segment.segmentType === 'landing' ? 0 : segment.height / segmentSteps;
+    const segmentTopThickness = getSegmentTopThickness(segment);
+    const flightSideOffset = side === 'left' ? segment.width / 2 - 0.045 : -segment.width / 2 + 0.045;
+    const flightStartX = previousSegment?.segmentType === 'landing' ? -segment.length / 2 + landingInset : -segment.length / 2;
+    const flightEndX = nextSegment?.segmentType === 'landing' ? segment.length / 2 - landingInset : segment.length / 2;
+    if (segment.segmentType === 'landing') {
+        return buildLandingRailPathFromScratch(layout, side, previousSegment, nextSegment, segmentTopThickness, landingInset);
+    }
+    return {
+        side,
+        points: [
+            ...(previousSegment?.segmentType === 'landing'
+                ? []
+                : [
+                    toRailLayoutWorldPoint(layout, flightStartX, segmentTopThickness, flightSideOffset),
+                ]),
+            ...Array.from({ length: segmentSteps }).map((_, index) => toRailLayoutWorldPoint(layout, -segment.length / 2 + segmentStepDepth * index + segmentStepDepth / 2, segmentStepHeight * (index + 1), flightSideOffset)),
+            ...(nextSegment?.segmentType === 'landing'
+                ? []
+                : [
+                    toRailLayoutWorldPoint(layout, flightEndX, segment.height, flightSideOffset),
+                ]),
+        ],
+    };
+}
+function buildLandingRailPathFromScratch(layout, side, previousSegment, nextSegment, topY, inset) {
+    const segment = layout.segment;
+    const backX = -segment.length / 2 + inset;
+    const frontX = segment.length / 2 - inset;
+    const leftZ = segment.width / 2 - inset;
+    const rightZ = -segment.width / 2 + inset;
+    const edgePoints = side === 'left'
+        ? [
+            toRailLayoutWorldPoint(layout, backX, topY, leftZ),
+            toRailLayoutWorldPoint(layout, frontX, topY, leftZ),
+        ]
+        : side === 'right'
+            ? [
+                toRailLayoutWorldPoint(layout, backX, topY, rightZ),
+                toRailLayoutWorldPoint(layout, frontX, topY, rightZ),
+            ]
+            : [
+                // When the next flight turns, rail the visible leading edge nearest the turn opening.
+                toRailLayoutWorldPoint(layout, previousSegment?.segmentType === 'stair' &&
+                    nextSegment?.attachmentSide &&
+                    nextSegment.attachmentSide !== 'front'
+                    ? backX
+                    : frontX, topY, leftZ),
+                toRailLayoutWorldPoint(layout, previousSegment?.segmentType === 'stair' &&
+                    nextSegment?.attachmentSide &&
+                    nextSegment.attachmentSide !== 'front'
+                    ? backX
+                    : frontX, topY, rightZ),
+            ];
+    return {
+        side,
+        points: edgePoints,
+    };
+}
+function toRailLayoutWorldPoint(layout, localX, localY, localZ) {
+    const [offsetX, offsetZ] = rotateXZ(localZ, localX, layout.rotation);
+    return new THREE.Vector3(layout.center[0] + offsetX, layout.elevation + localY, layout.center[1] + offsetZ);
+}
+function buildOffsetRailSegmentGeometries(points, heightOffset, radius) {
+    const geometries = [];
+    for (let index = 0; index < points.length - 1; index++) {
+        const start = points[index];
+        const end = points[index + 1];
+        if (!(start && end))
+            continue;
+        const segmentGeometry = createCylinderBetweenPoints(start.clone().add(new THREE.Vector3(0, heightOffset, 0)), end.clone().add(new THREE.Vector3(0, heightOffset, 0)), radius, 8);
+        if (segmentGeometry) {
+            geometries.push(segmentGeometry);
+        }
+    }
+    return geometries;
+}
+function buildBalusterGeometries(points, height, radius) {
+    const geometries = [];
+    for (const point of points) {
+        const geometry = new THREE.CylinderGeometry(radius, radius, Math.max(height, 0.05), 8);
+        geometry.translate(point.x, point.y + height / 2, point.z);
+        geometries.push(geometry);
+    }
+    return geometries;
+}
+function getSegmentTopThickness(segment) {
+    return Math.max(segment.thickness ?? 0.25, 0.02);
+}
+function createCylinderBetweenPoints(start, end, radius, radialSegments) {
+    const direction = new THREE.Vector3().subVectors(end, start);
+    const length = direction.length();
+    if (length <= 1e-5)
+        return null;
+    const midpoint = new THREE.Vector3().addVectors(start, end).multiplyScalar(0.5);
+    const quaternion = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.clone().normalize());
+    const geometry = new THREE.CylinderGeometry(radius, radius, length, radialSegments);
+    geometry.applyQuaternion(quaternion);
+    geometry.translate(midpoint.x, midpoint.y, midpoint.z);
+    return geometry;
+}
 /**
  * Computes the absolute Y height of a segment by traversing the stair's segment chain.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",