@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/shared/dormer-wall-opening-placement.d.ts

@@ -0,0 +1,21 @@
+import { type AnyNode, type DormerEvent, type DormerNode, type WindowEvent, type WindowNode } from '@pascal-app/core';
+import { type Object3D, Vector3 } from 'three';
+export type DormerWindowTarget = {
+    dormer: DormerNode;
+    face: NonNullable<WindowNode['dormerFace']>;
+    position: [number, number, number];
+    valid: boolean;
+};
+export declare function dormerEventFromHostedWindow(event: WindowEvent, dormer: DormerNode, object: Object3D): DormerEvent;
+export declare function getDormerWindowWorldYaw(event: DormerEvent, target: DormerWindowTarget): number;
+export declare function getDormerWindowWorldNormal(event: DormerEvent, target: DormerWindowTarget, out?: Vector3): Vector3;
+export declare function shouldWriteDormerWindowPreviewHost(node: WindowNode, target: DormerWindowTarget): boolean;
+export declare function resolveDormerWindowTarget(args: {
+    event: DormerEvent;
+    width: number;
+    height: number;
+    nodes: Readonly<Record<string, AnyNode>>;
+    ignoreId?: string;
+    snap?: (value: number) => number;
+}): DormerWindowTarget | null;
+//# sourceMappingURL=dormer-wall-opening-placement.d.ts.map

package/dist/shared/dormer-wall-opening-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dormer-wall-opening-placement.d.ts","sourceRoot":"","sources":["../../src/shared/dormer-wall-opening-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,UAAU,EAIf,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAE9C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,WAAW,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAA;IAC3C,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAID,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,GACf,WAAW,CAuBb;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAG9F;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,kBAAkB,EAC1B,GAAG,UAAmB,GACrB,OAAO,CAMT;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAUT;AAqDD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,KAAK,EAAE,WAAW,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACjC,GAAG,kBAAkB,GAAG,IAAI,CAuB5B"}

package/dist/shared/dormer-wall-opening-placement.js

