@pascal-app/nodes 0.1.1

package/dist/dormer/use-dormer-placement.js

@@ -0,0 +1,166 @@
+import { emitter, sceneRegistry, } from '@pascal-app/core';
+import { consumePlacementDragRelease, triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { createRelativeRoofDrag } from '../shared/relative-roof-drag';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { DORMER_PLACEMENT_ROTATION_STEP, DORMER_PLACEMENT_SNAP_M } from './geometry';
+const tmpMatrix = new THREE.Matrix4();
+const tmpInv = new THREE.Matrix4();
+const tmpPos = new THREE.Vector3();
+const tmpQuat = new THREE.Quaternion();
+const tmpScale = new THREE.Vector3();
+/**
+ * Shared placement-tool plumbing for fresh-place and duplicate/move
+ * tools. Owns:
+ *   - cursor → roof-segment hit resolution (delegated to the host
+ *     RoofNode pointer events)
+ *   - building-local segment transform extraction (for ghost mounting)
+ *   - 5cm grid snap + SFX cue
+ *   - keyboard rotate (R / Shift+R, ±15°)
+ *
+ * Does NOT own:
+ *   - the ghost mesh (caller renders `<DormerPreview>`)
+ *   - any node-lifecycle state (caller passes an `onCommit` that
+ *     decides between createNode / updateNode / etc.)
+ *
+ * Returns the segment transform + cursor hit so the caller can mount
+ * the ghost, plus the live ghost rotation (driven by R / Shift+R).
+ */
+export function useDormerPlacement(opts) {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const [segmentXform, setSegmentXform] = useState(null);
+    const [hitSegment, setHitSegment] = useState(null);
+    const [hitLocal, setHitLocal] = useState(null);
+    const [ghostRotation, setGhostRotation] = useState(opts.initialRotation ?? 0);
+    const lastSnapRef = useRef(null);
+    // Mirror of `ghostRotation` so the click handler (registered once
+    // inside useEffect) can read the latest value at commit time.
+    const ghostRotationRef = useRef(opts.initialRotation ?? 0);
+    const relativeStartRef = useRef(opts.relativeStart);
+    // Latest commit callback, captured via ref so the useEffect doesn't
+    // need it in its dep list (we don't want to re-register listeners
+    // every time the parent rerenders).
+    const onCommitRef = useRef(opts.onCommit);
+    onCommitRef.current = opts.onCommit;
+    const clearPreview = () => {
+        setSegmentXform(null);
+        setHitSegment(null);
+        setHitLocal(null);
+    };
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const computeSegmentXform = (segmentId) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            const segObj = sceneRegistry.nodes.get(segmentId);
+            if (!(buildingObj && segObj))
+                return null;
+            buildingObj.updateWorldMatrix(true, false);
+            segObj.updateWorldMatrix(true, false);
+            tmpInv.copy(buildingObj.matrixWorld).invert();
+            tmpMatrix.multiplyMatrices(tmpInv, segObj.matrixWorld);
+            tmpMatrix.decompose(tmpPos, tmpQuat, tmpScale);
+            return {
+                position: [tmpPos.x, tmpPos.y, tmpPos.z],
+                quaternion: [tmpQuat.x, tmpQuat.y, tmpQuat.z, tmpQuat.w],
+            };
+        };
+        const roofDrag = relativeStartRef.current
+            ? createRelativeRoofDrag(relativeStartRef.current)
+            : null;
+        let committed = false;
+        let lastRelativeHit = null;
+        const resolvePlacementHit = (event) => {
+            if (roofDrag)
+                return roofDrag.resolve(event);
+            return resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wz = event.position[2];
+            const sx = Math.round(wx / DORMER_PLACEMENT_SNAP_M) * DORMER_PLACEMENT_SNAP_M;
+            const sz = Math.round(wz / DORMER_PLACEMENT_SNAP_M) * DORMER_PLACEMENT_SNAP_M;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolvePlacementHit(event);
+            if (!hit)
+                return;
+            if (roofDrag)
+                lastRelativeHit = hit;
+            const xform = computeSegmentXform(hit.segment.id);
+            if (!xform)
+                return;
+            setSegmentXform(xform);
+            setHitSegment(hit.segment);
+            // Lift the ghost to the actual roof-surface Y at the cursor so
+            // it tracks the mouse along the slope. The CSG inside
+            // `generateDormerGeometry` carves the dormer against the host
+            // roof regardless of `position[1]` — anchoring at the cursor
+            // height is purely a visual alignment.
+            setHitLocal([hit.localX, hit.localY, hit.localZ]);
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            if (committed)
+                return;
+            const hit = roofDrag
+                ? (lastRelativeHit ?? resolvePlacementHit(event))
+                : resolvePlacementHit(event);
+            if (!hit)
+                return;
+            committed = true;
+            onCommitRef.current(hit, ghostRotationRef.current);
+            triggerSFX('sfx:item-place');
+            event.stopPropagation();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (committed)
+                return;
+            if (!consumePlacementDragRelease(event))
+                return;
+            const hit = roofDrag ? lastRelativeHit : null;
+            if (!hit)
+                return;
+            committed = true;
+            onCommitRef.current(hit, ghostRotationRef.current);
+            triggerSFX('sfx:item-place');
+        };
+        const onKeyDown = (e) => {
+            if (e.key !== 'r' && e.key !== 'R')
+                return;
+            const target = e.target;
+            if (target &&
+                (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable))
+                return;
+            const dir = e.shiftKey ? -1 : 1;
+            ghostRotationRef.current += dir * DORMER_PLACEMENT_ROTATION_STEP;
+            setGhostRotation(ghostRotationRef.current);
+            e.preventDefault();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        window.addEventListener('keydown', onKeyDown);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+        };
+    }, [activeBuildingId]);
+    return {
+        activeBuildingId: activeBuildingId ?? undefined,
+        clearPreview,
+        segmentXform,
+        hitSegment,
+        hitLocal,
+        ghostRotation,
+    };
+}

