@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/wall/property-preview.js

@@ -0,0 +1,31 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+export function createWallPropertyPreview(id) {
+    let pending;
+    const clear = () => {
+        if (!pending)
+            return;
+        useLiveNodeOverrides.getState().clearFields(id, Object.keys(pending));
+        pending = undefined;
+        useScene.getState().markDirty(id);
+    };
+    return {
+        preview(patch) {
+            pending = { ...pending, ...patch };
+            useLiveNodeOverrides.getState().set(id, patch);
+            useScene.getState().markDirty(id);
+        },
+        commit(patch) {
+            const live = useLiveNodeOverrides.getState().get(id);
+            const current = pending && live
+                ? Object.fromEntries(Object.keys(pending)
+                    .filter((key) => key in live)
+                    .map((key) => [key, live[key]]))
+                : undefined;
+            const updates = { ...current, ...patch };
+            if (Object.keys(updates).length && useScene.getState().nodes[id]?.type === 'wall')
+                useScene.getState().updateNode(id, updates);
+            clear();
+        },
+        cancel: clear,
+    };
+}

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

@@ -0,0 +1,149 @@
+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" | "interior" | "exterior";
+    backSide: "unknown" | "interior" | "exterior";
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | 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: "top" | "none" | "bottom";
+        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;
+    thickness?: number | undefined;
+    height?: number | undefined;
+    curveOffset?: number | undefined;
+    supportSlabId?: string | undefined;
+    supportOffset?: number | undefined;
+    fillToTerrain?: boolean | undefined;
+    faceBands?: {
+        enabled: boolean;
+        count: number;
+        lowerHeight: number;
+        middleHeight: number;
+        upperHeight: number;
+    } | undefined;
+    skirting?: {
+        enabled: boolean;
+        sides: "interior" | "exterior" | "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: "interior" | "exterior" | "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: "interior" | "exterior" | "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":"AAmCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,gCAkMxC"}

package/dist/wall/rectangle-tool.js

