@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/window/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AA+GA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EA2oCvB,CAAA;eAEc,UAAU"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AAmHA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAqqCvB,CAAA;eAEc,UAAU"}

package/dist/window/tool.js

@@ -1,5 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, runAsSingleSceneHistoryStep, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, createSnapEaser, DEFAULT_WALL_THICKNESS, dormerWallFacePointToDormer, emitter, evaluateCorner, getEffectiveNode, getWallThickness, holdHiddenWallPointerEvents, isCurvedWall, isRailingWall, prefersReducedMotion, resolveOpeningFrameDepth, runAsSingleSceneHistoryStep, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
 import { windowTakesStyle } from '@pascal-app/core/building';
 import { calculateItemRotation, clearPlacementSurface, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, publishPlacementSurface, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { useEffect, useMemo, useRef, useState } from 'react';
@@ -64,10 +64,6 @@ const WindowTool = () => {
         rotation: [0, 0, 0],
         side: fallbackPose?.side ?? 'front',
     }), [fallbackPose?.side, placedType, placedStyle]);
-    // The frame depth is a fixed parse default (the `side` flip doesn't change
-    // it); a ref lets the facing-pose publish inside the setup effect read it
-    // without re-subscribing every event listener.
-    const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
         // The draft is a created carry draft: undo history and every save leave it out
