@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/stair/floor-stack.js

@@ -1,9 +1,47 @@
 export function getStairFloorPlacedFootprints(stair, nodes) {
+    if ((stair.stairType ?? 'straight') !== 'straight') {
+        return getArcStairFloorPlacedFootprints(stair);
+    }
     const segments = (stair.children ?? [])
         .map((childId) => nodes[childId])
         .filter((node) => node?.type === 'stair-segment');
     return getStairSegmentFloorPlacedFootprints(stair, segments);
 }
+const MAX_ARC_FOOTPRINT_SWEEP = Math.PI / 12;
+function getArcStairFloorPlacedFootprints(stair) {
+    const isSpiral = stair.stairType === 'spiral';
+    const innerRadius = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
+    const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4);
+    const sweepAngle = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
+    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
+    const sliceCount = Math.max(stepCount, Math.ceil(Math.abs(sweepAngle) / MAX_ARC_FOOTPRINT_SWEEP));
+    const footprints = [];
+    for (let index = 0; index < sliceCount; index += 1) {
+        const startAngle = -sweepAngle / 2 + (sweepAngle * index) / sliceCount;
+        const endAngle = -sweepAngle / 2 + (sweepAngle * (index + 1)) / sliceCount;
+        const midAngle = (startAngle + endAngle) / 2;
+        const halfSweep = Math.abs(endAngle - startAngle) / 2;
+        const projectedInnerRadius = innerRadius * Math.cos(halfSweep);
+        const radialSize = outerRadius - projectedInnerRadius;
+        const tangentialSize = 2 * outerRadius * Math.sin(halfSweep);
+        const centerRadius = (outerRadius + projectedInnerRadius) / 2;
+        const [offsetX, offsetZ] = rotateXZ(Math.cos(midAngle) * centerRadius, Math.sin(midAngle) * centerRadius, stair.rotation);
+        footprints.push({
+            position: [stair.position[0] + offsetX, stair.position[1], stair.position[2] + offsetZ],
+            dimensions: [Math.max(radialSize, 0.01), 0.01, Math.max(tangentialSize, 0.01)],
+            rotation: [0, midAngle - stair.rotation, 0],
+        });
+    }
+    if (isSpiral && (stair.showCenterColumn ?? true)) {
+        const columnRadius = Math.max(0.05, Math.min(innerRadius * 0.72, innerRadius - 0.03));
+        footprints.push({
+            position: stair.position,
+            dimensions: [columnRadius * 2, 0.01, columnRadius * 2],
+            rotation: [0, 0, 0],
+        });
+    }
+    return footprints;
+}
 export function getStairSegmentFloorPlacedFootprints(stair, segments) {
     const transforms = computeStairSegmentFloorStackTransforms(segments);
     return segments.map((segment, index) => {

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAuCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CA+BjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CA8BlE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA6BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CA4C3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA8BhE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA6CrE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAiCjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CAgClE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA+BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CAiD3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAgChE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CAkDrE,CAAA"}

package/dist/stair/floorplan-affordances.js

@@ -1,4 +1,5 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 // Minimums + max sweep mirror the 3D handles in
 // `packages/editor/src/components/editor/stair-segment-handles.tsx` so a 2D
@@ -47,12 +48,14 @@ export const segmentWidthAffordance = {
                 const delta = sign * (currentProj - initialProj);
                 const newWidth = Math.max(MIN_SEGMENT_WIDTH, initialWidth + delta);
                 lastWidth = newWidth;
-                useScene.getState().updateNode(segmentNodeId, { width: newWidth });
+                useLiveNodeOverrides.getState().set(segmentNodeId, { width: newWidth });
+                useScene.getState().markDirty(segmentNodeId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(segmentNodeId);
                 useScene.getState().updateNode(segmentNodeId, { width: lastWidth });
             },
         };
@@ -83,12 +86,14 @@ export const segmentLengthAffordance = {
                 const delta = currentProj - initialProj;
                 const newLength = Math.max(MIN_SEGMENT_LENGTH, initialLength + delta);
                 lastLength = newLength;
-                useScene.getState().updateNode(segmentNodeId, { length: newLength });
+                useLiveNodeOverrides.getState().set(segmentNodeId, { length: newLength });
+                useScene.getState().markDirty(segmentNodeId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(segmentNodeId);
                 useScene.getState().updateNode(segmentNodeId, { length: lastLength });
             },
         };
@@ -118,12 +123,14 @@ export const curvedStairWidthAffordance = {
                 const currentRadial = (planPoint[0] - cx) * radialX + (planPoint[1] - cz) * radialZ;
                 const newWidth = Math.max(MIN_CURVED_WIDTH, initialWidth + (currentRadial - initialRadial));
                 lastWidth = newWidth;
-                useScene.getState().updateNode(stairId, { width: newWidth });
+                useLiveNodeOverrides.getState().set(stairId, { width: newWidth });
+                useScene.getState().markDirty(stairId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(stairId);
                 useScene.getState().updateNode(stairId, { width: lastWidth });
             },
         };
@@ -162,12 +169,17 @@ export const curvedStairInnerRadiusAffordance = {
                 const newWidth = initialOuterRadius - newInner;
                 lastInner = newInner;
                 lastWidth = newWidth;
-                useScene.getState().updateNode(stairId, { innerRadius: newInner, width: newWidth });
+                useLiveNodeOverrides.getState().set(stairId, {
+                    innerRadius: newInner,
+                    width: newWidth,
+                });
+                useScene.getState().markDirty(stairId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(stairId);
                 useScene.getState().updateNode(stairId, { innerRadius: lastInner, width: lastWidth });
             },
         };
@@ -193,21 +205,23 @@ export const stairRotateAffordance = {
         let lastRotation = initialRotation;
         return {
             affectedIds: [stairId],
-            apply({ planPoint, modifiers }) {
+            apply({ planPoint }) {
                 const delta = rotateAffordanceDelta({
                     center: [cx, cz],
                     initialAngle,
                     planPoint,
-                    free: modifiers.shiftKey,
+                    free: !isAngleSnapActive(),
                 });
                 const newRotation = initialRotation - delta;
                 lastRotation = newRotation;
-                useScene.getState().updateNode(stairId, { rotation: newRotation });
+                useLiveNodeOverrides.getState().set(stairId, { rotation: newRotation });
+                useScene.getState().markDirty(stairId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(stairId);
                 useScene.getState().updateNode(stairId, { rotation: lastRotation });
             },
         };
@@ -253,12 +267,17 @@ export const curvedStairSweepAffordance = {
                 const newRotation = initialRotation + rotationShift;
                 lastSweep = newSweep;
                 lastRotation = newRotation;
-                useScene.getState().updateNode(stairId, { sweepAngle: newSweep, rotation: newRotation });
+                useLiveNodeOverrides.getState().set(stairId, {
+                    sweepAngle: newSweep,
+                    rotation: newRotation,
+                });
+                useScene.getState().markDirty(stairId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(stairId);
                 useScene.getState().updateNode(stairId, { sweepAngle: lastSweep, rotation: lastRotation });
             },
         };

package/dist/stair/floorplan-move.d.ts

@@ -5,13 +5,11 @@ import { type FloorplanMoveTarget, type StairNode } from '@pascal-app/core';
  * Existing stairs preserve the cursor grab offset, matching the 3D move
  * tools; fresh catalog placement follows the cursor absolutely.
  *
- * Figma alignment is layered on the stair footprint edges; Alt bypasses.
+ * Figma alignment is layered on the stair footprint edges.
  * Guides are cleared by `FloorplanRegistryMoveOverlay`'s Path 1 teardown.
  *
- * The position is written straight to scene each tick (the stair has a real
- * `position` field, unlike polygon kinds) and re-applied atomically via
- * `commit()` so the overlay's deterministic revert → resume → commit path
- * records a single undo step (same pattern door / window use).
+ * The position previews through the live override store and is written to
+ * scene once via `commit()`.
  */
 export declare const stairFloorplanMoveTarget: FloorplanMoveTarget<StairNode>;
 //# sourceMappingURL=floorplan-move.d.ts.map

package/dist/stair/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAIzB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAoDnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAoDnE,CAAA"}

package/dist/stair/floorplan-move.js

@@ -1,5 +1,5 @@
-import { collectAlignmentAnchors, movingAlignmentAnchors, snapScalar, useScene, } from '@pascal-app/core';
-import { applyFloorplanAlignment, getSegmentGridStep } from '@pascal-app/editor';
+import { collectAlignmentAnchors, movingAlignmentAnchors, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { applyFloorplanAlignment, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 /**
  * 2D floor-plan move handler for stair.
@@ -7,13 +7,11 @@ import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
  * Existing stairs preserve the cursor grab offset, matching the 3D move
  * tools; fresh catalog placement follows the cursor absolutely.
  *
- * Figma alignment is layered on the stair footprint edges; Alt bypasses.
+ * Figma alignment is layered on the stair footprint edges.
  * Guides are cleared by `FloorplanRegistryMoveOverlay`'s Path 1 teardown.
  *
- * The position is written straight to scene each tick (the stair has a real
- * `position` field, unlike polygon kinds) and re-applied atomically via
- * `commit()` so the overlay's deterministic revert → resume → commit path
- * records a single undo step (same pattern door / window use).
+ * The position previews through the live override store and is written to
+ * scene once via `commit()`.
  */
 export const stairFloorplanMoveTarget = ({ node, nodes }) => {
     const startY = node.position[1];
@@ -26,24 +24,23 @@ export const stairFloorplanMoveTarget = ({ node, nodes }) => {
     let lastValid = null;
     const session = {
         affectedIds: [node.id],
-        apply({ planPoint, modifiers }) {
-            // Snap the origin to the editor's current grid step (driven by
-            // `useEditor.gridSnapStep`). Shift bypasses the grid snap.
-            const step = getSegmentGridStep();
-            const snap = (value) => (modifiers.shiftKey ? value : snapScalar(value, step));
+        apply({ planPoint }) {
+            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
+            const snap = (value) => (step > 0 ? snapScalar(value, step) : value);
             const [gx, gz] = resolveCursor(planPoint, { snap });
-            // Figma alignment on the actual stair footprint (Alt bypasses alignment; Shift all snap),
-            // matching the 3D move tool. Publishes guides via `useAlignmentGuides`.
+            // Figma alignment on the actual stair footprint, matching the 3D move
+            // tool. Publishes guides via `useAlignmentGuides`.
             const movingAnchors = movingAlignmentAnchors(node, nodes, gx, gz, node.rotation ?? 0);
             const { point: aligned } = applyFloorplanAlignment([gx, gz], movingAnchors.length > 0
                 ? movingAnchors
-                : [{ nodeId: node.id, kind: 'corner', x: gx, z: gz }], candidates, { bypass: modifiers.altKey || modifiers.shiftKey });
+                : [{ nodeId: node.id, kind: 'corner', x: gx, z: gz }], candidates, { applySnap: isMagneticSnapActive() });
             const sx = aligned[0];
             const sz = aligned[1];
             if (lastValid && lastValid.position[0] === sx && lastValid.position[2] === sz)
                 return;
             lastValid = { position: [sx, startY, sz] };
-            useScene.getState().updateNodes([{ id: node.id, data: lastValid }]);
+            useLiveNodeOverrides.getState().set(node.id, lastValid);
+            useScene.getState().markDirty(node.id);
         },
         canCommit() {
             // No overlap / placement rules for stairs in 2D — any pointer-up
@@ -57,6 +54,7 @@ export const stairFloorplanMoveTarget = ({ node, nodes }) => {
             // door / window use.
             if (!lastValid)
                 return;
+            useLiveNodeOverrides.getState().clear(node.id);
             useScene.getState().updateNodes([{ id: node.id, data: lastValid }]);
         },
     };

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,SAAS,EAEV,MAAM,kBAAkB,CAAA;AAgBzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAib1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,SAAS,EAEV,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAoc1B"}

package/dist/stair/floorplan.js

@@ -3,7 +3,8 @@
 // `definition.ts` so the 2D handle visually lines up with where the 3D
 // curved-arrow gizmo would sit at the matching world point.
 const STAIR_ROTATE_PLAN_OFFSET = 0.4;
-import { buildFloorplanStairEntry, buildSvgAnnularSectorPath, buildSvgArcPath, buildSvgArrowHeadPoints, getArcPlanPoint, } from '@pascal-app/editor';
+import { buildFloorplanStairEntry, buildSvgAnnularSectorPath, buildSvgArcPath, buildSvgArrowHeadPoints, floorplanGeometryMetadata, getArcPlanPoint, } from '@pascal-app/editor';
+import { buildStairDocumentation, resolveStairPlanDirection, resolveStraightStairDirectionArrow, stairPlanBreakStep, } from './documentation';
 /**
  * Stage C floor-plan emitter for stair. The stair is the parent; its
  * children are the `stair-segment`s whose transforms are *cumulative*
@@ -79,7 +80,11 @@ export function buildStairFloorplan(stair, ctx) {
             // Tread bars — one per visible step inside the segment.
             // `buildFloorplanStairEntry` already returns the thickened
             // polygons; we emit them as filled polygons.
-            for (const treadBar of segmentEntry.treadBars) {
+            const breakStep = stairPlanBreakStep(segmentEntry.segment.stepCount);
+            for (let treadIndex = 0; treadIndex < segmentEntry.treadBars.length; treadIndex += 1) {
+                if (treadIndex + 1 >= breakStep)
+                    continue;
+                const treadBar = segmentEntry.treadBars[treadIndex];
                 children.push({
                     kind: 'polygon',
                     points: toFloorplanPoints(treadBar),
@@ -216,10 +221,10 @@ export function buildStairFloorplan(stair, ctx) {
         const stepBase = stairType === 'spiral' ? 6 : 4;
         const stepCount = Math.max(stepBase, Math.round(stair.stepCount ?? 10));
         const stepSweep = normalizedSweepAngle / stepCount;
-        // For spirals only: the last ~32% of the sweep is dashed (matches
-        // the legacy `dashedFromIndex = Math.floor(stepCount * 0.68)`).
-        const dashedFromIndex = stairType === 'spiral' ? Math.floor(stepCount * 0.68) : Infinity;
+        const breakStep = stairPlanBreakStep(stepCount);
         for (let index = 0; index <= stepCount; index += 1) {
+            if (index >= breakStep && index !== stepCount)
+                continue;
             const angle = sectorStartAngle + stepSweep * index;
             const inner = getArcPlanPoint(stairCenter, innerRadius, angle);
             const outer = getArcPlanPoint(stairCenter, outerRadius, angle);
@@ -228,8 +233,7 @@ export function buildStairFloorplan(stair, ctx) {
             // Curved: regular stroke everywhere, but both the starting and the
             // ending step lines are bolded (matches the legacy
             // `<FloorplanStairLayer>` curved branch).
-            // Spiral: only the last step is accented + bolded; intermediate
-            // steps past `dashedFromIndex` are dashed.
+            // Spiral: only the last step is accented + bolded.
             const isEmphasised = stairType === 'spiral' ? isLast : isFirst || isLast;
             const stepWidth = stairType === 'spiral' ? (isEmphasised ? 1.8 : 1.15) : isEmphasised ? 1.5 : 1.1;
             children.push({
@@ -240,7 +244,6 @@ export function buildStairFloorplan(stair, ctx) {
                 y2: outer.y,
                 stroke: stairType === 'spiral' && isLast ? stairAccent : stairStroke,
                 strokeWidth: stepWidth,
-                strokeDasharray: index >= dashedFromIndex && !isLast ? '0.1 0.08' : undefined,
                 vectorEffect: 'non-scaling-stroke',
             });
         }
@@ -273,9 +276,13 @@ export function buildStairFloorplan(stair, ctx) {
             });
         }
         // 6. Direction arrow — head only, at the upper end of the sweep.
-        const arrowAngle = visualSectorEndAngle - stepSweep * 0.8;
+        const direction = resolveStairPlanDirection(stair, ctx.parent?.type === 'level' ? ctx.parent.id : stair.parentId);
+        const arrowAngle = direction === 'up'
+            ? visualSectorEndAngle - stepSweep * 0.8
+            : sectorStartAngle + stepSweep * 0.8;
         const arrowPoint = getArcPlanPoint(stairCenter, centerlineRadius, arrowAngle);
-        const tangentAngle = arrowAngle + (normalizedSweepAngle >= 0 ? Math.PI / 2 : -Math.PI / 2);
+        const sweepDirection = normalizedSweepAngle >= 0 ? 1 : -1;
+        const tangentAngle = arrowAngle + sweepDirection * (direction === 'up' ? Math.PI / 2 : -Math.PI / 2);
         const arrowSize = clamp(stair.width * (stairType === 'spiral' ? 0.18 : 0.16), 0.1, 0.18);
         const headPts = buildSvgArrowHeadPoints(arrowPoint, tangentAngle, arrowSize);
         children.push({
@@ -283,6 +290,7 @@ export function buildStairFloorplan(stair, ctx) {
             points: headPts.map((p) => [p.x, p.y]),
             fill: stairAccent,
             stroke: 'none',
+            metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
         });
         // 7. Resize arrows — mirror of the 3D `CurvedStairWidthArrow`,
         //    `CurvedStairInnerRadiusArrow`, and two `CurvedStairSweepArrow`s.
@@ -344,28 +352,33 @@ export function buildStairFloorplan(stair, ctx) {
     // the stair-segment chain in straight space and produces a malformed
     // polyline once the chain is laid around an arc.
     if (stairType === 'straight' && entry.arrow) {
-        if (entry.arrow.polyline.length >= 2) {
+        const direction = resolveStairPlanDirection(stair, ctx.parent?.type === 'level' ? ctx.parent.id : stair.parentId);
+        const directionArrow = resolveStraightStairDirectionArrow(entry, direction);
+        if (directionArrow && directionArrow.polyline.length >= 2) {
             children.push({
                 kind: 'polyline',
-                points: toFloorplanPoints(entry.arrow.polyline),
+                points: toFloorplanPoints(directionArrow.polyline),
                 fill: 'none',
                 stroke: stairAccent,
                 strokeWidth: 0.02,
                 strokeLinecap: 'round',
                 strokeLinejoin: 'round',
                 opacity: showSelectedChrome ? 0.92 : 0.72,
+                metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
             });
         }
-        if (entry.arrow.head.length >= 3) {
+        if (directionArrow && directionArrow.head.length >= 3) {
             children.push({
                 kind: 'polygon',
-                points: toFloorplanPoints(entry.arrow.head),
+                points: toFloorplanPoints(directionArrow.head),
                 fill: stairAccent,
                 stroke: 'none',
                 opacity: showSelectedChrome ? 0.92 : 0.72,
+                metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
             });
         }
     }
+    children.push(...buildStairDocumentation(stair, entry, ctx));
     // Whole-stair rotation handle — sister to the 3D `stairRotateHandle`
     // (arc-resize, curved-arrow). 2D doesn't have a dedicated curved-arrow
     // primitive, so we emit a `move-arrow` with the `'stair-rotate'`

package/dist/stair/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair/panel.tsx"],"names":[],"mappings":"AA6DA,MAAM,CAAC,OAAO,UAAU,UAAU,uCA6fjC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair/panel.tsx"],"names":[],"mappings":"AAoEA,MAAM,CAAC,OAAO,UAAU,UAAU,uCAskBjC"}

package/dist/stair/panel.js

@@ -1,11 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { StairSegmentNode as StairSegmentNodeSchema, useScene, } from '@pascal-app/core';
+import { resolveStairTotalRise, StairSegmentNode as StairSegmentNodeSchema, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE, duplicateStairSubtree, getStairLevelOptions, MetricControl, PanelSection, PanelWrapper, resolveStairDestinationLevel, resolveStairFromLevelId, resolveStairToLevelId, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useMemo } from 'react';
 import { useShallow } from 'zustand/react/shallow';
+import { getStairDestinationUpdates } from './destination';
 const RAILING_MODE_OPTIONS = [
     { label: 'None', value: 'none' },
     { label: 'Left', value: 'left' },
@@ -25,6 +26,9 @@ const STAIR_SLAB_OPENING_OPTIONS = [
     { label: 'None', value: 'none' },
     { label: 'Destination', value: 'destination' },
 ];
+// Slabs at least this high off the storey floor read as decks (mezzanines) —
+// lower slabs are floor coverings, never useful stair destinations.
+const DECK_DESTINATION_MIN_ELEVATION = 0.5;
 export default function StairPanel() {
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const selectedCount = useViewer((s) => s.selection.selectedIds.length);
@@ -35,6 +39,23 @@ export default function StairPanel() {
     const nodes = useScene((s) => s.nodes);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
     const levels = useMemo(() => (node?.type === 'stair' ? getStairLevelOptions(nodes, node) : []), [node, nodes]);
+    const candidateDecks = useMemo(() => {
+        if (node?.type !== 'stair')
+            return [];
+        const level = node.parentId ? nodes[node.parentId] : undefined;
+        if (level?.type !== 'level')
+            return [];
+        const decks = [];
+        for (const childId of level.children) {
+            const child = nodes[childId];
+            if (child?.type !== 'slab')
+                continue;
+            if (child.id === node.deckSlabId || child.elevation >= DECK_DESTINATION_MIN_ELEVATION) {
+                decks.push(child);
+            }
+        }
+        return decks;
+    }, [node, nodes]);
     const segments = useScene(useShallow((s) => {
         if (!selectedId)
             return [];
@@ -83,6 +104,12 @@ export default function StairPanel() {
             toLevelId: plan?.toLevel.id ?? fromLevelId,
         });
     }, [handleUpdate]);
+    const handleDestinationChange = useCallback((value) => {
+        if (!node)
+            return;
+        const target = useScene.getState().nodes[value];
+        handleUpdate(getStairDestinationUpdates(node, target, value));
+    }, [node, handleUpdate]);
     const getLastSegmentFillDefaults = useCallback(() => {
         if (!node)
             return { fillToFloor: true };
@@ -166,13 +193,19 @@ export default function StairPanel() {
         return null;
     const resolvedFromLevelId = resolveStairFromLevelId(nodes, node, levels);
     const resolvedToLevelId = resolveStairToLevelId(nodes, node, resolvedFromLevelId, levels);
+    const deckNode = node.deckSlabId ? nodes[node.deckSlabId] : undefined;
+    const attachedDeck = deckNode?.type === 'slab' ? deckNode : undefined;
+    const resolvedRise = Math.round(resolveStairTotalRise(node, nodes) * 100) / 100;
     return (_jsxs(PanelWrapper, { icon: "/icons/stairs.webp", onClose: handleClose, title: node.name || 'Staircase', width: 300, children: [_jsx(PanelSection, { title: "Type", children: _jsx(SegmentedControl, { onChange: (value) => handleUpdate(value === 'spiral' && node.stairType !== 'spiral'
                         ? {
                             stairType: value,
                             sweepAngle: DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE,
                             position: [node.position[0], 0, node.position[2]],
                         }
-                        : { stairType: value }), options: STAIR_TYPE_OPTIONS, value: node.stairType ?? 'straight' }) }), _jsx(PanelSection, { title: "Opening", children: _jsxs("div", { className: "space-y-3", children: [_jsx(ToggleControl, { checked: (node.slabOpeningMode ?? 'none') === 'destination', label: "Auto Cutout", onChange: handleAutoCutoutChange }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "From Level" }), _jsx("select", { className: "h-9 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-foreground text-sm", onChange: (event) => handleFromLevelChange(event.target.value), value: resolvedFromLevelId ?? '', children: levels.map((level) => (_jsx("option", { value: level.id, children: level.name || `Level ${level.level + 1}` }, level.id))) })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "To Level" }), _jsx("select", { className: "h-9 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-foreground text-sm", onChange: (event) => handleUpdate({ toLevelId: event.target.value }), value: resolvedToLevelId ?? '', children: levels.map((level) => (_jsx("option", { value: level.id, children: level.name || `Level ${level.level + 1}` }, level.id))) })] }), _jsx(SegmentedControl, { onChange: (value) => handleAutoCutoutChange(value === 'destination'), options: STAIR_SLAB_OPENING_OPTIONS, value: node.slabOpeningMode ?? 'none' }), (node.slabOpeningMode ?? 'none') === 'destination' ? (_jsx(MetricControl, { label: "Opening Offset", max: 0.5, min: 0, onChange: (value) => handleUpdate({ openingOffset: value }), precision: 2, step: 0.01, unit: "m", value: Math.round((node.openingOffset ?? 0) * 100) / 100 })) : null, node.stairType === 'spiral' && (_jsxs(_Fragment, { children: [_jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "Landing" }), _jsx(SegmentedControl, { onChange: (value) => handleUpdate({ topLandingMode: value }), options: TOP_LANDING_MODE_OPTIONS, value: node.topLandingMode ?? 'none' })] }), (node.topLandingMode ?? 'none') === 'integrated' && (_jsx(MetricControl, { label: "Top Landing", max: 5, min: 0.3, onChange: (value) => handleUpdate({ topLandingDepth: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.topLandingDepth ?? 0.9) * 100) / 100 }))] }))] }) }), node.stairType === 'straight' && (_jsxs(PanelSection, { title: "Segments", children: [_jsx("div", { className: "flex flex-col gap-1", children: segments.map((seg, i) => (_jsxs("button", { className: "flex items-center justify-between rounded-lg border border-border/50 bg-[#2C2C2E] px-3 py-2 text-foreground text-sm transition-colors hover:bg-[#3e3e3e]", onClick: () => handleSelectSegment(seg.id), type: "button", children: [_jsx("span", { className: "truncate", children: seg.name || `Segment ${i + 1}` }), _jsx("span", { className: "text-muted-foreground text-xs capitalize", children: seg.segmentType })] }, seg.id))) }), _jsxs("div", { className: "flex gap-1.5", children: [_jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add flight", onClick: handleAddFlight }), _jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add landing", onClick: handleAddLanding })] })] })), (node.stairType === 'curved' || node.stairType === 'spiral') && (_jsxs(PanelSection, { title: "Geometry", children: [_jsx(MetricControl, { label: "Width", max: 10, min: 0.4, onChange: (value) => handleUpdate({ width: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.width ?? 1) * 100) / 100 }), _jsx(MetricControl, { label: "Rise", max: 10, min: 0.2, onChange: (value) => handleUpdate({ totalRise: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.totalRise ?? 2.5) * 100) / 100 }), _jsx(MetricControl, { label: "Steps", max: 32, min: 2, onChange: (value) => handleUpdate({ stepCount: Math.max(2, Math.round(value)) }), precision: 0, step: 1, unit: "", value: Math.max(2, Math.round(node.stepCount ?? 10)) }), node.stairType !== 'spiral' && (_jsx(ToggleControl, { checked: node.fillToFloor ?? true, label: "Fit To Floor", onChange: (checked) => handleUpdate({ fillToFloor: checked }) })), (node.stairType === 'spiral' || !(node.fillToFloor ?? true)) && (_jsx(MetricControl, { label: "Thickness", max: 1, min: 0.02, onChange: (value) => handleUpdate({ thickness: value }), precision: 2, step: 0.01, unit: "m", value: Math.round((node.thickness ?? 0.25) * 100) / 100 })), _jsx(MetricControl, { label: "Inner Radius", max: 10, min: node.stairType === 'spiral' ? 0.05 : 0.2, onChange: (value) => handleUpdate({ innerRadius: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.innerRadius ?? 0.9) * 100) / 100 }), _jsx(SliderControl, { label: "Sweep", max: node.stairType === 'spiral' ? 720 : 270, min: node.stairType === 'spiral' ? -720 : -270, onChange: (degrees) => handleUpdate({ sweepAngle: (degrees * Math.PI) / 180 }), precision: 0, step: 1, unit: "\u00B0", value: Math.round(((node.sweepAngle ?? Math.PI / 2) * 180) / Math.PI) }), node.stairType === 'spiral' && (_jsxs(_Fragment, { children: [_jsx(ToggleControl, { checked: node.showCenterColumn ?? true, label: "Center Column", onChange: (checked) => handleUpdate({ showCenterColumn: checked }) }), _jsx(ToggleControl, { checked: node.showStepSupports ?? true, label: "Step Supports", onChange: (checked) => handleUpdate({ showStepSupports: checked }) })] }))] })), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: 50, min: -50, onChange: (v) => {
+                        : { stairType: value }), options: STAIR_TYPE_OPTIONS, value: node.stairType ?? 'straight' }) }), _jsx(PanelSection, { title: "Opening", children: _jsxs("div", { className: "space-y-3", children: [attachedDeck ? null : (_jsx(ToggleControl, { checked: (node.slabOpeningMode ?? 'none') === 'destination', label: "Auto Cutout", onChange: handleAutoCutoutChange })), _jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "From Level" }), _jsx("select", { className: "h-9 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-foreground text-sm", onChange: (event) => handleFromLevelChange(event.target.value), value: resolvedFromLevelId ?? '', children: levels.map((level) => (_jsx("option", { value: level.id, children: level.name || `Level ${level.level + 1}` }, level.id))) })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "To" }), _jsxs("select", { className: "h-9 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-foreground text-sm", onChange: (event) => handleDestinationChange(event.target.value), value: attachedDeck ? attachedDeck.id : (resolvedToLevelId ?? ''), children: [levels.map((level) => (_jsx("option", { value: level.id, children: level.name || `Level ${level.level + 1}` }, level.id))), candidateDecks.map((deck) => (_jsx("option", { value: deck.id, children: deck.name || 'Deck' }, deck.id)))] })] }), attachedDeck ? (_jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "Rise" }), _jsx(SegmentedControl, { onChange: (value) => handleUpdate(value === 'custom' ? { totalRise: resolvedRise } : { totalRise: undefined }), options: [
+                                        { label: 'Follows deck', value: 'follows' },
+                                        { label: 'Custom rise', value: 'custom' },
+                                    ], value: node.totalRise == null ? 'follows' : 'custom' }), node.totalRise == null ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", resolvedRise, " m"] })) : (_jsx(MetricControl, { label: "Rise", max: 10, min: 0.2, onChange: (value) => handleUpdate({ totalRise: value }), precision: 2, step: 0.05, unit: "m", value: resolvedRise }))] })) : null, attachedDeck ? null : (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (value) => handleAutoCutoutChange(value === 'destination'), options: STAIR_SLAB_OPENING_OPTIONS, value: node.slabOpeningMode ?? 'none' }), (node.slabOpeningMode ?? 'none') === 'destination' ? (_jsx(MetricControl, { label: "Opening Offset", max: 0.5, min: 0, onChange: (value) => handleUpdate({ openingOffset: value }), precision: 2, step: 0.01, unit: "m", value: Math.round((node.openingOffset ?? 0) * 100) / 100 })) : null] })), node.stairType === 'spiral' && (_jsxs(_Fragment, { children: [_jsxs("div", { className: "space-y-1.5", children: [_jsx("div", { className: "px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]", children: "Landing" }), _jsx(SegmentedControl, { onChange: (value) => handleUpdate({ topLandingMode: value }), options: TOP_LANDING_MODE_OPTIONS, value: node.topLandingMode ?? 'none' })] }), (node.topLandingMode ?? 'none') === 'integrated' && (_jsx(MetricControl, { label: "Top Landing", max: 5, min: 0.3, onChange: (value) => handleUpdate({ topLandingDepth: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.topLandingDepth ?? 0.9) * 100) / 100 }))] }))] }) }), node.stairType === 'straight' && (_jsxs(PanelSection, { title: "Segments", children: [_jsx("div", { className: "flex flex-col gap-1", children: segments.map((seg, i) => (_jsxs("button", { className: "flex items-center justify-between rounded-lg border border-border/50 bg-[#2C2C2E] px-3 py-2 text-foreground text-sm transition-colors hover:bg-[#3e3e3e]", onClick: () => handleSelectSegment(seg.id), type: "button", children: [_jsx("span", { className: "truncate", children: seg.name || `Segment ${i + 1}` }), _jsx("span", { className: "text-muted-foreground text-xs capitalize", children: seg.segmentType })] }, seg.id))) }), _jsxs("div", { className: "flex gap-1.5", children: [_jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add flight", onClick: handleAddFlight }), _jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add landing", onClick: handleAddLanding })] })] })), (node.stairType === 'curved' || node.stairType === 'spiral') && (_jsxs(PanelSection, { title: "Geometry", children: [_jsx(MetricControl, { label: "Width", max: 10, min: 0.4, onChange: (value) => handleUpdate({ width: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.width ?? 1) * 100) / 100 }), _jsx(MetricControl, { label: "Rise", max: 10, min: 0.2, onChange: (value) => handleUpdate({ totalRise: value }), precision: 2, step: 0.05, unit: "m", value: Math.round(resolveStairTotalRise(node, nodes) * 100) / 100 }), _jsx(MetricControl, { label: "Steps", max: 32, min: 2, onChange: (value) => handleUpdate({ stepCount: Math.max(2, Math.round(value)) }), precision: 0, step: 1, unit: "", value: Math.max(2, Math.round(node.stepCount ?? 10)) }), node.stairType !== 'spiral' && (_jsx(ToggleControl, { checked: node.fillToFloor ?? true, label: "Fit To Floor", onChange: (checked) => handleUpdate({ fillToFloor: checked }) })), (node.stairType === 'spiral' || !(node.fillToFloor ?? true)) && (_jsx(MetricControl, { label: "Thickness", max: 1, min: 0.02, onChange: (value) => handleUpdate({ thickness: value }), precision: 2, step: 0.01, unit: "m", value: Math.round((node.thickness ?? 0.25) * 100) / 100 })), _jsx(MetricControl, { label: "Inner Radius", max: 10, min: node.stairType === 'spiral' ? 0.05 : 0.2, onChange: (value) => handleUpdate({ innerRadius: value }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.innerRadius ?? 0.9) * 100) / 100 }), _jsx(SliderControl, { label: "Sweep", max: node.stairType === 'spiral' ? 720 : 270, min: node.stairType === 'spiral' ? -720 : -270, onChange: (degrees) => handleUpdate({ sweepAngle: (degrees * Math.PI) / 180 }), precision: 0, step: 1, unit: "\u00B0", value: Math.round(((node.sweepAngle ?? Math.PI / 2) * 180) / Math.PI) }), node.stairType === 'spiral' && (_jsxs(_Fragment, { children: [_jsx(ToggleControl, { checked: node.showCenterColumn ?? true, label: "Center Column", onChange: (checked) => handleUpdate({ showCenterColumn: checked }) }), _jsx(ToggleControl, { checked: node.showStepSupports ?? true, label: "Step Supports", onChange: (checked) => handleUpdate({ showStepSupports: checked }) })] }))] })), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: 50, min: -50, onChange: (v) => {
                             const pos = [...node.position];
                             pos[0] = v;
                             handleUpdate({ position: pos });

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/stair/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAmDzB,eAAO,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAiHnE,CAAA;AAinCD,eAAe,aAAa,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/stair/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAmDzB,eAAO,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAiHnE,CAAA;AAknCD,eAAe,aAAa,CAAA"}

package/dist/stair/renderer.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { resolveStairTotalRise, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
 import { getStairBodyMaterials, getStairRailingMaterial, NodeRenderer, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
@@ -69,7 +69,7 @@ function StairRailings({ stair, material }) {
         const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
         const sweepAngle = stair.sweepAngle ?? (stair.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
         const stepSweep = sweepAngle / stepCount;
-        const stepHeight = Math.max(stair.totalRise ?? 2.5, 0.1) / stepCount;
+        const stepHeight = Math.max(resolveStairTotalRise(stair, nodes), 0.1) / stepCount;
         const innerRadius = Math.max(stair.stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius ?? 0.9);
         const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4);
         const leftRadius = sweepAngle >= 0 ? innerRadius + 0.04 : outerRadius - 0.04;
@@ -205,9 +205,10 @@ function RailSegment({ start, end, radius, material, }) {
     return (_jsx("mesh", { castShadow: true, geometry: RAIL_GEOMETRY, material: material, name: "stair-railing-rail", position: [midpoint.x, midpoint.y, midpoint.z], quaternion: quaternion, receiveShadow: true, scale: [Math.max(radius, 0.01), length, Math.max(radius, 0.01)], userData: STAIR_RAILING_SLOT_USER_DATA }));
 }
 function CurvedStairBody({ stair, bodyMaterials, }) {
+    const nodes = useScene((state) => state.nodes);
     const sideMaterial = bodyMaterials[1];
     const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-    const totalRise = Math.max(stair.totalRise ?? 2.5, 0.1);
+    const totalRise = Math.max(resolveStairTotalRise(stair, nodes), 0.1);
     const stepHeight = totalRise / stepCount;
     const isSpiral = stair.stairType === 'spiral';
     const innerRadius = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? 0.9);

package/dist/structural-grid/coordination.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, StructuralGridNode } from '@pascal-app/core';
+export type StructuralGridPoint = readonly [x: number, z: number];
+export type StructuralGridSnap = {
+    point: [number, number];
+    distance: number;
+    kind: 'intersection' | 'line';
+    axes: StructuralGridNode[];
+    reference: string;
+};
+export declare const STRUCTURAL_GRID_SNAP_DISTANCE_M = 0.25;
+export declare const STRUCTURAL_GRID_REFERENCE_TOLERANCE_M = 0.02;
+export declare function collectStructuralGridAxes(nodes: Readonly<Record<string, AnyNode>>, levelId: string | null | undefined): StructuralGridNode[];
+export declare function formatStructuralGridReference(axes: readonly StructuralGridNode[]): string;
+export declare function resolveStructuralGridSnap(point: StructuralGridPoint, axes: readonly StructuralGridNode[], maxDistance?: number): StructuralGridSnap | null;
+export declare function resolveStructuralGridReference(point: StructuralGridPoint, axes: readonly StructuralGridNode[], tolerance?: number): string | null;
+//# sourceMappingURL=coordination.d.ts.map

package/dist/structural-grid/coordination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination.d.ts","sourceRoot":"","sources":["../../src/structural-grid/coordination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAEnE,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAA;AAEjE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,cAAc,GAAG,MAAM,CAAA;IAC7B,IAAI,EAAE,kBAAkB,EAAE,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,+BAA+B,OAAO,CAAA;AACnD,eAAO,MAAM,qCAAqC,OAAO,CAAA;AAIzD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,kBAAkB,EAAE,CAMtB;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CASzF;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,WAAW,SAAkC,GAC5C,kBAAkB,GAAG,IAAI,CA4C3B;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,SAAS,SAAwC,GAChD,MAAM,GAAG,IAAI,CAMf"}