@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/fence/tool.js

@@ -1,26 +1,50 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { calculateLevelMiters, collectAlignmentAnchors, emitter, getTwoPointFenceCurveTangents, getWallMiterBoundaryPoints, resolveAlignment, sampleFenceSpline, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapFenceDraftPoint, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, useSegmentDraftChain, } from '@pascal-app/editor';
-import { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { calculateLevelMiters, collectAlignmentAnchors, emitter, FenceNode, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, levelBaseElevationAt, resolveAlignment, sampleFenceSpline, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
+import { createSceneSupportHeightSampler, getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Vector3 } from 'three';
 import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import { createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, getFenceInheritedDefaults, snapFenceDraftPoint, } from './drafting';
+import FenceFeatureTool from './feature-tool';
+import { createFenceRailHeightSampler, generateFenceGeometry } from './geometry-parts';
 const FENCE_PREVIEW_HEIGHT = 1.8;
 const FENCE_PREVIEW_THICKNESS = 0.08;
 // Grid-plane surface publish (pointer-decided): scratch + constant normal so
 // per-move publishes don't allocate.
 const SURFACE_UP = new Vector3(0, 1, 0);
 const surfacePointScratch = new Vector3();
-// The walking surface the pointer actually aims at (deck top when over the
-// deck, floor/ground underneath it) — only for genuine 3D pointer events.
-// The 2D floor plan emits synthetic grid events with no camera ray behind
-// them; those keep the uncapped max election and leave the grid plane alone.
 function pointedSurfaceFor(camera, event) {
-    return event.nativeEvent?.target instanceof HTMLCanvasElement
-        ? resolvePointerSupportSurface(camera, event.position, { includeNodeTopSurfaces: true })
-        : null;
+    if (event.localRay) {
+        return resolvePointerSupportSurface(camera, event.position, { includeNodeTopSurfaces: true });
+    }
+    const levelId = useViewer.getState().selection.levelId;
+    if (!levelId)
+        return null;
+    const [x, , z] = event.localPosition;
+    const pointed = spatialGridManager.getPointedSupportSurface(levelId, [x, 10_000, z], [0, -1, 0]);
+    const nodes = useScene.getState().nodes;
+    const supportSlabId = pointed.slabId ?? GROUND_SUPPORT_ID;
+    const elevation = pointed.slabId ? pointed.elevation : levelBaseElevationAt(nodes, levelId, x, z);
+    const levelMesh = sceneRegistry.nodes.get(levelId);
+    const world = levelMesh
+        ? levelMesh.localToWorld(new Vector3(x, elevation, z))
+        : new Vector3(event.position[0], event.position[1] + elevation - event.localPosition[1], event.position[2]);
+    const buildingId = useViewer.getState().selection.buildingId;
+    const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+    const local = buildingMesh
+        ? buildingMesh.worldToLocal(world.clone())
+        : new Vector3(x, elevation, z);
+    return {
+        elevation,
+        supportSlabId,
+        sourceNodeId: null,
+        worldY: world.y,
+        worldPoint: [world.x, world.y, world.z],
+        localPoint: [local.x, local.y, local.z],
+    };
 }
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
 const ALIGNMENT_THRESHOLD_M = 0.08;
@@ -280,12 +304,19 @@ function getCurrentLevelElements() {
 }
 export const FenceTool = () => {
     const fenceMode = useEditor((s) => s.continuationByContext.fence);
+    const feature = useEditor((s) => s.toolDefaults.fence?.featurePlacement);
+    if (feature === 'gate' || feature === 'opening')
+        return _jsx(FenceFeatureTool, { kind: feature });
     if (fenceMode === 'curved') {
         return _jsx(SplineFenceDraft, {});
     }
+    if (fenceMode === 'freehand')
+        return _jsx(SplineFenceDraft, { freehand: true });
     return _jsx(StraightFenceTool, {});
 };
 const StraightFenceTool = () => {
+    const { activeLevelId, sceneApi } = useRegistryToolContext();
+    const draftContext = useMemo(() => ({ sceneApi, levelId: activeLevelId }), [sceneApi, activeLevelId]);
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
@@ -294,8 +325,16 @@ const StraightFenceTool = () => {
     // than the generic fallbacks. Read through refs so the live event
     // handlers below see the latest values without re-subscribing.
     const fenceDefaults = useEditor((s) => s.toolDefaults.fence);
-    const previewHeight = typeof fenceDefaults?.height === 'number' ? fenceDefaults.height : FENCE_PREVIEW_HEIGHT;
-    const previewThickness = typeof fenceDefaults?.thickness === 'number' ? fenceDefaults.thickness : FENCE_PREVIEW_THICKNESS;
+    const startingPoint = useRef(new Vector3(0, 0, 0));
+    const buildingState = useRef(0);
+    const inheritedPreview = buildingState.current === 1
+        ? getFenceInheritedDefaults([startingPoint.current.x, startingPoint.current.z], draftContext)
+        : null;
+    const effectiveDefaults = { ...fenceDefaults, ...inheritedPreview };
+    const previewHeight = typeof effectiveDefaults.height === 'number' ? effectiveDefaults.height : FENCE_PREVIEW_HEIGHT;
+    const previewThickness = typeof effectiveDefaults.thickness === 'number'
+        ? effectiveDefaults.thickness
+        : FENCE_PREVIEW_THICKNESS;
     const previewHeightRef = useRef(previewHeight);
     previewHeightRef.current = previewHeight;
     const previewThicknessRef = useRef(previewThickness);
@@ -307,10 +346,8 @@ const StraightFenceTool = () => {
     cameraRef.current = camera;
     const cursorRef = useRef(null);
     const previewRef = useRef(null);
-    const startingPoint = useRef(new Vector3(0, 0, 0));
     const endingPoint = useRef(new Vector3(0, 0, 0));
     const constructionSurface = useRef(null);
-    const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
     const [axisGuide, setAxisGuide] = useState(null);
     const measurementColor = isDark ? '#ffffff' : '#111111';
@@ -318,7 +355,10 @@ const StraightFenceTool = () => {
     // Scope seeded defaults to this tool session: clear on deactivation so a
     // later manual fence draw isn't drawn with a stale preset's parameters.
     // Unmount-only (empty deps) — the [unit] effect below must not clear it.
-    useEffect(() => () => useEditor.getState().setToolDefaults('fence', null), []);
+    useEffect(() => () => {
+        if (!useEditor.getState().toolDefaults.fence?.featurePlacement)
+            useEditor.getState().setToolDefaults('fence', null);
+    }, []);
     useEffect(() => {
         let previousFenceEnd = null;
         // Alignment candidates — anchors of every alignable object. Refreshed
@@ -478,7 +518,7 @@ const StraightFenceTool = () => {
                     supportCap: pointedSurface?.elevation ?? null,
                     preferredSupportSlabId: pointedSurface?.supportSlabId ?? null,
                     constructionElevation: pointedSurface?.sourceNodeId ? pointedSurface.elevation : null,
-                });
+                }, draftContext);
                 if (!createdFence)
                     return;
                 // The new segment is now a real node — make it an alignment target
@@ -534,16 +574,66 @@ const StraightFenceTool = () => {
             draftPreview.setFenceDraftStart(null);
             draftPreview.setFenceDraftEnd(null);
         };
-    }, [unit, metricNotation]);
+    }, [unit, metricNotation, draftContext]);
     return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: previewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#ffffff", depthTest: false, depthWrite: false, opacity: 0.45, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
 const SPLINE_PREVIEW_COLOR = '#8381ed';
 const SPLINE_PREVIEW_SEGMENTS = 40;
-const SplineFenceDraft = () => {
-    const previewHeight = typeof useEditor.getState().toolDefaults.fence?.height === 'number'
-        ? useEditor.getState().toolDefaults.fence?.height
-        : FENCE_PREVIEW_HEIGHT;
+const FREEHAND_SAMPLE_DISTANCE = 0.2;
+const FREEHAND_SIMPLIFY_TOLERANCE = 0.08;
+const FREEHAND_MAX_CONTROL_POINTS = 64;
+function simplifyFreehandPath(points, tolerance = FREEHAND_SIMPLIFY_TOLERANCE) {
+    if (points.length <= 2)
+        return points;
+    let threshold = tolerance * tolerance;
+    while (true) {
+        const keep = new Uint8Array(points.length);
+        keep[0] = 1;
+        keep[points.length - 1] = 1;
+        const ranges = [[0, points.length - 1]];
+        while (ranges.length > 0) {
+            const [start, end] = ranges.pop();
+            const a = points[start];
+            const b = points[end];
+            const dx = b[0] - a[0];
+            const dz = b[1] - a[1];
+            const lengthSquared = dx * dx + dz * dz;
+            let farthestIndex = -1;
+            let farthestDistanceSquared = threshold;
+            for (let index = start + 1; index < end; index += 1) {
+                const point = points[index];
+                const t = lengthSquared > 1e-9
+                    ? Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dz) / lengthSquared))
+                    : 0;
+                const offsetX = point[0] - (a[0] + dx * t);
+                const offsetZ = point[1] - (a[1] + dz * t);
+                const distanceSquared = offsetX * offsetX + offsetZ * offsetZ;
+                if (distanceSquared > farthestDistanceSquared) {
+                    farthestDistanceSquared = distanceSquared;
+                    farthestIndex = index;
+                }
+            }
+            if (farthestIndex >= 0) {
+                keep[farthestIndex] = 1;
+                ranges.push([start, farthestIndex], [farthestIndex, end]);
+            }
+        }
+        const simplified = points.filter((_, index) => keep[index] === 1);
+        if (simplified.length <= FREEHAND_MAX_CONTROL_POINTS)
+            return simplified;
+        threshold *= 2.25;
+    }
+}
+const SplineFenceDraft = ({ freehand = false }) => {
+    const { activeLevelId, sceneApi } = useRegistryToolContext();
+    const draftContext = useMemo(() => ({ sceneApi, levelId: activeLevelId }), [sceneApi, activeLevelId]);
+    const fenceDefaults = useEditor((state) => state.toolDefaults.fence);
+    const sceneNodes = useScene((state) => state.nodes);
+    const levelId = useViewer((state) => state.selection.levelId);
     const [draftPoints, setDraftPoints] = useState([]);
+    const inheritedPreview = useMemo(() => draftPoints[0] ? getFenceInheritedDefaults(draftPoints[0], draftContext, sceneNodes) : null, [draftPoints[0], sceneNodes, draftContext]);
+    const effectiveDefaults = useMemo(() => ({ ...fenceDefaults, ...inheritedPreview }), [fenceDefaults, inheritedPreview]);
+    const previewHeight = typeof effectiveDefaults.height === 'number' ? effectiveDefaults.height : FENCE_PREVIEW_HEIGHT;
     const [cursor, setCursor] = useState(null);
     // Building-local Y of the grid plane (rides the pointed surface — see
     // `pointedSurfaceFor`), so the spline preview draws on the deck top when
@@ -552,10 +642,9 @@ const SplineFenceDraft = () => {
     const camera = useThree((state) => state.camera);
     const cameraRef = useRef(camera);
     cameraRef.current = camera;
-    // Pointer cap for the commit (Enter / double-click carry no useful grid
-    // event of their own) — last resolved on move/click.
-    const supportSurfaceRef = useRef(null);
     const draftRef = useRef(draftPoints);
+    const freehandSamplesRef = useRef([]);
+    const isSketchingRef = useRef(false);
     draftRef.current = draftPoints;
     // Mirror the full transient curve so additional preview surfaces observe
     // the same snapped control points as the local preview.
@@ -563,24 +652,22 @@ const SplineFenceDraft = () => {
         useFenceCurveDraft.getState().setDraft(draftPoints, cursor);
     }, [cursor, draftPoints]);
     useEffect(() => () => useFenceCurveDraft.getState().reset(), []);
-    useEffect(() => () => useEditor.getState().setToolDefaults('fence', null), []);
+    useEffect(() => () => {
+        if (!useEditor.getState().toolDefaults.fence?.featurePlacement)
+            useEditor.getState().setToolDefaults('fence', null);
+    }, []);
     useEffect(() => {
         const snapPoint = (local) => {
+            if (freehand)
+                return local;
             const step = isGridSnapActive() ? getSegmentGridStep() : 0;
             if (step <= 0)
                 return local;
             return [snapScalarToGrid(local[0], step), snapScalarToGrid(local[1], step)];
         };
-        const commit = () => {
-            const points = draftRef.current;
+        const commit = (points = draftRef.current) => {
             if (points.length >= 2) {
-                const created = createSplineFenceOnCurrentLevel(points, undefined, {
-                    supportCap: supportSurfaceRef.current?.elevation ?? null,
-                    preferredSupportSlabId: supportSurfaceRef.current?.supportSlabId ?? null,
-                    constructionElevation: supportSurfaceRef.current?.sourceNodeId
-                        ? supportSurfaceRef.current.elevation
-                        : null,
-                });
+                const created = createSplineFenceOnCurrentLevel(points, undefined, draftContext);
                 if (created) {
                     triggerSFX('sfx:item-place');
                     // Once the new curve fence is selected for direct editing, leave
@@ -590,28 +677,77 @@ const SplineFenceDraft = () => {
                     useEditor.getState().setMode('select');
                 }
             }
+            draftRef.current = [];
+            freehandSamplesRef.current = [];
+            isSketchingRef.current = false;
             setDraftPoints([]);
             setCursor(null);
         };
         const trackPointedSurface = (event) => {
             const pointed = pointedSurfaceFor(cameraRef.current, event);
-            if (!pointed)
+            const activeSurface = pointed;
+            if (!activeSurface)
                 return null;
-            if (draftRef.current.length === 0)
-                supportSurfaceRef.current = pointed;
-            const activeSurface = supportSurfaceRef.current ?? pointed;
             publishPlacementSurface(surfacePointScratch.set(event.position[0], activeSurface.worldY, event.position[2]), SURFACE_UP);
             setLiftY(activeSurface.localPoint?.[1] ?? event.localPosition[1]);
             return pointed;
         };
         const onMove = (event) => {
             const pointed = trackPointedSurface(event);
-            setCursor(snapPoint([
+            const point = snapPoint([
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ]);
+            setCursor(point);
+            if (freehand && isSketchingRef.current) {
+                const last = freehandSamplesRef.current.at(-1);
+                if (last &&
+                    Math.hypot(point[0] - last[0], point[1] - last[1]) >= FREEHAND_SAMPLE_DISTANCE) {
+                    const samples = [...freehandSamplesRef.current, point];
+                    freehandSamplesRef.current = samples;
+                    const next = simplifyFreehandPath(samples);
+                    draftRef.current = next;
+                    setDraftPoints(next);
+                }
+            }
+        };
+        const onPointerDown = (event) => {
+            if (!freehand || event.nativeEvent.button !== 0)
+                return;
+            const pointed = trackPointedSurface(event);
+            const point = snapPoint([
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ]);
+            isSketchingRef.current = true;
+            freehandSamplesRef.current = [point];
+            draftRef.current = [point];
+            setDraftPoints([point]);
+            setCursor(point);
+        };
+        const onPointerUp = (event) => {
+            if (!freehand || !isSketchingRef.current)
+                return;
+            isSketchingRef.current = false;
+            const pointed = trackPointedSurface(event);
+            const point = snapPoint([
                 pointed?.localPoint?.[0] ?? event.localPosition[0],
                 pointed?.localPoint?.[2] ?? event.localPosition[2],
-            ]));
+            ]);
+            const previous = freehandSamplesRef.current;
+            const last = previous.at(-1);
+            const samples = last && Math.hypot(point[0] - last[0], point[1] - last[1]) < 0.03
+                ? previous
+                : [...previous, point];
+            freehandSamplesRef.current = samples;
+            const next = simplifyFreehandPath(samples);
+            draftRef.current = next;
+            setDraftPoints(next);
+            commit(next);
         };
         const onClick = (event) => {
+            if (freehand)
+                return;
             const pointed = trackPointedSurface(event);
             if (event.nativeEvent.detail >= 2) {
                 commit();
@@ -632,27 +768,100 @@ const SplineFenceDraft = () => {
             if (draftRef.current.length === 0)
                 return;
             markToolCancelConsumed();
+            isSketchingRef.current = false;
+            if (freehand) {
+                draftRef.current = [];
+                freehandSamplesRef.current = [];
+                setDraftPoints([]);
+                setCursor(null);
+                return;
+            }
             setDraftPoints((prev) => prev.slice(0, -1));
         };
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
+        emitter.on('grid:pointerdown', onPointerDown);
+        emitter.on('grid:pointerup', onPointerUp);
         emitter.on('tool:cancel', onCancel);
         window.addEventListener('keydown', onKeyDown);
         return () => {
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
+            emitter.off('grid:pointerdown', onPointerDown);
+            emitter.off('grid:pointerup', onPointerUp);
             emitter.off('tool:cancel', onCancel);
             clearPlacementSurface();
             window.removeEventListener('keydown', onKeyDown);
         };
-    }, []);
-    const previewPoints = cursor ? [...draftPoints, cursor] : draftPoints;
-    const curveGeometry = useMemo(() => {
+    }, [freehand, draftContext]);
+    const previewPoints = useMemo(() => {
+        const last = draftPoints.at(-1);
+        return cursor && last && !pointMatches(last, cursor) ? [...draftPoints, cursor] : draftPoints;
+    }, [cursor, draftPoints]);
+    const previewNode = useMemo(() => {
         if (previewPoints.length < 2)
             return null;
-        const sampled = sampleFenceSpline(previewPoints, getTwoPointFenceCurveTangents(previewPoints), SPLINE_PREVIEW_SEGMENTS);
-        return new BufferGeometry().setFromPoints(sampled.map((point) => new Vector3(point.x, liftY + previewHeight, point.y)));
-    }, [liftY, previewHeight, previewPoints]);
-    return (_jsxs("group", { children: [cursor && _jsx(CursorSphere, { height: previewHeight, position: [cursor[0], liftY, cursor[1]] }), draftPoints.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [point[0], liftY + previewHeight, point[1]], children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false })] }, `fence-spline-pt-${index}`))), curveGeometry && (_jsx("line", { frustumCulled: false, geometry: curveGeometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }))] }));
+        return FenceNode.parse({
+            ...effectiveDefaults,
+            id: 'fence_curve_preview',
+            start: previewPoints[0],
+            end: previewPoints.at(-1),
+            path: previewPoints,
+            tangents: undefined,
+        });
+    }, [effectiveDefaults, previewPoints]);
+    const previewGroundAt = useMemo(() => {
+        if (!levelId || !previewNode)
+            return null;
+        const selectedHost = previewNode.surfaceMode === 'selected'
+            ? (previewNode.supportSurfaceNodeId ?? previewNode.supportSlabId)
+            : undefined;
+        const sampledSupport = createSceneSupportHeightSampler(sceneNodes, levelId, selectedHost);
+        const startHeight = sampledSupport(previewNode.start[0], previewNode.start[1]);
+        const samples = new Map();
+        return (x, z) => {
+            const key = `${x},${z}`;
+            const cached = samples.get(key);
+            if (cached !== undefined)
+                return cached;
+            const height = previewNode.surfaceMode === 'level' ? startHeight : sampledSupport(x, z);
+            samples.set(key, height);
+            return height;
+        };
+    }, [levelId, previewNode, sceneNodes]);
+    const previewStartGround = previewNode
+        ? (previewGroundAt?.(previewNode.start[0], previewNode.start[1]) ?? 0)
+        : 0;
+    const previewLift = previewGroundAt ? previewStartGround : liftY;
+    const ghostGeometry = useMemo(() => previewNode
+        ? generateFenceGeometry(previewNode, previewGroundAt ? (x, z) => previewGroundAt(x, z) - previewStartGround : undefined)
+        : null, [previewNode, previewGroundAt, previewStartGround]);
+    useEffect(() => () => ghostGeometry?.dispose(), [ghostGeometry]);
+    useEffect(() => {
+        usePlacementPreview.getState().set(previewNode);
+    }, [previewNode]);
+    useEffect(() => () => usePlacementPreview.getState().clear(), []);
+    const curveGeometry = useMemo(() => {
+        if (previewPoints.length < 2 || previewNode?.transitionMode !== 'slope')
+            return null;
+        const sampled = sampleFenceSpline(previewPoints, undefined, SPLINE_PREVIEW_SEGMENTS);
+        const railHeightAt = previewGroundAt
+            ? createFenceRailHeightSampler(previewNode, (x, z) => previewGroundAt(x, z) - previewStartGround)
+            : null;
+        return new BufferGeometry().setFromPoints(sampled.map((point) => new Vector3(point.x, previewLift + previewHeight + (railHeightAt?.(point.x, point.y) ?? 0), point.y)));
+    }, [previewLift, previewGroundAt, previewHeight, previewNode, previewPoints, previewStartGround]);
+    useEffect(() => () => curveGeometry?.dispose(), [curveGeometry]);
+    return (_jsxs("group", { children: [ghostGeometry && (_jsx("mesh", { geometry: ghostGeometry, layers: EDITOR_LAYER, position: [0, previewLift + (previewNode?.supportOffset ?? 0), 0], raycast: () => { }, renderOrder: 1, children: _jsx("meshBasicMaterial", { color: "#ffffff", depthWrite: false, opacity: 0.45, transparent: true }) })), cursor && (_jsx(CursorSphere, { height: previewHeight, position: [
+                    cursor[0],
+                    previewLift +
+                        (previewGroundAt ? previewGroundAt(cursor[0], cursor[1]) - previewStartGround : 0),
+                    cursor[1],
+                ] })), draftPoints.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [
+                    point[0],
+                    previewLift +
+                        (previewGroundAt ? previewGroundAt(point[0], point[1]) - previewStartGround : 0) +
+                        previewHeight,
+                    point[1],
+                ], children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false })] }, `fence-spline-pt-${index}`))), curveGeometry && (_jsx("line", { frustumCulled: false, geometry: curveGeometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }))] }));
 };
 export default FenceTool;

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

