@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/shared/wall-attach-target.js

@@ -120,6 +120,9 @@ export function resolveWallAttachmentAtPlanPoint(wall, planPoint, maxDistance =
         itemRotation: side === 'front' ? 0 : Math.PI,
     };
 }
+export function projectPlanPointToWallLocalX(wall, planPoint) {
+    return resolveWallAttachmentAtPlanPoint(wall, planPoint, Number.POSITIVE_INFINITY)?.localX ?? 0;
+}
 /**
  * Return the closest wall attachment target in plan space, including curved
  * walls. This is deliberately separate from `findClosestWallInPlan`: doors,
@@ -240,7 +243,7 @@ export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, he
         if (childId === ignoreId)
             continue;
         const child = nodes[childId];
-        if (!child)
+        if (!child || child.metadata.isTransient)
             continue;
         let childLeft;
         let childRight;

package/dist/shared/wall-event-from-grid.d.ts

@@ -0,0 +1,5 @@
+import { type AnyNode, type AnyNodeId, type GridEvent, type WallEvent } from '@pascal-app/core';
+import { type Object3D } from 'three';
+/** Canvas surface queries still reach the host when a rendered child consumes mesh events. */
+export declare function wallEventFromGrid(event: GridEvent, activeLevelId: AnyNodeId | null, nodes: Record<AnyNodeId, AnyNode>, objects: ReadonlyMap<string, Object3D>): WallEvent | null;
+//# sourceMappingURL=wall-event-from-grid.d.ts.map

package/dist/shared/wall-event-from-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-event-from-grid.d.ts","sourceRoot":"","sources":["../../src/shared/wall-event-from-grid.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EAEd,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAW,KAAK,QAAQ,EAAW,MAAM,OAAO,CAAA;AAEvD,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,GACrC,SAAS,GAAG,IAAI,CA8BlB"}

package/dist/shared/wall-event-from-grid.js

@@ -0,0 +1,36 @@
+import { isCurvedWall, } from '@pascal-app/core';
+import { Matrix3, Vector3 } from 'three';
+/** Canvas surface queries still reach the host when a rendered child consumes mesh events. */
+export function wallEventFromGrid(event, activeLevelId, nodes, objects) {
+    if (event.surfaceHit?.kind !== 'wall' || !event.surfaceNormal)
+        return null;
+    const wall = nodes[event.surfaceHit.hostId];
+    if (wall?.type !== 'wall' ||
+        wall.visible === false ||
+        wall.metadata.isTransient ||
+        wall.parentId !== activeLevelId ||
+        isCurvedWall(wall))
+        return null;
+    const object = objects.get(wall.id);
+    const frame = event.localFrameId ? objects.get(event.localFrameId) : undefined;
+    if (!object || (event.localFrameId && !frame))
+        return null;
+    object.updateWorldMatrix(true, false);
+    frame?.updateWorldMatrix(true, false);
+    const normal = new Vector3(...event.surfaceNormal);
+    if (frame)
+        normal.applyNormalMatrix(new Matrix3().getNormalMatrix(frame.matrixWorld));
+    normal.applyNormalMatrix(new Matrix3().getNormalMatrix(object.matrixWorld.clone().invert()));
+    if (Math.abs(normal.z) <= 0.7)
+        return null;
+    const position = object.worldToLocal(new Vector3(...event.position));
+    return {
+        node: wall,
+        object,
+        position: event.position,
+        localPosition: position.toArray(),
+        normal: normal.toArray(),
+        nativeEvent: event.nativeEvent,
+        stopPropagation: () => { },
+    };
+}

package/dist/shelf/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAQpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwJ5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AASpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyJ5D,CAAA"}

package/dist/shelf/definition.js

@@ -1,3 +1,4 @@
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
 import { sanitizeShelfDimensions } from './dimensions';
 import { buildShelfFloorplan } from './floorplan';
 import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances';
@@ -173,7 +174,7 @@ export const shelfDefinition = {
             })),
         },
         selectable: { hitVolume: 'bbox' },
-        duplicable: true,
+        duplicable: { subtree: 'with-children' },
         deletable: true,
         paint: shelfPaint,
         slots: (n) => shelfSlots(n),
