@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/fence/tool.js

@@ -1,26 +1,91 @@
 '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 { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+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, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isTypingTarget, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
+import { createSceneSupportHeightSampler, getLevelPresentationY, 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 { BufferGeometry, DoubleSide, Plane, Raycaster, Vector2, Vector3, } from 'three';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides.js';
+import { createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, getFenceDrawingSurface, getFenceInheritedDefaults, snapFenceDraftPoint, } from './drafting.js';
+import FenceFeatureTool from './feature-tool.js';
+import { createFenceRailHeightSampler, generateFenceGeometry } from './geometry-parts.js';
 const FENCE_PREVIEW_HEIGHT = 1.8;
 const FENCE_PREVIEW_THICKNESS = 0.08;
+function FenceSurfaceSnapPoints() {
+    const hostId = useEditor((state) => state.toolDefaults.fence?.supportSurfaceNodeId);
+    const levelId = useViewer((state) => state.selection.levelId);
+    const levelMode = useViewer((state) => state.levelMode);
+    useScene((state) => (typeof hostId === 'string' ? state.nodes[hostId] : undefined));
+    useScene((state) => {
+        const surface = getFenceDrawingSurface(state.nodes, hostId, levelId, levelMode);
+        return surface ? surface.levelElevation + surface.elevation : null;
+    });
+    const surface = getFenceDrawingSurface();
+    if (!surface)
+        return null;
+    return (_jsx("group", { children: surface.boundary.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [point[0], surface.levelElevation + surface.elevation + 0.025, point[1]], renderOrder: 2, children: [_jsx("sphereGeometry", { args: [0.045, 12, 8] }), _jsx("meshBasicMaterial", { color: "#f97316", depthTest: false, transparent: true, opacity: 0.8 })] }, index))) }));
+}
 // 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;
+    const surface = getFenceDrawingSurface();
+    if (surface) {
+        const buildingId = useViewer.getState().selection.buildingId;
+        const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+        const point = new Vector3(event.localPosition[0], surface.levelElevation + surface.elevation, event.localPosition[2]);
+        if (buildingMesh)
+            buildingMesh.localToWorld(point);
+        const worldY = point.y;
+        if (event.nativeEvent?.target instanceof HTMLCanvasElement) {
+            const bounds = event.nativeEvent.target.getBoundingClientRect();
+            const raycaster = new Raycaster();
+            raycaster.setFromCamera(new Vector2(((event.nativeEvent.clientX - bounds.left) / bounds.width) * 2 - 1, -((event.nativeEvent.clientY - bounds.top) / bounds.height) * 2 + 1), camera);
+            if (!raycaster.ray.intersectPlane(new Plane(SURFACE_UP, -worldY), point))
+                return null;
+        }
+        const worldPoint = [point.x, point.y, point.z];
+        if (buildingMesh)
+            buildingMesh.worldToLocal(point);
+        return {
+            elevation: surface.elevation,
+            sourceNodeId: surface.id,
+            supportSlabId: null,
+            localPoint: [point.x, point.y, point.z],
+            worldY,
+            worldPoint,
+        };
+    }
+    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;
@@ -278,14 +343,42 @@ function getCurrentLevelElements() {
         fences: children.filter((n) => n?.type === 'fence'),
     };
 }
+function dropFenceSurfaceHost() {
+    const editor = useEditor.getState();
+    const defaults = editor.toolDefaults.fence;
+    if (typeof defaults?.supportSurfaceNodeId !== 'string')
+        return;
+    const { supportSurfaceNodeId: _host, ...unhosted } = defaults;
+    editor.setToolDefaults('fence', unhosted);
+}
 export const FenceTool = () => {
+    const levelId = useViewer((state) => state.selection.levelId);
+    const levelMode = useViewer((state) => state.levelMode);
+    const hostId = useEditor((state) => state.toolDefaults.fence?.supportSurfaceNodeId);
+    const hostParentId = useScene((state) => typeof hostId === 'string' ? state.nodes[hostId]?.parentId : undefined);
+    const floorY = useScene((state) => levelId ? getLevelPresentationY(levelId, state.nodes, levelMode) : 0);
+    const draftKey = `${levelId}:${floorY}`;
+    // A surface host (a deck's railing) holds for one drawing session on its floor: leaving the
+    // floor or the tool drops it, and the fence tool draws plain fences again.
+    useEffect(() => {
+        if (typeof hostId === 'string' && hostParentId !== levelId)
+            dropFenceSurfaceHost();
+    }, [hostId, levelId, hostParentId]);
+    useEffect(() => dropFenceSurfaceHost, []);
     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, {});
+        return (_jsxs(_Fragment, { children: [_jsx(FenceSurfaceSnapPoints, {}), _jsx(SplineFenceDraft, {}, draftKey)] }));
     }
-    return _jsx(StraightFenceTool, {});
+    if (fenceMode === 'freehand')
+        return _jsx(SplineFenceDraft, { freehand: true }, draftKey);
+    return (_jsxs(_Fragment, { children: [_jsx(FenceSurfaceSnapPoints, {}), _jsx(StraightFenceTool, {}, draftKey)] }));
 };
 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 +387,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 +408,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 +417,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
@@ -330,6 +432,10 @@ const StraightFenceTool = () => {
         // Align the drafted point onto another object's nearest real anchor and
         // publish the guide. Returns the possibly snapped point.
         const alignPoint = (point, options) => {
+            if (getFenceDrawingSurface()) {
+                useAlignmentGuides.getState().clear();
+                return point;
+            }
             // Figma alignment lines onto existing corners / edges are DISPLAYED in
             // every mode except Off (isAlignmentGuideActive); the magnetic pull onto
             // them is applied only in 'lines' mode (isMagneticSnapActive).
@@ -434,7 +540,10 @@ const StraightFenceTool = () => {
             }
             const { walls, fences } = getCurrentLevelElements();
             const pointed = pointedSurfaceFor(cameraRef.current, event);
-            const localClick = [event.localPosition[0], event.localPosition[2]];
+            const localClick = [
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ];
             if (buildingState.current === 0) {
                 const snappedStart = alignPoint(snapFenceDraftPoint({
                     point: localClick,
@@ -478,7 +587,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 +643,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 +711,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 +721,25 @@ 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) => {
-            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
-            if (step <= 0)
+            if (freehand)
                 return local;
-            return [snapScalarToGrid(local[0], step), snapScalarToGrid(local[1], step)];
+            const { walls, fences } = getCurrentLevelElements();
+            return snapFenceDraftPoint({
+                point: local,
+                walls,
+                fences,
+                magnetic: isMagneticSnapActive(),
+            });
         };
-        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 +749,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();
@@ -625,6 +833,8 @@ const SplineFenceDraft = () => {
             setDraftPoints((prev) => [...prev, point]);
         };
         const onKeyDown = (event) => {
+            if (isTypingTarget(event.target))
+                return;
             if (event.key === 'Enter')
                 commit();
         };
@@ -632,27 +842,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.js';
+/**
+ * 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;AA2DzB,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"}