@@ -0,0 +1,7 @@
+/**
+ * Open/Close for a single selected gate, the door's button in the action menu.
+ * Not a `mechanism`: a gate's open angle is saved on the node, and mechanisms
+ * never write the node.
+ */
+export default function FenceGateActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/fence-feature/actions.tsx"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAqBvC"}

package/dist/fence-feature/actions.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useScene } from '@pascal-app/core';
+import { ActionMenuButton } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { DoorClosed, DoorOpen } from 'lucide-react';
+import { toggleFenceGate } from './interaction';
+/**
+ * Open/Close for a single selected gate, the door's button in the action menu.
+ * Not a `mechanism`: a gate's open angle is saved on the node, and mechanisms
+ * never write the node.
+ */
+export default function FenceGateActions() {
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const gate = useScene((s) => {
+        const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
+        return node?.type === 'fence-gate' ? node : undefined;
+    });
+    if (!gate)
+        return null;
+    const open = (gate.openAngle ?? 0) > 0.01;
+    return (_jsx(ActionMenuButton, { keys: ['E'], label: open ? 'Close' : 'Open', onClick: (event) => {
+            event.stopPropagation();
+            toggleFenceGate(gate.id);
+        }, pressed: open, children: open ? _jsx(DoorClosed, { className: "h-4 w-4" }) : _jsx(DoorOpen, { className: "h-4 w-4" }) }));
+}

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

