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

package/dist/dormer/placement-guides.js

@@ -52,6 +52,7 @@ const alignMaterial = new LineBasicNodeMaterial({
  */
 export function DormerPlacementGuides({ segment, center, width, depth, rotation, movingId, }) {
     const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
     const [cx, , cz] = center;
     const faceBounds = getRoofSurfaceFaceBoundsAt(segment, cx, cz);
     const halfW = Math.max(0, width) / 2;
@@ -139,13 +140,13 @@ export function DormerPlacementGuides({ segment, center, width, depth, rotation,
         }
     }
     guides.push(...siblingSpacing.guides);
-    return (_jsx(_Fragment, { children: guides.map((g) => (_jsx(Guide, { guide: g, unit: unit }, g.id))) }));
+    return (_jsx(_Fragment, { children: guides.map((g) => (_jsx(Guide, { guide: g, metricNotation: metricNotation, unit: unit }, g.id))) }));
 }
-function Guide({ guide, unit }) {
+function Guide({ guide, metricNotation, unit, }) {
     if (guide.kind === 'badge') {
-        return _jsx(GuideBadge, { at: guide.at, pill: `= ${formatMeasurement(guide.value, unit)}` });
+        return (_jsx(GuideBadge, { at: guide.at, pill: `= ${formatMeasurement(guide.value, unit, metricNotation)}` }));
     }
-    return (_jsx(GuideLine, { from: guide.from, kind: guide.kind, pill: guide.value === undefined ? undefined : formatMeasurement(guide.value, unit), to: guide.to }));
+    return (_jsx(GuideLine, { from: guide.from, kind: guide.kind, pill: guide.value === undefined ? undefined : formatMeasurement(guide.value, unit, metricNotation), to: guide.to }));
 }
 function GuideBadge({ at, pill }) {
     return (_jsx(Html, { center: true, position: at, style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [20, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-[3px] px-[5px] py-[2px] font-semibold font-sans text-[11px] text-white", style: { backgroundColor: BADGE_BG }, children: pill }) }));

package/dist/dormer/preview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/dormer/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmB1C,QAAA,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAYhF,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/dormer/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmB1C,QAAA,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAoBhF,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/dormer/preview.js

@@ -22,7 +22,15 @@ const invalidGhostMaterial = new THREE.MeshStandardMaterial({
 const DormerPreview = ({ node, invalid }) => {
     const material = invalid ? invalidGhostMaterial : ghostMaterial;
     // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
-    const geo = useMemo(() => buildDormerGhostGeometry(node), [node.width, node.depth, node.height, node.roofHeight, node.roofType, node.wallSkirtHeight]);
+    const geo = useMemo(() => buildDormerGhostGeometry(node), [
+        node.width,
+        node.depth,
+        node.height,
+        node.roofHeight,
+        node.roofType,
+        node.shedHighSide,
+        node.wallSkirtHeight,
+    ]);
     useEffect(() => () => geo.dispose(), [geo]);
     return _jsx("mesh", { geometry: geo, material: material, raycast: () => { } });
 };

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/dormer/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAEL,2BAA2B,EAE5B,MAAM,gBAAgB,CAAA;AAGvB,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCA+KhE,CAAA;AAID,OAAO,EAAE,2BAA2B,EAAE,CAAA;AAEtC,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/dormer/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAShB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAEL,2BAA2B,EAE5B,MAAM,gBAAgB,CAAA;AAEvB,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCAoLhE,CAAA;AAqBD,OAAO,EAAE,2BAA2B,EAAE,CAAA;AAEtC,eAAe,cAAc,CAAA"}

package/dist/dormer/renderer.js

@@ -1,12 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getEffectiveDormerSurfaceMaterial, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { getDormerWallFaceFrame, getEffectiveDormerSurfaceMaterial, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, NodeRenderer, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
+import { useShallow } from 'zustand/react/shallow';
 import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
 import { buildDormerFallbackGeometry, DORMER_GABLE_MATERIAL_INDEX, generateDormerGeometry, } from './csg-geometry';
-import DormerWindowAssembly from './window-assembly';
 const DormerRenderer = ({ node: storeNode }) => {
     const ref = useRef(null);
     useRegistry(storeNode.id, 'dormer', ref);
@@ -20,6 +20,17 @@ const DormerRenderer = ({ node: storeNode }) => {
     const liveOverrides = useLiveNodeOverrides((state) => state.get(storeNode.id));
     const isLiveDrag = !!liveOverrides && Object.keys(liveOverrides).length > 0;
     const node = useMemo(() => (liveOverrides ? { ...storeNode, ...liveOverrides } : storeNode), [storeNode, liveOverrides]);
+    const childNodes = useScene(useShallow((state) => (node.children ?? [])
+        .map((childId) => state.nodes[childId])
+        .filter((child) => child !== undefined)));
+    const hostedWindowNodes = useMemo(() => childNodes.filter((child) => child.type === 'window'), [childNodes]);
+    const hostedWindowIds = useMemo(() => hostedWindowNodes.map((window) => window.id), [hostedWindowNodes]);
+    const liveWindowOverrides = useLiveNodeOverrides(useShallow((state) => hostedWindowIds.map((windowId) => state.overrides.get(windowId))));
+    const hostedWindows = useMemo(() => hostedWindowNodes.map((window, index) => {
+        const override = liveWindowOverrides[index];
+        return override ? { ...window, ...override } : window;
+    }), [hostedWindowNodes, liveWindowOverrides]);
+    const hasLiveWindowPreview = liveWindowOverrides.some((override) => override !== undefined);
     const segment = useScene((state) => node.roofSegmentId
         ? state.nodes[node.roofSegmentId]
         : undefined);
@@ -65,28 +76,20 @@ const DormerRenderer = ({ node: storeNode }) => {
         node.wallMaterial,
         node.wallMaterialPreset,
     ]);
-    // The window frame bars / sill take the 'joinery' role when untextured;
-    // otherwise the deck-side material (slot 1) drives the frame look.
-    const frameSideMat = useMemo(() => {
-        if (!textures)
-            return createSurfaceRoleMaterial('joinery', colorPreset, undefined, sceneTheme);
-        return material[1];
-    }, [textures, colorPreset, sceneTheme, material]);
-    // Dormer window glass has no per-node material — it always takes the
-    // themed 'glazing' role (semi-transparent) in both texture modes.
-    const glassMat = useMemo(() => createSurfaceRoleMaterial('glazing', colorPreset, undefined, sceneTheme), [colorPreset, sceneTheme]);
     // 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(() => {
         if (!segment)
             return null;
-        if (isLiveDrag)
+        if (isLiveDrag || hasLiveWindowPreview)
             return buildDormerFallbackGeometry(node);
-        return generateDormerGeometry(node, segment);
+        return generateDormerGeometry(node, segment, hostedWindows);
     }, [
         isLiveDrag,
+        hasLiveWindowPreview,
         segment,
         node.id,
         node.roofType,
+        node.shedHighSide,
         node.width,
         node.depth,
         node.height,
@@ -96,16 +99,7 @@ const DormerRenderer = ({ node: storeNode }) => {
         node.position[1],
         node.position[2],
         node.rotation,
-        node.windowWidth,
-        node.windowHeight,
-        node.windowOffsetX,
-        node.windowOffsetY,
-        node.windowShape,
-        node.windowArchHeight,
-        node.windowCornerRadii[0],
-        node.windowCornerRadii[1],
-        node.windowCornerRadii[2],
-        node.windowCornerRadii[3],
+        hostedWindows,
     ]);
     useEffect(() => () => geometry?.dispose(), [geometry]);
     // Map dormer-local geometry into the host segment's local frame (where the
@@ -126,8 +120,12 @@ const DormerRenderer = ({ node: storeNode }) => {
     // dormer's own position + rotation so the registered Object3D's
     // local frame is *dormer-local* — that's what `NodeArrowHandles`
     // reads to place its chevrons. Mirrors chimney's structure.
-    return (_jsx("group", { position: segment.position, "rotation-y": segment.rotation ?? 0, visible: node.visible, ...handlers, children: _jsxs("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], ref: ref, "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "dormer-body", receiveShadow: true }), _jsx(DormerWindowAssembly, { dormerToSegment: localToSegment, frameMaterial: frameSideMat, glassMaterial: glassMat, node: node, segment: segment })] }) }));
+    return (_jsx("group", { position: segment.position, "rotation-y": segment.rotation ?? 0, visible: node.visible, children: _jsxs("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], ref: ref, "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "dormer-body", receiveShadow: true, ...handlers }), hostedWindows.map((window) => (_jsx(DormerWindowHostFrame, { dormer: node, face: window.dormerFace ?? 'front', children: _jsx(NodeRenderer, { nodeId: window.id }) }, `${node.id}:${window.id}`)))] }) }));
 };
+function DormerWindowHostFrame({ dormer, face, children, }) {
+    const frame = getDormerWallFaceFrame(dormer, face);
+    return (_jsx("group", { position: frame.origin, "rotation-y": frame.yaw, children: children }));
+}
 // Re-export so consumers (e.g. tests) can reach the gable slot index
 // without importing from `@pascal-app/viewer` directly.
 export { DORMER_GABLE_MATERIAL_INDEX };

package/dist/dormer/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/dormer/tool.tsx"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AACH,QAAA,MAAM,UAAU,mCAyFf,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/dormer/tool.tsx"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH,QAAA,MAAM,UAAU,mCA+Ff,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/dormer/tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { DormerNode, useScene } from '@pascal-app/core';
+import { createDormerDefaultWindow, DormerNode, getDormerDefaultWindowFace, useScene, } from '@pascal-app/core';
 import { usePlacementPreview } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo } from 'react';
@@ -61,6 +61,8 @@ const DormerTool = () => {
                 rotation,
             });
             state.createNode(dormer, hit.segment.id);
+            const defaultWindow = createDormerDefaultWindow(dormer, `window_${dormer.id.replace(/^dormer_/, '')}_default`, getDormerDefaultWindowFace(dormer, hit.segment));
+            state.createNode(defaultWindow, dormer.id);
             state.dirtyNodes.add(hit.segment.id);
             setSelection({ selectedIds: [dormer.id] });
             usePlacementPreview.getState().clear();

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

@@ -0,0 +1,15 @@
+export declare const DORMER_WINDOW_GAP = 0.12;
+export declare const DORMER_WINDOW_MARGIN = 0.12;
+export declare const DORMER_WINDOW_MIN_WIDTH = 0.3;
+export type DormerWindowRowItem = {
+    id: string;
+    position: readonly [number, number, number];
+    width: number;
+};
+export type DormerWindowRowPlacement = {
+    id: string;
+    position: [number, number, number];
+    width: number;
+};
+export declare function planDormerWindowRow(dormerWidth: number, windows: readonly DormerWindowRowItem[]): DormerWindowRowPlacement[] | null;
+//# sourceMappingURL=window-layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"window-layout.d.ts","sourceRoot":"","sources":["../../src/dormer/window-layout.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,OAAO,CAAA;AACrC,eAAO,MAAM,oBAAoB,OAAO,CAAA;AACxC,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAwCD,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,wBAAwB,EAAE,GAAG,IAAI,CA4BnC"}

package/dist/dormer/window-layout.js

@@ -0,0 +1,59 @@
+export const DORMER_WINDOW_GAP = 0.12;
+export const DORMER_WINDOW_MARGIN = 0.12;
+export const DORMER_WINDOW_MIN_WIDTH = 0.3;
+const roundLayoutValue = (value) => {
+    const rounded = Math.round(value * 1_000_000) / 1_000_000;
+    return Object.is(rounded, -0) ? 0 : rounded;
+};
+function fitWindowWidths(preferredWidths, availableWidth) {
+    const minimumTotal = preferredWidths.length * DORMER_WINDOW_MIN_WIDTH;
+    if (availableWidth + 1e-9 < minimumTotal)
+        return null;
+    const widths = preferredWidths.map((width) => Math.max(DORMER_WINDOW_MIN_WIDTH, width));
+    if (widths.reduce((sum, width) => sum + width, 0) <= availableWidth)
+        return widths;
+    const fitted = Array.from({ length: widths.length }, () => 0);
+    const remainingIndices = new Set(widths.map((_, index) => index));
+    let remainingWidth = availableWidth;
+    while (remainingIndices.size > 0) {
+        const preferredTotal = [...remainingIndices].reduce((sum, index) => sum + widths[index], 0);
+        const scale = remainingWidth / preferredTotal;
+        const belowMinimum = [...remainingIndices].filter((index) => widths[index] * scale < DORMER_WINDOW_MIN_WIDTH);
+        if (belowMinimum.length === 0) {
+            for (const index of remainingIndices)
+                fitted[index] = widths[index] * scale;
+            break;
+        }
+        for (const index of belowMinimum) {
+            fitted[index] = DORMER_WINDOW_MIN_WIDTH;
+            remainingWidth -= DORMER_WINDOW_MIN_WIDTH;
+            remainingIndices.delete(index);
+        }
+    }
+    return fitted;
+}
+export function planDormerWindowRow(dormerWidth, windows) {
+    if (windows.length === 0)
+        return [];
+    const innerWidth = Math.max(0, dormerWidth - DORMER_WINDOW_MARGIN * 2);
+    const gapsWidth = DORMER_WINDOW_GAP * Math.max(0, windows.length - 1);
+    const widths = fitWindowWidths(windows.map((window) => window.width), innerWidth - gapsWidth);
+    if (!widths)
+        return null;
+    const rowWidth = widths.reduce((sum, width) => sum + width, 0) + gapsWidth;
+    let cursor = -rowWidth / 2;
+    return windows.map((window, index) => {
+        const width = widths[index];
+        const x = cursor + width / 2;
+        cursor += width + DORMER_WINDOW_GAP;
+        return {
+            id: window.id,
+            position: [
+                roundLayoutValue(x),
+                roundLayoutValue(window.position[1]),
+                roundLayoutValue(window.position[2]),
+            ],
+            width: roundLayoutValue(width),
+        };
+    });
+}

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

@@ -1 +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"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAiIxC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA4DpE,CAAA"}

