@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/shared/opening-guides-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EAOZ,KAAK,WAAW,EAGhB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAUzB;;qFAEqF;AACrF,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjE,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,EAAE,CAmBf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,MAAM,GAAG,IAAI,CAoBhB;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,IAAI,CAmFP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAcD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB,GAAG,IAAI,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,EACD,eAAe,EAAE,OAAO,GACvB,IAAI,CAeN"}
+{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAyC,MAAM,kBAAkB,CAAA;AAMvF,OAAO,EACL,KAAK,OAAO,EAOZ,KAAK,WAAW,EAGhB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAUzB;;qFAEqF;AACrF,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjE,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,EAAE,CAqBf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,MAAM,GAAG,IAAI,CAoBhB;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,IAAI,CAwFP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAcD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB,GAAG,IAAI,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CACT,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,eAAe,GAAG,gBAAgB,GAAG,eAAe,CAAC,CAC/F,EACD,eAAe,EAAE,OAAO,GACvB,IAAI,CAgBN"}

package/dist/shared/opening-guides-runtime.js

@@ -1,10 +1,11 @@
+import { getDoorOpeningSize, openingHostFacing } from '@pascal-app/core';
 // Runtime glue between the pure `computeOpeningGuides` geometry (core) and the
 // editor's 3D guide store, used by the door/window move + placement tools. Lives
 // in `nodes` (not core) because it talks to the editor store; kept thin so each
 // tool's per-tick hook is a single call.
 import { computeOpeningGuides, detectVerticalAlignment, getOpeningFloorDatum, getWallCurveFrameAt, getWallCurveLength, sceneRegistry, useScene, wallSupportForNodes, } from '@pascal-app/core';
+import { wallOpeningCeilingOver } from '@pascal-app/core/building';
 import { useOpeningGuides } from '@pascal-app/editor';
-import { resolveWallOpeningCeiling } from './wall-opening-ceiling.js';
 // Parity with `snapLocalXToNeighbors`' along-wall threshold.
 const SILL_SNAP_THRESHOLD_M = 0.08;
 // Hide a dimension that has collapsed to nothing (sill flush to the floor, or
@@ -20,14 +21,16 @@ export function collectOpeningSiblings(wall, movingId, nodes) {
         const node = nodes[childId];
         if (!node || (node.type !== 'door' && node.type !== 'window'))
             continue;
+        const size = getDoorOpeningSize(node);
         out.push({
             id: node.id,
-            centerS: node.position[0],
-            width: node.width,
+            centerS: node.position[0] - size.leafOffsetX * openingHostFacing(node),
+            width: size.width,
             centerY: node.position[1] +
+                (size.height - node.height) / 2 +
                 getOpeningFloorDatum(wall, node, nodes) -
                 wallSupportForNodes(wall, nodes).elevation,
-            height: node.height,
+            height: size.height,
         });
     }
     return out;
@@ -57,7 +60,7 @@ export function publishOpeningGuides3D(args) {
         getOpeningFloorDatum(wall, { position: [centerS, args.centerY, 0], width, height: args.height }, args.nodes) -
         wallSupportForNodes(wall, args.nodes).elevation;
     const wallLength = getWallCurveLength(wall);
-    const wallHeight = resolveWallOpeningCeiling(wall, args.nodes);
+    const wallHeight = wallOpeningCeilingOver(wall, args.nodes, centerS - width / 2, centerS + width / 2);
     const siblings = collectOpeningSiblings(wall, args.movingId, args.nodes);
     const guides = computeOpeningGuides({
         moving: { id: args.movingId, centerS, width, centerY, height: args.height },
@@ -172,13 +175,14 @@ export function publishOpeningResizeGuides(node, includeVertical) {
     const wall = node.parentId ? nodes[node.parentId] : undefined;
     if (wall?.type !== 'wall')
         return;
+    const size = getDoorOpeningSize(node);
     publishOpeningGuides3D({
         wall,
         movingId: node.id,
-        centerS: node.position[0],
-        centerY: node.position[1],
-        width: node.width,
-        height: node.height,
+        centerS: node.position[0] - size.leafOffsetX * openingHostFacing(node),
+        centerY: node.position[1] + (size.height - node.height) / 2,
+        width: size.width,
+        height: size.height,
         includeVertical,
         nodes,
         toWorld: wallToWorld(wall),

package/dist/shared/opening-labels.d.ts

@@ -0,0 +1,11 @@
+import type { MessageDescriptor, WindowNode } from '@pascal-app/core';
+import type { DoorStyle, WindowStyle } from '@pascal-app/core/building';
+/**
+ * The door and window panels' card names. Core's `DOOR_STYLE_LABELS`,
+ * `WINDOW_STYLE_LABELS` and the placement options stay English: the tool
+ * chips and agents read them.
+ */
+export declare const DOOR_STYLE_MESSAGES: Record<DoorStyle, MessageDescriptor>;
+export declare const WINDOW_STYLE_MESSAGES: Record<WindowStyle, MessageDescriptor>;
+export declare const WINDOW_TYPE_MESSAGES: Record<WindowNode['windowType'], MessageDescriptor>;
+//# sourceMappingURL=opening-labels.d.ts.map

package/dist/shared/opening-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-labels.d.ts","sourceRoot":"","sources":["../../src/shared/opening-labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,SAAS,EAAE,iBAAiB,CAWpE,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,WAAW,EAAE,iBAAiB,CAexE,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAYpF,CAAA"}

package/dist/shared/opening-labels.js

@@ -0,0 +1,46 @@
+/**
+ * The door and window panels' card names. Core's `DOOR_STYLE_LABELS`,
+ * `WINDOW_STYLE_LABELS` and the placement options stay English: the tool
+ * chips and agents read them.
+ */
+export const DOOR_STYLE_MESSAGES = {
+    panel: /* i18n */ { id: 'node.door.style.panel', message: 'Panel' },
+    glass: /* i18n */ { id: 'node.door.style.glass', message: 'Glass' },
+    modern: /* i18n */ { id: 'node.door.style.modern', message: 'Modern' },
+    'paneled-glass': /* i18n */ { id: 'node.door.style.paneledGlass', message: 'Paneled glass' },
+    french: /* i18n */ { id: 'node.door.style.french', message: 'French' },
+    shaker: /* i18n */ { id: 'node.door.style.shaker', message: 'Shaker' },
+    'six-panel': /* i18n */ { id: 'node.door.style.sixPanel', message: 'Six-panel' },
+    craftsman: /* i18n */ { id: 'node.door.style.craftsman', message: 'Craftsman' },
+    'half-louvered': /* i18n */ { id: 'node.door.style.halfLouvered', message: 'Half-louvered' },
+    barn: /* i18n */ { id: 'node.door.style.barn', message: 'Barn' },
+};
+export const WINDOW_STYLE_MESSAGES = {
+    single: /* i18n */ { id: 'node.window.style.single', message: 'Single' },
+    'double-hung': /* i18n */ { id: 'node.window.style.doubleHung', message: 'Double-hung' },
+    'triple-hung': /* i18n */ { id: 'node.window.style.tripleHung', message: 'Triple-hung' },
+    casement: /* i18n */ { id: 'node.window.style.casement', message: 'Casement' },
+    sliding: /* i18n */ { id: 'node.window.style.sliding', message: 'Sliding' },
+    grid: /* i18n */ { id: 'node.window.style.grid', message: 'Grid' },
+    'tall-grid': /* i18n */ { id: 'node.window.style.tallGrid', message: 'Tall grid' },
+    'wide-grid': /* i18n */ { id: 'node.window.style.wideGrid', message: 'Wide grid' },
+    'horizontal-bands': /* i18n */ {
+        id: 'node.window.style.horizontalBands',
+        message: 'Horizontal bands',
+    },
+    transom: /* i18n */ { id: 'node.window.style.transom', message: 'Transom' },
+    picture: /* i18n */ { id: 'node.window.style.picture', message: 'Picture' },
+};
+export const WINDOW_TYPE_MESSAGES = {
+    fixed: /* i18n */ { id: 'node.window.type.fixed', message: 'Fixed' },
+    sliding: /* i18n */ { id: 'node.window.type.sliding', message: 'Sliding' },
+    casement: /* i18n */ { id: 'node.window.type.casement', message: 'Casement' },
+    awning: /* i18n */ { id: 'node.window.type.awning', message: 'Awning' },
+    hopper: /* i18n */ { id: 'node.window.type.hopper', message: 'Hopper' },
+    'tilt-turn': /* i18n */ { id: 'node.window.type.tiltTurn', message: 'Tilt and turn' },
+    'single-hung': /* i18n */ { id: 'node.window.type.singleHung', message: 'Single-hung' },
+    'double-hung': /* i18n */ { id: 'node.window.type.doubleHung', message: 'Double-hung' },
+    bay: /* i18n */ { id: 'node.window.type.bay', message: 'Bay' },
+    bow: /* i18n */ { id: 'node.window.type.bow', message: 'Bow' },
+    louvered: /* i18n */ { id: 'node.window.type.louvered', message: 'Louvered' },
+};

package/dist/shared/opening-placement-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/shared/opening-placement-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAMpB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CA6GrB"}
+{"version":3,"file":"opening-placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/shared/opening-placement-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAQpB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAmHrB"}

package/dist/shared/opening-placement-dimensions.js

@@ -1,4 +1,4 @@
-import { computeOpeningGuides, getWallFaceOffsets, isCurvedWall, useScene, } from '@pascal-app/core';
+import { computeOpeningGuides, getDoorOpeningSize, getWallFaceOffsets, isCurvedWall, openingHostFacing, useScene, } from '@pascal-app/core';
 import { readFloorplanContext } from '@pascal-app/editor';
 import { formatConstructionLength } from './construction-length.js';
 import { resolveWallOpeningCeiling } from './wall-opening-ceiling.js';
@@ -63,26 +63,28 @@ export function buildOpeningPlacementDimensions(opening, ctx) {
         if (!sibling || (sibling.type !== 'door' && sibling.type !== 'window'))
             continue;
         const sib = sibling;
+        const size = getDoorOpeningSize(sib);
         siblings.push({
             id: sib.id,
-            centerS: sib.position[0],
-            width: sib.width,
-            centerY: sib.position[1],
-            height: sib.height,
+            centerS: sib.position[0] - size.leafOffsetX * openingHostFacing(sib),
+            width: size.width,
+            centerY: sib.position[1] + (size.height - sib.height) / 2,
+            height: size.height,
         });
     }
+    const size = getDoorOpeningSize(opening);
     const guides = computeOpeningGuides({
         moving: {
             id: opening.id,
-            centerS: opening.position[0],
-            width: opening.width,
-            centerY: opening.position[1],
-            height: opening.height,
+            centerS: opening.position[0] - size.leafOffsetX * openingHostFacing(opening),
+            width: size.width,
+            centerY: opening.position[1] + (size.height - opening.height) / 2,
+            height: size.height,
         },
         siblings,
         wall: {
             length: wallLength,
-            height: resolveWallOpeningCeiling(wall, useScene.getState().nodes),
+            height: resolveWallOpeningCeiling(wall, useScene.getState().nodes, wallLength > 1e-4 ? Math.max(0, Math.min(1, opening.position[0] / wallLength)) : 0.5),
         },
         // The 2D plan is top-down: sill/head height and vertical alignment aren't
         // representable here — those belong to the 3D viewport.

package/dist/shared/opening-plane-offset.d.ts

@@ -1,4 +1,4 @@
-import type { DoorNode, WindowNode } from '@pascal-app/core';
+import { type DoorNode, type WindowNode } from '@pascal-app/core';
 type PlanarOpening = Pick<DoorNode | WindowNode, 'position' | 'wallId' | 'parentId'>;
 /**
  * The wall-local plane offset (`position[2]`) a moved door / window keeps on
@@ -12,8 +12,9 @@ export declare function openingPlaneOffsetOnWall(opening: PlanarOpening, targetW
  * Where an opening's plan symbol sits across its wall. A centred opening keeps
  * the long-standing symbol: centred in the cutout, as deep as the wall. An
  * opening offset from the centre plane draws its frame at that offset with its
- * own `frameDepth`, like the 3D renderer; the builder then also draws the
- * cutout, because the wall is still cut through its whole thickness.
+ * resolved frame depth, like the 3D
+ * renderer; the builder then also draws the cutout, because the wall is still
+ * cut through its whole thickness.
  */
 export declare function resolveOpeningPlanPlane(opening: Pick<DoorNode | WindowNode, 'position' | 'frameDepth'>, wallThickness: number): {
     offset: number;

package/dist/shared/opening-plane-offset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-plane-offset.d.ts","sourceRoot":"","sources":["../../src/shared/opening-plane-offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE5D,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC,CAAA;AAEpF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAG7F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,YAAY,CAAC,EAC/D,aAAa,EAAE,MAAM,GACpB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAInC"}
+{"version":3,"file":"opening-plane-offset.d.ts","sourceRoot":"","sources":["../../src/shared/opening-plane-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA4B,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE3F,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC,CAAA;AAEpF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAG7F;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,YAAY,CAAC,EAC/D,aAAa,EAAE,MAAM,GACpB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAKnC"}

package/dist/shared/opening-plane-offset.js

@@ -1,3 +1,4 @@
+import { resolveOpeningFrameDepth } from '@pascal-app/core';
 /**
  * The wall-local plane offset (`position[2]`) a moved door / window keeps on
  * `targetWallId`. The offset is measured from the centre plane of the wall the
@@ -13,12 +14,14 @@ export function openingPlaneOffsetOnWall(opening, targetWallId) {
  * Where an opening's plan symbol sits across its wall. A centred opening keeps
  * the long-standing symbol: centred in the cutout, as deep as the wall. An
  * opening offset from the centre plane draws its frame at that offset with its
- * own `frameDepth`, like the 3D renderer; the builder then also draws the
- * cutout, because the wall is still cut through its whole thickness.
+ * resolved frame depth, like the 3D
+ * renderer; the builder then also draws the cutout, because the wall is still
+ * cut through its whole thickness.
  */
 export function resolveOpeningPlanPlane(opening, wallThickness) {
     const offset = opening.position[2] ?? 0;
-    if (offset === 0 || !(opening.frameDepth > 0))
+    const frameDepth = resolveOpeningFrameDepth(opening, wallThickness);
+    if (offset === 0 || !(frameDepth > 0))
         return { offset: 0, depth: wallThickness };
-    return { offset, depth: opening.frameDepth };
+    return { offset, depth: frameDepth };
 }

package/dist/shared/opening-swap.d.ts

@@ -0,0 +1,8 @@
+import { type DoorNode, type MechanismCapability, type WindowNode } from '@pascal-app/core';
+/**
+ * Commits a hinge or swing swap of a door or window as one undo step, then opens it through its
+ * kind's mechanism when it is closed, so the new side is visible. The opening is the mechanism's
+ * preview (the action menu's Open): it leaves the saved open state and the undo history alone.
+ */
+export declare function applyOpeningSwap<N extends DoorNode | WindowNode>(node: N, patch: Partial<N>, mechanism: MechanismCapability): void;
+//# sourceMappingURL=opening-swap.d.ts.map

package/dist/shared/opening-swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-swap.d.ts","sourceRoot":"","sources":["../../src/shared/opening-swap.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAGxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,GAAG,UAAU,EAC9D,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,SAAS,EAAE,mBAAmB,QAS/B"}

package/dist/shared/opening-swap.js

@@ -0,0 +1,18 @@
+import { useInteractive, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+/**
+ * Commits a hinge or swing swap of a door or window as one undo step, then opens it through its
+ * kind's mechanism when it is closed, so the new side is visible. The opening is the mechanism's
+ * preview (the action menu's Open): it leaves the saved open state and the undo history alone.
+ */
+export function applyOpeningSwap(node, patch, mechanism) {
+    const scene = useScene.getState();
+    scene.updateNode(node.id, patch);
+    scene.dirtyNodes.add(node.id);
+    if (node.parentId)
+        scene.dirtyNodes.add(node.parentId);
+    triggerSFX('sfx:item-rotate');
+    const swapped = useScene.getState().nodes[node.id];
+    if (swapped && !mechanism.isOn(swapped, useInteractive.getState()))
+        mechanism.set(swapped, true);
+}

package/dist/shared/path-point-affordance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-point-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/path-point-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAA;AAE3E,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,SAAS,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,EACnF,IAAI,EAAE,MAAM,GACX,mBAAmB,CAAC,CAAC,CAAC,CAgIxB"}
+{"version":3,"file":"path-point-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/path-point-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAUzB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAA;AAE3E,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,SAAS,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,EACnF,IAAI,EAAE,MAAM,GACX,mBAAmB,CAAC,CAAC,CAAC,CA2HxB"}

package/dist/shared/path-point-affordance.js

@@ -2,6 +2,7 @@ import { analyzePortConnectivity, resolveConnectivityUpdates, useScene, } from '
 import { isGridSnapActive, snapPointToGrid } from '@pascal-app/editor';
 import { planRunEndCapFollowUpdates } from './automatic-run-end-cap.js';
 import { detectFittingEndpoint, planFittingEndpointReaim, } from './fitting-endpoint-reaim.js';
+import { createFollowerFrames } from './follower-frames.js';
 export function createPathPointMoveAffordance(kind) {
     const inert = {
         affectedIds: [],
@@ -41,6 +42,12 @@ export function createPathPointMoveAffordance(kind) {
                 ...(fittingEndpoint ? [fittingEndpoint.fitting.id] : []),
                 ...(connectivity?.connections.map((c) => c.nodeId) ?? []),
             ];
+            // The dispatcher commits what the last frame left in the scene.
+            const frame = createFollowerFrames(nodes, node.id);
+            const write = (updates) => useScene.getState().updateNodes(frame(updates).map((update) => ({
+                id: update.id,
+                data: update.data,
+            })));
             const endCapUpdates = (nextPath) => {
                 if ((kind !== 'duct-segment' && kind !== 'pipe-segment') || !isEndpoint)
                     return [];
@@ -58,7 +65,9 @@ export function createPathPointMoveAffordance(kind) {
                     ...node,
                     path: nextPath,
                 };
-                const updates = resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+                const updates = resolveConnectivityUpdates(connectivity, preview)?.filter((u) => useScene.getState().nodes[u.id]);
+                if (!updates)
+                    return null;
                 const capUpdates = endCapUpdates(nextPath);
                 const capIds = new Set(capUpdates.map((update) => update.id));
                 return [...updates.filter((update) => !capIds.has(update.id)), ...capUpdates];
@@ -81,33 +90,19 @@ export function createPathPointMoveAffordance(kind) {
                         const plan = planFittingEndpointReaim(fittingEndpoint, pointIndex, dragged);
                         if (!plan)
                             return;
-                        useScene.getState().updateNodes([
-                            {
-                                id: node.id,
-                                data: { path: plan.path, wallAttachment: undefined },
-                            },
-                            {
-                                id: plan.fittingUpdate.id,
-                                data: plan.fittingUpdate.data,
-                            },
-                            ...endCapUpdates(plan.path).map((update) => ({
-                                id: update.id,
-                                data: update.data,
-                            })),
+                        write([
+                            { id: node.id, data: { path: plan.path, wallAttachment: undefined } },
+                            plan.fittingUpdate,
+                            ...endCapUpdates(plan.path),
                         ]);
                         return;
                     }
                     const nextPath = initialPath.map((p, i) => (i === pointIndex ? dragged : p));
-                    useScene.getState().updateNodes([
-                        {
-                            id: node.id,
-                            data: { path: nextPath, wallAttachment: undefined },
-                        },
-                        ...(detached ? [] : followUpdates(nextPath)).map((u) => ({
-                            id: u.id,
-                            data: u.data,
-                        })),
-                    ]);
+                    const follow = detached ? [] : followUpdates(nextPath);
+                    // Joints that cannot follow hold the frame, like an out-of-range turn.
+                    if (!follow)
+                        return;
+                    write([{ id: node.id, data: { path: nextPath, wallAttachment: undefined } }, ...follow]);
                 },
                 canCommit() {
                     const final = useScene.getState().nodes[node.id];

package/dist/shared/path-segment-affordance.d.ts

@@ -8,7 +8,8 @@ import { type AnyNodeId, type FloorplanAffordance } from '@pascal-app/core';
  *  - **move-segment**: slide one segment perpendicular to itself. Both its
  *    vertices translate by the same plan-normal offset (the offset is the
  *    cursor's projection onto the segment normal); neighbours stretch and any
- *    mated joint follows via port connectivity. Grid-snapped (Shift bypasses).
+ *    mated joint follows via port connectivity. Grid-snapped while grid
+ *    snapping is on.
  *
  * The vertices' Y (elevation) is always held — plan editing never changes
  * height, matching the path-point affordance. Behavioral parity with the 3D

package/dist/shared/path-segment-affordance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-segment-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/path-segment-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzB,CAAA;AAGD,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,EAAE,EAAE,SAAS,CAAA;CAAE,CAAA;AA0C1F,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,SAAS,EAC7D,IAAI,EAAE,MAAM,GACX,mBAAmB,CAAC,CAAC,CAAC,CAkDxB"}
+{"version":3,"file":"path-segment-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/path-segment-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzB,CAAA;AAGD,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,EAAE,EAAE,SAAS,CAAA;CAAE,CAAA;AA6C1F,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,SAAS,EAC7D,IAAI,EAAE,MAAM,GACX,mBAAmB,CAAC,CAAC,CAAC,CAoDxB"}

package/dist/shared/path-segment-affordance.js

@@ -1,5 +1,5 @@
 import { analyzePortConnectivity, resolveConnectivityUpdates, useScene, } from '@pascal-app/core';
-import { snapPointToGrid } from '@pascal-app/editor';
+import { isGridSnapActive, snapPointToGrid } from '@pascal-app/editor';
 const inert = {
     affectedIds: [],
     apply() { },
@@ -25,7 +25,7 @@ function makeConnectivity(node, nodes, analyze) {
             ...node,
             path: nextPath,
         };
-        return resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+        return (resolveConnectivityUpdates(connectivity, preview)?.filter((u) => useScene.getState().nodes[u.id]) ?? null);
     };
     return { connectivity, affectedIds, followUpdates };
 }
@@ -45,21 +45,24 @@ export function createSegmentMoveAffordance(kind) {
             const mid = [(a[0] + b[0]) / 2, (a[2] + b[2]) / 2];
             return {
                 affectedIds,
-                apply({ planPoint, modifiers }) {
+                apply({ planPoint }) {
                     // Project the cursor onto the segment normal — that signed distance
-                    // is how far the whole segment slides. Grid-snap the magnitude
-                    // (Shift bypasses) so the slide lands on the same lattice as the
-                    // other plan tools.
+                    // is how far the whole segment slides. Grid-snap the magnitude so the
+                    // slide lands on the same lattice as the other plan tools.
                     const signedRaw = (planPoint[0] - mid[0]) * normal[0] + (planPoint[1] - mid[1]) * normal[1];
-                    const signed = modifiers.shiftKey ? signedRaw : snapPointToGrid([signedRaw, 0])[0];
+                    const signed = isGridSnapActive() ? snapPointToGrid([signedRaw, 0])[0] : signedRaw;
                     const ox = normal[0] * signed;
                     const oz = normal[1] * signed;
                     const nextPath = initialPath.map((p, i) => i === segmentIndex || i === segmentIndex + 1
                         ? [p[0] + ox, p[1], p[2] + oz]
                         : p);
+                    const follow = followUpdates(nextPath);
+                    // Joints that cannot follow hold the frame.
+                    if (!follow)
+                        return;
                     useScene.getState().updateNodes([
                         { id: node.id, data: { path: nextPath } },
-                        ...followUpdates(nextPath).map((u) => ({
+                        ...follow.map((u) => ({
                             id: u.id,
                             data: u.data,
                         })),

package/dist/shared/pipe-collar-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type AnyNode } from '@pascal-app/core';
+export default function PipeCollarInspector({ node }: {
+    node: AnyNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=pipe-collar-inspector.d.ts.map

package/dist/shared/pipe-collar-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-collar-inspector.d.ts","sourceRoot":"","sources":["../../src/shared/pipe-collar-inspector.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,kBAAkB,CAAA;AAIzB,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCAsCtE"}

package/dist/shared/pipe-collar-inspector.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatFixed, formatNumber, nodeRegistry, usePascalI18n, useScene, } from '@pascal-app/core';
+import { pipeCollarOccupied } from '../pipe-segment/collar-connection.js';
+import { activatePipeCollarContinuation } from '../pipe-segment/continuation.js';
+export default function PipeCollarInspector({ node }) {
+    const i18n = usePascalI18n();
+    const nodes = useScene((state) => state.nodes);
+    const ports = nodeRegistry.get(node.type)?.ports?.(node) ?? [];
+    const pipePorts = ports.filter((port) => port.system === 'waste' || port.system === 'vent');
+    if (!pipePorts.length)
+        return null;
+    return (_jsxs("section", { className: "space-y-2 border-t pt-3", children: [_jsx("h3", { className: "text-sm font-medium", children: i18n._({ id: 'node.shared.pipeCollarInspector.connectPipe', message: 'Connect pipe' }) }), pipePorts.map((port, index) => {
+                const occupied = pipeCollarOccupied(nodes, { ...port, nodeId: node.id });
+                return (_jsx("button", { type: "button", disabled: occupied, className: "block w-full rounded border px-2 py-1 text-left text-xs disabled:opacity-50", onClick: () => activatePipeCollarContinuation(node, port), children: i18n._({
+                        id: 'node.shared.pipeCollarInspector.collarButton',
+                        message: '{port, select, inlet {Inlet} outlet {Outlet} branch {Branch} branch2 {Second branch} other {Collar {number}}} · {diameter} in · {elevation} m · {state, select, connected {Connected} other {Draw from collar}}',
+                        values: {
+                            port: port.id,
+                            number: String(index + 1),
+                            diameter: formatNumber(port.diameter, { locale: i18n.getLocale() }),
+                            elevation: formatFixed(port.position[1], 3, i18n.getLocale()),
+                            state: occupied ? 'connected' : 'open',
+                        },
+                    }) }, port.id));
+            })] }));
+}

package/dist/shared/polygon-vertex-affordance.d.ts

@@ -44,6 +44,12 @@ export type PolygonAffordanceSnapContext<N extends PolygonShape & {
     modifiers: FloorplanAffordanceModifiers;
     holeIndex?: number;
     mode: PolygonAffordanceMode;
+    /**
+     * `move-vertex` / `add-vertex`: the ring as the drag found it (the new vertex inserted) and the
+     * dragged vertex's index in it, so a resolver can square the vertex to its neighbours.
+     */
+    ring?: ReadonlyArray<readonly [number, number]>;
+    vertexIndex?: number;
 };
 export type PolygonEdgeSnapContext<N extends PolygonShape & {
     id: AnyNodeId;
@@ -70,6 +76,13 @@ export type PolygonAffordanceOptions<N extends PolygonShape & {
      * translated edge, or `null` to keep the candidate.
      */
     snapEdge?: (context: PolygonEdgeSnapContext<N>) => [[number, number], [number, number]] | null;
+    /**
+     * `move-edge`: the sides beside the dragged one keep their own angle, running on to meet it
+     * where it goes; a side in line with it (a side split in two) gets a square jog instead, so
+     * pulling out part of a side makes a bump-out. Off, both ends of the side translate square to
+     * it and its neighbours pivot on their far ends.
+     */
+    keepNeighbourAngles?: boolean;
 };
 type PolygonShape = {
     polygon: ReadonlyArray<readonly [number, number]>;
@@ -92,6 +105,12 @@ export declare function createPolygonAddVertexAffordance<N extends PolygonShape
 export declare function createPolygonDeleteVertexAffordance<N extends PolygonShape & {
     id: AnyNodeId;
 }>(kind: string, options?: PolygonAffordanceOptions<N>): FloorplanAffordance<N>;
+/**
+ * `ring` with edge `edgeIndex` moved `distance` along `normal`, its neighbours keeping their angles
+ * (`keepNeighbourAngles`): each end goes where the neighbouring side's line meets the moved edge's,
+ * and a neighbour in line with the edge keeps its vertex, a square jog joining it to the moved end.
+ */
+export declare function movedEdgeKeepingNeighbours(ring: ReadonlyArray<readonly [number, number]>, edgeIndex: number, normal: readonly [number, number], distance: number): [number, number][];
 /**
  * Edge-drag: move a whole edge perpendicular to itself. Both endpoints
  * translate by `edgeNormal * projectedDelta`. The other vertices of

package/dist/shared/polygon-vertex-affordance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polygon-vertex-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/polygon-vertex-affordance.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"polygon-vertex-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/polygon-vertex-affordance.ts"],"names":[],"mappings":"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"}

package/dist/shared/polygon-vertex-affordance.js

@@ -71,6 +71,8 @@ export function createPolygonVertexAffordance(kind, options) {
                         modifiers,
                         holeIndex,
                         mode: 'move-vertex',
+                        ring: originalRing,
+                        vertexIndex,
                     });
                     const nextRing = originalRing.map((p, i) => i === vertexIndex ? [snapped[0], snapped[1]] : p);
                     const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
@@ -148,6 +150,8 @@ export function createPolygonAddVertexAffordance(kind, options) {
                         modifiers,
                         holeIndex,
                         mode: 'add-vertex',
+                        ring: initialRing,
+                        vertexIndex: newVertexIndex,
                     });
                     const nextRing = initialRing.map((p, i) => i === newVertexIndex ? [snapped[0], snapped[1]] : p);
                     const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
@@ -203,6 +207,59 @@ export function createPolygonDeleteVertexAffordance(kind, options) {
         },
     };
 }
+/** A neighbouring side within this sine of the dragged one's line is in line with it (a split side). */
+const IN_LINE_SINE = 0.05;
+/**
+ * `ring` with edge `edgeIndex` moved `distance` along `normal`, its neighbours keeping their angles
+ * (`keepNeighbourAngles`): each end goes where the neighbouring side's line meets the moved edge's,
+ * and a neighbour in line with the edge keeps its vertex, a square jog joining it to the moved end.
+ */
+export function movedEdgeKeepingNeighbours(ring, edgeIndex, normal, distance) {
+    const copy = ring.map(([x, y]) => [x, y]);
+    const count = ring.length;
+    // Under a millimetre the side has not moved: no jog a hair long.
+    if (count < 3 || Math.abs(distance) < 1e-3)
+        return copy;
+    const startIndex = edgeIndex;
+    const endIndex = (edgeIndex + 1) % count;
+    const start = ring[startIndex];
+    const end = ring[endIndex];
+    const moved = (p) => [
+        p[0] + normal[0] * distance,
+        p[1] + normal[1] * distance,
+    ];
+    /** Where the side from `neighbour` to `vertex` meets the moved edge; `null` in line with it. */
+    const meet = (vertex, neighbour) => {
+        const dx = vertex[0] - neighbour[0];
+        const dy = vertex[1] - neighbour[1];
+        const length = Math.hypot(dx, dy);
+        if (length < 1e-9)
+            return null;
+        const along = (dx * normal[0] + dy * normal[1]) / length;
+        if (Math.abs(along) < IN_LINE_SINE)
+            return null;
+        const target = moved(start);
+        const t = ((target[0] - neighbour[0]) * normal[0] + (target[1] - neighbour[1]) * normal[1]) /
+            (along * length);
+        return [neighbour[0] + dx * t, neighbour[1] + dy * t];
+    };
+    const startMeet = meet(start, ring[(startIndex - 1 + count) % count]);
+    const endMeet = meet(end, ring[(endIndex + 1) % count]);
+    const startPoints = startMeet
+        ? [startMeet]
+        : [[start[0], start[1]], moved(start)];
+    const endPoints = endMeet ? [endMeet] : [moved(end), [end[0], end[1]]];
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        if (i === startIndex)
+            out.push(...startPoints);
+        else if (i === endIndex)
+            out.push(...endPoints);
+        else
+            out.push(copy[i]);
+    }
+    return out;
+}
 /**
  * Edge-drag: move a whole edge perpendicular to itself. Both endpoints
  * translate by `edgeNormal * projectedDelta`. The other vertices of
@@ -307,12 +364,14 @@ export function createPolygonMoveEdgeAffordance(kind, options) {
                                     (snappedEdge[0][1] - startVertex[1]) * normalY;
                         }
                     }
-                    const nextRing = originalRing.map((p, i) => {
-                        if (i === edgeStartIndex || i === edgeEndIndex) {
-                            return [p[0] + normalX * normalDistance, p[1] + normalY * normalDistance];
-                        }
-                        return [p[0], p[1]];
-                    });
+                    const nextRing = options?.keepNeighbourAngles
+                        ? movedEdgeKeepingNeighbours(originalRing, edgeIndex, [normalX, normalY], normalDistance)
+                        : originalRing.map((p, i) => {
+                            if (i === edgeStartIndex || i === edgeEndIndex) {
+                                return [p[0] + normalX * normalDistance, p[1] + normalY * normalDistance];
+                            }
+                            return [p[0], p[1]];
+                        });
                     const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
                     commitRingPatch(node.id, holeIndex, patch);
                 },

package/dist/shared/refrigerant-line-selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refrigerant-line-selection.d.ts","sourceRoot":"","sources":["../../src/shared/refrigerant-line-selection.tsx"],"names":[],"mappings":"AA0BA,KAAK,mBAAmB,GAAG,SAAS,GAAG,aAAa,CAAA;AA6CpD,wBAAgB,wCAAwC,CAAC,IAAI,EAAE,mBAAmB,4CAiCjF"}
+{"version":3,"file":"refrigerant-line-selection.d.ts","sourceRoot":"","sources":["../../src/shared/refrigerant-line-selection.tsx"],"names":[],"mappings":"AAqCA,KAAK,mBAAmB,GAAG,SAAS,GAAG,aAAa,CAAA;AA6CpD,wBAAgB,wCAAwC,CAAC,IAAI,EAAE,mBAAmB,4CAiCjF"}