@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/pipe-fitting/definition.js

@@ -1,5 +1,7 @@
 import { useScene } from '@pascal-app/core';
 import { getRotationAxis, rotateEulerWorld } from '../shared/fitting-rotation';
+import { pipeFittingToolOptions } from '../shared/fitting-tool-options';
+import { pipeFittingQuickActions } from '../shared/mep-fitting-actions';
 import { buildPipeFittingFloorplan } from './floorplan';
 import { buildPipeFittingGeometry } from './geometry';
 import { pipeFittingParametrics } from './parametrics';
@@ -13,7 +15,7 @@ import { PipeFittingNode } from './schema';
  */
 export const pipeFittingDefinition = {
     kind: 'pipe-fitting',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: PipeFittingNode,
     category: 'utility',
     distributionRole: 'fitting',
@@ -25,6 +27,7 @@ export const pipeFittingDefinition = {
         metadata: {},
         position: [0, 0, 0],
         rotation: [0, 0, 0],
+        cleanoutStyle: 'end',
         fittingType: 'elbow',
         angle: 90,
         diameter: 2,
@@ -40,9 +43,19 @@ export const pipeFittingDefinition = {
     },
     parametrics: pipeFittingParametrics,
     geometry: buildPipeFittingGeometry,
-    geometryKey: (n) => JSON.stringify([n.fittingType, n.angle, n.diameter, n.diameter2, n.pipeMaterial, n.system]),
+    geometryKey: (n) => JSON.stringify([
+        n.fittingType,
+        n.cleanoutStyle,
+        n.angle,
+        n.diameter,
+        n.diameter2,
+        n.pipeMaterial,
+        n.system,
+    ]),
     ports: getPipeFittingPorts,
     floorplan: buildPipeFittingFloorplan,
+    quickActions: pipeFittingQuickActions,
+    quickActionNodeScope: 'level',
     // R/T rotate a selected fitting ±45° around the shared active axis —
     // same scheme as duct fittings (the default editor rotate only knows
     // Y; DWV stacks need X/Z). Alt-cycling lives in `./selection.tsx`.
@@ -68,6 +81,7 @@ export const pipeFittingDefinition = {
         selection: () => import('./selection'),
         move: () => import('./move-tool'),
     },
+    toolOptions: pipeFittingToolOptions,
     tool: () => import('./tool'),
     toolHints: [
         { key: 'Click', label: 'Place fitting' },

package/dist/pipe-fitting/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwC1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAK1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA0C1B"}

package/dist/pipe-fitting/floorplan.js

@@ -1,4 +1,6 @@
 import { INCHES_TO_METERS } from '../duct-segment/geometry';
+import { accessoryFloorplan } from '../shared/accessory-floorplan';
+import { buildPipeFittingGeometry } from './geometry';
 import { getPipeFittingPorts } from './ports';
 const WASTE_COLOR = '#57534e';
 const VENT_COLOR = '#78716c';
@@ -9,6 +11,8 @@ const VENT_COLOR = '#78716c';
  * hub, which is how they should read from above.
  */
 export function buildPipeFittingFloorplan(node, ctx) {
+    if (['end-cap', 'cleanout', 'reducer', 'coupling'].includes(node.fittingType))
+        return accessoryFloorplan(buildPipeFittingGeometry(node), node, ctx);
     const [cx, , cz] = node.position;
     const view = ctx.viewState;
     const palette = view?.palette;

package/dist/pipe-fitting/geometry.d.ts

@@ -1,11 +1,9 @@
 import { Group } from 'three';
 import type { PipeFittingNode } from './schema';
 /**
- * Pure geometry builder for a DWV fitting, in the node's LOCAL frame.
- * One cylinder stub per port from the junction outward, an oversized
- * hub sphere at the junction, and a smaller hub at each collar opening
- * (solvent-weld couplings). Wyes read correctly because their branch
- * stub leaves at 45° — the port layout does the work.
+ * Pure local-frame DWV fitting geometry. Ports remain the network contract;
+ * the model grows inward from each collar so replacing the old primitives does
+ * not move any connected pipe endpoint.
  */
 export declare function buildPipeFittingGeometry(node: PipeFittingNode): Group;
 //# sourceMappingURL=geometry.d.ts.map

package/dist/pipe-fitting/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAiC,MAAM,OAAO,CAAA;AAI5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAI/C;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CA0BrE"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,EASN,MAAM,OAAO,CAAA;AAKd,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAwN/C;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAoFrE"}

package/dist/pipe-fitting/geometry.js

@@ -1,31 +1,164 @@
-import { Group, Mesh, SphereGeometry, Vector3 } from 'three';
-import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
+import { CubicBezierCurve3, CylinderGeometry, Group, LineCurve3, Mesh, Quaternion, RingGeometry, SphereGeometry, TubeGeometry, Vector3, } from 'three';
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
 import { createPipeMaterial } from '../pipe-segment/geometry';
+import { addPlug, addProfile } from '../shared/accessory-geometry';
 import { localPipeFittingPorts } from './ports';
-const RADIAL_SEGMENTS = 20;
+const RADIAL_SEGMENTS = 28;
+const SWEEP_SEGMENTS = 32;
+const Y_AXIS = new Vector3(0, 1, 0);
+const Z_AXIS = new Vector3(0, 0, 1);
+function pipeRadius(diameterInches) {
+    return (diameterInches * INCHES_TO_METERS) / 2;
+}
+function addSocket(group, port, material, pipeMaterial) {
+    const radius = pipeRadius(port.diameter);
+    const bodyRadius = radius * 1.08;
+    const socketRadius = radius * (pipeMaterial === 'cast-iron' ? 1.18 : 1.3);
+    const portLength = port.position.length();
+    const socketDepth = Math.min(portLength * 0.42, Math.max(0.022, radius * 1.05));
+    const shoulderDepth = Math.min(portLength * 0.16, Math.max(0.006, radius * 0.32));
+    const direction = port.direction.clone().normalize();
+    const axisRotation = new Quaternion().setFromUnitVectors(Y_AXIS, direction);
+    const socket = new Mesh(new CylinderGeometry(socketRadius, socketRadius, socketDepth, RADIAL_SEGMENTS, 1, true), material);
+    socket.name = `pipe-fitting-socket-${port.id}`;
+    socket.position.copy(port.position).addScaledVector(direction, -socketDepth / 2);
+    socket.quaternion.copy(axisRotation);
+    group.add(socket);
+    const shoulder = new Mesh(new CylinderGeometry(socketRadius, bodyRadius, shoulderDepth, RADIAL_SEGMENTS, 1, true), material);
+    shoulder.name = `pipe-fitting-shoulder-${port.id}`;
+    shoulder.position
+        .copy(port.position)
+        .addScaledVector(direction, -(socketDepth + shoulderDepth / 2));
+    shoulder.quaternion.copy(axisRotation);
+    group.add(shoulder);
+    const rim = new Mesh(new RingGeometry(radius * 0.82, socketRadius, RADIAL_SEGMENTS), material);
+    rim.name = `pipe-fitting-rim-${port.id}`;
+    rim.position.copy(port.position).addScaledVector(direction, 0.0005);
+    rim.quaternion.setFromUnitVectors(Z_AXIS, direction);
+    group.add(rim);
+    if (pipeMaterial === 'cast-iron') {
+        for (const offset of [0.22, 0.72]) {
+            const band = new Mesh(new CylinderGeometry(socketRadius * 1.035, socketRadius * 1.035, 0.006, RADIAL_SEGMENTS), material);
+            band.name = `pipe-fitting-band-${port.id}-${offset}`;
+            band.position.copy(port.position).addScaledVector(direction, -socketDepth * offset);
+            band.quaternion.copy(axisRotation);
+            group.add(band);
+        }
+    }
+    else {
+        const stopRing = new Mesh(new CylinderGeometry(socketRadius * 1.035, socketRadius * 1.035, 0.006, RADIAL_SEGMENTS), material);
+        stopRing.name = `pipe-fitting-stop-${port.id}`;
+        stopRing.position.copy(port.position).addScaledVector(direction, -socketDepth * 0.88);
+        stopRing.quaternion.copy(axisRotation);
+        group.add(stopRing);
+    }
+    return {
+        bodyPoint: port.position.clone().addScaledVector(direction, -(socketDepth + shoulderDepth)),
+        bodyRadius,
+    };
+}
+function addStraight(group, start, end, radius, material, name) {
+    if (start.distanceToSquared(end) < 1e-8)
+        return;
+    const body = new Mesh(new TubeGeometry(new LineCurve3(start, end), 1, radius, RADIAL_SEGMENTS, false), material);
+    body.name = name;
+    group.add(body);
+}
+function addSweep(group, start, startTangent, end, endTangent, radius, material, name) {
+    const distance = start.distanceTo(end);
+    if (distance < 1e-5)
+        return;
+    const handle = Math.max(distance * 0.48, radius * 1.6);
+    const curve = new CubicBezierCurve3(start, start.clone().addScaledVector(startTangent.clone().normalize(), handle), end.clone().addScaledVector(endTangent.clone().normalize(), -handle), end);
+    const body = new Mesh(new TubeGeometry(curve, SWEEP_SEGMENTS, radius, RADIAL_SEGMENTS, false), material);
+    body.name = name;
+    group.add(body);
+}
+function addJunctionBlend(group, position, radius, material, name) {
+    const blend = new Mesh(new SphereGeometry(radius * 1.03, RADIAL_SEGMENTS, 18), material);
+    blend.name = name;
+    blend.position.copy(position);
+    group.add(blend);
+}
+function buildElbow(group, ports, sockets, material) {
+    const inlet = ports.find((port) => port.id === 'inlet');
+    const outlet = ports.find((port) => port.id === 'outlet');
+    if (!(inlet && outlet))
+        return;
+    const inletSocket = sockets.get(inlet.id);
+    const outletSocket = sockets.get(outlet.id);
+    if (!(inletSocket && outletSocket))
+        return;
+    addSweep(group, inletSocket.bodyPoint, inlet.direction.clone().negate(), outletSocket.bodyPoint, outlet.direction, inletSocket.bodyRadius, material, 'pipe-fitting-elbow-sweep');
+}
+function buildBranchFitting(group, node, ports, sockets, material) {
+    const inlet = ports.find((port) => port.id === 'inlet');
+    const outlet = ports.find((port) => port.id === 'outlet');
+    const inletSocket = inlet ? sockets.get(inlet.id) : null;
+    const outletSocket = outlet ? sockets.get(outlet.id) : null;
+    if (!(inlet && outlet && inletSocket && outletSocket))
+        return;
+    addStraight(group, inletSocket.bodyPoint, outletSocket.bodyPoint, inletSocket.bodyRadius, material, `pipe-fitting-${node.fittingType}-run`);
+    const runSpan = inletSocket.bodyPoint.distanceTo(outletSocket.bodyPoint);
+    const merge = new Vector3(runSpan * 0.1, 0, 0);
+    for (const branchId of node.fittingType === 'cross' ? ['branch', 'branch2'] : ['branch']) {
+        const branch = ports.find((port) => port.id === branchId);
+        const branchSocket = branch ? sockets.get(branch.id) : null;
+        if (!(branch && branchSocket))
+            continue;
+        addSweep(group, branchSocket.bodyPoint, branch.direction.clone().negate(), merge, new Vector3(1, 0, 0), branchSocket.bodyRadius, material, `pipe-fitting-${node.fittingType}-${branchId}-sweep`);
+    }
+    addJunctionBlend(group, merge, Math.max(inletSocket.bodyRadius, pipeRadius(node.diameter2) * 1.08), material, `pipe-fitting-${node.fittingType}-blend`);
+}
 /**
- * Pure geometry builder for a DWV fitting, in the node's LOCAL frame.
- * One cylinder stub per port from the junction outward, an oversized
- * hub sphere at the junction, and a smaller hub at each collar opening
- * (solvent-weld couplings). Wyes read correctly because their branch
- * stub leaves at 45° — the port layout does the work.
+ * Pure local-frame DWV fitting geometry. Ports remain the network contract;
+ * the model grows inward from each collar so replacing the old primitives does
+ * not move any connected pipe endpoint.
  */
 export function buildPipeFittingGeometry(node) {
     const group = new Group();
     const material = createPipeMaterial(node);
-    const radiusRun = (node.diameter * INCHES_TO_METERS) / 2;
-    for (const port of localPipeFittingPorts(node)) {
-        const radius = (port.diameter * INCHES_TO_METERS) / 2;
-        const stub = buildSection(new Vector3(0, 0, 0), port.position, radius, material, `pipe-fitting-stub-${port.id}`);
-        if (stub)
-            group.add(stub);
-        const hub = new Mesh(new SphereGeometry(radius * 1.18, RADIAL_SEGMENTS, 12), material);
-        hub.name = `pipe-fitting-hub-${port.id}`;
-        hub.position.copy(port.position);
-        group.add(hub);
+    const ports = localPipeFittingPorts(node);
+    const sockets = new Map();
+    for (const port of ports) {
+        sockets.set(port.id, addSocket(group, port, material, node.pipeMaterial));
+    }
+    if (node.fittingType === 'end-cap' ||
+        node.fittingType === 'cleanout' ||
+        node.fittingType === 'coupling' ||
+        node.fittingType === 'reducer') {
+        const inlet = sockets.get('inlet');
+        const outlet = sockets.get('outlet');
+        const radius = inlet.bodyRadius;
+        if (node.fittingType === 'reducer' && outlet) {
+            const taper = new Mesh(new CylinderGeometry(outlet.bodyRadius, radius, outlet.bodyPoint.x - inlet.bodyPoint.x, RADIAL_SEGMENTS, 1, true), material);
+            taper.name = 'pipe-reducer-taper';
+            taper.quaternion.setFromUnitVectors(Y_AXIS, new Vector3(1, 0, 0));
+            taper.position.x = (outlet.bodyPoint.x + inlet.bodyPoint.x) / 2;
+            group.add(taper);
+        }
+        else {
+            const end = outlet?.bodyPoint.x ?? 0.025;
+            addProfile(group, 'pipe-accessory-body', 'round', radius * 2, radius * 2, inlet.bodyPoint.x, end, material, radius * 0.16);
+            if (node.fittingType === 'end-cap')
+                addProfile(group, 'pipe-end-cap-closure', 'round', radius * 2, radius * 2, end - 0.004, end, material);
+            if (node.fittingType === 'cleanout') {
+                if (outlet) {
+                    const service = new Group();
+                    service.name = 'cleanout-service-branch';
+                    addProfile(service, 'cleanout-neck', 'round', radius * 2, radius * 2, 0, radius * 2, material, radius * 0.16);
+                    addPlug(service, radius, radius * 2, material);
+                    service.rotation.z = Math.PI / 2;
+                    group.add(service);
+                }
+                else
+                    addPlug(group, radius, end, material);
+            }
+        }
     }
-    const junction = new Mesh(new SphereGeometry(radiusRun * 1.18, RADIAL_SEGMENTS, 12), material);
-    junction.name = 'pipe-fitting-junction';
-    group.add(junction);
+    else if (node.fittingType === 'elbow')
+        buildElbow(group, ports, sockets, material);
+    else
+        buildBranchFitting(group, node, ports, sockets, material);
     return group;
 }

package/dist/pipe-fitting/inline-insertion.d.ts

@@ -0,0 +1,13 @@
+import { PipeFittingNode, PipeSegmentNode } from '@pascal-app/core';
+import type { RunBodyHit } from '../shared/ports';
+export type PipeInlineInsertionPlan = {
+    fitting: PipeFittingNode;
+    runUpdate: {
+        id: PipeSegmentNode['id'];
+        data: Partial<PipeSegmentNode>;
+    };
+    runTail: PipeSegmentNode;
+};
+export declare function isInlinePipeFitting(node: PipeFittingNode): boolean;
+export declare function planPipeInlineInsertion(run: PipeSegmentNode, hit: RunBodyHit, template: PipeFittingNode): PipeInlineInsertionPlan | null;
+//# sourceMappingURL=inline-insertion.d.ts.map

package/dist/pipe-fitting/inline-insertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-insertion.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/inline-insertion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAOjD,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,eAAe,CAAA;IACxB,SAAS,EAAE;QAAE,EAAE,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAA;KAAE,CAAA;IACxE,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAMlE;AAmCD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,eAAe,GACxB,uBAAuB,GAAG,IAAI,CAqEhC"}

package/dist/pipe-fitting/inline-insertion.js

@@ -0,0 +1,96 @@
+import { PipeFittingNode, PipeSegmentNode } from '@pascal-app/core';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { pipeFittingLegLength } from './ports';
+const MIN_PIPE_STUB_M = 0.05;
+export function isInlinePipeFitting(node) {
+    return (node.fittingType === 'coupling' ||
+        node.fittingType === 'reducer' ||
+        (node.fittingType === 'cleanout' && node.cleanoutStyle === 'inline'));
+}
+function splitWallAttachment(run, hit) {
+    const attachment = run.wallAttachment;
+    if (!attachment)
+        return {};
+    let distanceBefore = 0;
+    let totalDistance = 0;
+    for (let index = 0; index < run.path.length - 1; index++) {
+        const length = new Vector3(...run.path[index + 1]).distanceTo(new Vector3(...run.path[index]));
+        if (index < hit.segmentIndex)
+            distanceBefore += length;
+        totalDistance += length;
+    }
+    if (totalDistance < 1e-8)
+        return {};
+    const segmentStart = new Vector3(...run.path[hit.segmentIndex]);
+    const hitDistance = segmentStart.distanceTo(new Vector3(...hit.point));
+    const ratio = Math.min(1, Math.max(0, (distanceBefore + hitDistance) / totalDistance));
+    const splitUV = [
+        attachment.startUV[0] + (attachment.endUV[0] - attachment.startUV[0]) * ratio,
+        attachment.startUV[1] + (attachment.endUV[1] - attachment.startUV[1]) * ratio,
+    ];
+    return {
+        head: { ...attachment, endUV: splitUV },
+        tail: { ...attachment, startUV: splitUV },
+    };
+}
+export function planPipeInlineInsertion(run, hit, template) {
+    if (!isInlinePipeFitting(template))
+        return null;
+    const a = run.path[hit.segmentIndex];
+    const b = run.path[hit.segmentIndex + 1];
+    if (!a || !b)
+        return null;
+    const axis = new Vector3(...b).sub(new Vector3(...a));
+    if (axis.lengthSq() < 1e-10)
+        return null;
+    axis.normalize();
+    const fitting = PipeFittingNode.parse({
+        ...template,
+        diameter: run.diameter,
+        pipeMaterial: run.pipeMaterial,
+        system: run.system,
+        position: hit.point,
+        rotation: (() => {
+            const euler = new Euler().setFromQuaternion(new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), axis));
+            return [euler.x, euler.y, euler.z];
+        })(),
+    });
+    const legLength = pipeFittingLegLength(fitting.fittingType === 'reducer'
+        ? Math.max(fitting.diameter, fitting.diameter2)
+        : fitting.diameter);
+    const center = new Vector3(...hit.point);
+    if (center.distanceTo(new Vector3(...a)) < legLength + MIN_PIPE_STUB_M ||
+        center.distanceTo(new Vector3(...b)) < legLength + MIN_PIPE_STUB_M) {
+        return null;
+    }
+    const inlet = center.clone().addScaledVector(axis, -legLength);
+    const outlet = center.clone().addScaledVector(axis, legLength);
+    const upstreamPath = [
+        ...run.path.slice(0, hit.segmentIndex + 1).map((point) => [...point]),
+        inlet.toArray(),
+    ];
+    const tailPath = [
+        outlet.toArray(),
+        ...run.path.slice(hit.segmentIndex + 1).map((point) => [...point]),
+    ];
+    const wallAttachment = splitWallAttachment(run, hit);
+    const tailDiameter = fitting.fittingType === 'reducer' ? fitting.diameter2 : run.diameter;
+    const runTail = PipeSegmentNode.parse({
+        ...run,
+        id: undefined,
+        path: tailPath,
+        diameter: tailDiameter,
+        ...(wallAttachment.tail ? { wallAttachment: wallAttachment.tail } : {}),
+    });
+    return {
+        fitting,
+        runUpdate: {
+            id: run.id,
+            data: {
+                path: upstreamPath,
+                ...(wallAttachment.head ? { wallAttachment: wallAttachment.head } : {}),
+            },
+        },
+        runTail,
+    };
+}

package/dist/pipe-fitting/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,oBAAoB,EAAmB,MAAM,kBAAkB,CAAA;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkC/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA0ExE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,oBAAoB,EAAmB,MAAM,kBAAkB,CAAA;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkC/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAwFxE,CAAA"}

package/dist/pipe-fitting/parametrics.js

@@ -58,8 +58,22 @@ export const pipeFittingParametrics = {
                 {
                     key: 'fittingType',
                     kind: 'enum',
-                    options: ['elbow', 'wye', 'sanitary-tee', 'cross'],
-                    display: 'segmented',
+                    options: [
+                        'elbow',
+                        'wye',
+                        'sanitary-tee',
+                        'cross',
+                        'end-cap',
+                        'cleanout',
+                        'reducer',
+                        'coupling',
+                    ],
+                },
+                {
+                    key: 'cleanoutStyle',
+                    kind: 'enum',
+                    options: ['end', 'inline'],
+                    visibleIf: (n) => n.fittingType === 'cleanout',
                 },
                 {
                     key: 'angle',
@@ -89,7 +103,7 @@ export const pipeFittingParametrics = {
                     min: 1.25,
                     max: 6,
                     step: 0.25,
-                    visibleIf: (n) => n.fittingType !== 'elbow',
+                    visibleIf: (n) => ['wye', 'sanitary-tee', 'cross', 'reducer'].includes(n.fittingType),
                 },
                 { key: 'pipeMaterial', kind: 'enum', options: ['pvc', 'abs', 'cast-iron'] },
             ],

package/dist/pipe-fitting/ports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAS,OAAO,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C;sDACsD;AACtD,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,gDAAgD;AAChD,eAAO,MAAM,cAAc,QAAc,CAAA;AAEzC,KAAK,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAExF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,EAAE,CA4DxE;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,QAAQ,EAAE,CAcrE"}
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAS,OAAO,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C;sDACsD;AACtD,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,gDAAgD;AAChD,eAAO,MAAM,cAAc,QAAc,CAAA;AAEzC,KAAK,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAExF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,EAAE,CAqExE;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,QAAQ,EAAE,CAcrE"}

package/dist/pipe-fitting/ports.js

@@ -16,13 +16,16 @@ export const WYE_BRANCH_RAD = Math.PI / 4;
  * run along X, two opposed branches on ±Z.
  */
 export function localPipeFittingPorts(node) {
-    const run = pipeFittingLegLength(node.diameter);
+    const run = pipeFittingLegLength(node.fittingType === 'reducer' ? Math.max(node.diameter, node.diameter2) : node.diameter);
     const inlet = {
         id: 'inlet',
         position: new Vector3(-run, 0, 0),
         direction: new Vector3(-1, 0, 0),
         diameter: node.diameter,
     };
+    if (node.fittingType === 'end-cap' ||
+        (node.fittingType === 'cleanout' && node.cleanoutStyle === 'end'))
+        return [inlet];
     if (node.fittingType === 'elbow') {
         const theta = (node.angle * Math.PI) / 180;
         const outDir = new Vector3(Math.cos(theta), 0, Math.sin(theta));
@@ -42,6 +45,10 @@ export function localPipeFittingPorts(node) {
         direction: new Vector3(1, 0, 0),
         diameter: node.diameter,
     };
+    if (node.fittingType === 'reducer')
+        return [inlet, { ...outlet, diameter: node.diameter2 }];
+    if (node.fittingType === 'coupling' || node.fittingType === 'cleanout')
+        return [inlet, outlet];
     const branchLeg = pipeFittingLegLength(node.diameter2);
     if (node.fittingType === 'cross') {
         return [

package/dist/pipe-fitting/tool.d.ts

@@ -1,3 +1,29 @@
+import { type AnyNode, type AnyNodeId, PipeFittingNode } from '@pascal-app/core';
+import { Quaternion } from 'three';
+import { type ScenePort } from '../shared/ports';
+import { type PipeInlineInsertionPlan } from './inline-insertion';
+type Placement = {
+    position: [number, number, number];
+    rotation: [number, number, number];
+    snapPort: ScenePort | null;
+    insertion: PipeInlineInsertionPlan | null;
+    node: PipeFittingNode;
+    valid: boolean;
+};
+type PlacementContext = {
+    levelId: AnyNodeId | null;
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>;
+};
+/**
+ * Resolve where the fitting would land for a cursor at `raw`:
+ *   - Near an existing DWV port → mate: orientation aligns the inlet
+ *     onto the port (plus the user's manual R/T rotation, pivoting
+ *     around the inlet collar so it stays on the port while the body
+ *     sweeps).
+ *   - Otherwise → grid-snapped free placement on the floor, manual
+ *     rotation only.
+ */
+export declare function resolvePlacement(raw: [number, number, number], previewNode: PipeFittingNode, gridStep: number, manualQuat: Quaternion, surfaceHit: boolean, surfaceNormal?: [number, number, number], support?: (node: import("@pascal-app/core").DuctFittingNode | PipeFittingNode, rotation: [number, number, number], position: [number, number, number], surfacePoint: [number, number, number], surfaceNormal?: [number, number, number]) => [number, number, number], context?: PlacementContext): Placement;
 /**
  * Click-place tool for DWV pipe fittings (elbow / wye / sanitary tee) —
  * the plumbing sibling of the duct-fitting tool.

package/dist/pipe-fitting/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/tool.tsx"],"names":[],"mappings":"AA2FA;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,eAAe,0CAuJpB,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAazB,OAAO,EAAoD,UAAU,EAAW,MAAM,OAAO,CAAA;AAkB7F,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,oBAAoB,CAAA;AAK3B,KAAK,SAAS,GAAG;IACf,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,uBAAuB,GAAG,IAAI,CAAA;IACzC,IAAI,EAAE,eAAe,CAAA;IACrB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAC5C,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,eAAe,EAC5B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,OAAO,EACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,OAAO,6PAAgC,EACvC,OAAO,GAAE,gBAA+C,GACvD,SAAS,CAkGX;AAED;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,eAAe,0CAoPpB,CAAA;AAED,eAAe,eAAe,CAAA"}