package/dist/dormer/window-assembly.d.ts

@@ -0,0 +1,22 @@
+import type { DormerNode, RoofSegmentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Renders the window opening assembly (frame bars, glass panes, sill)
+ * on each exposed gable face of a dormer. Owns its geometry lifecycle
+ * (build via `buildDormerWindowGeometries`, dispose on unmount) so the
+ * renderer doesn't have to.
+ *
+ * Mounted inside the dormer's rotation group, in dormer-mesh-local
+ * coordinates. The CSG cut on the wall is performed separately inside
+ * the viewer's `generateDormerGeometry`; the geometry built here is
+ * sized to match that cut.
+ */
+declare const DormerWindowAssembly: ({ node, segment, frameMaterial, glassMaterial, dormerToSegment, }: {
+    node: DormerNode;
+    segment: RoofSegmentNode;
+    frameMaterial: THREE.Material;
+    glassMaterial: THREE.Material;
+    dormerToSegment: THREE.Matrix4;
+}) => import("react").JSX.Element;
+export default DormerWindowAssembly;
+//# sourceMappingURL=window-assembly.d.ts.map

package/dist/dormer/window-assembly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-assembly.d.ts","sourceRoot":"","sources":["../../src/dormer/window-assembly.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B;;;;;;;;;;GAUG;AACH,QAAA,MAAM,oBAAoB,GAAI,mEAM3B;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,CAAA;IACxB,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAA;IAC7B,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAA;IAI7B,eAAe,EAAE,KAAK,CAAC,OAAO,CAAA;CAC/B,gCA4KA,CAAA;AAED,eAAe,oBAAoB,CAAA"}

package/dist/dormer/window-assembly.js

@@ -0,0 +1,111 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { TrimClippedMesh } from '../shared/use-segment-trim-clip';
+import { getDormerExposedFaces, getDormerSkirtWindowDims } from './csg-geometry';
+import { buildDormerWindowGeometries } from './window-frame';
+/**
+ * Renders the window opening assembly (frame bars, glass panes, sill)
+ * on each exposed gable face of a dormer. Owns its geometry lifecycle
+ * (build via `buildDormerWindowGeometries`, dispose on unmount) so the
+ * renderer doesn't have to.
+ *
+ * Mounted inside the dormer's rotation group, in dormer-mesh-local
+ * coordinates. The CSG cut on the wall is performed separately inside
+ * the viewer's `generateDormerGeometry`; the geometry built here is
+ * sized to match that cut.
+ */
+const DormerWindowAssembly = ({ node, segment, frameMaterial, glassMaterial, dormerToSegment, }) => {
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const skirtWin = useMemo(() => getDormerSkirtWindowDims(node), [
+        node.width,
+        node.windowWidth,
+        node.windowHeight,
+        node.windowOffsetX,
+        node.windowOffsetY,
+        node.wallSkirtHeight,
+    ]);
+    const winW = skirtWin.width;
+    const winH = skirtWin.height;
+    const winShape = node.windowShape;
+    const resolvedRadii = [...node.windowCornerRadii];
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const winGeo = useMemo(() => buildDormerWindowGeometries(winW, winH, node.windowFrameThickness, node.windowFrameDepth, node.windowColumns, node.windowRows, node.windowDividerThickness, winShape, node.windowArchHeight, resolvedRadii), [
+        winW,
+        winH,
+        node.windowFrameThickness,
+        node.windowFrameDepth,
+        node.windowColumns,
+        node.windowRows,
+        node.windowDividerThickness,
+        winShape,
+        node.windowArchHeight,
+        ...resolvedRadii,
+    ]);
+    useEffect(() => {
+        return () => {
+            const disposed = new Set();
+            for (const bar of winGeo.frameBars) {
+                if (!disposed.has(bar.geo)) {
+                    bar.geo.dispose();
+                    disposed.add(bar.geo);
+                }
+            }
+            for (const pane of winGeo.glassPanes) {
+                if (!disposed.has(pane.geo)) {
+                    pane.geo.dispose();
+                    disposed.add(pane.geo);
+                }
+            }
+        };
+    }, [winGeo]);
+    const sillEnabled = node.windowSill !== false;
+    const sillT = Math.max(0.001, node.windowSillThickness);
+    const sillD = Math.max(0.001, node.windowSillDepth);
+    const sillW = winW + 0.06; // 3 cm overhang each side
+    const sillGeo = useMemo(() => (sillEnabled ? new THREE.BoxGeometry(sillW, sillT, sillD) : null), [sillEnabled, sillW, sillT, sillD]);
+    useEffect(() => () => sillGeo?.dispose(), [sillGeo]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const exposed = useMemo(() => getDormerExposedFaces(node, segment), [
+        segment,
+        node.roofType,
+        node.width,
+        node.depth,
+        node.height,
+        node.roofHeight,
+        node.position[0],
+        node.position[1],
+        node.position[2],
+        // Rotation flips which dormer-local face projects to which Z in
+        // segment frame, so dragging the dormer across the ridge with a
+        // non-zero yaw needs to recompute exposure to know which gable
+        // is now poking above the slope.
+        node.rotation,
+        // The window's vertical placement feeds `getDormerExposedFaces`
+        // (gates on the window CENTER clearing the host slope) — dragging
+        // the window down via inspector or the offset handle must
+        // re-evaluate which gable still exposes the opening.
+        node.windowOffsetY,
+        node.wallSkirtHeight,
+    ]);
+    const gableHalfZ = node.depth / 2;
+    const winX = skirtWin.offsetX;
+    const winY = skirtWin.centerY;
+    // The glazing role material is FrontSide (DoubleSide on a NodeMaterial
+    // poisons the MRT scene pass — see `createSurfaceRoleMaterial`). The
+    // back gable face therefore renders inside a Y-rotated group so its
+    // FrontSide points outward (-Z in segment frame). With the rotation,
+    // the sill always extrudes along the group's local +Z, so its position
+    // no longer needs to flip per-face.
+    const renderFace = (zPos, yRot, keyPrefix) => {
+        // Compose this face group's transform onto the dormer→segment matrix, so
+        // each window part can be clipped by the trim in segment-local space.
+        const faceToSegment = new THREE.Matrix4()
+            .copy(dormerToSegment)
+            .multiply(new THREE.Matrix4().compose(new THREE.Vector3(winX, winY, zPos), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), yRot), new THREE.Vector3(1, 1, 1)));
+        return (_jsxs("group", { name: `dormer-window-${keyPrefix}`, position: [winX, winY, zPos], "rotation-y": yRot, children: [winGeo.glassPanes.map((pane, i) => (_jsx(TrimClippedMesh, { geometry: pane.geo, material: glassMaterial, name: `dormer-glass-${keyPrefix}-${i}`, parentToSegment: faceToSegment, position: pane.pos, segment: segment }, `${keyPrefix}-glass-${i}`))), winGeo.frameBars.map((bar, i) => (_jsx(TrimClippedMesh, { castShadow: true, geometry: bar.geo, material: frameMaterial, name: `dormer-frame-${keyPrefix}-${i}`, parentToSegment: faceToSegment, position: bar.pos, segment: segment }, `${keyPrefix}-bar-${i}`))), sillGeo && (_jsx(TrimClippedMesh, { castShadow: true, geometry: sillGeo, material: frameMaterial, name: `dormer-sill-${keyPrefix}`, parentToSegment: faceToSegment, position: [0, -winH / 2 - sillT / 2, sillD / 2], receiveShadow: true, segment: segment }))] }));
+    };
+    return (_jsxs(_Fragment, { children: [exposed.front && renderFace(gableHalfZ, 0, 'front'), exposed.back && renderFace(-gableHalfZ, Math.PI, 'back')] }));
+};
+export default DormerWindowAssembly;

