@pascal-app/nodes 1.0.6 → 1.1.0

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,EAkqCvB,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
@@ -351,6 +347,7 @@ const WindowTool = () => {
             const slid = clampToWall(wall, localX, localY, width, height, nodes);
             const { clampedY } = slid;
             let clampedX = slid.clampedX;
+            let fits = slid.fits;
             // The corner zone: the edge snaps to the corner, unless a curtain wall's margin keeps it off.
             const found = cornerSnapOn
                 ? evaluateCorner(nodes, {
@@ -370,10 +367,12 @@ const WindowTool = () => {
                     block = { reason: 'curtain', end: snap.end };
                     snap = null;
                 }
-                else
+                else {
                     clampedX = snap.centreX;
+                    fits = settled.fits;
+                }
             }
-            const valid = !hasWallChildOverlap(wall.id, nodes, clampedX, clampedY, width, height, ignoreId);
+            const valid = fits && !hasWallChildOverlap(wall.id, nodes, clampedX, clampedY, width, height, ignoreId);
             return { clampedX, clampedY, valid, snap, block };
         };
         // Shared create/update path for the wall draft — used by the direct
@@ -432,7 +431,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 +482,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 +549,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 +577,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 +617,7 @@ const WindowTool = () => {
                 return;
             if (!isValidWallSideFace(event.normal) ||
                 isCurvedWall(event.node) ||
+                isRailingWall(event.node) ||
                 event.node.parentId !== getLevelId()) {
                 return;
             }
@@ -776,7 +782,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 +859,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 +1037,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/contextual-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgB1B"}
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgB1B"}

package/dist/zone/contextual-dimensions.js

@@ -1,5 +1,4 @@
-import { area as footprintArea, polygonInteriorPoint, } from '@pascal-app/core';
-import { formatAreaLabel } from '@pascal-app/editor';
+import { area as footprintArea, formatAreaLabel, polygonInteriorPoint, } from '@pascal-app/core';
 export function buildZoneContextualDimensions(node, ctx) {
     if (node.autoFromWalls && node.enclosureStatus === 'open')
         return null;

package/dist/zone/definition.d.ts

@@ -1,10 +1,265 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ZoneNode } from './schema.js';
-/**
- * Zone — Stage A. Custom-behavior escape hatch: zone uses TSL shader
- * materials + `<Html>` portals + per-frame uniform poking, so it
- * lives via `def.renderer` + `def.system` (no `def.geometry` possible
- * because zone isn't really a mesh).
- */
-export declare const zoneDefinition: NodeDefinition<typeof ZoneNode>;
+export declare const zoneDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`zone_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"zone">>;
+    name: import("zod").ZodString;
+    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    holes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+    autoFromWalls: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    boundaryWallIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`wall_${string}`>>>>;
+    boundarySeparatorIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    hostZoneId: import("zod").ZodOptional<import("zod").ZodString>;
+    seed: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    floor: import("zod").ZodOptional<import("zod").ZodObject<{
+        elevation: import("zod").ZodOptional<import("zod").ZodNumber>;
+        support: import("zod").ZodOptional<import("zod").ZodLiteral<"open">>;
+        footprint: import("zod").ZodOptional<import("zod").ZodString>;
+        thickness: import("zod").ZodOptional<import("zod").ZodNumber>;
+        sourceSlabId: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`slab_${string}`>>;
+        finish: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>>;
+        regions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            finish: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>;
+        }, import("zod/v4/core").$strip>>>;
+        script: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"script">;
+            meta: import("zod").ZodOptional<import("zod").ZodObject<{
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                category: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                parent: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            language: import("zod").ZodDefault<import("zod").ZodEnum<{
+                bpy: "bpy";
+                three: "three";
+            }>>;
+            script: import("zod").ZodString;
+            params: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>>;
+            artifact: import("zod").ZodString;
+            manifest: import("zod").ZodObject<{
+                bounds: import("zod").ZodObject<{
+                    min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>;
+                params: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                    kind: import("zod").ZodEnum<{
+                        boolean: "boolean";
+                        number: "number";
+                        string: "string";
+                    }>;
+                    default: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>;
+                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    step: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    unit: import("zod").ZodOptional<import("zod").ZodString>;
+                    options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>>;
+                parts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                    type: import("zod").ZodOptional<import("zod").ZodString>;
+                    bounds: import("zod").ZodOptional<import("zod").ZodObject<{
+                        min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                        max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>>;
+                surfaces: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    part: import("zod").ZodOptional<import("zod").ZodString>;
+                    y: import("zod").ZodNumber;
+                    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                }, import("zod/v4/core").$strip>>>;
+                slots: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                    color: import("zod").ZodOptional<import("zod").ZodString>;
+                    roughness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    metalness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    transparent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    emissive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>>;
+                anchors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    normal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                }, import("zod/v4/core").$strip>>>;
+                lights: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    color: import("zod").ZodString;
+                    intensity: import("zod").ZodNumber;
+                    distance: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    spot: import("zod").ZodOptional<import("zod").ZodObject<{
+                        direction: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                        angle: import("zod").ZodNumber;
+                        softness: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                    shadows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    glow: import("zod").ZodOptional<import("zod").ZodObject<{
+                        size: import("zod").ZodNumber;
+                        strength: import("zod").ZodDefault<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>>;
+                undersides: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    part: import("zod").ZodOptional<import("zod").ZodString>;
+                    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                    plane: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>>>;
+                animations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    duration: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>>;
+                cutters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    host: import("zod").ZodEnum<{
+                        ceiling: "ceiling";
+                        mounted: "mounted";
+                        slab: "slab";
+                        wall: "wall";
+                    }>;
+                    polygon: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    minY: import("zod").ZodNumber;
+                    maxY: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>>;
+                cutout: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                collider: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                shape: import("zod").ZodOptional<import("zod").ZodObject<{
+                    tolerance: import("zod").ZodNumber;
+                    bands: import("zod").ZodArray<import("zod").ZodObject<{
+                        y0: import("zod").ZodNumber;
+                        y1: import("zod").ZodNumber;
+                        polygons: import("zod").ZodArray<import("zod").ZodObject<{
+                            outer: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                            holes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                triangles: import("zod").ZodNumber;
+                coverage: import("zod").ZodOptional<import("zod").ZodNumber>;
+                uncovered: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>>>;
+            }, import("zod/v4/core").$strip>;
+            images: import("zod").ZodOptional<import("zod").ZodObject<{
+                artifact: import("zod").ZodString;
+                thumbnail: import("zod").ZodString;
+                floorPlan: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            inputs: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        drop: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    roomType: import("zod").ZodOptional<import("zod").ZodEnum<{
+        deck: "deck";
+        patio: "patio";
+        porch: "porch";
+    }>>;
+    porchFraming: import("zod").ZodOptional<import("zod").ZodObject<{
+        auto: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        postSize: import("zod").ZodOptional<import("zod").ZodString>;
+        postSpacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+        beamSize: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    decking: import("zod").ZodOptional<import("zod").ZodObject<{
+        boardSize: import("zod").ZodOptional<import("zod").ZodEnum<{
+            "2x4": "2x4";
+            "2x6": "2x6";
+            "5/4x6": "5/4x6";
+            composite: "composite";
+        }>>;
+        gap: import("zod").ZodOptional<import("zod").ZodNumber>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            diagonal: "diagonal";
+            parallel: "parallel";
+            perpendicular: "perpendicular";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    ceiling: import("zod").ZodOptional<import("zod").ZodObject<{
+        regions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            finish: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>;
+        }, import("zod/v4/core").$strip>>>;
+    }, import("zod/v4/core").$strip>>;
+    floorStepFinish: import("zod").ZodOptional<import("zod").ZodString>;
+    floorStepOverrides: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+        step: import("zod").ZodOptional<import("zod").ZodNumber>;
+        finish: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    floorEdgeFinish: import("zod").ZodOptional<import("zod").ZodString>;
+    wallMaterial: import("zod").ZodOptional<import("zod").ZodString>;
+    wallOverrides: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        wallId: import("zod").ZodString;
+        face: import("zod").ZodEnum<{
+            a: "a";
+            b: "b";
+        }>;
+        finish: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    hasFloor: import("zod").ZodOptional<import("zod").ZodLiteral<false>>;
+    hasCeiling: import("zod").ZodOptional<import("zod").ZodLiteral<false>>;
+    spaceRole: import("zod").ZodDefault<import("zod").ZodEnum<{
+        generic: "generic";
+        room: "room";
+    }>>;
+    roomNumber: import("zod").ZodDefault<import("zod").ZodString>;
+    enclosureStatus: import("zod").ZodDefault<import("zod").ZodEnum<{
+        auto: "auto";
+        enclosed: "enclosed";
+        open: "open";
+    }>>;
+    floorFinish: import("zod").ZodDefault<import("zod").ZodString>;
+    wallFinish: import("zod").ZodDefault<import("zod").ZodString>;
+    ceilingFinish: import("zod").ZodDefault<import("zod").ZodString>;
+    ceilingHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    occupancy: import("zod").ZodDefault<import("zod").ZodString>;
+    clearDimensionPolicy: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "finish-faces": "finish-faces";
+        "inside-faces": "inside-faces";
+        none: "none";
+    }>>;
+    color: import("zod").ZodDefault<import("zod").ZodString>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAelF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsF1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ZoneNode } from './schema.js';
+export declare const zoneEditContribution: NodeEditContribution<typeof ZoneNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/zone/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAYvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CA8BtE,CAAA"}

package/dist/zone/definition.edit.js

@@ -0,0 +1,38 @@
+import { buildZoneContextualDimensions } from './contextual-dimensions.js';
+import { buildZoneFloorplan } from './floorplan.js';
+import { zoneAddVertexAffordance, zoneDeleteVertexAffordance, zoneMoveEdgeAffordance, zoneMoveVertexAffordance, } from './floorplan-affordances.js';
+import { zoneFloorplanMoveTarget } from './floorplan-move.js';
+import { zoneParametrics } from './parametrics.js';
+import { buildRoomFloorplanSchedule } from './room-documentation.js';
+import { buildingUnitsForZone } from './unit-membership.js';
+export const zoneEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildZoneContextualDimensions,
+            schedule: buildRoomFloorplanSchedule,
+        },
+    },
+    parametrics: zoneParametrics,
+    floorplan: buildZoneFloorplan,
+    // Every unit under the building, not just the current owner: a zone that
+    // joins its first unit has no owner to depend on until the unit changes.
+    floorplanDependencies: (node, nodes) => [
+        ...(node.autoFromWalls ? node.boundaryWallIds : []),
+        ...buildingUnitsForZone(node, (id) => nodes[id]).map((unit) => unit.id),
+    ],
+    // 2D body move — centroid-pivot polygon mover (same as slab / ceiling).
+    // Without this, zone fell through to the overlay's generic free-translate
+    // path, which committed a `position` field zone has no schema for, so the
+    // polygon never actually moved on drop.
+    floorplanMoveTarget: zoneFloorplanMoveTarget,
+    // Polygon editor when selected — same four operations slabs / ceilings
+    // expose. The shared factories key off `node.polygon`, optional
+    // `node.holes` (absent on zones). See `floorplan-affordances.ts`.
+    floorplanAffordances: {
+        'move-vertex': zoneMoveVertexAffordance,
+        'add-vertex': zoneAddVertexAffordance,
+        'move-edge': zoneMoveEdgeAffordance,
+        'delete-vertex': zoneDeleteVertexAffordance,
+    },
+};

package/dist/zone/definition.js

@@ -1,97 +1,4 @@
-import { ZoneNode as ZoneNodeSchema } from '@pascal-app/core';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
-import { buildZoneContextualDimensions } from './contextual-dimensions.js';
-import { buildZoneFloorplan } from './floorplan.js';
-import { zoneAddVertexAffordance, zoneDeleteVertexAffordance, zoneMoveEdgeAffordance, zoneMoveVertexAffordance, } from './floorplan-affordances.js';
-import { zoneFloorplanMoveTarget } from './floorplan-move.js';
-import { zoneParametrics } from './parametrics.js';
-import { zoneQuickMeasurement } from './quick-measurement.js';
-import { buildRoomFloorplanSchedule } from './room-documentation.js';
-import { ZoneNode } from './schema.js';
-import { buildingUnitsForZone } from './unit-membership.js';
-/**
- * Zone — Stage A. Custom-behavior escape hatch: zone uses TSL shader
- * materials + `<Html>` portals + per-frame uniform poking, so it
- * lives via `def.renderer` + `def.system` (no `def.geometry` possible
- * because zone isn't really a mesh).
- */
-export const zoneDefinition = {
-    kind: 'zone',
-    snapProfile: 'structural',
-    schemaVersion: 2,
-    schema: ZoneNode,
-    category: 'site',
-    extensions: {
-        'pascal:editor/floorplan': {
-            contextualDimensions: buildZoneContextualDimensions,
-            schedule: buildRoomFloorplanSchedule,
-        },
-    },
-    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,
-    },
-    parametrics: zoneParametrics,
-    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,
-    },
-    floorplan: buildZoneFloorplan,
-    // Every unit under the building, not just the current owner: a zone that
-    // joins its first unit has no owner to depend on until the unit changes.
-    floorplanDependencies: (node, nodes) => [
-        ...(node.autoFromWalls ? node.boundaryWallIds : []),
-        ...buildingUnitsForZone(node, (id) => nodes[id]).map((unit) => unit.id),
-    ],
-    // 2D body move — centroid-pivot polygon mover (same as slab / ceiling).
-    // Without this, zone fell through to the overlay's generic free-translate
-    // path, which committed a `position` field zone has no schema for, so the
-    // polygon never actually moved on drop.
-    floorplanMoveTarget: zoneFloorplanMoveTarget,
-    // Polygon editor when selected — same four operations slabs / ceilings
-    // expose. The shared factories key off `node.polygon`, optional
-    // `node.holes` (absent on zones). See `floorplan-affordances.ts`.
-    floorplanAffordances: {
-        'move-vertex': zoneMoveVertexAffordance,
-        'add-vertex': zoneAddVertexAffordance,
-        'move-edge': zoneMoveEdgeAffordance,
-        'delete-vertex': zoneDeleteVertexAffordance,
-    },
-    presentation: {
-        label: 'Zone',
-        description: 'A polygonal site zone (lawn, water, paving) with a TSL gradient material.',
-        icon: { kind: 'url', src: '/icons/zone.webp' },
-        paletteSection: 'site',
-        paletteOrder: 20,
-    },
-    mcp: {
-        description: 'A polygon-bounded site zone with a typed surface (grass / water / paving / ...).',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { zoneEditContribution } from './definition.edit.js';
+import { zoneRenderDefinition } from './definition.render.js';
+export const zoneDefinition = composeNodeDefinition(zoneRenderDefinition, zoneEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ZoneNode } from './schema.js';
+export declare const zoneRenderDefinition: NodeRenderDefinition<typeof ZoneNode> & {
+    kind: 'zone';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/zone/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAmDxF,CAAA"}