@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/zone/definition.render.js

@@ -0,0 +1,55 @@
+import { ZoneNode as ZoneNodeSchema } from '@pascal-app/core';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { zoneQuickMeasurement } from './quick-measurement.js';
+import { ZoneNode } from './schema.js';
+export const zoneRenderDefinition = {
+    kind: 'zone',
+    schemaVersion: 2,
+    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' },
+        exterior: false,
+        revealLayout: { room: (node) => (node.type === 'zone' ? node.polygon : null) },
+        duplicable: true,
+        deletable: true,
+        // Zones describe regions of a site — they don't translate as
+        // reusable presets independent of their site context.
+        presettable: false,
+    },
+    measurement: {
+        features: (node, ctx) => polygonMeasurementFeatures({
+            featurePrefix: 'zone',
+            height: 0,
+            label: 'Zone',
+            polygon: node.polygon,
+        }),
+        quickMeasure: (node) => zoneQuickMeasurement(node),
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 4,
+    },
+    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

@@ -104,6 +104,16 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -122,6 +132,17 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -136,6 +157,19 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
             } | undefined;
             inputs: string;
         } | undefined;
+        drop?: number | undefined;
+    } | undefined;
+    roomType?: "deck" | "patio" | "porch" | undefined;
+    porchFraming?: {
+        auto?: boolean | undefined;
+        postSize?: string | undefined;
+        postSpacing?: number | undefined;
+        beamSize?: string | undefined;
+    } | undefined;
+    decking?: {
+        boardSize?: "2x4" | "2x6" | "5/4x6" | "composite" | undefined;
+        gap?: number | undefined;
+        direction?: "diagonal" | "parallel" | "perpendicular" | undefined;
     } | undefined;
     ceiling?: {
         regions?: {
@@ -277,6 +311,16 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -295,6 +339,17 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -309,6 +364,19 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
             } | undefined;
             inputs: string;
         } | undefined;
+        drop?: number | undefined;
+    } | undefined;
+    roomType?: "deck" | "patio" | "porch" | undefined;
+    porchFraming?: {
+        auto?: boolean | undefined;
+        postSize?: string | undefined;
+        postSpacing?: number | undefined;
+        beamSize?: string | undefined;
+    } | undefined;
+    decking?: {
+        boardSize?: "2x4" | "2x6" | "5/4x6" | "composite" | undefined;
+        gap?: number | undefined;
+        direction?: "diagonal" | "parallel" | "perpendicular" | undefined;
     } | undefined;
     ceiling?: {
         regions?: {
@@ -450,6 +518,16 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -468,6 +546,17 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -482,6 +571,19 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
             } | undefined;
             inputs: string;
         } | undefined;
+        drop?: number | undefined;
+    } | undefined;
+    roomType?: "deck" | "patio" | "porch" | undefined;
+    porchFraming?: {
+        auto?: boolean | undefined;
+        postSize?: string | undefined;
+        postSpacing?: number | undefined;
+        beamSize?: string | undefined;
+    } | undefined;
+    decking?: {
+        boardSize?: "2x4" | "2x6" | "5/4x6" | "composite" | undefined;
+        gap?: number | undefined;
+        direction?: "diagonal" | "parallel" | "perpendicular" | undefined;
     } | undefined;
     ceiling?: {
         regions?: {
@@ -623,6 +725,16 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -641,6 +753,17 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -655,6 +778,19 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
             } | undefined;
             inputs: string;
         } | undefined;
