@pascal-app/core 1.0.6 → 1.1.0

package/dist/building/wall-openings.d.ts

@@ -1,21 +1,34 @@
-import { type AnyNode, type AnyNodeId, type CompiledGeometryScript, type GeometryScriptParamValue, type WallNode } from '../schema/index.js';
+import { type AnyNode, type AnyNodeId, type CompiledGeometryScript, DoorNode, type GeometryScriptParamValue, type WallNode, WindowNode } from '../schema/index.js';
 import type { DoorType, WindowType } from '../schema/nodes/opening-types.js';
 type Nodes = Readonly<Record<string, AnyNode>>;
 /**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's resolved top (storey
- * plane for plane-bound walls, stored height for explicit ones) minus the wall's elected slab
- * base, the ceiling an opening's top edge must stay under.
+ * Available wall-local Y span for an opening hosted on `wall` at chord fraction `t` (0 start,
+ * 1 end; see `getWallChordFractionAt`): the wall's resolved top (storey plane for plane-bound walls, stored height for explicit
+ * ones, sloped by `endHeightOffset`) minus the wall's elected slab base, the ceiling an opening's
+ * top edge must stay under.
  */
-export declare function resolveWallOpeningCeiling(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): number;
-/** A door's centre: slid along the wall to stay on it, standing on the floor. */
-export declare function clampDoorToWall(wall: WallNode, localX: number, width: number, height: number): {
+export declare function resolveWallOpeningCeiling(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, t: number): number;
+/** The lowest opening ceiling over arc-length stations `[left, right]` (see `getWallTopOver`). */
+export declare function wallOpeningCeilingOver(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, left: number, right: number): number;
+/**
+ * A door's centre: slid along the wall to stay on it, standing on the floor, and under a sloped
+ * top. `fits` is false when no position along the wall clears the door.
+ */
+export declare function clampDoorToWall(wall: WallNode, localX: number, width: number, height: number, door?: Partial<DoorNode>, nodes?: Readonly<Record<AnyNodeId, AnyNode>>): {
     clampedX: number;
     clampedY: number;
+    fits: boolean;
+    transomHeight?: number;
 };
-/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+/**
+ * A window's centre: slid to stay on the wall, and between the wall's bottom and its ceiling. The
+ * bottom is the floor, or lower where the wall fills down beside a sunken floor (a garage). Under
+ * a sloped top the window slides to where its span clears; `fits` is false when nowhere does.
+ */
 export declare function clampWindowToWall(wall: WallNode, localX: number, localY: number, width: number, height: number, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
     clampedX: number;
     clampedY: number;
+    fits: boolean;
 };
 /**
  * The first child of the wall (door, window, or wall-mounted item) that a rectangle centred on
@@ -36,8 +49,15 @@ export type WallOpeningInput = {
     position?: number;
     width?: number;
     height?: number;
+    sidelightLeft?: number;
+    sidelightRight?: number;
+    transomHeight?: number;
+    leafCount?: DoorNode['leafCount'];
+    slidingStyle?: DoorNode['slidingStyle'];
+    slideDirection?: DoorNode['slideDirection'];
     sillHeight?: number;
     hingesSide?: 'left' | 'right';
+    handleStyle?: DoorNode['handleStyle'];
     /** Defaults to the side opposite the hinges. */
     handleSide?: 'left' | 'right';
     swingDirection?: 'inward' | 'outward';
@@ -52,6 +72,22 @@ export type WallOpeningInput = {
     windowType?: WindowType;
     columns?: number;
     rows?: number;
+    windowHandle?: boolean;
+    sashGrid?: boolean;
+    sillInterior?: boolean;
+    shutters?: WindowNode['shutters'];
+    shutterWidth?: number;
+    openingDirection?: WindowNode['openingDirection'];
+    tiltTurnMode?: WindowNode['tiltTurnMode'];
+    sillOverhang?: WindowNode['sillOverhang'];
+    sillInteriorDepth?: WindowNode['sillInteriorDepth'];
+    sillInteriorThickness?: WindowNode['sillInteriorThickness'];
+    sillInteriorOverhang?: WindowNode['sillInteriorOverhang'];
+    shutterOpen?: WindowNode['shutterOpen'];
+    shutterSides?: WindowNode['shutterSides'];
+    rollerShutter?: WindowNode['rollerShutter'];
+    rollerShutterBoxHeight?: WindowNode['rollerShutterBoxHeight'];
+    rollerShutterOpen?: WindowNode['rollerShutterOpen'];
     /** A compiled script the opening is built from; its bounds set width and height. */
     compiled?: CompiledGeometryScript;
     code?: string;
@@ -62,6 +98,11 @@ export declare const DEFAULT_WINDOW: {
     readonly width: 1.5;
     readonly height: 1.5;
 };
+/**
+ * Refuses an opening that no stretch of a sloped wall can take under its top, which the wall
+ * clamps report as `fits: false`. The editor refuses the same placement; a flat wall always fits.
+ */
+export declare function refuseOpeningAboveSlope(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, kind: 'door' | 'window', width: number, height: number): never;
 /**
  * The sill that centres a window of `height` vertically on the lowest of `walls`, or 0 when it is
  * taller than they are. What a window with no sill given takes, on every agent surface.
@@ -133,6 +174,11 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         slots?: Record<string, string> | undefined;
@@ -198,6 +244,16 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -216,6 +272,17 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -251,8 +318,10 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         finishOpeningWidth?: number | undefined;
         finishOpeningHeight?: number | undefined;
         openingKind: "opening" | "window";
-        windowType: "awning" | "bay" | "bow" | "casement" | "double-hung" | "fixed" | "hopper" | "louvered" | "single-hung" | "sliding";
+        windowType: "awning" | "bay" | "bow" | "casement" | "double-hung" | "fixed" | "hopper" | "louvered" | "single-hung" | "sliding" | "tilt-turn";
         operationState: number;
+        openingDirection?: "inward" | "outward" | undefined;
+        tiltTurnMode?: "tilt" | "turn" | undefined;
         awningDirection: "down" | "up";
         casementStyle: "french" | "single";
         hingesSide: "left" | "right";
@@ -263,7 +332,9 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         archHeight: number;
         openingRevealRadius: number;
         frameThickness: number;
-        frameDepth: number;
+        frameDepth?: number | undefined;
+        windowHandle?: boolean | undefined;
+        sashGrid?: boolean | undefined;
         columnRatios: number[];
         rowRatios: number[];
         columnDividerThickness: number;
@@ -276,6 +347,21 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         sill: boolean;
         sillDepth: number;
         sillThickness: number;
+        sillOverhang?: number | undefined;
+        sillInterior?: boolean | undefined;
+        sillInteriorDepth?: number | undefined;
+        sillInteriorThickness?: number | undefined;
+        sillInteriorOverhang?: number | undefined;
+        shutters?: "board-batten" | "louvered" | "none" | "panel" | undefined;
+        shutterWidth?: number | undefined;
+        shutterOpen?: number | undefined;
+        shutterSides?: "both" | "left" | "right" | undefined;
+        rollerShutter?: "box" | "concealed" | "none" | undefined;
+        rollerShutterBoxHeight?: number | undefined;
+        rollerShutterOpen?: number | undefined;
+        casingFaceA?: boolean | undefined;
+        casingFaceB?: boolean | undefined;
+        casingWidth?: number | undefined;
     } | {
         object: "node";
         name?: string | undefined;
@@ -317,6 +403,11 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         slots?: Record<string, string> | undefined;
@@ -382,6 +473,16 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -400,6 +501,17 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -423,6 +535,10 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         roofFace?: "back" | "front" | "left" | "right" | undefined;
         width: number;
         height: number;
+        sidelightLeft?: number | undefined;
+        sidelightRight?: number | undefined;
+        transomHeight?: number | undefined;
+        slidingStyle?: "bypass" | "patio" | undefined;
         mark?: string | undefined;
         constructionType: "framed" | "masonry";
         dimensionReference: "finish-opening" | "masonry-opening" | "nominal" | "rough-opening";
@@ -434,7 +550,7 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         finishOpeningHeight?: number | undefined;
         doorCategory: "garage" | "interior";
         doorType: "barn" | "double" | "folding" | "french" | "garage-rollup" | "garage-sectional" | "garage-tiltup" | "hinged" | "pocket" | "sliding";
-        leafCount: 1 | 2 | 3 | 4;
+        leafCount: 1 | 2 | 3 | 4 | 6 | 8;
         operationState: number;
         slideDirection: "left" | "right";
         trackStyle: "none" | "overhead" | "pocket" | "visible";
@@ -447,9 +563,12 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
         archHeight: number;
         openingRevealRadius: number;
         frameThickness: number;
-        frameDepth: number;
+        frameDepth?: number | undefined;
         threshold: boolean;
         thresholdHeight: number;
+        casingFaceA?: boolean | undefined;
+        casingFaceB?: boolean | undefined;
+        casingWidth?: number | undefined;
         hingesSide: "left" | "right";
         swingDirection: "inward" | "outward";
         swingAngle: number;
@@ -462,11 +581,14 @@ export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput):
             panelInset: number;
         }[];
         handle: boolean;
+        handleStyle?: "bar" | "knob" | "lever" | "lever-curved" | "plate" | undefined;
         handleHeight: number;
         handleSide: "left" | "right";
         contentPadding: [number, number];
         doorCloser: boolean;
         panicBar: boolean;
+        panicBarStyle: "crossbar" | "touchbar";
+        panicBarRods: boolean;
         panicBarHeight: number;
     };
     wallId: string;

package/dist/building/wall-openings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/building/wall-openings.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/building/wall-openings.ts"],"names":[],"mappings":"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"}

package/dist/building/wall-openings.js

@@ -1,44 +1,102 @@
 import { refuseParamsWithoutScript } from '../agent-operations/add-object.js';
 import { refuse } from '../agent-tools/refusal.js';
+import { doorPositionForFacing, getDoorOpeningSize } from '../lib/door-opening.js';
 import { matchScriptSlotsToLibrary, requireMeasured, scriptedSize, scriptSource, } from '../lib/geometry-script-node.js';
-import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { openingHostFacing } from '../lib/opening-casing.js';
+import { wallBottomUnderOpening, wallSupportForNodes } from '../lib/opening-floor-datum.js';
 import { DoorNode, getScaledDimensions, WindowNode, } from '../schema/index.js';
 import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
-import { getWallTop } from '../services/storey.js';
+import { isRailingWall, railingOpeningFields } from '../schema/nodes/railing-wall.js';
+import { getWallTop, getWallTopOver } from '../services/storey.js';
 import { resolveWallExteriorSide } from '../systems/wall/wall-assembly.js';
-import { getWallCurveLength, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { getWallCurveLength, getWallStationAtChordFraction, isCurvedWall, } from '../systems/wall/wall-curve.js';
+import { doorTypeFields, NEW_DOOR_FRAME_THICKNESS } from './door-types.js';
 import { doorStyleLook, getWindowStyleOverrides, } from './opening-style-presets.js';
-import { windowTakesStyle } from './window-types.js';
+import { NEW_WINDOW_FRAME_THICKNESS, windowTakesStyle, windowTypeFields } from './window-types.js';
 /** 1 µm: below any buildable difference, above floating-point noise. */
 const TOUCHING = 1e-6;
 const lengthOf = (wall) => Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 /**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's resolved top (storey
- * plane for plane-bound walls, stored height for explicit ones) minus the wall's elected slab
- * base, the ceiling an opening's top edge must stay under.
+ * Available wall-local Y span for an opening hosted on `wall` at chord fraction `t` (0 start,
+ * 1 end; see `getWallChordFractionAt`): the wall's resolved top (storey plane for plane-bound walls, stored height for explicit
+ * ones, sloped by `endHeightOffset`) minus the wall's elected slab base, the ceiling an opening's
+ * top edge must stay under.
  */
-export function resolveWallOpeningCeiling(wall, nodes) {
+export function resolveWallOpeningCeiling(wall, nodes, t) {
     const support = wallSupportForNodes(wall, nodes);
-    return (getWallTop(wall, wall.parentId ?? '', nodes, support.elevation) -
+    return (getWallTop(wall, wall.parentId ?? '', nodes, support.elevation, t) -
         support.elevation);
 }
+/** The lowest opening ceiling over arc-length stations `[left, right]` (see `getWallTopOver`). */
+export function wallOpeningCeilingOver(wall, nodes, left, right) {
+    const support = wallSupportForNodes(wall, nodes);
+    return (getWallTopOver(wall, wall.parentId ?? '', nodes, support.elevation, left, right) - support.elevation);
+}
+/**
+ * The centres in `[min, max]` where a span `width` wide stays under a sloped top at `need`, or
+ * null when there are none. A flat top keeps the whole range: there the editor clamps and the
+ * agent path refuses an opening that is too tall, exactly as before tops could slope.
+ */
+function centresUnderCeiling(wall, nodes, width, need, min, max) {
+    const start = resolveWallOpeningCeiling(wall, nodes, 0);
+    const rise = resolveWallOpeningCeiling(wall, nodes, 1) - start;
+    if (Math.abs(rise) < 1e-6)
+        return [min, max];
+    if (min > max)
+        return null;
+    // The top is linear along the chord: past this station it is lower than `need`.
+    const limit = getWallStationAtChordFraction(wall, (need - start) / rise);
+    const lo = rise > 0 ? Math.max(min, limit + width / 2) : min;
+    const hi = rise > 0 ? max : Math.min(max, limit - width / 2);
+    return lo > hi + 1e-4 ? null : [lo, Math.max(lo, hi)];
+}
 /** A curtain wall keeps its perimeter frame clear of openings. */
 const openingMargin = (wall) => wall.wallType === 'curtain' ? getCurtainWallConfig(wall).perimeterWidth : 0;
-/** A door's centre: slid along the wall to stay on it, standing on the floor. */
-export function clampDoorToWall(wall, localX, width, height) {
+/**
+ * A door's centre: slid along the wall to stay on it, standing on the floor, and under a sloped
+ * top. `fits` is false when no position along the wall clears the door.
+ */
+export function clampDoorToWall(wall, localX, width, height, door, nodes = {}) {
     const margin = openingMargin(wall);
     const length = getWallCurveLength(wall);
-    const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
-    return { clampedX, clampedY: height / 2 };
+    const size = getDoorOpeningSize({ ...door, width, height });
+    const offset = size.leafOffsetX * openingHostFacing(door ?? {});
+    const min = margin + size.width / 2;
+    const max = length - margin - size.width / 2;
+    const fit = centresUnderCeiling(wall, nodes, size.width, height + margin, min, max);
+    const [lo, hi] = fit ?? [min, max];
+    const centre = Math.max(lo, Math.min(hi, localX - offset));
+    const transomHeight = door?.transomHeight !== undefined && size.height > height
+        ? Math.min(door.transomHeight, Math.max(0, wallOpeningCeilingOver(wall, nodes, centre - size.width / 2, centre + size.width / 2) -
+            margin -
+            height))
+        : undefined;
+    return {
+        clampedX: centre + offset,
+        clampedY: height / 2,
+        fits: fit !== null,
+        ...(transomHeight === undefined ? {} : { transomHeight }),
+    };
 }
-/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+/**
+ * A window's centre: slid to stay on the wall, and between the wall's bottom and its ceiling. The
+ * bottom is the floor, or lower where the wall fills down beside a sunken floor (a garage). Under
+ * a sloped top the window slides to where its span clears; `fits` is false when nowhere does.
+ */
 export function clampWindowToWall(wall, localX, localY, width, height, nodes) {
-    const ceiling = resolveWallOpeningCeiling(wall, nodes);
     const margin = openingMargin(wall);
     const length = getWallCurveLength(wall);
-    const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
-    const clampedY = Math.max(margin + height / 2, Math.min(ceiling - margin - height / 2, localY));
-    return { clampedX, clampedY };
+    const min = margin + width / 2;
+    const max = length - margin - width / 2;
+    const fit = centresUnderCeiling(wall, nodes, width, height + 2 * margin, min, max);
+    const [lo, hi] = fit ?? [min, max];
+    const clampedX = Math.max(lo, Math.min(hi, localX));
+    const ceiling = wallOpeningCeilingOver(wall, nodes, clampedX - width / 2, clampedX + width / 2);
+    const support = wallSupportForNodes(wall, nodes);
+    const floor = Math.min(0, wallBottomUnderOpening(wall, { position: [clampedX, 0, 0], width }, support) -
+        support.elevation);
+    const clampedY = Math.max(floor + margin + height / 2, Math.min(ceiling - margin - height / 2, localY));
+    return { clampedX, clampedY, fits: fit !== null };
 }
 /**
  * The first child of the wall (door, window, or wall-mounted item) that a rectangle centred on
@@ -74,11 +132,12 @@ export function findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, h
             childTop = item.position[1] + h;
         }
         else if (child.type === 'window' || child.type === 'door') {
-            const opening = child;
-            childLeft = opening.position[0] - opening.width / 2;
-            childRight = opening.position[0] + opening.width / 2;
-            childBottom = opening.position[1] - opening.height / 2;
-            childTop = opening.position[1] + opening.height / 2;
+            const size = child.type === 'door' ? getDoorOpeningSize(child) : { ...child, leafOffsetX: 0 };
+            const centerX = child.position[0] - size.leafOffsetX * openingHostFacing(child);
+            childLeft = centerX - size.width / 2;
+            childRight = centerX + size.width / 2;
+            childBottom = child.position[1] - child.height / 2;
+            childTop = childBottom + size.height;
         }
         else {
             continue;
@@ -106,12 +165,20 @@ const DEFAULTS = {
     window: DEFAULT_WINDOW,
 };
 const metres = (value) => `${value.toFixed(2)} m`;
+/**
+ * Refuses an opening that no stretch of a sloped wall can take under its top, which the wall
+ * clamps report as `fits: false`. The editor refuses the same placement; a flat wall always fits.
+ */
+export function refuseOpeningAboveSlope(wall, nodes, kind, width, height) {
+    const wallHeight = Math.max(resolveWallOpeningCeiling(wall, nodes, 0), resolveWallOpeningCeiling(wall, nodes, 1));
+    refuse('wall_too_low', `Wall ${wall.id} slopes to at most ${metres(wallHeight)}, and nowhere along it does a ${metres(width)} wide, ${metres(height)} tall ${kind} fit under its top. Use a smaller ${kind}, or raise the wall's low end.`, { wallId: wall.id, wallHeight, height });
+}
 /**
  * The sill that centres a window of `height` vertically on the lowest of `walls`, or 0 when it is
  * taller than they are. What a window with no sill given takes, on every agent surface.
  */
 export function centredWindowSill(walls, height, nodes) {
-    const ceiling = Math.min(...walls.map((wall) => resolveWallOpeningCeiling(wall, nodes)));
+    const ceiling = Math.min(...walls.map((wall) => wallOpeningCeilingOver(wall, nodes, 0, getWallCurveLength(wall))));
     return Math.max(0, (ceiling - height) / 2);
 }
 /**
@@ -161,6 +228,10 @@ export function planWallOpening(nodes, input) {
     const wall = host;
     if (isCurvedWall(wall))
         refuse('curved_wall', `Wall ${wallId} is curved; doors and windows go on straight walls, as in the editor.`, { wallId });
+    // A railing's openings are gaps in its guard: a door becomes one, a window has none to fill.
+    if (kind === 'window' && isRailingWall(wall))
+        refuse('railing_window', `Wall ${wallId} is a railing: it takes a door, which becomes a gap in the guard, not a window.`, { wallId });
+    const railingGap = kind === 'door' && isRailingWall(wall) ? railingOpeningFields(wall) : null;
     const { t, position } = input;
     if (t !== undefined && position !== undefined && Math.abs(t - position) > 1e-9)
         refuse('conflicting_position', `t (${t}) and position (${position}) disagree; they are the same field, pass one.`, { t, position });
@@ -179,23 +250,44 @@ export function planWallOpening(nodes, input) {
         requireMeasured(compiled, { label: `A ${kind}`, tool: `add_${kind}` });
     const [scriptedWidth, scriptedHeight] = compiled ? scriptedSize(compiled.manifest) : [];
     const width = scriptedWidth ?? input.width ?? DEFAULTS[kind].width;
-    const height = scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const height = railingGap?.height ?? scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const size = kind === 'door'
+        ? getDoorOpeningSize({
+            ...input,
+            ...(railingGap ? { openingKind: 'opening' } : {}),
+            width,
+            height,
+            ...(compiled ? { source: scriptSource(compiled, input) } : {}),
+        })
+        : { width, height, leafOffsetX: 0 };
     const wallLength = lengthOf(wall);
-    if (wallLength < width)
+    if (wallLength < size.width)
         refuse('wall_too_short', `Wall ${wallId} is ${metres(wallLength)} long, too short for a ${metres(width)} ${kind}.`, { wallId, wallLength, width });
     const rawX = along * wallLength;
     // A window with no sill given is centred on its wall, taller than the wall or not: the clamp
-    // below stands one that is too tall on the floor and reports it clamped.
-    const rawY = kind === 'door'
-        ? height / 2
-        : input.sillHeight === undefined
-            ? resolveWallOpeningCeiling(wall, nodes) / 2
-            : input.sillHeight + height / 2;
-    const { clampedX, clampedY } = kind === 'door'
-        ? clampDoorToWall(wall, rawX, width, height)
-        : clampWindowToWall(wall, rawX, rawY, width, height, nodes);
+    // below stands one that is too tall on the floor and reports it clamped. A door stands on the
+    // floor unless given a sill (rare: down to a floor sunk beside the wall); with one it keeps
+    // between the wall's bottom and its ceiling, as a window does. A railing's gap is on the floor.
+    const sill = railingGap ? undefined : input.sillHeight;
+    const onFloor = kind === 'door' && sill === undefined;
+    const rawY = sill !== undefined
+        ? sill + height / 2
+        : kind === 'door'
+            ? height / 2
+            : wallOpeningCeilingOver(wall, nodes, rawX - size.width / 2, rawX + size.width / 2) / 2;
+    const { clampedX, clampedY, fits } = onFloor
+        ? clampDoorToWall(wall, rawX, size.width, size.height, undefined, nodes)
+        : clampWindowToWall(wall, rawX, rawY + (size.height - height) / 2, size.width, size.height, nodes);
+    if (!fits)
+        refuseOpeningAboveSlope(wall, nodes, kind, size.width, size.height);
+    // Checked where the clamp put the door: under a sloped top it may have slid to the high end.
+    if (kind === 'door') {
+        const wallHeight = wallOpeningCeilingOver(wall, nodes, clampedX - size.width / 2, clampedX + size.width / 2) - openingMargin(wall);
+        if (size.height > wallHeight + TOUCHING)
+            refuse('wall_too_low', `Wall ${wallId} is ${metres(wallHeight)} high, too low for a ${metres(size.height)} door.`, { wallId, wallHeight, height: size.height });
+    }
     if (!input.force) {
-        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height);
+        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, size.width, size.height);
         if (blocking) {
             const span = blocking.type === 'item'
                 ? getScaledDimensions(blocking)[0]
@@ -214,12 +306,14 @@ export function planWallOpening(nodes, input) {
     const base = {
         ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
         name: input.name ?? `${kind === 'door' ? 'Door' : 'Window'} ${siblings + 1}`,
-        position: [clampedX, clampedY, 0],
+        position: [clampedX + size.leafOffsetX, clampedY - (size.height - height) / 2, 0],
         rotation: [0, 0, 0],
         wallId,
         parentId: wallId,
         width,
         height,
+        casingFaceA: true,
+        casingFaceB: true,
         ...(input.openingShape ? { openingShape: input.openingShape } : {}),
         ...(input.archHeight === undefined ? {} : { archHeight: Math.min(input.archHeight, height) }),
         ...(input.cornerRadius === undefined ? {} : { cornerRadius: input.cornerRadius }),
@@ -233,27 +327,74 @@ export function planWallOpening(nodes, input) {
     const node = kind === 'door'
         ? DoorNode.parse({
             ...base,
+            ...(input.doorType ? doorTypeFields(input.doorType) : {}),
+            frameThickness: NEW_DOOR_FRAME_THICKNESS,
             ...doorFacing(wall),
+            position: doorPositionForFacing({ ...input, ...base, ...railingGap }, doorFacing(wall).rotation),
             ...doorHardwareSides(input),
+            handleStyle: input.handleStyle,
             swingDirection: input.swingDirection ?? 'inward',
+            sidelightLeft: input.sidelightLeft,
+            sidelightRight: input.sidelightRight,
+            transomHeight: input.transomHeight,
+            ...(input.leafCount === undefined ? {} : { leafCount: input.leafCount }),
+            slidingStyle: input.slidingStyle,
+            ...(input.slideDirection ? { slideDirection: input.slideDirection } : {}),
             ...(input.style ? doorStyleLook(input.style) : {}),
             ...(input.doorType ? { doorType: input.doorType } : {}),
             ...(input.openingKind ? { openingKind: input.openingKind } : {}),
+            ...railingGap,
         })
         : WindowNode.parse({
             ...base,
+            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
             ...getWindowStyleOverrides(input.style),
-            ...(input.windowType ? { windowType: input.windowType } : {}),
+            ...windowTypeFields(windowType),
+            ...(input.hingesSide === undefined ? {} : { hingesSide: input.hingesSide }),
             ...(input.columns ? { columnRatios: equalRatios(input.columns) } : {}),
             ...(input.rows ? { rowRatios: equalRatios(input.rows) } : {}),
+            ...(input.windowType &&
+                !windowTakesStyle(input.windowType) &&
+                (input.columns || input.rows)
+                ? { sashGrid: true }
+                : input.sashGrid === undefined
+                    ? {}
+                    : { sashGrid: input.sashGrid }),
+            ...(input.windowHandle === undefined ? {} : { windowHandle: input.windowHandle }),
+            ...(input.sillInterior === undefined ? {} : { sillInterior: input.sillInterior }),
+            ...(input.shutters === undefined ? {} : { shutters: input.shutters }),
+            ...(input.shutterWidth === undefined ? {} : { shutterWidth: input.shutterWidth }),
+            ...(input.openingDirection === undefined
+                ? {}
+                : { openingDirection: input.openingDirection }),
+            ...(input.tiltTurnMode === undefined ? {} : { tiltTurnMode: input.tiltTurnMode }),
+            ...(input.sillOverhang === undefined ? {} : { sillOverhang: input.sillOverhang }),
+            ...(input.sillInteriorDepth === undefined
+                ? {}
+                : { sillInteriorDepth: input.sillInteriorDepth }),
+            ...(input.sillInteriorThickness === undefined
+                ? {}
+                : { sillInteriorThickness: input.sillInteriorThickness }),
+            ...(input.sillInteriorOverhang === undefined
+                ? {}
+                : { sillInteriorOverhang: input.sillInteriorOverhang }),
+            ...(input.shutterOpen === undefined ? {} : { shutterOpen: input.shutterOpen }),
+            ...(input.shutterSides === undefined ? {} : { shutterSides: input.shutterSides }),
+            ...(input.rollerShutter === undefined ? {} : { rollerShutter: input.rollerShutter }),
+            ...(input.rollerShutterBoxHeight === undefined
+                ? {}
+                : { rollerShutterBoxHeight: input.rollerShutterBoxHeight }),
+            ...(input.rollerShutterOpen === undefined
+                ? {}
+                : { rollerShutterOpen: input.rollerShutterOpen }),
         });
     return {
         node,
         wallId,
-        localX: clampedX,
+        localX: node.position[0],
         t: along,
         wallLength,
-        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(clampedY - rawY) > 1e-9,
-        ...(kind === 'window' ? { sillHeight: clampedY - height / 2 } : {}),
+        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(node.position[1] - rawY) > 1e-9,
+        ...(onFloor ? {} : { sillHeight: node.position[1] - height / 2 }),
     };
 }

package/dist/building/window-types.d.ts

@@ -1,5 +1,6 @@
 import type { WindowNode } from '../schema/index.js';
 import type { WindowType } from '../schema/nodes/opening-types.js';
+export declare const NEW_WINDOW_FRAME_THICKNESS = 0.02;
 /** The window types whose top takes a shape (rounded, arch); the others are rectangular. */
 export declare const SHAPED_WINDOW_TYPES: ReadonlySet<WindowType>;
 /** The window types that project from the wall and have no sill. */

package/dist/building/window-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-types.d.ts","sourceRoot":"","sources":["../../src/building/window-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAE/D,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,UAAU,CAMtD,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,UAAU,CAA2B,CAAA;AAErF,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAMtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,EACtC,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAIrB"}
+{"version":3,"file":"window-types.d.ts","sourceRoot":"","sources":["../../src/building/window-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAG/D,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,UAAU,CAMtD,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,UAAU,CAA2B,CAAA;AAErF,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAOtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,EACtC,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAIrB"}