@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/wall/floorplan-affordances.js

@@ -1,23 +1,29 @@
-import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { constrainWallCurveOffsetToAvoidIntersections, getMaxWallCurveOffset, getWallChordFrame, getWallCurveFrameAt, getWallThickness, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, resolveEndpointWallSplit, snapBuildingLocalToWorldGrid, snapScalarToGrid, snapWallDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+const MIN_WALL_THICKNESS = 0.05;
 function pointsEqual(a, b) {
     return a[0] === b[0] && a[1] === b[1];
 }
-function collectLevelWalls(nodes, excludeWallId) {
+function collectLevelWalls(nodes, parentId, excludeWallId) {
     const out = [];
     for (const node of Object.values(nodes)) {
-        if (node?.type === 'wall' && node.id !== excludeWallId)
+        if (node?.type === 'wall' &&
+            node.id !== excludeWallId &&
+            (node.parentId ?? null) === parentId) {
             out.push(node);
+        }
     }
     return out;
 }
-function collectLinkedWalls(nodes, draggedWallId, originalStart, originalEnd) {
+function collectLinkedWalls(nodes, draggedWallId, parentId, originalStart, originalEnd) {
     const linked = [];
     for (const node of Object.values(nodes)) {
         if (node?.type !== 'wall')
             continue;
         if (node.id === draggedWallId)
             continue;
+        if ((node.parentId ?? null) !== parentId)
+            continue;
         const wall = node;
         if (pointsEqual(wall.start, originalStart) ||
             pointsEqual(wall.start, originalEnd) ||
@@ -65,7 +71,9 @@ export const wallCurveAffordance = {
                 const offsetFromMidpoint = -((x - chord.midpoint.x) * chord.normal.x +
                     (y - chord.midpoint.y) * chord.normal.y);
                 const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
-                const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const requestedCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const sceneNodes = useScene.getState().nodes;
+                const nextCurveOffset = constrainWallCurveOffsetToAvoidIntersections(node, requestedCurveOffset, Object.values(sceneNodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId));
                 lastCurveOffset = nextCurveOffset;
                 // Publish the curve preview as a live override so renderers see
                 // it without zustand churn. Mark the wall dirty so `WallSystem`
@@ -89,13 +97,43 @@ export const wallCurveAffordance = {
         };
     },
 };
+export const wallThicknessAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { side } = payload;
+        const frame = getWallCurveFrameAt(node, 0.5);
+        const outwardX = frame.normal.x * side;
+        const outwardY = frame.normal.y * side;
+        const initialThickness = getWallThickness(node);
+        const wallId = node.id;
+        let lastThickness = initialThickness;
+        return {
+            affectedIds: [wallId],
+            apply({ planPoint }) {
+                const outwardDelta = (planPoint[0] - initialPlanPoint[0]) * outwardX +
+                    (planPoint[1] - initialPlanPoint[1]) * outwardY;
+                const rawThickness = initialThickness + outwardDelta * 2;
+                lastThickness = Math.max(MIN_WALL_THICKNESS, snapScalarToGrid(rawThickness, getSegmentGridStep()));
+                useLiveNodeOverrides.getState().set(wallId, { thickness: lastThickness });
+                useScene.getState().markDirty(wallId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([{ id: wallId, data: { thickness: lastThickness } }]);
+                useLiveNodeOverrides.getState().clear(wallId);
+            },
+        };
+    },
+};
 export const wallMoveEndpointAffordance = {
     start({ node, payload, nodes }) {
         const { endpoint } = payload;
         const fixedPoint = endpoint === 'start' ? [...node.end] : [...node.start];
         const originalStart = [...node.start];
         const originalEnd = [...node.end];
-        const linkedWalls = collectLinkedWalls(nodes, node.id, originalStart, originalEnd);
+        const parentId = (node.parentId ?? null);
+        const linkedWalls = collectLinkedWalls(nodes, node.id, parentId, originalStart, originalEnd);
         const affectedIds = [node.id, ...linkedWalls.map((w) => w.id)];
         const movingOriginal = endpoint === 'start' ? originalStart : originalEnd;
         // Walls attached to the MOVING corner cascade with the drag, but the snap
@@ -123,7 +161,7 @@ export const wallMoveEndpointAffordance = {
                 // the moving corner are excluded (stale coordinates); under
                 // Alt-detach they stay put, so they rejoin the candidate pool.
                 const sceneNodes = useScene.getState().nodes;
-                const walls = collectLevelWalls(sceneNodes, node.id);
+                const walls = collectLevelWalls(sceneNodes, parentId, node.id);
                 const staleWallIds = modifiers.altKey ? [node.id] : [node.id, ...movingLinkedWallIds];
                 // The grid step follows the active snapping mode (`getSegmentGridStep()`
                 // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
@@ -153,6 +191,7 @@ export const wallMoveEndpointAffordance = {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isAlignmentGuideActive(),
                     excludeIds: staleWallIds,
+                    levelId: parentId,
                 });
                 const primaryStart = endpoint === 'start' ? aligned : fixedPoint;
                 const primaryEnd = endpoint === 'end' ? aligned : fixedPoint;

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

@@ -23,10 +23,9 @@ import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings 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.
  */
 export declare const wallFloorplanMoveTarget: FloorplanMoveTarget<WallNode>;
 //# sourceMappingURL=floorplan-move.d.ts.map

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,EAGL,KAAK,mBAAmB,EAOxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiRjE,CAAA"}
+{"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"}

package/dist/wall/floorplan-move.js

@@ -1,7 +1,13 @@
-import { getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+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 { 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.
  *
@@ -26,10 +32,9 @@ import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings 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.
  */
 export const wallFloorplanMoveTarget = ({ node }) => {
     const wallId = node.id;
@@ -72,8 +77,75 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastDelta = [0, 0];
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
+    const levelId = node.parentId ?? null;
+    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)
+            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 nextIds = new Set(entries.map(([id]) => id));
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            if (nextIds.has(id))
+                continue;
+            overrides.clear(id);
+            sceneState.markDirty(id);
+            touchedSurfaceIds.delete(id);
+        }
+        if (entries.length > 0) {
+            overrides.setMany(entries);
+            for (const [id] of entries) {
+                touchedSurfaceIds.add(id);
+                if (!affectedIdSet.has(id)) {
+                    affectedIdSet.add(id);
+                    affectedIds.push(id);
+                }
+                sceneState.markDirty(id);
+            }
+        }
+    };
+    const clearSurfacePreviews = () => {
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            overrides.clear(id);
+            sceneState.markDirty(id);
+        }
+        touchedSurfaceIds.clear();
+        latestSurfacePlans = null;
+    };
     const session = {
-        affectedIds: [wallId, ...linkedOriginals.map((w) => w.id)],
+        affectedIds,
         apply({ planPoint }) {
             if (!rawAnchor) {
                 rawAnchor = [planPoint[0], planPoint[1]];
@@ -168,6 +240,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 thickness: getFloorplanWallThickness(wall),
             }));
             useWallMoveGhosts.getState().setBridges(ghostBridges);
+            publishSurfacePreviews([...previewSceneWalls, ...bridgePreviews.map(({ wall }) => wall)]);
             // `WallSystem` only runs its rebuild pass when `dirtyNodes` is
             // non-empty. We're not writing to scene any more, but we still
             // need the system to pick up the live override changes — so
@@ -195,6 +268,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 overrides.clear(wallId);
                 for (const wall of linkedOriginals)
                     overrides.clear(wall.id);
+                clearSurfacePreviews();
                 return;
             }
             const plan = planWallMoveJunctions(linkedOriginals, originalStart, originalEnd, lastNextStart, lastNextEnd);
@@ -232,10 +306,48 @@ 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,
-                create: bridgeCreates,
-                delete: Array.from(collapsedLinkedWallIds),
+                update: [
+                    ...commitUpdates,
+                    ...surfaceUpdates,
+                ],
+                create: [...bridgeCreates, ...surfaceCreates],
+                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
             });
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
@@ -246,6 +358,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             overrides.clear(wallId);
             for (const wall of linkedOriginals)
                 overrides.clear(wall.id);
+            clearSurfacePreviews();
             // Swap ghosts → real walls: the bridges we just created render
             // through the registry layer, so the dashed previews aren't
             // needed any more. Clearing here (instead of waiting for the

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;AAWlC,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,CAoMjG"}
+{"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"}

package/dist/wall/floorplan.js

@@ -2,6 +2,7 @@ import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallM
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards';
 import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions';
+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
 // drifting from BIM data. Inlined to keep nodes/wall self-contained.
@@ -190,6 +191,20 @@ export function buildWallFloorplan(node, ctx) {
             affordance: 'move-endpoint',
             payload: { wallId: node.id, endpoint: 'end' },
         });
+        const thicknessFrame = getWallCurveFrameAt(self, 0.5);
+        const halfVisibleThickness = getWallThickness(self) / 2;
+        for (const side of [1, -1]) {
+            children.push({
+                kind: 'endpoint-handle',
+                point: [
+                    thicknessFrame.point.x + thicknessFrame.normal.x * halfVisibleThickness * side,
+                    thicknessFrame.point.y + thicknessFrame.normal.y * halfVisibleThickness * side,
+                ],
+                state: 'idle',
+                affordance: 'thickness',
+                payload: { wallId: node.id, side },
+            });
+        }
         // Side move arrows — two directional arrows at the wall midpoint,
         // pointing outward perpendicular to the wall. Mirrors the 3D
         // `WallMoveSideHandles` arrows so users can grab the wall body
@@ -217,11 +232,10 @@ export function buildWallFloorplan(node, ctx) {
             }
         }
         // Curve sagitta handle — teal dot at the wall midpoint that
