@pascal-app/nodes 1.0.0 → 1.0.3

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

@@ -0,0 +1,167 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { getCurtainWallConfig, getEffectiveNode, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+import { getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, SegmentedControl, SliderControl, ToggleControl, } from '@pascal-app/editor';
+import { useState } from 'react';
+import { useCurtainPanelHighlight } from './curtain-panel-highlight';
+import { curtainGridPositions, curtainPanelType } from './curtain-wall-layout';
+function Choice({ label, value, options, onChange, }) {
+    return (_jsxs("label", { className: "flex items-center justify-between gap-2 text-xs text-muted-foreground", children: [label, _jsx("select", { "aria-label": label, className: "max-w-[160px] rounded-md border border-border bg-background px-2 py-1.5 text-foreground", onChange: (event) => {
+                    const option = options.find((entry) => entry.value === event.target.value);
+                    if (option)
+                        onChange(option.value);
+                }, value: value, children: options.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) })] }));
+}
+function LengthControl({ label, value, min, max, unit, onChange, onCommit, onCancel, profile = false, }) {
+    const millimeters = profile && unit === 'metric';
+    const display = (meters) => millimeters ? meters * 1000 : metersToLinearUnit(meters, unit);
+    return (_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: label, max: display(max), min: display(min), onChange: (next) => onChange(millimeters
+            ? Math.max(min, Math.min(max, next / 1000))
+            : linearControlValueToMeters(next, unit, { minMeters: min, maxMeters: max })), precision: millimeters ? 1 : 3, step: millimeters ? 1 : 0.005, unit: millimeters ? 'mm' : getLinearUnitLabel(unit), value: display(value) }));
+}
+function GridSection({ length, vertical = false, onPreview, title, value, unit, onChange, onCommit, onCancel, }) {
+    return (_jsxs(PanelSection, { title: title, children: [_jsx(Choice, { label: "Layout", onChange: (layout) => onChange({ ...value, layout }), options: [
+                    { label: 'Panel count', value: 'count' },
+                    { label: 'Maximum spacing', value: 'maximum-spacing' },
+                    { label: 'Fixed spacing', value: 'fixed-spacing' },
+                ], value: value.layout }), value.layout === 'count' ? (_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Panels", max: 32, min: 1, onChange: (count) => onPreview({ ...value, count: Math.round(count) }), precision: 0, step: 1, value: value.count })) : (_jsx(LengthControl, { onCommit: onCommit, onCancel: onCancel, label: "Spacing", max: 100, min: 0.2, onChange: (spacing) => onPreview({ ...value, spacing }), unit: unit, value: value.spacing })), value.layout === 'fixed-spacing' && (_jsx(SegmentedControl, { onChange: (alignment) => onChange({ ...value, alignment }), options: [
+                    { label: vertical ? 'Bottom' : 'Start', value: 'start' },
+                    { label: 'Center', value: 'center' },
+                    { label: vertical ? 'Top' : 'End', value: 'end' },
+                ], value: value.alignment })), _jsx("p", { className: "text-[11px] text-muted-foreground", children: (() => {
+                    const positions = curtainGridPositions(length, value);
+                    const spans = positions.slice(1).map((position, i) => position - positions[i]);
+                    if (!spans.length)
+                        return 'No panels';
+                    const min = metersToLinearUnit(Math.min(...spans), unit);
+                    const max = metersToLinearUnit(Math.max(...spans), unit);
+                    return `${spans.length} ${vertical ? 'rows' : 'columns'} · ${min.toFixed(2)}${max - min > 0.005 ? `–${max.toFixed(2)}` : ''} ${getLinearUnitLabel(unit)} grid spacing`;
+                })() })] }));
+}
+const PANEL_OPTIONS = [
+    { label: 'Glass', value: 'glass' },
+    { label: 'Solid', value: 'solid' },
+    { label: 'Empty', value: 'empty' },
+];
+export function getCurtainWallUpdate(node, patch) {
+    return {
+        curtainWall: { ...getCurtainWallConfig(getEffectiveNode(node)), ...patch },
+    };
+}
+export function CurtainWallPanel({ node, height, unit, onUpdate, onPreview, onCommit, onCancel, }) {
+    const config = getCurtainWallConfig(node);
+    const update = (patch, preview = false) => {
+        ;
+        (preview ? onPreview : onUpdate)(getCurtainWallUpdate(node, patch));
+    };
+    const [tintEditing, setTintEditing] = useState(false);
+    const [panelEditing, setPanelEditing] = useState(false);
+    const [selectedColumn, setColumn] = useState(0);
+    const [selectedRow, setRow] = useState(0);
+    const columnCount = curtainGridPositions(getWallCurveLength(node), config.columns).length - 1;
+    const rowCount = curtainGridPositions(height, config.rows).length - 1;
+    const column = Math.max(0, Math.min(selectedColumn, columnCount - 1));
+    const row = Math.max(0, Math.min(selectedRow, rowCount - 1));
+    const selectedType = curtainPanelType(config, column, row, rowCount);
+    const changePanel = (type) => update({
+        panels: [
+            ...config.panels.filter((panel) => panel.column !== column || panel.row !== row),
+            ...(type ? [{ column, row, type }] : []),
+        ],
+    });
+    const hiddenOverrides = config.panels.filter((panel) => panel.column >= columnCount || panel.row >= rowCount);
+    const diagramWidth = Math.max(240, columnCount * 32);
+    const diagramHeight = Math.max(150, rowCount * 32);
+    const overridden = config.panels.some((panel) => panel.column === column && panel.row === row);
+    const xs = curtainGridPositions(getWallCurveLength(node), config.columns);
+    const ys = curtainGridPositions(height, config.rows);
+    useCurtainPanelHighlight(node, xs[column] ?? 0, xs[column + 1] ?? 0, ys[row] ?? 0, ys[row + 1] ?? 0, panelEditing);
+    const hasGlass = xs
+        .slice(1)
+        .some((_, c) => ys.slice(1).some((_, r) => curtainPanelType(config, c, r, rowCount) === 'glass'));
+    const paintedGlass = Boolean(node.slots?.['curtain-glass']);
+    const effectiveThickness = Math.min(config.glassThickness, getWallThickness(node) * 0.45);
+    return (_jsxs(_Fragment, { children: [_jsxs(PanelSection, { title: "Wall system", children: [_jsx(Choice, { label: "Construction", onChange: (construction) => update({ construction }), options: [
+                            { label: 'Stick-built', value: 'stick' },
+                            { label: 'Unitized', value: 'unitized' },
+                        ], value: config.construction }), _jsx(Choice, { label: "Framing", onChange: (framing) => update({ framing }), options: [
+                            { label: 'Fully capped', value: 'capped' },
+                            { label: 'Vertical caps', value: 'vertical-caps' },
+                            { label: 'Horizontal caps', value: 'horizontal-caps' },
+                            { label: 'Structural glazing', value: 'structural-glazing' },
+                        ], value: config.framing }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: config.construction === 'unitized'
+                            ? 'Separate framed modules with joints between units.'
+                            : 'Continuous mullions and transoms assembled along the wall.' }), config.framing !== 'capped' && (_jsx("p", { className: "text-[11px] text-muted-foreground", children: "Uncapped members sit behind the glazing." }))] }), _jsx(GridSection, { onChange: (columns) => update({ columns }), onPreview: (columns) => update({ columns }, true), onCommit: onCommit, onCancel: onCancel, title: "Column layout", length: getWallCurveLength(node), unit: unit, value: config.columns }), _jsx(GridSection, { onChange: (rows) => update({ rows }), onPreview: (rows) => update({ rows }, true), onCommit: onCommit, onCancel: onCancel, title: "Row layout", length: height, vertical: true, unit: unit, value: config.rows }), ((getWallCurveLength(node) / config.columns.spacing > 32 &&
+                config.columns.layout !== 'count') ||
+                (height / config.rows.spacing > 32 && config.rows.layout !== 'count')) && (_jsx("p", { className: "px-3 text-[11px] text-muted-foreground", children: "Grid limited to 32 panels per axis. Spacing expands to fit this wall." })), _jsxs(PanelSection, { title: "Frame dimensions", children: [_jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Vertical frame width", max: 0.3, min: 0.01, onChange: (mullionWidth) => update({ mullionWidth }, true), unit: unit, value: config.mullionWidth }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Horizontal frame width", max: 0.3, min: 0.01, onChange: (transomWidth) => update({ transomWidth }, true), unit: unit, value: config.transomWidth }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Border / opening frame", max: 0.3, min: 0.01, onChange: (perimeterWidth) => update({ perimeterWidth }, true), unit: unit, value: config.perimeterWidth }), (config.construction === 'unitized' || config.framing !== 'capped') && (_jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: config.construction === 'unitized' ? 'Module joint width' : 'Glazing gap', max: 0.05, min: 0.002, onChange: (jointWidth) => update({ jointWidth }, true), unit: unit, value: config.jointWidth }))] }), _jsxs(PanelSection, { title: "Panel infill", children: [_jsx(Choice, { label: "Default panel", onChange: (panelType) => update({ panelType }), options: PANEL_OPTIONS, value: config.panelType }), _jsx(Choice, { label: "Opaque band", onChange: (spandrel) => update({ spandrel }), options: [
+                            { label: 'None', value: 'none' },
+                            { label: 'Bottom row', value: 'bottom' },
+                            { label: 'Top row', value: 'top' },
+                        ], value: config.spandrel }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Opaque bands replace a full row with solid panels. Apply their finish with the paint tool." }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Panel thickness", max: 0.08, min: 0.004, onChange: (glassThickness) => update({ glassThickness }, true), unit: unit, value: config.glassThickness }), effectiveThickness < config.glassThickness - 1e-6 && (_jsxs("p", { className: "text-[11px] text-muted-foreground", children: ["Effective thickness:", ' ', unit === 'metric'
+                                ? `${(effectiveThickness * 1000).toFixed(1)} mm`
+                                : `${metersToLinearUnit(effectiveThickness, unit).toFixed(3)} ${getLinearUnitLabel(unit)}`, ", limited by frame depth."] }))] }), _jsxs(PanelSection, { title: "Edit individual panels", children: [_jsx(ToggleControl, { checked: panelEditing, label: "Enable panel editing", onChange: setPanelEditing }), panelEditing && (_jsxs(_Fragment, { children: [_jsx("p", { className: "text-[11px] text-muted-foreground", children: "Choose a cell or enter its column and row. Use arrow keys to move between cells. Columns run from the wall start; rows count upward." }), _jsx("div", { className: "max-h-64 overflow-auto rounded border border-border", children: _jsx("svg", { viewBox: `0 0 ${diagramWidth} ${diagramHeight}`, style: { width: diagramWidth, height: diagramHeight }, className: "block", role: "group", "aria-label": "Curtain wall panel selection", children: xs.slice(1).flatMap((_, c) => ys.slice(1).map((_, r) => {
+                                        const type = curtainPanelType(config, c, r, rowCount);
+                                        const selected = c === column && r === row;
+                                        return (_jsx("rect", { role: "button", tabIndex: selected ? 0 : -1, "aria-label": `Column ${c + 1}, row ${r + 1}: ${type}`, "aria-pressed": selected, "data-cell": `${c}-${r}`, x: (c / columnCount) * diagramWidth, y: diagramHeight - ((r + 1) / rowCount) * diagramHeight, width: diagramWidth / columnCount, height: diagramHeight / rowCount, fill: type === 'glass'
+                                                ? '#53788a'
+                                                : type === 'solid'
+                                                    ? '#64748b'
+                                                    : 'transparent', stroke: selected ? '#fb923c' : '#94a3b8', strokeWidth: selected ? 3 : 1, className: "cursor-pointer focus:stroke-orange-400 focus:stroke-[3]", onClick: () => {
+                                                setColumn(c);
+                                                setRow(r);
+                                            }, onKeyDown: (event) => {
+                                                const arrows = {
+                                                    ArrowLeft: [-1, 0],
+                                                    ArrowRight: [1, 0],
+                                                    ArrowUp: [0, 1],
+                                                    ArrowDown: [0, -1],
+                                                };
+                                                const delta = arrows[event.key];
+                                                if (delta) {
+                                                    event.preventDefault();
+                                                    const nextColumn = Math.max(0, Math.min(columnCount - 1, c + delta[0]));
+                                                    const nextRow = Math.max(0, Math.min(rowCount - 1, r + delta[1]));
+                                                    setColumn(nextColumn);
+                                                    setRow(nextRow);
+                                                    const target = event.currentTarget.parentElement?.querySelector(`[data-cell="${nextColumn}-${nextRow}"]`);
+                                                    target?.focus();
+                                                    target?.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                                                }
+                                                if (event.key === 'Enter' || event.key === ' ') {
+                                                    event.preventDefault();
+                                                    setColumn(c);
+                                                    setRow(r);
+                                                }
+                                            } }, `${c}-${r}`));
+                                    })) }) }), hiddenOverrides.length > 0 && (_jsxs("div", { className: "space-y-2 text-[11px] text-muted-foreground", children: [_jsxs("p", { children: [hiddenOverrides.length, " custom panels are outside this grid. They return if the grid expands."] }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => update({
+                                            panels: config.panels.filter((panel) => panel.column < columnCount && panel.row < rowCount),
+                                        }), children: "Clear hidden overrides" })] })), _jsxs("p", { className: "text-[11px] text-muted-foreground", children: ["Column ", column + 1, ", row ", row + 1, " \u00B7", ' ', overridden ? 'Custom infill' : 'Following wall defaults'] }), _jsx(SliderControl, { label: "Column", max: Math.max(1, columnCount), min: 1, onChange: (value) => setColumn(Math.round(value) - 1), precision: 0, step: 1, value: column + 1 }), _jsx(SliderControl, { label: "Row", max: Math.max(1, rowCount), min: 1, onChange: (value) => setRow(Math.round(value) - 1), precision: 0, step: 1, value: row + 1 }), _jsx(Choice, { label: "Panel infill", onChange: changePanel, options: PANEL_OPTIONS, value: selectedType }), _jsx("button", { className: "rounded border border-border px-2 py-1 text-xs disabled:cursor-default disabled:opacity-40", disabled: !overridden, onClick: () => changePanel(), type: "button", children: "Reset this panel" }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Use the Door or Window tool to add an opening through the wall." })] }))] }), hasGlass && (_jsxs(PanelSection, { title: "Glass appearance", children: [paintedGlass && (_jsxs("div", { className: "space-y-2 text-xs text-muted-foreground", children: [_jsx("p", { children: "Glass appearance is controlled by the paint tool." }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1", onClick: () => {
+                                    onCommit();
+                                    const slots = { ...node.slots };
+                                    delete slots['curtain-glass'];
+                                    onUpdate({ slots });
+                                }, children: "Use glass settings instead" })] })), !paintedGlass && (_jsxs("div", { className: "space-y-2", children: [_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Opacity", max: 100, min: 5, onChange: (value) => update({ glassOpacity: value / 100 }, true), precision: 0, step: 5, unit: "%", value: Math.round(config.glassOpacity * 100) }), _jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Surface roughness", max: 1, min: 0, onChange: (glassRoughness) => update({ glassRoughness }, true), precision: 2, step: 0.05, value: config.glassRoughness }), _jsxs("label", { className: "flex items-center justify-between text-xs text-muted-foreground", children: ["Glass tint", _jsx("input", { "aria-label": "Glass tint", className: "h-7 w-10 cursor-pointer rounded border border-border bg-transparent", onKeyDown: (event) => {
+                                            if (event.key === 'Escape') {
+                                                event.preventDefault();
+                                                onCancel();
+                                                setTintEditing(false);
+                                            }
+                                        }, onChange: (event) => {
+                                            setTintEditing(true);
+                                            update({ glassColor: event.target.value }, true);
+                                        }, onBlur: () => {
+                                            if (!tintEditing)
+                                                return;
+                                            onCommit();
+                                            setTintEditing(false);
+                                        }, onInput: (event) => {
+                                            setTintEditing(true);
+                                            update({ glassColor: event.currentTarget.value }, true);
+                                        }, type: "color", value: config.glassColor })] }), tintEditing && (_jsxs("div", { className: "flex gap-2", children: [_jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => {
+                                            onCommit();
+                                            setTintEditing(false);
+                                        }, children: "Apply tint" }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => {
+                                            onCancel();
+                                            setTintEditing(false);
+                                        }, children: "Cancel tint" })] })), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Low roughness is smooth; high roughness gives a matte surface in rendered shading." })] }))] }))] }));
+}

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