+        drop?: number | undefined;
+    } | undefined;
+    roomType?: "deck" | "patio" | "porch" | undefined;
+    porchFraming?: {
+        auto?: boolean | undefined;
+        postSize?: string | undefined;
+        postSpacing?: number | undefined;
+        beamSize?: string | undefined;
+    } | undefined;
+    decking?: {
+        boardSize?: "2x4" | "2x6" | "5/4x6" | "composite" | undefined;
+        gap?: number | undefined;
+        direction?: "diagonal" | "parallel" | "perpendicular" | undefined;
     } | undefined;
     ceiling?: {
         regions?: {

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/quantities-panel.d.ts.map

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

package/dist/zone/quantities-panel.js

@@ -1,15 +1,19 @@
 'use client';
 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 { deriveZoneQuantityReport, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
+import { displayRoomName, 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.js';
 import { buildingUnitsForZone } from './unit-membership.js';
 function ZonePlanSketch({ edgeLengths, metricNotation, polygon, unit, }) {
+    const i18n = usePascalI18n();
     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" }));
+        return (_jsx("div", { className: "flex h-28 items-center justify-center rounded-md border border-border/50 text-muted-foreground text-xs", children: i18n._({
+                id: 'node.zone.quantitiesPanel.zoneBoundaryUnavailable',
+                message: 'Zone boundary unavailable',
+            }) }));
     }
     const viewWidth = 276;
     const viewHeight = 176;
@@ -27,7 +31,10 @@ function ZonePlanSketch({ edgeLengths, metricNotation, polygon, unit, }) {
     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) => {
+    return (_jsxs("svg", { "aria-label": i18n._({
+            id: 'node.zone.quantitiesPanel.topViewWithZoneEdgeDimensions',
+            message: '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;
@@ -44,9 +51,13 @@ function ZonePlanSketch({ edgeLengths, metricNotation, 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 })] }));
+    const i18n = usePascalI18n();
+    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)
+                            : i18n._({ id: 'node.zone.quantitiesPanel.notProven', message: 'Not proven' }) })] }), _jsx("div", { className: "mt-1 text-[10px] text-muted-foreground leading-snug", children: quantity.status === 'available' ? quantity.note : quantity.reason })] }));
 }
 function ZoneUnitPanel({ zone }) {
+    const i18n = usePascalI18n();
     const units = useScene(useShallow((state) => buildingUnitsForZone(zone, (id) => state.nodes[id])));
     if (units.length === 0)
         return null;
@@ -71,12 +82,16 @@ function ZoneUnitPanel({ zone }) {
         if (updates.length > 0)
             updateNodes(updates);
     };
-    return (_jsx(PanelSection, { title: "Unit", children: _jsx(PanelSelect, { label: "Unit", onChange: handleChange, options: [
-                { label: 'None', value: '' },
-                ...units.map((unit) => ({ label: unit.name || 'Unit', value: unit.id })),
+    return (_jsx(PanelSection, { title: i18n._({ id: 'node.zone.quantitiesPanel.unit', message: 'Unit' }), children: _jsx(PanelSelect, { label: i18n._({ id: 'node.zone.quantitiesPanel.unit', message: 'Unit' }), onChange: handleChange, options: [
+                { label: i18n._({ id: 'node.zone.quantitiesPanel.none', message: 'None' }), value: '' },
+                ...units.map((unit) => ({
+                    label: unit.name || i18n._({ id: 'node.zone.quantitiesPanel.unit', message: 'Unit' }),
+                    value: unit.id,
+                })),
             ], value: current?.id ?? '' }) }));
 }
 export default function ZoneQuantitiesPanel() {
+    const i18n = usePascalI18n();
     const selectedZoneId = useViewer((state) => state.selection.zoneId);
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
@@ -101,5 +116,15 @@ export default function ZoneQuantitiesPanel() {
     const report = useMemo(() => (effectiveZone ? deriveZoneQuantityReport(effectiveZone, effectiveNodes) : null), [effectiveNodes, effectiveZone]);
     if (!effectiveZone || !report)
         return null;
-    return (_jsxs(_Fragment, { children: [_jsx(ZoneUnitPanel, { zone: effectiveZone }), _jsxs(PanelSection, { title: effectiveZone.spaceRole === 'room' ? 'Room quantities' : 'Zone quantities', children: [_jsxs("div", { className: "overflow-hidden rounded-md border border-cyan-950/20 bg-[#f8faf7] text-slate-950", children: [_jsxs("div", { className: "flex items-center border-cyan-950/15 border-b px-2.5 py-2", children: [_jsx("span", { className: "font-semibold text-[11px]", children: effectiveZone.name }), _jsx("span", { className: "ml-auto rounded-full border border-cyan-800/25 bg-cyan-50 px-2 py-0.5 text-cyan-900 text-[9px]", children: report.classification === 'enclosed-room' ? 'Enclosed room' : 'Footprint only' })] }), _jsxs("div", { className: "flex items-baseline gap-2 px-2.5 py-2 font-mono text-[10px]", children: [_jsx("span", { className: "text-cyan-800", children: "A" }), _jsx("span", { children: formatAreaLabel(report.footprintArea, unit, 2) }), _jsx("span", { className: "ml-auto text-slate-600", children: "P" }), _jsx("span", { children: formatLinearMeasurement(report.perimeter, unit, metricNotation) })] })] }), _jsx(ZonePlanSketch, { edgeLengths: report.edgeLengths, metricNotation: metricNotation, polygon: effectiveZone.polygon, unit: unit }), _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(QuantityRow, { abbreviation: "Aw", format: (value) => formatAreaLabel(value, unit, 2), label: "Wall surface", quantity: report.wallSurface }), _jsx(QuantityRow, { abbreviation: "Af", format: (value) => formatAreaLabel(value, unit, 2), label: "Floor surface", quantity: report.floorSurface }), _jsx(QuantityRow, { abbreviation: "V", format: (value) => formatVolumeLabel(value, unit, 2), label: "Volume", quantity: report.volume })] })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(ZoneUnitPanel, { zone: effectiveZone }), _jsxs(PanelSection, { title: effectiveZone.spaceRole === 'room'
+                    ? i18n._({ id: 'node.zone.quantitiesPanel.roomQuantities', message: 'Room quantities' })
+                    : i18n._({ id: 'node.zone.quantitiesPanel.zoneQuantities', message: '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: displayRoomName(effectiveZone.name ?? '', i18n) }), _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'
+                                            ? i18n._({ id: 'node.zone.quantitiesPanel.enclosedRoom', message: 'Enclosed room' })
+                                            : i18n._({
+                                                id: 'node.zone.quantitiesPanel.footprintOnly',
+                                                message: 'Footprint only',
+                                            }) })] }), _jsxs("div", { className: "flex items-baseline gap-2 px-2.5 py-2 font-mono text-[10px]", children: [_jsx("span", { className: "text-cyan-800", children: "A" }), _jsx("span", { children: formatAreaLabel(report.footprintArea, unit, 2) }), _jsx("span", { className: "ml-auto text-slate-600", children: "P" }), _jsx("span", { children: formatLinearMeasurement(report.perimeter, unit, metricNotation) })] })] }), _jsx(ZonePlanSketch, { edgeLengths: report.edgeLengths, metricNotation: metricNotation, polygon: effectiveZone.polygon, unit: unit }), _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(QuantityRow, { abbreviation: "Aw", format: (value) => formatAreaLabel(value, unit, 2), label: i18n._({ id: 'node.zone.quantitiesPanel.wallSurface', message: 'Wall surface' }), quantity: report.wallSurface }), _jsx(QuantityRow, { abbreviation: "Af", format: (value) => formatAreaLabel(value, unit, 2), label: i18n._({
+                                    id: 'node.zone.quantitiesPanel.floorSurface',
+                                    message: 'Floor surface',
+                                }), quantity: report.floorSurface }), _jsx(QuantityRow, { abbreviation: "V", format: (value) => formatVolumeLabel(value, unit, 2), label: i18n._({ id: 'node.zone.quantitiesPanel.volume', message: 'Volume' }), quantity: report.volume })] })] })] }));
 }

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;AA8DzB,eAAO,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAWxD,CAAA;eAwJc,YAAY"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/zone/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA8DzB,eAAO,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAWxD,CAAA;eA0Jc,YAAY"}

