@pascal-app/nodes 0.1.1

package/dist/window/window-math.js

@@ -0,0 +1,41 @@
+/**
+ * Default sill height (metres from the floor to the BOTTOM of a window) for a
+ * fresh window that has no wall-face height yet — the off-wall ghost and the
+ * floor-cursor placement use it so a new window floats slightly above the
+ * ground rather than sitting on it. The committed Y is the window's CENTRE, so
+ * callers add `height / 2`. An existing window keeps its own sill.
+ */
+export const DEFAULT_WINDOW_SILL_M = 0.5;
+/**
+ * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
+ * Pass levelYOffset (the level group's current world Y) and slabElevation (the
+ * wall mesh's Y within the level group) so the cursor lands at the correct world
+ * height — matching how WallSystem positions the wall mesh at slabElevation.
+ */
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
+    const wallAngle = Math.atan2(wallNode.end[1] - wallNode.start[1], wallNode.end[0] - wallNode.start[0]);
+    return [
+        wallNode.start[0] + localX * Math.cos(wallAngle),
+        slabElevation + localY + levelYOffset,
+        wallNode.start[1] + localX * Math.sin(wallAngle),
+    ];
+}
+/**
+ * Clamps window center position so it stays fully within wall bounds.
+ */
+export function clampToWall(wallNode, localX, localY, width, height) {
+    const dx = wallNode.end[0] - wallNode.start[0];
+    const dz = wallNode.end[1] - wallNode.start[1];
+    const wallLength = Math.sqrt(dx * dx + dz * dz);
+    const wallHeight = wallNode.height ?? 2.5;
+    const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX));
+    const clampedY = Math.max(height / 2, Math.min(wallHeight - height / 2, localY));
+    return { clampedX, clampedY };
+}
+/**
+ * Wall-child overlap is shared by door + window placement (one source of
+ * truth in `shared/wall-attach-target.ts`). Re-exported here so existing
+ * `./window-math` importers don't change.
+ */
+export { hasWallChildOverlap } from '../shared/wall-attach-target';

package/dist/zone/definition.d.ts

@@ -0,0 +1,10 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { ZoneNode } from './schema';
+/**
+ * Zone — Stage A. Custom-behavior escape hatch: zone uses TSL shader
+ * materials + `<Html>` portals + per-frame uniform poking, so it
+ * lives via `def.renderer` + `def.system` (no `def.geometry` possible
+ * because zone isn't really a mesh).
+ */
+export declare const zoneDefinition: NodeDefinition<typeof ZoneNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAwE1D,CAAA"}

package/dist/zone/definition.js

