@pascal-app/nodes 1.0.6 → 1.1.0

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

@@ -0,0 +1,42 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getRailingWallConfig, getRailingWallHeight, RAILING_GUARD_HEIGHT, RAILING_GUARD_HEIGHT_TALL, RAILING_SPHERE_LIMIT, usePascalI18n, } from '@pascal-app/core';
+import { PanelSection, SegmentedControl, SelectControl, SliderControl, ToggleControl, } from '@pascal-app/editor';
+import { getRailingWallUpdate, RAILING_CAPPED_STYLES, RAILING_INFILL_LABELS, RAILING_STYLE_OPTIONS, railingHeightPreset, railingStylePatch, } from './railing-wall-panel-model.js';
+const INCH = 0.0254;
+/** The panel's lengths stop here: a guard is never this big, so the cap only bounds the slider. */
+const MAX_LENGTH = 1000;
+/**
+ * The wall panel's railing controls: the style, the guard's height
+ * (36 in, 42 in or its own), the posts' spacing and size, and the infill. Lengths read in inches
+ * on an imperial plan, where feet would show a 1½ in baluster as 0.13.
+ */
+export function RailingWallPanel({ node, unit, onUpdate, onPreview, onCommit, onCancel }) {
+    const i18n = usePascalI18n();
+    const config = getRailingWallConfig(node);
+    const height = getRailingWallHeight(node);
+    const imperial = unit === 'imperial';
+    const toShown = (meters) => (imperial ? meters / INCH : meters);
+    const toMeters = (shown) => (imperial ? shown * INCH : shown);
+    const update = (patch, preview = false) => (preview ? onPreview : onUpdate)(getRailingWallUpdate(node, patch));
+    const length = (label, value, min, onChange) => (_jsx(SliderControl, { label: label, max: toShown(MAX_LENGTH), min: toShown(min), onCancel: onCancel, onChange: (shown) => onChange(Math.min(Math.max(toMeters(shown), min), MAX_LENGTH)), onCommit: onCommit, precision: imperial ? 2 : 3, previewWhileTyping: true, restoreOnCommit: false, step: imperial ? 0.25 : 0.005, unit: imperial ? 'in' : 'm', value: toShown(value) }));
+    const preset = railingHeightPreset(height);
+    const infill = RAILING_INFILL_LABELS[config.style];
+    // IRC R312.1.3: no opening in a guard may pass a 4 in sphere.
+    const opensPastSphere = (infill.gap !== null && config.infillGap >= RAILING_SPHERE_LIMIT) ||
+        config.bottomClearance >= RAILING_SPHERE_LIMIT;
+    return (_jsxs(_Fragment, { children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.wall.railingWallPanel.railing', message: 'Railing' }), children: [_jsx(SelectControl, { label: i18n._({ id: 'node.wall.railingWallPanel.style', message: 'Style' }), onChange: (style) => update(railingStylePatch(style)), options: RAILING_STYLE_OPTIONS, value: config.style }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: i18n._({ id: 'node.wall.railingWallPanel.height', message: 'Height' }) }), _jsx(SegmentedControl, { mixed: preset === null, onChange: (next) => onUpdate({ height: next === '42' ? RAILING_GUARD_HEIGHT_TALL : RAILING_GUARD_HEIGHT }), options: [
+                            {
+                                label: i18n._({ id: 'node.wall.railingWallPanel.n36In', message: '36 in' }),
+                                value: '36',
+                            },
+                            {
+                                label: i18n._({ id: 'node.wall.railingWallPanel.n42In', message: '42 in' }),
+                                value: '42',
+                            },
+                        ], value: preset ?? '36' }), length('Height', height, 0.1, (meters) => onPreview({ height: meters })), RAILING_CAPPED_STYLES.has(config.style) && (_jsx(ToggleControl, { checked: config.cap, label: i18n._({ id: 'node.wall.railingWallPanel.n2x6Cap', message: '2x6 cap' }), onChange: (cap) => update({ cap }) }))] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.wall.railingWallPanel.posts', message: 'Posts' }), children: [length('Max spacing', config.postSpacing, 0.1, (postSpacing) => update({ postSpacing }, true)), length('Post size', config.postSize, 0.01, (postSize) => update({ postSize }, true))] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.wall.railingWallPanel.infill', message: 'Infill' }), children: [length(infill.size, config.infillSize, 0.003, (infillSize) => update({ infillSize }, true)), infill.gap !== null &&
+                        length(infill.gap, config.infillGap, 0, (infillGap) => update({ infillGap }, true)), length('Floor clearance', config.bottomClearance, 0, (bottomClearance) => update({ bottomClearance }, true)), opensPastSphere && (_jsx("p", { className: "px-1 text-[11px] text-muted-foreground", children: i18n._({
+                            id: 'node.wall.railingWallPanel.aGuardSOpeningsMustNot',
+                            message: "A guard's openings must not pass a 4 in sphere (IRC R312.1.3).",
+                        }) }))] })] }));
+}

