@pascal-app/nodes 1.0.4 → 1.0.5

package/dist/fence/tool.js

@@ -1,22 +1,63 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, emitter, FenceNode, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, levelBaseElevationAt, resolveAlignment, sampleFenceSpline, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
-import { createSceneSupportHeightSampler, getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { CursorSphere, clearPlacementSurface, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isTypingTarget, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
+import { createSceneSupportHeightSampler, getLevelPresentationY, getSceneTheme, useViewer, } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { BufferGeometry, DoubleSide, Vector3 } from 'three';
-import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
-import { createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, getFenceInheritedDefaults, snapFenceDraftPoint, } from './drafting';
-import FenceFeatureTool from './feature-tool';
-import { createFenceRailHeightSampler, generateFenceGeometry } from './geometry-parts';
+import { BufferGeometry, DoubleSide, Plane, Raycaster, Vector2, Vector3, } from 'three';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides.js';
+import { createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, getFenceDrawingSurface, getFenceInheritedDefaults, snapFenceDraftPoint, } from './drafting.js';
+import FenceFeatureTool from './feature-tool.js';
+import { createFenceRailHeightSampler, generateFenceGeometry } from './geometry-parts.js';
 const FENCE_PREVIEW_HEIGHT = 1.8;
 const FENCE_PREVIEW_THICKNESS = 0.08;
+function FenceSurfaceSnapPoints() {
+    const hostId = useEditor((state) => state.toolDefaults.fence?.supportSurfaceNodeId);
+    const levelId = useViewer((state) => state.selection.levelId);
+    const levelMode = useViewer((state) => state.levelMode);
+    useScene((state) => (typeof hostId === 'string' ? state.nodes[hostId] : undefined));
+    useScene((state) => {
+        const surface = getFenceDrawingSurface(state.nodes, hostId, levelId, levelMode);
+        return surface ? surface.levelElevation + surface.elevation : null;
+    });
+    const surface = getFenceDrawingSurface();
+    if (!surface)
+        return null;
+    return (_jsx("group", { children: surface.boundary.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [point[0], surface.levelElevation + surface.elevation + 0.025, point[1]], renderOrder: 2, children: [_jsx("sphereGeometry", { args: [0.045, 12, 8] }), _jsx("meshBasicMaterial", { color: "#f97316", depthTest: false, transparent: true, opacity: 0.8 })] }, index))) }));
+}
 // Grid-plane surface publish (pointer-decided): scratch + constant normal so
 // per-move publishes don't allocate.
 const SURFACE_UP = new Vector3(0, 1, 0);
 const surfacePointScratch = new Vector3();
 function pointedSurfaceFor(camera, event) {
+    const surface = getFenceDrawingSurface();
+    if (surface) {
+        const buildingId = useViewer.getState().selection.buildingId;
+        const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+        const point = new Vector3(event.localPosition[0], surface.levelElevation + surface.elevation, event.localPosition[2]);
+        if (buildingMesh)
+            buildingMesh.localToWorld(point);
+        const worldY = point.y;
+        if (event.nativeEvent?.target instanceof HTMLCanvasElement) {
+            const bounds = event.nativeEvent.target.getBoundingClientRect();
+            const raycaster = new Raycaster();
+            raycaster.setFromCamera(new Vector2(((event.nativeEvent.clientX - bounds.left) / bounds.width) * 2 - 1, -((event.nativeEvent.clientY - bounds.top) / bounds.height) * 2 + 1), camera);
+            if (!raycaster.ray.intersectPlane(new Plane(SURFACE_UP, -worldY), point))
+                return null;
+        }
+        const worldPoint = [point.x, point.y, point.z];
+        if (buildingMesh)
+            buildingMesh.worldToLocal(point);
+        return {
+            elevation: surface.elevation,
+            sourceNodeId: surface.id,
+            supportSlabId: null,
+            localPoint: [point.x, point.y, point.z],
+            worldY,
+            worldPoint,
+        };
+    }
     if (event.localRay) {
         return resolvePointerSupportSurface(camera, event.position, { includeNodeTopSurfaces: true });
     }
@@ -302,17 +343,38 @@ function getCurrentLevelElements() {
         fences: children.filter((n) => n?.type === 'fence'),
     };
 }