@@ -230,6 +231,7 @@ export const shelfDefinition = {
         ]);
     },
     floorplan: buildShelfFloorplan,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
     // 2D move handler — Path 1 in `FloorplanRegistryMoveOverlay`. Without
     // this the overlay falls through to Path 2 which stomps the SVG
     // entry's `transform` attribute (set by the floor-plan layer to

package/dist/shelf/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAQzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAmH7F"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAQzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,iBAAiB,CA0H7F"}

package/dist/shelf/floorplan.js

@@ -1,3 +1,4 @@
+import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 import { sanitizeShelfDimensions } from './dimensions';
 // Offsets for the floor-plan selection chrome. Resize chevrons sit a
 // hair off the footprint rim; the rotate-arrow corner sits a bit further
@@ -22,8 +23,14 @@ const ROTATE_ARROW_CORNER_OFFSET = 0.22;
  */
 export function buildShelfFloorplan(node, ctx) {
     const shelf = sanitizeShelfDimensions(node);
-    const [px, , pz] = shelf.position;
-    const ry = shelf.rotation[1] ?? 0;
+    const parent = shelf.parentId ? ctx?.resolve(shelf.parentId) : undefined;
+    const hostedFrame = ctx && parent?.type === 'procedural-item' && parent.attachments[shelf.id] !== undefined
+        ? restingNodePlanFrame(shelf, ctx.resolve)
+        : null;
+    const [px, , pz] = hostedFrame?.position ?? shelf.position;
+    const ry = hostedFrame
+        ? Math.atan2(hostedFrame.axes[2][0], hostedFrame.axes[2][2])
+        : (shelf.rotation[1] ?? 0);
     // Floor-plan plots at `-ry` so SVG's CW-with-y-down `rotate` direction
     // ends up visually matching Three.js Y-rotation (CCW from a top-down
     // view) — same `rotation` value rotates the same way in both views.

package/dist/site/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/site/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AA6HzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCAmSxD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/site/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AA8HzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCA6SxD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/site/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { terrainFieldOf, unionPolygons, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
-import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
+import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, useImmersiveXRPresentation, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import { BufferAttribute, BufferGeometry, Path, Shape, ShapeGeometry } from 'three';
 import { cameraPosition, color, mix, positionWorld, smoothstep, float as tslFloat, vec2, } from 'three/tsl';
@@ -75,6 +75,7 @@ function addSlabHoles(shape, slabPolygons, originX = 0, originZ = 0) {
 }
 export const SiteRenderer = ({ node }) => {
     const ref = useRef(null);
+    const immersiveXR = useImmersiveXRPresentation();
     const atmosphere = useSceneAtmosphere();
     const groundReplaced = useSceneGroundReplacement();
     useRegistry(node.id, 'site', ref);
@@ -290,9 +291,15 @@ export const SiteRenderer = ({ node }) => {
     // inside TerrainRenderer so a stroke that starts on a site with no persisted
     // terrain still mounts the mesh.
     const showTerrain = terrainGrid !== null;
+    // The Site is the one kind whose `visible` flag stops at itself: hiding it
+    // drops the parcel's own presentation — ground fill, sculpted ground, lot
+    // line — while everything standing on the site keeps its own flag (the
+    // exporter and the 2D plan draw the same line). The horizon disc is a world
+    // backdrop rather than part of the parcel, so it stays either way.
+    const showSiteSurfaces = node.visible !== false;
     if (!(node && lineGeometry)) {
         return null;
     }
-    return (_jsxs("group", { ref: ref, ...handlers, children: [(node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showTerrain && _jsx(TerrainRenderer, { material: groundMaterial, site: node }), groundGeometry && !showTerrain && (_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: [0, -0.05, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0] })), horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, HORIZON_PLANE_Y, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], userData: { pascalExport: 'strip' } })), _jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) })] }));
+    return (_jsxs("group", { ref: ref, ...handlers, children: [(node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showSiteSurfaces && showTerrain && _jsx(TerrainRenderer, { material: groundMaterial, site: node }), showSiteSurfaces && groundGeometry && !showTerrain && (_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: [0, -0.05, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0] })), !immersiveXR && horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, HORIZON_PLANE_Y, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], userData: { pascalExport: 'strip' } })), showSiteSurfaces && (_jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) }))] }));
 };
 export default SiteRenderer;

package/dist/skylight/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAoMvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAiFlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAoMvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAkFlE,CAAA"}

