@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/wall/curtain-opening-frame.js

@@ -0,0 +1,111 @@
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall, } from '@pascal-app/core';
+import { buildOpeningCutoutShape, ensureRenderableGeometryAttributes } from '@pascal-app/viewer';
+import { ExtrudeGeometry, Path, Shape, Vector2 } from 'three';
+export function mapCurtainOpeningGeometryToWall(geometry, wall) {
+    if (!isCurvedWall(wall))
+        return;
+    const length = getWallCurveLength(wall);
+    if (length <= 1e-6)
+        return;
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const position = geometry.getAttribute('position');
+    for (let index = 0; index < position.count; index++) {
+        const along = position.getX(index);
+        const depth = position.getZ(index);
+        const clampedAlong = Math.max(0, Math.min(length, along));
+        const frame = getWallCurveFrameAt(wall, clampedAlong / length);
+        const extension = along - clampedAlong;
+        const x = frame.point.x + frame.tangent.x * extension + frame.normal.x * depth - wall.start[0];
+        const z = frame.point.y + frame.tangent.y * extension + frame.normal.y * depth - wall.start[1];
+        position.setXYZ(index, x * cos + z * sin, position.getY(index), -x * sin + z * cos);
+    }
+    position.needsUpdate = true;
+    geometry.boundingBox = null;
+    geometry.boundingSphere = null;
+    geometry.computeVertexNormals();
+}
+export function curtainOpeningProfile(opening, width) {
+    const bottom = opening.position[1] - opening.height / 2;
+    if (Math.cos(opening.rotation[1]) < 0 && opening.openingRadiusMode === 'individual') {
+        if (opening.type === 'window') {
+            const [topLeft, topRight, bottomRight, bottomLeft] = opening.openingCornerRadii;
+            opening = {
+                ...opening,
+                openingCornerRadii: [topRight, topLeft, bottomLeft, bottomRight],
+            };
+        }
+        else {
+            const [topLeft, topRight] = opening.openingTopRadii;
+            opening = { ...opening, openingTopRadii: [topRight, topLeft] };
+        }
+    }
+    const points = buildOpeningCutoutShape(opening, {
+        left: opening.position[0] - opening.width / 2,
+        right: opening.position[0] + opening.width / 2,
+        bottom,
+        top: bottom + opening.height,
+    })
+        .getPoints(4)
+        .filter((point, index, all) => index === 0 || point.distanceToSquared(all[index - 1]) > 1e-14);
+    if (points[0].distanceToSquared(points.at(-1)) < 1e-14)
+        points.pop();
+    const outer = points.map((point, index) => {
+        const previous = points[(index + points.length - 1) % points.length];
+        const next = points[(index + 1) % points.length];
+        const before = point.clone().sub(previous).normalize();
+        const after = next.clone().sub(point).normalize();
+        const n1 = new Vector2(before.y, -before.x);
+        const n2 = new Vector2(after.y, -after.x);
+        const result = point
+            .clone()
+            .addScaledVector(n1.clone().add(n2), width / Math.max(1e-6, 1 + n1.dot(n2)));
+        if (opening.type === 'door' && Math.abs(point.y - bottom) < 1e-7)
+            result.y = bottom;
+        return result;
+    });
+    return { inner: points, outer };
+}
+export function buildCurtainOpeningFrame(opening, width, depth) {
+    const { inner, outer } = curtainOpeningProfile(opening, width);
+    const outline = new Shape(outer);
+    outline.closePath();
+    let ring;
+    if (opening.type === 'door') {
+        // The door has jambs and a head; its threshold remains owned by the door.
+        ring = new Shape([...outer.slice(1), outer[0], inner[0], ...inner.slice(1).reverse()]);
+        ring.closePath();
+    }
+    else {
+        ring = new Shape(outer);
+        ring.closePath();
+        const hole = new Path([...inner].reverse());
+        hole.closePath();
+        ring.holes.push(hole);
+    }
+    const extrude = (shape, thickness) => {
+        const indexed = new ExtrudeGeometry(shape, {
+            depth: thickness,
+            bevelEnabled: false,
+            steps: 1,
+        });
+        indexed.translate(0, 0, -thickness / 2);
+        ensureRenderableGeometryAttributes(indexed);
+        if (!indexed.index)
+            return indexed;
+        const geometry = indexed.toNonIndexed();
+        indexed.dispose();
+        return geometry;
+    };
+    return { frame: extrude(ring, depth), cutter: extrude(outline, depth * 3), cutout: outer };
+}
+export function curtainProfileSpan(points, height) {
+    const xs = [];
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i], b = points[(i + 1) % points.length];
+        if ((a.y <= height && b.y > height) || (b.y <= height && a.y > height))
+            xs.push(a.x + ((b.x - a.x) * (height - a.y)) / (b.y - a.y));
+    }
+    return xs.length >= 2 ? [Math.min(...xs), Math.max(...xs)] : null;
+}

