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

package/dist/shared/primitive-uv.js

@@ -0,0 +1,107 @@
+import * as THREE from 'three';
+/** Return cumulative metre distances along a sampled open or closed profile. */
+export function cumulativeProfileDistances(points) {
+    const distances = [0];
+    for (let index = 1; index < points.length; index += 1) {
+        const previous = points[index - 1];
+        const current = points[index];
+        distances.push(distances[index - 1] +
+            Math.hypot(current[0] - previous[0], current[1] - previous[1], current[2] - previous[2]));
+    }
+    return distances;
+}
+/** Project a flat polygon into metre-scaled UV coordinates without shearing trapezoids. */
+export function planarMetricUvs(points, normal, uOffset = 0, vOffset = 0) {
+    const origin = points[0];
+    const uTarget = points[1];
+    const ux = uTarget[0] - origin[0];
+    const uy = uTarget[1] - origin[1];
+    const uz = uTarget[2] - origin[2];
+    const uLength = Math.hypot(ux, uy, uz) || 1;
+    const unitU = [ux / uLength, uy / uLength, uz / uLength];
+    const normalLength = Math.hypot(normal[0], normal[1], normal[2]) || 1;
+    const unitNormal = [
+        normal[0] / normalLength,
+        normal[1] / normalLength,
+        normal[2] / normalLength,
+    ];
+    const unitV = [
+        unitNormal[1] * unitU[2] - unitNormal[2] * unitU[1],
+        unitNormal[2] * unitU[0] - unitNormal[0] * unitU[2],
+        unitNormal[0] * unitU[1] - unitNormal[1] * unitU[0],
+    ];
+    return points.map((point) => {
+        const x = point[0] - origin[0];
+        const y = point[1] - origin[1];
+        const z = point[2] - origin[2];
+        return [
+            uOffset + x * unitU[0] + y * unitU[1] + z * unitU[2],
+            vOffset + x * unitV[0] + y * unitV[1] + z * unitV[2],
+        ];
+    });
+}
+/** Reuse the authored unwrap for AO and light maps, which read texture channel 2. */
+export function copyUvToSecondaryChannel(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (uv)
+        geometry.setAttribute('uv2', uv.clone());
+}
+/** Apply metre-scaled planar UVs to a non-indexed, axis-aligned primitive. */
+export function applyPlanarWorldUvs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    const uvs = new Float32Array(position.count * 2);
+    for (let triangle = 0; triangle < position.count; triangle += 3) {
+        const nx = Math.abs(normal.getX(triangle));
+        const ny = Math.abs(normal.getY(triangle));
+        const nz = Math.abs(normal.getZ(triangle));
+        for (let corner = 0; corner < 3; corner += 1) {
+            const index = triangle + corner;
+            const x = position.getX(index);
+            const y = position.getY(index);
+            const z = position.getZ(index);
+            if (ny >= nx && ny >= nz) {
+                uvs[index * 2] = x;
+                uvs[index * 2 + 1] = z;
+            }
+            else if (nx >= nz) {
+                uvs[index * 2] = z;
+                uvs[index * 2 + 1] = y;
+            }
+            else {
+                uvs[index * 2] = x;
+                uvs[index * 2 + 1] = y;
+            }
+        }
+    }
+    geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+}
+/** Scale cylinder/cone side UVs by circumference and height; caps use XZ metres. */
+export function applyCylinderWorldUvs(geometry, radius, height) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    const sourceUv = geometry.getAttribute('uv');
+    const uvs = new Float32Array(position.count * 2);
+    const circumference = Math.PI * 2 * radius;
+    for (let index = 0; index < position.count; index += 1) {
+        if (Math.abs(normal.getY(index)) < 0.5) {
+            uvs[index * 2] = sourceUv.getX(index) * circumference;
+            uvs[index * 2 + 1] = (sourceUv.getY(index) - 0.5) * height;
+        }
+        else {
+            uvs[index * 2] = position.getX(index);
+            uvs[index * 2 + 1] = position.getZ(index);
+        }
+    }
+    geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+}
+/** Scale a sphere's equirectangular UVs to its circumference and pole distance. */
+export function applySphereWorldUvs(geometry, radius) {
+    const sourceUv = geometry.getAttribute('uv');
+    const uvs = new Float32Array(sourceUv.count * 2);
+    for (let index = 0; index < sourceUv.count; index += 1) {
+        uvs[index * 2] = sourceUv.getX(index) * Math.PI * 2 * radius;
+        uvs[index * 2 + 1] = sourceUv.getY(index) * Math.PI * radius;
+    }
+    geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+}

