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

package/dist/gutter/corner-mitre.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corner-mitre.d.ts","sourceRoot":"","sources":["../../src/gutter/corner-mitre.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,YAAoC,CAAA;AAQ5D,eAAO,MAAM,iBAAiB,QAAkC,CAAA;AAYhE,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,CAAA;CACxD,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,2FAA2F;IAC3F,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,gFAAgF;IAChF,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AA6BD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,GACtD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CA4BrC;AAUD,wBAAgB,UAAU,CACxB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,CAIR;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,EAC9D,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,YAAY,CAqCd"}
+{"version":3,"file":"corner-mitre.d.ts","sourceRoot":"","sources":["../../src/gutter/corner-mitre.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,YAAoC,CAAA;AAoB5D,eAAO,MAAM,iBAAiB,QAAkC,CAAA;AAYhE,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,CAAA;CACxD,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,2FAA2F;IAC3F,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,gFAAgF;IAChF,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AAsDD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,GACtD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CA4BrC;AAUD,wBAAgB,UAAU,CACxB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,CAIR;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,EAC9D,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,YAAY,CAsCd"}

package/dist/gutter/corner-mitre.js

@@ -1,4 +1,17 @@
 export const NO_MITRES = { left: 0, right: 0 };
+function prescribedLeanToMitres(gutter) {
+    const metadata = gutter.metadata;
+    if (!(metadata && typeof metadata === 'object' && !Array.isArray(metadata)))
+        return NO_MITRES;
+    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,
+    };
+}
 // Match the length-snap's 10 cm catch radius (`length-snap.ts`): any two
 // endpoints close enough for the corner snap to bind are close enough to
 // read as "they meant to meet". The corner snap pulls them to the exact
