@pascal-app/nodes 0.1.1

package/dist/roof-segment/renderer.js

@@ -0,0 +1,93 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, getRoofMaterialArray, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { getRoofDebugMaterials, getRoofMaterials } from '../roof/roof-materials';
+import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+export const RoofSegmentRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const nodes = useScene((state) => state.nodes);
+    useRegistry(node.id, 'roof-segment', ref);
+    const handlers = useNodeEvents(node, 'roof-segment');
+    const debugColors = useViewer((s) => s.debugColors);
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    const parentNode = node.parentId
+        ? nodes[node.parentId]
+        : undefined;
+    // 4 groups map 1:1 to the roof's 4-material array (see getRoofMaterialArray).
+    const placeholderGeometry = useMemo(() => createPlaceholderGeometry(4), []);
+    // Segment material precedence, per-role:
+    //   1. Segment's role-specific override (topMaterial, edgeMaterial, wallMaterial).
+    //   2. Segment's catch-all `material` (legacy single-slot paint).
+    //   3. Parent roof's role-specific material.
+    //   4. Parent roof's catch-all material.
+    //   5. Default `roofMaterials` (handled at the `material =` line below).
+    //
+    // The 4-slot layout matches getRoofMaterialArray:
+    //   slot 0 → 'edge'  (wall/trim & rake bands)
+    //   slot 1 → 'wall'  (deck top & shingle eave bands)
+    //   slot 2 → 'wall'  (interior)
+    //   slot 3 → 'top'   (shingle / roof surface)
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const customMaterial = useMemo(() => {
+        const resolveSlot = (role) => {
+            const parentSpec = parentNode ? getEffectiveRoofSurfaceMaterial(parentNode, role) : undefined;
+            const spec = getEffectiveSegmentSurfaceMaterial(node, role, parentSpec);
+            if (typeof spec.materialPreset === 'string') {
+                const resolved = createMaterialFromPresetRef(spec.materialPreset, shading);
+                if (resolved)
+                    return resolved;
+            }
+            if (spec.material !== undefined) {
+                return createMaterial(spec.material, shading);
+            }
+            return null;
+        };
+        // Themed parent-roof array (per-role scene-theme colours) — used both as the
+        // full fallback and to fill any individual untextured slot below.
+        const themedArray = parentNode
+            ? getRoofMaterialArray(parentNode, shading, textures, colorPreset, sceneTheme)
+            : null;
+        const edge = resolveSlot('edge');
+        const wall = resolveSlot('wall');
+        const top = resolveSlot('top');
+        if (!(edge || wall || top)) {
+            return themedArray;
+        }
+        // Some slots have explicit materials; fill the rest from the themed array so
+        // an untextured slot still picks up the scene-theme role colour, not blank white.
+        // Per-role only, then the themed parent slot — no cross-role fallback, so
+        // painting one segment surface never bleeds onto its other surfaces.
+        const slot = (i) => themedArray?.[i] ?? new THREE.MeshStandardMaterial();
+        return [edge ?? slot(0), wall ?? slot(1), wall ?? slot(2), top ?? slot(3)];
+    }, [
+        node.material,
+        node.materialPreset,
+        node.topMaterial,
+        node.topMaterialPreset,
+        node.edgeMaterial,
+        node.edgeMaterialPreset,
+        node.wallMaterial,
+        node.wallMaterialPreset,
+        parentNode,
+        shading,
+        textures,
+        colorPreset,
+        sceneTheme,
+    ]);
+    const material = debugColors
+        ? getRoofDebugMaterials(shading)
+        : customMaterial || getRoofMaterials(shading, textures, colorPreset);
+    useEffect(() => {
+        return () => {
+            placeholderGeometry.dispose();
+        };
+    }, [placeholderGeometry]);
+    return (_jsx("mesh", { geometry: placeholderGeometry, material: material, position: node.position, ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers }));
+};
+export default RoofSegmentRenderer;

package/dist/roof-segment/schema.d.ts