@@ -0,0 +1,5 @@
+import { BufferGeometry, Vector2 } from 'three';
+import type { CurtainWallPiece } from './curtain-wall-layout';
+export declare function buildStraightCurtainPiecesWithCutouts(pieces: readonly CurtainWallPiece[], base: number, cutouts: readonly (readonly Vector2[])[]): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function buildStraightCurtainPieces(pieces: readonly CurtainWallPiece[], base: number, cullSharedFaces?: boolean): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+//# sourceMappingURL=curtain-wall-piece-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-piece-geometry.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-piece-geometry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAsC,OAAO,EAAE,MAAM,OAAO,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAI7D,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,kGA+GzC;AAGD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,eAAe,UAAO,kGA0HvB"}

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

@@ -0,0 +1,220 @@
+import { subtractPolygonsFromPolygon } from '@pascal-app/core';
+import { ensureRenderableGeometryAttributes } from '@pascal-app/viewer';
+import { BufferGeometry, Float32BufferAttribute, ShapeUtils, Vector2 } from 'three';
+export function buildStraightCurtainPiecesWithCutouts(pieces, base, cutouts) {
+    const positions = [];
+    const normals = [];
+    const preparedCutouts = cutouts.map((cutout) => {
+        const points = cutout.map((point) => [point.x, point.y]);
+        const xs = points.map(([x]) => x);
+        const ys = points.map(([, y]) => y);
+        return {
+            points,
+            minX: Math.min(...xs),
+            maxX: Math.max(...xs),
+            minY: Math.min(...ys),
+            maxY: Math.max(...ys),
+        };
+    });
+    const vertex = (point, normal) => {
+        positions.push(point[0], point[1], point[2]);
+        normals.push(normal[0], normal[1], normal[2]);
+    };
+    const contains = (ring, point) => {
+        let inside = false;
+        for (let index = 0, previous = ring.length - 1; index < ring.length; previous = index++) {
+            const a = ring[index];
+            const b = ring[previous];
+            if (a[1] > point[1] !== b[1] > point[1] &&
+                point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0]) {
+                inside = !inside;
+            }
+        }
+        return inside;
+    };
+    const area = (ring) => Math.abs(ring.reduce((sum, point, index) => {
+        const next = ring[(index + 1) % ring.length];
+        return sum + point[0] * next[1] - next[0] * point[1];
+    }, 0) / 2);
+    for (const piece of pieces) {
+        const bottom = piece.bottom + base;
+        const top = piece.top + base;
+        const overlapping = preparedCutouts.filter((cutout) => cutout.maxX > piece.left &&
+            cutout.minX < piece.right &&
+            cutout.maxY > bottom &&
+            cutout.minY < top);
+        const subject = [
+            [piece.left, bottom],
+            [piece.right, bottom],
+            [piece.right, top],
+            [piece.left, top],
+        ];
+        const rings = subtractPolygonsFromPolygon(subject, overlapping.map(({ points }) => points)).sort((a, b) => area(b) - area(a));
+        const groups = [];
+        for (const ring of rings) {
+            const parent = groups.find(({ contour }) => contains(contour, ring[0]));
+            if (parent)
+                parent.holes.push([...ring].reverse());
+            else
+                groups.push({ contour: ring, holes: [] });
+        }
+        for (const { contour, holes } of groups) {
+            const flattened = [contour, ...holes].flat();
+            const triangles = ShapeUtils.triangulateShape(contour.map(([x, y]) => new Vector2(x, y)), holes.map((hole) => hole.map(([x, y]) => new Vector2(x, y))));
+            for (const triangle of triangles) {
+                const aIndex = triangle[0];
+                const bIndex = triangle[1];
+                const cIndex = triangle[2];
+                const a = flattened[aIndex];
+                const b = flattened[bIndex];
+                const c = flattened[cIndex];
+                vertex([a[0], a[1], piece.front], [0, 0, 1]);
+                vertex([b[0], b[1], piece.front], [0, 0, 1]);
+                vertex([c[0], c[1], piece.front], [0, 0, 1]);
+                vertex([c[0], c[1], piece.back], [0, 0, -1]);
+                vertex([b[0], b[1], piece.back], [0, 0, -1]);
+                vertex([a[0], a[1], piece.back], [0, 0, -1]);
+            }
+            for (const ring of [contour, ...holes]) {
+                for (let index = 0; index < ring.length; index++) {
+                    const a = ring[index];
+                    const b = ring[(index + 1) % ring.length];
+                    const dx = b[0] - a[0];
+                    const dy = b[1] - a[1];
+                    const length = Math.hypot(dx, dy);
+                    if (length <= 1e-6)
+                        continue;
+                    const normal = [dy / length, -dx / length, 0];
+                    vertex([a[0], a[1], piece.back], normal);
+                    vertex([b[0], b[1], piece.back], normal);
+                    vertex([b[0], b[1], piece.front], normal);
+                    vertex([a[0], a[1], piece.back], normal);
+                    vertex([b[0], b[1], piece.front], normal);
+                    vertex([a[0], a[1], piece.front], normal);
+                }
+            }
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}
+// Adjacent fragments of one pane share a boundary, not a second glass surface.
+export function buildStraightCurtainPieces(pieces, base, cullSharedFaces = true) {
+    if (!cullSharedFaces) {
+        const valuesPerPiece = 6 * 6 * 3;
+        const positions = new Float32Array(pieces.length * valuesPerPiece);
+        const normals = new Float32Array(pieces.length * valuesPerPiece);
+        let offset = 0;
+        const vertex = (point, normal) => {
+            positions[offset] = point[0];
+            normals[offset++] = normal[0];
+            positions[offset] = point[1];
+            normals[offset++] = normal[1];
+            positions[offset] = point[2];
+            normals[offset++] = normal[2];
+        };
+        const quad = (a, b, c, d, normal) => {
+            vertex(a, normal);
+            vertex(b, normal);
+            vertex(c, normal);
+            vertex(a, normal);
+            vertex(c, normal);
+            vertex(d, normal);
+        };
+        for (const piece of pieces) {
+            const { left: l, right: r, bottom, top, front: f, back: k } = piece;
+            const b = bottom + base;
+            const t = top + base;
+            quad([l, b, f], [r, b, f], [r, t, f], [l, t, f], [0, 0, 1]);
+            quad([r, b, k], [l, b, k], [l, t, k], [r, t, k], [0, 0, -1]);
+            quad([l, b, k], [l, b, f], [l, t, f], [l, t, k], [-1, 0, 0]);
+            quad([r, b, f], [r, b, k], [r, t, k], [r, t, f], [1, 0, 0]);
+            quad([l, b, k], [r, b, k], [r, b, f], [l, b, f], [0, -1, 0]);
+            quad([l, t, f], [r, t, f], [r, t, k], [l, t, k], [0, 1, 0]);
+        }
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+        geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+        ensureRenderableGeometryAttributes(geometry);
+        return geometry;
+    }
+    const positions = new Float32Array(pieces.length * 6 * 6 * 3);
+    const normals = new Float32Array(positions.length);
+    let offset = 0;
+    const vertex = (point, normal) => {
+        positions[offset] = point[0];
+        normals[offset++] = normal[0];
+        positions[offset] = point[1];
+        normals[offset++] = normal[1];
+        positions[offset] = point[2];
+        normals[offset++] = normal[2];
+    };
+    const quad = (a, b, c, d, normal) => {
+        vertex(a, normal);
+        vertex(b, normal);
+        vertex(c, normal);
+        vertex(a, normal);
+        vertex(c, normal);
+        vertex(d, normal);
+    };
+    const sides = ['left', 'right', 'bottom', 'top'];
+    const key = (piece, side, coordinate = piece[side]) => `${side}:${coordinate.toFixed(7)}:${piece.front.toFixed(7)}:${piece.back.toFixed(7)}`;
+    const edges = new Map();
+    if (cullSharedFaces) {
+        for (const piece of pieces) {
+            for (const side of sides) {
+                const id = key(piece, side);
+                const neighbors = edges.get(id) ?? [];
+                neighbors.push(piece);
+                edges.set(id, neighbors);
+            }
+        }
+    }
+    for (const piece of pieces) {
+        const { left: l, right: r, bottom, top, front: f, back: k } = piece;
+        const b = bottom + base;
+        const t = top + base;
+        quad([l, b, f], [r, b, f], [r, t, f], [l, t, f], [0, 0, 1]);
+        quad([r, b, k], [l, b, k], [l, t, k], [r, t, k], [0, 0, -1]);
+        for (const side of sides) {
+            const vertical = side === 'left' || side === 'right';
+            let runs = vertical ? [[bottom, top]] : [[l, r]];
+            const opposite = side === 'left' ? 'right' : side === 'right' ? 'left' : side === 'bottom' ? 'top' : 'bottom';
+            if (cullSharedFaces) {
+                for (const other of edges.get(key(piece, opposite, piece[side])) ?? []) {
+                    if (other === piece)
+                        continue;
+                    const low = vertical ? other.bottom : other.left;
+                    const high = vertical ? other.top : other.right;
+                    runs = runs.flatMap(([start, end]) => high <= start || low >= end
+                        ? [[start, end]]
+                        : [
+                            ...(low > start ? [[start, low]] : []),
+                            ...(high < end ? [[high, end]] : []),
+                        ]);
+                }
+            }
+            for (const [start, end] of runs) {
+                if (vertical) {
+                    const y0 = start + base, y1 = end + base;
+                    if (side === 'left')
+                        quad([l, y0, k], [l, y0, f], [l, y1, f], [l, y1, k], [-1, 0, 0]);
+                    else
+                        quad([r, y0, f], [r, y0, k], [r, y1, k], [r, y1, f], [1, 0, 0]);
+                }
+                else if (side === 'bottom')
+                    quad([start, b, k], [end, b, k], [end, b, f], [start, b, f], [0, -1, 0]);
+                else
+                    quad([start, t, f], [end, t, f], [end, t, k], [start, t, k], [0, 1, 0]);
+            }
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions.subarray(0, offset), 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals.subarray(0, offset), 3));
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}

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

@@ -0,0 +1,4 @@
+import type { BufferGeometry } from 'three';
+export declare const CURTAIN_WALL_SHADOW_NAME = "curtain-wall-shadow";
+export declare function buildCurtainWallShadowGeometry(source: BufferGeometry, opaqueGlass: boolean): BufferGeometry;
+//# sourceMappingURL=curtain-wall-shadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-shadow.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-shadow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C,eAAO,MAAM,wBAAwB,wBAAwB,CAAA;AAE7D,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,OAAO,GACnB,cAAc,CAYhB"}

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

@@ -0,0 +1,15 @@
+export const CURTAIN_WALL_SHADOW_NAME = 'curtain-wall-shadow';
+export function buildCurtainWallShadowGeometry(source, opaqueGlass) {
+    const geometry = source.clone();
+    const indices = [];
+    for (const group of source.groups) {
+        if (group.materialIndex === 1 && !opaqueGlass)
+            continue;
+        for (let i = group.start; i < group.start + group.count; i++)
+            indices.push(source.index ? source.index.getX(i) : i);
+    }
+    geometry.clearGroups();
+    geometry.setIndex(indices);
+    geometry.setDrawRange(0, indices.length);
+    return geometry;
+}

package/dist/wall/definition.d.ts

@@ -1,19 +1,4 @@
 import { type NodeDefinition } from '@pascal-app/core';
 import { WallNode } from './schema';
-/**
- * Wall — the Phase 3 stress test of the registry-driven node model.
- *
- * Stage A: registered (capabilities, relations, parametrics, presentation).
- * Stage B: deferred — wall geometry depends on level-batch miter data that
- *   doesn't fit the generic `(node, ctx) => Group` shape without `ctx.
- *   levelData?.miters`. See plan's "GeometryContext" extension note.
- *   `renderer` + `system` keep wrap-exporting legacy WallRenderer +
- *   WallSystem + WallCutout.
- * Stage C: `def.floorplan` builder produces the mitered plan footprint
- *   polygon from shared floor-plan level data, with `ctx.siblings` as the
- *   direct-caller fallback.
- *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
- *   wall is registered.
- */
 export declare const wallDefinition: NodeDefinition<typeof WallNode>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAwBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA4J1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AA4BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyBnC,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsN1D,CAAA"}

package/dist/wall/definition.js

@@ -1,17 +1,22 @@
 import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, } from '@pascal-app/editor';
