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

package/dist/lean-to-extension/geometry.js

@@ -0,0 +1,662 @@
+import { applyWorldScaleBoxUVs, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { BoxGeometry, FrontSide, Group, Mesh, Quaternion, Vector3 } from 'three';
+import { bendLocalPoint, bendRotationYAtLocalX, isCurvedLeanTo } from './arc';
+import { readFreestandingCanopyJointMetadata } from './canopy-joint';
+import { readLeanToCornerJointMetadata } from './corner-joint';
+import { isDualSlopeLeanToCanopy, LEAN_TO_EXTENSION_GEOMETRY_REVISION, resolveLeanToLayout, } from './layout';
+import { LEAN_TO_SLOT_DEFAULTS } from './slots';
+// Number of straight facets used to approximate a curved member spanning the arc.
+export function leanToFacetCount(node) {
+    if (!isCurvedLeanTo(node))
+        return 1;
+    return Math.max(4, Math.min(32, Math.ceil(node.span / 0.4)));
+}
+export function leanToExtensionGeometryKey(node) {
+    return JSON.stringify([
+        LEAN_TO_EXTENSION_GEOMETRY_REVISION,
+        node.canopyForm,
+        node.span,
+        node.spanArcCenterZ,
+        node.spanArcRadius,
+        node.projection,
+        node.highEdgeHeight,
+        node.pitch,
+        node.roofThickness,
+        node.highOverhang,
+        node.lowOverhang,
+        node.leftOverhang,
+        node.rightOverhang,
+        node.coveringType,
+        node.beamWidth,
+        node.beamHeight,
+        node.ledgerDepth,
+        node.ledgerHeight,
+        node.highSideMode,
+        node.ledgerVerticalOffset,
+        node.lowBeamInset,
+        node.rafterWidth,
+        node.rafterHeight,
+        node.rafterSpacing,
+        node.rafterEndInset,
+        node.postWidth,
+        node.postDepth,
+        node.postCount,
+        node.postLayoutMode,
+        node.postSpacing,
+        node.postInset,
+        node.postBracing,
+        node.footingStyle,
+        node.sideFlashing,
+        node.flashingProjection,
+        node.flashingHeight,
+        node.slots,
+        node.framingStrategy,
+        node.purlinWidth,
+        node.purlinHeight,
+        node.purlinSpacing,
+        node.leftEndCondition,
+        node.rightEndCondition,
+        readLeanToCornerJointMetadata(node),
+        readFreestandingCanopyJointMetadata(node),
+    ]);
+}
+function addBox(group, args) {
+    const geometry = new BoxGeometry(...args.size);
+    applyWorldScaleBoxUVs(geometry, ...args.size);
+    const mesh = new Mesh(geometry, args.material ??
+        createSurfaceRoleMaterial(args.role, args.colorPreset, FrontSide, args.sceneTheme));
+    mesh.name = args.name;
+    mesh.position.set(...args.position);
+    // YXZ: apply pitch (X) first, then yaw (Y) around vertical to face along the arc.
+    mesh.rotation.set(args.rotationX ?? 0, args.rotationY ?? 0, 0, 'YXZ');
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.userData.surfaceRole = args.role;
+    if (args.slotId)
+        mesh.userData.slotId = args.slotId;
+    group.add(mesh);
+}
+function addBoxBetween(group, args) {
+    const start = new Vector3(...args.start);
+    const end = new Vector3(...args.end);
+    const direction = end.clone().sub(start);
+    const length = direction.length();
+    if (length <= 1e-6)
+        return;
+    const geometry = new BoxGeometry(args.width, args.height, length);
+    applyWorldScaleBoxUVs(geometry, args.width, args.height, length);
+    const mesh = new Mesh(geometry, args.material);
+    mesh.name = args.name;
+    mesh.position.copy(start.add(end).multiplyScalar(0.5));
+    mesh.quaternion.copy(new Quaternion().setFromUnitVectors(new Vector3(0, 0, 1), direction.normalize()));
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.userData.surfaceRole = args.role;
+    mesh.userData.slotId = args.slotId;
+    group.add(mesh);
+}
+function addMiteredBeam(group, args) {
+    const length = args.maxX - args.minX;
+    if (length <= 1e-6)
+        return;
+    const centerX = (args.minX + args.maxX) / 2;
+    const halfLength = length / 2;
+    const geometry = new BoxGeometry(length, args.height, args.depth);
+    applyWorldScaleBoxUVs(geometry, length, args.height, args.depth);
+    const positions = geometry.getAttribute('position');
+    for (let index = 0; index < positions.count; index++) {
+        const x = positions.getX(index);
+        const z = positions.getZ(index);
+        if (args.leftMiterCenter !== null && Math.abs(x + halfLength) <= 1e-6) {
+            positions.setX(index, args.leftMiterCenter - centerX - z * args.leftMiterSlope);
+        }
+        else if (args.rightMiterCenter !== null && Math.abs(x - halfLength) <= 1e-6) {
+            positions.setX(index, args.rightMiterCenter - centerX + z * args.rightMiterSlope);
+        }
+    }
+    positions.needsUpdate = true;
+    geometry.computeVertexNormals();
+    const mesh = new Mesh(geometry, args.material);
+    mesh.name = args.name ?? 'lean-to-front-beam';
+    mesh.position.set(centerX, args.y, args.z);
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.userData.surfaceRole = 'joinery';
+    mesh.userData.slotId = 'beam';
+    group.add(mesh);
+}
+function resolveLeanToSlotMaterial(node, slotId, ctx, shading, textures, role, colorPreset, sceneTheme) {
+    if (!textures)
+        return createSurfaceRoleMaterial(role, colorPreset, FrontSide, sceneTheme);
+    const ref = node.slots?.[slotId];
+    const slotDefault = LEAN_TO_SLOT_DEFAULTS[slotId];
+    return ((ref ? resolveMaterialRef(ref, ctx?.materials, shading) : null) ??
+        (slotDefault
+            ? resolveSlotDefaultMaterial(slotDefault, shading)
+            : createSurfaceRoleMaterial(role, colorPreset, FrontSide, sceneTheme)));
+}
+export function buildLeanToExtensionGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const layout = resolveLeanToLayout(node);
+    const butterfly = layout.canopyForm === 'butterfly';
+    const dualSlope = isDualSlopeLeanToCanopy(layout.canopyForm);
+    const primarySlope = butterfly ? -layout.pitchRadians : layout.pitchRadians;
+    const oppositeSlope = -primarySlope;
+    const cornerJoints = readLeanToCornerJointMetadata(node);
+    const canopyJoints = readFreestandingCanopyJointMetadata(node);
+    const group = new Group();
+    group.name = 'lean-to-extension-geometry';
+    const isConcave = (side) => (cornerJoints[side]?.beamExtension ?? 0) < -1e-6;
+    const concaveBeamBoundaryX = (side) => {
+        const extension = cornerJoints[side]?.beamExtension ?? 0;
+        return side === 'left' ? -layout.span / 2 - extension : layout.span / 2 + extension;
+    };
+    const isRetainedLowPostX = (x) => {
+        if (isConcave('left') && x <= concaveBeamBoundaryX('left') + 1e-6)
+            return false;
+        if (isConcave('right') && x >= concaveBeamBoundaryX('right') - 1e-6)
+            return false;
+        return true;
+    };
+    const seamIntersectionAtX = (side, x) => {
+        const seam = cornerJoints[side]?.seam;
+        if (!isConcave(side) || !seam)
+            return null;
+        const [start, end] = seam;
+        const deltaX = end[0] - start[0];
+        if (Math.abs(deltaX) <= 1e-6)
+            return null;
+        const ratio = (x - start[0]) / deltaX;
+        if (ratio < -1e-6 || ratio > 1 + 1e-6)
+            return null;
+        return {
+            z: start[1] + (end[1] - start[1]) * ratio,
+            dzDx: (end[1] - start[1]) / deltaX,
+            retainedSide: cornerJoints[side]?.framingRetainedSide ?? 'back',
+        };
+    };
+    const retainedWidthAtZ = (z) => {
+        let minX = layout.roofCenterX - layout.roofWidth / 2;
+        let maxX = layout.roofCenterX + layout.roofWidth / 2;
+        for (const side of ['left', 'right']) {
+            const seam = cornerJoints[side]?.seam;
+            if (!isConcave(side) || !seam)
+                continue;
+            const [start, end] = seam;
+            const deltaZ = end[1] - start[1];
+            if (Math.abs(deltaZ) <= 1e-6)
+                continue;
+            const ratio = (z - start[1]) / deltaZ;
+            if (ratio < -1e-6 || ratio > 1 + 1e-6)
+                continue;
+            const seamX = start[0] + (end[0] - start[0]) * ratio;
+            const deltaX = end[0] - start[0];
+            if (Math.abs(deltaX) <= 1e-6)
+                continue;
+            const retainedSide = cornerJoints[side]?.framingRetainedSide ?? 'back';
+            const slope = deltaZ / deltaX;
+            const retainGreaterX = retainedSide === 'front' ? slope < 0 : slope > 0;
+            if (retainGreaterX)
+                minX = Math.max(minX, seamX);
+            else
+                maxX = Math.min(maxX, seamX);
+        }
+        return { minX, maxX };
+    };
+    const canopySeamIntersectionsAtX = (planeSide, x) => {
+        const intersections = [];
+        for (const [side, joint] of Object.entries(canopyJoints)) {
+            if (joint.kind !== 'corner' || joint.innerCanopySide !== planeSide)
+                continue;
+            const endpointX = side === 'left' ? -layout.span / 2 : layout.span / 2;
+            const seamEndX = endpointX + (side === 'left' ? 1 : -1) * joint.trimX;
+            const seamEndZ = (planeSide === 'positive' ? 1 : -1) * joint.trimZ;
+            const deltaX = seamEndX - endpointX;
+            if (Math.abs(deltaX) <= 1e-6)
+                continue;
+            const ratio = (x - endpointX) / deltaX;
+            if (ratio < -1e-6 || ratio > 1 + 1e-6)
+                continue;
+            intersections.push({ z: seamEndZ * ratio, dzDx: seamEndZ / deltaX });
+        }
+        return intersections;
+    };
+    const retainedCanopyWidthAtZ = (planeSide, z) => {
+        let minX = layout.roofCenterX - layout.roofWidth / 2;
+        let maxX = layout.roofCenterX + layout.roofWidth / 2;
+        for (const [side, joint] of Object.entries(canopyJoints)) {
+            if (joint.kind !== 'corner' || joint.innerCanopySide !== planeSide || joint.trimZ <= 1e-6) {
+                continue;
+            }
+            const ratio = Math.abs(z) / joint.trimZ;
+            if (ratio < -1e-6 || ratio > 1 + 1e-6)
+                continue;
+            const endpointX = side === 'left' ? -layout.span / 2 : layout.span / 2;
+            const seamX = endpointX + (side === 'left' ? 1 : -1) * joint.trimX * ratio;
+            if (side === 'left')
+                minX = Math.max(minX, seamX);
+            else
+                maxX = Math.min(maxX, seamX);
+        }
+        return { minX, maxX };
+    };
+    const curved = isCurvedLeanTo(node);
+    const facets = leanToFacetCount(node);
+    const bend = (localX, localZ) => {
+        const point = bendLocalPoint(node, localX, localZ);
+        return [point.x, point.y];
+    };
+    const bendRotY = (localX) => bendRotationYAtLocalX(node, localX);
+    // Point-like member (post, rafter, brace): placed on the arc with a per-member yaw.
+    const addBentBox = (args) => {
+        const [x, z] = bend(args.localX, args.localZ);
+        addBox(group, {
+            name: args.name,
+            size: args.size,
+            position: [x, args.y, z],
+            rotationX: args.rotationX,
+            rotationY: bendRotY(args.localX),
+            role: args.role,
+            colorPreset,
+            sceneTheme,
+            material: args.material,
+            slotId: args.slotId,
+        });
+    };
+    // Width-spanning member (roof strip, purlin, high beam): faceted along the arc.
+    const addBentStrip = (args) => {
+        const count = curved ? facets : 1;
+        const localFacetWidth = args.totalWidth / count;
+        const facetWidth = curved
+            ? 2 *
+                Math.abs((node.spanArcCenterZ ?? 0) - args.localZ) *
+                Math.tan(localFacetWidth / (2 * (node.spanArcRadius ?? 1)))
+            : localFacetWidth;
+        for (let index = 0; index < count; index++) {
+            const centerX = args.centerX - args.totalWidth / 2 + (index + 0.5) * localFacetWidth;
+            const [x, z] = bend(centerX, args.localZ);
+            addBox(group, {
+                name: count > 1 ? `${args.name}-${index}` : args.name,
+                size: [facetWidth + (count > 1 ? 0.004 : 0), args.height, args.depth],
+                position: [x, args.y, z],
+                rotationX: args.rotationX,
+                rotationY: bendRotY(centerX),
+                role: args.role,
+                colorPreset,
+                sceneTheme,
+                material: args.material,
+                slotId: args.slotId,
+            });
+        }
+    };
+    const flashingMaterial = resolveLeanToSlotMaterial(node, 'flashing', ctx, shading, textures, 'roof', colorPreset, sceneTheme);
+    const ledgerMaterial = resolveLeanToSlotMaterial(node, 'ledger', ctx, shading, textures, 'wall', colorPreset, sceneTheme);
+    const beamMaterial = resolveLeanToSlotMaterial(node, 'beam', ctx, shading, textures, 'wall', colorPreset, sceneTheme);
+    const framingMaterial = resolveLeanToSlotMaterial(node, 'framing', ctx, shading, textures, 'wall', colorPreset, sceneTheme);
+    const postsMaterial = resolveLeanToSlotMaterial(node, 'posts', ctx, shading, textures, 'joinery', colorPreset, sceneTheme);
+    const footingsMaterial = resolveLeanToSlotMaterial(node, 'footings', ctx, shading, textures, 'joinery', colorPreset, sceneTheme);
+    const footingHeight = node.footingStyle === 'concrete-pad' ? 0.12 : 0.04;
+    const footingScale = node.footingStyle === 'concrete-pad' ? 2 : 1.4;
+    if (!ctx) {
+        addBentStrip({
+            name: 'lean-to-preview-roof',
+            centerX: layout.roofCenterX,
+            totalWidth: layout.roofWidth,
+            height: node.roofThickness,
+            depth: layout.slopeLength,
+            localZ: layout.roofCenterZ,
+            y: layout.roofCenterY,
+            rotationX: primarySlope,
+            role: 'roof',
+        });
+        if (dualSlope) {
+            addBentStrip({
+                name: 'lean-to-preview-roof-opposite',
+                centerX: layout.roofCenterX,
+                totalWidth: layout.roofWidth,
+                height: node.roofThickness,
+                depth: layout.slopeLength,
+                localZ: -layout.roofCenterZ,
+                y: layout.roofCenterY,
+                rotationX: oppositeSlope,
+                role: 'roof',
+            });
+        }
+    }
+    if (node.highSideMode === 'independent-high-beam' && !butterfly) {
+        addBentStrip({
+            name: 'lean-to-independent-high-beam',
+            centerX: 0,
+            totalWidth: layout.span,
+            height: node.ledgerHeight,
+            depth: node.ledgerDepth,
+            localZ: 0,
+            y: layout.highEdgeHeight -
+                node.roofThickness / 2 -
+                node.ledgerHeight / 2 +
+                node.ledgerVerticalOffset,
+            role: 'joinery',
+            material: ledgerMaterial,
+            slotId: 'ledger',
+        });
+    }
+    if (node.sideFlashing) {
+        for (const [side, condition] of [
+            [-1, node.leftEndCondition],
+            [1, node.rightEndCondition],
+        ]) {
+            if (condition !== 'wall-abutment')
+                continue;
+            addBentBox({
+                name: `lean-to-${side < 0 ? 'left' : 'right'}-side-flashing`,
+                size: [node.flashingProjection, node.flashingHeight, layout.slopeLength],
+                localX: side < 0 ? -(layout.span / 2 + node.leftOverhang) : layout.span / 2 + node.rightOverhang,
+                localZ: layout.roofCenterZ,
+                y: layout.roofCenterY + node.flashingHeight / 3,
+                rotationX: layout.pitchRadians,
+                role: 'roof',
+                material: flashingMaterial,
+                slotId: 'flashing',
+            });
+        }
+    }
+    const leftBeamExtension = cornerJoints.left?.beamExtension ?? 0;
+    const rightBeamExtension = cornerJoints.right?.beamExtension ?? 0;
+    const leftMiterCenter = cornerJoints.left ? -layout.span / 2 - leftBeamExtension : null;
+    const rightMiterCenter = cornerJoints.right ? layout.span / 2 + rightBeamExtension : null;
+    const beamMinX = leftMiterCenter === null ? -layout.beamSpan / 2 : leftMiterCenter - node.beamWidth / 2;
+    const beamMaxX = rightMiterCenter === null ? layout.beamSpan / 2 : rightMiterCenter + node.beamWidth / 2;
+    if (curved) {
+        addBentStrip({
+            name: 'lean-to-front-beam',
+            centerX: (beamMinX + beamMaxX) / 2,
+            totalWidth: beamMaxX - beamMinX,
+            height: node.beamHeight,
+            depth: node.beamWidth,
+            localZ: layout.beamZ,
+            y: layout.beamCenterY,
+            role: 'joinery',
+            material: beamMaterial,
+            slotId: 'beam',
+        });
+    }
+    else {
+        addMiteredBeam(group, {
+            minX: beamMinX,
+            maxX: beamMaxX,
+            leftMiterCenter,
+            rightMiterCenter,
+            leftMiterSlope: Math.tan(cornerJoints.left?.gutterMitre ?? 0),
+            rightMiterSlope: Math.tan(cornerJoints.right?.gutterMitre ?? 0),
+            height: node.beamHeight,
+            depth: node.beamWidth,
+            y: layout.beamCenterY,
+            z: layout.beamZ,
+            colorPreset,
+            sceneTheme,
+            material: beamMaterial,
+        });
+        if (dualSlope) {
+            addMiteredBeam(group, {
+                minX: beamMinX,
+                maxX: beamMaxX,
+                leftMiterCenter: null,
+                rightMiterCenter: null,
+                leftMiterSlope: 0,
+                rightMiterSlope: 0,
+                height: node.beamHeight,
+                depth: node.beamWidth,
+                y: layout.beamCenterY,
+                z: layout.oppositeBeamZ,
+                colorPreset,
+                sceneTheme,
+                material: beamMaterial,
+                name: 'lean-to-opposite-beam',
+            });
+        }
+    }
+    if (!ctx) {
+        for (const [index, x] of layout.postXs.entries()) {
+            addBentBox({
+                name: `lean-to-post-${index}`,
+                size: [node.postWidth, layout.postHeight, node.postDepth],
+                localX: x,
+                localZ: layout.beamZ,
+                y: layout.postHeight / 2,
+                role: 'joinery',
+                material: postsMaterial,
+                slotId: 'posts',
+            });
+            if (node.footingStyle !== 'none') {
+                addBentBox({
+                    name: `lean-to-post-footing-${index}`,
+                    size: [node.postWidth * footingScale, footingHeight, node.postDepth * footingScale],
+                    localX: x,
+                    localZ: layout.beamZ,
+                    y: footingHeight / 2,
+                    role: 'joinery',
+                    material: footingsMaterial,
+                    slotId: 'footings',
+                });
+            }
+        }
+    }
+    if (!ctx && node.highSideMode === 'independent-high-beam') {
+        const highPostHeight = dualSlope
+            ? layout.postHeight
+            : Math.max(0.2, layout.highEdgeHeight -
+                node.roofThickness / 2 -
+                node.ledgerHeight +
+                node.ledgerVerticalOffset);
+        for (const [index, x] of layout.postXs.entries()) {
+            addBentBox({
+                name: `lean-to-high-post-${index}`,
+                size: [node.postWidth, highPostHeight, node.postDepth],
+                localX: x,
+                localZ: dualSlope ? layout.oppositeBeamZ : 0,
+                y: highPostHeight / 2,
+                role: 'joinery',
+                material: postsMaterial,
+                slotId: 'posts',
+            });
+            if (node.footingStyle !== 'none') {
+                addBentBox({
+                    name: `lean-to-high-post-footing-${index}`,
+                    size: [node.postWidth * footingScale, footingHeight, node.postDepth * footingScale],
+                    localX: x,
+                    localZ: dualSlope ? layout.oppositeBeamZ : 0,
+                    y: footingHeight / 2,
+                    role: 'joinery',
+                    material: footingsMaterial,
+                    slotId: 'footings',
+                });
+            }
+        }
+    }
+    if (node.postBracing === 'knee') {
+        for (const [index, x] of layout.postXs.entries()) {
+            if (!isRetainedLowPostX(x))
+                continue;
+            addBentBox({
+                name: `lean-to-knee-brace-${index}`,
+                size: [node.rafterWidth, node.rafterHeight, Math.min(0.8, layout.projection / 2)],
+                localX: x,
+                localZ: Math.max(0, layout.beamZ - 0.22),
+                y: layout.beamCenterY - 0.22,
+                rotationX: Math.PI / 4,
+                role: 'joinery',
+                material: framingMaterial,
+                slotId: 'framing',
+            });
+            if (dualSlope) {
+                addBentBox({
+                    name: `lean-to-opposite-knee-brace-${index}`,
+                    size: [node.rafterWidth, node.rafterHeight, Math.min(0.8, layout.projection / 2)],
+                    localX: x,
+                    localZ: Math.min(0, layout.oppositeBeamZ + 0.22),
+                    y: layout.beamCenterY - 0.22,
+                    rotationX: -Math.PI / 4,
+                    role: 'joinery',
+                    material: framingMaterial,
+                    slotId: 'framing',
+                });
+            }
+        }
+    }
+    if (node.framingStrategy === 'rafters') {
+        const roofBuildUp = node.roofThickness / Math.max(0.1, Math.cos(layout.pitchRadians)) +
+            (node.shingleThickness ?? 0.025) * Math.cos(layout.pitchRadians);
+        const rafterY = (z) => (butterfly
+            ? layout.lowEdgeHeight + Math.abs(z) * Math.tan(layout.pitchRadians)
+            : layout.highEdgeHeight - Math.abs(z) * Math.tan(layout.pitchRadians)) -
+            roofBuildUp -
+            node.rafterHeight / 2;
+        const halfRafterRun = (layout.rafterSlopeLength * Math.cos(layout.pitchRadians)) / 2;
+        const rafterBackZ = layout.rafterCenterZ - halfRafterRun;
+        const rafterFrontZ = layout.rafterCenterZ + halfRafterRun;
+        const addRafter = (name, x, backZ, frontZ, centerZ, rotationX) => {
+            if (frontZ <= backZ + 1e-6)
+                return;
+            const expectedBackZ = centerZ - halfRafterRun;
+            const expectedFrontZ = centerZ + halfRafterRun;
+            if (backZ > expectedBackZ + 1e-6 || frontZ < expectedFrontZ - 1e-6) {
+                addBoxBetween(group, {
+                    name,
+                    start: [x, rafterY(backZ), backZ],
+                    end: [x, rafterY(frontZ), frontZ],
+                    width: node.rafterWidth,
+                    height: node.rafterHeight,
+                    role: 'joinery',
+                    colorPreset,
+                    sceneTheme,
+                    material: framingMaterial,
+                    slotId: 'framing',
+                });
+                return;
+            }
+            addBentBox({
+                name,
+                size: [node.rafterWidth, node.rafterHeight, layout.rafterSlopeLength],
+                localX: x,
+                localZ: centerZ,
+                y: layout.rafterCenterY,
+                rotationX,
+                role: 'joinery',
+                material: framingMaterial,
+                slotId: 'framing',
+            });
+        };
+        for (const [index, x] of layout.rafterXs.entries()) {
+            if (cornerJoints.left && index === 0)
+                continue;
+            if (cornerJoints.right && index === layout.rafterXs.length - 1)
+                continue;
+            let clippedBackZ = rafterBackZ;
+            let clippedFrontZ = rafterFrontZ;
+            for (const side of ['left', 'right']) {
+                const intersection = seamIntersectionAtX(side, x);
+                if (!intersection)
+                    continue;
+                const endRetreat = (Math.abs(intersection.dzDx) * node.rafterWidth) / 2 +
+                    (Math.sin(layout.pitchRadians) * node.rafterHeight) / 2 +
+                    0.002;
+                if (intersection.retainedSide === 'front') {
+                    clippedBackZ = Math.max(clippedBackZ, intersection.z + endRetreat);
+                }
+                else {
+                    clippedFrontZ = Math.min(clippedFrontZ, intersection.z - endRetreat);
+                }
+            }
+            for (const intersection of canopySeamIntersectionsAtX('positive', x)) {
+                const endRetreat = (Math.abs(intersection.dzDx) * node.rafterWidth) / 2 +
+                    (Math.sin(layout.pitchRadians) * node.rafterHeight) / 2 +
+                    0.002;
+                clippedFrontZ = Math.min(clippedFrontZ, intersection.z - endRetreat);
+            }
+            addRafter(`lean-to-rafter-${index}`, x, clippedBackZ, clippedFrontZ, layout.rafterCenterZ, primarySlope);
+            if (dualSlope) {
+                let oppositeBackZ = -rafterFrontZ;
+                const oppositeFrontZ = -rafterBackZ;
+                for (const intersection of canopySeamIntersectionsAtX('negative', x)) {
+                    const endRetreat = (Math.abs(intersection.dzDx) * node.rafterWidth) / 2 +
+                        (Math.sin(layout.pitchRadians) * node.rafterHeight) / 2 +
+                        0.002;
+                    oppositeBackZ = Math.max(oppositeBackZ, intersection.z + endRetreat);
+                }
+                addRafter(`lean-to-opposite-rafter-${index}`, x, oppositeBackZ, oppositeFrontZ, -layout.rafterCenterZ, oppositeSlope);
+            }
+        }
+        for (const [side, joint] of Object.entries(cornerJoints)) {
+            if (!(joint?.sharedPostOwner && joint.seam) || node.hostKind === 'freestanding')
+                continue;
+            const [start, end] = joint.seam;
+            const [startX, startZ] = bend(start[0], start[1]);
+            const [endX, endZ] = bend(end[0], end[1]);
+            addBoxBetween(group, {
+                name: `lean-to-${side}-corner-rafter`,
+                start: [startX, rafterY(start[1]), startZ],
+                end: [endX, rafterY(end[1]), endZ],
+                width: node.rafterWidth,
+                height: node.rafterHeight,
+                role: 'joinery',
+                colorPreset,
+                sceneTheme,
+                material: framingMaterial,
+                slotId: 'framing',
+            });
+        }
+    }
+    else if (node.framingStrategy === 'purlins' || node.framingStrategy === 'covering-specific') {
+        const coveringSpacing = node.coveringType === 'shingle' ? 0.4 : 0.6;
+        const spacing = node.framingStrategy === 'covering-specific'
+            ? Math.min(node.purlinSpacing, coveringSpacing)
+            : node.purlinSpacing;
+        const count = Math.max(2, Math.ceil(layout.rafterSlopeLength / spacing) + 1);
+        for (let index = 0; index < count; index++) {
+            const fraction = index / (count - 1);
+            const z = fraction * layout.rafterCenterZ * 2;
+            const y = layout.rafterCenterY +
+                (butterfly ? z - layout.rafterCenterZ : layout.rafterCenterZ - z) *
+                    Math.tan(layout.pitchRadians);
+            const retained = retainedWidthAtZ(z);
+            const positiveRetained = retainedCanopyWidthAtZ('positive', z);
+            const primaryMinX = Math.max(retained.minX, positiveRetained.minX);
+            const primaryMaxX = Math.min(retained.maxX, positiveRetained.maxX);
+            if (primaryMaxX > primaryMinX + 1e-6) {
+                addBentStrip({
+                    name: `lean-to-purlin-${index}`,
+                    centerX: (primaryMinX + primaryMaxX) / 2,
+                    totalWidth: primaryMaxX - primaryMinX,
+                    height: node.purlinHeight,
+                    depth: node.purlinWidth,
+                    localZ: z,
+                    y,
+                    rotationX: primarySlope,
+                    role: 'joinery',
+                    material: framingMaterial,
+                    slotId: 'framing',
+                });
+            }
+            if (dualSlope) {
+                const negativeRetained = retainedCanopyWidthAtZ('negative', -z);
+                const oppositeMinX = Math.max(retained.minX, negativeRetained.minX);
+                const oppositeMaxX = Math.min(retained.maxX, negativeRetained.maxX);
+                if (oppositeMaxX > oppositeMinX + 1e-6) {
+                    addBentStrip({
+                        name: `lean-to-opposite-purlin-${index}`,
+                        centerX: (oppositeMinX + oppositeMaxX) / 2,
+                        totalWidth: oppositeMaxX - oppositeMinX,
+                        height: node.purlinHeight,
+                        depth: node.purlinWidth,
+                        localZ: -z,
+                        y,
+                        rotationX: oppositeSlope,
+                        role: 'joinery',
+                        material: framingMaterial,
+                        slotId: 'framing',
+                    });
+                }
+            }
+        }
+    }
+    return group;
+}