@@ -25,15 +38,41 @@ function gutterEndpoints(g) {
     const outX = Math.sin(r);
     const outZ = Math.cos(r);
     const half = g.length / 2;
+    const curvedEnd = (x, plus) => {
+        const arc = g.arc;
+        if (!arc || !Number.isFinite(arc.radius))
+            return null;
+        const signedRef = (Math.sign(arc.centerZ) || 1) * arc.radius;
+        const phi = (x - arc.centerX) / signedRef;
+        const radial = -arc.centerZ;
+        const bentX = arc.centerX - radial * Math.sin(phi);
+        const bentZ = arc.centerZ + radial * Math.cos(phi);
+        const tangentX = Math.cos(phi);
+        const tangentZ = Math.sin(phi);
+        const radialX = -Math.sin(phi);
+        const radialZ = Math.cos(phi);
+        const rotate = (xValue, zValue) => [
+            xValue * dirX + zValue * outX,
+            xValue * dirZ + zValue * outZ,
+        ];
+        const [worldX, worldZ] = rotate(bentX, bentZ);
+        const [tangentWorldX, tangentWorldZ] = rotate(tangentX, tangentZ);
+        const [outWorldX, outWorldZ] = rotate(radialX, radialZ);
+        return {
+            pos: [px + worldX, py, pz + worldZ],
+            awayDir: plus ? [-tangentWorldX, -tangentWorldZ] : [tangentWorldX, tangentWorldZ],
+            outDir: [outWorldX, outWorldZ],
+        };
+    };
     return {
-        plus: {
+        plus: curvedEnd(half, true) ?? {
             pos: [px + dirX * half, py, pz + dirZ * half],
             // From the +X endpoint, the rest of the gutter extends back
             // toward the −X end — so "away from this end" is −dir.
             awayDir: [-dirX, -dirZ],
             outDir: [outX, outZ],
         },
-        minus: {
+        minus: curvedEnd(-half, false) ?? {
             pos: [px - dirX * half, py, pz - dirZ * half],
             awayDir: [dirX, dirZ],
             outDir: [outX, outZ],
@@ -143,11 +182,12 @@ function axisIntersectionXZ(aPos, aDir, bPos, bDir) {
  * result is deterministic.
  */
 export function computeGutterMitres(subject, subjectSegment, siblings) {
+    const prescribed = prescribedLeanToMitres(subject);
     if (siblings.length === 0)
-        return NO_MITRES;
+        return prescribed;
     const subj = gutterEndpointsInFrame(subject, subjectSegment);
-    let leftMitre = 0;
-    let rightMitre = 0;
+    let leftMitre = prescribed.left;
+    let rightMitre = prescribed.right;
     for (const sib of siblings) {
         if (sib.gutter.id === subject.id)
             continue;
@@ -163,10 +203,10 @@ export function computeGutterMitres(subject, subjectSegment, siblings) {
         if (!otherPlusAtCorner && !otherMinusAtCorner)
             continue;
         const otherEnd = otherPlusAtCorner ? other.plus : other.minus;
-        if (leftMitre === 0 && planDistSq(subj.minus.pos, corner) <= CORNER_EPSILON_SQ) {
+        if (planDistSq(subj.minus.pos, corner) <= CORNER_EPSILON_SQ) {
             leftMitre = mitreBetween(subj.minus, otherEnd);
         }
-        if (rightMitre === 0 && planDistSq(subj.plus.pos, corner) <= CORNER_EPSILON_SQ) {
+        if (planDistSq(subj.plus.pos, corner) <= CORNER_EPSILON_SQ) {
             rightMitre = mitreBetween(subj.plus, otherEnd);
         }
         if (leftMitre !== 0 && rightMitre !== 0)

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA8GrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA2D9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA8D9D,CAAA"}

package/dist/gutter/definition.js

@@ -1,6 +1,7 @@
 import { GutterNode as GutterNodeSchema, } from '@pascal-app/core';
 import { buildGutterFloorplan } from './floorplan';
 import { snapLengthToCorner } from './length-snap';
+import { gutterPaint } from './paint';
 import { gutterParametrics } from './parametrics';
 import { GutterNode } from './schema';
 // Edge-to-arrow-center offset, matching the box-vent / ridge-vent
@@ -33,9 +34,9 @@ function getRimZ(n) {
 //
 // Corner snap: when the dragged endpoint nears the geometric corner it
 // would form with another gutter (the crossing of their length axes),
-// `snapLengthToCorner` overrides the raw newLength so the endpoint lands
-// EXACTLY on that corner — the corner-mitre detector then fires reliably
-// without pixel-perfect dragging. Only this gutter's length changes.
+// `snapLengthToCorner` is the handle's magnetic snap, so Lines mode lands the
+// endpoint exactly on that corner, Grid mode uses the chosen step, and Off
+// leaves the cursor raw. Only this gutter's length changes.
 function gutterLengthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -43,21 +44,26 @@ function gutterLengthHandle(side) {
         axis: 'x',
         anchor: side === 'right' ? 'min' : 'max',
         min: MIN_LENGTH,
+        gridSnap: true,
         currentValue: (n) => n.length,
-        apply: (initial, newLength, sceneApi) => {
+        magneticSnap: (initial, newLength, sceneApi) => {
             const rotY = initial.rotation ?? 0;
             const armX = Math.cos(rotY);
             const armZ = -Math.sin(rotY);
             const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
             const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
-            const snap = snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi);
-            // Only the dragged gutter's own length is snapped — `snapLengthToCorner`
-            // never moves the corner-mate, so dragging one gutter can't reset
-            // another the user placed deliberately.
-            const newCenterX = anchorX + sign * (snap.length / 2) * armX;
-            const newCenterZ = anchorZ + sign * (snap.length / 2) * armZ;
+            return snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi).length;
+        },
+        apply: (initial, newLength) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
+            const newCenterX = anchorX + sign * (newLength / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newLength / 2) * armZ;
             return {
-                length: snap.length,
+                length: newLength,
                 position: [newCenterX, initial.position[1], newCenterZ],
             };
         },
@@ -81,6 +87,7 @@ function gutterSizeHandle() {
         // downward grows the value 1:1.
         anchor: 'max',
         min: MIN_SIZE,
+        gridSnap: true,
         currentValue: (n) => n.size,
         apply: (_n, newValue) => ({ size: Math.max(MIN_SIZE, newValue) }),
         placement: {
@@ -112,10 +119,11 @@ const gutterHandles = [
  */
 export const gutterDefinition = {
     kind: 'gutter',
-    schemaVersion: 1,
+    schemaVersion: 4,
     schema: GutterNode,
     category: 'structure',
     surfaceRole: 'roof',
+    snapProfile: 'item',
     defaults: () => {
         const stub = GutterNodeSchema.parse({
             id: 'gutter_default',
@@ -125,9 +133,11 @@ export const gutterDefinition = {
         return rest;
     },
     capabilities: {
+        slots: () => [{ slotId: 'gutter', label: 'Gutter', default: 'library:preset-softwhite' }],
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
+        paint: gutterPaint,
         // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
         // eave fascia — no `buildCut`, just the dirty cascade so the
         // parent roof's merged shell rebuilds when the gutter moves /
@@ -154,7 +164,7 @@ export const gutterDefinition = {
     presentation: {
         label: 'Gutter',
         description: 'Rain-water channel running along the eave of a roof segment.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/gutter.webp' },
         paletteSection: 'structure',
         paletteOrder: 122,
     },

package/dist/gutter/eave-align.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eave-align.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-align.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oFAAoF;AACpF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AA2BD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,eAAe,EAC/B,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,MAAM,CA+BR"}
+{"version":3,"file":"eave-align.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-align.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oFAAoF;AACpF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AAkCD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,eAAe,EAC/B,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,MAAM,CAiCR"}

package/dist/gutter/eave-align.js

@@ -1,5 +1,12 @@
 import { CORNER_EPSILON_SQ, gutterEndpointsInFrame, planDistSq } from './corner-mitre';
 import { computeEaveY } from './eave-snap';
+function prescribedLeanToEaveY(gutter) {
+    const metadata = gutter.metadata;
+    if (!(metadata && typeof metadata === 'object' && !Array.isArray(metadata)))
+        return null;
+    const value = metadata.leanToGutterEaveY;
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
 function guttersMeet(a, aSeg, b, bSeg) {
     const ea = gutterEndpointsInFrame(a, aSeg);
     const eb = gutterEndpointsInFrame(b, bSeg);
@@ -17,6 +24,9 @@ function worldEaveY(segment) {
     return (segment.position?.[1] ?? 0) + computeEaveY(segment);
 }
 export function computeSharedEaveY(subject, subjectSegment, siblings) {
+    const prescribed = prescribedLeanToEaveY(subject);
+    if (prescribed !== null)
+        return prescribed;
     const subjectBaseY = subjectSegment.position?.[1] ?? 0;
     if (siblings.length === 0)
         return computeEaveY(subjectSegment);

package/dist/gutter/eave-snap.d.ts

@@ -1,4 +1,4 @@
-import type { RoofSegmentNode } from '@pascal-app/core';
+import { type RoofSegmentNode } from '@pascal-app/core';
 /**
  * Shared eave-snap math for the gutter's placement + move tools.
  *

package/dist/gutter/eave-snap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eave-snap.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,kBAAkB,CAAA;AAEjE;;;;;;;;;;;;;;GAcG;AAOH,eAAO,MAAM,gBAAgB,OAAO,CAAA;AACpC,eAAO,MAAM,YAAY,OAAO,CAAA;AAEhC,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEhD,MAAM,MAAM,QAAQ,GAAG;IACrB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAYR;AA2CD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,QAAQ,CAqDV"}
+{"version":3,"file":"eave-snap.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-snap.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;GAcG;AAOH,eAAO,MAAM,gBAAgB,OAA0B,CAAA;AACvD,eAAO,MAAM,YAAY,OAAsB,CAAA;AAE/C,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEhD,MAAM,MAAM,QAAQ,GAAG;IACrB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAER;AAwCD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,QAAQ,CAqDV"}

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"}