package/dist/dormer/window-frame.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+/**
+ * Frame + glass geometry for the window opening on a dormer's gable
+ * face. The extruded frame profile uses the same shape builders as the
+ * CSG cut in the viewer (`generateDormerGeometry`), so the frame sits
+ * flush in the wall — keeping the cut and the frame visually in sync.
+ *
+ * Only the frame bars and glass panes are produced here; the wall
+ * opening itself is CSG-subtracted from the dormer body inside the
+ * viewer's `generateDormerGeometry`.
+ */
+export type DormerWindowShape = 'rectangle' | 'rounded' | 'arch';
+export type WindowGeometries = {
+    frameBars: {
+        geo: THREE.BufferGeometry;
+        pos: [number, number, number];
+    }[];
+    glassPanes: {
+        geo: THREE.BufferGeometry;
+        pos: [number, number, number];
+    }[];
+};
+export declare function buildDormerWindowGeometries(winW: number, winH: number, ft: number, fd: number, cols: number, rows: number, dt: number, shape?: DormerWindowShape, archHeight?: number, cornerRadii?: [number, number, number, number]): WindowGeometries;
+//# sourceMappingURL=window-frame.d.ts.map

package/dist/dormer/window-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-frame.d.ts","sourceRoot":"","sources":["../../src/dormer/window-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAA;IACzE,UAAU,EAAE;QAAE,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAA;CAC3E,CAAA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,iBAA+B,EACtC,UAAU,SAAO,EACjB,WAAW,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAA4B,GACvE,gBAAgB,CAgIlB"}

