@pascal-app/nodes 0.1.1 → 1.0.0-beta.1

package/dist/wall/floorplan.js

@@ -1,23 +1,55 @@
-import { calculateLevelMiters, getWallCurveLength, getWallMidpointHandlePoint, getWallPlanFootprint, isCurvedWall, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, 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';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
 // drifting from BIM data. Inlined to keep nodes/wall self-contained.
 const FLOORPLAN_WALL_THICKNESS_SCALE = 1.18;
 const FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS = 0.13;
 const FLOORPLAN_MAX_EXTRA_THICKNESS = 0.035;
+const FLOORPLAN_SELECTION_HATCH_SPACING = 0.12;
+const FLOORPLAN_SELECTED_WALL_STROKE_WIDTH = 0.03;
+const FLOORPLAN_SELECTION_HATCH_STROKE_WIDTH = 0.02;
+const WALL_DIMENSION_REFERENCES = ['finished-faces', 'centerline', 'stud-faces'];
 function floorplanWallThickness(wall) {
-    const baseThickness = wall.thickness ?? 0.1;
+    const baseThickness = getWallThickness(wall);
     const scaledThickness = baseThickness * FLOORPLAN_WALL_THICKNESS_SCALE;
     return Math.min(baseThickness + FLOORPLAN_MAX_EXTRA_THICKNESS, Math.max(baseThickness, scaledThickness, FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS));
 }
 function exaggerateWallThickness(wall) {
     return { ...wall, thickness: floorplanWallThickness(wall) };
 }
-function formatLengthMetric(meters) {
-    return `${Number.parseFloat(meters.toFixed(2))}m`;
-}
-export function computeWallFloorplanLevelData({ siblings, }) {
-    return calculateLevelMiters(siblings.map(exaggerateWallThickness));
+export function computeWallFloorplanLevelData({ siblings, nodes, }) {
+    const walls = siblings.map(exaggerateWallThickness);
+    const constructionDimensionsByReference = {};
+    for (const reference of WALL_DIMENSION_REFERENCES) {
+        let cached;
+        Object.defineProperty(constructionDimensionsByReference, reference, {
+            enumerable: true,
+            get: () => {
+                if (cached)
+                    return cached;
+                const datumPolicy = reference === 'finished-faces'
+                    ? 'wall-face'
+                    : reference === 'stud-faces'
+                        ? 'structural-face'
+                        : 'centerline';
+                cached = buildLevelWallConstructionDimensionPlan(siblings, nodes, constructionDimensionStandard({
+                    datumPolicy,
+                    ...(reference === 'finished-faces'
+                        ? { intersectionReferencePolicy: 'both-faces' }
+                        : {}),
+                }));
+                return cached;
+            },
+        });
+    }
+    return {
+        miters: calculateLevelMiters(walls),
+        documentMiters: calculateLevelMiters([...siblings]),
+        constructionDimensionsByReference,
+    };
 }
 /**
  * Stage C floor-plan builder for wall — emits the full chrome stack the
@@ -29,25 +61,27 @@ export function computeWallFloorplanLevelData({ siblings, }) {
  *      wall body easily.
  *   4. Two endpoint handles (start + end) when selected — the registry
  *      layer hosts the 5-circle stack + hover transitions + 2D drag.
- *   5. A small dimension label at the midpoint when selected.
+ *   5. Exterior facade strings plus interior wall spans and hosted-opening widths.
  *
  * `ctx.levelData` provides the shared level miter graph when the floor-plan
  * dispatcher precomputes it; `ctx.siblings` remains the fallback path for
  * direct builder callers.
  */
 export function buildWallFloorplan(node, ctx) {
-    const self = exaggerateWallThickness(node);
+    const { automaticDimensions, metricNotation, purpose, wallDimensionReference } = readFloorplanContext(ctx);
+    const documentMode = purpose === 'document';
+    const wallForPurpose = (wall) => (documentMode ? wall : exaggerateWallThickness(wall));
+    const self = wallForPurpose(node);
     // Prefer the level-batch miter graph the floor-plan dispatcher precomputes
     // once per pass (`computeWallFloorplanLevelData`). Only the fallback path —
     // a direct builder caller with no shared data — pays the O(N) exaggerate +
     // level-wide miter calc per wall; the dispatcher path is O(1) here, which is
     // what keeps a wall drag from being O(N²) across the level.
-    const miters = ctx.levelData ??
+    const levelData = ctx.levelData;
+    const miters = (documentMode ? levelData?.documentMiters : levelData?.miters) ??
         calculateLevelMiters([
             self,
-            ...ctx.siblings
-                .filter((s) => s.type === 'wall')
-                .map(exaggerateWallThickness),
+            ...ctx.siblings.filter((s) => s.type === 'wall').map(wallForPurpose),
         ]);
     const polygon = getWallPlanFootprint(self, miters);
     if (!polygon || polygon.length < 3)
@@ -75,8 +109,9 @@ export function buildWallFloorplan(node, ctx) {
             points,
             fill,
             stroke,
-            strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+            strokeWidth: showSelectedChrome ? FLOORPLAN_SELECTED_WALL_STROKE_WIDTH : 0.02,
             opacity: 0.92,
+            metadata: floorplanGeometryMetadata({ annotationObstacle: 'outline' }),
             // Once the wall is selected, the body keeps catching the pointer
             // so the cursor stays neutral (no drag/pointer affordance from
             // the slab below leaking through), but only the side-arrows and
@@ -85,15 +120,44 @@ export function buildWallFloorplan(node, ctx) {
             cursor: isSelected ? 'default' : undefined,
         },
     ];
+    if (automaticDimensions) {
+        const dimensionStroke = isSelected && palette ? palette.selectedStroke : (palette?.measurementStroke ?? '#334155');
+        const dimensionStandard = constructionDimensionStandard({
+            datumPolicy: wallDimensionDatumPolicy(wallDimensionReference),
+            metricNotation,
+        });
+        const exteriorCornerDimensionStandard = constructionDimensionStandard({
+            datumPolicy: 'structural-face',
+            metricNotation,
+        });
+        if (isCurvedWall(node)) {
+            children.push(...buildCurvedWallConstructionDimensions(self, {
+                unit: view?.unit ?? 'metric',
+                stroke: dimensionStroke,
+                profile: documentMode ? 'document' : 'editor',
+                standard: exteriorCornerDimensionStandard,
+                siblings: ctx.siblings.filter((sibling) => sibling.type === 'wall'),
+            }));
+        }
+        else {
+            const planned = levelData?.constructionDimensionsByReference[wallDimensionReference].get(node.id);
+            if (planned) {
+                children.push(...renderPlannedConstructionDimensions(planned, view?.unit ?? 'metric', dimensionStroke, documentMode ? 'document' : 'editor', dimensionStandard));
+            }
+            else if (!levelData) {
+                children.push(...buildWallConstructionDimensions(self, ctx, {
+                    unit: view?.unit ?? 'metric',
+                    stroke: dimensionStroke,
+                    profile: documentMode ? 'document' : 'editor',
+                    standard: exteriorCornerDimensionStandard,
+                }));
+            }
+        }
+    }
     // Selection hatch overlay — only when the wall is *the* selected item
     // (not when it's just marquee-highlighted), matching the legacy.
     if (isSelected && palette) {
-        children.push({
-            kind: 'hatch',
-            points,
-            color: palette.selectedHatch,
-            opacity: 1,
-        });
+        children.push(...buildSelectedWallHatchLines(self, palette.selectedHatch));
     }
     // Hit-line on the centerline. Stroke width is in screen pixels so it
     // stays clickable at any zoom. Skipped while selected — the user has
@@ -136,19 +200,18 @@ export function buildWallFloorplan(node, ctx) {
             const dz = node.end[1] - node.start[1];
             const wallLength = Math.hypot(dx, dz);
             if (wallLength > 1e-6) {
-                const midX = (node.start[0] + node.end[0]) / 2;
-                const midZ = (node.start[1] + node.end[1]) / 2;
+                const midpoint = getWallMidpointHandlePoint(node);
                 const nx = -dz / wallLength;
                 const nz = dx / wallLength;
                 const offset = floorplanWallThickness(node) / 2 + 0.05;
                 children.push({
                     kind: 'move-arrow',
-                    point: [midX + nx * offset, midZ + nz * offset],
+                    point: [midpoint.x + nx * offset, midpoint.y + nz * offset],
                     angle: Math.atan2(nz, nx),
                 });
                 children.push({
                     kind: 'move-arrow',
-                    point: [midX - nx * offset, midZ - nz * offset],
+                    point: [midpoint.x - nx * offset, midpoint.y - nz * offset],
                     angle: Math.atan2(-nz, -nx),
                 });
             }
@@ -169,65 +232,44 @@ export function buildWallFloorplan(node, ctx) {
                 payload: { wallId: node.id },
             });
         }
-        // Length measurement. Curved walls use the simple rounded label
-        // (the chord-vs-arc thing is hard to express with a dimension line);
-        // straight walls get the full architect's overlay with extension
-        // marks + ticks, offset to the side facing away from the level
-        // centroid (matches the legacy `getWallMeasurementOverlay`).
-        const length = getWallCurveLength(node);
-        if (length >= 0.1) {
-            const dx = node.end[0] - node.start[0];
-            const dz = node.end[1] - node.start[1];
-            const midX = (node.start[0] + node.end[0]) / 2;
-            const midZ = (node.start[1] + node.end[1]) / 2;
-            if (isCurvedWall(node)) {
-                children.push({
-                    kind: 'dimension-label',
-                    cx: midX,
-                    cy: midZ,
-                    text: formatLengthMetric(length),
-                    angle: Math.atan2(dz, dx),
-                });
-            }
-            else {
-                // Outward unit normal = perpendicular to (dx, dz), choose the
-                // side facing away from other walls' centroid so the dimension
-                // line sits outside the building.
-                const nx = -dz / length;
-                const nz = dx / length;
-                const wallSiblings = ctx.siblings.filter((s) => s.type === 'wall');
-                const centroid = wallCentroid([node, ...wallSiblings]);
-                const cx = midX - centroid[0];
-                const cz = midZ - centroid[1];
-                const facingAway = cx * nx + cz * nz >= 0 ? 1 : -1;
-                children.push({
-                    kind: 'dimension',
-                    start: [node.start[0], node.start[1]],
-                    end: [node.end[0], node.end[1]],
-                    offsetNormal: [nx * facingAway, nz * facingAway],
-                    offsetDistance: 0.75,
-                    extensionOvershoot: 0.12,
-                    text: formatLengthMetric(length),
-                });
-            }
-        }
     }
     return { kind: 'group', children };
 }
