@pascal-app/nodes 1.0.4 → 1.0.5

package/dist/eyebrow-vent/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,QAAA,MAAM,eAAe,mCA4HpB,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,QAAA,MAAM,eAAe,mCA4HpB,CAAA;eAEc,eAAe"}

package/dist/eyebrow-vent/tool.js

@@ -1,16 +1,16 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { EyebrowVentNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
 import { triggerSFX } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
-import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
-import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
-import { getAnalyticalNormal, getDownSlopeYaw, surfaceQuatFromNormal } from '../shared/roof-surface';
-import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
-import { eyebrowVentDefinition } from './definition';
-import EyebrowVentPreview from './preview';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview.js';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit.js';
+import { getAnalyticalNormal, getDownSlopeYaw, surfaceQuatFromNormal } from '../shared/roof-surface.js';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides.js';
+import { eyebrowVentDefinition } from './definition.js';
+import EyebrowVentPreview from './preview.js';
 const worldPoint = new THREE.Vector3();
 /**
  * Eyebrow-vent placement tool. Mounts when the palette activates the

package/dist/fence/actions/move-endpoint.d.ts

@@ -1,5 +1,5 @@
 import { type AlignmentAnchor, type AnyNodeId, type DragAction, type FenceNode, type WallNode } from '@pascal-app/core';
-import { type FencePlanPoint } from '../drafting';
+import { type FencePlanPoint } from '../drafting.js';
 type LinkedFenceSnapshot = {
     id: FenceNode['id'];
     start: FencePlanPoint;

package/dist/fence/actions/move-endpoint.js

@@ -1,6 +1,6 @@
 import { collectAlignmentAnchors, resolveAlignment, resolveFenceSupportSlabPatch, useScene, } from '@pascal-app/core';
 import { isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, useAlignmentGuides, } from '@pascal-app/editor';
-import { snapFenceDraftPoint } from '../drafting';
+import { snapFenceDraftPoint } from '../drafting.js';
 /**
  * Phase 5 Stage D — move-fence-endpoint drag affordance.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/fence/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAQf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAyIxD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/fence/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAQf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAyIxD,CAAA;eAEc,cAAc"}

package/dist/fence/definition.d.ts

@@ -1,5 +1,5 @@
 import { type FenceNode as FenceNodeType, type NodeDefinition, type SceneApi } from '@pascal-app/core';
-import { FenceNode } from './schema';
+import { FenceNode } from './schema.js';
 export declare function fenceBaseElevation(n: FenceNodeType, sceneApi?: SceneApi, point?: readonly [number, number]): number;
 /**
  * Fence — Phase 5 batch kind. Stage B complete: `def.geometry` drives

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,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,CAkJ5D,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,16 +1,16 @@
 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 { 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;
@@ -309,6 +309,21 @@ export const fenceDefinition = {
         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' }, hosting: false },
@@ -332,7 +347,7 @@ 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,
@@ -341,7 +356,7 @@ export const fenceDefinition = {
     // 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
@@ -375,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

@@ -1,4 +1,4 @@
-import { type AnyNodeId, type FenceConstructionOptions as FenceCommitOptions, FenceNode, type SceneApi, type WallNode } from '@pascal-app/core';
+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 = {
@@ -6,6 +6,12 @@ export type FenceDraftContext = {
     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[];

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

@@ -1 +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"}
+{"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

@@ -1,5 +1,6 @@
-import { DEFAULT_ANGLE_STEP, FenceNode, getFenceCenterlineLength, getFenceSplineLength, resolveFenceConstructionSupport, sampleFenceCenterline, snapPointAlongAngleRay, } from '@pascal-app/core';
+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',
@@ -56,6 +57,52 @@ export function getFenceInheritedDefaults(start, context, currentNodes = context
 }
 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];
@@ -127,7 +174,9 @@ export function snapFenceDraftPoint(args) {
     // first (mirrors `snapWallDraftPointDetailed`'s special-point pre-pass).
     if (start && angleSnap) {
         const rawTarget = magnetic &&
-            (findFenceSnapTarget(point, fences, ignoreFenceIds) ?? findWallSnapTarget(point, walls));
+            (findSurfaceSnapTarget(point) ??
+                findFenceSnapTarget(point, fences, ignoreFenceIds) ??
+                findWallSnapTarget(point, walls));
         if (rawTarget)
             return rawTarget;
     }
@@ -141,9 +190,19 @@ export function snapFenceDraftPoint(args) {
             : 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();
@@ -155,7 +214,7 @@ export function createFenceOnCurrentLevel(start, end, options, context) {
     // spacing, …) merge in first; `name`/`start`/`end` always win. The
     // schema parse validates and drops anything unexpected.
     const defaults = {
-        ...useEditor.getState().toolDefaults.fence,
+        ...getFenceDefaultsForCurrentLevel(),
         ...getFenceInheritedDefaults(start, context),
     };
     const authoredFence = FenceNode.parse({
@@ -192,7 +251,7 @@ export function createSplineFenceOnCurrentLevel(path, tangents, context) {
     }
     const fenceCount = Object.values(nodes).filter((node) => node.type === 'fence').length;
     const defaults = {
-        ...useEditor.getState().toolDefaults.fence,
+        ...getFenceDefaultsForCurrentLevel(),
         ...getFenceInheritedDefaults(start, context),
     };
     const authoredFence = FenceNode.parse({

package/dist/fence/feature-tool.js

@@ -2,7 +2,7 @@
 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';
+import { pickFenceTarget } from '../fence-feature/pick-target.js';
 export default function FenceFeatureTool({ kind }) {
     const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
     useEffect(() => {

package/dist/fence/floorplan-affordances.js

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

package/dist/fence/floorplan.js

@@ -1,5 +1,5 @@
 import { fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getWallMidpointHandlePoint, isCurvedWall, isSplineFence, resolveFenceFeatures, sampleFenceCenterline, } from '@pascal-app/core';
-import { buildFenceFeatureSymbol } from '../fence-feature/floorplan';
+import { buildFenceFeatureSymbol } from '../fence-feature/floorplan.js';
 /**
  * Stage C floor-plan builder for fence. 1:1 visual port of the legacy
  * `FloorplanFenceLayer` from `floorplan-panel.tsx`:

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAkH3E,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,GAAE,MAAM,GAAG,UAAmB,GACjC,KAAK,CAuIP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAkH3E,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,GAAE,MAAM,GAAG,UAAmB,GACjC,KAAK,CAwIP"}

package/dist/fence/geometry.js

@@ -1,8 +1,8 @@
 import { FENCE_SLOT_DEFAULTS, fenceWithFeatures, floorConstructionLift, getMaterialPresetByRef, liftedManualSlab, plateLevelContext, } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { FrontSide, Group, Mesh } from 'three';
-import { generateFenceSlotGeometries, } from './geometry-parts';
-import { resolveFenceLiftElevation } from './lift';
+import { generateFenceSlotGeometries, } from './geometry-parts.js';
+import { resolveFenceLiftElevation } from './lift.js';
 const FENCE_SLOT_ORDER = ['posts', 'infill', 'base', 'rail'];
 const fenceMaterialCache = new Map();
 function sharedFenceCorners(node, siblings) {
@@ -115,7 +115,7 @@ export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = t
         ? resolveFenceLiftElevation(node, (id) => {
             const host = ctx.resolve(id);
             return host?.type === 'slab' ? liftedManualSlab(nodes, host) : host;
-        }, startGround)
+        }, startGround, nodes)
         : 0;
     const lift = supportAt
         ? sampledStart + (node.supportOffset ?? 0)

package/dist/fence/index.d.ts

@@ -1,4 +1,4 @@
-export { fenceDefinition } from './definition';
-export { beginFenceFeaturePlacement } from './features';
-export { FenceNode } from './schema';
+export { fenceDefinition } from './definition.js';
+export { beginFenceFeaturePlacement } from './features.js';
+export { FenceNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fence/index.js

@@ -1,3 +1,3 @@
-export { fenceDefinition } from './definition';
-export { beginFenceFeaturePlacement } from './features';
-export { FenceNode } from './schema';
+export { fenceDefinition } from './definition.js';
+export { beginFenceFeaturePlacement } from './features.js';
+export { FenceNode } from './schema.js';

package/dist/fence/inspector-editors.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { clampFencePicketRailProjection, findLevelAncestorId, getClampedWallCurveOffset, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getMaxWallCurveOffset, getTwoPointFenceCurveTangents, getWallArcData, getWallCurveFrameAt, getWallCurveLength, maxFencePicketRailProjection, nodeRegistry, normalizeWallCurveOffset, sampleFenceSpline, useScene, } from '@pascal-app/core';
 import { SliderControl } from '@pascal-app/editor';
 export function FencePatternInfo({ node }) {

package/dist/fence/lift.d.ts

@@ -1,5 +1,5 @@
 import { type AnyNode } from '@pascal-app/core';
-import type { FenceNode } from './schema';
+import type { FenceNode } from './schema.js';
 /**
  * Elevation (meters above the level plane) a hosted fence stands at.
  *
@@ -21,7 +21,7 @@ import type { FenceNode } from './schema';
  * exists wins outright, so a railing on a deck pad keeps the pad's elevation
  * instead of following the hillside around it.
  */
-export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'supportSlabId' | 'supportOffset' | 'parentId'>, resolve: (id: string) => AnyNode | undefined, levelBase?: number): number;
+export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'supportSlabId' | 'supportSurfaceNodeId' | 'supportOffset' | 'parentId'>, resolve: (id: string) => AnyNode | undefined, levelBase?: number, nodes?: Record<string, AnyNode>): number;
 /**
  * {@link resolveFenceLiftElevation} against a nodes record, with the level base
  * resolved from the terrain under the fence's start point — the same anchor the
@@ -34,5 +34,5 @@ export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'support
  * using the pure form, since `GeometryContext` deliberately exposes the ground
  * as a closure rather than the store.
  */
