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

package/dist/gutter/eave-snap.js

@@ -1,3 +1,4 @@
+import { computeGutterEaveY, GUTTER_EAVE_TUCK_INWARD, GUTTER_EAVE_TUCK_UP, getRoofShapeEaveSides, } from '@pascal-app/core';
 /**
  * Shared eave-snap math for the gutter's placement + move tools.
  *
@@ -18,8 +19,8 @@
 // drip-edge. These tuck the snap so the gutter reads as "attached to
 // the fascia" rather than "floating at the very tip of the overhang".
 // Tuned by feel — bump them up if the gutter looks too low / outboard.
-export const EAVE_TUCK_INWARD = 0.04;
-export const EAVE_TUCK_UP = 0.04;
+export const EAVE_TUCK_INWARD = GUTTER_EAVE_TUCK_INWARD;
+export const EAVE_TUCK_UP = GUTTER_EAVE_TUCK_UP;
 /**
  * Live eave Y from a segment's wallHeight + overhang + pitch. Pulled
  * out as a shared helper because the renderer derives Y from this same
@@ -28,18 +29,7 @@ export const EAVE_TUCK_UP = 0.04;
  * `resolveEaveSnap` uses the same formula at placement.
  */
 export function computeEaveY(segment) {
-    const wallHeight = segment.wallHeight ?? 0;
-    // Flat roofs have no slope drop and no slope-surface-vs-deck-top
-    // offset — the deck top IS the eave line. EAVE_TUCK_UP is a
-    // correction that lifts a SLOPED gutter from the slope-surface up to
-    // the deck-top line; applying it to a flat deck floats the gutter
-    // above the roof and leaves a visible gap between the edge and the
-    // gutter. So mount flat gutters right at the deck top.
-    if ((segment.roofType ?? 'gable') === 'flat')
-        return wallHeight;
-    const overhang = segment.overhang ?? 0;
-    const pitchRad = ((segment.pitch ?? 0) * Math.PI) / 180;
-    return wallHeight - overhang * Math.tan(pitchRad) + EAVE_TUCK_UP;
+    return computeGutterEaveY(segment);
 }
 /**
  * Pick which of the segment's eaves is closest to the cursor.
@@ -49,7 +39,7 @@ export function computeEaveY(segment) {
  *    regardless of which side the cursor is on — clicking on the high
  *    side still rolls the gutter down to the low eave.
  *
- *  - `hip` / `flat` / `dutch`: 4-way. The slope the user is standing
+ *  - Four-eave roofs: the slope the user is standing
  *    on is determined by whichever of `|lx|/halfW` or `|lz|/halfD` is
  *    larger — same `max(fx, fz)` discriminator the segment-hit's
  *    `analyticalSurfaceY` uses for hip. Sign of the dominant axis
@@ -57,16 +47,13 @@ export function computeEaveY(segment) {
  *    lower run has all four eaves at the eave line — it gets the same
  *    4-way snap as hip.
  *
- *  - `gable` / `gambrel` / `mansard`: 2-way `±Z`. Mansard has real
- *    4-side eaves in plan, but the segment-hit formula approximates it
- *    as 2-slope (depth-only), so we stay consistent here — the user
- *    can re-place the gutter manually on a side eave if mansard
- *    becomes important.
+ *  - `gable` / `gambrel`: 2-way `±Z`.
  */
 function pickEaveSide(roofType, localX, localZ, halfW, halfD) {
-    if (roofType === 'shed')
-        return '+Z';
-    if (roofType === 'hip' || roofType === 'flat' || roofType === 'dutch') {
+    const sides = getRoofShapeEaveSides(roofType);
+    if (sides.length === 1)
+        return sides[0];
+    if (sides.includes('+X')) {
         const fx = halfW > 0 ? Math.abs(localX) / halfW : 0;
         const fz = halfD > 0 ? Math.abs(localZ) / halfD : 0;
         if (fx > fz)

package/dist/gutter/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/gutter/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAQlD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,gBAAgB,CAAA;AAW7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,YAAwB,GAC/B,KAAK,CAAC,cAAc,CAsLtB"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/gutter/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAQlD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,gBAAgB,CAAA;AAW7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,YAAwB,GAC/B,KAAK,CAAC,cAAc,CA8LtB"}

package/dist/gutter/geometry.js

@@ -1,6 +1,7 @@
 import { Brush, csgEvaluator, csgGeometry, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { applyCylinderWorldUvs, applyPlanarWorldUvs, copyUvToSecondaryChannel, } from '../shared/primitive-uv';
 import { NO_MITRES } from './corner-mitre';
 import { OUTLET_STUB_LENGTH, OUTLET_WALL_THICKNESS, outletDims, outletShapeForProfile, profileFloorMidZ, } from './profile-geometry';
 /**
@@ -78,7 +79,7 @@ export function buildGutterGeometry(node, mitres = NO_MITRES) {
         depth: channelLen,
         bevelEnabled: false,
         curveSegments: 16,
-        steps: 1,
+        steps: gutterArcSteps(node, channelLen),
     });
     // Apply the corner-mitre skew while we're still in the source frame.
     // Source axes (pre-rotation): X_cs = outward, Y_cs = vertical,
@@ -135,7 +136,7 @@ export function buildGutterGeometry(node, mitres = NO_MITRES) {
             depth: capLeftLen,
             bevelEnabled: false,
             curveSegments: 16,
-            steps: 1,
+            steps: gutterArcSteps(node, capLeftLen),
         });
         leftCap.rotateY(-Math.PI / 2);
         // Left cap spans [-len/2, -len/2 + capLeftLen]: translate by
@@ -149,7 +150,7 @@ export function buildGutterGeometry(node, mitres = NO_MITRES) {
             depth: capRightLen,
             bevelEnabled: false,
             curveSegments: 16,
-            steps: 1,
+            steps: gutterArcSteps(node, capRightLen),
         });
         rightCap.rotateY(-Math.PI / 2);
         // Right cap spans [+len/2 - capRightLen, +len/2].
@@ -190,7 +191,11 @@ export function buildGutterGeometry(node, mitres = NO_MITRES) {
     // CSG drill — punches each bore through the merged geometry. Runs
     // last so the floor + collars are already in one mesh; each drill
     // cuts both at once, subtracted sequentially.
-    if (placements.length > 0) {
+    // Subtracting a near-end outlet from an already subdivided curved run makes
+    // three-bvh-csg discard the complete cross-section around the drill, leaving
+    // a visible break in the fascia. Keep the curved trough watertight; its collar
+    // and connected downspout still conceal the floor where the bore would sit.
+    if (placements.length > 0 && !node.arc) {
         let workingBrush = new Brush(merged);
         prepareBrushForCSG(workingBrush);
         for (const p of placements) {
@@ -208,9 +213,115 @@ export function buildGutterGeometry(node, mitres = NO_MITRES) {
         }
         const cutGeometry = csgGeometry(workingBrush);
         merged.dispose();
-        return cutGeometry;
+        const finished = bendGutterGeometryAlongArc(cutGeometry, node, mitres);
+        copyUvToSecondaryChannel(finished);
+        return finished;
     }
-    return merged;
+    const finished = bendGutterGeometryAlongArc(merged, node, mitres);
+    copyUvToSecondaryChannel(finished);
+    return finished;
+}
+function gutterArcSteps(node, length) {
+    if (!node.arc || !Number.isFinite(node.arc.radius))
+        return 1;
+    return Math.max(1, Math.min(32, Math.ceil(length / 0.4)));
+}
+// Bend the finished straight gutter (length along mesh-+X, outward along mesh-+Z)
+// onto its stored concentric arc. Each vertex keeps its vertical Y; its (x, z) rotate
+// about the arc center by the angle its along-length coordinate subtends, so the trough
+// hugs the same circle as the deck's eave. Absent `arc` is a straight no-op.
+function bendGutterGeometryAlongArc(geometry, node, mitres) {
+    const arc = node.arc;
+    if (!arc || !Number.isFinite(arc.radius))
+        return geometry;
+    const signedRef = (Math.sign(arc.centerZ) || 1) * arc.radius;
+    const position = geometry.attributes.position;
+    const metadata = node.metadata && typeof node.metadata === 'object' && !Array.isArray(node.metadata)
+        ? node.metadata
+        : {};
+    const rawStraightEnds = metadata.leanToGutterArcStraightEnds;
+    const straightEnds = rawStraightEnds && typeof rawStraightEnds === 'object' && !Array.isArray(rawStraightEnds)
+        ? rawStraightEnds
+        : {};
+    const straightEnd = (side) => {
+        const raw = straightEnds[side];
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            return null;
+        const value = raw;
+        return typeof value.startX === 'number' && typeof value.endX === 'number'
+            ? { startX: value.startX, endX: value.endX }
+            : null;
+    };
+    const leftStraight = straightEnd('left');
+    const rightStraight = straightEnd('right');
+    const bendPoint = (x, z, phi) => {
+        const radial = z - arc.centerZ;
+        return {
+            x: arc.centerX - radial * Math.sin(phi),
+            z: arc.centerZ + radial * Math.cos(phi),
+        };
+    };
+    const bendMitredEnd = (x, z, endX) => {
+        const phi = (endX - arc.centerX) / signedRef;
+        const base = bendPoint(endX, z, phi);
+        const extension = x - endX;
+        return {
+            x: base.x + extension * Math.cos(phi),
+            z: base.z + extension * Math.sin(phi),
+        };
+    };
+    const bendStraightEnd = (x, z, transition) => {
+        const startPhi = (transition.startX - arc.centerX) / signedRef;
+        const endPhi = (transition.endX - arc.centerX) / signedRef;
+        const start = bendPoint(transition.startX, 0, startPhi);
+        const end = bendPoint(transition.endX, 0, endPhi);
+        const spanX = transition.endX - transition.startX;
+        const direction = Math.sign(spanX) || 1;
+        const beyondEnd = Math.max(0, (x - transition.endX) * direction);
+        const pathX = x - beyondEnd * direction;
+        const ratio = Math.abs(spanX) > 1e-6 ? (pathX - transition.startX) / spanX : 0;
+        let centerX = start.x + (end.x - start.x) * ratio;
+        let centerZ = start.z + (end.z - start.z) * ratio;
+        const chordLength = Math.hypot(end.x - start.x, end.z - start.z);
+        const tangentX = chordLength > 1e-6 ? (end.x - start.x) / chordLength : Math.cos(startPhi);
+        const tangentZ = chordLength > 1e-6 ? (end.z - start.z) / chordLength : Math.sin(startPhi);
+        centerX += beyondEnd * tangentX;
+        centerZ += beyondEnd * tangentZ;
+        let normalX = -tangentZ;
+        let normalZ = tangentX;
+        const midPhi = (startPhi + endPhi) / 2;
+        if (normalX * -Math.sin(midPhi) + normalZ * Math.cos(midPhi) < 0) {
+            normalX = -normalX;
+            normalZ = -normalZ;
+        }
+        return { x: centerX + z * normalX, z: centerZ + z * normalZ };
+    };
+    const rightTan = Math.tan(mitres.right);
+    const leftTan = Math.tan(mitres.left);
+    const halfLength = Math.max(0.05, node.length) / 2;
+    const endEpsilon = 1e-4;
+    for (let index = 0; index < position.count; index++) {
+        const x = position.getX(index);
+        const z = position.getZ(index);
+        const onRightMitre = mitres.right !== 0 && Math.abs(x - (halfLength + z * rightTan)) < endEpsilon;
+        const onLeftMitre = mitres.left !== 0 && Math.abs(x - (-halfLength - z * leftTan)) < endEpsilon;
+        const onRightStraight = rightStraight && x >= rightStraight.startX - endEpsilon;
+        const onLeftStraight = leftStraight && x <= leftStraight.startX + endEpsilon;
+        const bent = onRightStraight
+            ? bendStraightEnd(x, z, rightStraight)
+            : onLeftStraight
+                ? bendStraightEnd(x, z, leftStraight)
+                : onRightMitre
+                    ? bendMitredEnd(x, z, halfLength)
+                    : onLeftMitre
+                        ? bendMitredEnd(x, z, -halfLength)
+                        : bendPoint(x, z, (x - arc.centerX) / signedRef);
+        position.setX(index, bent.x);
+        position.setZ(index, bent.z);
+    }
+    position.needsUpdate = true;
+    geometry.computeVertexNormals();
+    return geometry;
 }
 // Remove the extrude's cross-section CAP triangles at a mitred end so two
 // gutters meeting at a corner don't leave coincident, z-fighting end
@@ -431,6 +542,7 @@ function buildHangers(node, len, size, capLeftLen, capRightLen, mitres) {
         // not. `mergeGeometries` rejects mixed-index sets, so flatten the
         // box to non-indexed before pushing.
         const bar = new THREE.BoxGeometry(HANGER_BAR_LEN, HANGER_BAR_THICKNESS, strapDepth).toNonIndexed();
+        applyPlanarWorldUvs(bar);
         // Center the bar at X = position, Y just above the rim line, Z
         // straddling 0 so the strap covers the full back-to-front span.
         bar.translate(x, HANGER_BAR_THICKNESS / 2 + 0.001, rimWidth / 2);
@@ -485,9 +597,13 @@ function resolveOutletPlacements(node, len, size, capLeftLen, capRightLen) {
 /** Cylinder (round) or box (rect) sized to `dims`, height `h` along Y. */
 function outletSolid(dims, h) {
     if (dims.shape === 'round') {
-        return new THREE.CylinderGeometry(dims.halfX, dims.halfX, h, OUTLET_RADIAL_SEGMENTS).toNonIndexed();
+        const geometry = new THREE.CylinderGeometry(dims.halfX, dims.halfX, h, OUTLET_RADIAL_SEGMENTS).toNonIndexed();
+        applyCylinderWorldUvs(geometry, dims.halfX, h);
+        return geometry;
     }
-    return new THREE.BoxGeometry(2 * dims.halfX, h, 2 * dims.halfZ).toNonIndexed();
+    const geometry = new THREE.BoxGeometry(2 * dims.halfX, h, 2 * dims.halfZ).toNonIndexed();
+    applyPlanarWorldUvs(geometry);
+    return geometry;
 }
 /**
  * Solid collar at the OUTER cross-section; the CSG drill hollows out the
@@ -509,9 +625,11 @@ function buildOutletFunnel(p, size) {
     let funnel;
     if (p.shape === 'round') {
         funnel = new THREE.CylinderGeometry(p.outer.halfX * OUTLET_FLARE_SCALE, p.outer.halfX, OUTLET_FLARE_HEIGHT, OUTLET_RADIAL_SEGMENTS).toNonIndexed();
+        applyCylinderWorldUvs(funnel, p.outer.halfX * OUTLET_FLARE_SCALE, OUTLET_FLARE_HEIGHT);
     }
     else {
         funnel = new THREE.BoxGeometry(2 * p.outer.halfX * OUTLET_FLARE_SCALE, OUTLET_FLARE_HEIGHT, 2 * p.outer.halfZ * OUTLET_FLARE_SCALE).toNonIndexed();
+        applyPlanarWorldUvs(funnel);
     }
     funnel.translate(p.x, centerY, p.z);
     return funnel;

package/dist/gutter/outlet-lookup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outlet-lookup.d.ts","sourceRoot":"","sources":["../../src/gutter/outlet-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAEL,KAAK,WAAW,EAIjB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,uEAAuE;IACvE,CAAC,EAAE,MAAM,CAAA;IACT,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAA;IACT,8DAA8D;IAC9D,CAAC,EAAE,MAAM,CAAA;IACT,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,KAAK,EAAE,WAAW,CAAA;IAClB,sFAAsF;IACtF,UAAU,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAwCD,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,qBAAqB,GAAG,IAAI,CAM9B;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,GACjB,KAAK,CAAC,qBAAqB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ/C"}
+{"version":3,"file":"outlet-lookup.d.ts","sourceRoot":"","sources":["../../src/gutter/outlet-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAEL,KAAK,WAAW,EAIjB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,uEAAuE;IACvE,CAAC,EAAE,MAAM,CAAA;IACT,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAA;IACT,8DAA8D;IAC9D,CAAC,EAAE,MAAM,CAAA;IACT,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,KAAK,EAAE,WAAW,CAAA;IAClB,sFAAsF;IACtF,UAAU,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AA8DD,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,qBAAqB,GAAG,IAAI,CAM9B;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,GACjB,KAAK,CAAC,qBAAqB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ/C"}

package/dist/gutter/outlet-lookup.js

@@ -11,10 +11,31 @@ function placeOutlet(gutter, outlet, len, size, t) {
     if (maxX <= minX)
         return null;
     const x = Math.max(minX, Math.min(maxX, outlet.offset ?? 0));
+    const z = profileFloorMidZ(gutter.profile ?? 'k-style', size);
+    // Straight run: the along-length X and outward Z are already the
+    // mesh-local center. A managed lean-to gutter following a curved wall
+    // carries a concentric arc, so the trough floor bends along its length —
+    // remap (x, z) onto the same arc the geometry uses so the drop tube mounts
+    // on the actual bent floor rather than the straight chord.
+    const arc = gutter.arc;
+    if (arc && Number.isFinite(arc.radius)) {
+        const signedRef = (Math.sign(arc.centerZ) || 1) * arc.radius;
+        const phi = (x - arc.centerX) / signedRef;
+        const radial = z - arc.centerZ;
+        return {
+            x: arc.centerX - radial * Math.sin(phi),
+            y: -size,
+            z: arc.centerZ + radial * Math.cos(phi),
+            bore: inner.halfX,
+            shape,
+            innerHalfX: inner.halfX,
+            innerHalfZ: inner.halfZ,
+        };
+    }
     return {
         x,
         y: -size,
-        z: profileFloorMidZ(gutter.profile ?? 'k-style', size),
+        z,
         bore: inner.halfX,
         shape,
         innerHalfX: inner.halfX,

package/dist/gutter/paint.d.ts

@@ -0,0 +1,3 @@
+import type { PaintCapability } from '@pascal-app/core';
+export declare const gutterPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/gutter/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/gutter/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD,eAAO,MAAM,WAAW,EAAE,eAIzB,CAAA"}

package/dist/gutter/paint.js

@@ -0,0 +1,6 @@
+import { surfacePaintCapability } from '../shared/surface-paint';
+export const gutterPaint = {
+    ...surfacePaintCapability,
+    materialTarget: 'gutter',
+    resolveRole: () => 'gutter',
+};

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/gutter/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,CAAC,UAAU,CA6D9D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/gutter/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,CAAC,UAAU,CAiE9D,CAAA"}

package/dist/gutter/parametrics.js

@@ -14,7 +14,7 @@ export const gutterParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'length', kind: 'number', unit: 'm', min: 0.2, max: 12, step: 0.05 },
+                { key: 'length', kind: 'number', unit: 'm', min: 0.2, max: 1000, step: 0.05 },
                 { key: 'size', kind: 'number', unit: 'm', min: 0.05, max: 0.3, step: 0.005 },
                 {
                     key: 'thickness',
@@ -54,6 +54,9 @@ export const gutterParametrics = {
             ],
         },
     ],
+    onDeleteCascade: (node, nodes) => Object.values(nodes)
+        .filter((candidate) => candidate.type === 'downspout' && candidate.gutterId === node.id)
+        .map((candidate) => candidate.id),
     // Lazy-loaded section that lists every downspout attached to this
     // gutter and offers an Add button at the bottom. Outlets are created
     // and removed through this panel (and the downspout placement tool) —

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/gutter/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAwBzB;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCAmNhE,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/gutter/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCA8PhE,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/gutter/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { useShallow } from 'zustand/react/shallow';
@@ -10,11 +10,25 @@ import { computeGutterMitres, NO_MITRES } from './corner-mitre';
 import { computeSharedEaveY } from './eave-align';
 import { computeEaveY } from './eave-snap';
 import { buildGutterGeometry } from './geometry';
+import { segmentForGutterTrimClip } from './trim-clip';
 const defaultMaterial = new THREE.MeshStandardMaterial({
     color: 0xff_ff_ff,
     roughness: 0.7,
     metalness: 0.25,
 });
+function leanToJointMitres(node) {
+    const metadata = node.metadata && typeof node.metadata === 'object' && !Array.isArray(node.metadata)
+        ? node.metadata
+        : {};
+    const value = metadata.leanToGutterMitres;
+    if (!(value && typeof value === 'object' && !Array.isArray(value)))
+        return NO_MITRES;
+    const mitres = value;
+    return {
+        left: typeof mitres.left === 'number' && Number.isFinite(mitres.left) ? mitres.left : 0,
+        right: typeof mitres.right === 'number' && Number.isFinite(mitres.right) ? mitres.right : 0,
+    };
+}
 /**
  * Gutter renderer. Mounts at the eave of the host roof-segment — the
  * gutter hangs level off the eave line (gravity wins; no slope tilt).
@@ -39,6 +53,7 @@ const GutterRenderer = ({ node: storeNode }) => {
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneTheme = useViewer((s) => s.sceneTheme);
+    const sceneMaterials = useScene((s) => s.materials);
     const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
     const node = overrides ? { ...storeNode, ...overrides } : storeNode;
     const segment = useScene((state) => node.roofSegmentId
@@ -74,6 +89,9 @@ const GutterRenderer = ({ node: storeNode }) => {
         if (!roof)
             return [];
         const out = [];
+        const managedByLeanTo = typeof node.metadata?.managedByLeanTo === 'string'
+            ? node.metadata.managedByLeanTo
+            : null;
         for (const sid of roof.children ?? []) {
             const s = state.nodes[sid];
             if (s?.type !== 'roof-segment')
@@ -85,6 +103,21 @@ const GutterRenderer = ({ node: storeNode }) => {
                     out.push(g);
             }
         }
+        if (managedByLeanTo) {
+            for (const candidate of Object.values(state.nodes)) {
+                if (candidate?.type !== 'gutter' || candidate.id === storeNode.id)
+                    continue;
+                const candidateMetadata = candidate.metadata;
+                if (typeof candidateMetadata?.managedByLeanTo !== 'string')
+                    continue;
+                const segment = candidate.roofSegmentId
+                    ? state.nodes[candidate.roofSegmentId]
+                    : undefined;
+                if (!segment || out.some((node) => node.id === segment.id))
+                    continue;
+                out.push(segment, candidate);
+            }
+        }
         return out;
     }));
     // Mitres AND the run's shared eave height come from the same sibling
@@ -133,8 +166,13 @@ const GutterRenderer = ({ node: storeNode }) => {
         effectiveSegment?.roofType,
         mitreNodes,
     ]);
+    const jointMitres = leanToJointMitres(node);
+    const renderedMitres = {
+        left: jointMitres.left || mitres.left,
+        right: jointMitres.right || mitres.right,
+    };
     // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
-    const geometry = useMemo(() => buildGutterGeometry(node, mitres), [
+    const geometry = useMemo(() => buildGutterGeometry(node, renderedMitres), [
         node.length,
         node.size,
         node.thickness,
@@ -143,11 +181,14 @@ const GutterRenderer = ({ node: storeNode }) => {
         node.endCapRight,
         node.hangerStyle,
         node.hangerSpacing,
+        node.arc?.centerX,
+        node.arc?.centerZ,
+        node.arc?.radius,
         // Value-compare the outlets array so the CSG drills only rebuild
         // when an outlet's offset / diameter changes or one is added.
         JSON.stringify(node.outlets),
-        mitres.left,
-        mitres.right,
+        renderedMitres.left,
+        renderedMitres.right,
     ]);
     useEffect(() => () => geometry.dispose(), [geometry]);
     // Paint surface: explicit material wins, then preset, then the cached
@@ -162,20 +203,35 @@ const GutterRenderer = ({ node: storeNode }) => {
     // visible face. FrontSide is therefore sufficient and DoubleSide is not
     // needed.
     const material = useMemo(() => {
-        if (!textures || (!node.material && !node.materialPreset)) {
+        if (!textures) {
+            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        }
+        const slotMaterial = resolveMaterialRef(node.slots?.gutter, sceneMaterials, shading);
+        if (slotMaterial)
+            return slotMaterial;
+        if (!node.material && !node.materialPreset) {
             return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
         }
         return node.material
             ? createMaterial(node.material, shading)
             : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
-    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.slots?.gutter,
+        node.material,
+        node.materialPreset,
+        sceneMaterials,
+    ]);
     // Map gutter-local geometry into the host segment's local frame (where the
     // trim cut prisms live) — same pose the inner mesh group is mounted with
     // (position [x, liveEaveY, z] + yaw). Computed before the early return so the
     // hook order stays stable.
     const liveEaveYForClip = sharedEaveY ?? (effectiveSegment ? computeEaveY(effectiveSegment) : 0);
     const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, liveEaveYForClip, node.position[2] ?? 0), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), node.rotation ?? 0), new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[2], node.rotation, liveEaveYForClip]);
-    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, effectiveSegment, localToSegment);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, segmentForGutterTrimClip(node, effectiveSegment), localToSegment);
     if (!segment || !effectiveSegment)
         return null;
     // `node.position` is segment-local — the placement tool resolves the

package/dist/gutter/trim-clip.d.ts

@@ -0,0 +1,3 @@
+import type { GutterNode, RoofSegmentNode } from '@pascal-app/core';
+export declare function segmentForGutterTrimClip(gutter: Pick<GutterNode, 'arc'>, segment: RoofSegmentNode | undefined): RoofSegmentNode | undefined;
+//# sourceMappingURL=trim-clip.d.ts.map

package/dist/gutter/trim-clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim-clip.d.ts","sourceRoot":"","sources":["../../src/gutter/trim-clip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,EAC/B,OAAO,EAAE,eAAe,GAAG,SAAS,GACnC,eAAe,GAAG,SAAS,CAI7B"}

package/dist/gutter/trim-clip.js

@@ -0,0 +1,5 @@
+export function segmentForGutterTrimClip(gutter, segment) {
+    // Segment trim cutters are axis-aligned boxes. On a long arc, the back cutter
+    // crosses the gutter twice and removes two unrelated sections of the run.
+    return gutter.arc && segment?.arc ? undefined : segment;
+}

package/dist/hvac-equipment/parametrics.js

@@ -14,9 +14,9 @@ export const hvacEquipmentParametrics = {
         {
             label: 'Cabinet',
             fields: [
-                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 2, step: 0.05 },
-                { key: 'depth', kind: 'number', unit: 'm', min: 0.3, max: 2, step: 0.05 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 2.5, step: 0.05 },
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 1000, step: 0.05 },
             ],
         },
         {

package/dist/hvac-equipment/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAyGtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAiHtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/hvac-equipment/tool.js

@@ -5,6 +5,7 @@ import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor } from '@
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { subscribeAccessorySnapping } from '../shared/accessory-snapping';
 import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
 import { hvacEquipmentDefinition } from './definition';
@@ -55,9 +56,13 @@ const HvacEquipmentTool = () => {
         // it); `'off'` is the no-snap bypass.
         const resolveAligned = (event) => alignDrawPoint(resolve(event), {
             applySnap: isMagneticSnapActive(),
-            bypass: false,
+            bypass: !isMagneticSnapActive(),
         });
-        const onMove = (event) => setCursor(resolveAligned(event));
+        let lastEvent = null;
+        const onMove = (event) => {
+            lastEvent = event;
+            setCursor(resolveAligned(event));
+        };
         const onClick = (event) => {
             const position = resolveAligned(event);
             const unit = HvacEquipmentNode.parse({
@@ -91,10 +96,15 @@ const HvacEquipmentTool = () => {
             setYaw(yawRef.current);
             triggerSFX('sfx:item-rotate');
         };
+        const unsubscribeSnapping = subscribeAccessorySnapping(() => {
+            if (lastEvent)
+                onMove(lastEvent);
+        });
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
+            unsubscribeSnapping();
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             window.removeEventListener('keydown', onKeyDown, true);

package/dist/imported-mesh/definition.d.ts

@@ -0,0 +1,5 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { ImportedMeshNode } from './schema';
+/** Format-neutral fallback for imported objects without a parametric node. */
+export declare const importedMeshDefinition: NodeDefinition<typeof ImportedMeshNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/imported-mesh/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/imported-mesh/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAiC1E,CAAA"}

package/dist/imported-mesh/definition.js

@@ -0,0 +1,38 @@
+import { buildImportedMeshFloorplan } from './floorplan';
+import { buildImportedMeshGeometry } from './geometry';
+import { ImportedMeshNode } from './schema';
+/** Format-neutral fallback for imported objects without a parametric node. */
+export const importedMeshDefinition = {
+    kind: 'imported-mesh',
+    schemaVersion: 1,
+    schema: ImportedMeshNode,
+    category: 'structure',
+    snapProfile: 'item',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        primitives: [],
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        presettable: false,
+    },
+    geometryKey: (node) => `${node.id}:${node.primitives.length}`,
+    geometry: buildImportedMeshGeometry,
+    floorplan: buildImportedMeshFloorplan,
+    presentation: {
+        label: 'Imported Mesh',
+        description: 'Geometry preserved from an imported model when no native Pascal shape exists.',
+        icon: { kind: 'url', src: '/icons/item.webp' },
+        hidden: true,
+    },
+    mcp: {
+        description: 'Imported triangle geometry with source identity and properties in metadata.',
+    },
+};

package/dist/imported-mesh/floorplan.d.ts

@@ -0,0 +1,4 @@
+import type { FloorplanGeometry, GeometryContext, ImportedMeshNode } from '@pascal-app/core';
+/** A compact plan proxy for imported geometry, derived from its XZ bounds. */
+export declare function buildImportedMeshFloorplan(node: ImportedMeshNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/imported-mesh/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/imported-mesh/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,8EAA8E;AAC9E,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgC1B"}