@@ -0,0 +1,4 @@
+import { FenceGateNode, FenceOpeningNode, type NodeDefinition } from '@pascal-app/core';
+export declare const fenceGateDefinition: NodeDefinition<typeof FenceGateNode | typeof FenceOpeningNode>;
+export declare const fenceOpeningDefinition: NodeDefinition<typeof FenceGateNode | typeof FenceOpeningNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACb,gBAAgB,EAGhB,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAuDzB,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,GAAG,OAAO,gBAAgB,CA4B9F,CAAA;AAyBD,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAgB/C,CAAA"}

package/dist/fence-feature/definition.js

@@ -0,0 +1,112 @@
+import { FenceGateNode, FenceOpeningNode, findLevelAncestorId, } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { AnimationClip, QuaternionKeyframeTrack } from 'three';
+import { buildFenceFeatureFloorplan } from './floorplan';
+import { fenceFeatureAffordance } from './floorplan-affordances';
+import { buildFenceFeatureGeometry } from './geometry';
+import { fenceFeatureHandles } from './handles';
+import { FenceFeatureEditor } from './inspector';
+import { toggleFenceGate } from './interaction';
+import { createFenceFeatureMoveSession } from './move-session';
+const floorplanMoveTarget = ({ node, sceneApi }) => {
+    if (!sceneApi)
+        throw new Error('Fence feature move requires SceneApi');
+    const levelId = findLevelAncestorId(node.id, sceneApi.nodes()) ?? null;
+    const session = createFenceFeatureMoveSession(node, sceneApi, levelId, (id) => useViewer.getState().setSelection({ selectedIds: [id] }));
+    return {
+        affectedIds: session.affectedIds,
+        apply: ({ planPoint }) => session.update(planPoint),
+        canCommit: session.canCommit,
+        commit: session.commit,
+    };
+};
+const parametrics = {
+    groups: [
+        {
+            label: 'Settings',
+            fields: [{ key: 'center', kind: 'custom', component: FenceFeatureEditor }],
+        },
+    ],
+};
+const shared = {
+    schemaVersion: 1,
+    category: 'structure',
+    capabilities: { selectable: { hitVolume: 'bbox' }, deletable: true },
+    geometry: buildFenceFeatureGeometry,
+    floorplan: buildFenceFeatureFloorplan,
+    floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
+    floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
+    handles: fenceFeatureHandles,
+    floorplanMoveTarget,
+    affordanceTools: { move: () => import('./move-tool') },
+    affordanceHints: {
+        move: [
+            { key: 'Left click', label: 'Place on a fence' },
+            { key: 'Esc', label: 'Cancel move' },
+        ],
+    },
+    parametrics,
+};
+export const fenceGateDefinition = {
+    ...shared,
+    kind: 'fence-gate',
+    keyboardActions: {
+        e: {
+            appliesTo: (node) => node.type === 'fence-gate',
+            run: (node) => toggleFenceGate(node.id),
+        },
+    },
+    schema: FenceGateNode,
+    extensions: {
+        'pascal:editor/floorplan': {
+            actionMenu: { actions: () => import('./actions') },
+        },
+    },
+    exportAnimation: ({ node, object }) => node.type === 'fence-gate' ? bakeFenceGateClip(node.id, object) : null,
+    defaults: () => {
+        const { id, type, ...rest } = FenceGateNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Gate',
+        description: 'A gate hosted by a fence.',
+        icon: { kind: 'url', src: '/icons/fence.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};
+function bakeFenceGateClip(id, object) {
+    const tracks = [];
+    object.traverse((part) => {
+        const marker = part.userData.pascalFenceGateLeaf;
+        if (typeof marker?.openRotationY !== 'number' || Math.abs(marker.openRotationY) < 1e-5)
+            return;
+        part.rotation.y = 0;
+        const closed = part.quaternion.clone();
+        part.rotation.y = marker.openRotationY;
+        const open = part.quaternion.clone();
+        part.rotation.y = 0;
+        tracks.push(new QuaternionKeyframeTrack(`${part.uuid}.quaternion`, [0, 1], [...closed.toArray(), ...open.toArray()]));
+    });
+    if (tracks.length === 0)
+        return null;
+    const clip = new AnimationClip(`${id}: open`, 1, tracks);
+    clip.userData = { loop: false };
+    return clip;
+}
+export const fenceOpeningDefinition = {
+    ...shared,
+    kind: 'fence-opening',
+    schema: FenceOpeningNode,
+    defaults: () => {
+        const { id, type, ...rest } = FenceOpeningNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Open Passage',
+        description: 'An intentional opening in a fence.',
+        icon: { kind: 'url', src: '/icons/door.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};

package/dist/fence-feature/floorplan-affordances.d.ts

@@ -0,0 +1,3 @@
+import { type FenceFeatureNode, type FloorplanAffordance } from '@pascal-app/core';
+export declare const fenceFeatureAffordance: FloorplanAffordance<FenceFeatureNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/fence-feature/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence-feature/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,gBAAgB,CAmCxE,CAAA"}

package/dist/fence-feature/floorplan-affordances.js

@@ -0,0 +1,37 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, projectPointToFence, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+export const fenceFeatureAffordance = {
+    start({ node, payload, nodes }) {
+        const host = node.parentId ? nodes[node.parentId] : undefined;
+        const edge = payload.edge;
+        let patch = {};
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                if (host?.type !== 'fence')
+                    return;
+                const distance = projectPointToFence(host, planPoint).center;
+                let center = distance;
+                let width = node.width;
+                if (edge !== 'center') {
+                    const fixed = node.center + ((edge === 'start' ? 1 : -1) * node.width) / 2;
+                    if (edge === 'start' ? distance > fixed - 0.35 : distance < fixed + 0.35)
+                        return;
+                    width = Math.abs(fixed - distance);
+                    center = (fixed + distance) / 2;
+                }
+                const fence = fenceWithFeatures(host, (host.children ?? []).map((id) => nodes[id]).filter(Boolean));
+                if (!canPlaceFenceFeature(fence, { ...fenceFeatureData(node), center, width }))
+                    return;
+                patch = { center, width };
+                useLiveNodeOverrides.getState().set(node.id, patch);
+                useScene.getState().markDirty(node.id);
+                useScene.getState().markDirty(host.id);
+            },
+            canCommit: () => Object.keys(patch).length > 0,
+            commit() {
+                useScene.getState().updateNode(node.id, patch);
+                useLiveNodeOverrides.getState().clear(node.id);
+            },
+        };
+    },
+};

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

@@ -0,0 +1,4 @@
+import { type FenceFeatureData, type FenceFeatureNode, type FenceNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export declare function buildFenceFeatureFloorplan(child: FenceFeatureNode, ctx: GeometryContext): FloorplanGeometry | null;
+export declare function buildFenceFeatureSymbol(data: FenceFeatureData, node: FenceNode, ctx: GeometryContext, interactive?: boolean): FloorplanGeometry;
+//# sourceMappingURL=floorplan.d.ts.map