@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/fence/definition.js

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

package/dist/fence/drafting.d.ts

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

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

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

package/dist/fence/drafting.js

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

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

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

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

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

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