package/dist/downspout/definition.js

@@ -1,4 +1,5 @@
 import { DownspoutNode as DownspoutNodeSchema, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint';
 import { downspoutParametrics } from './parametrics';
 import { computeDownspoutPath, downspoutPipeDims, effectiveWallJog, resolveDownspoutRouting, } from './routing';
 import { DownspoutNode } from './schema';
@@ -38,8 +39,12 @@ function downspoutLengthHandle() {
         anchor: 'max',
         shape: 'tracker',
         min: MIN_LENGTH,
+        gridSnap: true,
         currentValue: (n) => n.length,
-        apply: (_n, newValue) => ({ length: Math.max(MIN_LENGTH, newValue) }),
+        apply: (_n, newValue) => ({
+            length: Math.max(MIN_LENGTH, newValue),
+            lengthMode: 'manual',
+        }),
         placement: {
             position: (n, scene) => {
                 const routing = resolveDownspoutRouting(n, scene);
@@ -87,13 +92,14 @@ function downspoutMoveHandle(side) {
         axis: 'x',
         anchor: 'min',
         cursor: 'ew-resize',
+        gridSnap: true,
         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);
+            const outlets = (gutter.outlets ?? []).map((o) => o.id === n.outletId ? { ...o, offset: newOffset, generatedBy: undefined } : o);
             // Patch targets the GUTTER (overrideTarget), not the downspout.
             return { outlets };
         },
@@ -127,10 +133,11 @@ const downspoutHandles = [
  */
 export const downspoutDefinition = {
     kind: 'downspout',
-    schemaVersion: 1,
+    schemaVersion: 3,
     schema: DownspoutNode,
     category: 'structure',
     surfaceRole: 'roof',
+    snapProfile: 'item',
     defaults: () => {
         const stub = DownspoutNodeSchema.parse({
             id: 'downspout_default',
@@ -140,9 +147,11 @@ export const downspoutDefinition = {
         return rest;
     },
     capabilities: {
+        slots: () => [{ slotId: 'surface', label: 'Surface', default: 'library:preset-softwhite' }],
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
+        paint: { ...surfacePaintCapability, materialTarget: 'downspout' },
         // Logically a roof accessory — registers under the segment, has
         // no buildCut, just the standard dirty cascade.
         roofAccessory: {},
@@ -153,6 +162,10 @@ export const downspoutDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    system: {
+        module: () => import('./system'),
+        priority: 2,
+    },
     preview: () => import('./preview'),
     tool: () => import('./tool'),
     toolHints: [
@@ -163,7 +176,7 @@ export const downspoutDefinition = {
     presentation: {
         label: 'Downspout',
         description: 'Vertical drop pipe from a gutter outlet to the ground.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/downspout.webp' },
         paletteSection: 'structure',
         paletteOrder: 123,
     },

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

@@ -1 +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"}
+{"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;AAS9B,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,CAgDtB"}

package/dist/downspout/geometry.js

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { applyCylinderWorldUvs, applyPlanarWorldUvs, applySphereWorldUvs, copyUvToSecondaryChannel, } from '../shared/primitive-uv';
 import { computeDownspoutPath, downspoutPipeDims, effectiveWallJog, } from './routing';
 /**
  * Downspout pipe builder. The pipe follows a real downspout's path —
@@ -78,6 +79,7 @@ export function buildDownspoutGeometry(node, routing) {
             p.dispose();
     }
     merged.computeVertexNormals();
+    copyUvToSecondaryChannel(merged);
     return merged;
 }
 /**
@@ -92,6 +94,10 @@ function segmentBetween(a, b, dims) {
     const geo = dims.shape === 'round'
         ? new THREE.CylinderGeometry(dims.halfX, dims.halfX, len, RADIAL_SEGMENTS).toNonIndexed()
         : new THREE.BoxGeometry(2 * dims.halfX, len, 2 * dims.halfZ).toNonIndexed();
+    if (dims.shape === 'round')
+        applyCylinderWorldUvs(geo, dims.halfX, len);
+    else
+        applyPlanarWorldUvs(geo);
     // The primitive runs along +Y centred at origin; rotate +Y onto the
     // segment direction, then drop it on the midpoint.
     geo.applyQuaternion(new THREE.Quaternion().setFromUnitVectors(UP, dir.normalize()));
@@ -150,6 +156,7 @@ function ringTube(a, b, dims) {
 function jointAt(p, prev, next, dims) {
     if (dims.shape === 'round') {
         const geo = new THREE.SphereGeometry(dims.halfX, JOINT_SEGMENTS, JOINT_SEGMENTS).toNonIndexed();
+        applySphereWorldUvs(geo, dims.halfX);
         geo.translate(p.x, p.y, p.z);
         return geo;
     }
@@ -160,6 +167,7 @@ function jointAt(p, prev, next, dims) {
         bis.copy(dirOut); // straight-through; degenerate
     bis.normalize();
     const geo = new THREE.BoxGeometry(2 * dims.halfX, 2 * dims.halfZ, 2 * dims.halfZ).toNonIndexed();
+    applyPlanarWorldUvs(geo);
     geo.applyQuaternion(new THREE.Quaternion().setFromUnitVectors(UP, bis));
     geo.translate(p.x, p.y, p.z);
     return geo;
@@ -185,6 +193,7 @@ function buildStraps(path, dims, spacing) {
     for (let i = 0; i < count; i++) {
         const y = count > 1 ? top - STRAP_END_MARGIN - i * stride : (top + bottom) / 2;
         const band = new THREE.BoxGeometry(w, STRAP_THICKNESS, d).toNonIndexed();
+        applyPlanarWorldUvs(band);
         band.translate(0, y, z);
         straps.push(band);
     }
@@ -197,6 +206,7 @@ function buildStraps(path, dims, spacing) {
 function buildSplash(path) {
     const [bx, by, bz] = path.bottom;
     const slab = new THREE.BoxGeometry(SPLASH_WIDTH, SPLASH_THICKNESS, SPLASH_LENGTH).toNonIndexed();
+    applyPlanarWorldUvs(slab);
     // Tilt the far (+Z) end down so it slopes away from the wall.
     slab.rotateX(SPLASH_TILT);
     slab.translate(bx, by - SPLASH_THICKNESS / 2, bz + SPLASH_LENGTH / 2);

package/dist/downspout/inspector-editors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/downspout/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,sCAyDxE"}
+{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/downspout/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,sCAoExE"}

package/dist/downspout/inspector-editors.js

@@ -50,7 +50,15 @@ export function DownspoutPositionEditor({ node }) {
     const handleCommit = (offset) => {
         // Commit once to the store, then drop the override.
         const state = useScene.getState();
-        state.updateNode(gutterId, { outlets: withOffset(offset) });
+        const outlets = withOffset(offset).map((entry) => entry.id === node.outletId ? { ...entry, generatedBy: undefined } : entry);
+        const metadata = node.metadata && typeof node.metadata === 'object' && !Array.isArray(node.metadata)
+            ? { ...node.metadata }
+            : {};
+        delete metadata.generatedBy;
+        state.updateNodes([
+            { id: gutterId, data: { outlets } },
+            { id: node.id, data: { metadata: metadata } },
+        ]);
         useLiveNodeOverrides.getState().clear(gutterId);
         state.markDirty(gutterId);
     };

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/downspout/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,aAAa,CAgEpE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/downspout/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,aAAa,CAiEpE,CAAA"}

package/dist/downspout/parametrics.js

@@ -1,10 +1,11 @@
 import { DownspoutPositionEditor } from './inspector-editors';
 export const downspoutParametrics = {
+    derive: (_next, patch) => ('length' in patch ? { lengthMode: 'manual' } : {}),
     groups: [
         {
             label: 'Dimensions',
             fields: [
-                { key: 'length', kind: 'number', unit: 'm', min: 0.1, max: 8, step: 0.05 },
+                { key: 'length', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 },
                 { key: 'diameter', kind: 'number', unit: 'm', min: 0.02, max: 0.15, step: 0.005 },
                 // Cross-section: follow the gutter profile, or force round / rect.
                 {

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/downspout/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAqKtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/downspout/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAwBzB;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAmLtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/downspout/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 { computeEaveY } from '../gutter/eave-snap';
@@ -38,6 +38,7 @@ const DownspoutRenderer = ({ 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 }
@@ -96,13 +97,28 @@ const DownspoutRenderer = ({ node: storeNode }) => {
     ]);
     useEffect(() => () => geometry.dispose(), [geometry]);
     const material = useMemo(() => {
-        if (!textures || (!node.material && !node.materialPreset)) {
+        if (!textures) {
+            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        }
+        const slotMaterial = resolveMaterialRef(node.slots?.surface, 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?.surface,
+        node.material,
+        node.materialPreset,
+        sceneMaterials,
+    ]);
     // Map downspout-local geometry into the host segment's local frame (where the
     // trim cut prisms live). Recompose the same outlet pose the inner mesh group
     // is mounted with (gutter offset + rotation → outlet → eave Y). Computed

package/dist/downspout/system.d.ts

@@ -0,0 +1,7 @@
+import { type SceneApi } from '@pascal-app/core';
+export declare function initializeAutomaticDownspoutSync(sceneApi: SceneApi): () => void;
+declare const DownspoutSystem: ({ sceneApi }: {
+    sceneApi: SceneApi;
+}) => null;
+export default DownspoutSystem;
+//# sourceMappingURL=system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/downspout/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AA0EzB,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,cAkClE;AAED,QAAA,MAAM,eAAe,GAAI,cAAc;IAAE,QAAQ,EAAE,QAAQ,CAAA;CAAE,SAG5D,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/downspout/system.js

@@ -0,0 +1,114 @@
+'use client';
+import { resolveAutomaticDownspoutLength, usesAutomaticDownspoutLength, } from '@pascal-app/core';
+import { useEffect } from 'react';
+const BROAD_AUTOMATIC_LENGTH_DEPENDENCY_TYPES = new Set([
+    'site',
+    'building',
+    'level',
+    'wall',
+    'lean-to-extension',
+    'roof',
+]);
+function affectedAutomaticDownspoutIds(nodes, previous, changedIds, automaticIds) {
+    const affected = new Set();
+    for (const id of changedIds) {
+        const current = nodes[id];
+        const prior = previous[id];
+        if (current?.type === 'downspout' && usesAutomaticDownspoutLength(current))
+            affected.add(id);
+        if (prior?.type === 'downspout')
+            affected.add(id);
+        const candidate = current ?? prior;
+        if (!candidate)
+            continue;
+        if (BROAD_AUTOMATIC_LENGTH_DEPENDENCY_TYPES.has(candidate.type)) {
+            for (const automaticId of automaticIds)
+                affected.add(automaticId);
+            continue;
+        }
+        if (candidate.type === 'gutter' || candidate.type === 'roof-segment') {
+            const segmentId = candidate.type === 'roof-segment'
+                ? candidate.id
+                : (candidate.parentId ?? candidate.roofSegmentId);
+            const segment = segmentId
+                ? (nodes[segmentId] ?? previous[segmentId])
+                : undefined;
+            for (const childId of segment?.children ?? []) {
+                const child = nodes[childId] ?? previous[childId];
+                if (child?.type === 'downspout')
+                    affected.add(child.id);
+            }
+        }
+    }
+    return affected;
+}
+function automaticLengthUpdates(nodes, candidateIds) {
+    const updates = [];
+    for (const id of candidateIds) {
+        const candidate = nodes[id];
+        if (candidate?.type !== 'downspout' || !usesAutomaticDownspoutLength(candidate))
+            continue;
+        const downspout = candidate;
+        const gutter = downspout.gutterId
+            ? nodes[downspout.gutterId]
+            : undefined;
+        const segment = gutter?.roofSegmentId
+            ? nodes[gutter.roofSegmentId]
+            : undefined;
+        const outlet = gutter?.outlets?.find((entry) => entry.id === downspout.outletId);
+        if (!(gutter?.type === 'gutter' && segment?.type === 'roof-segment' && outlet))
+            continue;
+        const length = resolveAutomaticDownspoutLength(nodes, segment, gutter, outlet.offset);
+        if (Math.abs(length - downspout.length) > 1e-6) {
+            updates.push({ id: downspout.id, data: { length } });
+        }
+    }
+    return updates;
+}
+export function initializeAutomaticDownspoutSync(sceneApi) {
+    const applyChanges = sceneApi.applyChanges;
+    const subscribeNodes = sceneApi.subscribeNodes;
+    if (!(applyChanges && subscribeNodes))
+        return () => { };
+    const automaticIds = new Set();
+    for (const node of Object.values(sceneApi.nodes())) {
+        if (node.type === 'downspout' && usesAutomaticDownspoutLength(node)) {
+            automaticIds.add(node.id);
+        }
+    }
+    let syncing = false;
+    const apply = (nodes, candidateIds) => {
+        const updates = automaticLengthUpdates(nodes, candidateIds);
+        if (updates.length === 0)
+            return;
+        syncing = true;
+        sceneApi.pauseHistory();
+        try {
+            applyChanges({ update: updates });
+        }
+        finally {
+            sceneApi.resumeHistory();
+            syncing = false;
+        }
+    };
+    apply(sceneApi.nodes(), automaticIds);
+    return subscribeNodes((nodes, previous, changedIds) => {
+        if (syncing)
+            return;
+        for (const id of changedIds) {
+            const node = nodes[id];
+            if (node?.type === 'downspout' && usesAutomaticDownspoutLength(node))
+                automaticIds.add(id);
+            else if (previous[id]?.type === 'downspout')
+                automaticIds.delete(id);
+        }
+        const affected = affectedAutomaticDownspoutIds(nodes, previous, changedIds, automaticIds);
+        if (affected.size > 0)
+            apply(nodes, affected);
+    });
+}
+const DownspoutSystem = ({ sceneApi }) => {
+    useEffect(() => initializeAutomaticDownspoutSync(sceneApi), [sceneApi]);
+    return null;
+};
+export default DownspoutSystem;

package/dist/duct-fitting/accessory-geometry.d.ts

@@ -0,0 +1,4 @@
+import type { DuctFittingNode } from '@pascal-app/core';
+import { Group, type Material } from 'three';
+export declare function buildDuctAccessory(node: DuctFittingNode, material: Material): Group | null;
+//# sourceMappingURL=accessory-geometry.d.ts.map

package/dist/duct-fitting/accessory-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessory-geometry.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/accessory-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,KAAK,EAAE,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,IAAI,CAiH1F"}