@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/fence/feature-tool.js

@@ -0,0 +1,140 @@
+'use client';
+import { emitter, FenceGateNode, FenceOpeningNode, FenceStyle, fenceFeaturePlacementIssue, fenceWithFeatures, useLiveNodeOverrides, } from '@pascal-app/core';
+import { markToolCancelConsumed, triggerSFX, useEditor, useRegistryToolContext, } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { pickFenceTarget } from '../fence-feature/pick-target';
+export default function FenceFeatureTool({ kind }) {
+    const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
+    useEffect(() => {
+        let previewId;
+        let finished = false;
+        const featureId = crypto.randomUUID();
+        const clear = () => {
+            if (!previewId)
+                return;
+            useLiveNodeOverrides.getState().clearFields(previewId, ['features']);
+            sceneApi.markDirty(previewId);
+            previewId = undefined;
+        };
+        const setFeedback = (message) => {
+            const defaults = useEditor.getState().toolDefaults.fence;
+            if (defaults?.featurePlacementFeedback === message)
+                return;
+            useEditor
+                .getState()
+                .setToolDefaults('fence', { ...defaults, featurePlacementFeedback: message });
+        };
+        const candidate = (point, host, ray) => {
+            const nodes = sceneApi.nodes();
+            const best = pickFenceTarget(point, host, ray, sceneApi, activeLevelId);
+            if (!best)
+                return { issue: 'Click on a fence to place the feature.' };
+            const defaults = useEditor.getState().toolDefaults.fence;
+            const selectedStyle = FenceStyle.safeParse(defaults?.featureStyle);
+            const feature = {
+                id: featureId,
+                kind,
+                center: best.center,
+                width: typeof defaults?.featureWidth === 'number' ? defaults.featureWidth : 1.1,
+                matchFenceStyle: defaults?.featureMatchStyle !== false,
+                leafType: defaults?.featureLeafType === 'double' ? 'double' : 'single',
+                height: defaults?.featureMatchStyle === false
+                    ? Math.max(0.3, best.fence.height - 0.22)
+                    : undefined,
+                clearance: defaults?.featureMatchStyle === false ? best.fence.groundClearance : undefined,
+                style: defaults?.featureMatchStyle === false && selectedStyle.success
+                    ? selectedStyle.data
+                    : 'match',
+                hinge: 'left',
+                swing: 'inward',
+                openAngle: 0,
+                frameWidth: defaults?.featureMatchStyle === false ? 0.055 : undefined,
+                thickness: defaults?.featureMatchStyle === false ? 0.06 : undefined,
+                spacing: defaults?.featureMatchStyle === false ? 0.15 : undefined,
+                boardWidth: defaults?.featureMatchStyle === false ? 0.055 : undefined,
+                brace: 'none',
+                showHardware: true,
+                showPosts: true,
+            };
+            const issue = fenceFeaturePlacementIssue(fenceWithFeatures(best.fence, (best.fence.children ?? []).map((id) => nodes[id]).filter(Boolean)), feature);
+            return issue
+                ? {
+                    issue: issue === 'overlap'
+                        ? 'That spot overlaps another gate or passage. Choose a clear section.'
+                        : issue === 'end'
+                            ? 'Move farther from the fence end or reduce the opening width.'
+                            : 'Opening width must be at least 0.35 m.',
+                }
+                : { hit: { fence: best.fence, feature } };
+        };
+        const update = (point, host, ray) => {
+            clear();
+            const { hit, issue } = candidate(point, host, ray);
+            if (hit) {
+                setFeedback(undefined);
+                previewId = hit.fence.id;
+                useLiveNodeOverrides.getState().set(previewId, { features: [hit.feature] });
+                sceneApi.markDirty(previewId);
+            }
+            return { hit, issue };
+        };
+        const commit = (point, host, ray) => {
+            if (finished)
+                return;
+            const { hit, issue } = update(point, host, ray);
+            if (!hit) {
+                setFeedback(issue);
+                return;
+            }
+            finished = true;
+            clear();
+            const { id: _id, kind: _kind, ...data } = hit.feature;
+            const schema = kind === 'gate' ? FenceGateNode : FenceOpeningNode;
+            const child = schema.parse({
+                ...data,
+                parentId: hit.fence.id,
+                name: kind === 'gate' ? 'Gate' : 'Open passage',
+            });
+            sceneApi.upsert(child, hit.fence.id);
+            triggerSFX('sfx:item-place');
+            useEditor.getState().setMode('select');
+            useEditor.getState().setTool(null);
+            useEditor.getState().setToolDefaults('fence', null);
+            selectNode(child.id);
+        };
+        const onMove = (event) => {
+            update([event.localPosition[0], event.localPosition[2]], undefined, event.localRay);
+        };
+        const onClick = (event) => {
+            commit([event.localPosition[0], event.localPosition[2]], undefined, event.localRay);
+        };
+        const onFenceMove = (event) => {
+            update([event.localPosition[0], event.localPosition[2]], event.node);
+        };
+        const onFenceClick = (event) => {
+            commit([event.localPosition[0], event.localPosition[2]], event.node);
+            event.stopPropagation();
+        };
+        const cancel = () => {
+            clear();
+            markToolCancelConsumed();
+            useEditor.getState().setMode('select');
+            useEditor.getState().setTool(null);
+            useEditor.getState().setToolDefaults('fence', null);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        emitter.on('fence:move', onFenceMove);
+        emitter.on('fence:click', onFenceClick);
+        emitter.on('tool:cancel', cancel);
+        return () => {
+            clear();
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            emitter.off('fence:move', onFenceMove);
+            emitter.off('fence:click', onFenceClick);
+            emitter.off('tool:cancel', cancel);
+        };
+    }, [activeLevelId, kind, sceneApi, selectNode]);
+    return null;
+}

package/dist/fence/features.d.ts

@@ -0,0 +1,2 @@
+export declare function beginFenceFeaturePlacement(kind: 'gate' | 'opening'): void;
+//# sourceMappingURL=features.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/fence/features.ts"],"names":[],"mappings":"AAIA,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAQlE"}

package/dist/fence/features.js

@@ -0,0 +1,12 @@
+import { emitter } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+export function beginFenceFeaturePlacement(kind) {
+    emitter.emit('tool:cancel');
+    const editor = useEditor.getState();
+    editor.setPhase('building');
+    editor.setMode('build');
+    editor.setTool('fence');
+    editor.setToolDefaults('fence', { featurePlacement: kind });
+    useViewer.getState().setSelection({ selectedIds: [] });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAUzB,MAAM,kBAAkB,CAAA;AAsFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAgCnE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAqCtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAoDjE,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CA4HtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAUzB,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAgCnE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAqCtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAoDjE,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CA6HtE,CAAA"}

package/dist/fence/floorplan-affordances.js

@@ -1,5 +1,6 @@
 import { getFenceCenterlineFrameAt, getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapBuildingLocalToWorldGrid, snapFenceDraftPoint, snapScalarToGrid, useAlignmentGuides, } from '@pascal-app/editor';
+import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapBuildingLocalToWorldGrid, snapScalarToGrid, useAlignmentGuides, } from '@pascal-app/editor';
+import { snapFenceDraftPoint } from './drafting';
 /**
  * Floor-plan 2D drag affordances for fence — sister to the 3D
  * `actions/move-endpoint.ts` `DragAction`. Same legacy interaction

package/dist/fence/floorplan.d.ts

@@ -1,4 +1,3 @@
-import { type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
-import type { FenceNode } from './schema';
-export declare function buildFenceFloorplan(node: FenceNode, ctx: GeometryContext): FloorplanGeometry;
+import { type FenceWithFeatures, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export declare function buildFenceFloorplan(node: FenceWithFeatures, ctx: GeometryContext): FloorplanGeometry;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAiNzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,CAyT5F"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAUrB,MAAM,kBAAkB,CAAA;AAkPzB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,CA8VnB"}

package/dist/fence/floorplan.js

@@ -1,4 +1,5 @@
-import { getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceControlHandle, getWallMidpointHandlePoint, isCurvedWall, isSplineFence, sampleFenceCenterline, } from '@pascal-app/core';
+import { fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getWallMidpointHandlePoint, isCurvedWall, isSplineFence, resolveFenceFeatures, sampleFenceCenterline, } from '@pascal-app/core';
+import { buildFenceFeatureSymbol } from '../fence-feature/floorplan';
 /**
  * Stage C floor-plan builder for fence. 1:1 visual port of the legacy
  * `FloorplanFenceLayer` from `floorplan-panel.tsx`:
@@ -64,6 +65,36 @@ function buildCenterlinePathD(points) {
 }
 function buildMarker(fence, point, angleRadians, accentColor, surfaceColor, isActive) {
     const markerStrokeWidth = isActive ? 1.65 : 1.35;
+    if (fence.style === 'picket') {
+        const w = clamp(fence.postSize * 0.55, 0.035, 0.065);
+        const h = clamp(fence.baseHeight * 0.55, 0.08, 0.14);
+        return {
+            kind: 'group',
+            transform: { translate: [point.x, point.y], rotate: angleRadians },
+            children: [
+                {
+                    kind: 'rect',
+                    x: -(w + 0.026) / 2,
+                    y: -(h + 0.026) / 2,
+                    width: w + 0.026,
+                    height: h + 0.026,
+                    rx: 0.012,
+                    ry: 0.012,
+                    fill: surfaceColor,
+                },
+                {
+                    kind: 'rect',
+                    x: -w / 2,
+                    y: -h / 2,
+                    width: w,
+                    height: h,
+                    rx: 0.008,
+                    ry: 0.008,
+                    fill: accentColor,
+                },
+            ],
+        };
+    }
     if (fence.style === 'privacy' || fence.style === 'horizontal') {
         const w = clamp(fence.postSize * 0.58, 0.038, 0.068);
         const h = clamp(Math.max(fence.baseHeight * 0.5, fence.postSize * 1.4), 0.1, 0.17);
@@ -181,6 +212,8 @@ function buildMarker(fence, point, angleRadians, accentColor, surfaceColor, isAc
     };
 }
 export function buildFenceFloorplan(node, ctx) {
+    const drafts = node.features ?? [];
+    node = fenceWithFeatures(node, ctx.children);
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
@@ -196,7 +229,22 @@ export function buildFenceFloorplan(node, ctx) {
             { x: node.start[0], y: node.start[1] },
             { x: node.end[0], y: node.end[1] },
         ];
-    const pathD = buildCenterlinePathD(centerlinePoints);
+    const features = resolveFenceFeatures(node);
+    const visibleRanges = [];
+    let rangeStart = 0;
+    for (const feature of features) {
+        if (feature.startT > rangeStart)
+            visibleRanges.push([rangeStart, feature.startT]);
+        rangeStart = feature.endT;
+    }
+    if (rangeStart < 1)
+        visibleRanges.push([rangeStart, 1]);
+    const strokePaths = features.length === 0
+        ? [centerlinePoints]
+        : visibleRanges.map(([start, end]) => {
+            const count = Math.max(2, Math.ceil(((end - start) * getFenceCenterlineLength(node)) / 0.2) + 1);
+            return Array.from({ length: count }, (_, index) => getFenceCenterlineFrameAt(node, start + ((end - start) * index) / (count - 1)).point);
+        });
     // Stroke shifts: selected wins; hover (not selected) → `wallHoverStroke`
     // (light blue from the legacy palette, same as walls); otherwise dark
     // accent. Mirrors the `fenceStroke` ternary in the legacy panel.
@@ -223,7 +271,7 @@ export function buildFenceFloorplan(node, ctx) {
     const glowOpacity = isActive ? 0.22 : isHovered ? 0.14 : 0;
     // Marker frames. Filter to first+last when infill is off so the user
     // still sees end posts (matches legacy).
-    const markerTs = getFloorplanFenceMarkerTs(node);
+    const markerTs = getFloorplanFenceMarkerTs(node).filter((t) => !features.some((feature) => t > feature.startT && t < feature.endT));
     const markerFrames = markerTs.map((t) => {
         const frame = getFenceCenterlineFrameAt(node, t);
         return {
@@ -239,41 +287,44 @@ export function buildFenceFloorplan(node, ctx) {
     // low-opacity ring. Width steps with the interaction level so hover
     // is subtler than active.
     if (glowOpacity > 0) {
+        for (const points of strokePaths)
+            children.push({
+                kind: 'path',
+                d: buildCenterlinePathD(points),
+                fill: 'none',
+                stroke: glowStroke,
+                strokeWidth: isActive ? 9.5 : isHovered ? 8.8 : 8.2,
+                strokeOpacity: glowOpacity,
+                strokeLinecap: 'round',
+                strokeLinejoin: 'round',
+                vectorEffect: 'non-scaling-stroke',
+            });
+    }
+    // 2. White underlay — visible fence body base layer.
+    for (const points of strokePaths)
         children.push({
             kind: 'path',
-            d: pathD,
+            d: buildCenterlinePathD(points),
             fill: 'none',
-            stroke: glowStroke,
-            strokeWidth: isActive ? 9.5 : isHovered ? 8.8 : 8.2,
-            strokeOpacity: glowOpacity,
+            stroke: underlayStroke,
+            strokeOpacity: 0.98,
+            strokeWidth: underlayWidth,
             strokeLinecap: 'round',
             strokeLinejoin: 'round',
             vectorEffect: 'non-scaling-stroke',
         });
-    }
-    // 2. White underlay — visible fence body base layer.
-    children.push({
-        kind: 'path',
-        d: pathD,
-        fill: 'none',
-        stroke: underlayStroke,
-        strokeOpacity: 0.98,
-        strokeWidth: underlayWidth,
-        strokeLinecap: 'round',
-        strokeLinejoin: 'round',
-        vectorEffect: 'non-scaling-stroke',
-    });
     // 3. Dark accent on top.
-    children.push({
-        kind: 'path',
-        d: pathD,
-        fill: 'none',
-        stroke: accentStroke,
-        strokeWidth: accentWidth,
-        strokeLinecap: 'round',
-        strokeLinejoin: 'round',
-        vectorEffect: 'non-scaling-stroke',
-    });
+    for (const points of strokePaths)
+        children.push({
+            kind: 'path',
+            d: buildCenterlinePathD(points),
+            fill: 'none',
+            stroke: accentStroke,
+            strokeWidth: accentWidth,
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round',
+            vectorEffect: 'non-scaling-stroke',
+        });
     // 4. Style-aware markers. Pass `showInteractiveChrome` so hover also
     // bumps marker stroke widths slightly (legacy panel does the same).
     for (const marker of visibleMarkers) {
@@ -283,20 +334,21 @@ export function buildFenceFloorplan(node, ctx) {
     // chord-spanning line; a spline fence emits one short hit-line per sampled
     // span so the clickable region follows the curve instead of cutting the
     // chord (there's no curved `hit-path` primitive yet).
-    if (isSplineFence(node)) {
-        for (let i = 1; i < centerlinePoints.length; i += 1) {
-            const a = centerlinePoints[i - 1];
-            const b = centerlinePoints[i];
-            children.push({
-                kind: 'hit-line',
-                x1: a.x,
-                y1: a.y,
-                x2: b.x,
-                y2: b.y,
-                strokeWidthPx: 18,
-                cursor: 'pointer',
-            });
-        }
+    if (isSplineFence(node) || features.length > 0) {
+        for (const points of strokePaths)
+            for (let i = 1; i < points.length; i += 1) {
+                const a = points[i - 1];
+                const b = points[i];
+                children.push({
+                    kind: 'hit-line',
+                    x1: a.x,
+                    y1: a.y,
+                    x2: b.x,
+                    y2: b.y,
+                    strokeWidthPx: 18,
+                    cursor: 'pointer',
+                });
+            }
     }
     else {
         children.push({
@@ -328,38 +380,44 @@ export function buildFenceFloorplan(node, ctx) {
                 const armY = handle.y * TANGENT_HANDLE_ARM_SCALE;
                 const out = [point[0] + armX, point[1] + armY];
                 const inn = [point[0] - armX, point[1] - armY];
+                const showOut = i < node.path.length - 1 &&
+                    getFenceSpanMode(node.path, node.tangents, node.spanModes, i) === 'curve';
+                const showIn = i > 0 && getFenceSpanMode(node.path, node.tangents, node.spanModes, i - 1) === 'curve';
                 // Connecting line (the "tangent" through the point). Violet to match
                 // the 3D tangent line + the handle dots.
-                children.push({
-                    kind: 'line',
-                    x1: inn[0],
-                    y1: inn[1],
-                    x2: out[0],
-                    y2: out[1],
-                    stroke: '#8381ed',
-                    strokeWidth: 1.25,
-                    strokeOpacity: 0.85,
-                    vectorEffect: 'non-scaling-stroke',
-                });
+                if (showOut || showIn)
+                    children.push({
+                        kind: 'line',
+                        x1: showIn ? inn[0] : point[0],
+                        y1: showIn ? inn[1] : point[1],
+                        x2: showOut ? out[0] : point[0],
+                        y2: showOut ? out[1] : point[1],
+                        stroke: '#8381ed',
+                        strokeWidth: 1.25,
+                        strokeOpacity: 0.85,
+                        vectorEffect: 'non-scaling-stroke',
+                    });
                 // Handle dot on each end. Both drive the same `move-tangent`
                 // affordance; `side` tells it which end is being dragged so the
                 // stored OUT vector gets the correct sign.
-                children.push({
-                    kind: 'endpoint-handle',
-                    point: out,
-                    state: 'idle',
-                    variant: 'curve',
-                    affordance: 'move-tangent',
-                    payload: { fenceId: node.id, index: i, side: 'out' },
-                });
-                children.push({
-                    kind: 'endpoint-handle',
-                    point: inn,
-                    state: 'idle',
-                    variant: 'curve',
-                    affordance: 'move-tangent',
-                    payload: { fenceId: node.id, index: i, side: 'in' },
-                });
+                if (showOut)
+                    children.push({
+                        kind: 'endpoint-handle',
+                        point: out,
+                        state: 'idle',
+                        variant: 'curve',
+                        affordance: 'move-tangent',
+                        payload: { fenceId: node.id, index: i, side: 'out' },
+                    });
+                if (showIn)
+                    children.push({
+                        kind: 'endpoint-handle',
+                        point: inn,
+                        state: 'idle',
+                        variant: 'curve',
+                        affordance: 'move-tangent',
+                        payload: { fenceId: node.id, index: i, side: 'in' },
+                    });
                 // The control-point dot last so it sits on top of the tangent line.
                 children.push({
                     kind: 'endpoint-handle',
@@ -462,5 +520,7 @@ export function buildFenceFloorplan(node, ctx) {
             });
         }
     }
+    for (const feature of drafts)
+        children.push(buildFenceFeatureSymbol(feature, node, ctx, false));
     return { kind: 'group', children };
 }

package/dist/fence/geometry-parts.d.ts

@@ -0,0 +1,50 @@
+import { type FenceFeatureData, type FenceNode, type FenceWithFeatures } from '@pascal-app/core';
+import * as THREE from 'three';
+type FencePart = {
+    geometry?: THREE.BufferGeometry;
+    position: [number, number, number];
+    rotationY?: number;
+    rotationZ?: number;
+    scale: [number, number, number];
+    shape?: 'box' | 'pyramid' | 'picket';
+    picketTop?: FenceNode['picketTop'];
+    startT?: number;
+    endT?: number;
+    heightOverride?: number;
+    curveBlock?: {
+        centerY: number;
+        height: number;
+        depth: number;
+        lateralOffset: number;
+    };
+    endpoint?: 'start' | 'end';
+};
+export type FenceGateLeafGeometry = {
+    geometry: THREE.BufferGeometry;
+    hinge: {
+        x: number;
+        z: number;
+    };
+    rotationY: number;
+    openRotationY: number;
+};
+export declare function getFenceFeatureDimensions(fence: FenceNode, feature: FenceFeatureData): {
+    bottom: number;
+    height: number;
+    postBottom: number;
+    postHeight: number;
+};
+export type FenceSlotId = 'posts' | 'infill' | 'base' | 'rail';
+export type FenceSlotParts = Record<FenceSlotId, FencePart[]>;
+export type FenceCornerNeighbors = Partial<Record<'start' | 'end', FenceNode>>;
+export declare function createFenceRailHeightSampler(fence: FenceNode, heightAt: (x: number, z: number) => number): (x: number, z: number) => number;
+/**
+ * Geometry split by paint slot — posts, infill, base, rail — each a separate
+ * merged BufferGeometry (empty ones included) so the fence renderer can give
+ * each its own material + `userData.slotId`. Slots match the panel's build
+ * options 1:1.
+ */
+export declare function generateFenceSlotGeometries(fence: FenceWithFeatures, heightAt?: (x: number, z: number) => number, mode?: 'all' | 'body' | 'features', omitEndpointPosts?: ReadonlySet<'start' | 'end'>, cornerNeighbors?: FenceCornerNeighbors, gateLeafGeometries?: FenceGateLeafGeometry[]): Record<FenceSlotId, THREE.BufferGeometry>;
+export declare function generateFenceGeometry(fence: FenceNode, heightAt?: (x: number, z: number) => number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+export {};
+//# sourceMappingURL=geometry-parts.d.ts.map

package/dist/fence/geometry-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-parts.d.ts","sourceRoot":"","sources":["../../src/fence/geometry-parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,iBAAiB,EAMvB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,KAAK,SAAS,GAAG;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC,cAAc,CAAA;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAG/B,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAA;IACpC,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAA;IACtF,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAoUD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB;;;;;EAkCpF;AAmDD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAE9D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC,CAAA;AAE7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,KAAK,EAAE,SAAS,CAAC,CAAC,CAAA;AA6vB9E,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,OAhB/B,MAAM,KAAK,MAAM,YAqB7B;AAyWD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAC3C,IAAI,GAAE,KAAK,GAAG,MAAM,GAAG,UAAkB,EACzC,iBAAiB,CAAC,EAAE,WAAW,CAAC,OAAO,GAAG,KAAK,CAAC,EAChD,eAAe,CAAC,EAAE,oBAAoB,EACtC,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,GAC3C,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,cAAc,CAAC,CA4C3C;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,oFAO5C"}