@@ -0,0 +1,80 @@
+import { resolveAutoZonePolygon, ZoneNode as ZoneNodeSchema, } from '@pascal-app/core';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { buildZoneFloorplan } from './floorplan';
+import { zoneAddVertexAffordance, zoneDeleteVertexAffordance, zoneMoveEdgeAffordance, zoneMoveVertexAffordance, } from './floorplan-affordances';
+import { zoneFloorplanMoveTarget } from './floorplan-move';
+import { zoneParametrics } from './parametrics';
+import { zoneQuickMeasurement } from './quick-measurement';
+import { ZoneNode } from './schema';
+/**
+ * Zone — Stage A. Custom-behavior escape hatch: zone uses TSL shader
+ * materials + `<Html>` portals + per-frame uniform poking, so it
+ * lives via `def.renderer` + `def.system` (no `def.geometry` possible
+ * because zone isn't really a mesh).
+ */
+export const zoneDefinition = {
+    kind: 'zone',
+    snapProfile: 'structural',
+    schemaVersion: 1,
+    schema: ZoneNode,
+    category: 'site',
+    defaults: () => {
+        const stub = ZoneNodeSchema.parse({ id: 'zone_default', type: 'zone' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Zones describe regions of a site — they don't translate as
+        // reusable presets independent of their site context.
+        presettable: false,
+    },
+    parametrics: zoneParametrics,
+    measurement: {
+        features: (node, ctx) => polygonMeasurementFeatures({
+            featurePrefix: 'zone',
+            height: 0,
+            label: 'Zone',
+            polygon: resolveAutoZonePolygon(node, ctx.resolve),
+        }),
+        quickMeasure: (node, ctx) => zoneQuickMeasurement(node, ctx),
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 4,
+    },
+    floorplan: buildZoneFloorplan,
+    floorplanDependencies: (node) => (node.autoFromWalls ? node.boundaryWallIds : []),
+    // 2D body move — centroid-pivot polygon mover (same as slab / ceiling).
+    // Without this, zone fell through to the overlay's generic free-translate
+    // path, which committed a `position` field zone has no schema for, so the
+    // polygon never actually moved on drop.
+    floorplanMoveTarget: zoneFloorplanMoveTarget,
+    // Polygon editor when selected — same four operations slabs / ceilings
+    // expose. The shared factories key off `node.polygon`, optional
+    // `node.holes` (absent on zones). See `floorplan-affordances.ts`.
+    floorplanAffordances: {
+        'move-vertex': zoneMoveVertexAffordance,
+        'add-vertex': zoneAddVertexAffordance,
+        'move-edge': zoneMoveEdgeAffordance,
+        'delete-vertex': zoneDeleteVertexAffordance,
+    },
+    presentation: {
+        label: 'Zone',
+        description: 'A polygonal site zone (lawn, water, paving) with a TSL gradient material.',
+        icon: { kind: 'url', src: '/icons/zone.webp' },
+        paletteSection: 'site',
+        paletteOrder: 20,
+    },
+    mcp: {
+        description: 'A polygon-bounded site zone with a typed surface (grass / water / paving / ...).',
+    },
+};

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

@@ -0,0 +1,81 @@
+export declare const zoneMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    id: `zone_${string}`;
+    type: "zone";
+    name: string;
+    polygon: [number, number][];
+    autoFromWalls: boolean;
+    boundaryWallIds: `wall_${string}`[];
+    color: string;
+    metadata: import("zod").JSONType;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+}>;
+export declare const zoneAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    id: `zone_${string}`;
+    type: "zone";
+    name: string;
+    polygon: [number, number][];
+    autoFromWalls: boolean;
+    boundaryWallIds: `wall_${string}`[];
+    color: string;
+    metadata: import("zod").JSONType;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+}>;
+export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    id: `zone_${string}`;
+    type: "zone";
+    name: string;
+    polygon: [number, number][];
+    autoFromWalls: boolean;
+    boundaryWallIds: `wall_${string}`[];
+    color: string;
+    metadata: import("zod").JSONType;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+}>;
+export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    id: `zone_${string}`;
+    type: "zone";
+    name: string;
+    polygon: [number, number][];
+    autoFromWalls: boolean;
+    boundaryWallIds: `wall_${string}`[];
+    color: string;
+    metadata: import("zod").JSONType;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +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"}

package/dist/zone/floorplan-affordances.js

@@ -0,0 +1,19 @@
+import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance';
+/**
+ * 2D affordances for zone — same four polygon-editing operations
+ * slabs and ceilings expose. Zones have no `holes` field, but the
+ * shared factory accepts that case (holeIndex stays undefined and the
+ * boundary polygon is the target).
+ *
+ *   - `move-vertex` — drag an existing polygon vertex.
+ *   - `add-vertex` — insert a new vertex at an edge midpoint, then drag.
+ *   - `move-edge` — drag an entire edge perpendicular to itself.
+ *   - `delete-vertex` — remove a double-clicked vertex down to three.
+ */
+const zoneManualEditOptions = {
+    boundaryCommitData: { autoFromWalls: false, boundaryWallIds: [] },
+};
+export const zoneMoveVertexAffordance = createPolygonVertexAffordance('zone', zoneManualEditOptions);
+export const zoneAddVertexAffordance = createPolygonAddVertexAffordance('zone', zoneManualEditOptions);
+export const zoneMoveEdgeAffordance = createPolygonMoveEdgeAffordance('zone', zoneManualEditOptions);
+export const zoneDeleteVertexAffordance = createPolygonDeleteVertexAffordance('zone', zoneManualEditOptions);

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