package/dist/wall/curtain-panel-highlight.d.ts

@@ -0,0 +1,3 @@
+import { type WallNode } from '@pascal-app/core';
+export declare function useCurtainPanelHighlight(wall: WallNode, left: number, right: number, bottom: number, top: number, enabled: boolean): void;
+//# sourceMappingURL=curtain-panel-highlight.d.ts.map

package/dist/wall/curtain-panel-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-panel-highlight.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-panel-highlight.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAezB,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,QA2GjB"}

package/dist/wall/curtain-panel-highlight.js

@@ -0,0 +1,113 @@
+import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, sceneRegistry, } from '@pascal-app/core';
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { BufferGeometry, DoubleSide, Float32BufferAttribute, Line, LineBasicMaterial, Mesh, MeshBasicMaterial, Vector3, } from 'three';
+export function useCurtainPanelHighlight(wall, left, right, bottom, top, enabled) {
+    const wallId = wall.id;
+    const startX = wall.start[0];
+    const startZ = wall.start[1];
+    const endX = wall.end[0];
+    const endZ = wall.end[1];
+    const curveOffset = wall.curveOffset;
+    const thickness = getWallThickness(wall);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const curveWall = {
+            start: [startX, startZ],
+            end: [endX, endZ],
+            curveOffset,
+        };
+        const host = sceneRegistry.nodes.get(wallId);
+        if (!host)
+            return;
+        const length = getWallCurveLength(curveWall);
+        if (length <= 0)
+            return;
+        const angle = Math.atan2(endZ - startZ, endX - startX);
+        const cos = Math.cos(angle), sin = Math.sin(angle);
+        const points = [];
+        for (const y of [bottom, top]) {
+            const edge = [];
+            for (let i = 0; i <= 24; i++) {
+                const frame = getWallCurveFrameAt(curveWall, (left + ((right - left) * i) / 24) / length);
+                const offset = thickness / 2 + 0.005;
+                const x = frame.point.x + frame.normal.x * offset - startX;
+                const z = frame.point.y + frame.normal.y * offset - startZ;
+                edge.push(new Vector3(x * cos + z * sin, y, -x * sin + z * cos));
+            }
+            points.push(...(y === bottom ? edge : edge.reverse()));
+        }
+        points.push(points[0].clone());
+        const geometry = new BufferGeometry().setFromPoints(points);
+        const material = new LineBasicMaterial({
+            color: '#fb923c',
+            depthTest: false,
+            depthWrite: false,
+        });
+        const outline = new Line(geometry, material);
+        outline.layers.set(EDITOR_LAYER);
+        outline.raycast = () => { };
+        const vertices = [];
+        for (let i = 0; i < 24; i++) {
+            for (const index of [i, i + 1, 49 - i, i + 1, 48 - i, 49 - i]) {
+                vertices.push(...points[index].toArray());
+            }
+        }
+        const fillGeometry = new BufferGeometry();
+        fillGeometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+        const fillMaterial = new MeshBasicMaterial({
+            color: '#fb923c',
+            transparent: true,
+            opacity: 0.6,
+            side: DoubleSide,
+            depthTest: false,
+            depthWrite: false,
+        });
+        const fill = new Mesh(fillGeometry, fillMaterial);
+        fill.layers.set(EDITOR_LAYER);
+        fill.raycast = () => { };
+        let scene = host;
+        while (scene.parent)
+            scene = scene.parent;
+        outline.matrixAutoUpdate = false;
+        fill.matrixAutoUpdate = false;
+        scene.add(outline, fill);
+        let frameId = 0;
+        const sync = () => {
+            const current = sceneRegistry.nodes.get(wallId);
+            outline.visible = fill.visible = Boolean(current?.visible);
+            if (current) {
+                current.updateWorldMatrix(true, false);
+                outline.matrix.copy(current.matrixWorld);
+                fill.matrix.copy(current.matrixWorld);
+                outline.matrixWorld.copy(current.matrixWorld);
+                fill.matrixWorld.copy(current.matrixWorld);
+            }
+            frameId = requestAnimationFrame(sync);
+        };
+        sync();
+        return () => {
+            cancelAnimationFrame(frameId);
+            outline.removeFromParent();
+            fill.removeFromParent();
+            fillGeometry.dispose();
+            fillMaterial.dispose();
+            geometry.dispose();
+            material.dispose();
+        };
+    }, [
+        enabled,
+        wallId,
+        startX,
+        startZ,
+        endX,
+        endZ,
+        curveOffset,
+        thickness,
+        left,
+        right,
+        bottom,
+        top,
+    ]);
+}