@@ -0,0 +1,101 @@
+import { dormerPointToWallFace, getDormerWallFaceFrame, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
+import { Vector3 } from 'three';
+const dormerFaceNormal = new Vector3();
+export function dormerEventFromHostedWindow(event, dormer, object) {
+    object.updateWorldMatrix(true, false);
+    const localPoint = object.worldToLocal(new Vector3(...event.position));
+    const face = event.node.dormerFace ?? 'front';
+    const normal = face === 'front'
+        ? [0, 0, 1]
+        : face === 'back'
+            ? [0, 0, -1]
+            : face === 'right'
+                ? [1, 0, 0]
+                : [-1, 0, 0];
+    return {
+        node: dormer,
+        normal,
+        object,
+        position: event.position,
+        localPosition: [localPoint.x, localPoint.y, localPoint.z],
+        faceIndex: event.faceIndex,
+        nativeEvent: event.nativeEvent,
+        stopPropagation: event.stopPropagation,
+    };
+}
+export function getDormerWindowWorldYaw(event, target) {
+    const normal = getDormerWindowWorldNormal(event, target);
+    return Math.atan2(normal.x, normal.z);
+}
+export function getDormerWindowWorldNormal(event, target, out = dormerFaceNormal) {
+    const frame = getDormerWallFaceFrame(event.node, target.face);
+    event.object.updateWorldMatrix(true, false);
+    return out
+        .set(Math.sin(frame.yaw), 0, Math.cos(frame.yaw))
+        .transformDirection(event.object.matrixWorld);
+}
+export function shouldWriteDormerWindowPreviewHost(node, target) {
+    return (node.parentId !== target.dormer.id ||
+        node.dormerId !== target.dormer.id ||
+        node.dormerFace !== target.face ||
+        node.wallId !== undefined ||
+        node.roofSegmentId !== undefined ||
+        node.roofFace !== undefined ||
+        node.visible !== false);
+}
+function faceFromNormal(normal) {
+    if (!normal)
+        return null;
+    const [x, , z] = normal;
+    if (Math.abs(z) >= Math.abs(x))
+        return z >= 0 ? 'front' : 'back';
+    return x >= 0 ? 'right' : 'left';
+}
+function faceFromPoint(dormer, point) {
+    const distances = [
+        { face: 'front', distance: Math.abs(point[2] - dormer.depth / 2) },
+        { face: 'back', distance: Math.abs(point[2] + dormer.depth / 2) },
+        { face: 'right', distance: Math.abs(point[0] - dormer.width / 2) },
+        { face: 'left', distance: Math.abs(point[0] + dormer.width / 2) },
+    ];
+    return distances.reduce((closest, current) => current.distance < closest.distance ? current : closest).face;
+}
+function hasWindowOverlap(dormer, nodes, face, position, width, height, ignoreId) {
+    const left = position[0] - width / 2;
+    const right = position[0] + width / 2;
+    const bottom = position[1] - height / 2;
+    const top = position[1] + height / 2;
+    return (dormer.children ?? []).some((childId) => {
+        if (childId === ignoreId)
+            return false;
+        const child = nodes[childId];
+        if (child?.type !== 'window' || child.dormerFace !== face)
+            return false;
+        return (Math.abs(child.position[0] - position[0]) < (child.width + width) / 2 &&
+            Math.abs(child.position[1] - position[1]) < (child.height + height) / 2 &&
+            child.position[0] + child.width / 2 > left &&
+            child.position[0] - child.width / 2 < right &&
+            child.position[1] + child.height / 2 > bottom &&
+            child.position[1] - child.height / 2 < top);
+    });
+}
+export function resolveDormerWindowTarget(args) {
+    const { event, width, height, nodes, ignoreId, snap = (value) => value } = args;
+    const face = faceFromNormal(event.normal) ?? faceFromPoint(event.node, event.localPosition);
+    const point = dormerPointToWallFace(event.node, face, event.localPosition);
+    const frame = getDormerWallFaceFrame(event.node, face);
+    const clampedX = Math.max(-frame.width / 2 + width / 2, Math.min(frame.width / 2 - width / 2, snap(point[0])));
+    const vertical = getDormerWallOpeningVerticalBounds(event.node, face, clampedX, width);
+    const minY = vertical.min + height / 2;
+    const maxY = vertical.max - height / 2;
+    if (maxY < minY)
+        return null;
+    const clampedY = Math.max(minY, Math.min(maxY, snap(point[1])));
+    const position = [clampedX, clampedY, 0];
+    return {
+        dormer: event.node,
+        face,
+        position,
+        valid: !hasWindowOverlap(event.node, nodes, face, position, width, height, ignoreId),
+    };
+}

package/dist/shared/duct-adapter.d.ts

@@ -0,0 +1,10 @@
+import { DuctFittingNode } from '@pascal-app/core';
+import { Vector3 } from 'three';
+import { type DuctProfile } from './auto-fitting';
+import type { ScenePort } from './ports';
+export declare function ductProfilesMatch(a: DuctProfile, b: DuctProfile): boolean;
+export declare function planDuctAdapter(port: ScenePort, source: DuctProfile, target: DuctProfile, widthAxis?: Vector3): {
+    fitting: DuctFittingNode;
+    collarPoint: [number, number, number];
+} | null;
+//# sourceMappingURL=duct-adapter.d.ts.map

package/dist/shared/duct-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duct-adapter.d.ts","sourceRoot":"","sources":["../../src/shared/duct-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAkB,OAAO,EAAE,MAAM,OAAO,CAAA;AAG/C,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,gBAAgB,CAAA;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAOzE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,OAAO,GAClB;IAAE,OAAO,EAAE,eAAe,CAAC;IAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CA6B5E"}

package/dist/shared/duct-adapter.js

@@ -0,0 +1,43 @@
+import { DuctFittingNode } from '@pascal-app/core';
+import { Euler, Matrix4, Vector3 } from 'three';
+import { fittingLegLength } from '../duct-fitting/ports';
+import { rectSectionAxes } from '../duct-segment/geometry';
+import { profileDiameterIn } from './auto-fitting';
+export function ductProfilesMatch(a, b) {
+    return (a.shape === b.shape &&
+        (a.shape === 'round'
+            ? Math.abs(a.diameter - b.diameter) < 1e-5
+            : Math.abs(a.width - b.width) < 1e-5 && Math.abs(a.height - b.height) < 1e-5));
+}
+export function planDuctAdapter(port, source, target, widthAxis) {
+    if (ductProfilesMatch(source, target))
+        return null;
+    const axis = new Vector3(...port.direction).normalize();
+    if (axis.lengthSq() < 1e-10)
+        return null;
+    const width = widthAxis?.clone() ?? rectSectionAxes(axis).width;
+    const height = new Vector3().crossVectors(width, axis).normalize();
+    const rotation = new Euler().setFromRotationMatrix(new Matrix4().makeBasis(axis, height, width));
+    const diameter = profileDiameterIn(source);
+    const leg = fittingLegLength(diameter);
+    const position = new Vector3(...port.position).addScaledVector(axis, leg);
+    const fittingType = source.shape === target.shape ? 'reducer' : 'transition';
+    const fitting = DuctFittingNode.parse({
+        fittingType,
+        name: fittingType === 'reducer' ? 'Reducer' : 'Transition',
+        position: position.toArray(),
+        rotation: [rotation.x, rotation.y, rotation.z],
+        inletShape: source.shape,
+        outletShape: target.shape,
+        shape: source.shape,
+        shape2: target.shape,
+        diameter,
+        diameter2: profileDiameterIn(target),
+        width: source.width,
+        height: source.height,
+        width2: target.width,
+        height2: target.height,
+        system: port.system === 'return' ? 'return' : 'supply',
+    });
+    return { fitting, collarPoint: position.addScaledVector(axis, leg).toArray() };
+}

package/dist/shared/elbow-branch-continuation.d.ts

@@ -0,0 +1,20 @@
+import { type AnyNode, type AnyNodeId, DuctFittingNode, PipeFittingNode } from '@pascal-app/core';
+import type { ScenePort } from './ports';
+type Point = [number, number, number];
+export type ElbowBranchPromotion<T> = {
+    fitting: T;
+    continuationPort: ScenePort;
+};
+export type RunContinuationHandlePlan = {
+    position: Point;
+    fittingId?: AnyNodeId;
+};
+export declare function findMatedScenePorts(source: ScenePort, nodes: Readonly<Record<string, AnyNode>>): ScenePort[];
+export declare function resolveDuctContinuationHandle(source: ScenePort, nodes: Readonly<Record<string, AnyNode>>, gap: number): RunContinuationHandlePlan | null;
+export declare function resolvePipeContinuationHandle(source: ScenePort, nodes: Readonly<Record<string, AnyNode>>, gap: number): RunContinuationHandlePlan | null;
+export declare function planDuctElbowBranchPromotion(elbow: DuctFittingNode, connectedPortId: string): ElbowBranchPromotion<DuctFittingNode> | null;
+export declare function planPipeElbowBranchPromotion(elbow: PipeFittingNode, connectedPortId: string): ElbowBranchPromotion<PipeFittingNode> | null;
+export declare function planDuctTeeCrossPromotion(tee: DuctFittingNode): ElbowBranchPromotion<DuctFittingNode> | null;
+export declare function planPipeTeeCrossPromotion(tee: PipeFittingNode): ElbowBranchPromotion<PipeFittingNode> | null;
+export {};
+//# sourceMappingURL=elbow-branch-continuation.d.ts.map

package/dist/shared/elbow-branch-continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elbow-branch-continuation.d.ts","sourceRoot":"","sources":["../../src/shared/elbow-branch-continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EAEf,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,OAAO,EAAE,CAAC,CAAA;IACV,gBAAgB,EAAE,SAAS,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,KAAK,CAAA;IACf,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,CAAA;AAID,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,SAAS,EAAE,CAkBb;AAqDD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,EAAE,MAAM,GACV,yBAAyB,GAAG,IAAI,CASlC;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,EAAE,MAAM,GACV,yBAAyB,GAAG,IAAI,CASlC;AAuCD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,eAAe,EACtB,eAAe,EAAE,MAAM,GACtB,oBAAoB,CAAC,eAAe,CAAC,GAAG,IAAI,CAqC9C;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,eAAe,EACtB,eAAe,EAAE,MAAM,GACtB,oBAAoB,CAAC,eAAe,CAAC,GAAG,IAAI,CA8B9C;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,GACnB,oBAAoB,CAAC,eAAe,CAAC,GAAG,IAAI,CAU9C;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,GACnB,oBAAoB,CAAC,eAAe,CAAC,GAAG,IAAI,CAU9C"}

package/dist/shared/elbow-branch-continuation.js

@@ -0,0 +1,200 @@
+import { DuctFittingNode, nodeRegistry, PipeFittingNode, } from '@pascal-app/core';
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { getPipeFittingPorts, WYE_BRANCH_RAD } from '../pipe-fitting/ports';
+const MATE_TOLERANCE_M = 0.05;
+export function findMatedScenePorts(source, nodes) {
+    const toleranceSq = MATE_TOLERANCE_M * MATE_TOLERANCE_M;
+    const mates = [];
+    for (const node of Object.values(nodes)) {
+        if (!node || node.id === source.nodeId)
+            continue;
+        const ports = nodeRegistry.get(node.type)?.ports?.(node);
+        if (!ports)
+            continue;
+        for (const port of ports) {
+            if (source.system && port.system && source.system !== port.system)
+                continue;
+            const dx = source.position[0] - port.position[0];
+            const dy = source.position[1] - port.position[1];
+            const dz = source.position[2] - port.position[2];
+            if (dx * dx + dy * dy + dz * dz <= toleranceSq) {
+                mates.push({ ...port, nodeId: node.id });
+            }
+        }
+    }
+    return mates;
+}
+function handlePosition(port, gap) {
+    return [
+        port.position[0] + port.direction[0] * gap,
+        port.position[1] + port.direction[1] * gap,
+        port.position[2] + port.direction[2] * gap,
+    ];
+}
+function allPortsOccupied(fitting, nodes) {
+    const ports = nodeRegistry.get(fitting.type)?.ports?.(fitting) ?? [];
+    return ports.every((port) => findMatedScenePorts({ ...port, nodeId: fitting.id }, nodes).length > 0);
+}
+function resolveFittingExpansionHandle(source, nodes, gap, fittingType, promoteElbow, promoteTee) {
+    const mates = findMatedScenePorts(source, nodes);
+    if (mates.length === 0)
+        return { position: handlePosition(source, gap) };
+    for (const mate of mates) {
+        const fitting = nodes[mate.nodeId];
+        if (fitting?.type !== fittingType)
+            continue;
+        if (fitting.fittingType === 'end-cap') {
+            return {
+                position: handlePosition(source, gap),
+                fittingId: fitting.id,
+            };
+        }
+        const promotion = fitting.fittingType === 'elbow'
+            ? promoteElbow(fitting, mate.id)
+            : promoteTee(fitting);
+        if (!promotion)
+            continue;
+        if (!allPortsOccupied(fitting, nodes))
+            continue;
+        return {
+            position: handlePosition(promotion.continuationPort, gap),
+            fittingId: fitting.id,
+        };
+    }
+    return null;
+}
+export function resolveDuctContinuationHandle(source, nodes, gap) {
+    return resolveFittingExpansionHandle(source, nodes, gap, 'duct-fitting', planDuctElbowBranchPromotion, planDuctTeeCrossPromotion);
+}
+export function resolvePipeContinuationHandle(source, nodes, gap) {
+    return resolveFittingExpansionHandle(source, nodes, gap, 'pipe-fitting', planPipeElbowBranchPromotion, planPipeTeeCrossPromotion);
+}
+function frame(primary, reference) {
+    const x = primary.clone().normalize();
+    const z = new Vector3().crossVectors(x, reference);
+    if (z.lengthSq() < 1e-10)
+        return null;
+    z.normalize();
+    const y = new Vector3().crossVectors(z, x);
+    return new Matrix4().makeBasis(x, y, z);
+}
+function branchRotation(growthDirection, existingBranchDirection, localBranchDirection) {
+    const localFrame = frame(new Vector3(1, 0, 0), localBranchDirection);
+    const worldFrame = frame(growthDirection, existingBranchDirection);
+    if (!localFrame || !worldFrame)
+        return null;
+    const rotation = new Quaternion().setFromRotationMatrix(worldFrame.multiply(localFrame.transpose()));
+    const euler = new Euler().setFromQuaternion(rotation);
+    return [euler.x, euler.y, euler.z];
+}
+function elbowDirections(ports, connectedPortId) {
+    const connected = ports.find((port) => port.id === connectedPortId);
+    const other = ports.find((port) => port.id !== connectedPortId);
+    if (!connected || !other)
+        return null;
+    const growth = new Vector3(...connected.direction).multiplyScalar(-1).normalize();
+    const branch = new Vector3(...other.direction).normalize();
+    if (growth.lengthSq() < 1e-10 || branch.lengthSq() < 1e-10)
+        return null;
+    return { growth, branch };
+}
+export function planDuctElbowBranchPromotion(elbow, connectedPortId) {
+    if (elbow.fittingType !== 'elbow')
+        return null;
+    const existingPorts = getDuctFittingPorts(elbow).map((port) => ({
+        ...port,
+        nodeId: elbow.id,
+    }));
+    const directions = elbowDirections(existingPorts, connectedPortId);
+    if (!directions)
+        return null;
+    const measuredBranchAngle = (directions.growth.angleTo(directions.branch) * 180) / Math.PI;
+    if (measuredBranchAngle < 45 - 1e-4 || measuredBranchAngle > 135 + 1e-4)
+        return null;
+    // The tolerance above intentionally accepts values infinitesimally outside
+    // the schema range, so normalize before parsing the generated fitting.
+    const branchAngle = Math.min(135, Math.max(45, measuredBranchAngle));
+    const phi = (branchAngle * Math.PI) / 180;
+    const rotation = branchRotation(directions.growth, directions.branch, new Vector3(Math.cos(phi), 0, Math.sin(phi)));
+    if (!rotation)
+        return null;
+    const fitting = DuctFittingNode.parse({
+        ...elbow,
+        name: 'Tee',
+        fittingType: 'tee',
+        rotation,
+        branchAngle,
+        shape2: elbow.shape,
+        width2: elbow.width,
+        height2: elbow.height,
+        diameter2: elbow.diameter,
+    });
+    const continuation = getDuctFittingPorts(fitting).find((port) => port.id === 'outlet');
+    if (!continuation)
+        return null;
+    return {
+        fitting,
+        continuationPort: { ...continuation, nodeId: elbow.id },
+    };
+}
+export function planPipeElbowBranchPromotion(elbow, connectedPortId) {
+    if (elbow.fittingType !== 'elbow')
+        return null;
+    const existingPorts = getPipeFittingPorts(elbow).map((port) => ({
+        ...port,
+        nodeId: elbow.id,
+    }));
+    const directions = elbowDirections(existingPorts, connectedPortId);
+    if (!directions)
+        return null;
+    const angle = (directions.growth.angleTo(directions.branch) * 180) / Math.PI;
+    const isWye = Math.abs(angle - 45) <= 1;
+    const isSanitaryTee = Math.abs(angle - 90) <= 1;
+    if (!isWye && !isSanitaryTee)
+        return null;
+    const localBranch = isWye
+        ? new Vector3(Math.cos(WYE_BRANCH_RAD), 0, Math.sin(WYE_BRANCH_RAD))
+        : new Vector3(0, 0, 1);
+    const rotation = branchRotation(directions.growth, directions.branch, localBranch);
+    if (!rotation)
+        return null;
+    const fitting = PipeFittingNode.parse({
+        ...elbow,
+        name: isWye ? 'Wye' : 'Sanitary Tee',
+        fittingType: isWye ? 'wye' : 'sanitary-tee',
+        rotation,
+        diameter2: elbow.diameter,
+    });
+    const continuation = getPipeFittingPorts(fitting).find((port) => port.id === 'outlet');
+    if (!continuation)
+        return null;
+    return {
+        fitting,
+        continuationPort: { ...continuation, nodeId: elbow.id },
+    };
+}
+export function planDuctTeeCrossPromotion(tee) {
+    if (tee.fittingType !== 'tee' || Math.abs(tee.branchAngle - 90) > 1e-4)
+        return null;
+    const fitting = DuctFittingNode.parse({ ...tee, name: 'Cross', fittingType: 'cross' });
+    const continuation = getDuctFittingPorts(fitting).find((port) => port.id === 'branch2');
+    return continuation
+        ? {
+            fitting,
+            continuationPort: { ...continuation, nodeId: tee.id },
+        }
+        : null;
+}
+export function planPipeTeeCrossPromotion(tee) {
+    if (tee.fittingType !== 'sanitary-tee')
+        return null;
+    const fitting = PipeFittingNode.parse({ ...tee, name: 'Cross', fittingType: 'cross' });
+    const continuation = getPipeFittingPorts(fitting).find((port) => port.id === 'branch2');
+    return continuation
+        ? {
+            fitting,
+            continuationPort: { ...continuation, nodeId: tee.id },
+        }
+        : null;
+}

package/dist/shared/fitting-clearance.d.ts

@@ -0,0 +1,5 @@
+export declare const FITTING_CLEARANCE_MESSAGE = "Not enough room for this fitting. Lengthen the run or move the connection.";
+type Point = readonly [number, number, number];
+export declare function hasFittingClearance(start: Point, end: Point, direction: Point, minimum: number): boolean;
+export {};
+//# sourceMappingURL=fitting-clearance.d.ts.map

package/dist/shared/fitting-clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-clearance.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-clearance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,+EACwC,CAAA;AAE9E,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9C,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,SAAS,EAAE,KAAK,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAST"}

package/dist/shared/fitting-clearance.js

@@ -0,0 +1,11 @@
+export const FITTING_CLEARANCE_MESSAGE = 'Not enough room for this fitting. Lengthen the run or move the connection.';
+export function hasFittingClearance(start, end, direction, minimum) {
+    const length = Math.hypot(...direction);
+    if (length < 1e-9)
+        return false;
+    const remaining = ((end[0] - start[0]) * direction[0] +
+        (end[1] - start[1]) * direction[1] +
+        (end[2] - start[2]) * direction[2]) /
+        length;
+    return remaining >= minimum;
+}

package/dist/shared/fitting-deletion-cleanup.d.ts

@@ -0,0 +1,14 @@
+import type { AnyNode, AnyNodeId, DuctSegmentNode, PipeSegmentNode } from '@pascal-app/core';
+type Run = DuctSegmentNode | PipeSegmentNode;
+export type FittingDeletionPlan = {
+    fittingId: AnyNodeId;
+    deleteFitting: boolean;
+    cascadeDeleteIds: AnyNodeId[];
+    updates: Array<{
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }>;
+};
+export declare function fittingDeletionPlansForRun(run: Run, nodes: Record<AnyNodeId, AnyNode>, topologyDeleteIds: ReadonlySet<AnyNodeId>, ownerOnly: boolean): FittingDeletionPlan[];
+export {};
+//# sourceMappingURL=fitting-deletion-cleanup.d.ts.map

package/dist/shared/fitting-deletion-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-deletion-cleanup.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-deletion-cleanup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAET,eAAe,EAGf,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAMzB,KAAK,GAAG,GAAG,eAAe,GAAG,eAAe,CAAA;AAU5C,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,SAAS,CAAA;IACpB,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAA;CAC1D,CAAA;AA6TD,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,iBAAiB,EAAE,WAAW,CAAC,SAAS,CAAC,EACzC,SAAS,EAAE,OAAO,GACjB,mBAAmB,EAAE,CAqBvB"}