@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/door/swing.js

@@ -0,0 +1,36 @@
+const flip = (side) => (side === 'left' ? 'right' : 'left');
+/** Whether a door swings on hinges (the panel's Swing section), so its swing can be swapped. */
+export function canSwapDoorSwing(door) {
+    return (!door.source &&
+        door.openingKind !== 'opening' &&
+        (door.doorType === 'hinged' || door.doorType === 'double' || door.doorType === 'french'));
+}
+/** Whether a door has one hinge side to swap: a single hinged leaf. */
+export function canSwapDoorHinge(door) {
+    return canSwapDoorSwing(door) && door.doorType === 'hinged';
+}
+/** The leaf hung from `side`'s jamb, with its handle on the free edge opposite the hinges. */
+export function hingesSidePatch(side) {
+    return { hingesSide: side, handleSide: flip(side) };
+}
+/** The leaf hung from the other jamb: hinges and handle trade sides, so the handle stays on the free edge. */
+export function swapDoorHingePatch(door) {
+    return { hingesSide: flip(door.hingesSide), handleSide: flip(door.handleSide) };
+}
+/** The leaf swinging into the other side of the wall. */
+export function swapDoorSwingPatch(door) {
+    return { swingDirection: door.swingDirection === 'inward' ? 'outward' : 'inward' };
+}
+/**
+ * The swing that opens a door's leaf toward `side` of its wall: the face under the cursor while
+ * placing, so the door swings into the side it is placed from (R flips it to the other side). An
+ * inward door opens toward the face it is hung facing (`rotationY` 0 faces front, π back), so a
+ * door facing that side swings inward and one facing away swings outward. A garage door has no
+ * swing and keeps its own.
+ */
+export function placementSwing(door, rotationY, side) {
+    if (door.doorType?.startsWith('garage-'))
+        return door.swingDirection;
+    const facing = Math.cos(rotationY) >= 0 ? 'front' : 'back';
+    return facing === side ? 'inward' : 'outward';
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/door/tool.tsx"],"names":[],"mappings":"AAuEA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAsxBrB,CAAA;eAEc,QAAQ"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/door/tool.tsx"],"names":[],"mappings":"AAgFA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAo2BrB,CAAA;eAEc,QAAQ"}

package/dist/door/tool.js

@@ -1,5 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, DoorNode, emitter, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, DEFAULT_WALL_THICKNESS, DoorNode, doorPositionForFacing, emitter, getDoorOpeningSize, getWallThickness, holdHiddenWallPointerEvents, isCurvedWall, isRailingWall, openingHostFacing, railingOpeningFields, resolveOpeningFrameDepth, sceneRegistry, spatialGridManager, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
 import { placedDoorFace } from '@pascal-app/core/building';
 import { EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
@@ -13,6 +13,7 @@ import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } fro
 import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './door-math.js';
 import { placedDoorFields, useDoorPlacement } from './placement.js';
 import DoorPreview from './preview.js';
+import { placementSwing } from './swing.js';
 const edgeMaterial = new LineBasicNodeMaterial({
     color: 0xef_44_44,
     linewidth: 3,
@@ -55,10 +56,6 @@ const DoorTool = () => {
         rotation: [0, 0, 0],
         side: fallbackPose?.side ?? 'front',
     }), [fallbackPose?.side, placedType, placedStyle]);
-    // The frame depth is a fixed parse default (the `side` flip doesn't change
-    // it); a ref lets the facing-pose publish inside the setup effect read it
-    // without re-subscribing every event listener.
-    const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
         // The draft is a created carry draft: undo history and every save leave it out