package/dist/wall/curtain-wall-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { WallGeometryAdapter } from '@pascal-app/viewer';
+export declare const curtainWallGeometryAdapter: WallGeometryAdapter;
+//# sourceMappingURL=curtain-wall-adapter.d.ts.map

package/dist/wall/curtain-wall-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-adapter.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAW7D,eAAO,MAAM,0BAA0B,EAAE,mBAgDxC,CAAA"}

package/dist/wall/curtain-wall-adapter.js

@@ -0,0 +1,55 @@
+import { useLiveNodeOverrides } from '@pascal-app/core';
+import { buildCurtainWallGeometry } from './curtain-wall-geometry';
+import { buildCurtainWallShadowGeometry, CURTAIN_WALL_SHADOW_NAME } from './curtain-wall-shadow';
+function isOpaque(material) {
+    return material !== undefined && (!material.transparent || material.opacity >= 1);
+}
+const deferredShadowWalls = new Set();
+export const curtainWallGeometryAdapter = {
+    prepareChildren(wall, children, context) {
+        if (wall.wallType !== 'curtain') {
+            return { envelopeChildren: [...children], renderChildren: [...children] };
+        }
+        const renderChildren = children.map((child) => {
+            if ((child.type !== 'door' && child.type !== 'window') || child.openingShape === 'rectangle')
+                return child;
+            const override = useLiveNodeOverrides.getState().get(child.id);
+            const liveBounds = context.isLive(child.id) &&
+                (!override || 'position' in override || 'width' in override || 'height' in override);
+            return liveBounds ? { ...child, openingShape: 'rectangle' } : child;
+        });
+        return {
+            envelopeChildren: renderChildren.filter((child) => child.type !== 'door' && child.type !== 'window'),
+            renderChildren,
+        };
+    },
+    buildGeometry(wall, envelope, children) {
+        if (wall.wallType !== 'curtain')
+            return envelope;
+        const livePreview = children.some((child) => (child.type === 'door' || child.type === 'window') &&
+            useLiveNodeOverrides.getState().get(child.id) !== undefined);
+        const deferShadow = children.some((child) => {
+            if (child.type !== 'door' && child.type !== 'window')
+                return false;
+            const metadata = useLiveNodeOverrides.getState().get(child.id)?.metadata;
+            return metadata?.deferParentRebuild === true;
+        });
+        if (deferShadow)
+            deferredShadowWalls.add(wall.id);
+        else
+            deferredShadowWalls.delete(wall.id);
+        return buildCurtainWallGeometry(wall, envelope, children, livePreview);
+    },
+    syncAuxiliaryGeometry(wall, mesh, geometry) {
+        if (wall.wallType !== 'curtain')
+            return;
+        if (deferredShadowWalls.has(wall.id))
+            return;
+        const shadowMesh = mesh.getObjectByName(CURTAIN_WALL_SHADOW_NAME);
+        if (!shadowMesh)
+            return;
+        const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+        shadowMesh.geometry.dispose();
+        shadowMesh.geometry = buildCurtainWallShadowGeometry(geometry, isOpaque(materials[1]));
+    },
+};