-        // controls `curveOffset`. Hidden when the wall hosts a door /
-        // window / wall-attached item: bending the wall would tear those
-        // children, so the legacy disables the handle in that case (see
-        // `wallCurveHandles.hasWallChildrenBlockingCurve`).
-        if (!hasCurveBlockingChildren(ctx.children)) {
+        // controls `curveOffset`. Hidden when the wall hosts an opening,
+        // lean-to extension, or wall-attached item because bending the host
+        // would tear the child geometry away from it.
+        if (!hasWallCurveBlockingChildren(ctx.children)) {
             const handle = getWallMidpointHandlePoint(node);
             children.push({
                 kind: 'endpoint-handle',
@@ -271,21 +285,3 @@ function wallDimensionDatumPolicy(reference) {
             return 'wall-face';
     }
 }
-/**
- * Doors, windows, and wall-attached items would tear if the wall bent
- * around them, so the curve sagitta handle hides when any of those
- * children exist. Mirrors the legacy
- * `wallCurveHandles.hasWallChildrenBlockingCurve` check.
- */
-function hasCurveBlockingChildren(children) {
-    for (const child of children) {
-        if (child.type === 'door' || child.type === 'window')
-            return true;
-        if (child.type === 'item') {
-            const attachTo = child.asset?.attachTo;
-            if (attachTo === 'wall' || attachTo === 'wall-side')
-                return true;
-        }
-    }
-    return false;
-}

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,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"}
+{"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;AA4BD,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,CAoClD;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,CAyCrD"}

package/dist/wall/move-shared.js

@@ -61,9 +61,10 @@ export function getLinkedWallSnapshots(args) {
     }
     return snapshots;
 }
-function wallSegmentExists(walls, start, end) {
-    return walls.some((wall) => (samePoint(wall.start, start) && samePoint(wall.end, end)) ||
-        (samePoint(wall.start, end) && samePoint(wall.end, start)));
+function wallSegmentExists(walls, start, end, parentId) {
+    return walls.some((wall) => wall.parentId === parentId &&
+        ((samePoint(wall.start, start) && samePoint(wall.end, end)) ||
+            (samePoint(wall.start, end) && samePoint(wall.end, start))));
 }
 // Resolve a wall slot ref (`library:`/`scene:`) to a swatch colour, or
 // undefined when the ref is absent / dangling / colourless.
@@ -108,7 +109,7 @@ export function buildBridgeWallCreates(args) {
         if (!isSegmentLongEnough(plan.originalPoint, nextPoint)) {
             continue;
         }
-        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint)) {
+        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint, plan.wall.parentId)) {
             continue;
         }
         const { id: _id, parentId: _parentId, children: _children, ...sourceWall } = plan.wall;
@@ -124,20 +125,22 @@ export function buildBridgeWallCreates(args) {
             node: bridgeWall,
             parentId: (plan.wall.parentId ?? undefined),
         });