package/dist/lean-to-extension/index.d.ts

@@ -0,0 +1,8 @@
+export { createLeanToAssembly, createManagedLeanToPost } from './assembly';
+export { leanToExtensionDefinition } from './definition';
+export { buildLeanToExtensionFloorplan } from './floorplan';
+export { buildLeanToExtensionGeometry, leanToExtensionGeometryKey } from './geometry';
+export { leanToWallLocalPose, resolveLeanToLayout, resolveLeanToWallPlacement, } from './layout';
+export { findLeanToSlabEdgePlacement, moveLeanToAlongSlabEdge, reconcileLeanToSlabEdgePlacement, resolveLeanToFreestandingPlacement, resolveLeanToSlabEdgePlacement, } from './placement';
+export { LeanToExtensionNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/lean-to-extension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,EAAE,4BAA4B,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AACrF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,2BAA2B,EAC3B,uBAAuB,EACvB,gCAAgC,EAChC,kCAAkC,EAClC,8BAA8B,GAC/B,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA"}

package/dist/lean-to-extension/index.js

@@ -0,0 +1,7 @@
+export { createLeanToAssembly, createManagedLeanToPost } from './assembly';
+export { leanToExtensionDefinition } from './definition';
+export { buildLeanToExtensionFloorplan } from './floorplan';
+export { buildLeanToExtensionGeometry, leanToExtensionGeometryKey } from './geometry';
+export { leanToWallLocalPose, resolveLeanToLayout, resolveLeanToWallPlacement, } from './layout';
+export { findLeanToSlabEdgePlacement, moveLeanToAlongSlabEdge, reconcileLeanToSlabEdgePlacement, resolveLeanToFreestandingPlacement, resolveLeanToSlabEdgePlacement, } from './placement';
+export { LeanToExtensionNode } from './schema';