package/dist/wall/curtain-wall-floorplan.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode, type FloorplanGeometry, type WallNode } from '@pascal-app/core';
+export declare function buildCurtainWallFloorplan(wall: WallNode, height: number, stroke: string, children?: readonly AnyNode[]): FloorplanGeometry[];
+//# sourceMappingURL=curtain-wall-floorplan.d.ts.map

package/dist/wall/curtain-wall-floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAKtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,SAAS,OAAO,EAAO,GAChC,iBAAiB,EAAE,CAwFrB"}

package/dist/wall/curtain-wall-floorplan.js

@@ -0,0 +1,91 @@
+import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+import { curtainOpeningProfile, curtainProfileSpan } from './curtain-opening-frame';
+import { buildCurtainWallLayout } from './curtain-wall-layout';
+export function buildCurtainWallFloorplan(wall, height, stroke, children = []) {
+    const length = getWallCurveLength(wall);
+    if (length <= 1e-6)
+        return [];
+    const config = getCurtainWallConfig(wall);
+    const cutHeight = Math.min(1.2, height * 0.5);
+    const openings = children
+        .filter((child) => child.type === 'door' || child.type === 'window')
+        .map((opening) => ({
+        opening,
+        profile: curtainOpeningProfile(opening, config.perimeterWidth),
+        framed: opening.openingShape !== 'rectangle',
+    }));
+    const pieces = buildCurtainWallLayout(length, height, getWallThickness(wall), config, children.filter((child) => child.type === 'door' || child.type === 'window'))
+        .filter((piece) => piece.bottom <= cutHeight && piece.top > cutHeight)
+        .flatMap((piece) => {
+        let runs = [piece];
+        for (const { profile, framed } of openings) {
+            const span = curtainProfileSpan(framed ? profile.outer : profile.inner, cutHeight);
+            if (!span)
+                continue;
+            const [left, right] = span;
+            runs = runs.flatMap((run) => {
+                if (right <= run.left || left >= run.right)
+                    return [run];
+                return [
+                    ...(left > run.left ? [{ ...run, right: left }] : []),
+                    ...(right < run.right ? [{ ...run, left: right }] : []),
+                ];
+            });
+        }
+        return runs;
+    });
+    for (const { profile, framed } of openings) {
+        if (!framed)
+            continue;
+        const outer = curtainProfileSpan(profile.outer, cutHeight);
+        const inner = curtainProfileSpan(profile.inner, cutHeight);
+        if (!outer)
+            continue;
+        const spans = inner
+            ? [
+                [outer[0], inner[0]],
+                [inner[1], outer[1]],
+            ]
+            : [outer];
+        for (const [left, right] of spans) {
+            if (right - left <= 1e-6)
+                continue;
+            pieces.push({
+                left: Math.max(0, left),
+                right: Math.min(length, right),
+                bottom: 0,
+                top: height,
+                front: getWallThickness(wall) / 2,
+                back: -getWallThickness(wall) / 2,
+                role: 'frame',
+            });
+        }
+    }
+    return pieces.map((piece) => {
+        const points = [];
+        for (const offset of [piece.front, piece.back]) {
+            const side = [];
+            for (let i = 0; i <= 8; i++) {
+                const along = piece.left + ((piece.right - piece.left) * i) / 8;
+                const frame = getWallCurveFrameAt(wall, along / length);
+                side.push([
+                    frame.point.x + frame.normal.x * offset,
+                    frame.point.y + frame.normal.y * offset,
+                ]);
+            }
+            points.push(...(offset === piece.front ? side : side.reverse()));
+        }
+        return {
+            kind: 'polygon',
+            points,
+            fill: piece.role === 'glass'
+                ? config.glassColor
+                : piece.role === 'frame'
+                    ? config.frameColor
+                    : config.solidColor,
+            stroke,
+            strokeWidth: 0.008,
+            pointerEvents: 'none',
+        };
+    });
+}

package/dist/wall/curtain-wall-geometry.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNode, type WallNode } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+export declare function buildCurtainWallGeometry(wall: WallNode, envelope: BufferGeometry, children?: readonly AnyNode[], livePreview?: boolean): BufferGeometry;
+//# sourceMappingURL=curtain-wall-geometry.d.ts.map

