@pascal-app/nodes 1.0.3 → 1.0.5

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-affordances.js

@@ -1,4 +1,4 @@
-import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance';
+import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance.js';
 /**
  * 2D affordances for zone — same four polygon-editing operations
  * slabs and ceilings expose. Zones have no `holes` field, but the

package/dist/zone/floorplan-move.js

@@ -1,4 +1,4 @@
-import { createPolygonCentroidMoveTarget } from '../shared/polygon-centroid-move';
+import { createPolygonCentroidMoveTarget } from '../shared/polygon-centroid-move.js';
 /**
  * 2D floor-plan move handler for zone. Delegates to the shared polygon
  * centroid-pivot mover — the zone's centroid snaps to the (grid-snapped,

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,18 +1,18 @@
-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';
-import { owningUnitForZone } from './unit-membership';
+import { formatConstructionLength, } from '../shared/construction-length.js';
+import { buildRoomClearDimensions } from './room-clear-dimensions.js';
+import { owningUnitForZone } from './unit-membership.js';
 /**
  * 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/index.d.ts

@@ -1,2 +1,2 @@
-export { zoneDefinition } from './definition';
+export { zoneDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/zone/index.js

@@ -1 +1 @@
-export { zoneDefinition } from './definition';
+export { zoneDefinition } from './definition.js';

package/dist/zone/parametrics.js

@@ -1,4 +1,4 @@
 export const zoneParametrics = {
     groups: [],
-    trailingSection: () => import('./quantities-panel'),
+    trailingSection: () => import('./quantities-panel.js'),
 };

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":"AAsMA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCA6F1C"}
+{"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,12 +1,12 @@
 '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 { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+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 } from '../shared/panel-fields';
-import { buildingUnitsForZone } from './unit-membership';
+import { PanelSelect } from '../shared/panel-fields.js';
+import { buildingUnitsForZone } from './unit-membership.js';
 function ZonePlanSketch({ edgeLengths, metricNotation, polygon, unit, }) {
     if (polygon.length < 3) {
         return (_jsx("div", { className: "flex h-28 items-center justify-center rounded-md border border-border/50 text-muted-foreground text-xs", children: "Zone boundary unavailable" }));
@@ -82,21 +82,10 @@ export default function ZoneQuantitiesPanel() {
     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;

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;
+import { polygonBoundaryLength, polygonReportAnchor, polygonSurfaceArea, } from '../shared/quick-measurement.js';
+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,uCAoNxD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/zone/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA8DzB,eAAO,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAWxD,CAAA;eAwJc,YAAY"}

package/dist/zone/renderer.js

@@ -1,16 +1,15 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { resolveAutoZonePolygon, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { useNodeEvents, useViewer, ZONE_LAYER } from '@pascal-app/viewer';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { polygonInteriorPoint, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createZoneShape, createZoneWallGeometry, useNodeEvents, useViewer, ZONE_LAYER, } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
-import { useMemo, useRef } from 'react';
-import { BufferGeometry, Color, DoubleSide, Float32BufferAttribute, Shape } from 'three';
+import { useEffect, useMemo, useRef } from 'react';
+import { Color, DoubleSide } from 'three';
 import { color, float, uniform, uv } from 'three/tsl';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
-import { useShallow } from 'zustand/react/shallow';
-import { owningUnitForZone } from './unit-membership';
+import { FinishScriptModel } from '../shared/finish-script-model.js';
+import { owningUnitForZone } from './unit-membership.js';
 const Y_OFFSET = 0.01;
-const WALL_HEIGHT = 2.3;
 /**
  * Creates a gradient material for zone walls using TSL
  * Gradient goes from zone color at bottom to transparent at top
@@ -50,117 +49,35 @@ const createFloorMaterial = (zoneColor) => {
         userData: { uOpacity: opacity },
     });
 };
-/**
- * Creates wall geometry for zone borders
- * Each wall segment is a vertical quad from one polygon point to the next
- */
-const createWallGeometry = (polygon) => {
-    const geometry = new BufferGeometry();
-    if (polygon.length < 2)
-        return geometry;
-    const positions = [];
-    const uvs = [];
-    const indices = [];
-    // Create a wall segment for each edge of the polygon
-    for (let i = 0; i < polygon.length; i++) {
-        const current = polygon[i];
-        const next = polygon[(i + 1) % polygon.length];
-        const baseIndex = i * 4;
-        // Four vertices per wall segment (two triangles forming a quad)
-        // Bottom-left
-        positions.push(current[0], Y_OFFSET, current[1]);
-        uvs.push(0, 0);
-        // Bottom-right
-        positions.push(next[0], Y_OFFSET, next[1]);
-        uvs.push(1, 0);
-        // Top-right
-        positions.push(next[0], Y_OFFSET + WALL_HEIGHT, next[1]);
-        uvs.push(1, 1);
-        // Top-left
-        positions.push(current[0], Y_OFFSET + WALL_HEIGHT, current[1]);
-        uvs.push(0, 1);
-        // Two triangles for the quad
-        indices.push(baseIndex, baseIndex + 1, baseIndex + 2, baseIndex, baseIndex + 2, baseIndex + 3);
-    }
-    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
-    geometry.setIndex(indices);
-    geometry.computeVertexNormals();
-    return geometry;
-};
 export const ZoneRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'zone', ref);
