@pascal-app/nodes 1.0.1 → 1.0.4

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

@@ -0,0 +1,248 @@
+import { type AnyNodeId, type WallConstructionOptions, type WallNode, type WallPlanPoint } from '@pascal-app/core';
+export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanPoint, end: WallPlanPoint, defaults?: Partial<WallNode>, options?: WallConstructionOptions): {
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: Record<string, unknown>;
+    id: `wall_${string}`;
+    type: "wall";
+    children: (`item_${string}` | `procedural-item_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}`)[];
+    start: [number, number];
+    end: [number, number];
+    frontSide: "unknown" | "exterior" | "interior";
+    backSide: "unknown" | "exterior" | "interior";
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    wallType?: "standard" | "curtain" | undefined;
+    curtainWall?: {
+        construction: "stick" | "unitized";
+        framing: "capped" | "vertical-caps" | "horizontal-caps" | "structural-glazing";
+        columns: {
+            layout: "count" | "maximum-spacing" | "fixed-spacing";
+            count: number;
+            spacing: number;
+            alignment: "center" | "start" | "end";
+        };
+        rows: {
+            layout: "count" | "maximum-spacing" | "fixed-spacing";
+            count: number;
+            spacing: number;
+            alignment: "center" | "start" | "end";
+        };
+        mullionWidth: number;
+        transomWidth: number;
+        perimeterWidth: number;
+        jointWidth: number;
+        glassThickness: number;
+        panelType: "glass" | "solid" | "empty";
+        spandrel: "bottom" | "top" | "none";
+        frameColor: string;
+        glassColor: string;
+        solidColor: string;
+        glassOpacity: number;
+        glassRoughness: number;
+        panels: {
+            column: number;
+            row: number;
+            type: "glass" | "solid" | "empty";
+        }[];
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    interiorMaterial?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interiorMaterialPreset?: string | undefined;
+    exteriorMaterial?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    exteriorMaterialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+    legacyFaceMaterials?: {
+        a?: {
+            material?: {
+                id?: string | undefined;
+                preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "front" | "back" | "double";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+        } | undefined;
+        b?: {
+            material?: {
+                id?: string | undefined;
+                preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "front" | "back" | "double";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+        } | undefined;
+    } | undefined;
+    faceRegions?: {
+        id: string;
+        face: "a" | "b";
+        finish: string;
+        u0?: number | undefined;
+        u1?: number | undefined;
+        v0?: number | undefined;
+        v1?: number | undefined;
+    }[] | undefined;
+    thickness?: number | undefined;
+    assembly?: {
+        layers: {
+            id: string;
+            role: "fill" | "shell" | "finish" | "lining" | "substrate" | "sheathing" | "membrane" | "underlay" | "insulation" | "air" | "furring" | "structure" | "deck" | "covering" | "glazing";
+            thickness: number;
+            core?: true | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[];
+        backing?: {
+            id: string;
+            role: "fill" | "shell" | "finish" | "lining" | "substrate" | "sheathing" | "membrane" | "underlay" | "insulation" | "air" | "furring" | "structure" | "deck" | "covering" | "glazing";
+            thickness: number;
+            core?: true | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[] | undefined;
+        face?: "front" | "exterior" | undefined;
+        presetId?: string | undefined;
+        cavityInsulation?: string | undefined;
+    } | undefined;
+    justification?: "a" | "b" | undefined;
+    height?: number | undefined;
+    curveOffset?: number | undefined;
+    supportSlabId?: string | undefined;
+    supportOffset?: number | undefined;
+    fillToTerrain?: boolean | undefined;
+    underpinning?: {
+        rim: number;
+        stem: number;
+        openings?: {
+            u: number;
+            width: number;
+            top: number;
+            bottom: number;
+        }[] | undefined;
+    } | undefined;
+    skirting?: {
+        enabled: boolean;
+        sides: "a" | "b" | "exterior" | "interior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+    crown?: {
+        enabled: boolean;
+        sides: "a" | "b" | "exterior" | "interior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+    chairRail?: {
+        enabled: boolean;
+        sides: "a" | "b" | "exterior" | "interior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+}[];
+//# sourceMappingURL=rectangle-command.d.ts.map

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

@@ -0,0 +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"}

package/dist/wall/rectangle-command.js

@@ -0,0 +1,22 @@
+import { planWallRectangle, resolveWallConstruction, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+export function createWallRectangle(levelId, start, end, defaults = {}, options) {
+    const scene = useScene.getState();
+    if (scene.readOnly)
+        throw Error('This scene is read-only.');
+    const plan = planWallRectangle(scene.nodes, { levelId, start, end, wallDefaults: defaults });
+    if (!plan.changes.create.length && !plan.changes.update.length && !plan.changes.delete.length)
+        return [];
+    const construction = resolveWallConstruction(scene.nodes, levelId, plan.walls, options);
+    const walls = new Map(construction.walls.map((w) => [w.id, w]));
+    const changes = {
+        ...plan.changes,
+        create: plan.changes.create.map((op) => ({
+            ...op,
+            node: walls.get(op.node.id) ?? op.node,
+        })),
+    };
+    if (construction.sourceSupportUpdate)
+        changes.update.push(construction.sourceSupportUpdate);
+    runAsSingleSceneHistoryStep(useScene, () => scene.applyNodeChanges(changes));
+    return construction.walls;
+}

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

@@ -0,0 +1,2 @@
+export default function RectangleWallTool(): import("react").JSX.Element;
+//# sourceMappingURL=rectangle-tool.d.ts.map

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

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

package/dist/wall/rectangle-tool.js

@@ -0,0 +1,165 @@
+'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 { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useState } from 'react';
+import { DoubleSide } from 'three';
+import { createWallRectangle } from './rectangle-command';
+export default function RectangleWallTool() {
+    const { activeLevelId, isCameraDragging } = useRegistryToolContext();
+    const canvas = useThree((s) => s.gl.domElement);
+    const { isImperial } = useLinearDisplay('m', 2);
+    const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const measurementColor = isDark ? '#ffffff' : '#111111';
+    const measurementShadowColor = isDark ? '#111111' : '#ffffff';
+    const defaults = useEditor((s) => s.toolDefaults.wall);
+    const [draft, setDraft] = useState(null);
+    const [message, setMessage] = useState('');
+    const [cursor, setCursor] = useState(null);
+    const levelHeight = useScene((s) => activeLevelId && s.nodes[activeLevelId]?.type === 'level' ? s.nodes[activeLevelId].height : 3);
+    const height = typeof defaults?.height === 'number' ? defaults.height : (levelHeight ?? 3);
+    const thickness = typeof defaults?.thickness === 'number' ? defaults.thickness : 0.1;
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        setDraft(null);
+        setMessage('');
+        let start = null;
+        let corner = null;
+        let plane = null;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'wall' });
+        const pointFor = (e) => {
+            const result = snapWallDraftPointDetailed({
+                point: [e.localPosition[0], e.localPosition[2]],
+                walls: Object.values(useScene.getState().nodes).filter((n) => n.type === 'wall' && n.parentId === activeLevelId),
+                magnetic: isMagneticSnapActive(),
+            });
+            useWallSnapIndicator.getState().set(result.snap
+                ? {
+                    x: result.point[0],
+                    z: result.point[1],
+                    kind: result.snap,
+                    wallIds: result.targetWallIds,
+                }
+                : null);
+            return result.point;
+        };
+        const move = (e) => {
+            if (e.nativeEvent.target !== canvas || isCameraDragging())
+                return;
+            const point = pointFor(e);
+            const hoverPlane = plane ?? resolveEventConstructionPlane(e, null);
+            if (plane)
+                publishHorizontalConstructionPlane(e, plane);
+            setCursor([point[0], hoverPlane.localY, point[1]]);
+            setMessage('');
+            if (!start)
+                return;
+            // The wall draft's tick as the dragged corner steps to a new snapped spot.
+            if (corner && (corner[0] !== point[0] || corner[1] !== point[1]))
+                triggerSFX('sfx:grid-snap');
+            corner = point;
+            setDraft({ start, end: point, y: hoverPlane.localY });
+        };
+        const leave = () => {
+            setCursor(null);
+            useWallSnapIndicator.getState().clear();
+        };
+        // The first corner is mirrored out of tree, like the wall chain's origin,
+        // for consumers outside the tool (the plan view, onboarding hints).
+        const publishStart = (point) => useFloorplanDraftPreview.getState().setWallRectangleDraftStart(point);
+        const cancel = () => {
+            if (start) {
+                markToolCancelConsumed();
+                publishStart(null);
+            }
+            start = null;
+            corner = null;
+            plane = null;
+            setDraft(null);
+            setMessage('');
+            leave();
+            clearPlacementSurface();
+        };
+        const click = (e) => {
+            if (e.nativeEvent.target !== canvas || e.nativeEvent.button !== 0 || isCameraDragging())
+                return;
+            const point = pointFor(e);
+            if (!start) {
+                start = point;
+                publishStart(point);
+                plane = resolveEventConstructionPlane(e, null);
+                publishHorizontalConstructionPlane(e, plane);
+                setCursor([point[0], plane.localY, point[1]]);
+                corner = point;
+                setDraft({ start, end: point, y: plane.localY });
+                setMessage('');
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            try {
+                createWallRectangle(activeLevelId, start, point, useEditor.getState().toolDefaults.wall ?? {}, {
+                    constructionElevation: plane?.elevation,
+                    preferredSupportSlabId: plane?.supportSlabId,
+                    constructionHeight: height,
+                });
+                cancel();
+                triggerSFX('sfx:structure-build');
+            }
+            catch (error) {
+                setMessage(error.message);
+            }
+        };
+        // The plan view finishing or dropping the same rectangle (split view) ends it here too.
+        const stopMirror = useFloorplanDraftPreview.subscribe((state, previous) => {
+            if (!start || !previous.wallRectangleDraftStart || state.wallRectangleDraftStart)
+                return;
+            start = null;
+            corner = null;
+            plane = null;
+            setDraft(null);
+        });
+        emitter.on('grid:move', move);
+        emitter.on('grid:click', click);
+        emitter.on('tool:cancel', cancel);
+        canvas.addEventListener('pointerleave', leave);
+        return () => {
+            stopMirror();
+            emitter.off('grid:move', move);
+            emitter.off('grid:click', click);
+            emitter.off('tool:cancel', cancel);
+            canvas.removeEventListener('pointerleave', leave);
+            if (start)
+                publishStart(null);
+            useWallSnapIndicator.getState().clear();
+            clearPlacementSurface();
+            useInteractionScope.getState().endIf((s) => s.kind === 'drafting' && s.tool === 'wall');
+        };
+    }, [activeLevelId, height, canvas, isCameraDragging]);
+    const corners = draft ? wallRectangleCorners(draft.start, draft.end) : [];
+    const unit = isImperial ? 'imperial' : 'metric';
+    // Label the two sides meeting at the cursor corner, as the floor plan does.
+    const cursorIndex = draft
+        ? corners.findIndex(([x, z]) => x === draft.end[0] && z === draft.end[1])
+        : -1;
+    const sideLabels = draft && cursorIndex >= 0
+        ? [cursorIndex + 3, cursorIndex].map((side) => {
+            const a = corners[side % 4];
+            const b = corners[(side + 1) % 4];
+            return {
+                label: formatLinearMeasurement(Math.hypot(b[0] - a[0], b[1] - a[1]), unit),
+                position: [
+                    (a[0] + b[0]) / 2,
+                    draft.y + height + DRAFT_LABEL_Y_OFFSET,
+                    (a[1] + b[1]) / 2,
+                ],
+            };
+        })
+        : [];
+    return (_jsxs("group", { children: [_jsx(CursorSphere, { name: "rectangle-wall-cursor", height: height, position: cursor ?? [0, 0, 0], visible: !!cursor }), corners.map((a, i) => {
+                const b = corners[(i + 1) % 4];
+                return (_jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 1, position: [(a[0] + b[0]) / 2, draft.y + height / 2, (a[1] + b[1]) / 2], rotation: [0, -Math.atan2(b[1] - a[1], b[0] - a[0]), 0], children: [_jsx("boxGeometry", { args: [Math.hypot(b[0] - a[0], b[1] - a[1]), height, thickness] }), _jsx("meshBasicMaterial", { color: message ? '#ef4444' : '#818cf8', depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }, i));
+            }), draft && message ? (_jsx(DraftMeasurementLabel, { color: "#ef4444", label: message, position: [draft.end[0], draft.y + height + DRAFT_LABEL_Y_OFFSET, draft.end[1]], shadowColor: measurementShadowColor })) : (sideLabels.map((side, index) => (_jsx(DraftMeasurementLabel, { color: measurementColor, label: side.label, position: side.position, shadowColor: measurementShadowColor }, index))))] }));
+}

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,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAsCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4IjD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4JjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -1,10 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { hiddenWallPointerEventsHeld, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { getVisibleWallMaterials, NodeRenderer, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { getWallFinishRefs, NodeRenderer, SHADOW_ONLY_LAYER, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+import { getCurtainAwareWallMaterials } from './curtain-wall-materials';
 import { extractWallSelectionRay, WALL_COLLISION_MESH_NAME, wallPointerEventsSuppressed, } from './pointer-transparency';
 import { createWallRayHitClassifier } from './selection-hit-owner';
 import { createWallTreatmentSelector, useWallTreatmentLevelData } from './treatment-level-data';
@@ -38,6 +39,7 @@ const WallRenderer = ({ node }) => {
     const ref = useRef(null);
     const placeholderGeometry = useMemo(() => createPlaceholderGeometry(3), []);
     const collisionPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(), []);
+    const shadowPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(), []);
     useRegistry(node.id, 'wall', ref);
     useLayoutEffect(() => {
         useScene.getState().markDirty(node.id);
@@ -46,8 +48,9 @@ const WallRenderer = ({ node }) => {
         return () => {
             placeholderGeometry.dispose();
             collisionPlaceholderGeometry.dispose();
+            shadowPlaceholderGeometry.dispose();
         };
-    }, [collisionPlaceholderGeometry, placeholderGeometry]);
+    }, [collisionPlaceholderGeometry, placeholderGeometry, shadowPlaceholderGeometry]);
     const rawHandlers = useNodeEvents(node, 'wall');
     // Hidden walls participate in hover/selection NEAREST-FIRST: when the
     // wall-mode pass hides this wall (`WallCutout` stamps `userData.wallHidden`
@@ -110,7 +113,9 @@ const WallRenderer = ({ node }) => {
     // register after mount, and a dangling ref cached as the slot default must
     // re-resolve when they land.
     const libraryMaterialsVersion = useLibraryMaterialsVersion();
-    const baseMaterials = getVisibleWallMaterials(node, shading, textures, colorPreset, sceneTheme, sceneMaterials);
+    // Built geometry's groups index its finish palette; WallCutout swaps the
+    // array whenever a rebuild changes that palette.
+    const baseMaterials = getCurtainAwareWallMaterials(treatmentNode, shading, textures, colorPreset, sceneTheme, sceneMaterials, getWallFinishRefs(ref.current?.geometry)).visible;
     // biome-ignore lint/correctness/useExhaustiveDependencies: libraryMaterialsVersion invalidates the ref resolution inside createWallExtraSlotMaterials
     const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading, libraryMaterialsVersion]);
     useEffect(() => () => {
@@ -119,6 +124,6 @@ const WallRenderer = ({ node }) => {
         for (const entry of owned)
             entry.dispose();
     }, [baseMaterials, extraMaterials]);
-    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
+    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.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
 };
 export default WallRenderer;

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

@@ -0,0 +1,4 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/** The plan side of the wall's `split` reshape (`reshapeLayers.split`): the same draft as 3D. */
+export default function WallSplitFloorplanLayer(_props: FloorplanToolContext): import("react").JSX.Element | null;
+//# sourceMappingURL=split-floorplan-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,71 @@
+'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 { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { useEffect } from 'react';
+import { bindWallSplitPointer } from './split-pointer';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
+import { useWallSplit } from './split-store';
+/** The plan side of the wall's `split` reshape (`reshapeLayers.split`): the same draft as 3D. */
+export default function WallSplitFloorplanLayer(_props) {
+    const draft = useWallSplit((s) => s.draft);
+    const wallId = draft?.wallId;
+    const wall = useScene((s) => (draft ? s.nodes[draft.wallId] : undefined));
+    const levelId = useViewer((s) => s.selection.levelId);
+    const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
+    const isDark = useViewer((s) => getSceneTheme(s.sceneTheme).appearance === 'dark');
+    const context = useFloorplanRender();
+    const upp = context?.unitsPerPixel ?? 0.01;
+    useEffect(() => {
+        if (!wallId || useScene.getState().nodes[wallId]?.parentId !== levelId)
+            return;
+        const scene = document.querySelector('g[data-floorplan-scene]');
+        const surface = scene?.ownerSVGElement;
+        if (!surface)
+            return;
+        return bindWallSplitPointer(surface, (event) => {
+            if (!(event.target instanceof Node && surface.contains(event.target)))
+                return null;
+            const point = clientToPlan(event.clientX, event.clientY);
+            const current = useScene.getState().nodes[wallId];
+            if (!point || current?.type !== 'wall')
+                return null;
+            const distance = wallSplitDistance(current, point);
+            // Only the wall's own stroke is a target, including its endpoint exclusion zones.
+            const frame = frameAt(current, distance);
+            if (Math.hypot(frame.point.x - point[0], frame.point.y - point[1]) > hitHalfWidth(current, upp))
+                return null;
+            return distance;
+        });
+    }, [wallId, levelId, upp]);
+    if (!draft || wall?.type !== 'wall' || wall.parentId !== levelId)
+        return null;
+    const { preview, snap } = draft;
+    const half = hitHalfWidth(wall, upp);
+    const color = wallSplitMarkerColor(preview.valid);
+    const cut = preview.frames[0]?.point;
+    return (_jsxs("g", { "data-testid": "pascal-split-marker-2d", pointerEvents: "none", children: [snap?.kind === 'alignment' && cut && (_jsx("line", { stroke: "#818cf8", strokeDasharray: `${4 * upp} ${3 * upp}`, strokeOpacity: 0.8, strokeWidth: upp, x1: snap.anchor[0], x2: cut.x, y1: snap.anchor[1], y2: cut.y })), preview.frames.map(({ point, normal }, index) => {
+                const line = {
+                    x1: point.x - normal.x * half,
+                    y1: point.y - normal.y * half,
+                    x2: point.x + normal.x * half,
+                    y2: point.y + normal.y * half,
+                };
+                return (_jsxs("g", { children: [_jsx("line", { ...line, stroke: "#f7f3ed", strokeLinecap: "round", strokeWidth: 7 * upp }), _jsx("line", { ...line, stroke: color, strokeLinecap: "round", strokeWidth: 3 * upp })] }, index));
+            }), !preview.valid && cut ? (_jsx("text", { fill: color, fontSize: 12 * upp, paintOrder: "stroke", stroke: isDark ? '#0f172a' : '#ffffff', strokeWidth: 3 * upp, textAnchor: "middle", x: cut.x, y: cut.y - half - 6 * upp, children: preview.message })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(FloorplanDraftMeasurement, { labelBackground: isDark ? '#0f172a' : '#ffffff', labelText: isDark ? '#e2e8f0' : '#171717', measurement: {
+                    lengthLabel: `${formatLinearMeasurement(segment.length, unit, metricNotation)}${segment.count > 1 ? ` × ${segment.count}` : ''}`,
+                    midpoint: segment.midpoint,
+                    direction: segment.direction,
+                    angleLabels: [],
+                }, measurementStroke: context?.palette.measurementStroke ?? color, sceneRotationDeg: context?.sceneRotationDeg ?? 0, unitsPerPixel: upp }, index))))] }));
+}
+/** The wall's stroke plus a finger's width, so the cut can be grabbed at any zoom. */
+function hitHalfWidth(wall, upp) {
+    return Math.max(getWallFaceOffsets(wall).a, -getWallFaceOffsets(wall).b) + 8 * upp;
+}
+function frameAt(wall, distance) {
+    const length = getWallCurveLength(wall);
+    return getWallCurveFrameAt(wall, length > 0 ? distance / length : 0);
+}

package/dist/wall/split-pointer.d.ts

@@ -0,0 +1,3 @@
+/** Both viewports feed a wall distance; neither writes scene nodes while hovering. */
+export declare function bindWallSplitPointer(surface: Element, distanceAt: (event: PointerEvent) => number | null): () => void;
+//# sourceMappingURL=split-pointer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"split-pointer.d.ts","sourceRoot":"","sources":["../../src/wall/split-pointer.ts"],"names":[],"mappings":"AAUA,sFAAsF;AACtF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,MAAM,GAAG,IAAI,cA2EnD"}