@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/window/definition.render.js

@@ -0,0 +1,83 @@
+import { windowSlots } from '@pascal-app/core';
+import { NEW_WINDOW_FRAME_THICKNESS } from '@pascal-app/core/building';
+import { windowBatchable } from '../shared/node-batch/batchable.js';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
+import { openingSeenFromOutside } from '../wall/exterior.js';
+import { windowMechanism } from './mechanism.js';
+import { WindowNode } from './schema.js';
+export function resolveWindowHandlePortalTarget(window, scene) {
+    const parentId = window.parentId;
+    if (!parentId)
+        return null;
+    const grandparentId = scene.get(parentId)
+        ?.parentId;
+    if (!grandparentId)
+        return null;
+    if (window.dormerId !== parentId)
+        return grandparentId;
+    return (scene.get(grandparentId)?.parentId ??
+        grandparentId);
+}
+export const windowRenderDefinition = {
+    kind: 'window',
+    schemaVersion: 4,
+    schema: WindowNode,
+    category: 'structure',
+    // Same schema-driven defaults trick as door: parse a stub, strip
+    // id/type. Window also has many fields with zod `.default()` set.
+    defaults: () => {
+        const stub = WindowNode.parse({
+            id: 'window_default',
+            type: 'window',
+            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
+            casingFaceA: true,
+            casingFaceB: true,
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        reveal: { phase: 'openings', style: 'cut' },
+        exterior: openingSeenFromOutside,
+        revealOnEdit: ['position', 'width', 'height', 'openingShape', 'windowType'],
+        batchable: windowBatchable,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        wallOpeningPlacement: true,
+        // Windows also host on roof-segment wall faces (base walls under the
+        // roof, gable ends) — same wiring as door; see the door capability
+        // for why `dirtyHandledByOwnSystem` is required.
+        roofAccessory: {
+            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
+            cutScope: 'wall',
+            dirtyHandledByOwnSystem: true,
+        },
+        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
+        // the cursor at preset placement time — see door for the pattern.
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
+        // Frame / glass slots painted through the registry. The window system tags
+        // each mesh with its `userData.slotId`; paint writes `node.slots`.
+        slots: () => windowSlots(),
+        mechanism: windowMechanism,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Window',
+        description: 'A window cut into a wall. Animated open/close for opening windows.',
+        icon: { kind: 'url', src: '/icons/window.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 60,
+    },
+    mcp: {
+        description: 'A window mounted on a wall, with type / dimensions / opening options.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAwRrE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CA6RrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -56,6 +56,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
     // See `doorFloorplanMoveTarget`: off-wall the window free-follows the cursor
     // as a ghost and isn't committable (it needs a wall). Starts true.
     let onWall = true;
+    let lastFits = true;
     // Alt force-place (last apply's modifier) — lets `canCommit` allow an
     // overlapping placement, matching the 3D move.
     let forcePlace = false;
@@ -164,6 +165,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             const slid = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height, nodes);
             const { clampedY } = slid;
             let clampedX = slid.clampedX;
+            lastFits = slid.fits;
             // Alt, or snapping off, drops the window where it is.
             const corner = forcePlace || snappingTurnedOff()
                 ? { snap: null, block: null }
@@ -184,8 +186,10 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                     corner.block = { reason: 'curtain', end: cornerSnap.end };
                     cornerSnap = null;
                 }
-                else
+                else {
                     clampedX = cornerSnap.centreX;
+                    lastFits = settled.fits;
+                }
             }
             showCornerCue(cornerSnap, corner.block);
             // One click per real position step, keyed on the SNAPPED along-wall value
@@ -237,9 +241,8 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             const live = useScene.getState().nodes[nodeId];
             if (live?.type !== 'window')
                 return false;
-            // Block on overlap UNLESS Alt force-places — same `placeable` rule as
-            // the 3D move + the shared `resolveOpeningPlacement`.
-            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = !lastFits ||
+                hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {

package/dist/window/mechanism.js

@@ -1,4 +1,4 @@
-import { closeWindowOpenState, getDisplayedWindowShutterValue, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, setWindowShuttersOpenState, } from '@pascal-app/editor';
+import { closeWindowOpenState, getDisplayedWindowShutterValue, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, setWindowShuttersOpenState, } from '@pascal-app/core';
 import { scriptedOpening } from '../shared/scripted-opening.js';
 /** A window's sash: Open and Close preview it without touching the saved open state. */
 export const windowMechanism = {

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA6BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAuEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAw5ClD,CAAA;eAEc,cAAc"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA6BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAuEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAu5ClD,CAAA;eAEc,cAAc"}

package/dist/window/move-tool.js

@@ -321,6 +321,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const slid = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.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.
             // Alt, or snapping off, places the window where it is dropped.
             const found = plain || snappingTurnedOff()
@@ -341,10 +342,13 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     block = { reason: 'curtain', end: snap.end };
                     snap = null;
                 }
-                else
+                else {
                     clampedX = snap.centreX;
+                    fits = settled.fits;
+                }
             }
-            const valid = !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
+            const valid = fits &&
+                !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -668,15 +672,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // Scene writes, not overrides: leaving the wall must actually remove the
             // window from the wall's `children` or the CSG cut trails the ghost
             // around the old wall (see the wall-branch note in `applyPreview`).
-            if (currentHostId === levelId) {
-                updateDraft({
-                    position: [localX, sillCenterY, localZ],
-                    rotation: [0, yaw, 0],
-                    side: sideOverride,
-                    visible: false,
-                });
-            }
-            else {
+            if (currentHostId !== levelId) {
                 if (currentHostId && currentHostId !== levelId)
                     markHostDirty(currentHostId);
                 updateDraft({

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

@@ -1 +1 @@
-{"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"}
+{"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

@@ -347,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, {
@@ -366,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

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,
+    },
+};