package/dist/wall/rectangle-command.d.ts

@@ -25,7 +25,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     id: `wall_${string}`;
     type: "wall";
-    wallType?: "curtain" | "standard" | undefined;
+    wallType?: "curtain" | "railing" | "standard" | undefined;
     curtainWall?: {
         construction: "stick" | "unitized";
         framing: "capped" | "horizontal-caps" | "structural-glazing" | "vertical-caps";
@@ -59,6 +59,15 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             type: "empty" | "glass" | "solid";
         }[];
     } | undefined;
+    railing?: {
+        style: "balusters" | "boards" | "cable" | "glass" | "metal" | "post-and-rail";
+        postSpacing: number;
+        postSize: number;
+        infillSize: number;
+        infillGap: number;
+        bottomClearance: number;
+        cap: boolean;
+    } | undefined;
     children: (`door_${string}` | `item_${string}` | `leanto_${string}` | `procedural-item_${string}` | `window_${string}`)[];
     material?: {
         id?: string | undefined;
@@ -75,6 +84,11 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     materialPreset?: string | undefined;
@@ -93,6 +107,11 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     interiorMaterialPreset?: string | undefined;
@@ -111,6 +130,11 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     exteriorMaterialPreset?: string | undefined;
@@ -132,6 +156,11 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                     url: string;
                     repeat?: [number, number] | undefined;
                     scale?: number | undefined;
+                    offset?: [number, number] | undefined;
+                    normalMap?: string | undefined;
+                    normalScale?: number | undefined;
+                    bumpMap?: string | undefined;
+                    bumpScale?: number | undefined;
                 } | undefined;
             } | undefined;
             materialPreset?: string | undefined;
@@ -152,6 +181,11 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                     url: string;
                     repeat?: [number, number] | undefined;
                     scale?: number | undefined;
+                    offset?: [number, number] | undefined;
+                    normalMap?: string | undefined;
+                    normalScale?: number | undefined;
+                    bumpMap?: string | undefined;
+                    bumpScale?: number | undefined;
                 } | undefined;
             } | undefined;
             materialPreset?: string | undefined;
@@ -173,6 +207,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
             thickness: number;
             core?: true | undefined;
+            spacing?: number | undefined;
             material?: string | undefined;
             slot?: string | undefined;
             returns?: boolean | undefined;
@@ -187,6 +222,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
             role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
             thickness: number;
             core?: true | undefined;
+            spacing?: number | undefined;
             material?: string | undefined;
             slot?: string | undefined;
             returns?: boolean | undefined;
@@ -202,6 +238,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     justification?: "a" | "b" | undefined;
     height?: number | undefined;
+    endHeightOffset?: number | undefined;
     curveOffset?: number | undefined;
     supportSlabId?: string | undefined;
     supportOffset?: number | undefined;