package/dist/dormer/window-frame.js

@@ -0,0 +1,100 @@
+import * as THREE from 'three';
+import { createDormerArchShape, createDormerRoundedShape } from './csg-geometry';
+export function buildDormerWindowGeometries(winW, winH, ft, fd, cols, rows, dt, shape = 'rectangle', archHeight = 0.35, cornerRadii = [0.15, 0.15, 0.15, 0.15]) {
+    const safeFt = Math.max(0.001, ft);
+    const safeDt = Math.max(0.001, dt);
+    const innerW = Math.max(0.01, winW - 2 * safeFt);
+    const innerH = Math.max(0.01, winH - 2 * safeFt);
+    const hw = winW / 2;
+    const hh = winH / 2;
+    const frameBars = [];
+    const glassPanes = [];
+    if (shape === 'arch' || shape === 'rounded') {
+        const insetRadii = cornerRadii.map((r) => Math.max(r - safeFt, 0));
+        const outerShape = shape === 'arch'
+            ? createDormerArchShape(winW, winH, archHeight)
+            : createDormerRoundedShape(winW, winH, cornerRadii);
+        const innerHole = shape === 'arch'
+            ? createDormerArchShape(winW - 2 * safeFt, winH - 2 * safeFt, Math.max(archHeight - safeFt, 0.01))
+            : createDormerRoundedShape(winW - 2 * safeFt, winH - 2 * safeFt, insetRadii);
+        outerShape.holes.push(innerHole);
+        const frameGeo = new THREE.ExtrudeGeometry(outerShape, {
+            depth: fd,
+            bevelEnabled: false,
+            curveSegments: 24,
+        });
+        frameGeo.translate(0, 0, -fd / 2);
+        frameBars.push({ geo: frameGeo, pos: [0, 0, 0] });
+        const colDividerCount = cols - 1;
+        const totalColDividerW = colDividerCount * safeDt;
+        const paneAreaW = Math.max(0.01, innerW - totalColDividerW);
+        const paneW = paneAreaW / cols;
+        for (let c = 1; c < cols; c++) {
+            const x = -innerW / 2 + c * paneW + (c - 0.5) * safeDt;
+            frameBars.push({ geo: new THREE.BoxGeometry(safeDt, innerH, fd), pos: [x, 0, 0] });
+        }
+        const rowDividerCount = rows - 1;
+        const totalRowDividerH = rowDividerCount * safeDt;
+        const paneAreaH = Math.max(0.01, innerH - totalRowDividerH);
+        const paneH = paneAreaH / rows;
+        for (let r = 1; r < rows; r++) {
+            const y = -innerH / 2 + r * paneH + (r - 0.5) * safeDt;
+            frameBars.push({ geo: new THREE.BoxGeometry(innerW, safeDt, fd), pos: [0, y, 0] });
+        }
+        const glassShape = shape === 'arch'
+            ? createDormerArchShape(winW - 2 * safeFt, winH - 2 * safeFt, Math.max(archHeight - safeFt, 0.01))
+            : createDormerRoundedShape(winW - 2 * safeFt, winH - 2 * safeFt, insetRadii);
+        const glassGeo = new THREE.ExtrudeGeometry(glassShape, {
+            depth: 0.008,
+            bevelEnabled: false,
+            curveSegments: 24,
+        });
+        glassGeo.translate(0, 0, -0.004);
+        glassPanes.push({ geo: glassGeo, pos: [0, 0, 0] });
+    }
+    else {
+        frameBars.push({
+            geo: new THREE.BoxGeometry(winW, safeFt, fd),
+            pos: [0, hh - safeFt / 2, 0],
+        });
+        frameBars.push({
+            geo: new THREE.BoxGeometry(winW, safeFt, fd),
+            pos: [0, -hh + safeFt / 2, 0],
+        });
+        frameBars.push({
+            geo: new THREE.BoxGeometry(safeFt, innerH, fd),
+            pos: [-hw + safeFt / 2, 0, 0],
+        });
+        frameBars.push({
+            geo: new THREE.BoxGeometry(safeFt, innerH, fd),
+            pos: [hw - safeFt / 2, 0, 0],
+        });
+        const colDividerCount = cols - 1;
+        const totalColDividerW = colDividerCount * safeDt;
+        const paneAreaW = Math.max(0.01, innerW - totalColDividerW);
+        const paneW = paneAreaW / cols;
+        for (let c = 1; c < cols; c++) {
+            const x = -innerW / 2 + c * paneW + (c - 0.5) * safeDt;
+            frameBars.push({ geo: new THREE.BoxGeometry(safeDt, innerH, fd), pos: [x, 0, 0] });
+        }
+        const rowDividerCount = rows - 1;
+        const totalRowDividerH = rowDividerCount * safeDt;
+        const paneAreaH = Math.max(0.01, innerH - totalRowDividerH);
+        const paneH = paneAreaH / rows;
+        for (let r = 1; r < rows; r++) {
+            const y = -innerH / 2 + r * paneH + (r - 0.5) * safeDt;
+            frameBars.push({ geo: new THREE.BoxGeometry(innerW, safeDt, fd), pos: [0, y, 0] });
+        }
+        const glassW = Math.max(0.01, paneAreaW / cols);
+        const glassH = Math.max(0.01, paneAreaH / rows);
+        const glassGeo = new THREE.BoxGeometry(glassW, glassH, 0.008);
+        for (let c = 0; c < cols; c++) {
+            const cx = -innerW / 2 + paneAreaW / cols / 2 + c * (paneAreaW / cols + safeDt);
+            for (let r = 0; r < rows; r++) {
+                const cy = -innerH / 2 + paneAreaH / rows / 2 + r * (paneAreaH / rows + safeDt);
+                glassPanes.push({ geo: glassGeo, pos: [cx, cy, 0] });
+            }
+        }
+    }
+    return { frameBars, glassPanes };
+}

