@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/wall/treatments.js

@@ -1,11 +1,12 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, wallFaceBaseOffset, wallFaceScriptSkirtingGap, } from '@pascal-app/core';
+import { clampWallEndHeightOffset, getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, openingCasingBoards, resolveOpeningCasingHost, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, wallFaceBaseOffset, wallFaceScriptSkirtingGap, } from '@pascal-app/core';
 import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
 import { memo, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries as mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
+import { skirtingFloorOpeningRanges } from './skirting-floor-gaps.js';
 import { treatmentMiterDataForProud } from './treatment-level-data.js';
 const CURVE_SEGMENTS = 24;
 const MIN_SLICE_PROUD = 0.0005;
@@ -340,8 +341,27 @@ function subtractOpeningRanges(ranges, openings) {
     }
     return next;
 }
-function trimOpeningRanges(node, childrenNodes, yBottom, height) {
+/**
+ * Where a trim on `face`, from `yBottom` to `height` above it, breaks for the wall's doors and
+ * windows: across each opening it reaches, and across each casing board on that face it reaches
+ * (the legs beside the cutout, the head over it, a window's bottom board under it), so a skirting
+ * or chair rail stops against the casing instead of running through it. A face the opening is not
+ * cased on breaks at the cutout only.
+ */
+function trimOpeningRanges(node, face, childrenNodes, yBottom, height, slope = 0) {
     const yTop = yBottom + height;
+    // The band rises `slope` per metre along the wall, so a box cuts it only over
+    // the stretch where the two overlap.
+    const cut = (x0, x1, bottom, top) => {
+        if (Math.abs(slope) <= EPS)
+            return top > yBottom + EPS && bottom < yTop - EPS ? [[x0, x1]] : [];
+        const a = (top - yBottom) / slope;
+        const b = (bottom - yTop) / slope;
+        const from = Math.max(x0, Math.min(a, b));
+        const to = Math.min(x1, Math.max(a, b));
+        return to - from > EPS ? [[from, to]] : [];
+    };
+    const nodes = useScene.getState().nodes;
     return childrenNodes
         .filter((child) => child.type === 'door' || child.type === 'window')
         .flatMap((child) => {
@@ -349,10 +369,17 @@ function trimOpeningRanges(node, childrenNodes, yBottom, height) {
         const childHeight = child.height ?? 0;
         const position = child.position ?? [0, 0, 0];
         const childBottom = position[1] - childHeight / 2;
-        const childTop = childBottom + childHeight;
-        if (childTop <= yBottom + EPS || childBottom >= yTop - EPS)
-            return [];
-        return [[position[0] - width / 2, position[0] + width / 2]];
+        const ranges = cut(position[0] - width / 2, position[0] + width / 2, childBottom, childBottom + childHeight);
+        const opening = { ...child, position };
+        const host = resolveOpeningCasingHost(opening, nodes, node);
+        if (!host)
+            return ranges;
+        for (const board of openingCasingBoards(opening, host)) {
+            const [x, y] = [position[0] + board.center[0], position[1] + board.center[1]];
+            if (board.face === face)
+                ranges.push(...cut(x - board.size[0] / 2, x + board.size[0] / 2, y - board.size[1] / 2, y + board.size[1] / 2));
+        }
+        return ranges;
     });
 }
 function buildPlanPolygon(outer, inner) {
@@ -428,12 +455,19 @@ function mergeGeometries(geometries) {
     return null;
 }
 export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelData) {
-    const wallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+    const wallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes, 0);
     const height = trim.height;
+    const endHeightOffset = clampWallEndHeightOffset(node.endHeightOffset, wallHeight);
+    const minWallHeight = Math.min(wallHeight, wallHeight + endHeightOffset);
+    const chairRailOffsetY = trim.offsetY ?? WALL_CHAIR_RAIL_DEFAULT.offsetY ?? 0.9;
+    const requiredWallHeight = kind === 'chairRail' ? chairRailOffsetY + height : height;
+    if (minWallHeight < requiredWallHeight - EPS) {
+        return null;
+    }
     const yBottom = kind === 'crown'
-        ? Math.max(0, wallHeight - height)
+        ? wallHeight - height
         : kind === 'chairRail'
-            ? Math.max(0, Math.min(wallHeight - height, trim.offsetY ?? WALL_CHAIR_RAIL_DEFAULT.offsetY ?? 0.9))
+            ? Math.max(0, Math.min(minWallHeight - height, chairRailOffsetY))
             : 0;
     const faceOffset = getWallLocalFaceZ(node, resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b') *
         resolveTreatmentSideSign(node, side);
@@ -441,6 +475,9 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
     if (inner.length < 2)
         return null;
     const wallLength = Math.hypot(node.end[0] - node.start[0], node.end[1] - node.start[1]);
+    if (wallLength < EPS)
+        return null;
+    const crownSlope = kind === 'crown' ? endHeightOffset / wallLength : 0;
     const support = kind === 'skirting' && node.parentId
         ? (levelData.supports?.get(node.id) ??
             spatialGridManager.getSlabSupportForWall(node.parentId, node.start, node.end, node.curveOffset ?? 0, node.thickness, node.supportSlabId, undefined, node.supportOffset, node.justification))
@@ -456,9 +493,13 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
     };
     const face = resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b';
     const faceScript = kind === 'skirting' ? node.finishScripts?.[face] : undefined;
+    const floorGaps = kind === 'skirting' ? skirtingFloorOpeningRanges(node, face, useScene.getState().nodes) : [];
     const runs = bases.flatMap((base) => {
         const bottom = support ? base.elevation - support.elevation : yBottom;
-        const openingRanges = trimOpeningRanges(node, childrenNodes, bottom, height);
+        const openingRanges = [
+            ...trimOpeningRanges(node, face, childrenNodes, bottom, height, crownSlope),
+            ...floorGaps,
+        ];
         if (support)
             for (const child of childrenNodes) {
                 for (const run of wallDoorStepRuns(node, child, support.faceDatum, support.elevation))
@@ -474,10 +515,12 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
             start,
             end,
             bottom,
-            slopeStart: stationX(base.start),
-            slope: base.endElevation === undefined
-                ? 0
-                : (base.endElevation - base.elevation) / (stationX(base.end) - stationX(base.start)),
+            slopeStart: kind === 'crown' ? 0 : stationX(base.start),
+            slope: kind === 'crown'
+                ? crownSlope
+                : base.endElevation === undefined
+                    ? 0
+                    : (base.endElevation - base.elevation) / (stationX(base.end) - stationX(base.start)),
         }));
     });
     if (runs.length === 0)