@@ -0,0 +1,2 @@
+export { RoofSegmentNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/roof-segment/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/roof-segment/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/roof-segment/schema.js

@@ -0,0 +1 @@
+export { RoofSegmentNode } from '@pascal-app/core';

package/dist/scan/definition.d.ts

@@ -0,0 +1,9 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { ScanNode } from './schema';
+/**
+ * Scan — Stage A. Mesh imported from the capture pipeline (LiDAR /
+ * photogrammetry). `ScanSystem` handles mesh loading + per-frame
+ * positioning; renderer mounts the imported geometry.
+ */
+export declare const scanDefinition: NodeDefinition<typeof ScanNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/scan/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/scan/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAElF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA8C1D,CAAA"}

package/dist/scan/definition.js

@@ -0,0 +1,49 @@
+import { ScanNode as ScanNodeSchema } from '@pascal-app/core';
+import { scanParametrics } from './parametrics';
+import { ScanNode } from './schema';
+/**
+ * Scan — Stage A. Mesh imported from the capture pipeline (LiDAR /
+ * photogrammetry). `ScanSystem` handles mesh loading + per-frame
+ * positioning; renderer mounts the imported geometry.
+ */
+export const scanDefinition = {
+    kind: 'scan',
+    // Heavy LiDAR asset: stripped from the bake, re-added live from scene_graph
+    // in the viewer (see plans → Part D; glb-reference-nodes.tsx).
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: ScanNode,
+    category: 'site',
+    defaults: () => {
+        const stub = ScanNodeSchema.parse({ id: 'scan_default', type: 'scan' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: false,
+        deletable: true,
+        // Scans carry user-uploaded imagery — cataloging them as
+        // reusable presets is out of scope.
+        presettable: false,
+    },
+    parametrics: scanParametrics,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 1,
+    },
+    presentation: {
+        label: 'Scan',
+        description: 'A captured mesh (LiDAR / photogrammetry) imported as a scene reference.',
+        icon: { kind: 'url', src: '/icons/mesh.webp' },
+        paletteSection: 'site',
+        paletteOrder: 40,
+    },
+    mcp: {
+        description: 'A captured mesh import.',
+    },
+};

package/dist/scan/index.d.ts

@@ -0,0 +1,2 @@
+export { scanDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

package/dist/scan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scan/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/scan/index.js

@@ -0,0 +1 @@
+export { scanDefinition } from './definition';

package/dist/scan/parametrics.d.ts

@@ -0,0 +1,3 @@
+import type { ParametricDescriptor, ScanNode } from '@pascal-app/core';
+export declare const scanParametrics: ParametricDescriptor<ScanNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/scan/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/scan/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAE1D,CAAA"}

package/dist/scan/parametrics.js

@@ -0,0 +1,3 @@
+export const scanParametrics = {
+    groups: [],
+};

package/dist/scan/renderer.d.ts

@@ -0,0 +1,6 @@
+import { type ScanNode } from '@pascal-app/core';
+export declare const ScanRenderer: ({ node }: {
+    node: ScanNode;
+}) => import("react").JSX.Element;
+export default ScanRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/scan/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAK7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAsBxD,CAAA;AAiDD,eAAe,YAAY,CAAA"}

package/dist/scan/renderer.js

@@ -0,0 +1,54 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRegistry } from '@pascal-app/core';
+import { useAssetUrl, useGLTFKTX2, useViewer } from '@pascal-app/viewer';
+import { Suspense, useMemo, useRef } from 'react';
+export const ScanRenderer = ({ node }) => {
+    const showScans = useViewer((s) => s.showScans);
+    const ref = useRef(null);
+    useRegistry(node.id, 'scan', ref);
+    const resolvedUrl = useAssetUrl(node.url);
+    return (_jsx("group", { position: node.position, ref: ref, rotation: node.rotation, scale: [node.scale, node.scale, node.scale], visible: showScans, children: resolvedUrl && (_jsx(Suspense, { children: _jsx(ScanModel, { opacity: node.opacity, url: resolvedUrl }) })) }));
+};
+const ScanModel = ({ url, opacity }) => {
+    const gltf = useGLTFKTX2(url);
+    const scene = gltf.scene;
+    useMemo(() => {
+        const normalizedOpacity = opacity / 100;
+        const isTransparent = normalizedOpacity < 1;
+        const updateMaterial = (material) => {
+            if (isTransparent) {
+                material.transparent = true;
+                material.opacity = normalizedOpacity;
+                material.depthWrite = false;
+            }
+            else {
+                material.transparent = false;
+                material.opacity = 1;
+                material.depthWrite = true;
+            }
+            material.needsUpdate = true;
+        };
+        scene.traverse((child) => {
+            if (child.isMesh) {
+                const mesh = child;
+                // Disable raycasting
+                mesh.raycast = () => { };
+                // Exclude from bounding box calculations
+                mesh.geometry.boundingBox = null;
+                mesh.geometry.boundingSphere = null;
+                mesh.frustumCulled = false;
+                if (Array.isArray(mesh.material)) {
+                    mesh.material.forEach((material) => {
+                        updateMaterial(material);
+                    });
+                }
+                else {
+                    updateMaterial(mesh.material);
+                }
+            }
+        });
+    }, [scene, opacity]);
+    return _jsx("primitive", { object: scene });
+};
+export default ScanRenderer;

package/dist/scan/schema.d.ts

@@ -0,0 +1,2 @@
+export { ScanNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/scan/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/scan/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/scan/schema.js

@@ -0,0 +1 @@
+export { ScanNode } from '@pascal-app/core';

package/dist/scan/system.d.ts

@@ -0,0 +1,3 @@
+import { ScanSystem } from '@pascal-app/viewer';
+export default ScanSystem;
+//# sourceMappingURL=system.d.ts.map

package/dist/scan/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/scan/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/C,eAAe,UAAU,CAAA"}

package/dist/scan/system.js

@@ -0,0 +1,3 @@
+'use client';
+import { ScanSystem } from '@pascal-app/viewer';
+export default ScanSystem;

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

@@ -0,0 +1,253 @@
+import { DuctFittingNode, DuctSegmentNode, PipeFittingNode, PipeSegmentNode } from '@pascal-app/core';
+import type { RunBodyHit, ScenePort } from './ports';
+type Point = [number, number, number];
+/** Cross-section a planned fitting (and the duct drawing it) carries. */
+export type DuctProfile = {
+    shape: 'round' | 'rect' | 'oval';
+    /** Round size in inches (ignored for rect / oval — the equivalent is derived). */
+    diameter: number;
+    /** Rect / oval profile in inches. */
+    width: number;
+    height: number;
+};
+/** Effective round-size (inches) a profile presents at joints. */
+export declare function profileDiameterIn(profile: DuctProfile): number;
+export type ElbowJointPlan = {
+    /** Parsed elbow node, its junction centered ON the drawn corner point,
+     *  oriented so the inlet faces the existing run and the outlet faces
+     *  the new one. */
+    fitting: DuctFittingNode;
+    /** The elbow's outlet collar — where the new duct should start (or end)
+     *  instead of the corner point, so duct meets metal instead of
+     *  overlapping the fitting. */
+    collarPoint: Point;
+    /** Where the EXISTING run's endpoint must move (pulled back one leg
+     *  from the corner) so the elbow's inlet collar replaces that stretch
+     *  of duct — keeping the visual corner exactly where it was drawn. */
+    trimmedPortPoint: Point;
+};
+/**
+ * Plan the elbow that joins an existing run's open port to a new run
+ * leaving the joint along `awayDir`.
+ *
+ * Geometry: the elbow's local inlet faces -X and its outlet is turned
+ * `angle`° in the local XZ plane (see the duct-fitting schema). For a
+ * turn of θ between the port's outward direction and `awayDir`, an elbow
+ * with `angle = θ` mates both exactly; the rotation is whatever maps the
+ * local (inlet, outlet) direction pair onto the world (port, away) pair —
+ * which also covers vertical turns (horizontal run → riser), since the
+ * mapping is a full 3D rotation, not just yaw.
+ *
+ * Returns null when no fitting belongs at the joint: near-straight
+ * continuation (butt-join is fine), a back-turn sharper than 90°, or a
+ * degenerate direction pair.
+ */
+/**
+ * Domain-agnostic corner-joint math: where an elbow-shaped fitting (any
+ * kind whose local inlet faces -X with the outlet turned `angle`° in
+ * XZ) lands when joining `port` to a run leaving along `awayDir`, with
+ * legs of `legM` meters. The junction sits exactly ON the corner; the
+ * caller trims the existing run to `trimmedPortPoint` and starts the
+ * new one at `collarPoint`.
+ */
+export type CornerJointGeometry = {
+    angleDeg: number;
+    rotation: Point;
+    junction: Point;
+    collarPoint: Point;
+    trimmedPortPoint: Point;
+};
+export declare function planCornerJoint(port: Pick<ScenePort, 'position' | 'direction'>, awayDir: Point, legM: number): CornerJointGeometry | null;
+export declare function planElbowAtPort(port: ScenePort, awayDir: Point, profile: DuctProfile): ElbowJointPlan | null;
+export type TeeTapPlan = {
+    /** Parsed tee node, its junction centered ON the tap point, run legs
+     *  along the trunk and branch collar toward the new run. */
+    fitting: DuctFittingNode;
+    /** The tee's branch collar — where the new duct should start. */
+    branchCollar: Point;
+    /** Trunk rewritten to END one run-leg before the tap point. */
+    trunkUpdate: {
+        id: DuctSegmentNode['id'];
+        data: {
+            path: Point[];
+        };
+    };
+    /** New run carrying the rest of the trunk, starting one run-leg after
+     *  the tap point. Created alongside the tee. */
+    trunkTail: DuctSegmentNode;
+};
+/**
+ * Plan the tee that taps a branch off the SIDE of an existing run.
+ *
+ * The trunk is split at the tap point: the original node keeps the
+ * upstream half (trimmed one leg short), a new duct-segment node carries
+ * the downstream half (starting one leg after), and the tee's run legs
+ * bridge the gap with its junction exactly on the centerline hit. The
+ * branch collar follows `awayDir`: the tee becomes a lateral whose
+ * `branchAngle` (clamped to the buildable 45–135° range) matches the turn
+ * the drawn run makes off the trunk, so the new duct continues straight
+ * out of the collar instead of kinking square.
+ *
+ * Returns null when the tap can't be built: too close to the segment's
+ * ends (no room for the run legs — join the end port instead), or the
+ * branch direction is parallel to the trunk.
+ */
+export declare function planTeeAtRunBody(trunk: DuctSegmentNode, hit: RunBodyHit, awayDir: Point, branch: DuctProfile): TeeTapPlan | null;
+export type CrossTapPlan = {
+    /** Parsed cross node, junction ON the crossing point, run legs along
+     *  the trunk and two opposed branch legs along the drawn run. */
+    fitting: DuctFittingNode;
+    /** Branch collar on the START side of the drawn run — the first half
+     *  of the drawn duct ENDS here. */
+    branchCollarNear: Point;
+    /** Branch collar on the END side of the drawn run — the second half
+     *  of the drawn duct STARTS here. */
+    branchCollarFar: Point;
+    /** Trunk rewritten to END one run-leg before the crossing. */
+    trunkUpdate: {
+        id: DuctSegmentNode['id'];
+        data: {
+            path: Point[];
+        };
+    };
+    /** New run carrying the rest of the trunk, starting one run-leg past
+     *  the crossing. Created alongside the cross. */
+    trunkTail: DuctSegmentNode;
+};
+/**
+ * Plan the four-way cross where a drawn run passes straight THROUGH the
+ * SIDE of an existing run. Like a tee tap, the trunk is split at the
+ * crossing (original keeps the upstream half, a new node carries the
+ * downstream half, both pulled one run-leg back). The drawn run is split
+ * by the CALLER into two halves that meet the cross's two opposed branch
+ * collars — `branchCollarNear` toward `awayDir`'s origin (the drawn
+ * start) and `branchCollarFar` along `awayDir` (the drawn end).
+ *
+ * `awayDir` is the drawn run's direction (start → end). Its component
+ * perpendicular to the trunk axis sets the branch axis; a drawn run that
+ * isn't square to the trunk still gets a square cross (the off-square
+ * lead-ins are absorbed by the drawn duct halves). Returns null when the
+ * crossing is too near a trunk end (no room for the run legs) or the
+ * drawn run is parallel to the trunk.
+ */
+export declare function planCrossAtRunBody(trunk: DuctSegmentNode, hit: RunBodyHit, awayDir: Point, branch: DuctProfile): CrossTapPlan | null;
+export type ElbowRealignPlan = {
+    /** Patch for the existing elbow: new turn angle + orientation. */
+    update: {
+        id: DuctFittingNode['id'];
+        data: {
+            angle: number;
+            rotation: Point;
+        };
+    };
+    /** Where the free collar lands — the new duct starts (or ends) here. */
+    collarPoint: Point;
+};
+export type PipeElbowRealignPlan = {
+    update: {
+        id: PipeFittingNode['id'];
+        data: {
+            angle: number;
+            rotation: Point;
+        };
+    };
+    collarPoint: Point;
+};
+/** Re-aim a DUCT elbow whose open collar a new run just snapped onto. */
+export declare function planElbowRealign(elbow: DuctFittingNode, snappedPortId: string, awayDir: Point): ElbowRealignPlan | null;
+/** Re-aim a DWV PIPE elbow — same geometry, pipe collar leg length. */
+export declare function planPipeElbowRealign(elbow: PipeFittingNode, snappedPortId: string, awayDir: Point): PipeElbowRealignPlan | null;
+export type TeeBranchRealignPlan = {
+    /** Patch for the existing tee: new branch lean angle. The run axis and
+     *  the tee's orientation stay fixed (inlet / outlet stay mated to the
+     *  trunk) — only `branchAngle` changes. */
+    update: {
+        id: DuctFittingNode['id'];
+        data: {
+            branchAngle: number;
+        };
+    };
+    /** Where the branch collar lands at the new angle — the dragged run's
+     *  mated end rides here. */
+    collarPoint: Point;
+};
+/**
+ * Re-aim a duct TEE's branch to follow a run dragged off its branch collar.
+ *
+ * Unlike the elbow (which re-orients its whole body), a tee's run legs stay
+ * mated to the trunk, so the body orientation is FIXED: the branch can only
+ * swing within the tee's local XZ plane (local +X = run axis, +Z = the
+ * square branch direction). `awayDir` (junction → dragged end) is projected
+ * onto that plane and read as the lean angle off +X — 90° square, <90°
+ * leaning downstream toward the outlet, >90° upstream toward the inlet —
+ * clamped to the schema's buildable 45–135° lateral range.
+ */
+export declare function planTeeBranchRealign(tee: DuctFittingNode, awayDir: Point): TeeBranchRealignPlan | null;
+export type PipeElbowPlan = {
+    fitting: PipeFittingNode;
+    collarPoint: Point;
+    trimmedPortPoint: Point;
+};
+/**
+ * Elbow (bend) joining an existing DWV run's open port to a new run —
+ * same corner geometry as the duct elbow, minted as a pipe fitting.
+ */
+export declare function planPipeElbowAtPort(port: ScenePort, awayDir: Point, diameterIn: number, pipeMaterial?: PipeFittingNode['pipeMaterial']): PipeElbowPlan | null;
+export type PipeBranchTapPlan = {
+    /** Parsed wye / sanitary tee, junction ON the tap point. */
+    fitting: PipeFittingNode;
+    /** The branch collar — where the new run starts. */
+    branchCollar: Point;
+    /** Tapped run rewritten to END one run-leg before the tap. */
+    runUpdate: {
+        id: PipeSegmentNode['id'];
+        data: {
+            path: Point[];
+        };
+    };
+    /** New run carrying the rest of the tapped run. */
+    runTail: PipeSegmentNode;
+};
+/**
+ * Plan the branch fitting that taps a new run into the SIDE of an
+ * existing DWV run — a **sanitary tee**: the branch enters SQUARE off the
+ * run (same T as the duct tee tap), facing the drawn branch's side.
+ *
+ * The run splits like a duct tee tap: original keeps the upstream half,
+ * a new node carries the downstream half, both trimmed one run-leg from
+ * the tap point.
+ */
+export declare function planPipeBranchTap(run: PipeSegmentNode, hit: RunBodyHit, awayDir: Point, branchDiameterIn: number): PipeBranchTapPlan | null;
+export type PipeCrossTapPlan = {
+    /** Parsed cross node, junction ON the crossing point, run legs along
+     *  the run and two opposed branch legs along the drawn run. */
+    fitting: PipeFittingNode;
+    /** Branch collar on the START side of the drawn run — the first half
+     *  of the drawn pipe ENDS here. */
+    branchCollarNear: Point;
+    /** Branch collar on the END side of the drawn run — the second half
+     *  of the drawn pipe STARTS here. */
+    branchCollarFar: Point;
+    /** Tapped run rewritten to END one run-leg before the crossing. */
+    runUpdate: {
+        id: PipeSegmentNode['id'];
+        data: {
+            path: Point[];
+        };
+    };
+    /** New run carrying the rest of the tapped run. */
+    runTail: PipeSegmentNode;
+};
+/**
+ * Plan the four-way DWV cross where a drawn run passes straight THROUGH
+ * the SIDE of an existing run — the pipe sibling of `planCrossAtRunBody`.
+ * The run splits at the crossing (original keeps the upstream half, a new
+ * node carries the downstream half, both pulled one run-leg back). The
+ * drawn run is split by the CALLER into two halves meeting the cross's
+ * opposed branch collars — `branchCollarNear` toward the drawn start,
+ * `branchCollarFar` along the drawn end. Returns null when the crossing
+ * is too near a run end or the drawn run is parallel to the run.
+ */
+export declare function planPipeCrossAtRunBody(run: PipeSegmentNode, hit: RunBodyHit, awayDir: Point, branchDiameterIn: number): PipeCrossTapPlan | null;
+export {};
+//# sourceMappingURL=auto-fitting.d.ts.map

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

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