-function wallCentroid(walls) {
-    // Mean of every wall endpoint — cheap approximation of "where the
-    // building lives" so we can offset the dimension line away from it.
-    let sumX = 0;
-    let sumZ = 0;
-    let count = 0;
-    for (const wall of walls) {
-        sumX += wall.start[0] + wall.end[0];
-        sumZ += wall.start[1] + wall.end[1];
-        count += 2;
+function buildSelectedWallHatchLines(wall, stroke) {
+    const length = getWallCurveLength(wall);
+    if (length <= 1e-6)
+        return [];
+    const halfAcross = getWallThickness(wall) / 2;
+    const halfAlong = halfAcross;
+    const count = Math.max(1, Math.floor(length / FLOORPLAN_SELECTION_HATCH_SPACING));
+    const spacing = length / count;
+    const lines = [];
+    for (let index = 0; index < count; index += 1) {
+        const along = (index + 0.5) * spacing;
+        const frame = getWallCurveFrameAt(wall, along / length);
+        lines.push({
+            kind: 'line',
+            x1: frame.point.x - frame.tangent.x * halfAlong - frame.normal.x * halfAcross,
+            y1: frame.point.y - frame.tangent.y * halfAlong - frame.normal.y * halfAcross,
+            x2: frame.point.x + frame.tangent.x * halfAlong + frame.normal.x * halfAcross,
+            y2: frame.point.y + frame.tangent.y * halfAlong + frame.normal.y * halfAcross,
+            stroke,
+            strokeWidth: FLOORPLAN_SELECTION_HATCH_STROKE_WIDTH,
+            pointerEvents: 'none',
+            metadata: floorplanGeometryMetadata({ renderPass: 'overlay' }),
+        });
+    }
+    return lines;
+}
+function wallDimensionDatumPolicy(reference) {
+    switch (reference) {
+        case 'centerline':
+            return 'centerline';
+        case 'stud-faces':
+            return 'structural-face';
+        case 'finished-faces':
+            return 'wall-face';
     }
-    if (count === 0)
-        return [0, 0];
-    return [sumX / count, sumZ / count];
 }
 /**
  * Doors, windows, and wall-attached items would tear if the wall bent

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

@@ -1 +1 @@
-{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAEhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAuF5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA2ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CA6B3B"}
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAGhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAmG5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA8ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAgC3B"}

package/dist/wall/measurement.js

@@ -1,7 +1,9 @@
-import { DEFAULT_WALL_HEIGHT, getWallCurveFrameAt, getWallThickness, sampleWallCenterline, } from '@pascal-app/core';
+import { getWallArcData, getWallCurveFrameAt, getWallThickness, sampleWallCenterline, useScene, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 const point = (x, y, z) => [x, y, z];
 export function wallMeasurementFeatures(wall) {
-    const height = wall.height ?? DEFAULT_WALL_HEIGHT;
+    const height = resolveWallOpeningCeiling(wall, useScene.getState().nodes);
+    const arc = getWallArcData(wall);
     const centerline = sampleWallCenterline(wall).map(({ x, y }) => point(x, 0, y));
     const midpoint = getWallCurveFrameAt(wall, 0.5).point;
     const halfThickness = getWallThickness(wall) / 2;
@@ -42,6 +44,17 @@ export function wallMeasurementFeatures(wall) {
             priority: 90,
             geometry: { kind: 'point', point: point(midpoint.x, 0, midpoint.y) },
         },
+        ...(arc
+            ? [
+                {
+                    id: 'wall:curve:center',
+                    label: 'Wall arc center',
+                    snapKind: 'center',
+                    priority: 90,
+                    geometry: { kind: 'point', point: point(arc.center.x, 0, arc.center.y) },
+                },
+            ]
+            : []),
         {
             id: 'wall:face:left',
             label: 'Wall face',
@@ -132,7 +145,7 @@ export function matchWallMeasurementFeature(wall, hit, maxDistance) {
         const faceDistance = Math.hypot(hit[0] - faceX, hit[2] - faceZ);
         const threshold = Math.max(maxDistance, halfThickness + 0.03);
         if (faceDistance <= threshold && (!best || faceDistance < best.distance)) {
-            const height = Math.max(0, Math.min(wall.height ?? DEFAULT_WALL_HEIGHT, hit[1]));
+            const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), hit[1]));
             best = {
                 featureId: side > 0 ? 'wall:face:left' : 'wall:face:right',
                 point: point(faceX, height, faceZ),
@@ -162,7 +175,7 @@ export function resolveWallMeasurementFeature(wall, reference) {
     if (typeof heightValue !== 'number' || feature.geometry.kind !== 'path') {
         return normal ? { ...feature, normal } : feature;
     }
-    const height = Math.max(0, Math.min(wall.height ?? DEFAULT_WALL_HEIGHT, heightValue));
+    const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), heightValue));
     return {
         ...feature,
         ...(normal ? { normal } : {}),

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

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAcL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAyBzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CA4dzE,CAAA;AAkBD,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAeL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAqhBzE,CAAA;AAkBD,eAAe,oBAAoB,CAAA"}

package/dist/wall/move-endpoint-tool.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { collectAlignmentAnchors, DEFAULT_WALL_HEIGHT, emitter, getWallCurveLength, getWallThickness, pauseSceneHistory, resolveAlignment, resumeSceneHistory, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, emitter, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, pauseSceneHistory, resolveAlignment, resolveMovedWallSupportSlabPatch, resumeSceneHistory, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, MeasurementPill, markToolCancelConsumed, resolveEndpointWallSplit, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useInteractionScope, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { LevelOffsetGroup } from '../shared/level-offset-group';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 /** Figma-style alignment-snap threshold (meters), matching the item move /
  *  placement tools. 8 cm gives a magnetic pull without fighting grid snap. */
 const ALIGNMENT_THRESHOLD_M = 0.08;
@@ -102,6 +104,12 @@ export const MoveWallEndpointTool = ({ target }) => {
     });
     const [altPressed, setAltPressed] = useState(false);
     const unit = useViewer((s) => s.unit);
+    const nodes = useScene((state) => state.nodes);
+    const liveOverride = useLiveNodeOverrides((state) => state.overrides.get(target.wall.id));
+    const effectiveWall = liveOverride
+        ? { ...target.wall, ...liveOverride }
+        : target.wall;
+    const wallBaseElevation = getWallBaseElevationForNodes(effectiveWall, nodes);
     // Alt-detach only affects walls sharing the moving endpoint; walls linked
     // solely to the fixed endpoint never move, so the hint would be noise.
     const movingOriginal = target.endpoint === 'start' ? originalStartRef.current : originalEndRef.current;
@@ -116,18 +124,38 @@ export const MoveWallEndpointTool = ({ target }) => {
         const originalStart = originalStartRef.current;
         const originalEnd = originalEndRef.current;
         const fixedPoint = fixedPointRef.current;
+        const movingOriginalPoint = target.endpoint === 'start' ? originalStart : originalEnd;
+        // Walls attached to the MOVING corner cascade with the drag, but the snap
+        // pipeline reads the scene store, which keeps their pre-drag coordinates
+        // until commit. Their stale corners would recreate the old junction as a
+        // snap/alignment target: inside the connect radius the endpoint could
+        // never land closer than ~5cm to where it started, making sub-5cm
+        // corrections (e.g. squaring a scan-imported 91° corner) impossible.
+        // Excluded while attached; under Alt-detach they stay put and remain
+        // legitimate targets.
+        const movingLinkedWallIds = linkedOriginalsRef.current
+            .filter((wall) => samePoint(wall.start, movingOriginalPoint) || samePoint(wall.end, movingOriginalPoint))
+            .map((wall) => wall.id);
         const levelWalls = Object.values(useScene.getState().nodes).filter((node) => node?.type === 'wall' && (node.parentId ?? null) === (target.wall.parentId ?? null));
         // Alignment candidates — anchors of every OTHER alignable object (walls,
         // fences, items, slabs, ceilings, columns), gathered once (the set is
         // stable during the drag). Coords are building-local, the same frame as
         // the cursor and the 3D guide layer, so the published guide lines up.
+        // The attached variant additionally drops anchors owned by walls that
+        // follow the moving corner (see `movingLinkedWallIds` above) — their
+        // scene coordinates are stale during the drag.
         const wallAlignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, nodeId);
+        const movingLinkedIdSet = new Set(movingLinkedWallIds);
+        const attachedAlignmentCandidates = wallAlignmentCandidates.filter((anchor) => !movingLinkedIdSet.has(anchor.nodeId));
         pauseSceneHistory(useScene);
         let wasCommitted = false;
-        // Last point handed to `applyPreview` — lets the Alt keydown/keyup
-        // handlers re-run the preview immediately on a modifier change instead of
-        // waiting for the next mousemove.
-        let lastMovedPoint = null;
+        // Last RAW cursor point from `grid:move` — lets the Alt keydown/keyup
+        // handlers re-run the FULL snap pipeline immediately on a modifier change
+        // instead of waiting for the next mousemove. The raw point (not the
+        // snapped one) matters: the snap/alignment candidate set depends on Alt
+        // (stale-junction exclusion above), so a point snapped under the previous
+        // modifier state must not be reused as-is.
+        let lastRawPoint = null;
         // The first pointer-up is the *grab* of a click-to-move; later ones are
         // drops. See the `!hasChanged` branch in `onPointerUp`.
         let hasReleasedOnce = false;
@@ -160,7 +188,6 @@ export const MoveWallEndpointTool = ({ target }) => {
             touchedWallIds.clear();
         };
         const applyPreview = (movingPoint, detachLinkedWalls = false) => {
-            lastMovedPoint = movingPoint;
             const nextStart = target.endpoint === 'start' ? movingPoint : fixedPoint;
             const nextEnd = target.endpoint === 'end' ? movingPoint : fixedPoint;
             const linkedUpdates = detachLinkedWalls
@@ -213,16 +240,18 @@ export const MoveWallEndpointTool = ({ target }) => {
             window.addEventListener('click', swallow, { capture: true, once: true });
             setTimeout(() => window.removeEventListener('click', swallow, { capture: true }), 300);
         };
-        const onGridMove = (event) => {
-            const planPoint = [event.localPosition[0], event.localPosition[2]];
-            // Endpoint move honours the active snapping mode (the HUD chip): grid →
-            // lattice; lines → magnetic corner/alignment snap; angles → lock the
-            // segment to 15° rays from the FIXED corner; off → raw. No Shift bypass —
-            // Shift cycles the mode now, and Off is the bypass.
+        // Full snap pipeline from a RAW cursor point to the applied endpoint —
+        // shared by `grid:move` and the Alt keydown/keyup handlers, since the
+        // candidate set (stale-junction exclusion) flips with the modifier.
+        // Endpoint move honours the active snapping mode (the HUD chip): grid →
+        // lattice; lines → magnetic corner/alignment snap; angles → lock the
+        // segment to 15° rays from the FIXED corner; off → raw. No Shift bypass —
+        // Shift cycles the mode now, and Off is the bypass.
+        const resolveDragPoint = (planPoint) => {
             const snapResult = snapWallDraftPointDetailed({
                 point: planPoint,
                 walls: levelWalls,
-                ignoreWallIds: [nodeId],
+                ignoreWallIds: altPressedRef.current ? [nodeId] : [nodeId, ...movingLinkedWallIds],
                 start: fixedPoint,
                 angleSnap: isAngleSnapActive(),
                 magnetic: isMagneticSnapActive(),
@@ -238,10 +267,13 @@ export const MoveWallEndpointTool = ({ target }) => {
             // (isAlignmentGuideActive); the magnetic pull onto them is applied only in
             // 'lines' mode (isMagneticSnapActive).
             let alignedPoint = snappedPoint;
-            if (isAlignmentGuideActive() && wallAlignmentCandidates.length > 0) {
+            const alignmentCandidates = altPressedRef.current
+                ? wallAlignmentCandidates
+                : attachedAlignmentCandidates;
+            if (isAlignmentGuideActive() && alignmentCandidates.length > 0) {
                 const ar = resolveAlignment({
                     moving: [{ nodeId, kind: 'corner', x: snappedPoint[0], z: snappedPoint[1] }],
-                    candidates: wallAlignmentCandidates,
+                    candidates: alignmentCandidates,
                     threshold: ALIGNMENT_THRESHOLD_M,
                 });
                 const magnetic = isMagneticSnapActive();
@@ -273,14 +305,20 @@ export const MoveWallEndpointTool = ({ target }) => {
                 .set(snapResult.snap
                 ? { x: alignedPoint[0], z: alignedPoint[1], kind: snapResult.snap }
                 : null);
+            return alignedPoint;
+        };
+        const onGridMove = (event) => {
+            const planPoint = [event.localPosition[0], event.localPosition[2]];
+            lastRawPoint = planPoint;
             // The keydown listener can't observe an Alt press that predates the
             // tool mounting; the pointer event can. Sync the shared ref (single Alt
-            // source for preview, HUD badge, and commit) before applying.
+            // source for snap targets, preview, HUD badge, and commit) before the
+            // snap pipeline reads it.
             if (event.nativeEvent.altKey !== altPressedRef.current) {
                 altPressedRef.current = event.nativeEvent.altKey;
                 setAltPressed(event.nativeEvent.altKey);
             }
-            applyPreview(alignedPoint, altPressedRef.current);
+            applyPreview(resolveDragPoint(planPoint), altPressedRef.current);
         };
         const onPointerUp = () => {
             useAlignmentGuides.getState().clear();
@@ -353,6 +391,14 @@ export const MoveWallEndpointTool = ({ target }) => {
                             },
                         })),
                     ]);
+                    const affectedIds = [nodeId, ...linkedUpdates.map((u) => u.id)];
+                    const committedNodes = useScene.getState().nodes;
+                    useScene.getState().updateNodes(affectedIds.flatMap((id) => {
+                        const wall = committedNodes[id];
+                        return wall?.type === 'wall'
+                            ? [{ id, data: resolveMovedWallSupportSlabPatch(wall, committedNodes) }]
+                            : [];
+                    }));
                     useScene.getState().markDirty(nodeId);
                     for (const u of linkedUpdates) {
                         useScene.getState().markDirty(u.id);
@@ -375,17 +421,18 @@ export const MoveWallEndpointTool = ({ target }) => {
             markToolCancelConsumed();
             exitMoveMode();
         };
-        // Single Alt writer for keyboard transitions. Re-running the preview on
-        // the flip keeps geometry and the HUD badge in lockstep — detach reverts
-        // the linked walls instantly, re-attach snaps them onto the dragged point
-        // — without waiting for the next mousemove.
+        // Single Alt writer for keyboard transitions. Re-running the FULL snap
+        // pipeline from the raw cursor on the flip keeps geometry and the HUD
+        // badge in lockstep — detach reverts the linked walls instantly and
+        // re-snaps against their (now live) corners, re-attach drops them from
+        // the candidate set again — without waiting for the next mousemove.
         const setAltState = (pressed) => {
             if (altPressedRef.current === pressed)
                 return;
             altPressedRef.current = pressed;
             setAltPressed(pressed);
-            if (lastMovedPoint) {
-                applyPreview(lastMovedPoint, pressed);
+            if (lastRawPoint) {
+                applyPreview(resolveDragPoint(lastRawPoint), pressed);
             }
         };
         const onKeyDown = (event) => {
@@ -437,12 +484,12 @@ export const MoveWallEndpointTool = ({ target }) => {
         end: previewEnd,
         curveOffset: target.wall.curveOffset,
     });
-    const wallHeight = target.wall.height ?? DEFAULT_WALL_HEIGHT;
+    const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes);
     const dimMidX = (previewStart[0] + previewEnd[0]) / 2;
     const dimMidZ = (previewStart[1] + previewEnd[1]) / 2;
-    return (_jsxs("group", { children: [_jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, wallHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: wallHeight, length: liveLength, primary: "length", thickness: getWallThickness(target.wall), unit: unit }) }), canDetachCorner && (_jsx(Html, { position: [cursorLocalPos[0], 0, cursorLocalPos[2]], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
-                            ? 'border-amber-500/80 bg-amber-500/15 text-amber-100'
-                            : 'border-border bg-background/95 text-muted-foreground'}`, children: altPressed ? 'Detaching corner' : 'Alt to detach' }) }) })), angleLabel && _jsx(EndpointAngleLabel, { label: angleLabel.label, position: angleLabel.position })] }));
+    return (_jsx(LevelOffsetGroup, { children: _jsxs("group", { position: [0, wallBaseElevation, 0], children: [_jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, wallHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: wallHeight, length: liveLength, primary: "length", thickness: getWallThickness(effectiveWall), unit: unit }) }), canDetachCorner && (_jsx(Html, { position: [cursorLocalPos[0], 0, cursorLocalPos[2]], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
+                                ? 'border-amber-500/80 bg-amber-500/15 text-amber-100'
+                                : 'border-border bg-background/95 text-muted-foreground'}`, children: altPressed ? 'Detaching corner' : 'Alt to detach' }) }) })), angleLabel && (_jsx(EndpointAngleLabel, { label: angleLabel.label, position: angleLabel.position }))] }) }));
 };
 function EndpointAngleLabel({ label, position, }) {
     return (_jsx(Html, { center: true, position: position, style: { pointerEvents: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-full border border-border bg-background/95 px-2 py-1 font-mono font-semibold text-[11px] text-foreground shadow-lg backdrop-blur-md", children: label }) }));

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

@@ -1 +1 @@
-{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAMd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAazB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA0BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAkClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAqCrD"}
+{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA0BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAkClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAqCrD"}

package/dist/wall/move-shared.js

@@ -1,5 +1,6 @@
-import { DEFAULT_WALL_HEIGHT, getMaterialPresetByRef, parseMaterialRef, resolveMaterial, useScene, WallNode as WallSchema, } from '@pascal-app/core';
+import { getMaterialPresetByRef, parseMaterialRef, resolveMaterial, useScene, WallNode as WallSchema, } from '@pascal-app/core';
 import { isSegmentLongEnough } from '@pascal-app/editor';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 /**
  * Pure helpers shared by the 3D `MoveWallTool` and the 2D
  * `wallFloorplanMoveTarget`. Lives in `packages/nodes` because the
@@ -153,7 +154,7 @@ export function buildBridgeWallPreviews(args) {
             start: [...plan.originalPoint],
             end: [...nextPoint],
             color: getWallGhostColor(plan.wall),
-            height: plan.wall.height ?? DEFAULT_WALL_HEIGHT,
+            height: resolveWallOpeningCeiling(plan.wall, useScene.getState().nodes),
         };
         previews.push({ ghost, wall });
         wallsForDuplicateCheck.push(wall);

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,EAqBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAqIzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA6hBrD,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,CA4iBrD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/move-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { detectSpacesForLevel, emitter, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, pauseSceneHistory, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, projectAutoSlabsForPlan, resumeSceneHistory, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { detectSpacesForLevel, emitter, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, pauseSceneHistory, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, resolveMovedWallSupportSlabPatch, resumeSceneHistory, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, EDITOR_LAYER, getSegmentGridStep, isSegmentLongEnough, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
@@ -182,9 +182,10 @@ export const MoveWallTool = ({ node }) => {
             // re-flowed through the planner.
             const existingSlabs = getLevelSlabs(levelId, sceneState.nodes);
             const slabPlan = planAutoSlabsForLevel(roomPolygons, existingSlabs);
+            const levelNode = sceneState.nodes[levelId];
             const ceilingPlan = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
-                walls: levelWalls,
-                slabs: projectAutoSlabsForPlan(existingSlabs, slabPlan),
+                storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
+                ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
             });
             latestSurfacePlans = { slabs: slabPlan, ceilings: ceilingPlan };
             const overrideEntries = [];
@@ -435,6 +436,17 @@ export const MoveWallTool = ({ node }) => {
             // undoable step. Then drop the live overrides — the renderer
             // now reads the committed walls + polygons directly.
             commitSurfacesToStore();
+            const affectedWallIds = [
+                ...commitUpdates.map((entry) => entry.id),
+                ...bridgeCreates.map((entry) => entry.node.id),
+            ];
+            const committedNodes = useScene.getState().nodes;
+            useScene.getState().updateNodes(affectedWallIds.flatMap((id) => {
+                const wall = committedNodes[id];
+                return wall?.type === 'wall'
+                    ? [{ id, data: resolveMovedWallSupportSlabPatch(wall, committedNodes) }]
+                    : [];
+            }));
             clearSurfaceOverrides();
             clearWallOverrides();
             pauseSceneHistory(useScene);

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAmDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CAmDhB;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAoCtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAoDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CA+DhB;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAoCtB,CAAA"}