package/dist/window/actions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The window's action-menu contribution, in 2D and 3D, mirroring the door's: swap a casement's
+ * hinge side without opening the panel. One undo step; a closed window opens so the new side
+ * shows.
+ */
+export default function WindowActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/window/actions.tsx"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,uCAoBpC"}

package/dist/window/actions.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { ActionMenuButton } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { ArrowLeftRight } from 'lucide-react';
+import { applyOpeningSwap } from '../shared/opening-swap.js';
+import { windowMechanism } from './mechanism.js';
+import { canSwapWindowHinge, swapWindowHingePatch } from './swing.js';
+/**
+ * The window's action-menu contribution, in 2D and 3D, mirroring the door's: swap a casement's
+ * hinge side without opening the panel. One undo step; a closed window opens so the new side
+ * shows.
+ */
+export default function WindowActions() {
+    const i18n = usePascalI18n();
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const windowNode = useScene((s) => {
+        const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
+        return node?.type === 'window' ? node : undefined;
+    });
+    const readOnly = useScene((s) => s.readOnly);
+    if (!windowNode || readOnly || !canSwapWindowHinge(windowNode))
+        return null;
+    return (_jsx(ActionMenuButton, { label: i18n._({ id: 'node.window.actions.swapHingeSide', message: 'Swap hinge side' }), onClick: (event) => {
+            event.stopPropagation();
+            applyOpeningSwap(windowNode, swapWindowHingePatch(windowNode), windowMechanism);
+        }, children: _jsx(ArrowLeftRight, { className: "h-4 w-4" }) }));
+}

package/dist/window/definition.d.ts

