@pascal-app/nodes 0.1.1 → 1.0.0-beta.1

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

@@ -8,6 +8,15 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    spaceRole: "generic" | "room";
+    roomNumber: string;
+    enclosureStatus: "auto" | "enclosed" | "open";
+    floorFinish: string;
+    wallFinish: string;
+    ceilingFinish: string;
+    ceilingHeight: number;
+    occupancy: string;
+    clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
     metadata: import("zod").JSONType;
     camera?: {
@@ -28,6 +37,15 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    spaceRole: "generic" | "room";
+    roomNumber: string;
+    enclosureStatus: "auto" | "enclosed" | "open";
+    floorFinish: string;
+    wallFinish: string;
+    ceilingFinish: string;
+    ceilingHeight: number;
+    occupancy: string;
+    clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
     metadata: import("zod").JSONType;
     camera?: {
@@ -48,6 +66,15 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    spaceRole: "generic" | "room";
+    roomNumber: string;
+    enclosureStatus: "auto" | "enclosed" | "open";
+    floorFinish: string;
+    wallFinish: string;
+    ceilingFinish: string;
+    ceilingHeight: number;
+    occupancy: string;
+    clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
     metadata: import("zod").JSONType;
     camera?: {
@@ -68,6 +95,15 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
+    spaceRole: "generic" | "room";
+    roomNumber: string;
+    enclosureStatus: "auto" | "enclosed" | "open";
+    floorFinish: string;
+    wallFinish: string;
+    ceilingFinish: string;
+    ceilingHeight: number;
+    occupancy: string;
+    clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
     metadata: import("zod").JSONType;
     camera?: {

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

package/dist/zone/floorplan.js

@@ -1,4 +1,7 @@
 import { resolveAutoZonePolygon, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { formatConstructionLength, } from '../shared/construction-length';
+import { buildRoomClearDimensions } from './room-clear-dimensions';
 /**
  * Stage C floor-plan builder for zone. Zones are colored polygons —
  * fill + outline both come from `zone.color`. Selection adds an
@@ -14,13 +17,15 @@ export function buildZoneFloorplan(node, ctx) {
     if (!ring || ring.length < 3)
         return null;
     const view = ctx.viewState;
+    const floorplanContext = readFloorplanContext(ctx);
     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 isRoom = node.spaceRole === 'room';
+    const fillOpacity = isRoom ? (isSelected ? 0.12 : 0.04) : isSelected ? 0.28 : 0.16;
     const children = [
         {
             kind: 'polygon',
@@ -80,9 +85,15 @@ export function buildZoneFloorplan(node, ctx) {
     // 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);
     const name = node.name?.trim();
-    if (name) {
-        const [cx, cy] = polygonCentroid(ring);
+    if (isRoom) {
+        children.push(...buildRoomLabels(node, cx, cy, view?.unit ?? 'metric', floorplanContext.purpose === 'document' ? 'document' : 'editor', floorplanContext.metricNotation, stroke));
+        if (floorplanContext.automaticDimensions) {
+            children.push(...buildRoomClearDimensions(node, ctx));
+        }
+    }
+    else if (name) {
         children.push({
             kind: 'text',
             x: cx,
@@ -106,6 +117,51 @@ export function buildZoneFloorplan(node, ctx) {
     return { kind: 'group', children };
 }
 const ZONE_LABEL_FONT_SIZE = 0.2;
+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) {
+    const lines = [];
+    const name = node.name.trim();
+    if (name)
+        lines.push({ text: name, fontSize: ROOM_NAME_FONT_SIZE, fontWeight: 700 });
+    if (node.roomNumber) {
+        lines.push({ text: node.roomNumber, fontSize: ROOM_NUMBER_FONT_SIZE, fontWeight: 600 });
+    }
+    const finishes = [
+        node.floorFinish ? `FL: ${node.floorFinish}` : '',
+        node.wallFinish ? `WL: ${node.wallFinish}` : '',
+        node.ceilingFinish ? `CL: ${node.ceilingFinish}` : '',
+    ].filter(Boolean);
+    if (finishes.length > 0) {
+        lines.push({ text: finishes.join(' · '), fontSize: ROOM_DETAIL_FONT_SIZE, fontWeight: 500 });
+    }
+    const roomDetails = [
+        `CH: ${formatConstructionLength(node.ceilingHeight, unit, profile, { metricNotation })}`,
+    ];
+    if (node.occupancy)
+        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) => ({
+        kind: 'text',
+        x,
+        y: startY + index * ROOM_LABEL_LINE_SPACING,
+        text: line.text,
+        fontSize: line.fontSize,
+        fill: color,
+        stroke: '#ffffff',
+        strokeWidth: line.fontSize * 0.18,
+        paintOrder: 'stroke',
+        fontFamily: 'system-ui, -apple-system, sans-serif',
+        fontWeight: line.fontWeight,
+        textAnchor: 'middle',
+        dominantBaseline: 'central',
+        upright: true,
+        metadata: floorplanGeometryMetadata({ annotationRole: 'room-label' }),
+    }));
+}
 /**
  * Area-weighted centroid of a simple polygon (Shoelace formula). Falls
  * back to the bounding-box center when the signed area is degenerate

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":"AAyJA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCAsF1C"}
+{"version":3,"file":"quantities-panel.d.ts","sourceRoot":"","sources":["../../src/zone/quantities-panel.tsx"],"names":[],"mappings":"AA4TA,MAAM,CAAC,OAAO,UAAU,mBAAmB,uCA2F1C"}

package/dist/zone/quantities-panel.js

@@ -1,9 +1,9 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+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, PanelSection, } from '@pascal-app/editor';
+import { formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, MetricControl, PanelSection, ToggleControl, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
-import { useMemo } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 function ZonePlanSketch({ edgeLengths, polygon, unit, }) {
     if (polygon.length < 3) {
@@ -44,6 +44,50 @@ function ZonePlanSketch({ edgeLengths, polygon, unit, }) {
 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 })] }));
 }
+function RoomTextField({ label, onCommit, value, }) {
+    const [draft, setDraft] = useState(value);
+    const cancelRef = useRef(false);
+    useEffect(() => setDraft(value), [value]);
+    const commit = () => {
+        if (cancelRef.current) {
+            cancelRef.current = false;
+            setDraft(value);
+            return;
+        }
+        const next = draft.trim();
+        if (next !== value)
+            onCommit(next);
+        else
+            setDraft(value);
+    };
+    return (_jsxs("label", { className: "flex h-10 items-center gap-3 rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-sm", children: [_jsx("span", { className: "shrink-0 text-muted-foreground", children: label }), _jsx("input", { className: "min-w-0 flex-1 bg-transparent text-right text-foreground outline-none selection:bg-primary/30", onBlur: commit, onChange: (event) => setDraft(event.target.value), onKeyDown: (event) => {
+                    if (event.key === 'Enter')
+                        event.currentTarget.blur();
+                    if (event.key === 'Escape') {
+                        cancelRef.current = true;
+                        event.currentTarget.blur();
+                    }
+                }, type: "text", value: draft })] }));
+}
+function RoomSelect({ label, onChange, options, value, }) {
+    return (_jsxs("label", { className: "flex h-10 items-center justify-between gap-3 rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsx("select", { className: "min-w-0 rounded-md border border-border/50 bg-[#232325] px-2 py-1 text-foreground text-xs outline-none", onChange: (event) => onChange(event.target.value), value: value, children: options.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) })] }));
+}
+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(RoomTextField, { label: "Room name", onCommit: (name) => update({ name }), value: zone.name }), _jsx(RoomTextField, { label: "Room number", onCommit: (roomNumber) => update({ roomNumber }), value: zone.roomNumber }), _jsx(RoomSelect, { 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(RoomTextField, { label: "Occupancy / use", onCommit: (occupancy) => update({ occupancy }), value: zone.occupancy }), _jsx(RoomTextField, { label: "Floor finish", onCommit: (floorFinish) => update({ floorFinish }), value: zone.floorFinish }), _jsx(RoomTextField, { label: "Wall finish", onCommit: (wallFinish) => update({ wallFinish }), value: zone.wallFinish }), _jsx(RoomTextField, { 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(RoomSelect, { 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);
@@ -79,5 +123,5 @@ export default function ZoneQuantitiesPanel() {
     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 })] })] }));
+    return (_jsxs(_Fragment, { children: [_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) })] })] }), _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/room-clear-dimensions.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanGeometry, type GeometryContext, type ZoneNode } from '@pascal-app/core';
+export declare function buildRoomClearDimensions(node: ZoneNode, ctx: GeometryContext): FloorplanGeometry[];
+//# sourceMappingURL=room-clear-dimensions.d.ts.map

package/dist/zone/room-clear-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-clear-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/room-clear-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAuBzB,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CA4DrB"}

package/dist/zone/room-clear-dimensions.js

@@ -0,0 +1,406 @@
+import { detectSpacesForLevel, getWallThickness, } from '@pascal-app/core';
+import { readFloorplanContext } from '@pascal-app/editor';
+import { formatConstructionLength, } from '../shared/construction-length';
+const LINE_TOLERANCE = 1e-4;
+const ANGLE_TOLERANCE = 1e-3;
+const MIN_CLEAR_SPAN = 0.3;
+const MIN_ROOM_TO_ROOM_SPAN = 0.03;
+const FIRST_DIMENSION_POSITION = 0.32;
+const SECOND_DIMENSION_POSITION = 0.68;
+const EXTENSION_OVERSHOOT = 0.08;
+export function buildRoomClearDimensions(node, ctx) {
+    if (node.spaceRole !== 'room' ||
+        (node.clearDimensionPolicy !== 'inside-faces' &&
+            node.clearDimensionPolicy !== 'finish-faces') ||
+        node.enclosureStatus === 'open' ||
+        !node.autoFromWalls ||
+        !node.parentId ||
+        node.boundaryWallIds.length < 3) {
+        return [];
+    }
+    const walls = node.boundaryWallIds.flatMap((id) => {
+        const resolved = ctx.resolve(id);
+        return resolved &&
+            typeof resolved === 'object' &&
+            'type' in resolved &&
+            resolved.type === 'wall'
+            ? [resolved]
+            : [];
+    });
+    if (walls.length !== node.boundaryWallIds.length)
+        return [];
+    const boundaryIds = new Set(node.boundaryWallIds);
+    const space = detectSpacesForLevel(node.parentId, walls).spaces.find((candidate) => candidate.wallIds.length === boundaryIds.size &&
+        candidate.wallIds.every((id) => boundaryIds.has(id)));
+    if (!space)
+        return [];
+    const wallsById = new Map(walls.map((wall) => [wall.id, wall]));
+    const faceLines = resolveClearFaceLines(space.boundaryFaces, wallsById);
+    if (!faceLines)
+        return [];
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const floorplanContext = readFloorplanContext(ctx);
+    const profile = floorplanContext.purpose === 'document' ? 'document' : 'editor';
+    const metricNotation = floorplanContext.metricNotation;
+    const stroke = ctx.viewState?.palette.measurementStroke ?? '#475569';
+    const rectangle = resolveClearFaceRectangle(faceLines);
+    const dimensions = rectangle
+        ? buildRectangleClearDimensions(rectangle, unit, profile, metricNotation, stroke)
+        : buildRectilinearClearDimensions(faceLines, unit, profile, metricNotation, stroke);
+    if (dimensions.length === 0)
+        return [];
+    return [
+        ...dimensions,
+        ...buildRoomToRoomClearDimensions(node, ctx, space.boundaryFaces, wallsById, unit, profile, metricNotation, stroke),
+    ];
+}
+function resolveClearFaceLines(boundaryFaces, wallsById) {
+    const faceLines = [];
+    for (const boundary of boundaryFaces) {
+        const wall = wallsById.get(boundary.wallId);
+        if (!wall || Math.abs(wall.curveOffset ?? 0) > LINE_TOLERANCE)
+            return null;
+        const line = offsetBoundaryFace(boundary, wall);
+        if (!line)
+            return null;
+        faceLines.push(line);
+    }
+    const merged = mergeCollinearFaces(faceLines);
+    return merged.length >= 4 ? merged : null;
+}
+function resolveClearFaceRectangle(merged) {
+    if (merged.length !== 4)
+        return null;
+    const vertices = merged.map((line, index) => {
+        const previous = merged[(index + merged.length - 1) % merged.length];
+        return intersectLines(previous, line);
+    });
+    if (vertices.some((vertex) => vertex === null))
+        return null;
+    const rectangle = vertices;
+    const directions = rectangle.map((start, index) => normalizedDirection(start, rectangle[(index + 1) % rectangle.length]));
+    if (directions.some((direction) => direction === null))
+        return null;
+    const [first, second, third, fourth] = directions;
+    if (Math.abs(dot(first, second)) > ANGLE_TOLERANCE ||
+        Math.abs(dot(second, third)) > ANGLE_TOLERANCE ||
+        Math.abs(dot(third, fourth)) > ANGLE_TOLERANCE ||
+        Math.abs(dot(fourth, first)) > ANGLE_TOLERANCE ||
+        dot(first, third) > -1 + ANGLE_TOLERANCE ||
+        dot(second, fourth) > -1 + ANGLE_TOLERANCE) {
+        return null;
+    }
+    return rectangle;
+}
+function buildRectangleClearDimensions(rectangle, unit, profile, metricNotation, stroke) {
+    const first = dimensionAcrossOppositeFaces(rectangle[0], rectangle[1], rectangle[3], rectangle[2], FIRST_DIMENSION_POSITION, unit, profile, metricNotation, stroke);
+    const second = dimensionAcrossOppositeFaces(rectangle[1], rectangle[2], rectangle[0], rectangle[3], SECOND_DIMENSION_POSITION, unit, profile, metricNotation, stroke);
+    return first && second ? [first, second] : [];
+}
+function buildRectilinearClearDimensions(faceLines, unit, profile, metricNotation, stroke) {
+    const vertices = clearFacePolygon(faceLines);
+    if (!vertices || !isRectilinearPolygon(vertices))
+        return [];
+    const dimensions = [];
+    const seen = new Set();
+    for (let firstIndex = 0; firstIndex < faceLines.length; firstIndex++) {
+        const first = faceLines[firstIndex];
+        const firstDirection = normalizedDirection(first.start, first.end);
+        if (!firstDirection)
+            return [];
+        for (let secondIndex = firstIndex + 1; secondIndex < faceLines.length; secondIndex++) {
+            const second = faceLines[secondIndex];
+            const secondDirection = normalizedDirection(second.start, second.end);
+            if (!secondDirection)
+                return [];
+            if (Math.abs(dot(firstDirection, secondDirection)) < 1 - ANGLE_TOLERANCE)
+                continue;
+            const dimension = dimensionBetweenOverlappingParallelFaces(first, second, firstDirection, vertices, unit, profile, metricNotation, stroke);
+            if (!dimension)
+                continue;
+            const key = dimensionKey(dimension);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            dimensions.push(dimension);
+        }
+    }
+    return dimensions;
+}
+function offsetBoundaryFace(boundary, wall) {
+    const first = boundary.points[0];
+    const last = boundary.points[boundary.points.length - 1];
+    if (!(first && last))
+        return null;
+    const wallDirection = normalizedDirection(wall.start, wall.end);
+    if (!wallDirection)
+        return null;
+    const normal = [-wallDirection[1], wallDirection[0]];
+    const side = boundary.face === 'front' ? 1 : -1;
+    const offset = (getWallThickness(wall) / 2) * side;
+    return {
+        start: [first[0] + normal[0] * offset, first[1] + normal[1] * offset],
+        end: [last[0] + normal[0] * offset, last[1] + normal[1] * offset],
+    };
+}
+function clearFacePolygon(faceLines) {
+    const vertices = faceLines.map((line, index) => {
+        const previous = faceLines[(index + faceLines.length - 1) % faceLines.length];
+        return intersectLines(previous, line);
+    });
+    return vertices.some((vertex) => vertex === null) ? null : vertices;
+}
+function isRectilinearPolygon(vertices) {
+    if (vertices.length < 4)
+        return false;
+    const directions = vertices.map((start, index) => normalizedDirection(start, vertices[(index + 1) % vertices.length]));
+    if (directions.some((direction) => direction === null))
+        return false;
+    for (let index = 0; index < directions.length; index++) {
+        const current = directions[index];
+        const next = directions[(index + 1) % directions.length];
+        if (Math.abs(dot(current, next)) > ANGLE_TOLERANCE)
+            return false;
+    }
+    return true;
+}
+function dimensionBetweenOverlappingParallelFaces(first, second, direction, polygon, unit, profile, metricNotation, stroke) {
+    const firstStart = dot(first.start, direction);
+    const firstEnd = dot(first.end, direction);
+    const secondStart = dot(second.start, direction);
+    const secondEnd = dot(second.end, direction);
+    const overlapStart = Math.max(Math.min(firstStart, firstEnd), Math.min(secondStart, secondEnd));
+    const overlapEnd = Math.min(Math.max(firstStart, firstEnd), Math.max(secondStart, secondEnd));
+    if (overlapEnd - overlapStart < MIN_CLEAR_SPAN)
+        return null;
+    const projection = (overlapStart + overlapEnd) / 2;
+    const start = projectPointToLineProjection(first, direction, projection);
+    const end = projectPointToLineProjection(second, direction, projection);
+    const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+    if (!pointInPolygon(midpoint, polygon))
+        return null;
+    const axis = normalizedDirection(start, end);
+    if (!axis)
+        return null;
+    const length = distance(start, end);
+    if (length < MIN_CLEAR_SPAN)
+        return null;
+    return {
+        kind: 'dimension',
+        start,
+        end,
+        offsetNormal: [-axis[1], axis[0]],
+        offsetDistance: 0,
+        extensionOvershoot: EXTENSION_OVERSHOOT,
+        text: formatConstructionLength(length, unit, profile, { metricNotation }),
+        stroke,
+    };
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let index = 0, previousIndex = polygon.length - 1; index < polygon.length; previousIndex = index++) {
+        const current = polygon[index];
+        const previous = polygon[previousIndex];
+        const intersects = current[1] > point[1] !== previous[1] > point[1] &&
+            point[0] <
+                ((previous[0] - current[0]) * (point[1] - current[1])) / (previous[1] - current[1]) +
+                    current[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function dimensionKey(dimension) {
+    const first = `${roundKey(dimension.start[0])},${roundKey(dimension.start[1])}`;
+    const second = `${roundKey(dimension.end[0])},${roundKey(dimension.end[1])}`;
+    return first < second ? `${first}|${second}` : `${second}|${first}`;
+}
+function roundKey(value) {
+    return Math.round(value / LINE_TOLERANCE);
+}
+function buildRoomToRoomClearDimensions(node, ctx, boundaryFaces, wallsById, unit, profile, metricNotation, stroke) {
+    if (node.clearDimensionPolicy !== 'finish-faces')
+        return [];
+    const neighboringRooms = ctx.siblings.filter((sibling) => sibling.type === 'zone' &&
+        sibling.id !== node.id &&
+        String(node.id) < String(sibling.id) &&
+        sibling.spaceRole === 'room' &&
+        sibling.clearDimensionPolicy === 'finish-faces' &&
+        sibling.enclosureStatus !== 'open' &&
+        sibling.autoFromWalls &&
+        sibling.parentId === node.parentId);
+    if (neighboringRooms.length === 0)
+        return [];
+    const dimensions = [];
+    const currentBoundaryByWallId = new Map(boundaryFaces.map((boundary) => [boundary.wallId, boundary]));
+    for (const neighbor of neighboringRooms) {
+        const sharedWallIds = neighbor.boundaryWallIds.filter((wallId) => currentBoundaryByWallId.has(wallId));
+        if (sharedWallIds.length === 0)
+            continue;
+        const neighborWalls = neighbor.boundaryWallIds.flatMap((id) => {
+            const resolved = ctx.resolve(id);
+            return resolved &&
+                typeof resolved === 'object' &&
+                'type' in resolved &&
+                resolved.type === 'wall'
+                ? [resolved]
+                : [];
+        });
+        if (neighborWalls.length !== neighbor.boundaryWallIds.length)
+            continue;
+        const neighborWallIds = new Set(neighbor.boundaryWallIds);
+        const neighborSpace = detectSpacesForLevel(neighbor.parentId ?? '', neighborWalls).spaces.find((candidate) => candidate.wallIds.length === neighborWallIds.size &&
+            candidate.wallIds.every((id) => neighborWallIds.has(id)));
+        if (!neighborSpace)
+            continue;
+        const neighborBoundaryByWallId = new Map(neighborSpace.boundaryFaces.map((boundary) => [boundary.wallId, boundary]));
+        for (const wallId of sharedWallIds) {
+            const wall = wallsById.get(wallId);
+            const currentBoundary = currentBoundaryByWallId.get(wallId);
+            const neighborBoundary = neighborBoundaryByWallId.get(wallId);
+            if (!(wall && currentBoundary && neighborBoundary))
+                continue;
+            const currentLine = offsetBoundaryFace(currentBoundary, wall);
+            const neighborLine = offsetBoundaryFace(neighborBoundary, wall);
+            if (!(currentLine && neighborLine))
+                continue;
+            const dimension = dimensionAcrossSharedRoomWall(currentLine, neighborLine, unit, profile, metricNotation, stroke);
+            if (dimension)
+                dimensions.push(dimension);
+        }
+    }
+    return dimensions;
+}
+function dimensionAcrossSharedRoomWall(currentLine, neighborLine, unit, profile, metricNotation, stroke) {
+    const direction = normalizedDirection(currentLine.start, currentLine.end);
+    if (!direction)
+        return null;
+    const neighborDirection = normalizedDirection(neighborLine.start, neighborLine.end);
+    if (!neighborDirection || Math.abs(dot(direction, neighborDirection)) < 1 - ANGLE_TOLERANCE) {
+        return null;
+    }
+    const currentStart = dot(currentLine.start, direction);
+    const currentEnd = dot(currentLine.end, direction);
+    const neighborStart = dot(neighborLine.start, direction);
+    const neighborEnd = dot(neighborLine.end, direction);
+    const overlapStart = Math.max(Math.min(currentStart, currentEnd), Math.min(neighborStart, neighborEnd));
+    const overlapEnd = Math.min(Math.max(currentStart, currentEnd), Math.max(neighborStart, neighborEnd));
+    if (overlapEnd - overlapStart < MIN_CLEAR_SPAN)
+        return null;
+    const projection = (overlapStart + overlapEnd) / 2;
+    const start = projectPointToLineProjection(currentLine, direction, projection);
+    const end = projectPointToLineProjection(neighborLine, direction, projection);
+    const clear = distance(start, end);
+    if (clear < MIN_ROOM_TO_ROOM_SPAN)
+        return null;
+    const axis = normalizedDirection(start, end);
+    if (!axis)
+        return null;
+    return {
+        kind: 'dimension',
+        start,
+        end,
+        offsetNormal: [-axis[1], axis[0]],
+        offsetDistance: 0,
+        extensionOvershoot: EXTENSION_OVERSHOOT,
+        text: `R-R ${formatConstructionLength(clear, unit, profile, { metricNotation })}`,
+        stroke,
+    };
+}
+function projectPointToLineProjection(line, direction, projection) {
+    const originProjection = dot(line.start, direction);
+    return [
+        line.start[0] + direction[0] * (projection - originProjection),
+        line.start[1] + direction[1] * (projection - originProjection),
+    ];
+}
+function mergeCollinearFaces(lines) {
+    const merged = [];
+    for (const line of lines) {
+        const previous = merged[merged.length - 1];
+        if (previous && canMerge(previous, line))
+            previous.end = line.end;
+        else
+            merged.push({ ...line });
+    }
+    while (merged.length > 1) {
+        const first = merged[0];
+        const last = merged[merged.length - 1];
+        if (!canMerge(last, first))
+            break;
+        first.start = last.start;
+        merged.pop();
+    }
+    return merged;
+}
+function canMerge(first, second) {
+    const firstDirection = normalizedDirection(first.start, first.end);
+    const secondDirection = normalizedDirection(second.start, second.end);
+    if (!(firstDirection && secondDirection))
+        return false;
+    return (dot(firstDirection, secondDirection) > 1 - ANGLE_TOLERANCE &&
+        pointLineDistance(second.start, first) <= LINE_TOLERANCE);
+}
+function intersectLines(first, second) {
+    const firstDirection = [
+        first.end[0] - first.start[0],
+        first.end[1] - first.start[1],
+    ];
+    const secondDirection = [
+        second.end[0] - second.start[0],
+        second.end[1] - second.start[1],
+    ];
+    const denominator = cross(firstDirection, secondDirection);
+    if (Math.abs(denominator) <= LINE_TOLERANCE)
+        return null;
+    const delta = [second.start[0] - first.start[0], second.start[1] - first.start[1]];
+    const parameter = cross(delta, secondDirection) / denominator;
+    return [
+        first.start[0] + firstDirection[0] * parameter,
+        first.start[1] + firstDirection[1] * parameter,
+    ];
+}
+function dimensionAcrossOppositeFaces(firstStart, firstEnd, oppositeStart, oppositeEnd, position, unit, profile, metricNotation, stroke) {
+    const start = interpolate(firstStart, firstEnd, position);
+    const end = interpolate(oppositeStart, oppositeEnd, position);
+    const direction = normalizedDirection(start, end);
+    if (!direction)
+        return null;
+    const length = distance(start, end);
+    if (length < MIN_CLEAR_SPAN)
+        return null;
+    return {
+        kind: 'dimension',
+        start,
+        end,
+        offsetNormal: [-direction[1], direction[0]],
+        offsetDistance: 0,
+        extensionOvershoot: EXTENSION_OVERSHOOT,
+        text: formatConstructionLength(length, unit, profile, { metricNotation }),
+        stroke,
+    };
+}
+function normalizedDirection(start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const length = Math.hypot(dx, dy);
+    return length <= LINE_TOLERANCE ? null : [dx / length, dy / length];
+}
+function pointLineDistance(point, line) {
+    const direction = normalizedDirection(line.start, line.end);
+    if (!direction)
+        return Number.POSITIVE_INFINITY;
+    return Math.abs(cross(direction, [point[0] - line.start[0], point[1] - line.start[1]]));
+}
+function interpolate(start, end, t) {
+    return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
+}
+function distance(first, second) {
+    return Math.hypot(second[0] - first[0], second[1] - first[1]);
+}
+function dot(first, second) {
+    return first[0] * second[0] + first[1] * second[1];
+}
+function cross(first, second) {
+    return first[0] * second[1] - first[1] * second[0];
+}