@pascal-app/nodes 1.0.1 → 1.0.3

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

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

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

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

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

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

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

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

package/dist/wall/definition.d.ts

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

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

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

package/dist/wall/definition.js

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

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

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

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

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

package/dist/wall/drawing-mode.js

@@ -0,0 +1,38 @@
+import { emitter } from '@pascal-app/core';
+import { isEditableKeyboardTarget } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { create } from 'zustand';
+export const useWallDrawingMode = create((set, get) => ({
+    mode: 'line',
+    toggle: () => {
+        emitter.emit('tool:cancel');
+        set({ mode: get().mode === 'rectangle' ? 'line' : 'rectangle' });
+    },
+}));
+const onKeyDown = (e) => {
+    if (e.repeat || e.metaKey || e.ctrlKey || e.altKey)
+        return;
+    if (e.key !== 'r' && e.key !== 'R')
+        return;
+    if (isEditableKeyboardTarget(e.target))
+        return;
+    e.preventDefault();
+    useWallDrawingMode.getState().toggle();
+};
+let owners = 0;
+/**
+ * R toggles line / rectangle drawing (the HUD's Shape chip cycles the same
+ * store). Both wall tools mount this: the 3D tool only exists once the canvas
+ * does, and split view mounts both, so one listener serves whichever is up.
+ * The mode outlives the tool: re-arming walls resumes the last shape used.
+ */
+export function useWallDrawingModeKeys() {
+    useEffect(() => {
+        if (owners++ === 0)
+            window.addEventListener('keydown', onKeyDown);
+        return () => {
+            if (--owners === 0)
+                window.removeEventListener('keydown', onKeyDown);
+        };
+    }, []);
+}

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

@@ -0,0 +1,4 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
+export default function WallFloorplanTool(props: FloorplanToolContext): import("react").JSX.Element | null;
+//# sourceMappingURL=floorplan-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-tool.tsx"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,oBAAoB,EAO1B,MAAM,oBAAoB,CAAA;AAK3B,oGAAoG;AACpG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,sCAIpE"}

package/dist/wall/floorplan-tool.js