@@ -0,0 +1,147 @@
+'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, 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 end = 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 line draft's tick: once per snapped corner position.
+            if (end && (end[0] !== point[0] || end[1] !== point[1]))
+                triggerSFX('sfx:grid-snap');
+            end = point;
+            setDraft({ start, end: point, y: hoverPlane.localY });
+        };
+        const leave = () => {
+            setCursor(null);
+            useWallSnapIndicator.getState().clear();
+        };
+        const cancel = () => {
+            if (start)
+                markToolCancelConsumed();
+            start = null;
+            end = 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;
+                end = point;
+                plane = resolveEventConstructionPlane(e, null);
+                publishHorizontalConstructionPlane(e, plane);
+                setCursor([point[0], plane.localY, point[1]]);
+                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);
+            }
+        };
+        emitter.on('grid:move', move);
+        emitter.on('grid:click', click);
+        emitter.on('tool:cancel', cancel);
+        canvas.addEventListener('pointerleave', leave);
+        return () => {
+            emitter.off('grid:move', move);
+            emitter.off('grid:click', click);
+            emitter.off('tool:cancel', cancel);
+            canvas.removeEventListener('pointerleave', leave);
+            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;AAuCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAyJjD,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 { 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,7 @@ 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);
+    const baseMaterials = getCurtainAwareWallMaterials(treatmentNode, shading, textures, colorPreset, sceneTheme, sceneMaterials).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 +122,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/slots.d.ts

@@ -1,4 +1,4 @@
-import { type SlotDeclaration } from '@pascal-app/core';
+import { type SlotDeclaration, type WallNode } from '@pascal-app/core';
 /**
  * A wall exposes two paintable faces — interior + exterior. Painting writes
  * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
@@ -6,5 +6,5 @@ import { type SlotDeclaration } from '@pascal-app/core';
  * keeps walls on the same `{ slotId, label, default }` contract. The defaults
  * come from core so the viewer's material resolver renders the identical value.
  */
-export declare function wallSlots(): SlotDeclaration[];
+export declare function wallSlots(node?: WallNode): SlotDeclaration[];
 //# sourceMappingURL=slots.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA8B,MAAM,kBAAkB,CAAA;AAEnF;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CA2E7C"}
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,eAAe,EAAE,CAmF5D"}

package/dist/wall/slots.js

@@ -1,4 +1,4 @@
-import { WALL_SURFACE_SLOT_DEFAULTS } from '@pascal-app/core';
+import { getCurtainWallConfig, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 /**
  * A wall exposes two paintable faces — interior + exterior. Painting writes
  * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
@@ -6,7 +6,15 @@ import { WALL_SURFACE_SLOT_DEFAULTS } from '@pascal-app/core';
  * keeps walls on the same `{ slotId, label, default }` contract. The defaults
  * come from core so the viewer's material resolver renders the identical value.
  */
-export function wallSlots() {
+export function wallSlots(node) {
+    if (node?.wallType === 'curtain') {
+        const config = getCurtainWallConfig(node);
+        return [
+            { slotId: 'curtain-frame', label: 'Frame', default: config.frameColor },
+            { slotId: 'curtain-glass', label: 'Glass', default: config.glassColor },
+            { slotId: 'curtain-solid', label: 'Solid panels', default: config.solidColor },
+        ];
+    }
     return [
         { slotId: 'interior', label: 'Interior', default: WALL_SURFACE_SLOT_DEFAULTS.interior },
         { slotId: 'exterior', label: 'Exterior', default: WALL_SURFACE_SLOT_DEFAULTS.exterior },

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":"AAQA,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, getWallThickness, useScene, } from '@pascal-app/core';
+import { clientToPlan, FloorplanDraftWallMeasurement, 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", { pointerEvents: "none", "data-testid": "pascal-split-marker-2d", 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", strokeWidth: 7 * upp, strokeLinecap: "round" }), _jsx("line", { ...line, stroke: color, strokeWidth: 3 * upp, strokeLinecap: "round" })] }, 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(FloorplanDraftWallMeasurement, { 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 getWallThickness(wall) / 2 + 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"}

package/dist/wall/split-pointer.js

@@ -0,0 +1,95 @@
+import { commitWallSplit, hoverWallSplit, setWallSplitCuts } from './split-session';
+import { useWallSplit } from './split-store';
+// Pixels of continuous wheel travel per cut: a short trackpad swipe.
+const WHEEL_STEP_PX = 60;
+// A wheel event after this pause is a new notch or gesture and steps at once,
+// so each notch of a notched wheel is one cut whatever pixels the OS reports
+// for it; a continuous stream (trackpad, fast spin) steps by travel.
+const WHEEL_GESTURE_GAP_MS = 80;
+/** Both viewports feed a wall distance; neither writes scene nodes while hovering. */
+export function bindWallSplitPointer(surface, distanceAt) {
+    let pressed = null;
+    let wheelTravel = 0;
+    let lastWheelAt = Number.NEGATIVE_INFINITY;
+    const move = (event) => {
+        if (event.buttons && pressed !== event.pointerId)
+            return;
+        const distance = distanceAt(event);
+        if (distance !== null)
+            hoverWallSplit(distance, event.altKey);
+    };
+    const down = (event) => {
+        if (event.button !== 0)
+            return;
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        pressed = event.pointerId;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        hoverWallSplit(distance, event.altKey);
+    };
+    const up = (event) => {
+        if (pressed !== event.pointerId)
+            return;
+        pressed = null;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        hoverWallSplit(distance, event.altKey);
+        // Retain ownership through the click dispatched after pointerup, so normal
+        // selection cannot consume that same click after the cut closes its session.
+        const swallow = (click) => {
+            click.preventDefault();
+            click.stopImmediatePropagation();
+        };
+        surface.addEventListener('click', swallow, { capture: true, once: true });
+        setTimeout(() => surface.removeEventListener('click', swallow, true), 0);
+        commitWallSplit();
+    };
+    const cancel = () => {
+        pressed = null;
+    };
+    // Scrolling over the viewport changes the cut count, as in a loop cut;
+    // pinch (Ctrl + wheel) still zooms.
+    const wheel = (event) => {
+        if (event.ctrlKey || !(event.target instanceof Node) || !surface.contains(event.target))
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (!event.deltaY)
+            return;
+        const fresh = event.timeStamp - lastWheelAt > WHEEL_GESTURE_GAP_MS;
+        lastWheelAt = event.timeStamp;
+        let steps;
+        // Line-mode deltas only come from a notched wheel: one line event, one notch.
+        if (fresh || event.deltaMode !== 0) {
+            wheelTravel = 0;
+            steps = Math.sign(event.deltaY);
+        }
+        else {
+            wheelTravel += event.deltaY;
+            steps = Math.trunc(wheelTravel / WHEEL_STEP_PX);
+            wheelTravel -= steps * WHEEL_STEP_PX;
+        }
+        if (!steps)
+            return;
+        const draft = useWallSplit.getState().draft;
+        if (draft)
+            setWallSplitCuts(draft.cuts - steps);
+    };
+    window.addEventListener('pointermove', move, true);
+    window.addEventListener('pointerdown', down, true);
+    window.addEventListener('pointerup', up, true);
+    window.addEventListener('pointercancel', cancel, true);
+    window.addEventListener('wheel', wheel, { capture: true, passive: false });
+    return () => {
+        window.removeEventListener('pointermove', move, true);
+        window.removeEventListener('pointerdown', down, true);
+        window.removeEventListener('pointerup', up, true);
+        window.removeEventListener('pointercancel', cancel, true);
+        window.removeEventListener('wheel', wheel, true);
+    };
+}