package/dist/shared/reducer-size.d.ts

@@ -0,0 +1,2 @@
+export declare function reducerOutletDiameter(kind: 'duct-fitting' | 'pipe-fitting', inlet: number, outlet: number): number;
+//# sourceMappingURL=reducer-size.d.ts.map

package/dist/shared/reducer-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer-size.d.ts","sourceRoot":"","sources":["../../src/shared/reducer-size.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,GAAG,cAAc,EACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAOR"}

package/dist/shared/reducer-size.js

@@ -0,0 +1,12 @@
+const DUCT_SIZES = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 24, 30, 36, 48];
+const PIPE_SIZES = [1.25, 1.5, 2, 3, 4, 6, 8, 10, 12, 16];
+export function reducerOutletDiameter(kind, inlet, outlet) {
+    if (Math.abs(inlet - outlet) > 0.000001)
+        return outlet;
+    const sizes = kind === 'duct-fitting' ? DUCT_SIZES : PIPE_SIZES;
+    for (let i = sizes.length - 1; i >= 0; i--) {
+        if (sizes[i] < inlet)
+            return sizes[i];
+    }
+    return sizes.find((size) => size > inlet) ?? outlet;
+}

package/dist/shared/ridge-snap.js

@@ -23,7 +23,7 @@ import { getRidgeVentLinesForSegment, getRoofSegmentVisibleTopBounds, } from '@p
 export const RIDGE_LIFT = 0.09;
 export function resolveRidgeSnap(segment, cursorLocalX, cursorLocalZ) {
     const roofType = segment.roofType ?? 'gable';
-    if (roofType === 'flat')
+    if (roofType === 'flat' || roofType === 'conical')
         return null;
     const lines = roofType === 'shed'
         ? getShedHighEaveLine(segment)

package/dist/shared/roof-surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-surface.d.ts","sourceRoot":"","sources":["../../src/shared/roof-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEvF;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC5C,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACpD,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CACrD,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,qBAAqB,CAkBvB;AA8UD,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,eAAe,EACpB,GAAG,gBAAsB,GACxB,KAAK,CAAC,OAAO,CA4Gf;AAOD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,oBAqBjF;AAQD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAIpF"}
+{"version":3,"file":"roof-surface.d.ts","sourceRoot":"","sources":["../../src/shared/roof-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEvF;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC5C,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACpD,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CACrD,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,qBAAqB,CAkBvB;AAyVD,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,eAAe,EACpB,GAAG,gBAAsB,GACxB,KAAK,CAAC,OAAO,CAkHf;AAOD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,oBAqBjF;AAQD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAIpF"}

package/dist/shared/roof-surface.js

@@ -1,4 +1,4 @@
-import { getRoofModuleFaces, getRoofSegmentSurfaceY, getRoofShapeInsets, getRoofShapeRatios, getSegmentSlopeFrame, ROOF_SHAPE_DEFAULTS, } from '@pascal-app/core';
+import { getConicalRoofCoverage, getRoofModuleFaces, getRoofSegmentSurfaceY, getRoofShapeInsets, getRoofShapeRatios, getSegmentSlopeFrame, ROOF_SHAPE_DEFAULTS, } from '@pascal-app/core';
 import * as THREE from 'three';
 // ─── Roof-surface helpers ────────────────────────────────────────────
 // Analytical slope geometry for a roof segment, shared by every roof
@@ -51,6 +51,7 @@ function getRoofSurfaceFaces(segment) {
     return faces;
 }
 function roofSurfaceFaceCacheKey(segment) {
+    const conicalCoverage = getConicalRoofCoverage(segment);
     return [
         segment.roofType,
         segment.width,
@@ -61,6 +62,8 @@ function roofSurfaceFaceCacheKey(segment) {
         segment.overhang,
         segment.shingleThickness,
         segment.pitch,
+        conicalCoverage.startAngle,
+        conicalCoverage.sweepAngle,
         segment.gambrelLowerWidthRatio ?? ROOF_SHAPE_DEFAULTS.gambrelLowerWidthRatio,
         segment.gambrelLowerHeightRatio ?? ROOF_SHAPE_DEFAULTS.gambrelLowerHeightRatio,
         segment.mansardSteepWidthRatio ?? ROOF_SHAPE_DEFAULTS.mansardSteepWidthRatio,
@@ -71,6 +74,7 @@ function roofSurfaceFaceCacheKey(segment) {
     ].join('|');
 }
 function buildRoofSurfaceFaces(segment) {
+    const conicalCoverage = getConicalRoofCoverage(segment);
     const { roofType, width, depth, wallHeight, wallThickness, deckThickness, overhang } = segment;
     const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(segment);
     const verticalRt = activeRh > 0 ? deckThickness / cosTheta : deckThickness;
@@ -92,7 +96,10 @@ function buildRoofSurfaceFaces(segment) {
     let shinTopW = shinBotW;
     let shinTopD = shinBotD;
     let transZ = 0;
-    if (roofType === 'hip' || roofType === 'mansard' || roofType === 'dutch') {
+    if (roofType === 'hip' ||
+        roofType === 'mansard' ||
+        roofType === 'dutch' ||
+        roofType === 'conical') {
         shinTopW += 2 * stSin;
         shinTopD += 2 * stSin;
     }
@@ -146,6 +153,8 @@ function buildRoofSurfaceFaces(segment) {
         tanTheta,
         shapeRatios,
         dutchTopRakeThickness: segment.dutchTopRakeThickness,
+        conicalStartAngle: conicalCoverage.startAngle,
+        conicalSweepAngle: conicalCoverage.sweepAngle,
     })
         .filter((face) => faceNormalY(face) > SHINGLE_SURFACE_EPSILON)
         .map((face) => {
@@ -361,6 +370,12 @@ export function getAnalyticalNormal(lx, lz, seg, out = new THREE.Vector3()) {
     if (roofType === 'shed') {
         return buildSlopeNormal(0, 1, primaryTan, out);
     }
+    if (roofType === 'conical') {
+        const radius = Math.hypot(lx, lz);
+        if (radius <= 1e-6)
+            return out.set(0, 1, 0);
+        return buildSlopeNormal(lx / radius, lz / radius, primaryTan, out);
+    }
     // 4-sided slopes: the dominant axis chooses which face the point sits
     // on. Hip is uniform across all four faces. Mansard has a steep outer
     // band (primaryTan) and a shallow top inside the waist. Dutch has hip

package/dist/shared/run-cursor.d.ts

@@ -0,0 +1,22 @@
+import type { RunPoint, RunSurfaceFrame } from './distribution-run-contract';
+export declare function intersectRunPlane(ray: {
+    origin: RunPoint;
+    direction: RunPoint;
+}, frame: RunSurfaceFrame): RunPoint | null;
+export declare function resolveRunCursorPlane({ hit, working, ray, fallback, clearance, }: {
+    hit: {
+        point: RunPoint;
+        frame: RunSurfaceFrame;
+    } | null;
+    working: RunSurfaceFrame | null;
+    ray?: {
+        origin: RunPoint;
+        direction: RunPoint;
+    };
+    fallback: RunPoint;
+    clearance: number;
+}): {
+    point: RunPoint;
+    frame: RunSurfaceFrame;
+};
+//# sourceMappingURL=run-cursor.d.ts.map

package/dist/shared/run-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-cursor.d.ts","sourceRoot":"","sources":["../../src/shared/run-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAE5E,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,QAAQ,CAAA;CAAE,EAC9C,KAAK,EAAE,eAAe,GACrB,QAAQ,GAAG,IAAI,CAQjB;AAED,wBAAgB,qBAAqB,CAAC,EACpC,GAAG,EACH,OAAO,EACP,GAAG,EACH,QAAQ,EACR,SAAS,GACV,EAAE;IACD,GAAG,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,eAAe,CAAA;KAAE,GAAG,IAAI,CAAA;IACvD,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,GAAG,CAAC,EAAE;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,QAAQ,CAAA;KAAE,CAAA;IAC/C,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,CAQ9C"}

package/dist/shared/run-cursor.js

@@ -0,0 +1,19 @@
+export function intersectRunPlane(ray, frame) {
+    const denominator = ray.direction.reduce((sum, value, i) => sum + value * frame.normal[i], 0);
+    if (Math.abs(denominator) < 1e-5)
+        return null;
+    const distance = frame.origin.reduce((sum, value, i) => sum + (value - ray.origin[i]) * frame.normal[i], 0) /
+        denominator;
+    if (distance < 0 || !Number.isFinite(distance))
+        return null;
+    return ray.origin.map((value, i) => value + distance * ray.direction[i]);
+}
+export function resolveRunCursorPlane({ hit, working, ray, fallback, clearance, }) {
+    if (hit) {
+        const offset = (point) => point.map((value, i) => value + hit.frame.normal[i] * clearance);
+        return { point: offset(hit.point), frame: { ...hit.frame, origin: offset(hit.frame.origin) } };
+    }
+    if (!working)
+        throw new Error('A cursor requires a surface or a working plane');
+    return { point: ray ? (intersectRunPlane(ray, working) ?? fallback) : fallback, frame: working };
+}

package/dist/shared/run-direction-feedback.d.ts

@@ -0,0 +1,20 @@
+import type { RunPoint } from './distribution-run-tool';
+export type RunDirectionMode = 'free' | 'angle' | 'snap' | 'vertical';
+export type RunDirectionCandidate = {
+    direction: RunPoint;
+    active: boolean;
+};
+type RunVector = readonly [number, number, number];
+export declare function run3DDirectionCandidates(sourceDirection: RunVector): RunPoint[];
+export declare function runHorizontalDirectionCandidates(sourceDirection: RunVector | null): RunPoint[];
+export declare function resolveRunDirectionCandidates(start: RunPoint, cursor: RunPoint, sourceDirection: RunVector | null, mode: RunDirectionMode): RunDirectionCandidate[];
+export declare function RunDirectionFeedback({ start, cursor, sourceDirection, mode, snapped, onDirectionSelect, }: {
+    start: RunPoint;
+    cursor: RunPoint;
+    sourceDirection: RunVector | null;
+    mode: RunDirectionMode;
+    snapped: boolean;
+    onDirectionSelect?: (direction: RunPoint) => void;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=run-direction-feedback.d.ts.map

package/dist/shared/run-direction-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-direction-feedback.d.ts","sourceRoot":"","sources":["../../src/shared/run-direction-feedback.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAA;AAErE,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,QAAQ,CAAA;IACnB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAuBlD,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,SAAS,GAAG,QAAQ,EAAE,CA2B/E;AAED,wBAAgB,gCAAgC,CAAC,eAAe,EAAE,SAAS,GAAG,IAAI,GAAG,QAAQ,EAAE,CAU9F;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,QAAQ,EAChB,eAAe,EAAE,SAAS,GAAG,IAAI,EACjC,IAAI,EAAE,gBAAgB,GACrB,qBAAqB,EAAE,CA8BzB;AAED,wBAAgB,oBAAoB,CAAC,EACnC,KAAK,EACL,MAAM,EACN,eAAe,EACf,IAAI,EACJ,OAAO,EACP,iBAAiB,GAClB,EAAE;IACD,KAAK,EAAE,QAAQ,CAAA;IACf,MAAM,EAAE,QAAQ,CAAA;IAChB,eAAe,EAAE,SAAS,GAAG,IAAI,CAAA;IACjC,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,KAAK,IAAI,CAAA;CAClD,+BAsCA"}

package/dist/shared/run-direction-feedback.js

@@ -0,0 +1,139 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useThree } from '@react-three/fiber';
+import { useMemo } from 'react';
+import { OrthographicCamera, Quaternion, Vector3 } from 'three';
+const WORLD_DIRECTIONS = Array.from({ length: 8 }, (_, index) => {
+    const angle = (index * Math.PI) / 4;
+    return [Math.cos(angle), 0, Math.sin(angle)];
+});
+function horizontalDirection(direction) {
+    const length = Math.hypot(direction[0], direction[2]);
+    return length < 1e-6 ? null : [direction[0] / length, 0, direction[2] / length];
+}
+function normalizedDirection(direction) {
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    if (length < 1e-6)
+        return null;
+    const normalized = direction.map((component) => component / length);
+    return normalized.map((component) => (Math.abs(component) < 1e-12 ? 0 : component));
+}
+function cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+export function run3DDirectionCandidates(sourceDirection) {
+    const source = normalizedDirection(sourceDirection);
+    if (!source)
+        return [];
+    const reference = Math.abs(source[1]) < 0.95 ? [0, 1, 0] : [1, 0, 0];
+    const lateral = normalizedDirection(cross(source, reference));
+    if (!lateral)
+        return [source];
+    const upright = normalizedDirection(cross(lateral, source));
+    if (!upright)
+        return [source];
+    const candidates = [source];
+    for (const perpendicular of [upright, lateral]) {
+        for (const sign of [1, -1]) {
+            const turn = [
+                perpendicular[0] * sign,
+                perpendicular[1] * sign,
+                perpendicular[2] * sign,
+            ].map((component) => (Math.abs(component) < 1e-12 ? 0 : component));
+            candidates.push(turn);
+            const diagonal = normalizedDirection([
+                source[0] + turn[0],
+                source[1] + turn[1],
+                source[2] + turn[2],
+            ]);
+            if (diagonal)
+                candidates.push(diagonal);
+        }
+    }
+    return candidates;
+}
+export function runHorizontalDirectionCandidates(sourceDirection) {
+    if (!sourceDirection)
+        return WORLD_DIRECTIONS;
+    const source = horizontalDirection(sourceDirection);
+    if (!source)
+        return WORLD_DIRECTIONS;
+    const angle = Math.atan2(source[2], source[0]);
+    return [-Math.PI / 2, -Math.PI / 4, 0, Math.PI / 4, Math.PI / 2].map((offset) => [
+        Math.cos(angle + offset),
+        0,
+        Math.sin(angle + offset),
+    ]);
+}
+export function resolveRunDirectionCandidates(start, cursor, sourceDirection, mode) {
+    const delta = [cursor[0] - start[0], cursor[1] - start[1], cursor[2] - start[2]];
+    if (mode === 'vertical') {
+        const activeSign = delta[1] < 0 ? -1 : 1;
+        return [1, -1].map((sign) => ({
+            direction: [0, sign, 0],
+            active: sign === activeSign,
+        }));
+    }
+    const directions = sourceDirection
+        ? run3DDirectionCandidates(sourceDirection)
+        : runHorizontalDirectionCandidates(null);
+    let activeIndex = -1;
+    const pointerDirection = normalizedDirection(delta);
+    if (pointerDirection && mode === 'angle') {
+        let bestDot = Number.NEGATIVE_INFINITY;
+        for (let index = 0; index < directions.length; index++) {
+            const direction = directions[index];
+            const dot = direction[0] * pointerDirection[0] +
+                direction[1] * pointerDirection[1] +
+                direction[2] * pointerDirection[2];
+            if (dot > bestDot) {
+                bestDot = dot;
+                activeIndex = index;
+            }
+        }
+    }
+    return directions.map((direction, index) => ({ direction, active: index === activeIndex }));
+}
+export function RunDirectionFeedback({ start, cursor, sourceDirection, mode, snapped, onDirectionSelect, }) {
+    const candidates = useMemo(() => resolveRunDirectionCandidates(start, cursor, sourceDirection, mode), [cursor, mode, sourceDirection, start]);
+    const distance = Math.hypot(cursor[0] - start[0], cursor[1] - start[1], cursor[2] - start[2]);
+    const candidateLength = Math.min(1.8, Math.max(0.7, distance * 0.7));
+    const activeColor = snapped ? '#22c55e' : '#818cf8';
+    return (_jsxs("group", { children: [candidates.map((candidate, index) => (_jsx(DirectionRay, { active: candidate.active, color: candidate.active ? activeColor : '#818cf8', direction: candidate.direction, length: candidate.active ? Math.max(distance, candidateLength) : candidateLength, origin: start, onDirectionSelect: onDirectionSelect }, `${index}:${candidate.direction.join(':')}`))), distance > 0.01 && mode !== 'angle' && mode !== 'vertical' && (_jsx(DirectionRay, { active: true, color: activeColor, direction: [
+                    (cursor[0] - start[0]) / distance,
+                    (cursor[1] - start[1]) / distance,
+                    (cursor[2] - start[2]) / distance,
+                ], length: distance, origin: start, onDirectionSelect: onDirectionSelect }))] }));
+}
+function DirectionRay({ origin, direction, length, active, color, onDirectionSelect, }) {
+    const { camera } = useThree();
+    const zoomScale = camera instanceof OrthographicCamera ? 1 / camera.zoom : 1;
+    const placement = useMemo(() => {
+        const axis = new Vector3(direction[0], direction[1], direction[2]).normalize();
+        const start = new Vector3(origin[0], origin[1] + 0.015, origin[2]);
+        const end = start.clone().addScaledVector(axis, length);
+        return {
+            midpoint: start.clone().add(end).multiplyScalar(0.5).toArray(),
+            tip: end.toArray(),
+            rotation: new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), axis),
+        };
+    }, [direction, length, origin]);
+    const radius = (active ? 0.012 : 0.006) * zoomScale;
+    const arrowLength = (active ? 0.1 : 0.07) * zoomScale;
+    const arrowRadius = (active ? 0.04 : 0.025) * zoomScale;
+    const opacity = active ? 0.9 : 0.18;
+    return (_jsxs("group", { children: [_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.midpoint, quaternion: placement.rotation, scale: [radius, length, radius], renderOrder: active ? 4 : 2, onPointerDown: (event) => {
+                    if (!onDirectionSelect)
+                        return;
+                    event.stopPropagation();
+                    event.nativeEvent.stopImmediatePropagation();
+                    onDirectionSelect([...direction]);
+                }, children: [_jsx("cylinderGeometry", { args: [1, 1, 1, 8] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, opacity: opacity, transparent: true })] }), _jsxs("mesh", { layers: EDITOR_LAYER, position: placement.tip, quaternion: placement.rotation, scale: [arrowRadius, arrowLength, arrowRadius], renderOrder: active ? 4 : 2, onPointerDown: (event) => {
+                    if (!onDirectionSelect)
+                        return;
+                    event.stopPropagation();
+                    event.nativeEvent.stopImmediatePropagation();
+                    onDirectionSelect([...direction]);
+                }, children: [_jsx("coneGeometry", { args: [1, 1, 10] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, opacity: opacity, transparent: true })] })] }));
+}

package/dist/shared/run-hanger-controls.d.ts

@@ -0,0 +1,7 @@
+import { type AnyNodeId } from '@pascal-app/core';
+import { type SupportedRun } from './run-hangers';
+export declare function RunHangerPreview({ run, levelId }: {
+    run: SupportedRun;
+    levelId: AnyNodeId;
+}): import("react").JSX.Element;
+//# sourceMappingURL=run-hanger-controls.d.ts.map

package/dist/shared/run-hanger-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-hanger-controls.d.ts","sourceRoot":"","sources":["../../src/shared/run-hanger-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,SAAS,EAAY,MAAM,kBAAkB,CAAA;AAKzE,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAElE,wBAAgB,gBAAgB,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;IAAE,GAAG,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,+BAoC3F"}

package/dist/shared/run-hanger-controls.js

@@ -0,0 +1,44 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useScene } from '@pascal-app/core';
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { disposeObject3DResources } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { Mesh, MeshBasicMaterial } from 'three';
+import { buildRunHangers } from './run-hangers';
+export function RunHangerPreview({ run, levelId }) {
+    const nodes = useScene.getState().nodes;
+    const geometry = useMemo(() => {
+        const group = buildRunHangers({ ...run, parentId: levelId }, {
+            resolve: (id) => nodes[id],
+            children: [],
+            siblings: [],
+            parent: nodes[levelId] ?? null,
+            sceneNodes: nodes,
+        });
+        const material = new MeshBasicMaterial({
+            color: '#818cf8',
+            transparent: true,
+            opacity: 0.55,
+            depthTest: false,
+        });
+        const disposed = new Set();
+        group.traverse((child) => {
+            if (!(child instanceof Mesh))
+                return;
+            for (const previous of Array.isArray(child.material) ? child.material : [child.material]) {
+                if (!disposed.has(previous)) {
+                    previous.dispose();
+                    disposed.add(previous);
+                }
+            }
+            child.material = material;
+            child.layers.set(EDITOR_LAYER);
+        });
+        if (!group.children.length)
+            material.dispose();
+        return group;
+    }, [run, levelId, nodes]);
+    useEffect(() => () => disposeObject3DResources(geometry), [geometry]);
+    return _jsx("primitive", { object: geometry });
+}

package/dist/shared/run-hanger-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type SupportedRun } from './run-hangers';
+export default function RunHangerInspector({ node }: {
+    node: SupportedRun;
+}): import("react").JSX.Element;
+//# sourceMappingURL=run-hanger-inspector.d.ts.map

package/dist/shared/run-hanger-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-hanger-inspector.d.ts","sourceRoot":"","sources":["../../src/shared/run-hanger-inspector.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAGrE,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,+BAkH1E"}

package/dist/shared/run-hanger-inspector.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { emitter, useScene } from '@pascal-app/core';
+import { useMemo } from 'react';
+import { planRunHangerSlots } from './run-hangers';
+import SystemCheckPanel from './system-check-panel';
+export default function RunHangerInspector({ node }) {
+    const nodes = useScene((state) => state.nodes);
+    const slots = useMemo(() => planRunHangerSlots(node, nodes), [node, nodes]);
+    if (!node.autoHangers)
+        return _jsx(SystemCheckPanel, { nodeId: node.id, nodes: nodes });
+    const hosts = Object.values(nodes).filter((candidate) => candidate.parentId === node.parentId &&
+        (candidate.type === 'wall' || candidate.type === 'ceiling'));
+    const update = (id, patch) => {
+        const live = useScene.getState().nodes[node.id];
+        if (live?.type !== 'duct-segment' && live?.type !== 'pipe-segment')
+            return;
+        useScene.getState().updateNode(node.id, {
+            hangerOverrides: {
+                ...live.hangerOverrides,
+                [id]: { ...live.hangerOverrides?.[id], ...patch },
+            },
+        });
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(SystemCheckPanel, { nodeId: node.id, nodes: nodes }), _jsxs("section", { className: "space-y-2 border-t pt-3", children: [_jsx("h3", { className: "text-sm font-medium", children: "Individual hangers" }), _jsx("p", { className: "text-xs text-muted-foreground", children: "Positions are measured along each path segment. Changing spacing regenerates the numbered slots." }), _jsx("div", { className: "max-h-72 space-y-3 overflow-y-auto", children: slots.map((slot, index) => {
+                            const a = node.path[slot.segmentIndex];
+                            const b = node.path[slot.segmentIndex + 1];
+                            const length = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+                            const hostId = node.hangerOverrides?.[slot.id]?.hostId ?? '';
+                            return (_jsxs("div", { className: "space-y-1 rounded border p-2 text-xs", children: [_jsxs("div", { className: "flex justify-between", children: [_jsxs("span", { children: ["Hanger ", index + 1, " \u00B7 segment ", slot.segmentIndex + 1] }), _jsxs("label", { children: [_jsx("input", { type: "checkbox", checked: slot.skipped, onChange: (event) => update(slot.id, { skipped: event.target.checked }) }), ' ', "Skip"] })] }), !slot.skipped && !slot.hanger && (_jsx("p", { role: "status", className: "text-amber-600 dark:text-amber-400", children: "No support within reach. Move the hanger or choose another host." })), _jsxs("label", { className: "flex justify-between", children: ["Position (m)", _jsx("input", { "aria-label": `Hanger ${index + 1} position in metres`, type: "number", min: 0, max: length, step: 0.1, defaultValue: Number((slot.fraction * length).toFixed(3)), className: "w-20 bg-transparent", onBlur: (event) => {
+                                                    const value = event.target.valueAsNumber;
+                                                    if (Number.isFinite(value) &&
+                                                        value >= 0 &&
+                                                        value <= length &&
+                                                        Math.abs(value - slot.fraction * length) > 0.0005)
+                                                        update(slot.id, { fraction: value / length });
+                                                    else
+                                                        event.target.value = String(Number((slot.fraction * length).toFixed(3)));
+                                                } }, `${slot.id}:${slot.fraction}`)] }), _jsxs("select", { "aria-label": `Hanger ${index + 1} support`, value: hostId, className: "w-full bg-background", onChange: (event) => update(slot.id, { hostId: event.target.value }), children: [_jsx("option", { value: "", children: "Automatic support" }), hostId && !hosts.some((host) => host.id === hostId) && (_jsx("option", { value: hostId, children: "Missing support" })), hosts.map((host) => (_jsxs("option", { value: host.id, children: [host.name || host.type, " \u00B7 ", host.id.slice(-6)] }, host.id)))] }), slot.hanger && (_jsx("button", { type: "button", className: "underline", onClick: () => emitter.emit('camera-controls:focus', {
+                                            nodeId: slot.hanger.hostId,
+                                        }), children: "Reveal support" }))] }, slot.id));
+                        }) })] })] }));
+}

package/dist/shared/run-hanger-mode.d.ts

@@ -0,0 +1,11 @@
+import type { ToolHint } from '@pascal-app/core';
+export type RunHangerTool = 'duct-segment' | 'pipe-segment';
+type RunHangerModeState = {
+    enabled: Record<RunHangerTool, boolean>;
+    setEnabled: (tool: RunHangerTool, enabled: boolean) => void;
+    toggle: (tool: RunHangerTool) => void;
+};
+export declare const useRunHangerMode: import("zustand").UseBoundStore<import("zustand").StoreApi<RunHangerModeState>>;
+export declare function createRunHangerToolHint(tool: RunHangerTool): ToolHint;
+export {};
+//# sourceMappingURL=run-hanger-mode.d.ts.map

package/dist/shared/run-hanger-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-hanger-mode.d.ts","sourceRoot":"","sources":["../../src/shared/run-hanger-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGhD,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,cAAc,CAAA;AAE3D,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;IACvC,UAAU,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC3D,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,gBAAgB,iFAS1B,CAAA;AAEH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,QAAQ,CAsBrE"}

package/dist/shared/run-hanger-mode.js

@@ -0,0 +1,32 @@
+import { create } from 'zustand';
+export const useRunHangerMode = create((set) => ({
+    enabled: {
+        'duct-segment': false,
+        'pipe-segment': false,
+    },
+    setEnabled: (tool, enabled) => set((state) => ({ enabled: { ...state.enabled, [tool]: enabled } })),
+    toggle: (tool) => set((state) => ({ enabled: { ...state.enabled, [tool]: !state.enabled[tool] } })),
+}));
+export function createRunHangerToolHint(tool) {
+    return {
+        key: 'H',
+        label: 'Auto hangers',
+        chip: {
+            subscribe: (onChange) => useRunHangerMode.subscribe((state, previous) => {
+                if (state.enabled[tool] !== previous.enabled[tool])
+                    onChange();
+            }),
+            value: () => (useRunHangerMode.getState().enabled[tool] ? 'on' : 'off'),
+            cycle: () => useRunHangerMode.getState().toggle(tool),
+            labels: {
+                off: 'Auto hangers: Off',
+                on: 'Auto hangers: On',
+            },
+            icons: {
+                off: 'lucide:toggle-left',
+                on: 'lucide:toggle-right',
+            },
+            tooltip: 'Auto hangers - click or press H to toggle',
+        },
+    };
+}

package/dist/shared/run-hanger-system.d.ts

@@ -0,0 +1,3 @@
+export declare function DuctHangerSystem(): null;
+export declare function PipeHangerSystem(): null;
+//# sourceMappingURL=run-hanger-system.d.ts.map

package/dist/shared/run-hanger-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-hanger-system.d.ts","sourceRoot":"","sources":["../../src/shared/run-hanger-system.tsx"],"names":[],"mappings":"AAmCA,wBAAgB,gBAAgB,SAG/B;AACD,wBAAgB,gBAAgB,SAG/B"}

package/dist/shared/run-hanger-system.js

@@ -0,0 +1,39 @@
+'use client';
+import { useScene } from '@pascal-app/core';
+import { useEffect } from 'react';
+function useHangerDependencies(kind) {
+    useEffect(() => useScene.subscribe((state, previous) => {
+        if (state.nodes === previous.nodes)
+            return;
+        const structural = new Set([
+            'wall',
+            'ceiling',
+            'slab',
+            'level',
+            'building',
+            'site',
+            'door',
+            'window',
+        ]);
+        const changed = new Set([...Object.keys(state.nodes), ...Object.keys(previous.nodes)]);
+        const needsUpdate = [...changed].some((id) => {
+            const a = state.nodes[id];
+            const b = previous.nodes[id];
+            return a !== b && (structural.has(a?.type ?? '') || structural.has(b?.type ?? ''));
+        });
+        if (!needsUpdate)
+            return;
+        for (const node of Object.values(state.nodes)) {
+            if (node.type === kind && node.autoHangers)
+                state.markDirty(node.id);
+        }
+    }), [kind]);
+}
+export function DuctHangerSystem() {
+    useHangerDependencies('duct-segment');
+    return null;
+}
+export function PipeHangerSystem() {
+    useHangerDependencies('pipe-segment');
+    return null;
+}