@@ -0,0 +1,13 @@
+import type { FloorplanMoveTarget, ZoneNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for zone. Delegates to the shared polygon
+ * centroid-pivot mover — the zone's centroid snaps to the (grid-snapped,
+ * Figma-aligned) cursor. Zone has no `holes`, which the helper handles.
+ *
+ * Previously zone had no move target and fell through to the overlay's
+ * generic free-translate path, which committed a `position` field zone
+ * doesn't have (the polygon never moved on commit). Routing through this
+ * polygon mover translates the actual vertices. `meshY = 0`.
+ */
+export declare const zoneFloorplanMoveTarget: FloorplanMoveTarget<ZoneNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

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

package/dist/zone/floorplan-move.js

@@ -0,0 +1,17 @@
+import { createPolygonCentroidMoveTarget } from '../shared/polygon-centroid-move';
+/**
+ * 2D floor-plan move handler for zone. Delegates to the shared polygon
+ * centroid-pivot mover — the zone's centroid snaps to the (grid-snapped,
+ * Figma-aligned) cursor. Zone has no `holes`, which the helper handles.
+ *
+ * Previously zone had no move target and fell through to the overlay's
+ * generic free-translate path, which committed a `position` field zone
+ * doesn't have (the polygon never moved on commit). Routing through this
+ * polygon mover translates the actual vertices. `meshY = 0`.
+ */
+export const zoneFloorplanMoveTarget = ({ node, nodes }) => createPolygonCentroidMoveTarget({
+    node,
+    nodes,
+    meshY: 0,
+    extraCommitData: node.autoFromWalls ? { autoFromWalls: false, boundaryWallIds: [] } : undefined,
+});

package/dist/zone/floorplan.d.ts

@@ -0,0 +1,13 @@
+import { type FloorplanGeometry, type GeometryContext, type ZoneNode } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for zone. Zones are colored polygons —
+ * fill + outline both come from `zone.color`. Selection adds an
+ * accent-colored outline.
+ *
+ * The zone's `name` renders as a centered text label at the polygon's
+ * geometric centroid. 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 declare function buildZoneFloorplan(node: ZoneNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +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;AAEzB;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoGjG"}

package/dist/zone/floorplan.js

@@ -0,0 +1,147 @@
+import { resolveAutoZonePolygon, } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for zone. Zones are colored polygons —
+ * fill + outline both come from `zone.color`. Selection adds an
+ * accent-colored outline.
+ *
+ * The zone's `name` renders as a centered text label at the polygon's
+ * geometric centroid. 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);
+    if (!ring || ring.length < 3)
+        return null;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const points = ring.map(([x, z]) => [x, z]);
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : node.color;
+    const fillOpacity = isSelected ? 0.28 : 0.16;
+    const children = [
+        {
+            kind: 'polygon',
+            points,
+            fill: node.color,
+            fillOpacity,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.08 : 0.05,
+            strokeOpacity: showSelectedChrome ? 0.96 : 0.72,
+            strokeLinejoin: 'round',
+            vectorEffect: 'non-scaling-stroke',
+        },
+    ];
+    // Polygon editor — emitted only when the zone is the active
+    // selection. Same three handle types slabs / ceilings expose:
+    // edge-handle (drag whole edge), midpoint-handle (insert a vertex),
+    // endpoint-handle (drag an existing vertex). Order matters for
+    // hit-test layering: edges (large hit area) first, then midpoints,
+    // then vertices on top.
+    if (isSelected) {
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i];
+            const b = ring[(i + 1) % ring.length];
+            children.push({
+                kind: 'edge-handle',
+                x1: a[0],
+                y1: a[1],
+                x2: b[0],
+                y2: b[1],
+                affordance: 'move-edge',
+                payload: { edgeIndex: i },
+            });
+        }
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i];
+            const b = ring[(i + 1) % ring.length];
+            children.push({
+                kind: 'midpoint-handle',
+                point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+                affordance: 'add-vertex',
+                payload: { edgeIndex: i },
+            });
+        }
+        for (let i = 0; i < ring.length; i++) {
+            const [x, z] = ring[i];
+            children.push({
+                kind: 'endpoint-handle',
+                point: [x, z],
+                state: 'idle',
+                affordance: 'move-vertex',
+                payload: { vertexIndex: i },
+            });
+        }
+    }
+    // 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 name = node.name?.trim();
+    if (name) {
+        const [cx, cy] = polygonCentroid(ring);
+        children.push({
+            kind: 'text',
+            x: cx,
+            y: cy,
+            text: name,
+            // Same constants the legacy `FLOORPLAN_ZONE_LABEL_FONT_SIZE` uses
+            // (0.2 plan metres ≈ readable at typical building zooms).
+            fontSize: ZONE_LABEL_FONT_SIZE,
+            fill: '#ffffff',
+            stroke: node.color,
+            strokeWidth: ZONE_LABEL_FONT_SIZE * 0.35,
+            paintOrder: 'stroke',
+            fontFamily: 'system-ui, -apple-system, sans-serif',
+            fontWeight: 500,
+            textAnchor: 'middle',
+            dominantBaseline: 'central',
+            opacity: showSelectedChrome ? 1 : 0.92,
+            upright: true,
+        });
+    }
+    return { kind: 'group', children };
+}
+const ZONE_LABEL_FONT_SIZE = 0.2;
+/**
+ * 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.
+ */
+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;
+        }
+        return [(minX + maxX) / 2, (minY + maxY) / 2];
+    }
+    return [cx / (6 * area), cy / (6 * area)];
+}