@@ -304,6 +341,16 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -322,6 +369,17 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -399,6 +457,16 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -417,6 +485,17 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {

package/dist/wall/rectangle-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}
+{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}

package/dist/wall/rectangle-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangle-tool.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-tool.tsx"],"names":[],"mappings":"AAoCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,gCAoNxC"}
+{"version":3,"file":"rectangle-tool.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-tool.tsx"],"names":[],"mappings":"AAoCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,gCAsNxC"}

package/dist/wall/rectangle-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, useScene, wallRectangleCorners, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
+import { emitter, formatLinearMeasurement, useScene, wallRectangleCorners, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useState } from 'react';
@@ -35,6 +35,8 @@ export default function RectangleWallTool() {
                 point: [e.localPosition[0], e.localPosition[2]],
                 walls: Object.values(useScene.getState().nodes).filter((n) => n.type === 'wall' && n.parentId === activeLevelId),
                 magnetic: isMagneticSnapActive(),
+                // A corner aimed into an existing wall's body joins it.
+                captureWallBodies: true,
             });
             useWallSnapIndicator.getState().set(result.snap
                 ? {

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EASL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAoKjD,CAAA;eAEc,YAAY"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EASL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAsKjD,CAAA;eAEc,YAAY"}

package/dist/wall/renderer.js

@@ -139,7 +139,9 @@ const WallRenderer = ({ node }) => {
         for (const entry of owned)
             entry.dispose();
     }, [baseMaterials, extraMaterials]);