@@ -1,16 +1,357 @@
-import type { AnyNodeId, NodeDefinition, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
-import { WindowNode } from './schema.js';
-export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
-/**
- * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
- * cuts holes in them, animated open/close state for opening windows.
- *
- * Stages:
- *  - A: registered.
- *  - B: deferred — window geometry ~800 lines; extraction is a focused
- *    session. `def.renderer` + `def.system` wrap-export legacy.
- *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
- *    `openingPolygons` short-circuits window entries when registered.
- */
-export declare const windowDefinition: NodeDefinition<typeof WindowNode>;
+export declare const windowDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    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>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    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<`window_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"window">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    source: 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>>;
+    }, import("zod/v4/core").$strip>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    side: import("zod").ZodOptional<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+    }>>;
+    verticalAnchor: import("zod").ZodOptional<import("zod").ZodEnum<{
+        floor: "floor";
+        wall: "wall";
+    }>>;
+    floorThresholdVersion: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>]>>;
+    wallId: import("zod").ZodOptional<import("zod").ZodString>;
+    dormerId: import("zod").ZodOptional<import("zod").ZodString>;
+    dormerFace: import("zod").ZodOptional<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+        left: "left";
+        right: "right";
+    }>>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    roofFace: import("zod").ZodOptional<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+        left: "left";
+        right: "right";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    mark: import("zod").ZodOptional<import("zod").ZodString>;
+    constructionType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        framed: "framed";
+        masonry: "masonry";
+    }>>;
+    dimensionReference: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "finish-opening": "finish-opening";
+        "masonry-opening": "masonry-opening";
+        nominal: "nominal";
+        "rough-opening": "rough-opening";
+    }>>;
+    roughOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    roughOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    masonryOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    masonryOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    finishOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    finishOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    openingKind: import("zod").ZodDefault<import("zod").ZodEnum<{
+        opening: "opening";
+        window: "window";
+    }>>;
+    windowType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        awning: "awning";
+        bay: "bay";
+        bow: "bow";
+        casement: "casement";
+        "double-hung": "double-hung";
+        fixed: "fixed";
+        hopper: "hopper";
+        louvered: "louvered";
+        "single-hung": "single-hung";
+        sliding: "sliding";
+        "tilt-turn": "tilt-turn";
+    }>>;
+    operationState: import("zod").ZodDefault<import("zod").ZodNumber>;
+    openingDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    tiltTurnMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+        tilt: "tilt";
+        turn: "turn";
+    }>>;
+    awningDirection: import("zod").ZodDefault<import("zod").ZodEnum<{
+        down: "down";
+        up: "up";
+    }>>;
+    casementStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        french: "french";
+        single: "single";
+    }>>;
+    hingesSide: import("zod").ZodDefault<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    openingShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        arch: "arch";
+        rectangle: "rectangle";
+        rounded: "rounded";
+    }>>;
+    openingRadiusMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingCornerRadii: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    cornerRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    archHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    openingRevealRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    windowHandle: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    sashGrid: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    columnRatios: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodNumber>>;
+    rowRatios: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodNumber>>;
+    columnDividerThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rowDividerThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    corner: import("zod").ZodOptional<import("zod").ZodObject<{
+        end: import("zod").ZodEnum<{
+            end: "end";
+            start: "start";
+        }>;
+        partnerId: import("zod").ZodString;
+        post: import("zod").ZodDefault<import("zod").ZodEnum<{
+            none: "none";
+            post: "post";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    sill: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    sillDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    sillThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    sillOverhang: import("zod").ZodOptional<import("zod").ZodNumber>;
+    sillInterior: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    sillInteriorDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    sillInteriorThickness: import("zod").ZodOptional<import("zod").ZodNumber>;
+    sillInteriorOverhang: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shutters: import("zod").ZodOptional<import("zod").ZodEnum<{
+        "board-batten": "board-batten";
+        louvered: "louvered";
+        none: "none";
+        panel: "panel";
+    }>>;
+    shutterWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shutterOpen: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shutterSides: import("zod").ZodOptional<import("zod").ZodEnum<{
+        both: "both";
+        left: "left";
+        right: "right";
+    }>>;
+    rollerShutter: import("zod").ZodOptional<import("zod").ZodEnum<{
+        box: "box";
+        concealed: "concealed";
+        none: "none";
+    }>>;
+    rollerShutterBoxHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    rollerShutterOpen: import("zod").ZodOptional<import("zod").ZodNumber>;
+    casingFaceA: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    casingFaceB: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    casingWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
+export { resolveWindowHandlePortalTarget } from './definition.render.js';
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAkCzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAOrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AAwMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgH9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG5B,CAAA;AACD,OAAO,EAAE,+BAA+B,EAAE,MAAM,qBAAqB,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/window/definition.edit.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAyBvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA+N1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAoD1E,CAAA"}