package/dist/zone/renderer.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { polygonInteriorPoint, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { FLOOR_SCRIPT_LIFT, floorScriptSurface, 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 { useEffect, useMemo, useRef } from 'react';
@@ -56,11 +56,15 @@ export const ZoneRenderer = ({ node }) => {
     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. */
+/**
+ * The room's floor finish its script built: in the level's plan, its y = 0 on the floor plate's
+ * top. A room with no plate has no floor for it to stand on.
+ */
 function FloorScriptModel({ node, script }) {
-    return (_jsx("group", { "position-y": FLOOR_SCRIPT_LIFT, children: _jsx(FinishScriptModel, { ownerId: node.id, parentId: node.parentId, script: script }) }));
+    const surface = useScene((state) => floorScriptSurface(state.nodes, node.id));
+    if (surface === null)
+        return null;
+    return (_jsx("group", { "position-y": surface + 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/nodes",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Built-in node bundles for the Pascal 3D editor — one folder per kind, exported as `builtinPlugin`",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,6 +25,11 @@
       "types": "./dist/agent-operations/index.d.ts",
       "import": "./dist/agent-operations/index.js",
       "default": "./dist/agent-operations/index.js"
+    },
+    "./render": {
+      "types": "./dist/render.d.ts",
+      "import": "./dist/render.js",
+      "default": "./dist/render.js"
     }
   },
   "files": [
@@ -35,34 +40,35 @@
     "build": "NODE_OPTIONS=--max-old-space-size=6144 tsc --build && bun ../../scripts/fix-node-esm-imports.ts dist",
     "dev": "tsgo --build --watch",
     "test": "bun test",
-    "prepublishOnly": "bun run build && bun test"
+    "prepublishOnly": "bun run build && bun test",
+    "bench:elevator": "bun test ./src/elevator/__bench__/rendering.bench.tsx && bun ./src/elevator/__bench__/runtime.ts"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.6",
-    "@pascal-app/editor": "^1.0.6",
-    "@pascal-app/viewer": "^1.0.6",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/editor": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "lucide-react": "^1",
     "react": "^18 || ^19",
     "react-dom": "^18 || ^19",
-    "three": "^0.186",
+    "three": "^0.187",
     "zustand": "^5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.3.1",
-    "@modelcontextprotocol/server": "^2.3.1",
-    "@pascal-app/core": "^1.0.6",
-    "@pascal-app/editor": "^1.0.6",
-    "@pascal-app/mcp": "^1.0.6",
-    "@pascal-app/viewer": "^1.0.6",
+    "@modelcontextprotocol/client": "^2.4.0",
+    "@modelcontextprotocol/server": "^2.4.0",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/editor": "^1.1.0",
+    "@pascal-app/mcp": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@pascal/typescript-config": "*",
     "@react-three/test-renderer": "^9.1.1",
-    "@types/bun": "^1.4.3",
-    "@types/node": "^26.6.5",
+    "@types/bun": "^1.4.4",
+    "@types/node": "^26.6.6",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
-    "@types/three": "^0.186.0",
+    "@types/three": "^0.187",
     "typescript": "7.0.2"
   },
   "keywords": [
@@ -78,5 +84,10 @@
   },
   "license": "MIT",
   "homepage": "https://github.com/pascalorg/editor/tree/main/packages/nodes#readme",
-  "bugs": "https://github.com/pascalorg/editor/issues"
+  "bugs": "https://github.com/pascalorg/editor/issues",
+  "peerDependenciesMeta": {
+    "@pascal-app/editor": {
+      "optional": true
+    }
+  }
 }

package/dist/site/generic-foundation-geometry.d.ts

@@ -1,16 +0,0 @@
-import type { FoundationMember } from '@pascal-app/core';
-/** The foundation members of one kind as one indexed mesh, in world coordinates. */
-export type FoundationMesh = {
-    positions: Float32Array;
-    normals: Float32Array;
-    /** Metres along the run, for the courses of block to bond along the wall. */
-    along: Float32Array;
-    indices: Uint32Array;
-};
-/**
- * The runs of `kind` as closed boxes, six faces each with its own flat normal. A run is a prism on
- * the plan line `from` to `to`, `width` across, from `bottomY` to `topY`. Corners are closed by the
- * runs themselves (they overlap), so the boxes carry no joins.
- */
-export declare function buildFoundationMesh(members: readonly FoundationMember[], kind: FoundationMember['kind']): FoundationMesh | null;
-//# sourceMappingURL=generic-foundation-geometry.d.ts.map

package/dist/site/generic-foundation-geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic-foundation-geometry.d.ts","sourceRoot":"","sources":["../../src/site/generic-foundation-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,6EAA6E;IAC7E,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAC7B,cAAc,GAAG,IAAI,CA6DvB"}

package/dist/site/generic-foundation-geometry.js

@@ -1,75 +0,0 @@
-const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-const cross = (a, b) => [
-    a[1] * b[2] - a[2] * b[1],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0],
-];
-const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-/**
- * The runs of `kind` as closed boxes, six faces each with its own flat normal. A run is a prism on
- * the plan line `from` to `to`, `width` across, from `bottomY` to `topY`. Corners are closed by the
- * runs themselves (they overlap), so the boxes carry no joins.
- */
-export function buildFoundationMesh(members, kind) {
-    const runs = members.filter((member) => member.kind === kind);
-    if (runs.length === 0)
-        return null;
-    const positions = [];
-    const normals = [];
-    const along = [];
-    const indices = [];
-    const quad = (corners, outward, alongAt) => {
-        const [a, b, c] = corners;
-        const facing = dot(cross(sub(b, a), sub(c, a)), outward) >= 0;
-        const order = facing ? [0, 1, 2, 3] : [0, 3, 2, 1];
-        const base = positions.length / 3;
-        for (const index of order) {
-            positions.push(...corners[index]);
-            normals.push(...outward);
-            along.push(alongAt[index]);
-        }
-        indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
-    };
-    for (const { from, to, width, bottomY, topY } of runs) {
-        const dx = to[0] - from[0];
-        const dz = to[1] - from[1];
-        const length = Math.hypot(dx, dz);
-        if (length < 1e-9 || topY - bottomY < 1e-9)
-            continue;
-        const [ux, uz] = [dx / length, dz / length];
-        const [nx, nz] = [-uz, ux];
-        const half = width / 2;
-        const at = (end, side, y) => [
-            end[0] + nx * half * side,
-            y,
-            end[1] + nz * half * side,
-        ];
-        const [a0, a1, a2, a3] = [
-            at(from, 1, bottomY),
-            at(to, 1, bottomY),
-            at(to, -1, bottomY),
-            at(from, -1, bottomY),
-        ];
-        const [b0, b1, b2, b3] = [
-            at(from, 1, topY),
-            at(to, 1, topY),
-            at(to, -1, topY),
-            at(from, -1, topY),
-        ];
-        const run = [0, length, length, 0];
-        quad([b0, b1, b2, b3], [0, 1, 0], run);
-        quad([a0, a1, a2, a3], [0, -1, 0], run);
-        quad([a0, a1, b1, b0], [nx, 0, nz], [0, length, length, 0]);
-        quad([a3, a2, b2, b3], [-nx, 0, -nz], [0, length, length, 0]);
-        quad([a0, a3, b3, b0], [-ux, 0, -uz], [0, 0, 0, 0]);
-        quad([a1, a2, b2, b1], [ux, 0, uz], [length, length, length, length]);
-    }
-    if (indices.length === 0)
-        return null;
-    return {
-        positions: new Float32Array(positions),
-        normals: new Float32Array(normals),
-        along: new Float32Array(along),
-        indices: new Uint32Array(indices),
-    };
-}

package/dist/site/generic-foundation.d.ts

@@ -1,4 +0,0 @@
-import { type FoundationMember } from '@pascal-app/core';
-export declare function sameFoundation(a: readonly FoundationMember[], b: readonly FoundationMember[]): boolean;
-export declare function GenericFoundation(): import("react").JSX.Element;
-//# sourceMappingURL=generic-foundation.d.ts.map

package/dist/site/generic-foundation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic-foundation.d.ts","sourceRoot":"","sources":["../../src/site/generic-foundation.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,kBAAkB,CAAA;AAoDzB,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC,EAAE,SAAS,gBAAgB,EAAE,WAoB5F;AAwCD,wBAAgB,iBAAiB,gCA8BhC"}