@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/cabinet/wall-snap.js

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, getWallArcData, getWallCurveFrameAt, getWallPlanFootprint, getWallThickness, isCurvedWall, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallArcData, getWallCurveFrameAt, getWallLocalFaceZ, getWallPlanFootprint, isCurvedWall, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
 import { snapCabinetFootprintCenter } from './placement-snap';
 import { planToRunLocal, runLocalToPlan } from './run-layout';
 const EDGE_SNAP_THRESHOLD = 0.08;
@@ -190,7 +190,7 @@ function resolveCabinetWallUsableSpan({ depth, excludeIds, hit, nodes, parentLev
     const excluded = new Set(excludeIds);
     const frontNormal = [-hit.dirY, hit.dirX];
     const normalScale = hit.side === 'front' ? 1 : -1;
-    const faceZ = normalScale * (getWallThickness(hit.wall) / 2);
+    const faceZ = getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     const outerZ = faceZ + normalScale * depth;
     let start = 0;
     let end = hit.wallLength;
@@ -249,16 +249,16 @@ function cabinetRunWidthAndCenterOffset(cabinet, nodes) {
 }
 export function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }) {
     if (isCurvedWall(hit.wall)) {
-        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+        return getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     }
     const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === parentLevelId);
     if (walls.length === 0) {
-        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+        return getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     }
     const miterData = calculateLevelMiters(walls);
     const footprint = getWallPlanFootprint(hit.wall, miterData);
     if (footprint.length < 3) {
-        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+        return getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     }
     const frontNormal = [-hit.dirY, hit.dirX];
     const localPoints = footprint.map((point) => {
@@ -291,7 +291,7 @@ export function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }) {
         zIntersections.push(a.z + (b.z - a.z) * t);
     }
     if (zIntersections.length === 0) {
-        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+        return getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     }
     return hit.side === 'front' ? Math.max(...zIntersections) : Math.min(...zIntersections);
 }
@@ -301,7 +301,7 @@ export function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds = [], p
     const frontNormal = [-hit.dirY, hit.dirX];
     const normalScale = hit.side === 'front' ? 1 : -1;
     const yaw = Math.atan2(frontNormal[0] * normalScale, frontNormal[1] * normalScale);
