@pascal-app/nodes 1.0.1 → 1.0.4

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/curve-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAaL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAmJtD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAaL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAsJtD,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/wall/curve-tool.js

@@ -55,6 +55,10 @@ export const CurveWallTool = ({ node }) => {
             useScene.getState().markDirty(nodeId);
         };
         const onGridMove = (event) => {
+            // A move between the cancel and the unmount would republish an override
+            // nothing clears any more.
+            if (wasFinalized)
+                return;
             const snapStep = getSegmentGridStep();
             // Snap the cursor on the WORLD XZ grid (still in building-local
             // coords for the rest of the math) so a rotated building doesn't

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,EAKL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AA8BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA8BnC,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA2O1D,CAAA"}

package/dist/wall/definition.js

@@ -1,5 +1,5 @@
-import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, } from '@pascal-app/editor';
+import { DEFAULT_WALL_THICKNESS, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, wallSlots, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY, getWallDrawVariant, PANEL_MODEL_EXTENSION, useEditor, } from '@pascal-app/editor';
 import { buildWallContextualDimensions } from './contextual-dimensions';
 import { hasWallCurveBlockingChildren } from './curve-eligibility';
 import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
@@ -8,10 +8,13 @@ import { wallFloorplanMoveTarget } from './floorplan-move';
 import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
 import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
 import { wallPaint } from './paint';