package/dist/zone/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zone/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/zone/index.js

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

package/dist/zone/parametrics.d.ts

@@ -0,0 +1,3 @@
+import type { ParametricDescriptor, ZoneNode } from '@pascal-app/core';
+export declare const zoneParametrics: ParametricDescriptor<ZoneNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/zone/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAG1D,CAAA"}

package/dist/zone/parametrics.js

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

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

@@ -0,0 +1,2 @@
+export default function ZoneQuantitiesPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=quantities-panel.d.ts.map

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

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

package/dist/zone/quantities-panel.js

@@ -0,0 +1,83 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { deriveZoneQuantityReport, resolveAutoZonePolygon, 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';
+function ZonePlanSketch({ edgeLengths, 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" }));
+    }
+    const viewWidth = 276;
+    const viewHeight = 176;
+    const padding = 34;
+    const xs = polygon.map((point) => point[0]);
+    const ys = polygon.map((point) => point[1]);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    const width = Math.max(maxX - minX, 1e-6);
+    const height = Math.max(maxY - minY, 1e-6);
+    const scale = Math.min((viewWidth - padding * 2) / width, (viewHeight - padding * 2) / height);
+    const offsetX = (viewWidth - width * scale) / 2;
+    const offsetY = (viewHeight - height * scale) / 2;
+    const projected = polygon.map(([x, y]) => [offsetX + (x - minX) * scale, offsetY + (maxY - y) * scale]);
+    const center = projected.reduce((sum, point) => [sum[0] + point[0] / projected.length, sum[1] + point[1] / projected.length], [0, 0]);
+    return (_jsxs("svg", { "aria-label": "Top view with zone edge dimensions", className: "h-auto w-full rounded-md border border-cyan-950/20 bg-[#f8faf7]", role: "img", viewBox: `0 0 ${viewWidth} ${viewHeight}`, children: [_jsx("defs", { children: _jsx("pattern", { height: "12", id: "zone-quantity-grid", patternUnits: "userSpaceOnUse", width: "12", children: _jsx("path", { d: "M 12 0 L 0 0 0 12", fill: "none", stroke: "#0891b2", strokeOpacity: "0.08" }) }) }), _jsx("rect", { fill: "url(#zone-quantity-grid)", height: viewHeight, width: viewWidth }), _jsx("polygon", { fill: "#67e8f9", fillOpacity: "0.12", points: projected.map((point) => point.join(',')).join(' '), stroke: "#0e7490", strokeLinejoin: "round", strokeWidth: "1.5" }), projected.map((start, index) => {
+                const end = projected[(index + 1) % projected.length];
+                if (!end)
+                    return null;
+                const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+                const fromCenter = [midpoint[0] - center[0], midpoint[1] - center[1]];
+                const directionLength = Math.hypot(fromCenter[0], fromCenter[1]) || 1;
+                const labelPoint = [
+                    midpoint[0] + (fromCenter[0] / directionLength) * 15,
+                    midpoint[1] + (fromCenter[1] / directionLength) * 15,
+                ];
+                const label = formatLinearMeasurement(edgeLengths[index] ?? 0, unit);
+                const labelWidth = Math.max(24, label.length * 5.5 + 8);
+                return (_jsxs("g", { children: [_jsx("circle", { cx: start[0], cy: start[1], fill: "#f8faf7", r: "2.5", stroke: "#0e7490" }), _jsx("rect", { fill: "#f8faf7", height: "13", rx: "2", stroke: "#0e7490", strokeOpacity: "0.25", width: labelWidth, x: labelPoint[0] - labelWidth / 2, y: labelPoint[1] - 7 }), _jsx("text", { dominantBaseline: "middle", fill: "#164e63", fontFamily: "ui-monospace, SFMono-Regular, monospace", fontSize: "7.5", textAnchor: "middle", x: labelPoint[0], y: labelPoint[1], children: label })] }, `${start[0]}-${start[1]}-${index}`));
+            })] }));
+}
+function QuantityRow({ abbreviation, format, label, quantity, }) {
+    return (_jsxs("div", { className: "rounded-md border border-border/50 bg-background/35 px-2.5 py-2", children: [_jsxs("div", { className: "flex items-baseline gap-2", children: [_jsx("span", { className: "font-mono font-semibold text-cyan-600 text-[10px]", children: abbreviation }), _jsx("span", { className: "text-muted-foreground text-xs", children: label }), _jsx("span", { className: "ml-auto font-mono font-medium text-foreground text-xs tabular-nums", children: quantity.status === 'available' ? format(quantity.value) : 'Not proven' })] }), _jsx("div", { className: "mt-1 text-[10px] text-muted-foreground leading-snug", children: quantity.status === 'available' ? quantity.note : quantity.reason })] }));
+}
+export default function ZoneQuantitiesPanel() {
+    const selectedZoneId = useViewer((state) => state.selection.zoneId);
+    const unit = useViewer((state) => state.unit);
+    const nodes = useScene((state) => state.nodes);
+    const zone = selectedZoneId ? nodes[selectedZoneId] : undefined;
+    const livePolygon = useLiveNodeOverrides((state) => selectedZoneId ? state.overrides.get(selectedZoneId)?.polygon : 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 effectiveNodes = useMemo(() => {
+        if (boundaryOverrides.every((override) => !override))
+            return nodes;
+        const merged = { ...nodes };
+        boundaryWallIds.forEach((id, index) => {
+            const dependency = nodes[id];
+            const override = boundaryOverrides[index];
+            if (dependency && override)
+                merged[id] = { ...dependency, ...override };
+        });
+        return merged;
+    }, [boundaryOverrides, boundaryWallIds, nodes]);
+    const report = useMemo(() => (effectiveZone ? deriveZoneQuantityReport(effectiveZone, effectiveNodes) : null), [effectiveNodes, effectiveZone]);
+    if (!effectiveZone || !report)
+        return null;
+    return (_jsxs(PanelSection, { title: "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) })] })] }), _jsx(ZonePlanSketch, { edgeLengths: report.edgeLengths, 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

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

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

@@ -0,0 +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"}

package/dist/zone/quick-measurement.js

@@ -0,0 +1,29 @@
+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;
+    if (polygon.length < 3)
+        return null;
+    return {
+        title: node.name,
+        kindLabel: 'Zone',
+        anchor: polygonReportAnchor(polygon, 0.08),
+        metrics: [
+            {
+                key: 'area',
+                label: 'Footprint',
+                abbreviation: 'A',
+                quantity: 'area',
+                value: polygonSurfaceArea(polygon),
+            },
+            {
+                key: 'perimeter',
+                label: 'Perimeter',
+                abbreviation: 'P',
+                quantity: 'length',
+                value: polygonBoundaryLength(polygon),
+            },
+        ],
+        note: 'Footprint only — room envelope not proven.',
+    };
+}

package/dist/zone/renderer.d.ts

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

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

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