@pascal-app/nodes 1.0.3 → 1.0.5

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

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

package/dist/fence/definition.js

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

package/dist/fence/drafting.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"drafting.d.ts","sourceRoot":"","sources":["../../src/fence/drafting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,wBAAwB,IAAI,kBAAkB,EACnD,SAAS,EAMT,KAAK,QAAQ,EAIb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAG3B,MAAM,MAAM,cAAc,GAAG,aAAa,CAAA;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;CAC1B,CAAA;AAuCD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,iBAAiB,EAC1B,YAAY,GAAE,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA4B,GACrE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAiB3B;AAKD,wBAAgB,sBAAsB,CACpC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAA6B,EAC1D,EAAE,UAAgE,EAClE,OAAO,2BAAyC,EAChD,SAAS,6CAAiC;;;;;SAe3C;AAoHD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,EAAE,cAAc,CAAA;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,cAAc,CAAA;CACrD,GAAG,cAAc,CA8CjB;AASD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,kBAAkB,GAAG,SAAS,EACvC,OAAO,EAAE,iBAAiB,GACzB,SAAS,GAAG,IAAI,CA8BlB;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,cAAc,EAAE,EACtB,QAAQ,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,SAAS,EAC3C,OAAO,EAAE,iBAAiB,GACzB,SAAS,GAAG,IAAI,CAkClB"}

package/dist/fence/drafting.js

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

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

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

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

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