@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/slab/dependency-tracker.js

@@ -1,4 +1,4 @@
-import { getRenderableSlabPolygon, prepareSlabPolygonContext, scopeSlabPolygonContext, slabPolygonContextChanges, slabPolygonContextForLevel, } from '@pascal-app/core';
+import { floorConstructionLift, getRenderableSlabPolygon, isFloorPlate, plateLevelContext, prepareSlabPolygonContext, scopeSlabPolygonContext, slabPolygonContextChanges, slabPolygonContextForLevel, } from '@pascal-app/core';
 function sameReferences(left, right) {
     return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -10,17 +10,49 @@ export function createSlabDependencyTracker(initialNodes) {
         if (value !== undefined)
             return value;
         value = JSON.stringify(node.type === 'wall'
-            ? [node.id, node.start, node.end, node.thickness, node.curveOffset]
+            ? [
+                node.id,
+                node.start,
+                node.end,
+                node.thickness,
+                node.justification,
+                node.curveOffset,
+                node.supportSlabId,
+                node.supportOffset,
+                node.height,
+            ]
             : node.type === 'slab'
                 ? [
                     node.id,
                     node.polygon,
+                    node.holes,
                     node.elevation,
                     node.thickness,
                     node.recessed,
+                    node.support,
+                    node.plateRole,
                     node.fillToTerrain,
+                    node.floorHeight,
+                    node.foundation,
+                    node.boundary,
+                    node.zoneIds,
+                    node.slots,
                 ]
-                : null);
+                : node.type === 'door' || node.type === 'window'
+                    ? [node.id, node.parentId, node.position, node.width, node.height, node.verticalAnchor]
+                    : node.type === 'zone'
+                        ? [
+                            node.id,
+                            node.spaceRole,
+                            node.hasFloor,
+                            node.polygon,
+                            node.holes,
+                            node.floor,
+                            node.floorStepFinish,
+                            node.floorStepOverrides,
+                            node.floorEdgeFinish,
+                        ]
+                        : null);
         nodeInputs.set(node, value);
         return value;
     };