-        wallsForDuplicateCheck.push(bridgeWall);
+        wallsForDuplicateCheck.push({ ...bridgeWall, parentId: plan.wall.parentId });
     }
     return creates;
 }
 export function buildBridgeWallPreviews(args) {
     const { bridgePlans, nextStart, nextEnd, existingWalls } = args;
-    const wallsForDuplicateCheck = [...existingWalls];
+    const wallsForDuplicateCheck = [
+        ...existingWalls,
+    ];
     const previews = [];
     for (const plan of bridgePlans) {
         const nextPoint = plan.movedEndpoint === 'start' ? nextStart : nextEnd;
         if (!isSegmentLongEnough(plan.originalPoint, nextPoint)) {
             continue;
         }
-        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint)) {
+        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint, plan.wall.parentId)) {
             continue;
         }
         const { id: _id, children: _children, ...sourceWall } = plan.wall;

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;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"}
+{"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;AAEzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAqDpF;;;;;;;;;;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"}

package/dist/wall/paint.js

@@ -1,4 +1,5 @@
 import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { setSurfaceRaycastLayers } from '@pascal-app/viewer';
 import { Raycaster } from 'three';
 import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
@@ -20,6 +21,7 @@ const WALL_INDEX_SLOT = new Map(Object.entries(WALL_ARRAY_SLOT_INDEX).map(([slot
     slotId,
 ]));
 const wallSlotRaycaster = new Raycaster();
+setSurfaceRaycastLayers(wallSlotRaycaster.layers);
 function resolveSideFromMaterialIndex(materialIndex) {
     const slotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
     if (slotId)

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAoEA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAwRhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AA0FA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8ThC"}

package/dist/wall/panel.js

@@ -1,11 +1,28 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { buildWallFaceBandCountPatch, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, getWallFaceBandConfig, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, curveReshapeScope, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { buildWallFaceBandCountPatch, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, getWallFaceBandConfig, normalizeWallCurveOffset, terrainSupportLift, useLiveNodeOverrides, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, curveReshapeScope, formatLinearMeasurement, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Spline } from 'lucide-react';
 import { useCallback, useMemo, useRef } from 'react';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
+/**
+ * Base half of the plane-bound repair: a stamped draft offset goes, and a
+ * ground host is dropped unless sculpted terrain actually supports it — a
+ * terrain-less ground host (regression-era data) pins the base at the level
+ * floor and buries the wall in any later slab.
+ */
+function wallBaseRepairPatch(n) {
+    const nodes = useScene.getState().nodes;
+    const terrainSupported = n.parentId != null && terrainSupportLift(nodes, n.parentId, n.start[0], n.start[1]) != null;
+    return {
+        supportOffset: undefined,
+        ...(n.supportSlabId === GROUND_SUPPORT_ID && !terrainSupported
+            ? { supportSlabId: undefined }
+            : {}),
+    };
+}
 const WALL_TRIM_PROFILE_OPTIONS = {
     skirting: [
         { label: 'Flat', value: 'flat' },
@@ -47,22 +64,14 @@ export default function WallPanel() {
         return { ...sceneNode, ...liveOverride };
     }, [sceneNode, liveOverride]);
     // Boolean selector — re-renders only when this specific wall's child
-    // composition crosses the "has a door/window/wall-item" threshold.
+    // composition crosses the "has an incompatible hosted child" threshold.
     const hasWallChildrenBlockingCurve = useScene((s) => {
         if (!node)
             return false;
-        return (node.children ?? []).some((childId) => {
+        return hasWallCurveBlockingChildren((node.children ?? []).flatMap((childId) => {
             const child = s.nodes[childId];
-            if (!child)
-                return false;
-            if (child.type === 'door' || child.type === 'window')
-                return true;
-            if (child.type === 'item') {
-                const attachTo = child.asset?.attachTo;
-                return attachTo === 'wall' || attachTo === 'wall-side';
-            }
-            return false;
-        });
+            return child ? [child] : [];
+        }));
     });
     // Existing plane-bound walls have no stored height. Resolve their current
     // body height for display and materialize it if the user edits height or
@@ -103,15 +112,37 @@ export default function WallPanel() {
         ];
         handleUpdate({ end: newEnd });
     }, [handleUpdate]);
-    const handleBaseModeChange = useCallback((mode) => {
+    const handleTopModeChange = useCallback((mode) => {
         const n = nodeRef.current;
         if (!n)
             return;
-        const height = n.height ?? resolveWallOpeningCeiling(n, useScene.getState().nodes);
-        handleUpdate({
-            height: Math.max(0.1, height),
-            fillToTerrain: mode === 'terrain' ? true : undefined,
-        });
+        const isCustom = n.height != null;
+        if (mode === 'custom' && !isCustom) {
+            // Seed from the current effective height so the geometry doesn't
+            // jump at the moment of detaching from the storey plane.
+            const seeded = resolveWallOpeningCeiling(n, useScene.getState().nodes);
+            handleUpdate({ height: Math.max(0.1, seeded) });
+        }
+        else if (mode === 'storey' && isCustom) {
+            // Absent `height` = plane-bound; the store strips undefined keys.
+            handleUpdate({ height: undefined, ...wallBaseRepairPatch(n) });
+        }
+    }, [handleUpdate]);
+    // Terrain infill only extends the bottom; it must never materialize an
+    // explicit height, or toggling it would silently detach the wall top from
+    // the storey plane. "Auto" is a re-election, so it carries the same base
+    // repair as the follows-level toggle — and the control fires on a click of
+    // the already-selected segment, so regression-era walls that DISPLAY Auto
+    // while secretly ground-pinned heal from a click on Auto itself.
+    const handleInfillChange = useCallback((mode) => {
+        const n = nodeRef.current;
+        if (!n)
+            return;
+        if (mode === 'terrain') {
+            handleUpdate({ fillToTerrain: true });
+            return;
+        }
+        handleUpdate({ fillToTerrain: undefined, ...wallBaseRepairPatch(n) });
     }, [handleUpdate]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
@@ -127,6 +158,7 @@ export default function WallPanel() {
         return null;
     const length = getWallCurveLength(node);
     const followsTerrain = node.fillToTerrain === true;
+    const isPlaneBound = node.height == null;
     const height = node.height ?? resolvedHeightMeters ?? 2.5;
     const thickness = node.thickness ?? 0.1;
     const curveOffset = getClampedWallCurveOffset(node);
@@ -142,14 +174,17 @@ export default function WallPanel() {
     const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
     const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
     const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
-    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(20, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 20, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(6, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
-                            height: linearControlValueToMeters(v, unit, { maxMeters: 6, minMeters: 0.1 }),
-                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Base" }), _jsx(SegmentedControl, { onChange: handleBaseModeChange, options: [
-                            { label: 'Fixed', value: 'fixed' },
-                            { label: 'Follows level', value: 'terrain' },
-                        ], value: followsTerrain ? 'terrain' : 'fixed' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
+    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 1000, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Top" }), _jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
+                            { label: 'Follows level', value: 'storey' },
+                            { label: 'Custom height', value: 'custom' },
+                        ], value: isPlaneBound ? 'storey' : 'custom' }), isPlaneBound ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(height, unit)] })) : (_jsx(SliderControl, { label: "Height", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
+                            height: linearControlValueToMeters(v, unit, { maxMeters: 1000, minMeters: 0.1 }),
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 })), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Bottom" }), _jsx(SegmentedControl, { onChange: handleInfillChange, options: [
+                            { label: 'Auto', value: 'auto' },
+                            { label: 'Fill to terrain', value: 'terrain' },
+                        ], value: followsTerrain ? 'terrain' : 'auto' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
                             thickness: linearControlValueToMeters(v, unit, {
-                                maxMeters: 1,
+                                maxMeters: 1000,
                                 minMeters: 0.05,
                             }),
                         }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 }), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handleUpdate({

package/dist/wall/parametrics.js

@@ -15,10 +15,10 @@ export const wallParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 0.6, step: 0.01 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.01 },
                 // `height` may be absent (plane-bound top); the custom panel owns the
                 // Follows storey / Custom height mode switch, so this is metadata only.
-                { key: 'height', kind: 'number', unit: 'm', min: 1.5, max: 6, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 },
                 { key: 'curveOffset', kind: 'number', unit: 'm', min: -3, max: 3, step: 0.05 },
             ],
         },