package/dist/wall/curtain-wall-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-geometry.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMZ,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,cAAc,EAA0B,MAAM,OAAO,CAAA;AAkD9D,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,cAAc,EACxB,QAAQ,GAAE,SAAS,OAAO,EAAO,EACjC,WAAW,UAAQ,GAClB,cAAc,CA+MhB"}

package/dist/wall/curtain-wall-geometry.js

@@ -0,0 +1,226 @@
+import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, getWallThickness, isCurvedWall, } from '@pascal-app/core';
+import { Brush, Evaluator, ensureRenderableGeometryAttributes, INTERSECTION, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
+import { BufferGeometry, ExtrudeGeometry, Shape } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { buildCurtainOpeningFrame, mapCurtainOpeningGeometryToWall } from './curtain-opening-frame';
+import { buildCurtainWallLayout, curtainGridPositions, } from './curtain-wall-layout';
+import { buildStraightCurtainPieces, buildStraightCurtainPiecesWithCutouts, } from './curtain-wall-piece-geometry';
+function pieceGeometry(wall, piece, length, base) {
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const cos = Math.cos(angle), sin = Math.sin(angle);
+    const samples = isCurvedWall(wall)
+        ? Math.max(1, Math.ceil(((piece.right - piece.left) / length) * 48))
+        : 1;
+    const points = [];
+    for (const offset of [piece.front, piece.back]) {
+        const side = [];
+        for (let i = 0; i <= samples; i++) {
+            const along = piece.left + ((piece.right - piece.left) * i) / samples;
+            if (!isCurvedWall(wall)) {
+                side.push([along, -offset]);
+                continue;
+            }
+            const frame = getWallCurveFrameAt(wall, along / length);
+            const x = frame.point.x + frame.normal.x * offset - wall.start[0];
+            const z = frame.point.y + frame.normal.y * offset - wall.start[1];
+            side.push([x * cos + z * sin, -(-x * sin + z * cos)]);
+        }
+        points.push(...(offset === piece.front ? side : side.reverse()));
+    }
+    const shape = new Shape();
+    shape.moveTo(...points[0]);
+    for (const point of points.slice(1))
+        shape.lineTo(...point);
+    shape.closePath();
+    const geometry = new ExtrudeGeometry(shape, {
+        depth: piece.top - piece.bottom,
+        bevelEnabled: false,
+    });
+    geometry.rotateX(-Math.PI / 2);
+    geometry.translate(0, base + piece.bottom, 0);
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}
+export function buildCurtainWallGeometry(wall, envelope, children = [], livePreview = false) {
+    const length = getWallCurveLength(wall);
+    envelope.computeBoundingBox();
+    const bounds = envelope.boundingBox;
+    if (!bounds || bounds.isEmpty() || length <= 1e-6)
+        return envelope;
+    const pieces = buildCurtainWallLayout(length, bounds.max.y - bounds.min.y, getWallThickness(wall), getCurtainWallConfig(wall), children.filter((child) => child.type === 'door' || child.type === 'window'), bounds.min.y);
+    const shapedFrames = children
+        .filter((child) => (child.type === 'window' || child.type === 'door') && child.openingShape !== 'rectangle')
+        .map((opening) => {
+        const geometry = buildCurtainOpeningFrame(opening, getCurtainWallConfig(wall).perimeterWidth, getWallThickness(wall));
+        mapCurtainOpeningGeometryToWall(geometry.frame, wall);
+        mapCurtainOpeningGeometryToWall(geometry.cutter, wall);
+        return geometry;
+    });
+    const hasRectangularOpenings = children.some((child) => (child.type === 'window' || child.type === 'door') && child.openingShape === 'rectangle');
+    const evaluator = new Evaluator();
+    evaluator.attributes = ['position', 'normal', 'uv', 'uv2'];
+    evaluator.useGroups = false;
+    const shell = new Brush(envelope);
+    const position = envelope.getAttribute('position');
+    const near = (a, b) => Math.abs(a - b) < 1e-6;
+    const halfDepth = getWallThickness(wall) / 2;
+    const rectangular = !isCurvedWall(wall) &&
+        Array.from({ length: position.count }, (_, i) => i).every((i) => (near(position.getX(i), 0) || near(position.getX(i), length)) &&
+            (near(position.getY(i), bounds.min.y) || near(position.getY(i), bounds.max.y)) &&
+            (near(position.getZ(i), -halfDepth) || near(position.getZ(i), halfDepth)));
+    if (rectangular) {
+        for (const { frame } of shapedFrames) {
+            const framePosition = frame.getAttribute('position');
+            for (let index = 0; index < framePosition.count; index++) {
+                framePosition.setX(index, Math.max(bounds.min.x, Math.min(bounds.max.x, framePosition.getX(index))));
+                framePosition.setY(index, Math.max(bounds.min.y, Math.min(bounds.max.y, framePosition.getY(index))));
+            }
+            framePosition.needsUpdate = true;
+            frame.computeVertexNormals();
+        }
+    }
+    if (!rectangular)
+        prepareBrushForCSG(shell);
+    const leftEnvelopeXs = [];
+    const rightEnvelopeXs = [];
+    if (!rectangular && !isCurvedWall(wall)) {
+        for (let index = 0; index < position.count; index++) {
+            const x = position.getX(index);
+            (x < length / 2 ? leftEnvelopeXs : rightEnvelopeXs).push(x);
+        }
+    }
+    const safeLeft = leftEnvelopeXs.length ? Math.max(...leftEnvelopeXs) : 0;
+    const safeRight = rightEnvelopeXs.length ? Math.min(...rightEnvelopeXs) : length;
+    const xs = curtainGridPositions(length, getCurtainWallConfig(wall).columns);
+    const ys = curtainGridPositions(bounds.max.y - bounds.min.y, getCurtainWallConfig(wall).rows);
+    const cutRegions = shapedFrames.map(({ cutter }) => {
+        cutter.computeBoundingBox();
+        const box = cutter.boundingBox;
+        // Keep every fragment of a pane in the same partition to avoid new glass seams.
+        const lower = (positions, value) => [...positions].reverse().find((p) => p <= value) ?? positions[0];
+        const upper = (positions, value) => positions.find((p) => p >= value) ?? positions.at(-1);
+        return {
+            left: lower(xs, box.min.x),
+            right: upper(xs, box.max.x),
+            bottom: lower(ys, box.min.y - bounds.min.y),
+            top: upper(ys, box.max.y - bounds.min.y),
+        };
+    });
+    const results = [];
+    const roles = ['frame', 'glass', 'solid'];
+    try {
+        for (const [materialIndex, role] of roles.entries()) {
+            const allRolePieces = pieces.filter((piece) => piece.role === role);
+            const nearCut = (piece) => isCurvedWall(wall) ||
+                (!rectangular && (piece.left < safeLeft - 1e-6 || piece.right > safeRight + 1e-6)) ||
+                cutRegions.some((region) => piece.left < region.right &&
+                    piece.right > region.left &&
+                    piece.bottom < region.top &&
+                    piece.top > region.bottom);
+            const partitionPieces = !rectangular || cutRegions.length > 0;
+            const rolePieces = allRolePieces.filter(nearCut);
+            const untouchedPieces = partitionPieces
+                ? allRolePieces.filter((piece) => !nearCut(piece))
+                : [];
+            const builtPieces = partitionPieces ? rolePieces : allRolePieces;
+            if (!allRolePieces.length && !(role === 'frame' && shapedFrames.length))
+                continue;
+            let merged = null;
+            if (!isCurvedWall(wall) && builtPieces.length) {
+                const straightPieces = builtPieces.map((piece) => ({
+                    ...piece,
+                    left: piece.left === 0 ? Math.min(0, bounds.min.x) : piece.left,
+                    right: piece.right === length ? Math.max(length, bounds.max.x) : piece.right,
+                }));
+                merged =
+                    rectangular && shapedFrames.length
+                        ? buildStraightCurtainPiecesWithCutouts(straightPieces, bounds.min.y, shapedFrames.map(({ cutout }) => cutout))
+                        : buildStraightCurtainPieces(straightPieces, bounds.min.y, livePreview ? false : hasRectangularOpenings || shapedFrames.length > 0);
+            }
+            else if (builtPieces.length) {
+                const sources = rolePieces.map((piece) => pieceGeometry(wall, piece, length, bounds.min.y));
+                merged = mergeGeometries(sources, false);
+                for (const source of sources)
+                    source.dispose();
+            }
+            if (merged && !rectangular) {
+                for (const opening of shapedFrames) {
+                    if (!merged.getAttribute('position').count)
+                        break;
+                    const brush = new Brush(merged);
+                    const cutter = new Brush(opening.cutter);
+                    prepareBrushForCSG(brush);
+                    prepareBrushForCSG(cutter);
+                    const cut = evaluator.evaluate(brush, cutter, SUBTRACTION).geometry;
+                    merged.dispose();
+                    merged = cut.index ? cut.toNonIndexed() : cut;
+                    if (merged !== cut)
+                        cut.dispose();
+                }
+            }
+            if (role === 'frame' && shapedFrames.length) {
+                const frames = shapedFrames.map(({ frame }) => frame);
+                const combined = mergeGeometries(merged ? [merged, ...frames] : frames, false);
+                merged?.dispose();
+                if (!combined)
+                    continue;
+                merged = combined;
+            }
+            if (merged && !rectangular) {
+                const brush = new Brush(merged);
+                prepareBrushForCSG(brush);
+                try {
+                    // The existing wall envelope owns miter joins, support profiles, and all hosted cuts.
+                    const clipped = evaluator.evaluate(brush, shell, INTERSECTION).geometry;
+                    const geometry = clipped.index ? clipped.toNonIndexed() : clipped;
+                    if (geometry !== clipped)
+                        clipped.dispose();
+                    merged.dispose();
+                    merged = geometry;
+                }
+                catch (error) {
+                    merged.dispose();
+                    throw error;
+                }
+            }
+            if (untouchedPieces.length) {
+                const untouched = buildStraightCurtainPieces(untouchedPieces, bounds.min.y, false);
+                if (merged) {
+                    const combined = mergeGeometries([merged, untouched], false);
+                    untouched.dispose();
+                    merged.dispose();
+                    if (!combined)
+                        continue;
+                    merged = combined;
+                }
+                else {
+                    merged = untouched;
+                }
+            }
+            if (!merged)
+                continue;
+            merged.clearGroups();
+            merged.addGroup(0, merged.getAttribute('position').count, materialIndex);
+            results.push(merged);
+        }
+        if (!results.length)
+            return new BufferGeometry();
+        const combined = mergeGeometries(results, false) ?? new BufferGeometry();
+        let start = 0;
+        for (const result of results) {
+            const count = result.getAttribute('position').count;
+            combined.addGroup(start, count, result.groups[0].materialIndex);
+            start += count;
+        }
+        return combined;
+    }
+    finally {
+        for (const opening of shapedFrames) {
+            opening.frame.dispose();
+            opening.cutter.dispose();
+        }
+        envelope.dispose();
+        for (const result of results)
+            result.dispose();
+    }
+}

package/dist/wall/curtain-wall-layout.d.ts

@@ -0,0 +1,16 @@
+import type { CurtainGrid, CurtainPanelType, CurtainWallConfig, DoorNode } from '@pascal-app/core';
+export declare function curtainGridPositions(length: number, grid: CurtainGrid): number[];
+export type CurtainWallPiece = {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+    front: number;
+    back: number;
+    role: 'frame' | 'glass' | 'solid';
+};
+export declare function curtainPanelType(config: CurtainWallConfig, column: number, row: number, rowCount: number): CurtainPanelType;
+export declare function buildCurtainWallLayout(length: number, height: number, depth: number, config: CurtainWallConfig, openings?: readonly (Pick<DoorNode, 'position' | 'width' | 'height' | 'openingShape'> & {
+    type: 'door' | 'window';
+})[], baseElevation?: number): CurtainWallPiece[];
+//# sourceMappingURL=curtain-wall-layout.d.ts.map

package/dist/wall/curtain-wall-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-layout.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAElG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAqBhF;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;CAClC,CAAA;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf,gBAAgB,CASlB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,EACzB,QAAQ,GAAE,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,CAAC,GAAG;IACrF,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CACxB,CAAC,EAAO,EACT,aAAa,SAAI,GAChB,gBAAgB,EAAE,CAqMpB"}