package/dist/downspout/definition.d.ts

@@ -0,0 +1,17 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { DownspoutNode } from './schema';
+/**
+ * Downspout — vertical drop pipe taking water from a gutter outlet to
+ * the ground. Scene-graph parent is the same roof-segment the host
+ * gutter sits on (so it renders under `roof-elements` like every
+ * other accessory); the logical link to the gutter is via the
+ * `gutterId` field, which the renderer uses to look up the outlet
+ * position.
+ *
+ * No `handles` yet — the downspout's geometry is anchored to the
+ * gutter's outlet. Length (tracker cube at the routed mouth) and
+ * diameter (chevron on the wall run) are draggable arrows; the wall
+ * standoff lives in the inspector.
+ */
+export declare const downspoutDefinition: NodeDefinition<typeof DownspoutNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA4HxC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CAqDpE,CAAA"}

package/dist/downspout/definition.js

@@ -0,0 +1,173 @@
+import { DownspoutNode as DownspoutNodeSchema, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { downspoutParametrics } from './parametrics';
+import { computeDownspoutPath, downspoutPipeDims, effectiveWallJog, resolveDownspoutRouting, } from './routing';
+import { DownspoutNode } from './schema';
+// Mirrors the parametric `min`s so handle drags can't shrink the pipe
+// past what the inspector would accept.
+const MIN_LENGTH = 0.1;
+// The length cube + dashed leader ride the straight WALL RUN, offset
+// outward (+Z, over the eave) past the pipe surface so they float clear
+// of the pipe instead of touching it.
+const LENGTH_HANDLE_PAD = 0.12;
+// Lift the length cube a little up the run from the very bottom so it
+// reads as a height grip rather than sitting at the pipe's end. Clamped
+// to the run top so it never climbs above the straight section.
+const CUBE_LIFT = 0.18;
+// Side-move arrows: how far ±X (along the eave) they sit from the pipe,
+// and how far below the gutter floor — near the top so they read as
+// "grab and slide along the eave".
+const SIDE_MOVE_OFFSET = 0.22;
+const SIDE_MOVE_Y = -0.12;
+/**
+ * Length tracker — a dashed vertical leader from the outlet (Y = 0,
+ * the gutter floor) down to a small cube near the bottom of the
+ * straight wall run, `anchor: 'max'` + `axis: 'y'` so dragging the
+ * cube down extends the pipe 1:1.
+ *
+ * Both the cube and the leader sit on the wall-run line but offset
+ * outward (away from the pipe) by `radius + LENGTH_HANDLE_PAD`, so the
+ * whole dimension floats clear of the pipe — it reads as "change the
+ * height" rather than a box jammed onto the kicked-out mouth. The cube
+ * rides the run BOTTOM (above the kickout), not the mouth, so the
+ * dimension stays on the straight part.
+ */
+function downspoutLengthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'max',
+        shape: 'tracker',
+        min: MIN_LENGTH,
+        currentValue: (n) => n.length,
+        apply: (_n, newValue) => ({ length: Math.max(MIN_LENGTH, newValue) }),
+        placement: {
+            position: (n, scene) => {
+                const routing = resolveDownspoutRouting(n, scene);
+                const path = computeDownspoutPath(n.length, effectiveWallJog(n, routing), (n.terminal ?? 'splash') !== 'straight');
+                const halfZ = downspoutPipeDims(n, routing).halfZ;
+                const y = Math.min(path.wallRunTopY, path.wallRunBottomY + CUBE_LIFT);
+                return [0, y, path.wallRunZ + halfZ + LENGTH_HANDLE_PAD];
+            },
+        },
+        // Leader starts at Y = 0 (outlet / gutter floor) and runs DOWN past
+        // the cube — same tracker the wall / chimney height fields use.
+        trackerBaseY: () => 0,
+    };
+}
+// Usable half-span — keep the outlet a hair inside each end so the
+// collar never lands on a cap (the geometry clamps too; this bounds the
+// drag). Reads the host gutter's length.
+function moveBound(n, gutter) {
+    return Math.max(0.05, Math.max(0.05, gutter?.length ?? 2) / 2 - 0.1);
+}
+// Effective outlet offset for `currentValue` — reads the gutter's live
+// override first (so the dragged value tracks) then the store.
+function readOutletOffset(n) {
+    if (!n.gutterId)
+        return 0;
+    const id = n.gutterId;
+    const override = useLiveNodeOverrides.getState().get(id);
+    const gutter = useScene.getState().nodes[id];
+    const outlets = override?.outlets ?? gutter?.outlets ?? [];
+    return outlets.find((o) => o.id === n.outletId)?.offset ?? 0;
+}
+/**
+ * Side-move arrow — one of a ±X pair that slides the downspout along the
+ * eave. The position lives on the host gutter's outlet
+ * (`gutter.outlets[].offset`), not on the downspout, so `overrideTarget`
+ * redirects the drag's live override + commit to the gutter and `apply`
+ * returns the gutter's patch. The arrows sit near the top of the pipe
+ * and ride its group, which moves with the outlet — so they track the
+ * cursor 1:1 (`anchor: 'min'` → factor +1).
+ */
+function downspoutMoveHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'min',
+        cursor: 'ew-resize',
+        overrideTarget: (n) => (n.gutterId ? n.gutterId : undefined),
+        currentValue: (n) => readOutletOffset(n),
+        apply: (n, newOffset, scene) => {
+            const gutter = n.gutterId ? scene.get(n.gutterId) : undefined;
+            if (!gutter)
+                return {};
+            const outlets = (gutter.outlets ?? []).map((o) => o.id === n.outletId ? { ...o, offset: newOffset } : o);
+            // Patch targets the GUTTER (overrideTarget), not the downspout.
+            return { outlets };
+        },
+        min: (n, scene) => -moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
+        max: (n, scene) => moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
+        placement: {
+            // Static ±X beside the top of the pipe; the group it rides moves
+            // with the outlet, so the arrow stays under the cursor as it slides.
+            position: () => [sign * SIDE_MOVE_OFFSET, SIDE_MOVE_Y, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+const downspoutHandles = [
+    downspoutLengthHandle(),
+    downspoutMoveHandle('left'),
+    downspoutMoveHandle('right'),
+];
+/**
+ * Downspout — vertical drop pipe taking water from a gutter outlet to
+ * the ground. Scene-graph parent is the same roof-segment the host
+ * gutter sits on (so it renders under `roof-elements` like every
+ * other accessory); the logical link to the gutter is via the
+ * `gutterId` field, which the renderer uses to look up the outlet
+ * position.
+ *
+ * No `handles` yet — the downspout's geometry is anchored to the
+ * gutter's outlet. Length (tracker cube at the routed mouth) and
+ * diameter (chevron on the wall run) are draggable arrows; the wall
+ * standoff lives in the inspector.
+ */
+export const downspoutDefinition = {
+    kind: 'downspout',
+    schemaVersion: 1,
+    schema: DownspoutNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = DownspoutNodeSchema.parse({
+            id: 'downspout_default',
+            type: 'downspout',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Logically a roof accessory — registers under the segment, has
+        // no buildCut, just the standard dirty cascade.
+        roofAccessory: {},
+    },
+    parametrics: downspoutParametrics,
+    handles: downspoutHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Hover gutter', label: 'Highlight outlet' },
+        { key: 'Left click', label: 'Drop downspout from outlet' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Downspout',
+        description: 'Vertical drop pipe from a gutter outlet to the ground.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 123,
+    },
+    mcp: {
+        description: 'A downspout — drop pipe from a gutter outlet that elbows back to the wall, runs down the wall face, and kicks out at the bottom. length / diameter / standoff parametric.',
+    },
+};

package/dist/downspout/geometry.d.ts

@@ -0,0 +1,5 @@
+import type { DownspoutNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { type DownspoutRouting } from './routing';
+export declare function buildDownspoutGeometry(node: DownspoutNode, routing?: DownspoutRouting | null): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/downspout/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAGL,KAAK,gBAAgB,EAGtB,MAAM,WAAW,CAAA;AAwClB,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAChC,KAAK,CAAC,cAAc,CA+CtB"}