@@ -45,11 +77,23 @@ export function createSlabDependencyTracker(initialNodes) {
             const polygonContext = slabPolygonContextForLevel(level ?? null, (id) => nodes[id], context.slabs);
             const building = level?.parentId ? nodes[level.parentId] : undefined;
             const cached = previous.get(levelId);
-            const references = { level, building, slabs: context.slabs, context: polygonContext };
+            // Plates carry room finishes, so a zone edit changes what they draw even
+            // when nothing about their own polygon moved.
+            const { zones, openings = [] } = plateLevelContext(level ?? null, (id) => nodes[id]);
+            const references = {
+                level,
+                building,
+                slabs: context.slabs,
+                zones,
+                openings,
+                context: polygonContext,
+            };
             if (cached &&
                 cached.references.level === level &&
                 cached.references.building === building &&
                 sameReferences(cached.references.slabs, context.slabs) &&
+                sameReferences(cached.references.zones, zones) &&
+                sameReferences(cached.references.openings, openings) &&
                 sameReferences(cached.references.context.walls, polygonContext.walls) &&
                 sameReferences(cached.references.context.siblingSlabs, polygonContext.siblingSlabs)) {
                 current.set(levelId, cached);
@@ -63,6 +107,8 @@ export function createSlabDependencyTracker(initialNodes) {
                 cached.transform === transformSignature &&
                 sameValues(cached.references.context.walls, polygonContext.walls) &&
                 sameValues(cached.references.slabs, context.slabs) &&
+                sameValues(cached.references.zones, zones) &&
+                sameValues(cached.references.openings, openings) &&
                 sameValues(cached.references.context.siblingSlabs, polygonContext.siblingSlabs)) {
                 current.set(levelId, { ...cached, references });
                 continue;
@@ -70,9 +116,16 @@ export function createSlabDependencyTracker(initialNodes) {
             const slabs = new Map();
             const prepared = prepareSlabPolygonContext(polygonContext, cached?.prepared);
             const affected = cached ? slabPolygonContextChanges(cached.prepared, prepared) : () => true;
+            // Reaching here means a wall, zone or slab on this level changed by value,
+            // and a plate's top partition and side exposure read all three — so a
+            // plate never takes the per-slab shortcut, whatever its own fields say.
+            const partitionRevision = (cached?.partitionRevision ?? 0) + 1;
             for (const slab of context.slabs) {
                 const previousSlab = cached?.slabs.get(slab.id);
+                const lift = isFloorPlate(slab) ? 0 : floorConstructionLift(nodes, slab);
                 if (previousSlab &&
+                    previousSlab.lift === lift &&
+                    !isFloorPlate(slab) &&
                     (previousSlab.node === slab || sign(previousSlab.node) === sign(slab)) &&
                     (!slab.fillToTerrain || slab.recessed || cached?.transform === transformSignature) &&
                     !affected(slab)) {
@@ -85,16 +138,23 @@ export function createSlabDependencyTracker(initialNodes) {
                 // level context without changing this slab's geometry.
                 const signature = JSON.stringify([
                     polygon,
-                    slab.elevation,
+                    slab.elevation + lift,
                     slab.thickness,
                     slab.recessed,
                     slab.fillToTerrain && !slab.recessed ? transform : null,
+                    isFloorPlate(slab) ? partitionRevision : null,
                 ]);
-                slabs.set(slab.id, { node: slab, signature });
+                slabs.set(slab.id, { node: slab, signature, lift });
                 if (previousSlab?.signature !== signature)
                     dirty.push(slab.id);
             }
-            current.set(levelId, { prepared, transform: transformSignature, slabs, references });
+            current.set(levelId, {
+                prepared,
+                transform: transformSignature,
+                slabs,
+                references,
+                partitionRevision,
+            });
         }
         previous = current;
         return dirty;

package/dist/slab/elevation-limit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevation-limit.d.ts","sourceRoot":"","sources":["../../src/slab/elevation-limit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAUzB,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,GAAG,MAAM,CAE5F;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,GACpF,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAE7B;AAED,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,EACrF,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,QAAQ,CAAC,CAOnB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,sBAAsB,CAAC,GACzD,MAAM,CAER;AAED,mEAAmE;AACnE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,sBAAsB,CAAC,EAC5C,QAAQ,EAAE,MAAM,GACf,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAG7B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,EAC/C,YAAY,EAAE,MAAM,GACnB,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC,CAOxD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiB/F;AAiBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,EACd,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,CAUpB;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,GACb,MAAM,CAIR"}
+{"version":3,"file":"elevation-limit.d.ts","sourceRoot":"","sources":["../../src/slab/elevation-limit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAUzB,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,GAAG,MAAM,CAE5F;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,GACpF,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAE7B;AAED,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,EACrF,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,QAAQ,CAAC,CAOnB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,sBAAsB,CAAC,GACzD,MAAM,CAER;AAED,mEAAmE;AACnE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,sBAAsB,CAAC,EAC5C,QAAQ,EAAE,MAAM,GACf,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAG7B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,EAC/C,YAAY,EAAE,MAAM,GACnB,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC,CAOxD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiB/F;AAiBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,EACd,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,CAWpB;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,GACb,MAAM,CAIR"}

package/dist/slab/elevation-limit.js

@@ -113,12 +113,12 @@ export function clampSlabElevation(nodes, slab, proposedElevation) {
     const context = resolveSlabLevelContext(nodes, slab);
     if (!context)
         return { elevation: proposedElevation, clamped: false };
-    return clampSlabElevationForWalls(proposedElevation, slab, context.walls, context.slabs, context.storeyHeight);
+    return clampSlabElevationForWalls(proposedElevation, slab, context.walls, context.slabs, context.storeyHeight, nodes);
 }
 /** Drag-time upper bound for the slab height arrow; +Infinity when unconstrained. */
 export function slabElevationUpperBound(nodes, slab) {
     const context = resolveSlabLevelContext(nodes, slab);
     if (!context)
         return Number.POSITIVE_INFINITY;
-    return getSlabElevationUpperBound(slab, context.walls, context.slabs, context.storeyHeight);
+    return getSlabElevationUpperBound(slab, context.walls, context.slabs, context.storeyHeight, nodes);
 }

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

@@ -8,7 +8,8 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
     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;
     }[];
@@ -24,6 +25,17 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
         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;
@@ -43,8 +55,39 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    floorHeight?: number | undefined;
+    referenceFloorElevation?: number | undefined;
+    foundation?: {
+        type: "solid" | "none";
+        material?: string | {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
     recessedRimElevation?: number | undefined;
     fillToTerrain?: boolean | undefined;
+    boundary?: "auto" | undefined;
+    support?: "open" | undefined;
+    plateRole?: "base" | "platform" | "sunken" | undefined;
+    railing?: {
+        start: [number, number];
+        end: [number, number];
+    }[] | undefined;
+    zoneIds?: string[] | undefined;
+    associatedZoneIds?: string[] | undefined;
 }>;
 export declare const slabAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -56,7 +99,8 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
     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;
     }[];
@@ -72,6 +116,17 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
         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;
@@ -91,8 +146,39 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    floorHeight?: number | undefined;
+    referenceFloorElevation?: number | undefined;
+    foundation?: {
+        type: "solid" | "none";
+        material?: string | {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
     recessedRimElevation?: number | undefined;
     fillToTerrain?: boolean | undefined;
+    boundary?: "auto" | undefined;
+    support?: "open" | undefined;
+    plateRole?: "base" | "platform" | "sunken" | undefined;
+    railing?: {
+        start: [number, number];
+        end: [number, number];
+    }[] | undefined;
+    zoneIds?: string[] | undefined;
+    associatedZoneIds?: string[] | undefined;
 }>;
 export declare const slabMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -104,7 +190,8 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     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;
     }[];
@@ -120,6 +207,17 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
         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;
@@ -139,8 +237,39 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    floorHeight?: number | undefined;
+    referenceFloorElevation?: number | undefined;
+    foundation?: {
+        type: "solid" | "none";
+        material?: string | {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
     recessedRimElevation?: number | undefined;
     fillToTerrain?: boolean | undefined;
+    boundary?: "auto" | undefined;
+    support?: "open" | undefined;
+    plateRole?: "base" | "platform" | "sunken" | undefined;
+    railing?: {
+        start: [number, number];
+        end: [number, number];
+    }[] | undefined;
+    zoneIds?: string[] | undefined;
+    associatedZoneIds?: string[] | undefined;
 }>;
 export declare const slabDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -152,7 +281,8 @@ export declare const slabDeleteVertexAffordance: 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;
     }[];
@@ -168,6 +298,17 @@ export declare const slabDeleteVertexAffordance: 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;
@@ -187,7 +328,38 @@ export declare const slabDeleteVertexAffordance: import("@pascal-app/core").Floo
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    floorHeight?: number | undefined;
+    referenceFloorElevation?: number | undefined;
+    foundation?: {
+        type: "solid" | "none";
+        material?: string | {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
     recessedRimElevation?: number | undefined;
     fillToTerrain?: boolean | undefined;
+    boundary?: "auto" | undefined;
+    support?: "open" | undefined;
+    plateRole?: "base" | "platform" | "sunken" | undefined;
+    railing?: {
+        start: [number, number];
+        end: [number, number];
+    }[] | undefined;
+    zoneIds?: string[] | undefined;
+    associatedZoneIds?: string[] | undefined;
 }>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-affordances.ts"],"names":[],"mappings":"AAgEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAA;AACD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-affordances.ts"],"names":[],"mappings":"AA+DA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAA;AACD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}

package/dist/slab/floorplan-affordances.js

@@ -17,7 +17,6 @@ import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance,
  * Simpler model, no UX downside in practice.
  */
 const slabSnapOptions = {
-    boundaryCommitData: { autoFromWalls: false },
     resolvePlanPoint({ node, nodes, rawPoint, fallbackPoint, mode, }) {
         // Edge drags snap the EDGE, not the cursor (`snapEdge` below): a
         // cursor-based wall snap here would bake the pointer's grab offset

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGrE;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAS9D,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGrE;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAQ9D,CAAA"}

package/dist/slab/floorplan-move.js

@@ -12,8 +12,7 @@ export const slabFloorplanMoveTarget = ({ node, nodes }) => createPolygonCentroi
     node,
     nodes,
     meshY: 0,
-    // A user-dragged slab is a manual edit. Clear `autoFromWalls` so the
-    // space-detection sync doesn't recompute the polygon from the wall loop
-    // and snap the slab back to its original position.
-    extraCommitData: node.autoFromWalls ? { autoFromWalls: false } : undefined,
+    // A user-dragged plate detaches from the reconciler (the shared mover
+    // commits through `detachDerivedNode`), so the wall loop no longer
+    // recomputes the polygon and snaps the slab back.
 });

package/dist/slab/floorplan.d.ts

@@ -1,4 +1,11 @@
 import { type FloorplanGeometry, type GeometryContext, type SlabNode } from '@pascal-app/core';
+/**
+ * Whether the plan offers the slab's outline and hole handles: only a slab the
+ * user drew. A floor plate's outline (and its room-cut holes) follow the rooms
+ * and walls, so its handles would edit data the reconciler owns — the 3D view
+ * hides them for the same reason.
+ */
+export declare function slabOutlineEditable(node: SlabNode): boolean;
 /**
  * Stage C floor-plan builder for slab. Renders the slab polygon as a
  * filled path with holes cut out; when selected, overlays themed

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAyFjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAgGjG"}

package/dist/slab/floorplan.js

@@ -1,4 +1,14 @@
-import { getRenderableSlabPolygon, slabPolygonContextFromGeometry, } from '@pascal-app/core';
+import { cutterContextNodes, getRenderableSlabPolygon, hostedCutterHoles, isDerivedNode, slabPolygonContextFromGeometry, } from '@pascal-app/core';
+import { readFloorplanContext } from '@pascal-app/editor';
+/**
+ * Whether the plan offers the slab's outline and hole handles: only a slab the
+ * user drew. A floor plate's outline (and its room-cut holes) follow the rooms
+ * and walls, so its handles would edit data the reconciler owns — the 3D view
+ * hides them for the same reason.
+ */
+export function slabOutlineEditable(node) {
+    return !node.plateRole && !isDerivedNode(node);
+}
 /**
  * Stage C floor-plan builder for slab. Renders the slab polygon as a
  * filled path with holes cut out; when selected, overlays themed
@@ -37,14 +47,20 @@ export function buildSlabFloorplan(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;
         const holePts = hole.map(([x, z]) => [x, z]);
         segments.push(ring(holePts));
     }
     const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#475569';
-    const fill = showSelectedChrome ? '#ffffff' : '#cbd5e1';
+    // On a sheet the slab is its edge: printed, the wash tinted every room the
+    // colour of wet concrete.
+    const fill = readFloorplanContext(ctx).drafting
+        ? 'none'
+        : showSelectedChrome
+            ? '#ffffff'
+            : '#cbd5e1';
     // Slab body. Uses `fillOpacity` / `strokeOpacity` independently so the
     // outline stays crisp while the fill stays translucent — zones under
     // the slab read through, and on the selected state the hatch overlay
@@ -70,8 +86,9 @@ export function buildSlabFloorplan(node, ctx) {
             opacity: 0.7,
         });
     }
-    // Boundary editor — visible only when the slab is the active selection.
-    if (isSelected) {
+    // Boundary editor — visible only when the slab is the active selection, and
+    // only on a slab the user drew.
+    if (isSelected && slabOutlineEditable(node)) {
         // Handles operate on the STORED polygon while the fill shows the
         // band-healed render polygon; when the two diverge (edges projected
         // onto wall faces / interior centerline seams), a dashed skeleton of the

package/dist/slab/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/slab/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAInB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAoPd,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA4DP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/slab/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,eAAe,EAmBpB,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAInB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAkC,KAAK,EAAqC,MAAM,OAAO,CAAA;AAiQhG,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CAmOP"}