package/dist/skylight/definition.js

@@ -226,6 +226,7 @@ export const skylightDefinition = {
     parametrics: skylightParametrics,
     handles: skylightHandles,
     floorplan: buildSkylightFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/slab/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AA4BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AA8BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAyH1D,CAAA"}

package/dist/slab/definition.js

@@ -1,6 +1,7 @@
 import { MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, syncStairRises, } from '@pascal-app/core';
 import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts';
 import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit';
 import { buildSlabFloorplan } from './floorplan';
 import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances';
@@ -201,6 +202,9 @@ export const slabDefinition = {
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'slab',
         },
+        'pascal:editor/floorplan': {
+            selectionCounterparts: sameOutlineSurfaceCounterparts,
+        },
     },
     defaults: () => ({
         object: 'node',

package/dist/solar-panel/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CAyDtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA0DtE,CAAA"}

package/dist/solar-panel/definition.js

@@ -235,6 +235,7 @@ export const solarPanelDefinition = {
     parametrics: solarPanelParametrics,
     handles: solarPanelHandles,
     floorplan: buildSolarPanelFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/spawn/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAuE5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwE5D,CAAA"}

package/dist/spawn/definition.js

@@ -73,6 +73,7 @@ export const spawnDefinition = {
     },
     parametrics: spawnParametrics,
     handles: [spawnRotateHandle(), spawnMoveHandle()],
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/stair/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAQpB,MAAM,kBAAkB,CAAA;AAuZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAgH5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAQpB,MAAM,kBAAkB,CAAA;AAuZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAkH5D,CAAA"}

package/dist/stair/definition.js

@@ -375,6 +375,7 @@ export const stairDefinition = {
         return rest;
     },
     capabilities: {
+        surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
         // A stair has no centred box footprint: straight = a cumulative
         // `stair-segment` chain, curved / spiral = an annular sector. Hand the
@@ -401,6 +402,7 @@ export const stairDefinition = {
     },
     parametrics: stairParametrics,
     handles: stairHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/stair/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/stair/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEvE,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAG5D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/stair/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEvE,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAuK5D,CAAA"}

package/dist/stair/parametrics.js

@@ -1,4 +1,167 @@
 export const stairParametrics = {
-    groups: [],
+    groups: [
+        {
+            label: 'Type',
+            fields: [
+                {
+                    key: 'stairType',
+                    kind: 'enum',
+                    options: ['straight', 'curved', 'spiral'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Opening',
+            fields: [
+                { key: 'fromLevelId', kind: 'ref', label: 'From level', refKind: 'level' },
+                { key: 'toLevelId', kind: 'ref', label: 'To level', refKind: 'level' },
+                {
+                    key: 'slabOpeningMode',
+                    kind: 'enum',
+                    label: 'Auto cutout',
+                    options: ['none', 'destination'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'openingOffset',
+                    kind: 'number',
+                    label: 'Opening offset',
+                    unit: 'm',
+                    min: 0,
+                    max: 0.5,
+                    step: 0.01,
+                    visibleIf: (node) => node.slabOpeningMode === 'destination',
+                },
+            ],
+        },
+        {
+            label: 'Geometry',
+            fields: [
+                {
+                    key: 'width',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.4,
+                    max: 1000,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'stepCount',
+                    kind: 'number',
+                    label: 'Steps',
+                    min: 2,
+                    max: 32,
+                    step: 1,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'fillToFloor',
+                    kind: 'boolean',
+                    label: 'Fill to floor',
+                    visibleIf: (node) => node.stairType === 'curved',
+                },
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.02,
+                    max: 1000,
+                    step: 0.01,
+                    visibleIf: (node) => node.stairType === 'spiral' || !node.fillToFloor,
+                },
+                {
+                    key: 'innerRadius',
+                    kind: 'number',
+                    label: 'Inner radius',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'sweepAngle',
+                    kind: 'number',
+                    label: 'Sweep (rad)',
+                    min: -Math.PI * 4,
+                    max: Math.PI * 4,
+                    step: Math.PI / 180,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'showCenterColumn',
+                    kind: 'boolean',
+                    label: 'Center column',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'showStepSupports',
+                    kind: 'boolean',
+                    label: 'Step supports',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'topLandingMode',
+                    kind: 'enum',
+                    label: 'Top landing',
+                    options: ['none', 'integrated'],
+                    display: 'segmented',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'topLandingDepth',
+                    kind: 'number',
+                    label: 'Landing depth',
+                    unit: 'm',
+                    min: 0.3,
+                    max: 1000,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType === 'spiral' && node.topLandingMode === 'integrated',
+                },
+            ],
+        },
+        {
+            label: 'Position',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                {
+                    key: 'rotation',
+                    kind: 'number',
+                    label: 'Rotation (rad)',
+                    min: -Math.PI,
+                    max: Math.PI,
+                    step: Math.PI / 36,
+                },
+            ],
+        },
+        {
+            label: 'Railing',
+            fields: [
+                {
+                    key: 'railingMode',
+                    kind: 'enum',
+                    options: ['none', 'left', 'right', 'both'],
+                },
+                {
+                    key: 'railingHeight',
+                    kind: 'number',
+                    label: 'Railing height',
+                    unit: 'm',
+                    min: 0.7,
+                    max: 1.4,
+                    step: 0.02,
+                    visibleIf: (node) => node.railingMode !== 'none',
+                },
+            ],
+        },
+    ],
+    derive: (next, patch, previous) => patch.stairType === 'spiral' && previous?.stairType !== 'spiral'
+        ? {
+            position: [next.position[0], 0, next.position[2]],
+            sweepAngle: (400 * Math.PI) / 180,
+        }
+        : {},
     customPanel: () => import('./panel'),
 };

package/dist/stair-segment/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA2F3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAgD1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA2F3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAiD1E,CAAA"}

package/dist/stair-segment/definition.js

@@ -116,6 +116,7 @@ export const stairSegmentDefinition = {
     },
     parametrics: stairSegmentParametrics,
     handles: stairSegmentHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/stair-segment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/stair-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAE9E,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAG1E,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/stair-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAE9E,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAkF1E,CAAA"}

package/dist/stair-segment/parametrics.js

@@ -1,4 +1,84 @@
 export const stairSegmentParametrics = {
-    groups: [],
+    groups: [
+        {
+            label: 'Type',
+            fields: [
+                {
+                    key: 'segmentType',
+                    kind: 'enum',
+                    options: ['stair', 'landing'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'attachmentSide',
+                    kind: 'enum',
+                    label: 'Attachment',
+                    options: ['front', 'left', 'right'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.1 },
+                { key: 'length', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.1 },
+                {
+                    key: 'height',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.5,
+                    max: 1000,
+                    step: 0.1,
+                    visibleIf: (node) => node.segmentType === 'stair',
+                },
+                {
+                    key: 'stepCount',
+                    kind: 'number',
+                    label: 'Steps',
+                    min: 2,
+                    max: 30,
+                    step: 1,
+                    visibleIf: (node) => node.segmentType === 'stair',
+                },
+            ],
+        },
+        {
+            label: 'Structure',
+            fields: [
+                { key: 'fillToFloor', kind: 'boolean', label: 'Fill to floor' },
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.05,
+                    visibleIf: (node) => !node.fillToFloor,
+                },
+            ],
+        },
+        {
+            label: 'Position',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                {
+                    key: 'rotation',
+                    kind: 'number',
+                    label: 'Rotation (rad)',
+                    min: -Math.PI,
+                    max: Math.PI,
+                    step: Math.PI / 36,
+                },
+            ],
+        },
+    ],
+    derive: (_next, patch, previous) => {
+        if (!(patch.segmentType && patch.segmentType !== previous?.segmentType))
+            return {};
+        return patch.segmentType === 'landing'
+            ? { height: 0, length: 1, stepCount: 0 }
+            : { height: 2.5, length: 3, stepCount: 10 };
+    },
     customPanel: () => import('./panel'),
 };

package/dist/turbine-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoD1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA2DxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoD1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4DxE,CAAA"}

package/dist/turbine-vent/definition.js

@@ -96,6 +96,7 @@ export const turbineVentDefinition = {
     parametrics: turbineVentParametrics,
     handles: turbineVentHandles,
     floorplan: buildTurbineVentFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/wall/actions.d.ts

@@ -0,0 +1,3 @@
+/** The wall's action-menu contributions: Split (one wall) and Merge (several). */
+export default function WallActions(): import("react").JSX.Element;
+//# sourceMappingURL=actions.d.ts.map

package/dist/wall/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/wall/actions.tsx"],"names":[],"mappings":"AAgBA,kFAAkF;AAClF,MAAM,CAAC,OAAO,UAAU,WAAW,gCAOlC"}

package/dist/wall/actions.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { planWallMerge, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+import { Tooltip, TooltipContent, TooltipTrigger, triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { FoldHorizontal, Scissors } from 'lucide-react';
+import { useMemo } from 'react';
+import { openWallSplit } from './split-session';
+const BUTTON = 'tooltip-trigger rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground disabled:pointer-events-none disabled:opacity-50';
+/** The wall's action-menu contributions: Split (one wall) and Merge (several). */
+export default function WallActions() {
+    return (_jsxs(_Fragment, { children: [_jsx(SplitWallAction, {}), _jsx(MergeWallsAction, {})] }));
+}
+function SplitWallAction() {
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const wall = useScene((s) => selected.length === 1 ? s.nodes[selected[0]] : undefined);
+    const readOnly = useScene((s) => s.readOnly);
+    if (wall?.type !== 'wall')
+        return null;
+    return (_jsx("button", { type: "button", "aria-label": "Split wall", title: "Split wall", disabled: readOnly, className: BUTTON, onClick: (event) => {
+            event.stopPropagation();
+            openWallSplit(wall);
+        }, children: _jsx(Scissors, { className: "size-4" }) }));
+}
+/** Joins selected walls that continue each other into one — the inverse of Split. */
+function MergeWallsAction() {
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const nodes = useScene((s) => s.nodes);
+    const readOnly = useScene((s) => s.readOnly);
+    // null: not a wall selection (render nothing); otherwise why it can't merge, or null.
+    const merge = useMemo(() => {
+        if (selected.length < 2 || selected.some((id) => nodes[id]?.type !== 'wall'))
+            return null;
+        try {
+            planWallMerge(nodes, selected);
+            return { reason: null };
+        }
+        catch (error) {
+            return { reason: error instanceof Error ? error.message : 'These walls cannot be merged.' };
+        }
+    }, [nodes, selected]);
+    if (!merge)
+        return null;
+    const { reason } = merge;
+    const button = (_jsx("button", { type: "button", "aria-label": "Merge walls", title: reason ? undefined : 'Merge walls', disabled: readOnly || reason !== null, className: BUTTON, onClick: (event) => {
+            event.stopPropagation();
+            const plan = planWallMerge(useScene.getState().nodes, selected);
+            runAsSingleSceneHistoryStep(useScene, () => useScene.getState().applyNodeChanges(plan.changes));
+            useViewer.getState().setSelection({ selectedIds: [plan.wallId] });
+            triggerSFX('sfx:structure-build');
+        }, children: _jsx(FoldHorizontal, { className: "size-4" }) }));
+    if (!reason)
+        return button;
+    // A disabled button gets no hover events, so the reason hangs off a wrapper.
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx("span", { className: "inline-flex", children: button }) }), _jsx(TooltipContent, { side: "top", children: reason })] }));
+}

package/dist/wall/curtain-opening-frame.d.ts

@@ -0,0 +1,14 @@
+import { type DoorNode, type WallNode, type WindowNode } from '@pascal-app/core';
+import { type BufferGeometry, Vector2 } from 'three';
+export declare function mapCurtainOpeningGeometryToWall(geometry: BufferGeometry, wall: WallNode): void;
+export declare function curtainOpeningProfile(opening: DoorNode | WindowNode, width: number): {
+    inner: Vector2[];
+    outer: Vector2[];
+};
+export declare function buildCurtainOpeningFrame(opening: DoorNode | WindowNode, width: number, depth: number): {
+    frame: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+    cutter: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+    cutout: Vector2[];
+};
+export declare function curtainProfileSpan(points: readonly Vector2[], height: number): [number, number] | null;
+//# sourceMappingURL=curtain-opening-frame.d.ts.map

package/dist/wall/curtain-opening-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-opening-frame.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-opening-frame.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,QAAQ,EACb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,cAAc,EAAgC,OAAO,EAAE,MAAM,OAAO,CAAA;AAElF,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,QAsBvF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAAE,KAAK,EAAE,MAAM;;;EAqClF;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM;;;;EA+Bd;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CASzB"}