+import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
 import { buildWallContextualDimensions } from './contextual-dimensions';
 import { hasWallCurveBlockingChildren } from './curve-eligibility';
+import { useWallDrawingMode } from './drawing-mode';
 import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
 import { wallCurveAffordance, wallMoveEndpointAffordance, wallThicknessAffordance, } from './floorplan-affordances';
 import { wallFloorplanMoveTarget } from './floorplan-move';
 import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
 import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
 import { wallPaint } from './paint';
+import { wallSettings } from './panel-model';
 import { wallParametrics } from './parametrics';
 import { wallQuickMeasurement } from './quick-measurement';
 import { WallNode } from './schema';
 import { wallSlots } from './slots';
+import { WALL_SPLIT_MAX_CUTS } from './split-preview';
+import { setWallSplitCuts } from './split-session';
+import { useWallSplit } from './split-store';
 /**
  * Wall — the Phase 3 stress test of the registry-driven node model.
  *
@@ -27,14 +32,18 @@ import { wallSlots } from './slots';
  *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
  *   wall is registered.
  */
+const SPLIT_CUT_COUNTS = Array.from({ length: WALL_SPLIT_MAX_CUTS }, (_, index) => String(index + 1));
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 8,
+    schemaVersion: 9,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
     extensions: {
+        [PANEL_MODEL_EXTENSION]: {
+            rows: ({ node, nodes, update }) => wallSettings(node, nodes, update),
+        },
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'wall',
             classifyFace: (node, localNormal) => {
@@ -55,8 +64,11 @@ export const wallDefinition = {
             },
         },
         'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool'),