-    // When zones are toggled off (editor outside the zones layer) the visuals
-    // unmount entirely — a drei <Html> keeps costing per-frame matrix work and
-    // live DOM even at opacity 0. The registered group stays so the zone keeps
-    // its scene identity (selection registry, GLB export polygon stamping).
-    const showZones = useViewer((s) => s.showZones);
+    const showZones = useViewer((state) => state.showZones);
+    const script = node.floor?.script;
+    return (_jsxs("group", { ref: ref, visible: node.visible !== false, children: [showZones ? _jsx(ZoneVisuals, { node: node }) : null, script ? _jsx(FloorScriptModel, { node: node, script: script }) : null] }));
+};
+/** Over the floor plate's top, so the plate's own finish never shows through the boards. */
+const FLOOR_SCRIPT_LIFT = 0.001;
+/** The room's floor finish its script built, in the level's frame, just over the plate. */
+function FloorScriptModel({ node, script }) {
+    return (_jsx("group", { "position-y": FLOOR_SCRIPT_LIFT, children: _jsx(FinishScriptModel, { ownerId: node.id, parentId: node.parentId, script: script }) }));
+}
+function ZoneVisuals({ node }) {
     // Group-transform drags publish a translated/rotated polygon to
     // `useLiveNodeOverrides`; merge it so the zone previews live instead of
     // snapping only on commit (slab/ceiling get this via their systems'
     // `getEffectiveNode`). Per-node subscription — unrelated overrides don't
     // re-render this zone.
-    const livePolygon = useLiveNodeOverrides((s) => s.overrides.get(node.id)?.polygon);
-    const dependencyIds = node.autoFromWalls ? node.boundaryWallIds : [];
-    const dependencyNodes = useScene(useShallow((state) => dependencyIds.map((id) => state.nodes[id])));
-    const dependencyOverrides = useLiveNodeOverrides(useShallow((state) => dependencyIds.map((id) => state.overrides.get(id))));
-    const proceduralPolygon = useMemo(() => resolveAutoZonePolygon(node, (id) => {
-        const index = dependencyIds.indexOf(id);
-        const dependency = dependencyNodes[index];
-        if (!dependency)
-            return undefined;
-        const override = dependencyOverrides[index];
-        return override ? { ...dependency, ...override } : dependency;
-    }), [dependencyIds, dependencyNodes, dependencyOverrides, node]);
-    const polygon = livePolygon ?? proceduralPolygon;
+    const live = useLiveNodeOverrides((s) => s.overrides.get(node.id));
+    const polygon = live?.polygon ?? node.polygon;
+    const holes = live?.holes ?? node.holes;
     // The selector returns the unit node itself, so only edits to that unit
     // or its membership re-render this zone.
     const unit = useScene((s) => owningUnitForZone(node, (id) => s.nodes[id]));
     const tintColor = unit?.color ?? node.color;
-    // Create floor shape from polygon
-    const floorShape = useMemo(() => {
-        if (!polygon || polygon.length < 3)
-            return null;
-        const shape = new Shape();
-        const firstPt = polygon[0];
-        // Shape is in X-Y plane, we rotate it to X-Z plane
-        // Negate Y (which becomes Z) to get correct orientation
-        shape.moveTo(firstPt[0], -firstPt[1]);
-        for (let i = 1; i < polygon.length; i++) {
-            const pt = polygon[i];
-            shape.lineTo(pt[0], -pt[1]);
-        }
-        shape.closePath();
-        return shape;
-    }, [polygon]);
-    // Create wall geometry from polygon
-    const wallGeometry = useMemo(() => {
-        if (!polygon || polygon.length < 2)
-            return null;
-        return createWallGeometry(polygon);
-    }, [polygon]);
-    // Calculate polygon centroid for label positioning using the geometric centroid formula
-    // This correctly handles polygons regardless of vertex distribution along edges
-    const centroid = useMemo(() => {
-        if (!polygon || polygon.length < 3)
-            return [0, 0];
-        let signedArea = 0;
-        let cx = 0;
-        let cz = 0;
-        for (let i = 0; i < polygon.length; i++) {
-            const [x0, z0] = polygon[i];
-            const [x1, z1] = polygon[(i + 1) % polygon.length];
-            // Cross product for signed area
-            const cross = x0 * z1 - x1 * z0;
-            signedArea += cross;
-            cx += (x0 + x1) * cross;
-            cz += (z0 + z1) * cross;
-        }
-        signedArea /= 2;
-        const factor = 1 / (6 * signedArea);
-        return [cx * factor, cz * factor];
-    }, [polygon]);
+    const floorShape = useMemo(() => (polygon.length >= 3 ? createZoneShape({ polygon, holes }) : null), [polygon, holes]);
+    const wallGeometry = useMemo(() => (polygon.length >= 3 ? createZoneWallGeometry({ polygon, holes }) : null), [polygon, holes]);
+    const centroid = useMemo(() => polygonInteriorPoint({ polygon, holes }), [polygon, holes]);
     // Create materials
     const floorMaterial = useMemo(() => {
         if (!tintColor)
@@ -172,48 +89,51 @@ export const ZoneRenderer = ({ node }) => {
             return null;
         return createWallGradientMaterial(node.color);
     }, [node.color]);
+    useEffect(() => () => wallGeometry?.dispose(), [wallGeometry]);
+    useEffect(() => () => floorMaterial?.dispose(), [floorMaterial]);
+    useEffect(() => () => wallMaterial?.dispose(), [wallMaterial]);
     const handlers = useNodeEvents(node, 'zone');
     if (!(node && floorShape && wallGeometry && floorMaterial && wallMaterial)) {
         return null;
     }
-    return (_jsx("group", { ref: ref, visible: node.visible !== false, ...handlers, userData: { labelPosition: [centroid[0], 1, centroid[1]] }, children: showZones && (_jsxs(_Fragment, { children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: { pointerEvents: 'none' }, zIndexRange: [10, 0], children: _jsxs("div", { id: `${node.id}-label`, style: {
-                            display: 'flex',
-                            flexDirection: 'column',
-                            alignItems: 'center',
-                            transform: 'translate3d(-50%, -50%, 0)',
-                            opacity: 0,
-                            transition: 'opacity 0.3s ease-in-out',
-                        }, children: [_jsx("div", { style: {
-                                    width: 'max-content',
-                                    color: 'white',
-                                    textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
-                                    textAlign: 'center',
-                                }, children: _jsx("span", { children: node.name }) }), unit && (_jsx("div", { style: {
-                                    marginTop: '2px',
-                                    padding: '1px 6px',
-                                    borderRadius: '999px',
-                                    backgroundColor: tintColor,
-                                    color: 'white',
-                                    fontSize: '10px',
-                                    lineHeight: '14px',
-                                    whiteSpace: 'nowrap',
-                                }, children: unit.name })), _jsxs("div", { className: "label-pin", style: {
-                                    display: 'flex',
-                                    flexDirection: 'column',
-                                    alignItems: 'center',
-                                    marginTop: '2px',
-                                    opacity: 0,
-                                    transition: 'opacity 0.5s ease-in-out',
-                                }, children: [_jsx("div", { style: {
-                                            width: '2px',
-                                            height: '40px',
-                                            backgroundColor: node.color,
-                                        } }), _jsx("div", { style: {
-                                            width: '10px',
-                                            height: '10px',
-                                            borderRadius: '50%',
-                                            backgroundColor: node.color,
-                                            border: '1px solid white',
-                                        } })] })] }) }), _jsx("mesh", { layers: ZONE_LAYER, material: floorMaterial, name: "floor", position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, layers: ZONE_LAYER, material: wallMaterial, name: "walls" })] })) }));
-};
+    return (_jsxs("group", { ...handlers, userData: { labelPosition: [centroid[0], 1, centroid[1]] }, children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: { pointerEvents: 'none' }, zIndexRange: [10, 0], children: _jsxs("div", { id: `${node.id}-label`, style: {
+                        display: 'flex',
+                        flexDirection: 'column',
+                        alignItems: 'center',
+                        transform: 'translate3d(-50%, -50%, 0)',
+                        opacity: 0,
+                        transition: 'opacity 0.3s ease-in-out',
+                    }, children: [_jsx("div", { style: {
+                                width: 'max-content',
+                                color: 'white',
+                                textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
+                                textAlign: 'center',
+                            }, children: _jsx("span", { children: node.name }) }), unit && (_jsx("div", { style: {
+                                marginTop: '2px',
+                                padding: '1px 6px',
+                                borderRadius: '999px',
+                                backgroundColor: tintColor,
+                                color: 'white',
+                                fontSize: '10px',
+                                lineHeight: '14px',
+                                whiteSpace: 'nowrap',
+                            }, children: unit.name })), _jsxs("div", { className: "label-pin", style: {
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                marginTop: '2px',
+                                opacity: 0,
+                                transition: 'opacity 0.5s ease-in-out',
+                            }, children: [_jsx("div", { style: {
+                                        width: '2px',
+                                        height: '40px',
+                                        backgroundColor: node.color,
+                                    } }), _jsx("div", { style: {
+                                        width: '10px',
+                                        height: '10px',
+                                        borderRadius: '50%',
+                                        backgroundColor: node.color,
+                                        border: '1px solid white',
+                                    } })] })] }) }), _jsx("mesh", { layers: ZONE_LAYER, material: floorMaterial, name: "floor", position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, layers: ZONE_LAYER, material: wallMaterial, name: "walls" })] }));
+}
 export default ZoneRenderer;