@@ -169,7 +166,7 @@ const DoorTool = () => {
         // On-host cursor: the green/red wireframe outline tracks a live draft.
         // Showing it always clears the off-host floating ghost (they never
         // coexist — a draft means the cursor is on a valid host).
-        const updateCursor = (worldPosition, cursorRotationY, valid, indicatorYOffset) => {
+        const updateCursor = (worldPosition, cursorRotationY, valid, indicatorYOffset, hostThickness) => {
             setFallbackPose(null);
             const group = cursorGroupRef.current;
             if (!group)
@@ -184,7 +181,7 @@ const DoorTool = () => {
             useFacingPose.getState().set({
                 position: [worldPosition[0], worldPosition[1] + indicatorYOffset, worldPosition[2]],
                 rotationY: cursorRotationY,
-                depth: frameDepthRef.current,
+                depth: resolveOpeningFrameDepth({ frameDepth: draftRef.current?.frameDepth }, hostThickness),
             });
         };
         // Off-host fallback: hide the wireframe outline and float the real door
@@ -231,28 +228,47 @@ const DoorTool = () => {
             showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2, z]);
         };
         // Settle a wall target: alignment snap → clamp → overlap check. Pure read.
-        const resolveWallPlacement = (wall, rawLocalX, width, height, applySnap, ignoreId) => {
+        const resolveWallPlacement = (wall, rawLocalX, width, height, applySnap, ignoreId, rotationY = 0) => {
             // Along-wall alignment guides are DISPLAYED in every snapping mode; the
             // magnetic pull onto them is applied only when `applySnap` (magnetic
             // "lines" mode). The grid component lives in `snapToHalf`, which is itself
             // mode-aware (raw cursor when grid is off).
+            const draft = draftRef.current;
+            const size = getDoorOpeningSize({ ...draft, width, height });
+            const offset = size.leafOffsetX * openingHostFacing({ rotation: [0, rotationY, 0] });
+            const facingX = doorPositionForFacing({
+                ...draft,
+                width,
+                height,
+                rotation: [0, 0, 0],
+                position: [rawLocalX + size.leafOffsetX, height / 2, 0],
+            }, [0, rotationY, 0])[0];
             const localX = resolveWallSlideAlignment({
                 wallNode: wall,
-                rawLocalX,
-                width,
+                rawLocalX: facingX - offset,
+                width: size.width,
                 candidates: alignmentCandidates,
                 applySnap,
             });
-            const { clampedX, clampedY } = clampToWall(wall, localX, width, height);
-            const valid = !hasWallChildOverlap(wall.id, useScene.getState().nodes, clampedX, clampedY, width, height, ignoreId);
-            return { clampedX, clampedY, valid };
+            const cut = clampToWall(wall, localX + offset, width, height, { ...draft, rotation: [0, rotationY, 0] }, useScene.getState().nodes);
+            const fittedSize = getDoorOpeningSize({
+                ...draft,
+                width,
+                height,
+                transomHeight: cut.transomHeight ?? draft?.transomHeight,
+            });
+            const clampedX = cut.clampedX;
+            const clampedY = cut.clampedY;
+            const valid = cut.fits &&
+                !hasWallChildOverlap(wall.id, useScene.getState().nodes, cut.clampedX - offset, cut.clampedY + (fittedSize.height - height) / 2, fittedSize.width, fittedSize.height, ignoreId);
+            return { clampedX, clampedY, valid, transomHeight: cut.transomHeight };
         };
         // Shared create/update path for the wall draft — used by the direct
         // wall-mesh hover and the floor proximity snap. Reuses the existing draft
         // (reparenting only on an actual wall change to avoid churning the host's
         // children array, which flashes 0-vertex wall geometry in WebGPU).
         const applyWallTarget = (args) => {
-            const { wall, rawLocalX, side, itemRotation, cursorRotationY, applySnap } = args;
+            const { wall, rawLocalX, side, itemRotation, swingSide, cursorRotationY, applySnap } = args;
             const placed = placedDoorFields();
             const width = draftRef.current?.width ?? placed.width ?? 0.9;
             const height = draftRef.current?.height ?? placed.height ?? 2.1;
@@ -269,20 +285,26 @@ const DoorTool = () => {
                 createDraft(node, wall.id);
                 draftRef.current = node;
             }
-            const { clampedX, clampedY, valid } = resolveWallPlacement(wall, rawLocalX, width, height, applySnap, draftRef.current.id);
+            const { clampedX, clampedY, valid, transomHeight } = resolveWallPlacement(wall, rawLocalX, width, height, applySnap, draftRef.current.id, itemRotation);
+            // The leaf swings into the side the cursor is on (R sends it to the other side).
+            const swingDirection = placementSwing(draftRef.current, itemRotation, swingSide);
             if (wall.id === draftRef.current.parentId) {
                 useScene.getState().updateNode(draftRef.current.id, {
                     position: [clampedX, clampedY, 0],
+                    ...(transomHeight === undefined ? {} : { transomHeight }),
                     rotation: [0, itemRotation, 0],
                     side,
+                    swingDirection,
                 });
                 markHostDirty(wall.id);
             }
             else {
                 useScene.getState().updateNode(draftRef.current.id, {
                     position: [clampedX, clampedY, 0],
+                    ...(transomHeight === undefined ? {} : { transomHeight }),
                     rotation: [0, itemRotation, 0],
                     side,
+                    swingDirection,
                     parentId: wall.id,
                     wallId: wall.id,
                     // The draft may arrive from a roof-segment face hover.
@@ -291,7 +313,7 @@ const DoorTool = () => {
                 });
             }
             publishDraftPreview(wall);
-            updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
+            updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -height / 2, getWallThickness(wall));
             if (draftRef.current) {
                 publishOpeningGuidesForWallEvent({
                     wall,
@@ -309,7 +331,7 @@ const DoorTool = () => {
         };
         // Promote the draft into a permanent door. Shared by the wall-mesh click
         // and the floor proximity click.
-        const commitDoorAtWall = (wall, clampedX, clampedY, side, itemRotation) => {
+        const commitDoorAtWall = (wall, clampedX, clampedY, side, itemRotation, swingSide) => {
             const draft = draftRef.current;
             if (!draft)
                 return;
@@ -326,15 +348,25 @@ const DoorTool = () => {
                 const w = n.parentId ? state.nodes[n.parentId] : undefined;
                 return w?.parentId === levelId;
             }).length;
+            // On a railing the door becomes a gap in the guard, as tall as the guard.
+            const railingGap = isRailingWall(wall) ? railingOpeningFields(wall) : null;
             const node = DoorNode.parse({
-                name: `Door ${doorCount + 1}`,
-                position: [clampedX, clampedY, 0],
+                name: `${railingGap ? 'Opening' : 'Door'} ${doorCount + 1}`,
+                position: [
+                    clampedX,
+                    railingGap ? clampedY + (railingGap.height - draft.height) / 2 : clampedY,
+                    0,
+                ],
                 rotation: [0, itemRotation, 0],
                 side,
                 wallId: wall.id,
                 parentId: wall.id,
                 width: draft.width,
                 height: draft.height,
+                sidelightLeft: draft.sidelightLeft,
+                sidelightRight: draft.sidelightRight,
+                transomHeight: draft.transomHeight,
+                slidingStyle: draft.slidingStyle,
                 doorCategory: draft.doorCategory,
                 doorType: draft.doorType,
                 leafCount: draft.leafCount,
@@ -342,12 +374,14 @@ const DoorTool = () => {
                 slideDirection: draft.slideDirection,
                 trackStyle: draft.trackStyle,
                 garagePanelCount: draft.garagePanelCount,
+                casingFaceA: draft.casingFaceA,
+                casingFaceB: draft.casingFaceB,
+                casingWidth: draft.casingWidth,
                 frameThickness: draft.frameThickness,
-                frameDepth: draft.frameDepth,
                 threshold: draft.threshold,
                 thresholdHeight: draft.thresholdHeight,
                 hingesSide: draft.hingesSide,
-                swingDirection: draft.swingDirection,
+                swingDirection: placementSwing(draft, itemRotation, swingSide),
                 segments: draft.segments,
                 contentPadding: draft.contentPadding,
                 handle: draft.handle,
@@ -356,6 +390,7 @@ const DoorTool = () => {
                 doorCloser: draft.doorCloser,
                 panicBar: draft.panicBar,
                 panicBarHeight: draft.panicBarHeight,
+                ...railingGap,
             });
             useScene.getState().createNode(node, wall.id);
             useViewer.getState().setSelection({ selectedIds: [node.id] });
@@ -383,8 +418,11 @@ const DoorTool = () => {
                 return;
             }
             lastWallEvent = event;
-            // An outside wall's door faces out whichever face is hovered, as add_door places it.
-            const faceSide = placedDoorFace(event.node, getSideFromNormal(event.normal));
+            // An outside wall's door faces out whichever face is hovered, as add_door places it; the
+            // leaf still swings into the hovered side (R flips facing and swing together).
+            const hovered = getSideFromNormal(event.normal);
+            const swingSide = sideFlip ? (hovered === 'front' ? 'back' : 'front') : hovered;
+            const faceSide = placedDoorFace(event.node, hovered);
             const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
             const flipOffset = sideFlip ? Math.PI : 0;
             const itemRotation = (faceSide === 'back' ? Math.PI : 0) + flipOffset;
@@ -400,6 +438,7 @@ const DoorTool = () => {
                 rawLocalX: event.localPosition[0],
                 side,
                 itemRotation,
+                swingSide,
                 cursorRotationY: cursorRotation,
                 applySnap: isMagneticSnapActive(),
             });
@@ -413,14 +452,16 @@ const DoorTool = () => {
                 event.node.parentId !== getLevelId()) {
                 return;
             }
-            const faceSide = placedDoorFace(event.node, getSideFromNormal(event.normal));
+            const hovered = getSideFromNormal(event.normal);
+            const swingSide = sideFlip ? (hovered === 'front' ? 'back' : 'front') : hovered;
+            const faceSide = placedDoorFace(event.node, hovered);
             const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
             const itemRotation = (faceSide === 'back' ? Math.PI : 0) + (sideFlip ? Math.PI : 0);
-            const { clampedX, clampedY, valid } = resolveWallPlacement(event.node, event.localPosition[0], draftRef.current.width, draftRef.current.height, isMagneticSnapActive(), draftRef.current.id);
+            const { clampedX, clampedY, valid } = resolveWallPlacement(event.node, event.localPosition[0], draftRef.current.width, draftRef.current.height, isMagneticSnapActive(), draftRef.current.id, itemRotation);
             // Alt force-places over a collision (the draft stays red as a warning).
             if (!valid && event.nativeEvent?.altKey !== true)
                 return;
-            commitDoorAtWall(event.node, clampedX, clampedY, side, itemRotation);
+            commitDoorAtWall(event.node, clampedX, clampedY, side, itemRotation, swingSide);
             event.stopPropagation();
         };
         // XR runtimes deliver selectend as a grid click, but do not replay the
@@ -476,12 +517,13 @@ const DoorTool = () => {
             width: draftRef.current?.width ?? 0.9,
             height: draftRef.current?.height ?? 2.1,
             ignoreId: draftRef.current?.id,
+            opening: draftRef.current ?? undefined,
             vertical: { kind: 'bottom-locked' },
         });
         const updateRoofCursor = (target, roof) => {
             const pose = getRoofWallOpeningCursorPose(target, roof);
             if (pose)
-                updateCursor(pose.position, pose.rotationY, target.valid, -target.position[1]);
+                updateCursor(pose.position, pose.rotationY, target.valid, -target.position[1], DEFAULT_WALL_THICKNESS);
         };
         const onRoofHover = (event) => {
             hostKind = 'roof';
@@ -552,6 +594,10 @@ const DoorTool = () => {
                 parentId: segment.id,
                 width: draft.width,
                 height: draft.height,
+                sidelightLeft: draft.sidelightLeft,
+                sidelightRight: draft.sidelightRight,
+                transomHeight: draft.transomHeight,
+                slidingStyle: draft.slidingStyle,
                 doorCategory: draft.doorCategory,
                 doorType: draft.doorType,
                 leafCount: draft.leafCount,
@@ -559,8 +605,10 @@ const DoorTool = () => {
                 slideDirection: draft.slideDirection,
                 trackStyle: draft.trackStyle,
                 garagePanelCount: draft.garagePanelCount,
+                casingFaceA: draft.casingFaceA,
+                casingFaceB: draft.casingFaceB,
+                casingWidth: draft.casingWidth,
                 frameThickness: draft.frameThickness,
-                frameDepth: draft.frameDepth,
                 threshold: draft.threshold,
                 thresholdHeight: draft.thresholdHeight,
                 hingesSide: draft.hingesSide,
@@ -702,7 +750,7 @@ const DoorTool = () => {
     // unmount rather than reallocating (and orphaning) an EdgesGeometry on every
     // re-render during placement.
     const edgesGeo = useMemo(() => {
-        const boxGeo = new BoxGeometry(FALLBACK_WIDTH, FALLBACK_HEIGHT, 0.07);
+        const boxGeo = new BoxGeometry(FALLBACK_WIDTH, FALLBACK_HEIGHT, resolveOpeningFrameDepth({}, DEFAULT_WALL_THICKNESS));
         const geo = new EdgesGeometry(boxGeo);
         boxGeo.dispose();
         return geo;

package/dist/dormer/definition.d.ts

@@ -1,12 +1,241 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { DormerNode } from './schema.js';
-/**
- * Dormer — a small house-shaped protrusion sitting on top of a roof
- * segment. Windows are hosted child nodes; the legacy window* fields remain
- * in the schema only so scene migration can preserve older dormers.
- *
- * The renderer cuts each hosted window from the dormer shell and mounts
- * the regular WindowNode renderer in the selected wall-face frame.
- */
-export declare const dormerDefinition: NodeDefinition<typeof DormerNode>;
+export declare const dormerDefinition: 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<`dormer_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"dormer">>;
+    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>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    topMaterial: 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>>;
+    topMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    sideMaterial: 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>>;
+    sideMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    wallMaterial: 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>>;
+    wallMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    roofType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        barrel: "barrel";
+        conical: "conical";
+        dutch: "dutch";
+        flat: "flat";
+        gable: "gable";
+        gambrel: "gambrel";
+        hip: "hip";
+        mansard: "mansard";
+        shed: "shed";
+    }>>;
+    roofHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shedHighSide: import("zod").ZodDefault<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+    }>>;
+    wallSkirtHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowOffsetX: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowOffsetY: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowFrameThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowFrameDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowColumns: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowRows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowDividerThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        arch: "arch";
+        rectangle: "rectangle";
+        rounded: "rounded";
+    }>>;
+    windowArchHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowCornerRadii: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    windowSill: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    windowSillDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    windowSillThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`window_${string}`>>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAqPrC;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgF9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG5B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAuM1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAyB1E,CAAA"}