+function dropFenceSurfaceHost() {
+    const editor = useEditor.getState();
+    const defaults = editor.toolDefaults.fence;
+    if (typeof defaults?.supportSurfaceNodeId !== 'string')
+        return;
+    const { supportSurfaceNodeId: _host, ...unhosted } = defaults;
+    editor.setToolDefaults('fence', unhosted);
+}
 export const FenceTool = () => {
+    const levelId = useViewer((state) => state.selection.levelId);
+    const levelMode = useViewer((state) => state.levelMode);
+    const hostId = useEditor((state) => state.toolDefaults.fence?.supportSurfaceNodeId);
+    const hostParentId = useScene((state) => typeof hostId === 'string' ? state.nodes[hostId]?.parentId : undefined);
+    const floorY = useScene((state) => levelId ? getLevelPresentationY(levelId, state.nodes, levelMode) : 0);
+    const draftKey = `${levelId}:${floorY}`;
+    // A surface host (a deck's railing) holds for one drawing session on its floor: leaving the
+    // floor or the tool drops it, and the fence tool draws plain fences again.
+    useEffect(() => {
+        if (typeof hostId === 'string' && hostParentId !== levelId)
+            dropFenceSurfaceHost();
+    }, [hostId, levelId, hostParentId]);
+    useEffect(() => dropFenceSurfaceHost, []);
     const fenceMode = useEditor((s) => s.continuationByContext.fence);
     const feature = useEditor((s) => s.toolDefaults.fence?.featurePlacement);
     if (feature === 'gate' || feature === 'opening')
         return _jsx(FenceFeatureTool, { kind: feature });
     if (fenceMode === 'curved') {
-        return _jsx(SplineFenceDraft, {});
+        return (_jsxs(_Fragment, { children: [_jsx(FenceSurfaceSnapPoints, {}), _jsx(SplineFenceDraft, {}, draftKey)] }));
     }
     if (fenceMode === 'freehand')
-        return _jsx(SplineFenceDraft, { freehand: true });
-    return _jsx(StraightFenceTool, {});
+        return _jsx(SplineFenceDraft, { freehand: true }, draftKey);
+    return (_jsxs(_Fragment, { children: [_jsx(FenceSurfaceSnapPoints, {}), _jsx(StraightFenceTool, {}, draftKey)] }));
 };
 const StraightFenceTool = () => {
     const { activeLevelId, sceneApi } = useRegistryToolContext();
@@ -370,6 +432,10 @@ const StraightFenceTool = () => {
         // Align the drafted point onto another object's nearest real anchor and
         // publish the guide. Returns the possibly snapped point.
         const alignPoint = (point, options) => {
+            if (getFenceDrawingSurface()) {
+                useAlignmentGuides.getState().clear();
+                return point;
+            }
             // Figma alignment lines onto existing corners / edges are DISPLAYED in
             // every mode except Off (isAlignmentGuideActive); the magnetic pull onto
             // them is applied only in 'lines' mode (isMagneticSnapActive).
@@ -474,7 +540,10 @@ const StraightFenceTool = () => {
             }
             const { walls, fences } = getCurrentLevelElements();
             const pointed = pointedSurfaceFor(cameraRef.current, event);
-            const localClick = [event.localPosition[0], event.localPosition[2]];
+            const localClick = [
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ];
             if (buildingState.current === 0) {
                 const snappedStart = alignPoint(snapFenceDraftPoint({
                     point: localClick,
@@ -660,10 +729,13 @@ const SplineFenceDraft = ({ freehand = false }) => {
         const snapPoint = (local) => {
             if (freehand)
                 return local;
-            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
-            if (step <= 0)
-                return local;
-            return [snapScalarToGrid(local[0], step), snapScalarToGrid(local[1], step)];
+            const { walls, fences } = getCurrentLevelElements();
+            return snapFenceDraftPoint({
+                point: local,
+                walls,
+                fences,
+                magnetic: isMagneticSnapActive(),
+            });
         };
         const commit = (points = draftRef.current) => {
             if (points.length >= 2) {
@@ -761,6 +833,8 @@ const SplineFenceDraft = ({ freehand = false }) => {
             setDraftPoints((prev) => [...prev, point]);
         };
         const onKeyDown = (event) => {
+            if (isTypingTarget(event.target))
+                return;
             if (event.key === 'Enter')
                 commit();
         };

package/dist/fence-feature/actions.js

@@ -4,7 +4,7 @@ import { useScene } from '@pascal-app/core';
 import { ActionMenuButton } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { DoorClosed, DoorOpen } from 'lucide-react';
-import { toggleFenceGate } from './interaction';
+import { toggleFenceGate } from './interaction.js';
 /**
  * Open/Close for a single selected gate, the door's button in the action menu.
  * Not a `mechanism`: a gate's open angle is saved on the node, and mechanisms

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACb,gBAAgB,EAGhB,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAuDzB,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,GAAG,OAAO,gBAAgB,CA4B9F,CAAA;AAyBD,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAgB/C,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACb,gBAAgB,EAGhB,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AA2DzB,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,GAAG,OAAO,gBAAgB,CA4B9F,CAAA;AAyBD,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAgB/C,CAAA"}

package/dist/fence-feature/definition.js

@@ -1,13 +1,13 @@
 import { FenceGateNode, FenceOpeningNode, findLevelAncestorId, } from '@pascal-app/core';
 import { useViewer } from '@pascal-app/viewer';
 import { AnimationClip, QuaternionKeyframeTrack } from 'three';
-import { buildFenceFeatureFloorplan } from './floorplan';
-import { fenceFeatureAffordance } from './floorplan-affordances';
-import { buildFenceFeatureGeometry } from './geometry';
-import { fenceFeatureHandles } from './handles';
-import { FenceFeatureEditor } from './inspector';
-import { toggleFenceGate } from './interaction';
-import { createFenceFeatureMoveSession } from './move-session';
+import { buildFenceFeatureFloorplan } from './floorplan.js';
+import { fenceFeatureAffordance } from './floorplan-affordances.js';
+import { buildFenceFeatureGeometry } from './geometry.js';
+import { fenceFeatureHandles } from './handles.js';
+import { FenceFeatureEditor } from './inspector.js';
+import { toggleFenceGate } from './interaction.js';
+import { createFenceFeatureMoveSession } from './move-session.js';
 const floorplanMoveTarget = ({ node, sceneApi }) => {
     if (!sceneApi)
         throw new Error('Fence feature move requires SceneApi');
@@ -31,14 +31,18 @@ const parametrics = {
 const shared = {
     schemaVersion: 1,
     category: 'structure',
-    capabilities: { selectable: { hitVolume: 'bbox' }, deletable: true },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+    },
     geometry: buildFenceFeatureGeometry,
     floorplan: buildFenceFeatureFloorplan,
     floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
     floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
     handles: fenceFeatureHandles,
     floorplanMoveTarget,
-    affordanceTools: { move: () => import('./move-tool') },
+    affordanceTools: { move: () => import('./move-tool.js') },
     affordanceHints: {
         move: [
             { key: 'Left click', label: 'Place on a fence' },
@@ -59,7 +63,7 @@ export const fenceGateDefinition = {
     schema: FenceGateNode,
     extensions: {
         'pascal:editor/floorplan': {
-            actionMenu: { actions: () => import('./actions') },
+            actionMenu: { actions: () => import('./actions.js') },
         },
     },
     exportAnimation: ({ node, object }) => node.type === 'fence-gate' ? bakeFenceGateClip(node.id, object) : null,

package/dist/fence-feature/geometry.js

@@ -1,7 +1,7 @@
 import { fenceFeatureData, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceGateLeaves, } from '@pascal-app/core';
 import { BoxGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial } from 'three';
-import { buildFenceGeometry } from '../fence/geometry';
-import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+import { buildFenceGeometry } from '../fence/geometry.js';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
 export function buildFenceFeatureGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
     const host = ctx?.parent;
     if (host?.type !== 'fence')

package/dist/fence-feature/handles.js

@@ -1,6 +1,6 @@
 import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, projectPointToFence, } from '@pascal-app/core';
-import { fenceBaseElevation } from '../fence/definition';
-import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+import { fenceBaseElevation } from '../fence/definition.js';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
 export function featureHost(node, scene) {
     const parent = node.parentId ? scene.get(node.parentId) : undefined;
     return parent?.type === 'fence' ? parent : undefined;

package/dist/fence-feature/inspector.js

@@ -4,7 +4,7 @@ import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures,
 import { ActionButton, SliderControl, ToggleControl } from '@pascal-app/editor';
 import { useState } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
 export function FenceFeatureEditor({ node: child, onUpdate, }) {
     const [error, setError] = useState('');
     const parentId = child.parentId;
@@ -188,13 +188,13 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                                     matchFenceHeight: checked,
                                     height,
                                     ...(gate ? { clearance: bottom } : {}),
-                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: ["Gate style", _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
+                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: ["Gate style", _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
                                             const style = FenceStyle.safeParse(event.currentTarget.value);
                                             if (style.success)
                                                 update(feature.id, { style: style.data });
                                         }, children: [_jsx("option", { value: "picket", children: "Picket" }), _jsx("option", { value: "slat", children: "Vertical slats" }), _jsx("option", { value: "horizontal", children: "Horizontal boards" }), _jsx("option", { value: "privacy", children: "Solid privacy" }), _jsx("option", { value: "rail", children: "Open rails" })] })] })), selects
                                 .filter((field) => field.key !== 'hinge' || feature.leafType !== 'double')
-                                .map((field) => (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [field.label, _jsx("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: field.value, onChange: (event) => update(feature.id, { [field.key]: event.target.value }), children: field.options.map(([value, label]) => (_jsx("option", { value: value, children: label }, value))) })] }, field.key))), numbers
+                                .map((field) => (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [field.label, _jsx("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: field.value, onChange: (event) => update(feature.id, { [field.key]: event.target.value }), children: field.options.map(([value, label]) => (_jsx("option", { value: value, children: label }, value))) })] }, field.key))), numbers
                                 .filter((field) => feature.matchFenceStyle === false ||
                                 !['thickness', 'frameWidth', 'spacing', 'boardWidth'].includes(field.key))
                                 .map((field) => (_jsx(SliderControl, { label: field.label, value: field.value, min: field.min, max: field.max, step: field.step, precision: field.key === 'openAngle' ? 0 : 3, unit: field.unit, onChange: (value) => update(feature.id, {

package/dist/fence-feature/move-session.d.ts

@@ -1,8 +1,8 @@
 import { type AnyNodeId, type FenceFeatureNode, type FenceNode, type GridEvent, type SceneApi } from '@pascal-app/core';
 export declare function createFenceFeatureMoveSession(node: FenceFeatureNode, sceneApi: SceneApi, levelId: AnyNodeId | null, selectNode: (id: AnyNodeId) => void): {
-    affectedIds: (`roof_${string}` | `rseg_${string}` | `site_${string}` | `building_${string}` | `level_${string}` | `elevator_${string}` | `unit_${string}` | `zone_${string}` | `block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `slab_${string}` | `separator_${string}` | `floor-opening_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `cabinet_${string}` | `cabinet-module_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`)[];
+    affectedIds: (`block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
     clear: () => void;
-    update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent["localRay"]): void;
+    update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent['localRay']): void;
     canCommit: () => boolean;
     commit(): void;
 };

package/dist/fence-feature/move-session.js

@@ -1,5 +1,5 @@
 import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, useLiveNodeOverrides, } from '@pascal-app/core';
-import { pickFenceTarget } from './pick-target';
+import { pickFenceTarget } from './pick-target.js';
 export function createFenceFeatureMoveSession(node, sceneApi, levelId, selectNode) {
     const affectedIds = [node.id];
     if (node.parentId)

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

@@ -2,7 +2,7 @@
 import { emitter } from '@pascal-app/core';
 import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, useRegistryToolContext, } from '@pascal-app/editor';
 import { useEffect } from 'react';
-import { createFenceFeatureMoveSession } from './move-session';
+import { createFenceFeatureMoveSession } from './move-session.js';
 export default function MoveFenceFeatureTool({ node }) {
     const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
     useEffect(() => {

package/dist/floor-opening/definition.js

@@ -1,5 +1,5 @@
 import { FloorOpeningNode } from '@pascal-app/core';
-import { buildFloorOpeningFloorplan, floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan';
+import { buildFloorOpeningFloorplan, floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan.js';
 export const floorOpeningDefinition = {
     kind: 'floor-opening',
     bake: 'strip',

package/dist/floor-opening/floorplan.d.ts

@@ -7,150 +7,150 @@ import type { FloorOpeningNode, FloorplanGeometry, GeometryContext } from '@pasc
 export declare function buildFloorOpeningFloorplan(node: FloorOpeningNode, ctx: GeometryContext): FloorplanGeometry | null;
 export declare const floorOpeningMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
-    metadata: Record<string, unknown>;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    source: string;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-    name?: string | undefined;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
-        mode: "perspective" | "orthographic";
+        mode: "orthographic" | "perspective";
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    metadata: Record<string, unknown>;
     provenance?: {
         refs: {
-            id: string;
             ns?: string | undefined;
-            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
         }[];
         lineage?: {
-            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
             fromIds: string[];
         } | undefined;
     } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
     hostZoneId?: string | undefined;
     legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
     legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
     ownerId?: string | undefined;
     surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
 }>;
 export declare const floorOpeningAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
-    metadata: Record<string, unknown>;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    source: string;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-    name?: string | undefined;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
-        mode: "perspective" | "orthographic";
+        mode: "orthographic" | "perspective";
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    metadata: Record<string, unknown>;
     provenance?: {
         refs: {
-            id: string;
             ns?: string | undefined;
-            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
         }[];
         lineage?: {
-            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
             fromIds: string[];
         } | undefined;
     } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
     hostZoneId?: string | undefined;
     legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
     legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
     ownerId?: string | undefined;
     surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
 }>;
 export declare const floorOpeningMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
-    metadata: Record<string, unknown>;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    source: string;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-    name?: string | undefined;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
-        mode: "perspective" | "orthographic";
+        mode: "orthographic" | "perspective";
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    metadata: Record<string, unknown>;
     provenance?: {
         refs: {
-            id: string;
             ns?: string | undefined;
-            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
         }[];
         lineage?: {
-            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
             fromIds: string[];
         } | undefined;
     } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
     hostZoneId?: string | undefined;
     legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
     legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
     ownerId?: string | undefined;
     surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
 }>;
 export declare const floorOpeningDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
-    metadata: Record<string, unknown>;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    source: string;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-    name?: string | undefined;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
-        mode: "perspective" | "orthographic";
+        mode: "orthographic" | "perspective";
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    metadata: Record<string, unknown>;
     provenance?: {
         refs: {
-            id: string;
             ns?: string | undefined;
-            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
         }[];
         lineage?: {
-            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
             fromIds: string[];
         } | undefined;
     } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
     hostZoneId?: string | undefined;
     legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
     legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
     ownerId?: string | undefined;
     surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
 }>;
 //# sourceMappingURL=floorplan.d.ts.map

package/dist/floor-opening/floorplan.js

@@ -1,4 +1,4 @@
-import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance';
+import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance.js';
 const COLOR = '#f59e0b';
 /**
  * A floor opening on the plan: a dashed amber outline (the void the surfaces

package/dist/guide/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { GuideNode } from './schema';
+import { GuideNode } from './schema.js';
 /**
  * Guide — Stage A. Measurement reference annotations placed by the
  * user (linear / area / arc). `GuideSystem` handles per-frame

package/dist/guide/definition.js

@@ -1,6 +1,6 @@
 import { GuideNode as GuideNodeSchema } from '@pascal-app/core';
-import { guideParametrics } from './parametrics';
-import { GuideNode } from './schema';
+import { guideParametrics } from './parametrics.js';
+import { GuideNode } from './schema.js';
 /**
  * Guide — Stage A. Measurement reference annotations placed by the
  * user (linear / area / arc). `GuideSystem` handles per-frame
@@ -34,10 +34,10 @@ export const guideDefinition = {
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 5,
     },
     presentation: {

package/dist/guide/index.d.ts

@@ -1,2 +1,2 @@
-export { guideDefinition } from './definition';
+export { guideDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/guide/index.js

@@ -1 +1 @@
-export { guideDefinition } from './definition';
+export { guideDefinition } from './definition.js';

package/dist/guide/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/guide/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,kBAAkB,CAAA;AAQ9D,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAqB1D,CAAA;AAwDD,eAAe,aAAa,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/guide/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,kBAAkB,CAAA;AAQ9D,eAAO,MAAM,aAAa,aAAc;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAqB1D,CAAA;eAwDc,aAAa"}

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/guide/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/guide/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;eAEjC,WAAW"}

package/dist/gutter/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { GutterNode } from './schema';
+import { GutterNode } from './schema.js';
 /**
  * Gutter — a rain-water channel running along the eave of a roof
  * segment. Parented to a `roof-segment`; position is segment-local.

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA+D9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgE9D,CAAA"}