-    const wallFaceOffset = getWallThickness(hit.wall) / 2;
+    const wallFaceOffset = getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b') * normalScale;
     const neighbors = [];
     const excluded = new Set(excludeIds);
     for (const node of Object.values(nodes)) {
@@ -353,7 +353,7 @@ export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffse
     const frontNormal = [frame.normal.x, frame.normal.y];
     const normalScale = hit.side === 'front' ? 1 : -1;
     const normal = [frontNormal[0] * normalScale, frontNormal[1] * normalScale];
-    const resolvedFaceOffset = faceOffset ?? (normalScale * getWallThickness(hit.wall)) / 2;
+    const resolvedFaceOffset = faceOffset ?? getWallLocalFaceZ(hit.wall, hit.side === 'front' ? 'a' : 'b');
     const cabinetCenterOffset = resolvedFaceOffset + normalScale * (depth / 2);
     const guideOffset = resolvedFaceOffset;
     const guideStart = projectCabinetWallLocalPointToPlan(hit, Math.max(startStop, localX - halfWidth), guideOffset);

package/dist/ceiling/boundary-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAazB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAAE,CAwJ5E,CAAA;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAazB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAAE,CA0J5E,CAAA;AAED,eAAe,qBAAqB,CAAA"}

package/dist/ceiling/boundary-editor.js

@@ -17,7 +17,7 @@ import { useCallback, useEffect, useMemo, useRef } from 'react';
  */
 export const CeilingBoundaryEditor = ({ ceilingId, }) => {
     const ceilingNode = useScene((s) => s.nodes[ceilingId]);
-    const updateNode = useScene((s) => s.updateNode);
+    const detachDerivedNode = useScene((s) => s.detachDerivedNode);
     const markDirty = useScene((s) => s.markDirty);
     const setSelection = useViewer((s) => s.setSelection);
     const setHoveredId = useViewer((s) => s.setHoveredId);
@@ -35,9 +35,11 @@ export const CeilingBoundaryEditor = ({ ceilingId, }) => {
         : null;
     const handlePolygonChange = useCallback((newPolygon) => {
         clearCeilingSnapFeedback();
-        updateNode(ceilingId, { polygon: newPolygon });
+        // Reshaping the boundary is the sanctioned conversion of a derived
+        // ceiling into an authored one — the reconciler stops owning it here.
+        detachDerivedNode(ceilingId, { polygon: newPolygon });
         setSelection({ selectedIds: [ceilingId] });
-    }, [ceilingId, updateNode, setSelection]);
+    }, [ceilingId, detachDerivedNode, setSelection]);
     const handlePolygonPreview = useCallback((preview) => {
         if (preview) {
             ownsPolygonPreviewRef.current = true;

package/dist/ceiling/definition.d.ts

@@ -7,10 +7,10 @@ import { CeilingNode } from './schema';
  *
  * **Stage B intentionally skipped**: pure `def.geometry` extraction
  * would lose the React children rendering (hosted items) and the
- * named-mesh structure. Ceiling keeps `def.renderer` as the custom
- * escape hatch (per plans/editor-node-registry.md "custom-behavior
- * escape hatch"). Renderer wraps the legacy CeilingRenderer; system
- * wraps the legacy CeilingSystem.
+ * named-mesh structure. Ceiling keeps `def.renderer` as its escape hatch
+ * ("Opting out of a generic path" in wiki/architecture/node-definitions.md).
+ * Renderer wraps the legacy CeilingRenderer; system wraps the legacy
+ * CeilingSystem.
  *
  * **Stage C completed**: `def.floorplan` builder draws the ceiling
  * polygon as a dashed outline in floor plan; legacy `ceilingPolygons`

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAmFtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAiHhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAuBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA+EtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAuHhE,CAAA"}

package/dist/ceiling/definition.js

@@ -1,25 +1,24 @@
-import { getCeilingClampBound, resolveCeilingHeight, useScene, } from '@pascal-app/core';
+import { ceilingSlots, resolveCeilingHeight, useScene, } from '@pascal-app/core';
 import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { surfaceBatchable } from '../shared/node-batch/batchable';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts';
 import { buildCeilingFloorplan } from './floorplan';
 import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances';
 import { ceilingFloorplanMoveTarget } from './floorplan-move';
+import { CEILING_HANDLE_MIN_HEIGHT, ceilingHeightRange } from './height-bounds';
 import { ceilingPaint } from './paint';
 import { ceilingParametrics } from './parametrics';
 import { CeilingNode } from './schema';
-import { ceilingSlots } from './slots';
 const HEIGHT_HANDLE_OFFSET = 0.22;
-const MIN_CEILING_HEIGHT = 0.5;
 // Ceilings no longer drive the storey height; the stored level height
 // does. Height writes clamp under min(storey plane, lowest underside of
 // any covering slab from the level above) − CEILING_CLAMP_MARGIN, so a
 // ceiling can poke into neither the level above nor a deck hanging from
-// it (clamp, never ask).
-function ceilingHeightBound(n, sceneApi) {
-    const parent = n.parentId ? sceneApi.get(n.parentId) : undefined;
-    return parent?.type === 'level'
-        ? getCeilingClampBound(parent.id, sceneApi.nodes(), n.polygon ?? [])
-        : Number.POSITIVE_INFINITY;
+// it (clamp, never ask). On a level above grade the ceiling may hang below
+// the level floor down to grade (soffits owned by a roof level).
+function ceilingHeightBounds(n, sceneApi) {
+    return ceilingHeightRange(n, sceneApi.nodes(), CEILING_HANDLE_MIN_HEIGHT);
 }
 function ceilingPolygonCenter(n) {
     const polygon = n.polygon ?? [];
@@ -59,8 +58,8 @@ function ceilingHeightHandle() {
         kind: 'linear-resize',
         axis: 'y',
         anchor: 'min',
-        min: MIN_CEILING_HEIGHT,
-        max: ceilingHeightBound,
+        min: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).min,
+        max: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).max,
         currentValue: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
         magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(ceilingElevationGuideSource(n), newValue, sceneApi.nodes()),
         onDrag: (n, sceneApi) => publishStructuralElevationGuide(ceilingElevationGuideSource(n), resolveCeilingHeight(n, sceneApi.nodes()), sceneApi.nodes()),
@@ -84,10 +83,10 @@ function ceilingHandles(_node) {
  *
  * **Stage B intentionally skipped**: pure `def.geometry` extraction
  * would lose the React children rendering (hosted items) and the
- * named-mesh structure. Ceiling keeps `def.renderer` as the custom
- * escape hatch (per plans/editor-node-registry.md "custom-behavior
- * escape hatch"). Renderer wraps the legacy CeilingRenderer; system
- * wraps the legacy CeilingSystem.
+ * named-mesh structure. Ceiling keeps `def.renderer` as its escape hatch
+ * ("Opting out of a generic path" in wiki/architecture/node-definitions.md).
+ * Renderer wraps the legacy CeilingRenderer; system wraps the legacy
+ * CeilingSystem.
  *
  * **Stage C completed**: `def.floorplan` builder draws the ceiling
  * polygon as a dashed outline in floor plan; legacy `ceilingPolygons`
@@ -105,6 +104,9 @@ export const ceilingDefinition = {
             kind: 'ceiling',
             raycast: 'underside',
         },
+        'pascal:editor/floorplan': {
+            selectionCounterparts: sameOutlineSurfaceCounterparts,
+        },
     },
     // Height-less on purpose: a new ceiling follows the level top until the
     // user gives it an explicit custom height.
@@ -120,8 +122,10 @@ export const ceilingDefinition = {
         autoFromWalls: false,
     }),
     capabilities: {
+        batchable: surfaceBatchable,
         selectable: { hitVolume: 'bbox' },
         surfaces: {
+            hosting: false,
             top: {
                 height: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
             },
@@ -167,6 +171,7 @@ export const ceilingDefinition = {
         priority: 4,
     },
     floorplan: buildCeilingFloorplan,
+    floorplanDependsOnSiblings: true,
     // 2D move handler — translates polygon by cursor delta from first
     // pointer position. Mirror of slab; 3D `MoveCeilingTool` skips
     // 2D-sourced grid events so they don't double-write on commit.

package/dist/ceiling/floorplan-affordances.d.ts

@@ -9,7 +9,8 @@ export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").Flo
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "stair" | "elevator" | "manual";
+        source: "room" | "stair" | "elevator" | "manual" | "floor-opening";
+        openingId?: string | undefined;
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -22,6 +23,17 @@ export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").Flo
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     material?: {
         id?: string | undefined;
         preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
@@ -41,7 +53,15 @@ export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").Flo
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    openingIds?: string[] | undefined;
     height?: number | undefined;
+    regions?: {
+        id: string;
+        polygon: [number, number][];
+        finish: string | Record<string, unknown>;
+    }[] | undefined;
+    boundary?: "auto" | undefined;
+    zoneId?: string | undefined;
 }>;
 export declare const ceilingAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -54,7 +74,8 @@ export declare const ceilingAddVertexAffordance: import("@pascal-app/core").Floo
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "stair" | "elevator" | "manual";
+        source: "room" | "stair" | "elevator" | "manual" | "floor-opening";
+        openingId?: string | undefined;
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -67,6 +88,17 @@ export declare const ceilingAddVertexAffordance: import("@pascal-app/core").Floo
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     material?: {
         id?: string | undefined;
         preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
@@ -86,7 +118,15 @@ export declare const ceilingAddVertexAffordance: import("@pascal-app/core").Floo
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    openingIds?: string[] | undefined;
     height?: number | undefined;
+    regions?: {
+        id: string;
+        polygon: [number, number][];
+        finish: string | Record<string, unknown>;
+    }[] | undefined;
+    boundary?: "auto" | undefined;
+    zoneId?: string | undefined;
 }>;
 export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -99,7 +139,8 @@ export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").Floor
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "stair" | "elevator" | "manual";
+        source: "room" | "stair" | "elevator" | "manual" | "floor-opening";
+        openingId?: string | undefined;
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -112,6 +153,17 @@ export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").Floor
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     material?: {
         id?: string | undefined;
         preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
@@ -131,7 +183,15 @@ export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").Floor
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    openingIds?: string[] | undefined;
     height?: number | undefined;
+    regions?: {
+        id: string;
+        polygon: [number, number][];
+        finish: string | Record<string, unknown>;
+    }[] | undefined;
+    boundary?: "auto" | undefined;
+    zoneId?: string | undefined;
 }>;
 export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -144,7 +204,8 @@ export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").F
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "stair" | "elevator" | "manual";
+        source: "room" | "stair" | "elevator" | "manual" | "floor-opening";
+        openingId?: string | undefined;
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -157,6 +218,17 @@ export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").F
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     material?: {
         id?: string | undefined;
         preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
@@ -176,6 +248,14 @@ export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").F
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    openingIds?: string[] | undefined;
     height?: number | undefined;
+    regions?: {
+        id: string;
+        polygon: [number, number][];
+        finish: string | Record<string, unknown>;
+    }[] | undefined;
+    boundary?: "auto" | undefined;
+    zoneId?: string | undefined;
 }>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/ceiling/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-affordances.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA;AACD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrC,CAAA;AACD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzC,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-affordances.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA;AACD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrC,CAAA;AACD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzC,CAAA"}

package/dist/ceiling/floorplan-affordances.js

@@ -8,7 +8,6 @@ import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance,
  * full contract.
  */
 const ceilingSnapOptions = {
-    boundaryCommitData: { autoFromWalls: false },
     resolvePlanPoint({ node, nodes, rawPoint, fallbackPoint, }) {
         const sceneNodes = nodes;
         return resolveCeilingPlanPointSnap({

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,mBAAmB,EAAwB,MAAM,kBAAkB,CAAA;AAGnG;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,WAAW,CAMpE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,mBAAmB,EAAwB,MAAM,kBAAkB,CAAA;AAGnG;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,WAAW,CAKpE,CAAA"}

package/dist/ceiling/floorplan-move.js

@@ -13,5 +13,4 @@ export const ceilingFloorplanMoveTarget = ({ node, nodes }) => createPolygonCent
     node,
     nodes,
     meshY: resolveCeilingHeight(node, nodes) - 0.01,
-    extraCommitData: node.autoFromWalls ? { autoFromWalls: false } : undefined,
 });

package/dist/ceiling/floorplan.d.ts

@@ -1,4 +1,4 @@
-import type { CeilingNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import { type CeilingNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
 /**
  * Stage C floor-plan builder for ceiling. Dashed boundary (ceilings sit
  * above the slab); when selected, mounts the same boundary editor as

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B"}

package/dist/ceiling/floorplan.js

@@ -1,3 +1,4 @@
+import { cutterContextNodes, hostedCutterHoles, } from '@pascal-app/core';
 /**
  * Stage C floor-plan builder for ceiling. Dashed boundary (ceilings sit
  * above the slab); when selected, mounts the same boundary editor as
@@ -22,7 +23,7 @@ export function buildCeilingFloorplan(node, ctx) {
     };
     const segments = [ring(outer)];
     const holes = node.holes ?? [];
-    for (const hole of holes) {
+    for (const hole of [...holes, ...hostedCutterHoles(node, cutterContextNodes(node, ctx))]) {
         if (hole.length < 3)
             continue;
         segments.push(ring(hole.map(([x, z]) => [x, z])));

package/dist/ceiling/height-bounds.d.ts

@@ -0,0 +1,19 @@
+import { type AnyNode, type AnyNodeId, type CeilingNode } from '@pascal-app/core';
+/** Handle floor for a ceiling at grade: keeps the drag arrow off the floor. */
+export declare const CEILING_HANDLE_MIN_HEIGHT = 0.5;
+/** Panel slider floor for a ceiling at grade. */
+export declare const CEILING_PANEL_MIN_HEIGHT = 0;
+export type CeilingHeightRange = {
+    min: number;
+    max: number;
+};
+/**
+ * Where a ceiling's stored height may go. `max` clamps under the storey
+ * plane and any covering slab from the level above (clamp, never ask);
+ * `min` lets a ceiling on a level above grade hang down to grade, and
+ * keeps `atGradeMin` on the ground storey.
+ */
+export declare function ceilingHeightRange(ceiling: Pick<CeilingNode, 'parentId' | 'polygon'>, nodes: Record<AnyNodeId, AnyNode>, atGradeMin: number): CeilingHeightRange;
+/** Same order as the slider and handle clamps: the upper bound wins a conflict. */
+export declare function clampCeilingHeight(height: number, range: CeilingHeightRange): number;
+//# sourceMappingURL=height-bounds.d.ts.map

package/dist/ceiling/height-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-bounds.d.ts","sourceRoot":"","sources":["../../src/ceiling/height-bounds.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAGjB,MAAM,kBAAkB,CAAA;AAEzB,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAC5C,iDAAiD;AACjD,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7D;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,SAAS,CAAC,EAClD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,UAAU,EAAE,MAAM,GACjB,kBAAkB,CAOpB;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAEpF"}

package/dist/ceiling/height-bounds.js

@@ -0,0 +1,24 @@
+import { getCeilingClampBound, getCeilingMinHeight, } from '@pascal-app/core';
+/** Handle floor for a ceiling at grade: keeps the drag arrow off the floor. */
+export const CEILING_HANDLE_MIN_HEIGHT = 0.5;
+/** Panel slider floor for a ceiling at grade. */
+export const CEILING_PANEL_MIN_HEIGHT = 0;
+/**
+ * Where a ceiling's stored height may go. `max` clamps under the storey
+ * plane and any covering slab from the level above (clamp, never ask);
+ * `min` lets a ceiling on a level above grade hang down to grade, and
+ * keeps `atGradeMin` on the ground storey.
+ */
+export function ceilingHeightRange(ceiling, nodes, atGradeMin) {
+    const parent = ceiling.parentId ? nodes[ceiling.parentId] : undefined;
+    if (parent?.type !== 'level')
+        return { min: atGradeMin, max: Number.POSITIVE_INFINITY };
+    return {
+        min: getCeilingMinHeight(parent.id, nodes, atGradeMin),
+        max: getCeilingClampBound(parent.id, nodes, ceiling.polygon ?? []),
+    };
+}
+/** Same order as the slider and handle clamps: the upper bound wins a conflict. */
+export function clampCeilingHeight(height, range) {
+    return Math.min(range.max, Math.max(range.min, height));
+}

package/dist/ceiling/hole-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hole-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/hole-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAKzB;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC;IACvC,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;CAClB,CAwDA,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"hole-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/hole-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAKzB;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC;IACvC,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;CAClB,CAuDA,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/ceiling/hole-editor.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { resolveCeilingHeight, resolveLevelId, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { PolygonEditor } from '@pascal-app/editor';
+import { PolygonEditor, setCeilingHoles } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect } from 'react';
 /**
@@ -9,7 +9,6 @@ import { useCallback, useEffect } from 'react';
  */
 export const CeilingHoleEditor = ({ ceilingId, holeIndex }) => {
     const ceilingNode = useScene((s) => s.nodes[ceilingId]);
-    const updateNode = useScene((s) => s.updateNode);
     const markDirty = useScene((s) => s.markDirty);
     const setSelection = useViewer((s) => s.setSelection);
     const ceiling = ceilingNode?.type === 'ceiling' ? ceilingNode : null;
@@ -18,9 +17,9 @@ export const CeilingHoleEditor = ({ ceilingId, holeIndex }) => {
     const handlePolygonChange = useCallback((newPolygon) => {
         const updatedHoles = [...holes];
         updatedHoles[holeIndex] = newPolygon;
-        updateNode(ceilingId, { holes: updatedHoles });
+        setCeilingHoles(ceilingId, { holes: updatedHoles });
         setSelection({ selectedIds: [ceilingId] });
-    }, [ceilingId, holeIndex, holes, updateNode, setSelection]);
+    }, [ceilingId, holeIndex, holes, setSelection]);
     const handlePolygonPreview = useCallback((preview) => {
         if (preview) {
             const updatedHoles = [...holes];

package/dist/ceiling/materials.d.ts

@@ -8,7 +8,7 @@ export declare function getCeilingMaterials(color?: string): CeilingMaterials;
 /**
  * Resolve a slot `MaterialRef` to a flat colour for the ceiling surface.
  * `library:` refs use the catalog preset's base colour; `scene:` refs use the
- * stored material's colour. Returns null for a dangling / unparseable ref so
+ * stored material's colour; a plain colour is itself. Returns null for a dangling / unparseable ref so
  * the caller falls back to its default.
  */
 export declare function ceilingColorFromRef(ref: string | undefined, sceneMaterials: Record<SceneMaterialId, SceneMaterial> | undefined): string | null;

package/dist/ceiling/materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/ceiling/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAuB,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAoBzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACtC,CAAA;AAqBD,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,gBAAgB,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,GACjE,MAAM,GAAG,IAAI,CASf"}
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/ceiling/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAuB,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAoBzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACtC,CAAA;AAqBD,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,gBAAgB,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,GACjE,MAAM,GAAG,IAAI,CAiBf"}

package/dist/ceiling/materials.js

@@ -1,4 +1,4 @@
-import { getMaterialPresetByRef, parseMaterialRef, resolveMaterial, } from '@pascal-app/core';
+import { getCatalogMaterialById, getMaterialPresetByRef, parseMaterialColor, parseMaterialRef, resolveMaterial, } from '@pascal-app/core';
 import { float, mix, positionWorld, smoothstep } from 'three/tsl';
 import { BackSide, FrontSide, MeshBasicNodeMaterial } from 'three/webgpu';
 /**
@@ -43,15 +43,22 @@ export function getCeilingMaterials(color = '#999999') {
 /**
  * Resolve a slot `MaterialRef` to a flat colour for the ceiling surface.
  * `library:` refs use the catalog preset's base colour; `scene:` refs use the
- * stored material's colour. Returns null for a dangling / unparseable ref so
+ * stored material's colour; a plain colour is itself. Returns null for a dangling / unparseable ref so
  * the caller falls back to its default.
  */
 export function ceilingColorFromRef(ref, sceneMaterials) {
+    const color = parseMaterialColor(ref);
+    if (color)
+        return color;
     const parsed = parseMaterialRef(ref);
     if (!parsed)
         return null;
     if (parsed.kind === 'library') {
-        return getMaterialPresetByRef(ref)?.mapProperties.color ?? null;
+        // A flat tint: the catalog's preview colour reads as the finish (a textured
+        // preset's map colour is often plain white).
+        return (getCatalogMaterialById(parsed.id)?.previewColor ??
+            getMaterialPresetByRef(ref)?.mapProperties.color ??
+            null);
     }
     const sceneMaterial = sceneMaterials?.[parsed.id];
     if (!sceneMaterial)

package/dist/ceiling/paint.d.ts

@@ -1,9 +1,3 @@
-/**
- * Ceiling paint on the unified slot model. A ceiling has one paintable surface,
- * so every hit resolves to `surface`; commit writes `node.slots.surface`. The
- * preview swaps the registered underside mesh to the ceiling's own flat-tinted
- * material (built `BackSide`, the way it renders), so the hover preview matches
- * the committed result — a generic PBR preview would be invisible from below.
- */
-export declare const ceilingPaint: import("@pascal-app/core").PaintCapability;
+import { type PaintCapability } from '@pascal-app/core';
+export declare const ceilingPaint: PaintCapability;
 //# sourceMappingURL=paint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/ceiling/paint.ts"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,4CAwBvB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/ceiling/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AAqHzB,eAAO,MAAM,YAAY,EAAE,eAyB1B,CAAA"}