@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/wall/treatments.js

@@ -1,6 +1,6 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { 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 { 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';
@@ -348,9 +348,19 @@ function subtractOpeningRanges(ranges, openings) {
  * 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) {
+function trimOpeningRanges(node, face, childrenNodes, yBottom, height, slope = 0) {
     const yTop = yBottom + height;
-    const reaches = (bottom, top) => top > yBottom + EPS && bottom < yTop - EPS;
+    // 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')
@@ -359,17 +369,15 @@ function trimOpeningRanges(node, face, childrenNodes, yBottom, height) {
         const childHeight = child.height ?? 0;
         const position = child.position ?? [0, 0, 0];
         const childBottom = position[1] - childHeight / 2;
-        const ranges = [];
-        if (reaches(childBottom, childBottom + childHeight))
-            ranges.push([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 && reaches(y - board.size[1] / 2, y + board.size[1] / 2))
-                ranges.push([x - board.size[0] / 2, x + board.size[0] / 2]);
+            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;
     });
@@ -447,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);
@@ -460,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))
@@ -479,7 +497,7 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
     const runs = bases.flatMap((base) => {
         const bottom = support ? base.elevation - support.elevation : yBottom;
         const openingRanges = [
-            ...trimOpeningRanges(node, face, childrenNodes, bottom, height),
+            ...trimOpeningRanges(node, face, childrenNodes, bottom, height, crownSlope),
             ...floorGaps,
         ];
         if (support)
@@ -497,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/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;AAmCzB,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,CAwH9D,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;AAqBvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA+N1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAgD1E,CAAA"}