@pascal-app/nodes 1.0.1 → 1.0.4

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

@@ -6,8 +6,10 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
     type: "zone";
     name: string;
     polygon: [number, number][];
+    holes: [number, number][][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    boundarySeparatorIds: string[];
     spaceRole: "room" | "generic";
     roomNumber: string;
     enclosureStatus: "auto" | "open" | "enclosed";
@@ -26,6 +28,54 @@ export declare const zoneMoveVertexAffordance: 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;
+    hostZoneId?: string | undefined;
+    seed?: [number, number] | undefined;
+    floor?: {
+        elevation?: number | undefined;
+        support?: "open" | undefined;
+        footprint?: string | undefined;
+        thickness?: number | undefined;
+        sourceSlabId?: `slab_${string}` | undefined;
+        finish?: string | Record<string, unknown> | undefined;
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    ceiling?: {
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    floorStepFinish?: string | undefined;
+    floorStepOverrides?: {
+        key: string;
+        finish: string;
+        step?: number | undefined;
+    }[] | undefined;
+    floorEdgeFinish?: string | undefined;
+    wallMaterial?: string | undefined;
+    wallOverrides?: {
+        wallId: string;
+        face: "a" | "b";
+        finish: string;
+    }[] | undefined;
+    hasFloor?: false | undefined;
+    hasCeiling?: false | undefined;
 }>;
 export declare const zoneAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -35,8 +85,10 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
     type: "zone";
     name: string;
     polygon: [number, number][];
+    holes: [number, number][][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    boundarySeparatorIds: string[];
     spaceRole: "room" | "generic";
     roomNumber: string;
     enclosureStatus: "auto" | "open" | "enclosed";
@@ -55,6 +107,54 @@ export declare const zoneAddVertexAffordance: 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;
+    hostZoneId?: string | undefined;
+    seed?: [number, number] | undefined;
+    floor?: {
+        elevation?: number | undefined;
+        support?: "open" | undefined;
+        footprint?: string | undefined;
+        thickness?: number | undefined;
+        sourceSlabId?: `slab_${string}` | undefined;
+        finish?: string | Record<string, unknown> | undefined;
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    ceiling?: {
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    floorStepFinish?: string | undefined;
+    floorStepOverrides?: {
+        key: string;
+        finish: string;
+        step?: number | undefined;
+    }[] | undefined;
+    floorEdgeFinish?: string | undefined;
+    wallMaterial?: string | undefined;
+    wallOverrides?: {
+        wallId: string;
+        face: "a" | "b";
+        finish: string;
+    }[] | undefined;
+    hasFloor?: false | undefined;
+    hasCeiling?: false | undefined;
 }>;
 export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -64,8 +164,10 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     type: "zone";
     name: string;
     polygon: [number, number][];
+    holes: [number, number][][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    boundarySeparatorIds: string[];
     spaceRole: "room" | "generic";
     roomNumber: string;
     enclosureStatus: "auto" | "open" | "enclosed";
@@ -84,6 +186,54 @@ export declare const zoneMoveEdgeAffordance: 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;
+    hostZoneId?: string | undefined;
+    seed?: [number, number] | undefined;
+    floor?: {
+        elevation?: number | undefined;
+        support?: "open" | undefined;
+        footprint?: string | undefined;
+        thickness?: number | undefined;
+        sourceSlabId?: `slab_${string}` | undefined;
+        finish?: string | Record<string, unknown> | undefined;
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    ceiling?: {
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    floorStepFinish?: string | undefined;
+    floorStepOverrides?: {
+        key: string;
+        finish: string;
+        step?: number | undefined;
+    }[] | undefined;
+    floorEdgeFinish?: string | undefined;
+    wallMaterial?: string | undefined;
+    wallOverrides?: {
+        wallId: string;
+        face: "a" | "b";
+        finish: string;
+    }[] | undefined;
+    hasFloor?: false | undefined;
+    hasCeiling?: false | undefined;
 }>;
 export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -93,8 +243,10 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
     type: "zone";
     name: string;
     polygon: [number, number][];
+    holes: [number, number][][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    boundarySeparatorIds: string[];
     spaceRole: "room" | "generic";
     roomNumber: string;
     enclosureStatus: "auto" | "open" | "enclosed";
@@ -113,5 +265,53 @@ export declare const zoneDeleteVertexAffordance: 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;
+    hostZoneId?: string | undefined;
+    seed?: [number, number] | undefined;
+    floor?: {
+        elevation?: number | undefined;
+        support?: "open" | undefined;
+        footprint?: string | undefined;
+        thickness?: number | undefined;
+        sourceSlabId?: `slab_${string}` | undefined;
+        finish?: string | Record<string, unknown> | undefined;
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    ceiling?: {
+        regions?: {
+            id: string;
+            polygon: [number, number][];
+            finish: string | Record<string, unknown>;
+        }[] | undefined;
+    } | undefined;
+    floorStepFinish?: string | undefined;
+    floorStepOverrides?: {
+        key: string;
+        finish: string;
+        step?: number | undefined;
+    }[] | undefined;
+    floorEdgeFinish?: string | undefined;
+    wallMaterial?: string | undefined;
+    wallOverrides?: {
+        wallId: string;
+        face: "a" | "b";
+        finish: string;
+    }[] | undefined;
+    hasFloor?: false | undefined;
+    hasCeiling?: false | undefined;
 }>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/zone/floorplan-affordances.ts"],"names":[],"mappings":"AAuBA,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/zone/floorplan-affordances.ts"],"names":[],"mappings":"AAuBA,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/zone/floorplan.d.ts

@@ -3,7 +3,7 @@ import { type FloorplanGeometry, type GeometryContext, type ZoneNode } from '@pa
  * Stage C floor-plan builder for zone. Zones are colored polygons.
  *
  * The zone's `name` renders as a centered text label at the polygon's
- * geometric centroid. The registry layer sorts zones before every
+ * interior label point. The registry layer sorts zones before every
  * other kind so the label + polygon sit *under* walls / slabs /
  * furniture in the SVG document order (= z-order).
  */

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/zone/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmIjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/zone/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAiKjG"}

package/dist/zone/floorplan.js

@@ -1,4 +1,4 @@
-import { resolveAutoZonePolygon, } from '@pascal-app/core';
+import { polygonInteriorPoint, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { formatConstructionLength, } from '../shared/construction-length';
 import { buildRoomClearDimensions } from './room-clear-dimensions';
@@ -7,12 +7,12 @@ import { owningUnitForZone } from './unit-membership';
  * Stage C floor-plan builder for zone. Zones are colored polygons.
  *
  * The zone's `name` renders as a centered text label at the polygon's
- * geometric centroid. The registry layer sorts zones before every
+ * interior label point. The registry layer sorts zones before every
  * other kind so the label + polygon sit *under* walls / slabs /
  * furniture in the SVG document order (= z-order).
  */
 export function buildZoneFloorplan(node, ctx) {
-    const ring = resolveAutoZonePolygon(node, ctx.resolve);
+    const { polygon: ring, holes } = node;
     if (!ring || ring.length < 3)
         return null;
     const view = ctx.viewState;
@@ -21,16 +21,42 @@ export function buildZoneFloorplan(node, ctx) {
     const isHighlighted = view?.highlighted ?? false;
     const showSelectedChrome = isSelected || isHighlighted;
     const points = ring.map(([x, z]) => [x, z]);
+    // A sheet drafts every zone's tag itself — name, number, area, placed
+    // clear of everything else — so on a sheet the zone prints nothing of its
+    // own: no wash, no outline, no zone-coloured name, whatever its role or
+    // wherever it came from. The invisible outline keeps the zone in the
+    // collection the sheet reads its rooms from.
+    if (floorplanContext.drafting) {
+        return { kind: 'group', children: [{ kind: 'polygon', points, fill: 'none', stroke: 'none' }] };
+    }
     const unit = owningUnitForZone(node, ctx.resolve);
     const tintColor = unit?.color ?? node.color;
     const stroke = node.color;
     const focusOpacity = view?.focusedUnitId && !view.focusedUnitMemberIds?.includes(node.id) ? 0.35 : 1;
     const isRoom = node.spaceRole === 'room';
-    const fillOpacity = isRoom ? (isSelected ? 0.12 : 0.04) : isSelected ? 0.28 : 0.16;
+    // On the editor canvas a pill labels every zone; the wash and drawn tags
+    // come back only while a unit's membership is being painted.
+    const drawnTags = !floorplanContext.roomLabelOverlay || !!view?.focusedUnitId;
+    const fillOpacity = !drawnTags
+        ? 0
+        : isRoom
+            ? isSelected
+                ? 0.12
+                : 0.04
+            : isSelected
+                ? 0.28
+                : 0.16;
     const children = [
         {
-            kind: 'polygon',
-            points,
+            ...(holes.length
+                ? {
+                    kind: 'path',
+                    d: [ring, ...holes]
+                        .map((points) => `${points.map(([x, y], i) => `${i ? 'L' : 'M'} ${x} ${y}`).join(' ')} Z`)
+                        .join(' '),
+                    fillRule: 'evenodd',
+                }
+                : { kind: 'polygon', points }),
             fill: tintColor,
             fillOpacity: fillOpacity * focusOpacity,
             stroke,
@@ -84,17 +110,16 @@ export function buildZoneFloorplan(node, ctx) {
     // Name label — white fill inside a zone-colored stroke (`paintOrder:
     // 'stroke'` paints the stroke first so the fill reads cleanly through
     // it). Mirrors the legacy `FloorplanZoneLabel` so the look is
-    // consistent. Centered on the polygon's area-weighted centroid; the
-    // bbox-center fallback handles degenerate rings without throwing.
-    const [cx, cy] = polygonCentroid(ring);
+    // consistent. The anchor stays in the usable room area, outside holes.
+    const [cx, cy] = polygonInteriorPoint({ polygon: ring, holes });
     const name = node.name?.trim();
-    if (isRoom) {
-        children.push(...buildRoomLabels(node, cx, cy, view?.unit ?? 'metric', floorplanContext.purpose === 'document' ? 'document' : 'editor', floorplanContext.metricNotation, stroke, unit?.name));
-        if (floorplanContext.automaticDimensions) {
-            children.push(...buildRoomClearDimensions(node, ctx));
-        }
+    if (isRoom && drawnTags) {
+        children.push(...buildRoomLabels(node, cx, cy, view?.unit ?? 'metric', floorplanContext.purpose === 'document' ? 'document' : 'editor', floorplanContext.metricNotation, stroke, unit?.name, roomFloorLift(node, ctx)));
+    }
+    if (isRoom && floorplanContext.automaticDimensions) {
+        children.push(...buildRoomClearDimensions(node, ctx));
     }
-    else if (name) {
+    if (!isRoom && drawnTags && name) {
         const unitName = unit?.name.trim();
         const lines = unitName
             ? [
@@ -113,7 +138,7 @@ export function buildZoneFloorplan(node, ctx) {
                 // (0.2 plan metres ≈ readable at typical building zooms).
                 fontSize: line.fontSize,
                 fill: '#ffffff',
-                stroke: node.color,
+                stroke,
                 strokeWidth: line.fontSize * 0.35,
                 paintOrder: 'stroke',
                 fontFamily: 'system-ui, -apple-system, sans-serif',
@@ -133,7 +158,7 @@ const ROOM_NAME_FONT_SIZE = 0.2;
 const ROOM_NUMBER_FONT_SIZE = 0.16;
 const ROOM_DETAIL_FONT_SIZE = 0.11;
 const ROOM_LABEL_LINE_SPACING = 0.18;
-function buildRoomLabels(node, x, y, unit, profile, metricNotation, color, unitName) {
+function buildRoomLabels(node, x, y, unit, profile, metricNotation, color, unitName, lift = 0) {
     const lines = [];
     const name = node.name.trim();
     if (name)
@@ -159,7 +184,28 @@ function buildRoomLabels(node, x, y, unit, profile, metricNotation, color, unitN
         roomDetails.push(node.occupancy);
     lines.push({ text: roomDetails.join(' · '), fontSize: ROOM_DETAIL_FONT_SIZE, fontWeight: 500 });
     const startY = y - ((lines.length - 1) * ROOM_LABEL_LINE_SPACING) / 2;
-    return lines.map((line, index) => ({
+    const chip = Math.abs(lift) < 0.005
+        ? []
+        : [
+            {
+                kind: 'text',
+                x,
+                y: startY - ROOM_LABEL_LINE_SPACING,
+                text: `${lift > 0 ? '+' : '−'}${formatConstructionLength(Math.abs(lift), unit, profile, { metricNotation })}`,
+                fontSize: ROOM_DETAIL_FONT_SIZE,
+                fill: ROOM_LIFT_COLOR,
+                stroke: '#ffffff',
+                strokeWidth: ROOM_DETAIL_FONT_SIZE * 0.18,
+                paintOrder: 'stroke',
+                fontFamily: 'system-ui, -apple-system, sans-serif',
+                fontWeight: 700,
+                textAnchor: 'middle',
+                dominantBaseline: 'central',
+                upright: true,
+                metadata: floorplanGeometryMetadata({ annotationRole: 'room-label' }),
+            },
+        ];
+    return chip.concat(lines.map((line, index) => ({
         kind: 'text',
         x,
         y: startY + index * ROOM_LABEL_LINE_SPACING,
@@ -175,44 +221,38 @@ function buildRoomLabels(node, x, y, unit, profile, metricNotation, color, unitN
         dominantBaseline: 'central',
         upright: true,
         metadata: floorplanGeometryMetadata({ annotationRole: 'room-label' }),
-    }));
+    })));
 }
+// The room arrows' indigo: a raised or sunken room reads as the lift it carries.
+const ROOM_LIFT_COLOR = '#6366f1';
 /**
- * Area-weighted centroid of a simple polygon (Shoelace formula). Falls
- * back to the bounding-box center when the signed area is degenerate
- * (collinear vertices, zero-area polygon) so the label still has a
- * sensible anchor.
+ * How far the room's floor sits above the floor it is measured from — its
+ * footprint's base plate, or a mezzanine's host room — for the `+0.15` label
+ * chip; 0 when the room carries no floor intent of its own.
  */
-function polygonCentroid(ring) {
-    let area = 0;
-    let cx = 0;
-    let cy = 0;
-    for (let i = 0; i < ring.length; i++) {
-        const [x0, y0] = ring[i];
-        const [x1, y1] = ring[(i + 1) % ring.length];
-        const cross = x0 * y1 - x1 * y0;
-        area += cross;
-        cx += (x0 + x1) * cross;
-        cy += (y0 + y1) * cross;
-    }
-    area *= 0.5;
-    if (Math.abs(area) < 1e-9) {
-        // Degenerate — fall back to bbox center.
-        let minX = Infinity;
-        let maxX = -Infinity;
-        let minY = Infinity;
-        let maxY = -Infinity;
-        for (const [x, y] of ring) {
-            if (x < minX)
-                minX = x;
-            if (x > maxX)
-                maxX = x;
-            if (y < minY)
-                minY = y;
-            if (y > maxY)
-                maxY = y;
+function roomFloorLift(node, ctx) {
+    const elevation = node.floor?.elevation;
+    if (elevation === undefined)
+        return 0;
+    const baseOf = (zone) => {
+        if (!zone?.parentId)
+            return undefined;
+        const level = ctx.resolve(zone.parentId);
+        if (!level || !('children' in level))
+            return undefined;
+        for (const id of level.children) {
+            const plate = ctx.resolve(id);
+            if (plate?.type === 'slab' && plate.plateRole === 'base' && plate.zoneIds?.includes(zone.id))
+                return plate.floorHeight ?? plate.elevation;
         }
-        return [(minX + maxX) / 2, (minY + maxY) / 2];
+        return undefined;
+    };
+    let base;
+    if (node.floor?.support === 'open' && node.hostZoneId) {
+        const host = ctx.resolve(node.hostZoneId);
+        base = host?.floor?.elevation ?? baseOf(host);
     }
-    return [cx / (6 * area), cy / (6 * area)];
+    else
+        base = baseOf(node);
+    return base === undefined ? 0 : Math.round((elevation - base) * 1000) / 1000;
 }

package/dist/zone/quantities-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quantities-panel.d.ts","sourceRoot":"","sources":["../../src/zone/quantities-panel.tsx"],"names":[],"mappings":"AA8RA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCA8F1C"}
+{"version":3,"file":"quantities-panel.d.ts","sourceRoot":"","sources":["../../src/zone/quantities-panel.tsx"],"names":[],"mappings":"AAqMA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCAkF1C"}

package/dist/zone/quantities-panel.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { deriveZoneQuantityReport, resolveAutoZonePolygon, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, MetricControl, PanelSection, ToggleControl, } from '@pascal-app/editor';
+import { deriveZoneQuantityReport, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, PanelSection, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useMemo } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { PanelSelect, PanelTextField } from '../shared/panel-fields';
+import { PanelSelect } from '../shared/panel-fields';
 import { buildingUnitsForZone } from './unit-membership';
 function ZonePlanSketch({ edgeLengths, metricNotation, polygon, unit, }) {
     if (polygon.length < 3) {
@@ -76,43 +76,16 @@ function ZoneUnitPanel({ zone }) {
                 ...units.map((unit) => ({ label: unit.name || 'Unit', value: unit.id })),
             ], value: current?.id ?? '' }) }));
 }
-function RoomDocumentationPanel({ zone }) {
-    const updateNode = useScene((state) => state.updateNode);
-    const update = (patch) => updateNode(zone.id, patch);
-    const isRoom = zone.spaceRole === 'room';
-    return (_jsxs(PanelSection, { title: "Room documentation", children: [_jsx(ToggleControl, { checked: isRoom, label: "Architectural room", onChange: (checked) => update({ spaceRole: checked ? 'room' : 'generic' }) }), isRoom ? (_jsxs(_Fragment, { children: [_jsx(PanelTextField, { label: "Room name", onCommit: (name) => update({ name }), value: zone.name }), _jsx(PanelTextField, { label: "Room number", onCommit: (roomNumber) => update({ roomNumber }), value: zone.roomNumber }), _jsx(PanelSelect, { label: "Enclosure", onChange: (enclosureStatus) => update({ enclosureStatus: enclosureStatus }), options: [
-                            { label: 'Auto-detect', value: 'auto' },
-                            { label: 'Enclosed', value: 'enclosed' },
-                            { label: 'Open', value: 'open' },
-                        ], value: zone.enclosureStatus }), _jsx(PanelTextField, { label: "Occupancy / use", onCommit: (occupancy) => update({ occupancy }), value: zone.occupancy }), _jsx(PanelTextField, { label: "Floor finish", onCommit: (floorFinish) => update({ floorFinish }), value: zone.floorFinish }), _jsx(PanelTextField, { label: "Wall finish", onCommit: (wallFinish) => update({ wallFinish }), value: zone.wallFinish }), _jsx(PanelTextField, { label: "Ceiling finish", onCommit: (ceilingFinish) => update({ ceilingFinish }), value: zone.ceilingFinish }), _jsx(MetricControl, { label: "Ceiling height", max: 20, min: 0.1, onChange: (ceilingHeight) => update({ ceilingHeight }), precision: 2, step: 0.05, unit: "m", value: zone.ceilingHeight }), _jsx(PanelSelect, { label: "Clear dimensions", onChange: (clearDimensionPolicy) => update({
-                            clearDimensionPolicy: clearDimensionPolicy,
-                        }), options: [
-                            { label: 'None', value: 'none' },
-                            { label: 'Inside faces', value: 'inside-faces' },
-                            { label: 'Finish faces', value: 'finish-faces' },
-                        ], value: zone.clearDimensionPolicy })] })) : null] }));
-}
 export default function ZoneQuantitiesPanel() {
     const selectedZoneId = useViewer((state) => state.selection.zoneId);
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
     const nodes = useScene((state) => state.nodes);
     const zone = selectedZoneId ? nodes[selectedZoneId] : undefined;
-    const livePolygon = useLiveNodeOverrides((state) => selectedZoneId ? state.overrides.get(selectedZoneId)?.polygon : undefined);
+    const liveZone = useLiveNodeOverrides((state) => selectedZoneId ? state.overrides.get(selectedZoneId) : undefined);
     const boundaryWallIds = zone?.autoFromWalls ? zone.boundaryWallIds : [];
     const boundaryOverrides = useLiveNodeOverrides(useShallow((state) => boundaryWallIds.map((id) => state.overrides.get(id))));
-    const proceduralPolygon = zone
-        ? resolveAutoZonePolygon(zone, (id) => {
-            const dependency = nodes[id];
-            if (!dependency)
-                return undefined;
-            const override = boundaryOverrides[boundaryWallIds.indexOf(id)];
-            return override ? { ...dependency, ...override } : dependency;
-        })
-        : undefined;
-    const effectiveZone = zone
-        ? { ...zone, polygon: livePolygon ?? proceduralPolygon ?? zone.polygon }
-        : undefined;
+    const effectiveZone = zone ? { ...zone, ...liveZone } : undefined;
     const effectiveNodes = useMemo(() => {
         if (boundaryOverrides.every((override) => !override))
             return nodes;
@@ -128,5 +101,5 @@ export default function ZoneQuantitiesPanel() {
     const report = useMemo(() => (effectiveZone ? deriveZoneQuantityReport(effectiveZone, effectiveNodes) : null), [effectiveNodes, effectiveZone]);
     if (!effectiveZone || !report)
         return null;
-    return (_jsxs(_Fragment, { children: [_jsx(ZoneUnitPanel, { zone: effectiveZone }), _jsx(RoomDocumentationPanel, { zone: effectiveZone }), _jsxs(PanelSection, { title: effectiveZone.spaceRole === 'room' ? 'Room quantities' : 'Zone quantities', children: [_jsxs("div", { className: "overflow-hidden rounded-md border border-cyan-950/20 bg-[#f8faf7] text-slate-950", children: [_jsxs("div", { className: "flex items-center border-cyan-950/15 border-b px-2.5 py-2", children: [_jsx("span", { className: "font-semibold text-[11px]", children: effectiveZone.name }), _jsx("span", { className: "ml-auto rounded-full border border-cyan-800/25 bg-cyan-50 px-2 py-0.5 text-cyan-900 text-[9px]", children: report.classification === 'enclosed-room' ? 'Enclosed room' : 'Footprint only' })] }), _jsxs("div", { className: "flex items-baseline gap-2 px-2.5 py-2 font-mono text-[10px]", children: [_jsx("span", { className: "text-cyan-800", children: "A" }), _jsx("span", { children: formatAreaLabel(report.footprintArea, unit, 2) }), _jsx("span", { className: "ml-auto text-slate-600", children: "P" }), _jsx("span", { children: formatLinearMeasurement(report.perimeter, unit, metricNotation) })] })] }), _jsx(ZonePlanSketch, { edgeLengths: report.edgeLengths, metricNotation: metricNotation, polygon: effectiveZone.polygon, unit: unit }), _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(QuantityRow, { abbreviation: "Aw", format: (value) => formatAreaLabel(value, unit, 2), label: "Wall surface", quantity: report.wallSurface }), _jsx(QuantityRow, { abbreviation: "Af", format: (value) => formatAreaLabel(value, unit, 2), label: "Floor surface", quantity: report.floorSurface }), _jsx(QuantityRow, { abbreviation: "V", format: (value) => formatVolumeLabel(value, unit, 2), label: "Volume", quantity: report.volume })] })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(ZoneUnitPanel, { zone: effectiveZone }), _jsxs(PanelSection, { title: effectiveZone.spaceRole === 'room' ? 'Room quantities' : 'Zone quantities', children: [_jsxs("div", { className: "overflow-hidden rounded-md border border-cyan-950/20 bg-[#f8faf7] text-slate-950", children: [_jsxs("div", { className: "flex items-center border-cyan-950/15 border-b px-2.5 py-2", children: [_jsx("span", { className: "font-semibold text-[11px]", children: effectiveZone.name }), _jsx("span", { className: "ml-auto rounded-full border border-cyan-800/25 bg-cyan-50 px-2 py-0.5 text-cyan-900 text-[9px]", children: report.classification === 'enclosed-room' ? 'Enclosed room' : 'Footprint only' })] }), _jsxs("div", { className: "flex items-baseline gap-2 px-2.5 py-2 font-mono text-[10px]", children: [_jsx("span", { className: "text-cyan-800", children: "A" }), _jsx("span", { children: formatAreaLabel(report.footprintArea, unit, 2) }), _jsx("span", { className: "ml-auto text-slate-600", children: "P" }), _jsx("span", { children: formatLinearMeasurement(report.perimeter, unit, metricNotation) })] })] }), _jsx(ZonePlanSketch, { edgeLengths: report.edgeLengths, metricNotation: metricNotation, polygon: effectiveZone.polygon, unit: unit }), _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(QuantityRow, { abbreviation: "Aw", format: (value) => formatAreaLabel(value, unit, 2), label: "Wall surface", quantity: report.wallSurface }), _jsx(QuantityRow, { abbreviation: "Af", format: (value) => formatAreaLabel(value, unit, 2), label: "Floor surface", quantity: report.floorSurface }), _jsx(QuantityRow, { abbreviation: "V", format: (value) => formatVolumeLabel(value, unit, 2), label: "Volume", quantity: report.volume })] })] })] }));
 }

package/dist/zone/quick-measurement.d.ts

@@ -1,3 +1,3 @@
-import { type GeometryContext, type QuickMeasurementReport, type ZoneNode } from '@pascal-app/core';
-export declare function zoneQuickMeasurement(node: ZoneNode, context?: GeometryContext): QuickMeasurementReport | null;
+import type { QuickMeasurementReport, ZoneNode } from '@pascal-app/core';
+export declare function zoneQuickMeasurement(node: ZoneNode): QuickMeasurementReport | null;
 //# sourceMappingURL=quick-measurement.d.ts.map

package/dist/zone/quick-measurement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/zone/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAE3B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAOzB,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,sBAAsB,GAAG,IAAI,CA0B/B"}
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/zone/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAOxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,GAAG,IAAI,CA2BlF"}

package/dist/zone/quick-measurement.js

@@ -1,12 +1,13 @@
-import { resolveAutoZonePolygon, } from '@pascal-app/core';
 import { polygonBoundaryLength, polygonReportAnchor, polygonSurfaceArea, } from '../shared/quick-measurement';
-export function zoneQuickMeasurement(node, context) {
-    const polygon = context ? resolveAutoZonePolygon(node, context.resolve) : node.polygon;
+export function zoneQuickMeasurement(node) {
+    if (node.autoFromWalls && node.enclosureStatus === 'open')
+        return null;
+    const polygon = node.polygon;
     if (polygon.length < 3)
         return null;
     return {
         title: node.name,
-        kindLabel: 'Zone',
+        kindLabel: node.spaceRole === 'room' ? 'Room' : 'Zone',
         anchor: polygonReportAnchor(polygon, 0.08),
         metrics: [
             {
@@ -14,7 +15,7 @@ export function zoneQuickMeasurement(node, context) {
                 label: 'Footprint',
                 abbreviation: 'A',
                 quantity: 'area',
-                value: polygonSurfaceArea(polygon),
+                value: polygonSurfaceArea(polygon, node.holes),
             },
             {
                 key: 'perimeter',

package/dist/zone/renderer.d.ts

@@ -1,6 +1,6 @@
 import { type ZoneNode } from '@pascal-app/core';
 export declare const ZoneRenderer: ({ node }: {
     node: ZoneNode;
-}) => import("react").JSX.Element | null;
+}) => import("react").JSX.Element;
 export default ZoneRenderer;
 //# sourceMappingURL=renderer.d.ts.map

package/dist/zone/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/zone/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA0GzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCA+MxD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/zone/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA6DzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCASxD,CAAA;AA4ID,eAAe,YAAY,CAAA"}