@@ -202,7 +198,7 @@ const WindowTool = () => {
         // On-host cursor: the green/red wireframe outline tracks a live draft.
         // Showing it always clears the off-host floating ghost (they never
         // coexist — a draft means the cursor is on a valid host).
-        const updateCursor = (worldPosition, cursorRotationY, valid, indicatorYOffset) => {
+        const updateCursor = (worldPosition, cursorRotationY, valid, indicatorYOffset, hostThickness) => {
             setFallbackPose(null);
             const group = cursorGroupRef.current;
             if (!group)
@@ -217,7 +213,7 @@ const WindowTool = () => {
             useFacingPose.getState().set({
                 position: [worldPosition[0], worldPosition[1] + indicatorYOffset, worldPosition[2]],
                 rotationY: cursorRotationY,
-                depth: frameDepthRef.current,
+                depth: resolveOpeningFrameDepth({ frameDepth: draftRef.current?.frameDepth }, hostThickness),
             });
         };
         // Off-host fallback: hide the wireframe outline and float the real window
@@ -305,7 +301,7 @@ const WindowTool = () => {
             clearOpeningGuides3D();
             const worldPosition = dormerWindowWorldPosition(event, target);
             publishPlacementSurface(new Vector3(...worldPosition), getDormerWindowWorldNormal(event, target));
-            updateCursor(worldPosition, getDormerWindowWorldYaw(event, target), target.valid, 0);
+            updateCursor(worldPosition, getDormerWindowWorldYaw(event, target), target.valid, 0, DEFAULT_WALL_THICKNESS);
         };
         // Sill alignment (snap + guide): a sibling sill/centre/top wins over the
         // grid when within threshold — it's the magnetic ("lines") component for the
@@ -432,7 +428,7 @@ const WindowTool = () => {
                 });
             }
             publishDraftPreview(wall);
-            updateCursor(wallLocalToWorld(wall, shownX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
+            updateCursor(wallLocalToWorld(wall, shownX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY, getWallThickness(wall));
             if (draftRef.current) {
                 publishOpeningGuidesForWallEvent({
                     wall,
@@ -483,8 +479,10 @@ const WindowTool = () => {
                 awningDirection: draft.awningDirection,
                 casementStyle: draft.casementStyle,
                 hingesSide: draft.hingesSide,
+                casingFaceA: draft.casingFaceA,
+                casingFaceB: draft.casingFaceB,
+                casingWidth: draft.casingWidth,
                 frameThickness: draft.frameThickness,
-                frameDepth: draft.frameDepth,
                 columnRatios: draft.columnRatios,
                 rowRatios: draft.rowRatios,
                 columnDividerThickness: draft.columnDividerThickness,
@@ -548,8 +546,10 @@ const WindowTool = () => {
                 openingCornerRadii: draft.openingCornerRadii,
                 cornerRadius: draft.cornerRadius,
                 archHeight: draft.archHeight,
+                casingFaceA: draft.casingFaceA,
+                casingFaceB: draft.casingFaceB,
+                casingWidth: draft.casingWidth,
                 frameThickness: draft.frameThickness,
-                frameDepth: draft.frameDepth,
                 columnRatios: draft.columnRatios,
                 rowRatios: draft.rowRatios,
                 columnDividerThickness: draft.columnDividerThickness,
@@ -574,8 +574,10 @@ const WindowTool = () => {
         const onWallHover = (event) => {
             hostKind = 'wall';
             lastMeshEventTime = event.nativeEvent?.timeStamp ?? -1;
+            // A railing takes no window: its openings are gaps a door leaves in the guard.
             if (!isValidWallSideFace(event.normal) ||
                 isCurvedWall(event.node) ||
+                isRailingWall(event.node) ||
                 event.node.parentId !== getLevelId()) {
                 destroyDraft();
                 showWallFallbackCursor(event);
@@ -612,6 +614,7 @@ const WindowTool = () => {
                 return;
             if (!isValidWallSideFace(event.normal) ||
                 isCurvedWall(event.node) ||
+                isRailingWall(event.node) ||
                 event.node.parentId !== getLevelId()) {
                 return;
             }
@@ -776,7 +779,7 @@ const WindowTool = () => {
         const updateRoofCursor = (target, roof) => {
             const pose = getRoofWallOpeningCursorPose(target, roof);
             if (pose)
-                updateCursor(pose.position, pose.rotationY, target.valid, -target.position[1]);
+                updateCursor(pose.position, pose.rotationY, target.valid, -target.position[1], DEFAULT_WALL_THICKNESS);
         };
         const onRoofHover = (event) => {
             hostKind = 'roof';
@@ -853,8 +856,10 @@ const WindowTool = () => {
                 awningDirection: draft.awningDirection,
                 casementStyle: draft.casementStyle,
                 hingesSide: draft.hingesSide,
+                casingFaceA: draft.casingFaceA,
+                casingFaceB: draft.casingFaceB,
+                casingWidth: draft.casingWidth,
                 frameThickness: draft.frameThickness,
-                frameDepth: draft.frameDepth,
                 columnRatios: draft.columnRatios,
                 rowRatios: draft.rowRatios,
                 columnDividerThickness: draft.columnDividerThickness,
@@ -1029,7 +1034,7 @@ const WindowTool = () => {
     // dispose on unmount rather than reallocating (and orphaning) an EdgesGeometry
     // on every re-render during placement.
     const edgesGeo = useMemo(() => {
-        const boxGeo = new BoxGeometry(FALLBACK_WIDTH, FALLBACK_HEIGHT, 0.07);
+        const boxGeo = new BoxGeometry(FALLBACK_WIDTH, FALLBACK_HEIGHT, resolveOpeningFrameDepth({}, DEFAULT_WALL_THICKNESS));
         const geo = new EdgesGeometry(boxGeo);
         boxGeo.dispose();
         return geo;

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":"AAqNA,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, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
+import { displayRoomName, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, PanelSection, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useMemo } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { PanelSelect } from '../shared/panel-fields.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.0.7",
   "description": "Built-in node bundles for the Pascal 3D editor — one folder per kind, exported as `builtinPlugin`",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,31 +38,31 @@
     "prepublishOnly": "bun run build && bun test"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.6",
-    "@pascal-app/editor": "^1.0.6",
-    "@pascal-app/viewer": "^1.0.6",
+    "@pascal-app/core": "^1.0.7",
+    "@pascal-app/editor": "^1.0.7",
+    "@pascal-app/viewer": "^1.0.7",
     "@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.0.7",
+    "@pascal-app/editor": "^1.0.7",
+    "@pascal-app/mcp": "^1.0.7",
+    "@pascal-app/viewer": "^1.0.7",
     "@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": [

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