@pascal-app/nodes 0.1.1

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

@@ -0,0 +1,19 @@
+import { type DoorNode, type FloorplanGeometry, type GeometryContext, type WindowNode } from '@pascal-app/core';
+/**
+ * Build placement-measurement dimension lines for a door / window
+ * being moved on a wall. Mirrors the legacy
+ * `movingOpeningPlacementMeasurements` in `floorplan-panel.tsx`:
+ *
+ *   - Find the previous opening on the same wall (or the wall start
+ *     if none) → distance from its right face to this opening's
+ *     left face.
+ *   - Find the next opening (or wall end) → distance from this
+ *     opening's right face to its left face.
+ *   - Each renders as a `dimension` primitive offset to the wall's
+ *     outer face so the labels don't overlap the wall body.
+ *
+ * Returns an empty array if the parent isn't a wall, the wall is
+ * curved, or the opening is at wall length 0 (invalid).
+ */
+export declare function buildOpeningPlacementDimensions(opening: DoorNode | WindowNode, ctx: GeometryContext): FloorplanGeometry[];
+//# sourceMappingURL=opening-placement-dimensions.d.ts.map

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

@@ -0,0 +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,EAIpB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAsGrB"}

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

@@ -0,0 +1,152 @@
+import { computeOpeningGuides, isCurvedWall, } from '@pascal-app/core';
+/**
+ * Build placement-measurement dimension lines for a door / window
+ * being moved on a wall. Mirrors the legacy
+ * `movingOpeningPlacementMeasurements` in `floorplan-panel.tsx`:
+ *
+ *   - Find the previous opening on the same wall (or the wall start
+ *     if none) → distance from its right face to this opening's
+ *     left face.
+ *   - Find the next opening (or wall end) → distance from this
+ *     opening's right face to its left face.
+ *   - Each renders as a `dimension` primitive offset to the wall's
+ *     outer face so the labels don't overlap the wall body.
+ *
+ * Returns an empty array if the parent isn't a wall, the wall is
+ * curved, or the opening is at wall length 0 (invalid).
+ */
+export function buildOpeningPlacementDimensions(opening, ctx) {
+    const wall = ctx.parent;
+    if (wall?.type !== 'wall')
+        return [];
+    if (isCurvedWall(wall))
+        return [];
+    const [x1, z1] = wall.start;
+    const [x2, z2] = wall.end;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const wallLength = Math.hypot(dx, dz);
+    if (wallLength < 1e-6)
+        return [];
+    const dirX = dx / wallLength;
+    const dirZ = dz / wallLength;
+    // Outward normal — chosen by the wall builder via the level
+    // centroid. We replicate that decision here so the dimension lines
+    // land on the same face. Walk wall's siblings (the level's other
+    // walls) via ctx.resolve to compute the centroid.
+    const outwardNormal = computeOutwardNormal(wall, ctx, dirX, dirZ);
+    const wallThickness = wall.thickness ?? 0.1;
+    const halfThickness = wallThickness / 2;
+    const FLOORPLAN_WALL_OUTER_MEASUREMENT_OFFSET = 0.32;
+    // Outer-face projection for the placement dimensions (so extension lines stay
+    // short and the layout matches the legacy treatment); centreline projection
+    // for the equal-spacing badges, which sit on the solid wall between openings.
+    const facePoint = (along) => [
+        x1 + dirX * along + outwardNormal[0] * halfThickness,
+        z1 + dirZ * along + outwardNormal[1] * halfThickness,
+    ];
+    const centrePoint = (along) => [x1 + dirX * along, z1 + dirZ * along];
+    const round = (value) => Number.parseFloat(value.toFixed(2));
+    // This wall's OTHER openings as wall-local spans. `ctx.siblings` only includes
+    // same-kind nodes; doors and windows need each other, so resolve the wall's
+    // children directly.
+    const childIds = (wall.children ?? []);
+    const siblings = [];
+    for (const childId of childIds) {
+        if (childId === opening.id)
+            continue;
+        const sibling = ctx.resolve(childId);
+        if (!sibling || (sibling.type !== 'door' && sibling.type !== 'window'))
+            continue;
+        const sib = sibling;
+        siblings.push({
+            id: sib.id,
+            centerS: sib.position[0],
+            width: sib.width,
+            centerY: sib.position[1],
+            height: sib.height,
+        });
+    }
+    const guides = computeOpeningGuides({
+        moving: {
+            id: opening.id,
+            centerS: opening.position[0],
+            width: opening.width,
+            centerY: opening.position[1],
+            height: opening.height,
+        },
+        siblings,
+        wall: { length: wallLength, height: wall.height ?? 2.5 },
+        // The 2D plan is top-down: sill/head height and vertical alignment aren't
+        // representable here — those belong to the 3D viewport.
+        includeVertical: false,
+    });
+    const out = [];
+    // Edge-to-edge clearance to the nearest neighbour (or wall end) on each side.
+    for (const gap of guides.gaps) {
+        const lo = Math.min(gap.fromS, gap.toS);
+        const hi = Math.max(gap.fromS, gap.toS);
+        out.push({
+            kind: 'dimension',
+            start: facePoint(lo),
+            end: facePoint(hi),
+            offsetNormal: outwardNormal,
+            offsetDistance: FLOORPLAN_WALL_OUTER_MEASUREMENT_OFFSET,
+            extensionOvershoot: 0.12,
+            text: `${round(gap.distance)}m`,
+            stroke: '#f97316',
+        });
+    }
+    // Equal-spacing rhythm — a "=" badge per equal gap, on the wall centreline.
+    if (guides.equalSpacing) {
+        const wallAngle = Math.atan2(dz, dx);
+        const text = `${round(guides.equalSpacing.gap)}m`;
+        for (const seg of guides.equalSpacing.segments) {
+            out.push({
+                kind: 'equal-spacing-badge',
+                point: centrePoint((seg.fromS + seg.toS) / 2),
+                text,
+                angle: wallAngle,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Choose the perpendicular wall normal that points away from the
+ * other walls' centroid — same logic the wall builder uses to place
+ * its own dimension overlay so left / right placement dimensions land
+ * on the same face the wall label is on.
+ */
+function computeOutwardNormal(wall, ctx, dirX, dirZ) {
+    const nx = -dirZ;
+    const nz = dirX;
+    // Find the level by walking up via wall.parentId.
+    const level = wall.parentId
+        ? ctx.resolve(wall.parentId)
+        : null;
+    const levelChildren = (level?.children ??
+        []);
+    let sumX = 0;
+    let sumZ = 0;
+    let count = 0;
+    for (const childId of levelChildren) {
+        const child = ctx.resolve(childId);
+        if (child?.type !== 'wall')
+            continue;
+        const w = child;
+        sumX += w.start[0] + w.end[0];
+        sumZ += w.start[1] + w.end[1];
+        count += 2;
+    }
+    if (count === 0)
+        return [nx, nz];
+    const centroidX = sumX / count;
+    const centroidZ = sumZ / count;
+    const wallMidX = (wall.start[0] + wall.end[0]) / 2;
+    const wallMidZ = (wall.start[1] + wall.end[1]) / 2;
+    const fromCentroidX = wallMidX - centroidX;
+    const fromCentroidZ = wallMidZ - centroidZ;
+    const facingAway = fromCentroidX * nx + fromCentroidZ * nz >= 0 ? 1 : -1;
+    return [nx * facingAway, nz * facingAway];
+}

package/dist/shared/path-offset.d.ts

@@ -0,0 +1,10 @@
+type Point = [number, number, number];
+/**
+ * Offset a polyline horizontally by `offset` meters to one side, mitered at
+ * bends so the parallel line meets cleanly. Positive `offset` shifts along the
+ * `+UP × heading` side of each segment; negative flips to the other side. Used
+ * to lay a thin line beside an existing run (the liquid-line follow-trace).
+ */
+export declare function offsetPathHorizontal(path: readonly Point[], offset: number): Point[];
+export {};
+//# sourceMappingURL=path-offset.d.ts.map

package/dist/shared/path-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-offset.d.ts","sourceRoot":"","sources":["../../src/shared/path-offset.ts"],"names":[],"mappings":"AAEA,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AA4DrC;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CAOpF"}

package/dist/shared/path-offset.js

@@ -0,0 +1,74 @@
+import { Vector3 } from 'three';
+const UP = new Vector3(0, 1, 0);
+const FALLBACK_PERP = new Vector3(1, 0, 0);
+/** Cap on the miter-length multiplier so a sharp turn doesn't shoot the
+ * corner off to infinity — past this we'd want a bevel, but MEP runs bend
+ * gently enough that clamping is invisible. */
+const MITER_LIMIT = 4;
+/**
+ * Horizontal side vector for each path segment — the axis a parallel line is
+ * pushed apart along, kept HORIZONTAL so the offset never tilts. A vertical
+ * (riser) segment has no horizontal heading of its own, so it inherits the
+ * side vector from the nearest segment that does; this keeps the offset line
+ * beside the source as the run climbs instead of rotating about the bend.
+ * Falls back to the X axis only if the whole path is vertical.
+ */
+function segmentSides(points) {
+    const sides = [];
+    for (let i = 0; i < points.length - 1; i++) {
+        const dir = new Vector3().subVectors(points[i + 1], points[i]);
+        const horizontal = new Vector3(dir.x, 0, dir.z);
+        sides.push(horizontal.lengthSq() < 1e-9 ? null : horizontal.normalize().cross(UP).normalize());
+    }
+    // Forward then backward fill so vertical segments adopt a real heading.
+    for (let i = 1; i < sides.length; i++)
+        if (!sides[i])
+            sides[i] = sides[i - 1] ?? null;
+    for (let i = sides.length - 2; i >= 0; i--)
+        if (!sides[i])
+            sides[i] = sides[i + 1] ?? null;
+    return sides.map((s) => s ?? FALLBACK_PERP.clone());
+}
+/**
+ * Per-vertex offset vectors for shifting a path sideways into a parallel line.
+ * At an interior vertex the offset follows the angle bisector of the two
+ * adjacent segment side vectors, scaled by `1/cos(half-angle)` so the offset
+ * segments on either side of the bend meet exactly at one miter point (a plain
+ * per-segment side leaves them crossing/gapping). Endpoints use their single
+ * segment's side. Side vectors are horizontal, so the offset is too — a
+ * horizontal→vertical bend keeps the same side (cos 1, no expansion), leaving
+ * the parallel line side by side up the riser.
+ */
+function miterOffsets(points, offset) {
+    const sides = segmentSides(points);
+    return points.map((_p, i) => {
+        const sIn = i > 0 ? sides[i - 1] : null;
+        const sOut = i < sides.length ? sides[i] : null;
+        if (sIn && sOut) {
+            const bisector = sIn.clone().add(sOut);
+            // s_in == -s_out → a 180° switchback; the bisector vanishes, so just
+            // run straight out on one side.
+            if (bisector.lengthSq() < 1e-9)
+                return sIn.clone().multiplyScalar(offset);
+            bisector.normalize();
+            const cos = bisector.dot(sIn);
+            const scale = Math.min(MITER_LIMIT, 1 / Math.max(cos, 1 / MITER_LIMIT));
+            return bisector.multiplyScalar(offset * scale);
+        }
+        return (sIn ?? sOut).clone().multiplyScalar(offset);
+    });
+}
+/**
+ * Offset a polyline horizontally by `offset` meters to one side, mitered at
+ * bends so the parallel line meets cleanly. Positive `offset` shifts along the
+ * `+UP × heading` side of each segment; negative flips to the other side. Used
+ * to lay a thin line beside an existing run (the liquid-line follow-trace).
+ */
+export function offsetPathHorizontal(path, offset) {
+    const points = path.map(([x, y, z]) => new Vector3(x, y, z));
+    const offsets = miterOffsets(points, offset);
+    return points.map((p, i) => {
+        const o = p.clone().add(offsets[i]);
+        return [o.x, o.y, o.z];
+    });
+}

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

@@ -0,0 +1,34 @@
+import { type AnyNodeId, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * Shared "drag a path point" floor-plan affordance for polyline
+ * distribution kinds (duct-segment / pipe-segment / lineset). It is the
+ * 2D counterpart of their 3D `affordanceTools.selection` handles: one
+ * draggable handle per path vertex, moved freely on the plan (XZ) with
+ * grid snap (Shift bypasses). The vertex's Y (elevation / slope) is held
+ * fixed — plan editing never changes height.
+ *
+ * Like the 3D handles, dragging a vertex that sits on a fitting carries the
+ * joint along (port connectivity): the fitting follows, connected runs stretch
+ * along their own axis and translate across it, and that perpendicular slide
+ * propagates down the chain. And — duct / pipe only — dragging the free end
+ * of a straight run whose other end sits on an elbow re-aims that elbow to
+ * follow the drag (bend angle adapts) instead of translating it rigidly. Holding
+ * **Alt** detaches: the joint breaks for the drag so the vertex moves on its
+ * own (no elbow re-aim, no connectivity follow). Behavioral parity with the
+ * 3D selection tool.
+ *
+ * Wired via `def.floorplanAffordances['move-path-point']`; the floor-plan
+ * builders emit `endpoint-handle` primitives carrying `{ pointIndex }` so
+ * the dispatcher routes pointer-downs here.
+ */
+export type PathPointPayload = {
+    pointIndex: number;
+};
+type PathShape = {
+    path: ReadonlyArray<readonly [number, number, number]>;
+};
+export declare function createPathPointMoveAffordance<N extends PathShape & {
+    id: AnyNodeId;
+}>(kind: string): FloorplanAffordance<N>;
+export {};
+//# sourceMappingURL=path-point-affordance.d.ts.map

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

@@ -0,0 +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;AAQzB;;;;;;;;;;;;;;;;;;;;;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,CAqGxB"}

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

@@ -0,0 +1,97 @@
+import { analyzePortConnectivity, resolveConnectivityUpdates, useScene, } from '@pascal-app/core';
+import { snapPointToGrid } from '@pascal-app/editor';
+import { detectFittingEndpoint, planFittingEndpointReaim, } from './fitting-endpoint-reaim';
+export function createPathPointMoveAffordance(kind) {
+    const inert = {
+        affectedIds: [],
+        apply() { },
+        canCommit() {
+            return false;
+        },
+    };
+    return {
+        start({ node, payload, nodes }) {
+            const { pointIndex } = payload;
+            const initialPath = node.path.map((p) => [...p]);
+            const target = initialPath[pointIndex];
+            if (!target)
+                return { ...inert, affectedIds: [node.id] };
+            // Hold the dragged vertex's elevation — the plan move only shifts XZ.
+            const y = target[1];
+            // Connectivity snapshot: which fittings / runs are mated to this run's
+            // endpoints so they follow the drag. Only endpoints (first / last vertex)
+            // bear ports; interior vertices have no joint, so skip the analysis.
+            const isEndpoint = pointIndex === 0 || pointIndex === initialPath.length - 1;
+            // Fitting re-aim (duct / pipe): if this is a straight run whose OTHER
+            // end sits on an elbow collar (bend angle adapts) or a duct tee branch
+            // collar (branch lean adapts), the fitting swings to follow the drag —
+            // the 2D twin of the 3D selection handle's behaviour. Takes precedence
+            // over the rigid connectivity follow for this endpoint.
+            const fittingEndpoint = isEndpoint
+                ? detectFittingEndpoint(kind, initialPath, pointIndex, nodes)
+                : null;
+            const connectivity = isEndpoint && !fittingEndpoint
+                ? analyzePortConnectivity(node, nodes)
+                : null;
+            // Report every node the drag may write so the dispatcher snapshots them
+            // for the single-undo dance.
+            const affectedIds = [
+                node.id,
+                ...(fittingEndpoint ? [fittingEndpoint.fitting.id] : []),
+                ...(connectivity?.connections.map((c) => c.nodeId) ?? []),
+            ];
+            const followUpdates = (nextPath) => {
+                if (!connectivity)
+                    return [];
+                const preview = {
+                    ...node,
+                    path: nextPath,
+                };
+                return resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+            };
+            return {
+                affectedIds,
+                apply({ planPoint, modifiers }) {
+                    // Plan coords map x→world X, y→world Z.
+                    const raw = [planPoint[0], planPoint[1]];
+                    const [sx, sz] = modifiers.shiftKey ? raw : snapPointToGrid(raw);
+                    const dragged = [sx, y, sz];
+                    // Alt = detach: break the joint for this drag — the elbow does NOT
+                    // re-aim and mated fittings / runs do NOT follow; the vertex moves
+                    // on its own. Mirrors the 3D selection drag and the wall corner.
+                    const detached = modifiers.altKey;
+                    // Fitting re-aim: the fitting swings to follow the dragged end and
+                    // the run rides its re-aimed collar. Out-of-range turns hold the
+                    // frame.
+                    if (!detached && fittingEndpoint) {
+                        const plan = planFittingEndpointReaim(fittingEndpoint, pointIndex, dragged);
+                        if (!plan)
+                            return;
+                        useScene.getState().updateNodes([
+                            { id: node.id, data: { path: plan.path } },
+                            {
+                                id: plan.fittingUpdate.id,
+                                data: plan.fittingUpdate.data,
+                            },
+                        ]);
+                        return;
+                    }
+                    const nextPath = initialPath.map((p, i) => (i === pointIndex ? dragged : p));
+                    useScene.getState().updateNodes([
+                        { id: node.id, data: { path: nextPath } },
+                        ...(detached ? [] : followUpdates(nextPath)).map((u) => ({
+                            id: u.id,
+                            data: u.data,
+                        })),
+                    ]);
+                },
+                canCommit() {
+                    const final = useScene.getState().nodes[node.id];
+                    return (!!final &&
+                        final.type === kind &&
+                        final.path.length >= 2);
+                },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+import { type AnyNodeId, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * Shared "side-move a path segment" floor-plan affordance for polyline
+ * distribution kinds (duct-segment / pipe-segment). It is the 2D counterpart
+ * of the in-world side-move arrows in the kind's 3D
+ * `affordanceTools.selection` handles.
+ *
+ *  - **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).
+ *
+ * The vertices' Y (elevation) is always held — plan editing never changes
+ * height, matching the path-point affordance. Behavioral parity with the 3D
+ * selection arrows. (Length editing stays on the per-vertex hex handles.)
+ *
+ * Wired via `def.floorplanAffordances['move-segment']`; the floor-plan
+ * builder emits `move-arrow` primitives carrying the segment index so the
+ * dispatcher routes pointer-downs here.
+ */
+export type SegmentMovePayload = {
+    /** Index of the segment's first vertex (it spans [i, i+1]). */
+    segmentIndex: number;
+    /** Unit plan normal [nx, nz] the segment slides along. */
+    normal: [number, number];
+};
+type PathShape = {
+    path: ReadonlyArray<readonly [number, number, number]>;
+    id: AnyNodeId;
+};
+export declare function createSegmentMoveAffordance<N extends PathShape>(kind: string): FloorplanAffordance<N>;
+export {};
+//# sourceMappingURL=path-segment-affordance.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,77 @@
+import { analyzePortConnectivity, resolveConnectivityUpdates, useScene, } from '@pascal-app/core';
+import { snapPointToGrid } from '@pascal-app/editor';
+const inert = {
+    affectedIds: [],
+    apply() { },
+    canCommit() {
+        return false;
+    },
+};
+/**
+ * Connectivity snapshot + follow-update builder. Endpoints bear ports; an
+ * interior segment vertex never does, so the caller passes `analyze: false`
+ * to skip the work when neither moved vertex is a run end.
+ */
+function makeConnectivity(node, nodes, analyze) {
+    const connectivity = analyze ? analyzePortConnectivity(node, nodes) : null;
+    const affectedIds = [
+        node.id,
+        ...(connectivity?.connections.map((c) => c.nodeId) ?? []),
+    ];
+    const followUpdates = (nextPath) => {
+        if (!connectivity)
+            return [];
+        const preview = {
+            ...node,
+            path: nextPath,
+        };
+        return resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+    };
+    return { connectivity, affectedIds, followUpdates };
+}
+export function createSegmentMoveAffordance(kind) {
+    return {
+        start({ node, payload, nodes }) {
+            const { segmentIndex, normal } = payload;
+            const initialPath = node.path.map((p) => [...p]);
+            const a = initialPath[segmentIndex];
+            const b = initialPath[segmentIndex + 1];
+            if (!a || !b)
+                return { ...inert, affectedIds: [node.id] };
+            const lastIndex = initialPath.length - 1;
+            // A moved vertex bears a port only if it's a run end.
+            const touchesEnd = segmentIndex === 0 || segmentIndex + 1 === lastIndex;
+            const { affectedIds, followUpdates } = makeConnectivity(node, nodes, touchesEnd);
+            const mid = [(a[0] + b[0]) / 2, (a[2] + b[2]) / 2];
+            return {
+                affectedIds,
+                apply({ planPoint, modifiers }) {
+                    // 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.
+                    const signedRaw = (planPoint[0] - mid[0]) * normal[0] + (planPoint[1] - mid[1]) * normal[1];
+                    const signed = modifiers.shiftKey ? signedRaw : snapPointToGrid([signedRaw, 0])[0];
+                    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);
+                    useScene.getState().updateNodes([
+                        { id: node.id, data: { path: nextPath } },
+                        ...followUpdates(nextPath).map((u) => ({
+                            id: u.id,
+                            data: u.data,
+                        })),
+                    ]);
+                },
+                canCommit() {
+                    const final = useScene.getState().nodes[node.id];
+                    return (!!final &&
+                        final.type === kind &&
+                        final.path.length >= 2);
+                },
+            };
+        },
+    };
+}

package/dist/shared/pipe-run-translation-offset.d.ts

@@ -0,0 +1,27 @@
+import { type AnyNode, type AnyNodeId, PipeSegmentNode, type PortConnection } from '@pascal-app/core';
+import type { PipeFittingNode } from '../pipe-fitting/schema';
+import type { ScenePort } from './ports';
+type Point = [number, number, number];
+type PipeProfile = {
+    diameter: number;
+    pipeMaterial: PipeFittingNode['pipeMaterial'];
+};
+export type PipeRunTranslationOffsetPlan = {
+    pipePath: Point[];
+    fittings: PipeFittingNode[];
+    connectors: PipeSegmentNode[];
+    updates: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+};
+export declare function planPipeRunTranslationOffsets(args: {
+    pipe: PipeSegmentNode;
+    translatedPath: Point[];
+    profile: PipeProfile;
+    connections: PortConnection[];
+    scenePorts: ScenePort[];
+    nodesById: Record<string, AnyNode>;
+}): PipeRunTranslationOffsetPlan | null;
+export {};
+//# sourceMappingURL=pipe-run-translation-offset.d.ts.map

package/dist/shared/pipe-run-translation-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-run-translation-offset.d.ts","sourceRoot":"","sources":["../../src/shared/pipe-run-translation-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;CAC9C,CAAA;AAKD,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,KAAK,EAAE,CAAA;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,UAAU,EAAE,eAAe,EAAE,CAAA;IAC7B,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;CACrD,CAAA;AA8DD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,eAAe,CAAA;IACrB,cAAc,EAAE,KAAK,EAAE,CAAA;IACvB,OAAO,EAAE,WAAW,CAAA;IACpB,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,GAAG,4BAA4B,GAAG,IAAI,CAuFtC"}