@@ -0,0 +1,107 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, resolveTerrainWallConstructionOptions, useScene, } from '@pascal-app/core';
+import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { useEffect, useRef, useState } from 'react';
+import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
+import { createWallRectangle } from './rectangle-command';
+/** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
+export default function WallFloorplanTool(props) {
+    useWallDrawingModeKeys();
+    const mode = useWallDrawingMode((s) => s.mode);
+    return mode === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
+}
+/**
+ * Rectangle mode in the floor plan. Pointer moves stay with the panel, so the
+ * cursor, snapping, alignment guides and snap beacon are the line wall's own;
+ * this tool only claims clicks and publishes the first corner, and the panel's
+ * linear draft layer draws the four draft walls from it.
+ */
+function RectangleFloorplanTool({ activeLevelId }) {
+    const group = useRef(null);
+    const renderContext = useFloorplanRender();
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const svg = group.current?.ownerSVGElement;
+        if (!svg || !activeLevelId)
+            return;
+        const draft = useFloorplanDraftPreview.getState;
+        let down = null;
+        let construction;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'wall' });
+        const claim = (e) => {
+            e.preventDefault();
+            e.stopImmediatePropagation();
+        };
+        const onDown = (e) => {
+            if (e.button !== 0 || e.metaKey || e.ctrlKey)
+                return;
+            claim(e);
+            down = [e.clientX, e.clientY];
+        };
+        const cancel = () => {
+            if (draft().wallRectangleDraftStart)
+                markToolCancelConsumed();
+            draft().setWallRectangleDraftStart(null);
+            down = null;
+            setError(null);
+        };
+        const onClick = (e) => {
+            if (e.button !== 0 || e.metaKey || e.ctrlKey)
+                return;
+            claim(e);
+            if (!down || Math.hypot(e.clientX - down[0], e.clientY - down[1]) > 5) {
+                down = null;
+                return;
+            }
+            down = null;
+            // The panel's snapped cursor, exactly where a line wall would land.
+            const point = draft().cursorPoint;
+            if (!point)
+                return;
+            const start = draft().wallRectangleDraftStart;
+            if (!start) {
+                construction = resolveTerrainWallConstructionOptions(useScene.getState().nodes, activeLevelId, point, useEditor.getState().toolDefaults.wall);
+                draft().setWallRectangleDraftStart(point);
+                setError(null);
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            try {
+                createWallRectangle(activeLevelId, start, point, useEditor.getState().toolDefaults.wall ?? {}, construction);
+                cancel();
+                triggerSFX('sfx:structure-build');
+            }
+            catch (e) {
+                setError({ message: e.message, at: point });
+            }
+        };
+        const stopDouble = (e) => {
+            if (e.button === 0)
+                claim(e);
+        };
+        // The panel publishes the snapped cursor only when it moves to a new
+        // point, so each change while a corner is down is the line draft's tick.
+        const stopTick = useFloorplanDraftPreview.subscribe((state, previous) => {
+            if (state.wallRectangleDraftStart &&
+                state.cursorPoint &&
+                state.cursorPoint !== previous.cursorPoint)
+                triggerSFX('sfx:grid-snap');
+        });
+        svg.addEventListener('pointerdown', onDown, true);
+        svg.addEventListener('click', onClick, true);
+        svg.addEventListener('dblclick', stopDouble, true);
+        emitter.on('tool:cancel', cancel);
+        return () => {
+            stopTick();
+            svg.removeEventListener('pointerdown', onDown, true);
+            svg.removeEventListener('click', onClick, true);
+            svg.removeEventListener('dblclick', stopDouble, true);
+            emitter.off('tool:cancel', cancel);
+            draft().setWallRectangleDraftStart(null);
+            useInteractionScope.getState().endIf((s) => s.kind === 'drafting' && s.tool === 'wall');
+        };
+    }, [activeLevelId]);
+    const unitsPerPixel = renderContext?.unitsPerPixel ?? 0.01;
+    return (_jsx("g", { ref: group, pointerEvents: "none", children: error && (_jsx("text", { x: error.at[0], y: error.at[1] - 0.2, fill: "#ef4444", fontSize: 12 * unitsPerPixel, children: error.message })) }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAYlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAkNjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAQpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAalC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA8NjG"}

package/dist/wall/floorplan.js

@@ -1,7 +1,8 @@
-import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallEffectiveHeightForNodes, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards';
 import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions';
+import { buildCurtainWallFloorplan } from './curtain-wall-floorplan';
 import { hasWallCurveBlockingChildren } from './curve-eligibility';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
@@ -103,7 +104,7 @@ export function buildWallFloorplan(node, ctx) {
         : isHovered && palette
             ? palette.wallHoverStroke
             : '#1f2937';
-    const fill = showSelectedChrome ? '#ffffff' : '#374151';
+    const fill = node.wallType === 'curtain' ? 'transparent' : showSelectedChrome ? '#ffffff' : '#374151';
     const children = [
         {
             kind: 'polygon',
@@ -121,6 +122,9 @@ export function buildWallFloorplan(node, ctx) {
             cursor: isSelected ? 'default' : undefined,
         },
     ];
+    if (node.wallType === 'curtain') {
+        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
+    }
     if (automaticDimensions) {
         const dimensionStroke = isSelected && palette ? palette.selectedStroke : (palette?.measurementStroke ?? '#334155');
         const dimensionStandard = constructionDimensionStandard({

package/dist/wall/length-patch.d.ts

@@ -0,0 +1,3 @@
+import { type WallNode } from '@pascal-app/core';
+export declare function buildWallLengthPatch(node: WallNode, nextLength: number): Partial<WallNode>;
+//# sourceMappingURL=length-patch.d.ts.map

package/dist/wall/length-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-patch.d.ts","sourceRoot":"","sources":["../../src/wall/length-patch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE/F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAW1F"}

package/dist/wall/length-patch.js

@@ -0,0 +1,14 @@
+import { getClampedWallCurveOffset, getWallCurveLength } from '@pascal-app/core';
+export function buildWallLengthPatch(node, nextLength) {
+    const length = getWallCurveLength(node);
+    if (!length || !Number.isFinite(nextLength) || nextLength <= 0)
+        return {};
+    const ratio = nextLength / length;
+    return {
+        end: [
+            node.start[0] + (node.end[0] - node.start[0]) * ratio,
+            node.start[1] + (node.end[1] - node.start[1]) * ratio,
+        ],
+        ...(node.curveOffset ? { curveOffset: getClampedWallCurveOffset(node) * ratio } : {}),
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAwBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAqIzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA4iBrD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAwBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAqIzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA+jBrD,CAAA;AAED,eAAe,YAAY,CAAA"}