@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/elevator/renderer.js

@@ -1,12 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { getElevatorCabDepth, getElevatorCabWidth, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, getResolvedElevatorDoorPanelStyle as getResolvedDoorPanelStyle, getResolvedElevatorDoorStyle as getResolvedDoorStyle, getResolvedElevatorShaftStyle as getResolvedShaftStyle, resolveElevatorLevels, useInteractive, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
-import { createDefaultMaterial, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { ELEVATOR_CAB_SLOT_DEFAULT, ELEVATOR_DOORS_SLOT_DEFAULT, ELEVATOR_GLASS_SLOT_DEFAULT, ELEVATOR_SHAFT_SLOT_DEFAULT, getElevatorCabDepth, getElevatorCabWidth, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, getResolvedElevatorDoorPanelStyle as getResolvedDoorPanelStyle, getResolvedElevatorDoorStyle as getResolvedDoorStyle, getResolvedElevatorShaftStyle as getResolvedShaftStyle, resolveElevatorLevels, useInteractive, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { createDefaultMaterial, createSurfaceRoleMaterial, materialCastsShadow, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
 import { createContext, useCallback, useContext, useLayoutEffect, useMemo, useRef } from 'react';
 import { BoxGeometry, CylinderGeometry, Object3D, TorusGeometry, } from 'three';
 import { useShallow } from 'zustand/react/shallow';
-import { ELEVATOR_CAB_SLOT_DEFAULT, ELEVATOR_DOORS_SLOT_DEFAULT, ELEVATOR_GLASS_SLOT_DEFAULT, ELEVATOR_SHAFT_SLOT_DEFAULT, } from './slots';
 const DEFAULT_STRUCTURE_WHITE = '#f2f0ed';
 const SHAFT_WALL_COLOR = DEFAULT_STRUCTURE_WHITE;
 const SHAFT_SIDE_COLOR = DEFAULT_STRUCTURE_WHITE;
@@ -284,7 +283,7 @@ const SEGMENT_PROPS = {
     upperRight: { position: [0.32, 0.22, 0], size: [0.11, 0.42, 0.018] },
 };
 function BoxPrimitive({ castShadow = false, material, position, receiveShadow = false, rotation, scale, slotId, }) {
-    return (_jsx("mesh", { castShadow: castShadow, dispose: null, geometry: UNIT_BOX_GEOMETRY, material: material, position: position, receiveShadow: receiveShadow, rotation: rotation, scale: scale, userData: slotId ? ELEVATOR_SLOT_USER_DATA[slotId] : undefined }));
+    return (_jsx("mesh", { castShadow: castShadow && materialCastsShadow(material), dispose: null, geometry: UNIT_BOX_GEOMETRY, material: material, position: position, receiveShadow: receiveShadow, rotation: rotation, scale: scale, userData: slotId ? ELEVATOR_SLOT_USER_DATA[slotId] : undefined }));
 }
 function MeshButtonLabel({ faceSign = 1, label, material, position, scale, }) {
     const ref = useRef(null);

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA+DxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4DxE,CAAA"}

package/dist/eyebrow-vent/definition.js

@@ -1,4 +1,4 @@
-import { EyebrowVentNode as EyebrowVentNodeSchema, } from '@pascal-app/core';
+import { EyebrowVentNode as EyebrowVentNodeSchema, eyebrowVentSlots, } from '@pascal-app/core';
 import { buildEyebrowVentFloorplan } from './floorplan';
 import { eyebrowVentPaint } from './paint';
 import { eyebrowVentParametrics } from './parametrics';
@@ -111,10 +111,7 @@ export const eyebrowVentDefinition = {
         return rest;
     },
     capabilities: {
-        slots: () => [
-            { slotId: 'hood', label: 'Hood', default: 'library:preset-softwhite' },
-            { slotId: 'front', label: 'Louvers', default: 'library:preset-softwhite' },
-        ],
+        slots: eyebrowVentSlots,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,

package/dist/eyebrow-vent/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,uBAAuB,EAAkB,MAAM,kBAAkB,CAAA;AAOxF,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,uBAAuB,CAEzB;AAED,eAAO,MAAM,gBAAgB,4CA0B3B,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,uBAAuB,EAAkB,MAAM,kBAAkB,CAAA;AAQxF,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,uBAAuB,CAEzB;AAED,eAAO,MAAM,gBAAgB,4CAsB3B,CAAA"}

package/dist/eyebrow-vent/paint.js

@@ -1,4 +1,5 @@
 import { buildSlotPreviewMaterial, createSlotPaintCapability } from '../shared/slot-paint';
+import { swapPreviewMaterial } from '../shared/swap-preview-material';
 import { EYEBROW_VENT_MATERIAL_INDEX } from './geometry';
 export function resolveEyebrowVentMaterialRole(materialIndex) {
     return materialIndex === EYEBROW_VENT_MATERIAL_INDEX.front ? 'front' : 'hood';
@@ -16,13 +17,9 @@ export const eyebrowVentPaint = createSlotPaintCapability({
             const mesh = object;
             if (!mesh.isMesh || mesh.name !== 'eyebrow-vent-surface' || !Array.isArray(mesh.material))
                 return;
-            const previous = [...mesh.material];
-            const next = [...previous];
+            const next = [...mesh.material];
             next[materialIndex] = preview;
-            mesh.material = next;
-            restore = () => {
-                mesh.material = previous;
-            };
+            restore = swapPreviewMaterial(mesh, next);
         });
         return restore;
     },

package/dist/eyebrow-vent/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAmRvC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCA+PvC"}

package/dist/eyebrow-vent/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { EyebrowVentNode as EyebrowVentSchema, getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
@@ -52,27 +52,9 @@ export default function EyebrowVentPanel() {
         setSelection({ selectedIds: [] });
     }, [node, setMovingNode, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        const parentId = node.roofSegmentId;
-        if (!parentId)
-            return;
-        const state = useScene.getState();
-        const meta = typeof node.metadata === 'object' && node.metadata !== null
-            ? node.metadata
-            : {};
-        const cloneInput = {
-            ...node,
-            id: undefined,
-            metadata: { ...meta, isNew: true },
-        };
-        const cloned = EyebrowVentSchema.parse(cloneInput);
-        state.createNode(cloned, parentId);
-        state.dirtyNodes.add(parentId);
-        setMovingNode(cloned);
-        setSelection({ selectedIds: [] });
-    }, [node, setMovingNode, setSelection]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleDelete = useCallback(() => {
         if (!(selectedId && node))
             return;

package/dist/fence/actions/move-endpoint.d.ts

@@ -1,5 +1,5 @@
 import { type AlignmentAnchor, type AnyNodeId, type DragAction, type FenceNode, type WallNode } from '@pascal-app/core';
-import { type FencePlanPoint } from '@pascal-app/editor';
+import { type FencePlanPoint } from '../drafting';
 type LinkedFenceSnapshot = {
     id: FenceNode['id'];
     start: FencePlanPoint;

package/dist/fence/actions/move-endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/fence/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,SAAS,EAId,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAOpB,MAAM,oBAAoB,CAAA;AA2C3B,KAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,aAAa,EAAE,cAAc,CAAA;IAC7B,WAAW,EAAE,cAAc,CAAA;IAC3B,mBAAmB,EAAE,cAAc,CAAA;IACnC,UAAU,EAAE,cAAc,CAAA;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,eAAe,EAAE,mBAAmB,EAAE,CAAA;IACtC,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB;4DACwD;IACxD,eAAe,EAAE,eAAe,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,cAAc,CAAA;IAC3B,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,mBAAmB,EAAE,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAuDD,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,oBAAoB,EAAE,sBAAsB,CA6J9F,CAAA"}
+{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/fence/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,SAAS,EAId,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAAE,KAAK,cAAc,EAAuB,MAAM,aAAa,CAAA;AA2CtE,KAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,aAAa,EAAE,cAAc,CAAA;IAC7B,WAAW,EAAE,cAAc,CAAA;IAC3B,mBAAmB,EAAE,cAAc,CAAA;IACnC,UAAU,EAAE,cAAc,CAAA;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,eAAe,EAAE,mBAAmB,EAAE,CAAA;IACtC,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB;4DACwD;IACxD,eAAe,EAAE,eAAe,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,cAAc,CAAA;IAC3B,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,mBAAmB,EAAE,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAuDD,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,oBAAoB,EAAE,sBAAsB,CA6J9F,CAAA"}

package/dist/fence/actions/move-endpoint.js

@@ -1,5 +1,6 @@
 import { collectAlignmentAnchors, resolveAlignment, resolveFenceSupportSlabPatch, useScene, } from '@pascal-app/core';
-import { isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapFenceDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+import { isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, useAlignmentGuides, } from '@pascal-app/editor';
+import { snapFenceDraftPoint } from '../drafting';
 /**
  * Phase 5 Stage D — move-fence-endpoint drag affordance.
  *

package/dist/fence/definition.d.ts

@@ -1,5 +1,6 @@
-import { type NodeDefinition } from '@pascal-app/core';
+import { type FenceNode as FenceNodeType, type NodeDefinition, type SceneApi } from '@pascal-app/core';
 import { FenceNode } from './schema';
+export declare function fenceBaseElevation(n: FenceNodeType, sceneApi?: SceneApi, point?: readonly [number, number]): number;
 /**
  * Fence — Phase 5 batch kind. Stage B complete: `def.geometry` drives
  * the rebuild via the generic `<GeometrySystem>`; `<ParametricNodeRenderer>`

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA2H5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,IAAI,aAAa,EAS/B,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AASpC,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,aAAa,EAChB,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,GAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAW,GACzC,MAAM,CA+BR;AA4OD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAkJ5D,CAAA"}

package/dist/fence/definition.js

@@ -1,25 +1,43 @@
-import { getFenceControlHandle, isSplineFence, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { fenceSlots, findLevelAncestorId, floorConstructionLift, getFenceControlHandle, getFenceSpanMode, isSplineFence, levelBaseElevationAt, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, REGISTERED_DRAFT_SNAP_EXTENSION, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { createNodeTopSurfaceHeightSampler, createSceneSupportHeightSampler, } from '@pascal-app/viewer';
+import { snapFenceDraftPoint } from './drafting';
 import { buildFenceFloorplan } from './floorplan';
 import { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, fenceThicknessAffordance, } from './floorplan-affordances';
 import { fenceFloorplanMoveTarget } from './floorplan-move';
 import { buildFenceGeometry } from './geometry';
 import { resolveFenceLiftElevation, resolveFenceLiftElevationForNodes } from './lift';
 import { fencePaint } from './paint';
+import { fencePanelModel } from './panel-model';
 import { fenceParametrics } from './parametrics';
 import { FenceNode } from './schema';
-import { fenceSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.27;
 const SIDE_HANDLE_MIN_OFFSET = 0.33;
 const SIDE_HANDLE_TOP_INSET = 0.08;
 const SIDE_HANDLE_MIN_HEIGHT = 0.4;
 const HEIGHT_HANDLE_OFFSET = 0.45;
 const MIN_FENCE_HEIGHT = 0.3;
-function fenceBaseElevation(n, sceneApi) {
+export function fenceBaseElevation(n, sceneApi, point = n.start) {
     const nodes = sceneApi?.nodes();
-    return nodes
-        ? resolveFenceLiftElevationForNodes(n, nodes)
-        : resolveFenceLiftElevation(n, () => undefined);
+    if (!nodes)
+        return resolveFenceLiftElevation(n, () => undefined);
+    if (n.supportSlabId)
+        return resolveFenceLiftElevationForNodes(n, nodes);
+    const levelId = findLevelAncestorId(n.id, nodes);
+    if (levelId && ((n.path?.length ?? 0) >= 2 || Math.abs(n.curveOffset ?? 0) > 1e-4)) {
+        const selectedHost = n.surfaceMode === 'selected'
+            ? (n.supportSurfaceNodeId ?? n.supportSlabId)
+            : undefined;
+        const samplePoint = n.surfaceMode === 'level' ? n.start : point;
+        return (Math.max(createSceneSupportHeightSampler(nodes, levelId, selectedHost)(samplePoint[0], samplePoint[1]), levelBaseElevationAt(nodes, levelId, samplePoint[0], samplePoint[1]) +
+            floorConstructionLift(nodes, n)) + (n.supportOffset ?? 0));
+    }
+    if (n.supportSurfaceNodeId && levelId) {
+        const height = createNodeTopSurfaceHeightSampler(n.supportSurfaceNodeId, levelId)?.(point[0], point[1]);
+        if (height !== null && height !== undefined)
+            return height + (n.supportOffset ?? 0);
+    }
+    return resolveFenceLiftElevationForNodes(n, nodes);
 }
 function fenceMidpointFrame(n) {
     const dx = n.end[0] - n.start[0];
@@ -54,7 +72,7 @@ function fenceSideMoveHandle(side) {
                 const { midX, midZ, normalX, normalZ } = fenceMidpointFrame(n);
                 const offset = Math.max((n.thickness ?? 0.1) / 2 + SIDE_HANDLE_OFFSET, SIDE_HANDLE_MIN_OFFSET);
                 const h = n.height ?? 1.8;
-                const handleY = fenceBaseElevation(n, sceneApi) +
+                const handleY = fenceBaseElevation(n, sceneApi, [midX, midZ]) +
                     Math.max(h - SIDE_HANDLE_TOP_INSET, SIDE_HANDLE_MIN_HEIGHT);
                 return [midX + sign * normalX * offset, handleY, midZ + sign * normalZ * offset];
             },
@@ -90,7 +108,7 @@ function fenceHeightHandle() {
                 const { midX, midZ } = fenceMidpointFrame(n);
                 return [
                     midX,
-                    fenceBaseElevation(n, sceneApi) + (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET,
+                    fenceBaseElevation(n, sceneApi, [midX, midZ]) + (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET,
                     midZ,
                 ];
             },
@@ -117,7 +135,11 @@ function fenceElevationHandle(currentBase) {
             // including the ground, so dragging a fence's base to an absolute height
             // on a hillside stores the delta from that hillside and the fence keeps
             // following it.
-            const supportBase = resolveFenceLiftElevationForNodes({ ...initial, supportOffset: undefined }, sceneApi.nodes());
+            const { midX, midZ } = fenceMidpointFrame(initial);
+            const supportBase = fenceBaseElevation({ ...initial, supportOffset: undefined }, sceneApi, [
+                midX,
+                midZ,
+            ]);
             const nextOffset = newBase - supportBase;
             return {
                 supportOffset: Math.abs(nextOffset) < 1e-6 ? undefined : nextOffset,
@@ -126,7 +148,7 @@ function fenceElevationHandle(currentBase) {
         placement: {
             position: (n, sceneApi) => {
                 const { midX, midZ } = fenceMidpointFrame(n);
-                return [midX, fenceBaseElevation(n, sceneApi), midZ];
+                return [midX, fenceBaseElevation(n, sceneApi, [midX, midZ]), midZ];
             },
         },
     };
@@ -145,7 +167,7 @@ function fenceCornerPicker(endpoint) {
         placement: {
             position: (n, sceneApi) => {
                 const corner = endpoint === 'start' ? n.start : n.end;
-                return [corner[0], fenceBaseElevation(n, sceneApi), corner[1]];
+                return [corner[0], fenceBaseElevation(n, sceneApi, corner), corner[1]];
             },
         },
     };
@@ -161,7 +183,7 @@ function fenceControlPointPicker(index) {
         placement: {
             position: (n, sceneApi) => {
                 const point = n.path?.[index] ?? n.start;
-                return [point[0], fenceBaseElevation(n, sceneApi), point[1]];
+                return [point[0], fenceBaseElevation(n, sceneApi, point), point[1]];
             },
         },
     };
@@ -178,7 +200,7 @@ function fenceTangentPicker(index, side) {
         placement: {
             position: (n, sceneApi) => {
                 const point = n.path?.[index] ?? n.start;
-                const baseElevation = fenceBaseElevation(n, sceneApi);
+                const baseElevation = fenceBaseElevation(n, sceneApi, point);
                 if (!n.path)
                     return [point[0], baseElevation, point[1]];
                 const handle = getFenceControlHandle(n.path, n.tangents, index);
@@ -192,16 +214,26 @@ function fenceTangentPicker(index, side) {
     };
 }
 const fenceHandles = (node, sceneApi) => {
-    const elevationHandle = fenceElevationHandle(fenceBaseElevation(node, sceneApi));
+    const { midX, midZ } = fenceMidpointFrame(node);
+    const elevationHandle = fenceElevationHandle(fenceBaseElevation(node, sceneApi, [midX, midZ]));
     if (isSplineFence(node) && node.path) {
         return [
             elevationHandle,
             fenceHeightHandle(),
-            ...node.path.flatMap((_, index) => [
-                fenceControlPointPicker(index),
-                fenceTangentPicker(index, 'out'),
-                fenceTangentPicker(index, 'in'),
-            ]),
+            ...node.path.flatMap((_, index) => {
+                const path = node.path;
+                return [
+                    fenceControlPointPicker(index),
+                    ...(index < path.length - 1 &&
+                        getFenceSpanMode(path, node.tangents, node.spanModes, index) === 'curve'
+                        ? [fenceTangentPicker(index, 'out')]
+                        : []),
+                    ...(index > 0 &&
+                        getFenceSpanMode(path, node.tangents, node.spanModes, index - 1) === 'curve'
+                        ? [fenceTangentPicker(index, 'in')]
+                        : []),
+                ];
+            }),
         ];
     }
     return [
@@ -229,8 +261,12 @@ const fenceHandles = (node, sceneApi) => {
 export const fenceDefinition = {
     kind: 'fence',
     snapProfile: 'structural',
-    schemaVersion: 2,
+    schemaVersion: 3,
     schema: FenceNode,
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: fencePanelModel,
+        [REGISTERED_DRAFT_SNAP_EXTENSION]: snapFenceDraftPoint,
+    },
     category: 'structure',
     surfaceRole: 'wall',
     defaults: () => ({
@@ -243,22 +279,39 @@ export const fenceDefinition = {
         height: 1.8,
         thickness: 0.08,
         baseHeight: 0.22,
-        postSpacing: 2,
-        postSize: 0.1,
+        postSpacing: 1.98,
+        picketSpacing: 0.27,
+        patternDistribution: 'automatic',
+        patternAlignment: 'center',
+        patternCount: 4,
+        patternRemainder: 'leave',
+        picketWidth: 0.07,
+        picketTop: 'flat',
+        picketRailCount: 2,
+        picketProfile: 'level',
+        picketTopClearance: 0.2,
+        picketVariation: 0.23,
+        picketRailProjection: 0.001,
+        postSize: 0.109,
         topRailHeight: 0.04,
-        groundClearance: 0,
+        groundClearance: 0.14,
         edgeInset: 0.015,
         slatGap: 0.01,
         postCap: 'pyramid',
-        baseStyle: 'grounded',
+        baseStyle: 'floating',
+        surfaceMode: 'auto',
+        transitionMode: 'slope',
+        transitionWidth: 0.8,
         showInfill: true,
+        infillPlacement: 'center',
         color: '#ffffff',
-        style: 'slat',
+        style: 'picket',
+        children: [],
     }),
     capabilities: {
         surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
-        surfaces: { sides: { faces: 'all' } },
+        surfaces: { sides: { faces: 'all' }, hosting: false },
         duplicable: true,
         deletable: true,
         slots: (node) => fenceSlots(node),
@@ -270,7 +323,7 @@ export const fenceDefinition = {
     },
     relations: {
         linkedBy: 'endpoint-match',
-        cascadeDelete: 'none',
+        cascadeDelete: 'descendants',
     },
     parametrics: fenceParametrics,
     handles: fenceHandles,
@@ -283,6 +336,8 @@ export const fenceDefinition = {
     // Stage B: pure geometry function. Generic <GeometrySystem> rebuilds
     // on dirtyNodes; <ParametricNodeRenderer> mounts the empty group.
     geometry: buildFenceGeometry,
+    geometryChildTypes: ['fence-gate', 'fence-opening'],
+    floorplanDependencies: (node) => (node.children ?? []),
     // Dependency tracker only — a hosted railing (`supportSlabId`) renders at
     // its slab's elevation, so host elevation edits must re-dirty the fence.
     system: {

package/dist/fence/drafting.d.ts

@@ -0,0 +1,36 @@
+import { type AnyNodeId, type FenceConstructionOptions as FenceCommitOptions, FenceNode, type SceneApi, type WallNode } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+export type FencePlanPoint = WallPlanPoint;
+export type FenceDraftContext = {
+    sceneApi: SceneApi;
+    levelId: AnyNodeId | null;
+};
+export declare function getFenceInheritedDefaults(start: FencePlanPoint, context: FenceDraftContext, currentNodes?: ReturnType<SceneApi['nodes']>): Partial<FenceNode> | null;
+export declare function snapFenceDraftPoint(args: {
+    point: FencePlanPoint;
+    walls: WallNode[];
+    fences: FenceNode[];
+    start?: FencePlanPoint;
+    angleSnap?: boolean;
+    ignoreFenceIds?: string[];
+    bypassSnap?: boolean;
+    magnetic?: boolean;
+    /** Override the grid step. */
+    step?: number;
+    /**
+     * Optional grid-snap function. When provided, replaces the default
+     * local-axis snap — lets the 2D floor-plan keep snapping to the
+     * world XZ grid even when the building is rotated. Wall / fence
+     * endpoint snap precedence is preserved.
+     */
+    gridSnap?: (point: FencePlanPoint) => FencePlanPoint;
+}): FencePlanPoint;
+export declare function createFenceOnCurrentLevel(start: FencePlanPoint, end: FencePlanPoint, options: FenceCommitOptions | undefined, context: FenceDraftContext): FenceNode | null;
+/**
+ * Commit a smooth spline fence from a list of drawn control points. The
+ * centerline becomes a Catmull-Rom curve through `path`; `start`/`end` are
+ * pinned to the first/last point so endpoint handles, bbox, and miter
+ * references stay valid. Requires >= 2 points spanning a usable distance.
+ */
+export declare function createSplineFenceOnCurrentLevel(path: FencePlanPoint[], tangents: FenceNode['tangents'] | undefined, context: FenceDraftContext): FenceNode | null;
+//# sourceMappingURL=drafting.d.ts.map

package/dist/fence/drafting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafting.d.ts","sourceRoot":"","sources":["../../src/fence/drafting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,wBAAwB,IAAI,kBAAkB,EACnD,SAAS,EAIT,KAAK,QAAQ,EAGb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAE3B,MAAM,MAAM,cAAc,GAAG,aAAa,CAAA;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;CAC1B,CAAA;AAuCD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,iBAAiB,EAC1B,YAAY,GAAE,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA4B,GACrE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAiB3B;AA2FD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,EAAE,cAAc,CAAA;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,cAAc,CAAA;CACrD,GAAG,cAAc,CA0CjB;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,kBAAkB,GAAG,SAAS,EACvC,OAAO,EAAE,iBAAiB,GACzB,SAAS,GAAG,IAAI,CA8BlB;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,cAAc,EAAE,EACtB,QAAQ,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,SAAS,EAC3C,OAAO,EAAE,iBAAiB,GACzB,SAAS,GAAG,IAAI,CAkClB"}

package/dist/fence/drafting.js

@@ -0,0 +1,210 @@
+import { DEFAULT_ANGLE_STEP, FenceNode, getFenceCenterlineLength, getFenceSplineLength, resolveFenceConstructionSupport, sampleFenceCenterline, snapPointAlongAngleRay, } from '@pascal-app/core';
+import { findWallSnapTarget, getSegmentGridStep, isSegmentLongEnough, snapPointToGrid, triggerSFX, useEditor, } from '@pascal-app/editor';
+const INHERITED_FENCE_FIELDS = [
+    'height',
+    'thickness',
+    'material',
+    'materialPreset',
+    'slots',
+    'baseHeight',
+    'postSpacing',
+    'picketSpacing',
+    'patternDistribution',
+    'patternAlignment',
+    'patternCount',
+    'patternRemainder',
+    'picketWidth',
+    'picketTop',
+    'picketRailCount',
+    'picketProfile',
+    'picketTopClearance',
+    'picketVariation',
+    'picketRailProjection',
+    'postSize',
+    'topRailHeight',
+    'groundClearance',
+    'edgeInset',
+    'slatGap',
+    'postCap',
+    'baseStyle',
+    'surfaceMode',
+    'supportOffset',
+    'transitionMode',
+    'transitionWidth',
+    'showInfill',
+    'infillPlacement',
+    'color',
+    'style',
+];
+export function getFenceInheritedDefaults(start, context, currentNodes = context.sceneApi.nodes()) {
+    const { levelId } = context;
+    if (!levelId)
+        return null;
+    const nodes = currentNodes;
+    const source = Object.values(nodes).find((node) => node.type === 'fence' &&
+        node.parentId === levelId &&
+        node.visible !== false &&
+        [node.start, node.end].some((point) => distanceSquared(start, point) < 0.001 ** 2));
+    if (!source)
+        return null;
+    const defaults = {};
+    for (const field of INHERITED_FENCE_FIELDS) {
+        if (source[field] !== undefined)
+            defaults[field] = source[field];
+    }
+    return defaults;
+}
+const FENCE_CORNER_SNAP_RADIUS = 0.28;
+const FENCE_SPAN_SNAP_RADIUS = 0.16;
+function distanceSquared(a, b) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz;
+}
+function projectPointOntoSegment(point, segment) {
+    const [x1, z1] = segment.start;
+    const [x2, z2] = segment.end;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared < 1e-9) {
+        return null;
+    }
+    const t = Math.max(0, Math.min(1, ((point[0] - x1) * dx + (point[1] - z1) * dz) / lengthSquared));
+    return [x1 + dx * t, z1 + dz * t];
+}
+function findFenceSnapTarget(point, fences, ignoreFenceIds = []) {
+    const cornerRadiusSquared = FENCE_CORNER_SNAP_RADIUS ** 2;
+    const spanRadiusSquared = FENCE_SPAN_SNAP_RADIUS ** 2;
+    const ignoredFenceIds = new Set(ignoreFenceIds);
+    let bestCornerTarget = null;
+    let bestCornerDistanceSquared = Number.POSITIVE_INFINITY;
+    let bestSpanTarget = null;
+    let bestSpanDistanceSquared = Number.POSITIVE_INFINITY;
+    for (const fence of fences) {
+        if (ignoredFenceIds.has(fence.id)) {
+            continue;
+        }
+        for (const candidate of [fence.start, fence.end]) {
+            const candidateDistanceSquared = distanceSquared(point, candidate);
+            if (candidateDistanceSquared > cornerRadiusSquared ||
+                candidateDistanceSquared >= bestCornerDistanceSquared) {
+                continue;
+            }
+            bestCornerTarget = candidate;
+            bestCornerDistanceSquared = candidateDistanceSquared;
+        }
+        const samples = sampleFenceCenterline(fence, Math.max(32, Math.ceil(getFenceCenterlineLength(fence) / 0.1)));
+        for (let index = 1; index < samples.length; index += 1) {
+            const a = samples[index - 1];
+            const b = samples[index];
+            const candidate = projectPointOntoSegment(point, {
+                start: [a.x, a.y],
+                end: [b.x, b.y],
+            });
+            if (!candidate)
+                continue;
+            const candidateDistanceSquared = distanceSquared(point, candidate);
+            if (candidateDistanceSquared > spanRadiusSquared ||
+                candidateDistanceSquared >= bestSpanDistanceSquared)
+                continue;
+            bestSpanTarget = candidate;
+            bestSpanDistanceSquared = candidateDistanceSquared;
+        }
+    }
+    return bestCornerTarget ?? bestSpanTarget;
+}
+export function snapFenceDraftPoint(args) {
+    if (useEditor.getState().toolDefaults.fence?.featurePlacement)
+        return args.point;
+    const { point, walls, fences, start, angleSnap = false, ignoreFenceIds, bypassSnap = false, magnetic = true, step, gridSnap, } = args;
+    if (bypassSnap)
+        return point;
+    const gridStep = step ?? getSegmentGridStep();
+    // Magnetic endpoint snap must beat the angle lock, and the lock can pull
+    // the cursor far enough off an endpoint that probing the locked point
+    // would never engage — so under the lock, probe from the RAW cursor
+    // first (mirrors `snapWallDraftPointDetailed`'s special-point pre-pass).
+    if (start && angleSnap) {
+        const rawTarget = magnetic &&
+            (findFenceSnapTarget(point, fences, ignoreFenceIds) ?? findWallSnapTarget(point, walls));
+        if (rawTarget)
+            return rawTarget;
+    }
+    // The angle path snaps the distance ALONG the 15° ray — a scalar, the
+    // same in world and local frames — so the `gridSnap` world-grid override
+    // only applies when the angle lock is off.
+    const basePoint = start && angleSnap
+        ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, gridStep)]
+        : gridSnap
+            ? gridSnap(point)
+            : snapPointToGrid(point, gridStep);
+    if (!magnetic)
+        return basePoint;
+    const fenceSnapTarget = findFenceSnapTarget(basePoint, fences, ignoreFenceIds);
+    return fenceSnapTarget ?? findWallSnapTarget(basePoint, walls) ?? basePoint;
+}
+export function createFenceOnCurrentLevel(start, end, options, context) {
+    const { sceneApi, levelId: currentLevelId } = context;
+    const nodes = sceneApi.nodes();
+    if (!(currentLevelId && isSegmentLongEnough(start, end))) {
+        return null;
+    }
+    const fenceCount = Object.values(nodes).filter((node) => node.type === 'fence').length;
+    // Build parameters seeded by a placed preset (height, style, post
+    // spacing, …) merge in first; `name`/`start`/`end` always win. The
+    // schema parse validates and drops anything unexpected.
+    const defaults = {
+        ...useEditor.getState().toolDefaults.fence,
+        ...getFenceInheritedDefaults(start, context),
+    };
+    const authoredFence = FenceNode.parse({
+        ...defaults,
+        name: `Fence ${fenceCount + 1}`,
+        start,
+        end,
+    });
+    // Fences run no per-frame support election — the persisted host IS the
+    // lift (absent = level floor), so elect it at commit, pointer-capped.
+    const fence = resolveFenceConstructionSupport(authoredFence, currentLevelId, nodes, options);
+    sceneApi.upsert(fence, currentLevelId);
+    triggerSFX('sfx:structure-build');
+    return fence;
+}
+/**
+ * Commit a smooth spline fence from a list of drawn control points. The
+ * centerline becomes a Catmull-Rom curve through `path`; `start`/`end` are
+ * pinned to the first/last point so endpoint handles, bbox, and miter
+ * references stay valid. Requires >= 2 points spanning a usable distance.
+ */
+export function createSplineFenceOnCurrentLevel(path, tangents, context) {
+    const { sceneApi, levelId: currentLevelId } = context;
+    const nodes = sceneApi.nodes();
+    if (!currentLevelId || path.length < 2) {
+        return null;
+    }
+    const start = path[0];
+    const end = path[path.length - 1];
+    // A degenerate single-point-ish path (all clicks on one spot) is rejected
+    // the same way a too-short straight segment is.
+    if (getFenceSplineLength(path, tangents) < 0.01) {
+        return null;
+    }
+    const fenceCount = Object.values(nodes).filter((node) => node.type === 'fence').length;
+    const defaults = {
+        ...useEditor.getState().toolDefaults.fence,
+        ...getFenceInheritedDefaults(start, context),
+    };
+    const authoredFence = FenceNode.parse({
+        ...defaults,
+        name: `Fence ${fenceCount + 1}`,
+        start,
+        end,
+        path,
+        tangents,
+    });
+    const fence = authoredFence;
+    sceneApi.upsert(fence, currentLevelId);
+    triggerSFX('sfx:structure-build');
+    return fence;
+}

package/dist/fence/feature-tool.d.ts

@@ -0,0 +1,4 @@
+export default function FenceFeatureTool({ kind }: {
+    kind: 'gate' | 'opening';
+}): null;
+//# sourceMappingURL=feature-tool.d.ts.map

package/dist/fence/feature-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-tool.d.ts","sourceRoot":"","sources":["../../src/fence/feature-tool.tsx"],"names":[],"mappings":"AAyBA,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,QAuJ9E"}