-export declare function resolveFenceLiftElevationForNodes(node: Pick<FenceNode, 'id' | 'start' | 'supportSlabId' | 'supportOffset' | 'parentId'>, nodes: Record<string, AnyNode>): number;
+export declare function resolveFenceLiftElevationForNodes(node: Pick<FenceNode, 'id' | 'start' | 'supportSlabId' | 'supportSurfaceNodeId' | 'supportOffset' | 'parentId'>, nodes: Record<string, AnyNode>): number;
 //# sourceMappingURL=lift.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lift.d.ts","sourceRoot":"","sources":["../../src/fence/lift.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACrE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,EAC5C,SAAS,SAAI,GACZ,MAAM,CAQR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,OAAO,GAAG,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACtF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAWR"}
+{"version":3,"file":"lift.d.ts","sourceRoot":"","sources":["../../src/fence/lift.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,sBAAsB,GAAG,eAAe,GAAG,UAAU,CAAC,EAC9F,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,EAC5C,SAAS,SAAI,EACb,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,MAAM,CAiBR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,CACR,SAAS,EACT,IAAI,GAAG,OAAO,GAAG,eAAe,GAAG,sBAAsB,GAAG,eAAe,GAAG,UAAU,CACzF,EACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAYR"}

package/dist/fence/lift.js

@@ -1,4 +1,4 @@
-import { findLevelAncestorId, floorConstructionLift, levelBaseElevationAt, liftedManualSlab, } from '@pascal-app/core';
+import { findLevelAncestorId, floorConstructionLift, levelBaseElevationAt, liftedManualSlab, nodeRegistry, } from '@pascal-app/core';
 /**
  * Elevation (meters above the level plane) a hosted fence stands at.
  *
@@ -20,8 +20,17 @@ import { findLevelAncestorId, floorConstructionLift, levelBaseElevationAt, lifte
  * exists wins outright, so a railing on a deck pad keeps the pad's elevation
  * instead of following the hillside around it.
  */
-export function resolveFenceLiftElevation(node, resolve, levelBase = 0) {
+export function resolveFenceLiftElevation(node, resolve, levelBase = 0, nodes = {}) {
     const offset = node.supportOffset ?? 0;
+    if (node.supportSurfaceNodeId) {
+        const surface = resolve(node.supportSurfaceNodeId);
+        const top = surface && nodeRegistry.get(surface.type)?.capabilities?.surfaces?.top;
+        if (surface && top && surface.parentId === node.parentId) {
+            const height = typeof top.height === 'function' ? top.height(surface, { nodes }) : top.height;
+            const position = surface.position;
+            return (position?.[1] ?? 0) + height + floorConstructionLift(nodes, surface) + offset;
+        }
+    }
     if (!node.supportSlabId)
         return levelBase + offset;
     const host = resolve(node.supportSlabId);
@@ -50,5 +59,5 @@ export function resolveFenceLiftElevationForNodes(node, nodes) {
     return resolveFenceLiftElevation(node, (id) => {
         const host = nodes[id];
         return host?.type === 'slab' ? liftedManualSlab(nodes, host) : host;
-    }, levelBase + (nodes[node.id] ? floorConstructionLift(nodes, nodes[node.id]) : 0));
+    }, levelBase + (nodes[node.id] ? floorConstructionLift(nodes, nodes[node.id]) : 0), nodes);
 }

package/dist/fence/move-control-point-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAuGA,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAuGA,CAAA;eAEc,yBAAyB"}

package/dist/fence/move-endpoint-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAkBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CA0M3E,CAAA;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CA0M3E,CAAA;eAEc,qBAAqB"}

package/dist/fence/move-endpoint-tool.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, getWallCurveLength, useScene, } from '@pascal-app/core';
-import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
+import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isTypingTarget, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { moveFenceEndpointDragAction } from './actions/move-endpoint';
+import { moveFenceEndpointDragAction } from './actions/move-endpoint.js';
 function referenceSegments(walls, fences) {
     return [
         ...walls.map((w) => ({ id: w.id, start: w.start, end: w.end, curveOffset: w.curveOffset })),
@@ -153,7 +153,7 @@ export const MoveFenceEndpointTool = ({ target }) => {
     // event modifiers so the badge can toggle without a pointer move.
     useEffect(() => {
         const onKeyDown = (e) => {
-            if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement)
+            if (isTypingTarget(e.target))
                 return;
             if (e.key === 'Alt')
                 setAltPressed(true);
@@ -184,7 +184,7 @@ export const MoveFenceEndpointTool = ({ target }) => {
     const dimMidX = (liveStart[0] + liveEnd[0]) / 2;
     const dimMidZ = (liveStart[1] + liveEnd[1]) / 2;
     return (_jsxs("group", { children: [_jsx(CursorSphere, { position: cursorPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, fenceHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: fenceHeight, length: liveLength, primary: "length", thickness: target.fence.thickness ?? 0.08, unit: unit }) }), _jsx(Html, { position: cursorPos, style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
-                            ? 'border-amber-500/70 bg-amber-500/15 text-amber-100'
+                            ? 'border-amber-500/70 bg-amber-50/95 text-amber-800 dark:bg-amber-500/15 dark:text-amber-100'
                             : 'border-border/70 bg-background/90 text-foreground/80'}`, children: altPressed ? 'Detach endpoint' : 'Drag endpoint' }) }) }), angleLabel && (_jsx(Html, { center: true, position: angleLabel.position, style: { pointerEvents: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-full border border-border bg-background/95 px-2 py-1 font-mono font-semibold text-[11px] text-foreground shadow-lg backdrop-blur-md", children: angleLabel.label }) }))] }));
 };
 export default MoveFenceEndpointTool;

package/dist/fence/move-tangent-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAwGA,CAAA;AAED,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAwGA,CAAA;eAEc,oBAAoB"}

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAWf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAgSvD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAWf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAgSvD,CAAA;eAEc,aAAa"}

package/dist/fence/move-tool.js

@@ -4,7 +4,7 @@ import { constrainWallMoveDeltaToAxis, emitter, getPerpendicularWallMoveAxis, is
 import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { snapFenceDraftPoint } from './drafting';
+import { snapFenceDraftPoint } from './drafting.js';
 /**
  * Phase 5 Stage D — fence whole-move tool.
  *

package/dist/fence/paint.js

@@ -1,4 +1,4 @@
-import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint.js';
 const FENCE_SLOT_IDS = new Set(['posts', 'infill', 'base', 'rail']);
 function resolveFenceRole(args) {
     const slotId = args.hitObject?.userData?.slotId;

package/dist/fence/panel-model.js

@@ -1,4 +1,4 @@
-import { beginFenceFeaturePlacement } from './features';
+import { beginFenceFeaturePlacement } from './features.js';
 export const fencePanelModel = {
     rows() {
         return ['gate', 'opening'].map((kind) => ({

package/dist/fence/parametrics.d.ts

@@ -1,4 +1,4 @@
 import { type ParametricDescriptor } from '@pascal-app/core';
-import type { FenceNode } from './schema';
+import type { FenceNode } from './schema.js';
 export declare const fenceParametrics: ParametricDescriptor<FenceNode>;
 //# sourceMappingURL=parametrics.d.ts.map

package/dist/fence/parametrics.js

@@ -1,5 +1,5 @@
 import { clampFencePicketRailProjection, isSplineFence, } from '@pascal-app/core';
-import { FenceCurveEditor, FenceLengthEditor, FencePathEditor, FencePatternInfo, FencePicketRailProjectionEditor, FenceSurfaceEditor, } from './inspector-editors';
+import { FenceCurveEditor, FenceLengthEditor, FencePathEditor, FencePatternInfo, FencePicketRailProjectionEditor, FenceSurfaceEditor, } from './inspector-editors.js';
 export const fenceParametrics = {
     groups: [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,YAAY,YAwHjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,YAAY,YAwHjB,CAAA;eAEc,YAAY"}

package/dist/fence/system.js

@@ -2,7 +2,7 @@
 import { findLevelAncestorId, isFenceFeatureNode, nodeRegistry, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
-import { resolveFenceLiftElevationForNodes } from './lift';
+import { resolveFenceLiftElevationForNodes } from './lift.js';
 function followsSurfaces(fence) {
     return (fence.path?.length ?? 0) >= 2 || Math.abs(fence.curveOffset ?? 0) > 1e-4;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAkeA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAS7B,CAAA;AA6vBD,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAsjBA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAmC7B,CAAA;eAywBc,SAAS"}