+            reshapeLayers: { split: () => import('./split-floorplan-layer') },
             contextualDimensions: buildWallContextualDimensions,
             actionMenu: {
+                actions: () => import('./actions'),
                 canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
                     const child = nodes[childId];
                     return child ? [child] : [];
@@ -82,6 +94,7 @@ export const wallDefinition = {
         selectable: { hitVolume: 'bbox' },
         // Front + back faces host items (paintings, shelves, switches).
         surfaces: {
+            hosting: false,
             top: {
                 height: (node, { nodes }) => {
                     const wall = node;
@@ -101,7 +114,7 @@ export const wallDefinition = {
         // `{ slotId, label, default }` contract every other paintable kind exposes.
         // Paint still writes the legacy inline fields for base faces via
         // `wallPaint`; migrating those fully into `node.slots` is a later step.
-        slots: () => wallSlots(),
+        slots: (node) => wallSlots(node),
     },
     relations: {
         hosts: ['door', 'window', 'item', 'lean-to-extension'],
@@ -125,6 +138,7 @@ export const wallDefinition = {
         curve: () => import('./curve-tool'),
         'move-endpoint': () => import('./move-endpoint-tool'),
         move: () => import('./move-tool'),
+        split: () => import('./split-tool'),
     },
     renderer: {
         kind: 'parametric',
@@ -159,8 +173,55 @@ export const wallDefinition = {
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
     toolHints: [
         { key: 'Left click', label: 'Set wall start / end' },
+        {
+            key: 'R',
+            label: 'Shape',
+            chip: {
+                subscribe: (onChange) => useWallDrawingMode.subscribe(onChange),
+                value: () => useWallDrawingMode.getState().mode,
+                cycle: () => useWallDrawingMode.getState().toggle(),
+                labels: { line: 'Shape: Line', rectangle: 'Shape: Rectangle' },
+                icons: { line: 'lucide:minus', rectangle: 'lucide:square' },
+                tooltip: 'Wall shape — click or press R to toggle',
+            },
+        },
         { key: 'Esc', label: 'Cancel' },
     ],
+    // The split session (`split-session.ts`) is the wall's own reshape; the HUD
+    // shows these while it runs. The snapping chip comes from the scope.
+    affordanceHints: {
+        split: [
+            { key: 'Left click', label: 'Split at the marks' },
+            {
+                key: 'Scroll',
+                label: 'Cuts',
+                chip: {
+                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
+                    value: () => String(useWallSplit.getState().draft?.cuts ?? 1),
+                    cycle: () => {
+                        const cuts = useWallSplit.getState().draft?.cuts ?? 1;
+                        setWallSplitCuts(cuts >= WALL_SPLIT_MAX_CUTS ? 1 : cuts + 1);
+                    },
+                    labels: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [
+                        count,
+                        count === '1' ? 'Cuts: 1' : `Cuts: ${count}, even`,
+                    ])),
+                    icons: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [count, 'lucide:scissors'])),
+                    tooltip: 'Number of cuts — scroll or click to change',
+                },
+            },
+            {
+                key: 'Alt',
+                label: 'Free placement',
+                // Several cuts are evenly spaced, so there is nothing to place freely.
+                visible: {
+                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
+                    value: () => (useWallSplit.getState().draft?.cuts ?? 1) === 1,
+                },
+            },
+            { key: 'Esc', label: 'Cancel' },
+        ],
+    },
     presentation: {
         label: 'Wall',
         description: 'A straight or curved wall segment. Hosts doors, windows, lean-to extensions, and wall-mounted items.',
@@ -169,6 +230,6 @@ export const wallDefinition = {
         paletteOrder: 10,
     },
     mcp: {
-        description: 'A wall segment defined by start + end points, with optional curve sagitta.',
+        description: 'A wall defined by endpoints and optional curve sagitta. wallType selects standard or curtain. curtainWall configures construction, framing, grids, glazing, spandrels, and zero-based panel overrides. Thickness is frame depth for curtain walls.',
     },
 };

package/dist/wall/drawing-mode.d.ts

@@ -0,0 +1,12 @@
+export declare const useWallDrawingMode: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    mode: "line" | "rectangle";
+    toggle: () => void;
+}>>;
+/**
+ * R toggles line / rectangle drawing (the HUD's Shape chip cycles the same
+ * store). Both wall tools mount this: the 3D tool only exists once the canvas
+ * does, and split view mounts both, so one listener serves whichever is up.
+ * The mode outlives the tool: re-arming walls resumes the last shape used.
+ */
+export declare function useWallDrawingModeKeys(): void;
+//# sourceMappingURL=drawing-mode.d.ts.map

package/dist/wall/drawing-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-mode.d.ts","sourceRoot":"","sources":["../../src/wall/drawing-mode.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB;UACvB,MAAM,GAAG,WAAW;YAClB,MAAM,IAAI;GAOjB,CAAA;AAWH;;;;;GAKG;AACH,wBAAgB,sBAAsB,SAOrC"}