-    return (_jsxs("mesh", { castShadow: node.wallType !== 'curtain', geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { name: "curtain-wall-shadow", userData: { pascalExport: 'strip' }, geometry: shadowPlaceholderGeometry, layers: SHADOW_ONLY_LAYER, castShadow: true, visible: node.wallType === 'curtain', raycast: () => { }, children: _jsx("meshBasicMaterial", {}) }), _jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), node.wallType !== 'curtain' && hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), node.wallType !== 'curtain' &&
+    // Trim and scripted finishes dress a wall's faces: a curtain wall and a railing have none.
+    const hasFaces = node.wallType !== 'curtain' && node.wallType !== 'railing';
+    return (_jsxs("mesh", { castShadow: node.wallType !== 'curtain', geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { name: "curtain-wall-shadow", userData: { pascalExport: 'strip' }, geometry: shadowPlaceholderGeometry, layers: SHADOW_ONLY_LAYER, castShadow: true, visible: node.wallType === 'curtain', raycast: () => { }, children: _jsx("meshBasicMaterial", {}) }), _jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), hasFaces && hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), hasFaces &&
                 ['a', 'b'].map((face) => {
                     const script = node.finishScripts?.[face];
                     return script ? (_jsx(WallFaceScriptModel, { face: face, node: node, script: script }, face)) : null;

package/dist/wall/skirting-floor-gaps.d.ts

@@ -0,0 +1,8 @@
+import { type AnyNode, type WallFace, type WallNode } from '@pascal-app/core';
+/**
+ * Where a floor opening of the wall's level meets one of its faces, as wall-local x ranges along
+ * the chord (as the trim's runs are measured): the skirting breaks there, as it does at a door,
+ * rather than running on in mid-air along a double-height void or a stairwell.
+ */
+export declare function skirtingFloorOpeningRanges(wall: WallNode, face: WallFace, nodes: Readonly<Record<string, AnyNode>>): [number, number][];
+//# sourceMappingURL=skirting-floor-gaps.d.ts.map

package/dist/wall/skirting-floor-gaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skirting-floor-gaps.d.ts","sourceRoot":"","sources":["../../src/wall/skirting-floor-gaps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMZ,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAgCpB"}

package/dist/wall/skirting-floor-gaps.js

@@ -0,0 +1,36 @@
+import { area, getWallCurveFrameAt, getWallFaceOffsets, intersection, isCurvedWall, } from '@pascal-app/core';
+/** How far in front of the face a floor opening must reach to break the skirting. */
+const REACH = 0.05;
+/**
+ * Where a floor opening of the wall's level meets one of its faces, as wall-local x ranges along
+ * the chord (as the trim's runs are measured): the skirting breaks there, as it does at a door,
+ * rather than running on in mid-air along a double-height void or a stairwell.
+ */
+export function skirtingFloorOpeningRanges(wall, face, nodes) {
+    const openings = Object.values(nodes).filter((node) => node.type === 'floor-opening' &&
+        node.parentId === wall.parentId &&
+        node.drawnOn === 'floor' &&
+        node.cutsPrimary);
+    if (!openings.length)
+        return [];
+    const offset = getWallFaceOffsets(wall)[face];
+    const out = offset + (face === 'a' ? REACH : -REACH);
+    const samples = isCurvedWall(wall) ? 24 : 1;
+    const near = [];
+    const far = [];
+    for (let index = 0; index <= samples; index++) {
+        const { point, normal } = getWallCurveFrameAt(wall, index / samples);
+        near.push([point.x + normal.x * offset, point.y + normal.y * offset]);
+        far.push([point.x + normal.x * out, point.y + normal.y * out]);
+    }
+    const band = [...near, ...far.reverse()];
+    const [dx, dz] = [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]];
+    const length = Math.hypot(dx, dz) || 1;
+    const along = ([x, z]) => ((x - wall.start[0]) * dx + (z - wall.start[1]) * dz) / length;
+    return openings.flatMap((opening) => intersection(band, opening.polygon)
+        .filter((part) => area([part]) > 1e-6)
+        .map((part) => {
+        const xs = part.outer.map(along);
+        return [Math.min(...xs), Math.max(...xs)];
+    }));
+}

package/dist/wall/split-floorplan-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split-floorplan-layer.d.ts","sourceRoot":"","sources":["../../src/wall/split-floorplan-layer.tsx"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,oBAAoB,EAG1B,MAAM,oBAAoB,CAAA;AAO3B,iGAAiG;AACjG,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,sCAgG3E"}
+{"version":3,"file":"split-floorplan-layer.d.ts","sourceRoot":"","sources":["../../src/wall/split-floorplan-layer.tsx"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,oBAAoB,CAAA;AAO3B,iGAAiG;AACjG,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,sCAgG3E"}

package/dist/wall/split-floorplan-layer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, useScene, } from '@pascal-app/core';
-import { clientToPlan, FloorplanDraftMeasurement, formatLinearMeasurement, useFloorplanRender, } from '@pascal-app/editor';
+import { formatLinearMeasurement, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, useScene, } from '@pascal-app/core';
+import { clientToPlan, FloorplanDraftMeasurement, useFloorplanRender, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useEffect } from 'react';
 import { bindWallSplitPointer } from './split-pointer.js';

package/dist/wall/split-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split-tool.d.ts","sourceRoot":"","sources":["../../src/wall/split-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAA6C,MAAM,kBAAkB,CAAA;AAgB1F;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCA8J9D"}
+{"version":3,"file":"split-tool.d.ts","sourceRoot":"","sources":["../../src/wall/split-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,kBAAkB,CAAA;AAezB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCA8J9D"}

package/dist/wall/split-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getWallThickness, sceneRegistry, useScene } from '@pascal-app/core';
-import { DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, NO_RAYCAST, } from '@pascal-app/editor';
+import { formatLinearMeasurement, getWallThickness, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, NO_RAYCAST, } from '@pascal-app/editor';
 import { BATCHED_LAYER, getSceneTheme, SCENE_LAYER, useViewer } from '@pascal-app/viewer';
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';

package/dist/wall/system.d.ts

@@ -1,19 +1,5 @@
 export declare function resetWallTreatmentLevels(): void;
 export declare function updateWallTreatmentLevels(): void;
-/**
- * Registry-driven wall system bundle.
- *
- *  - **`WallSystem`** — reads `dirtyNodes`, batches by level, runs
- *    `calculateLevelMiters(levelWalls)`, rebuilds geometry via
- *    `generateExtrudedWall(node, children, miterData, slabElevation, baseElevation, baseSegments, storeyHeight)`,
- *    and cascades to adjacent walls that share a junction. This is the
- *    bulk of the wall runtime (~820 lines in viewer).
- *  - **`WallCutout`** — cutaway-mode hide/show logic based on camera
- *    direction and `frontSide` / `backSide` interior/exterior tags.
- *  - **`WallBatchSystem`** — once a level stops changing, sews its opaque
- *    walls into one mesh per material set so a floor costs a handful of
- *    draw calls instead of one per wall face run.
- */
 declare const WallSystems: () => import("react").JSX.Element;
 export default WallSystems;
 //# sourceMappingURL=system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAuDA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CA0FhD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;eAEc,WAAW"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAwDA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CA0FhD;AA4BD,QAAA,MAAM,WAAW,mCAShB,CAAA;eAEc,WAAW"}

package/dist/wall/system.js

@@ -6,6 +6,7 @@ import { useFrame } from '@react-three/fiber';
 import { useEffect } from 'react';
 import { curtainWallGeometryAdapter } from './curtain-wall-adapter.js';
 import { getCurtainAwareWallMaterials } from './curtain-wall-materials.js';
+import { withRailingWalls } from './railing-wall-adapter.js';
 import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data.js';
 import { wallTreatmentProudOffsets } from './treatments.js';
 import { WallBatchSystem } from './wall-batch-system.js';
@@ -125,8 +126,12 @@ const WallTreatmentMiterSystem = () => {
  *  - **`WallBatchSystem`** — once a level stops changing, sews its opaque
  *    walls into one mesh per material set so a floor costs a handful of
  *    draw calls instead of one per wall face run.
+ *
+ * Curtain walls and railings build their own mesh through the geometry
+ * adapter: a glazed grid, an open guard.
  */
+const wallGeometryAdapter = withRailingWalls(curtainWallGeometryAdapter);
 const WallSystems = () => {
-    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, { geometryAdapter: curtainWallGeometryAdapter }), _jsx(WallCutout, { materialResolver: getCurtainAwareWallMaterials }), _jsx(WallBatchSystem, {})] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, { geometryAdapter: wallGeometryAdapter }), _jsx(WallCutout, { materialResolver: getCurtainAwareWallMaterials }), _jsx(WallBatchSystem, {})] }));
 };
 export default WallSystems;

package/dist/wall/tool.d.ts

@@ -1,3 +1,19 @@
+import { type WallNode } from '@pascal-app/core';
+/**
+ * The walls the line tool snaps a drafted point against. `walls` is the active
+ * level, which the measurement HUD reports against. `snapWalls` adds an open
+ * Polygon room's sides and, as a reference for the corner and edge snaps, the
+ * floor below. `bodyWalls` leaves the floor below out: a body capture T-joins
+ * the wall it lands in, and a wall on another floor can't be joined, so an end
+ * near a lower wall's face stays where the plan (which only knows the active
+ * level) puts it. An invisible-wall draft also catches the invisible walls
+ * already drawn (`invisibleWallDraftSnapLines`).
+ */
+export declare function getWallDraftSnapWalls(): {
+    walls: WallNode[];
+    snapWalls: WallNode[];
+    bodyWalls: WallNode[];
+};
 export declare const WallTool: React.FC;
 export default WallTool;
 //# sourceMappingURL=tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAqhCA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAe5B,CAAA;eAEc,QAAQ"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAmBL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmdzB;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,IAAI;IACvC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACtB,CAQA;AAkyBD,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAe5B,CAAA;eAEc,QAAQ"}