+import { wallReferenceModel, 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 +30,37 @@ 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));
+/** Show a tool hint only while the wall tool draws this Rooms variant. */
+const whenWallVariant = (variant) => ({
+    subscribe: (onChange) => useEditor.subscribe(onChange),
+    value: () => getWallDrawVariant() === variant,
+});
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 8,
+    schemaVersion: 10,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
     extensions: {
+        [PANEL_MODEL_EXTENSION]: {
+            rows: ({ node, nodes, update }) => wallSettings(node, nodes, update),
+            multiControls: ({ selection, nodes }) => {
+                const reference = wallReferenceModel(selection, nodes);
+                return [
+                    {
+                        id: 'wall-reference',
+                        kind: 'segmented',
+                        section: 'Dimensions',
+                        label: 'Reference',
+                        options: reference.options,
+                        value: reference.value,
+                        onChange: (value) => reference.apply(value),
+                    },
+                ];
+            },
+        },
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'wall',
             classifyFace: (node, localNormal) => {
@@ -55,8 +81,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 +111,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 +131,14 @@ 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),
+        // F2 layers stack from the front face (or the exterior with
+        // `face: 'exterior'`); `thickness` holds their sum.
+        assembly: {
+            reference: 'front',
+            measure: 'normal',
+            body: (node) => node.thickness ?? DEFAULT_WALL_THICKNESS,
+        },
     },
     relations: {
         hosts: ['door', 'window', 'item', 'lean-to-extension'],
@@ -125,6 +162,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',
@@ -157,10 +195,57 @@ export const wallDefinition = {
     },
     floorplanMoveTarget: wallFloorplanMoveTarget,
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
+    // The gesture row follows the Rooms variant picked in the Build panel (the
+    // HUD header names it); the variant itself is never cycled from here.
     toolHints: [
-        { key: 'Left click', label: 'Set wall start / end' },
+        {
+            key: 'Left click',
+            label: 'Set one corner, then the opposite',
+            visible: whenWallVariant('rectangle'),
+        },
+        {
+            key: 'Left click',
+            label: 'Add a corner · click the first to close',
+            visible: whenWallVariant('polygon'),
+        },
+        { key: 'Left click', label: 'Set wall start / end', visible: whenWallVariant('walls') },
         { 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 +254,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/floorplan-move.d.ts

@@ -23,7 +23,7 @@ import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Existing automatic slabs and ceilings receive live polygon overrides during
+ * Existing slabs, ceilings and zones receive live polygon overrides during
  * the drag. New surfaces and removals stay deferred until commit because live
  * overrides cannot represent nodes that do not exist in the scene.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,mBAAmB,EAaxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAuYjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAgVjE,CAAA"}

package/dist/wall/floorplan-move.js

@@ -1,13 +1,7 @@
-import { detectSpacesForLevel, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
+import { createLevelStructurePreview, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallEndRejoins, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
-function getLevelSlabs(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
-}
-function getLevelCeilings(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
-}
 /**
  * 2D floor-plan move handler for wall.
  *
@@ -32,7 +26,7 @@ function getLevelCeilings(levelId, nodes) {
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Existing automatic slabs and ceilings receive live polygon overrides during
+ * Existing slabs, ceilings and zones receive live polygon overrides during
  * the drag. New surfaces and removals stay deferred until commit because live
  * overrides cannot represent nodes that do not exist in the scene.
  */
@@ -78,40 +72,22 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
     const levelId = node.parentId ?? null;
+    const previewStructure = levelId
+        ? createLevelStructurePreview(levelId, useScene.getState().nodes)
+        : null;
+    const dragNodes = Object.fromEntries(Object.values(useScene.getState().nodes)
+        .filter((node) => node.parentId === levelId)
+        .map((node) => [node.id, node]));
     const affectedIds = [wallId, ...linkedOriginals.map((wall) => wall.id)];
     const affectedIdSet = new Set(affectedIds);
     const touchedSurfaceIds = new Set();
-    let latestSurfacePlans = null;
-    const planSurfaces = (walls) => {
-        if (!levelId)
-            return null;
-        const sceneState = useScene.getState();
-        const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
-        const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
-        const slabs = planAutoSlabsForLevel(roomPolygons, getLevelSlabs(levelId, sceneState.nodes));
-        const levelNode = sceneState.nodes[levelId];
-        const ceilings = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
-            storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
-            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
-        });
-        return { slabs, ceilings };
-    };
     const publishSurfacePreviews = (walls) => {
-        const plans = planSurfaces(walls);
-        latestSurfacePlans = plans;
-        if (!plans)
+        if (!previewStructure)
             return;
-        const entries = [];
-        for (const update of plans.slabs.update) {
-            if (update.data.polygon !== undefined) {
-                entries.push([update.id, { polygon: update.data.polygon }]);
-            }
-        }
-        for (const update of plans.ceilings.update) {
-            if (update.data.polygon !== undefined || update.data.height !== undefined) {
-                entries.push([update.id, update.data]);
-            }
-        }
+        const updates = previewStructure(walls);
+        const entries = updates.flatMap((update) => 'polygon' in update.data || 'holes' in update.data
+            ? [[update.id, update.data]]
+            : []);
         const nextIds = new Set(entries.map(([id]) => id));
         const overrides = useLiveNodeOverrides.getState();
         const sceneState = useScene.getState();
@@ -142,7 +118,6 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             sceneState.markDirty(id);
         }
         touchedSurfaceIds.clear();
-        latestSurfacePlans = null;
     };
     const session = {
         affectedIds,
@@ -222,7 +197,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // `existingWalls` snapshot needs the post-drag layout so duplicate
             // detection works; we synthesise it from scene state + the
             // overrides we just published (zustand is still on baseline).
-            const previewSceneWalls = getWallsAfterUpdates(useScene.getState().nodes, [
+            const previewSceneWalls = getWallsAfterUpdates(dragNodes, [
                 { id: wallId, data: { start: nextStart, end: nextEnd } },
                 ...linkedUpdates.map((u) => ({ id: u.id, data: { start: u.start, end: u.end } })),
             ]).filter((wall) => !collapsedIds.has(wall.id));
@@ -306,49 +281,11 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
-            const finalWalls = [
-                ...existingWalls,
-                ...bridgeCreates.map((entry) => ({ ...entry.node, parentId: entry.parentId ?? null })),
-            ];
-            const surfacePlans = planSurfaces(finalWalls) ?? latestSurfacePlans;
-            const surfaceUpdates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                    ...surfacePlans.ceilings.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                ]
-                : [];
-            const surfaceCreates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.create.map((slab) => ({
-                        node: slab,
-                        parentId: levelId,
-                    })),
-                    ...surfacePlans.ceilings.create.map((ceiling) => ({
-                        node: ceiling,
-                        parentId: levelId,
-                    })),
-                ]
-                : [];
-            const surfaceDeletes = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.delete.map((id) => id),
-                    ...surfacePlans.ceilings.delete.map((id) => id),
-                ]
-                : [];
-            sceneState.applyNodeChanges({
-                update: [
-                    ...commitUpdates,
-                    ...surfaceUpdates,
-                ],
-                create: [...bridgeCreates, ...surfaceCreates],
-                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
-            });
+            sceneState.applyNodeChanges(planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: commitUpdates,
+                create: bridgeCreates,
+                delete: Array.from(collapsedLinkedWallIds),
+            }));
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
             // double-merging the same values and would shadow any genuine

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,EAQ1B,MAAM,oBAAoB,CAAA;AAI3B,oGAAoG;AACpG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,sCAEpE"}