@pascal-app/core 1.0.3 → 1.0.4

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

@@ -0,0 +1,445 @@
+import { type AnyNode, type AnyNodeId, type CompiledGeometryScript, type GeometryScriptParamValue, type WallNode } 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.
+ */
+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): {
+    clampedX: number;
+    clampedY: number;
+};
+/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+export declare function clampWindowToWall(wall: WallNode, localX: number, localY: number, width: number, height: number, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
+    clampedX: number;
+    clampedY: number;
+};
+/**
+ * The first child of the wall (door, window, or wall-mounted item) that a rectangle centred on
+ * (`clampedX`, `clampedY`) would overlap. Items store their bottom Y; doors and windows their
+ * centre Y.
+ */
+export declare function findWallChildOverlap(wallId: string, nodes: Nodes, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): AnyNode | null;
+/** Whether a placement collides; a missing wall counts as blocked, as in the editor's tools. */
+export declare function hasWallChildOverlap(wallId: string, nodes: Nodes, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): boolean;
+export type WallOpeningInput = {
+    name?: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    kind: 'door' | 'window';
+    wallId?: string;
+    t?: number;
+    position?: number;
+    width?: number;
+    height?: number;
+    sillHeight?: number;
+    hingesSide?: 'left' | 'right';
+    swingDirection?: 'inward' | 'outward';
+    /** A door, or a passage with no leaf (a cased opening, an arch), as the editor's door panel. */
+    openingKind?: 'door' | 'opening';
+    style?: string;
+    force?: boolean;
+    openingShape?: 'rectangle' | 'rounded' | 'arch';
+    archHeight?: number;
+    cornerRadius?: number;
+    doorType?: DoorType;
+    windowType?: WindowType;
+    columns?: number;
+    rows?: number;
+    /** A compiled script the opening is built from; its bounds set width and height. */
+    compiled?: CompiledGeometryScript;
+    code?: string;
+    params?: Record<string, GeometryScriptParamValue>;
+};
+/**
+ * Plan a door or window on a wall with the editor's rules, or refuse with a code: the one
+ * operation behind `add_door` / `add_window` on every agent surface. The caller creates
+ * `node` under `wallId`.
+ */
+/**
+ * Which way a door on `wall` faces: out, when the wall knows its outside. A door's swing and a
+ * garage door's track run behind its facing (a garage door's track once ran on the street), so a door facing out opens and rolls inside, whichever way the wall was drawn. A wall
+ * that does not know its outside, or an inside wall, keeps its front.
+ */
+export declare function doorFacing(wall: Pick<WallNode, 'frontSide' | 'backSide'>): {
+    side?: 'front' | 'back';
+    rotation: [number, number, number];
+};
+/** The face a door placed by hand takes: out on an outside wall, else the face hovered. */
+export declare const placedDoorFace: (wall: Pick<WallNode, "frontSide" | "backSide">, hovered: "front" | "back") => "front" | "back";
+export declare function planWallOpening(nodes: Nodes, input: WallOpeningInput): {
+    sillHeight?: number | undefined;
+    node: {
+        object: "node";
+        parentId: string | null;
+        visible: boolean;
+        metadata: Record<string, unknown>;
+        id: `door_${string}`;
+        type: "door";
+        position: [number, number, number];
+        rotation: [number, number, number];
+        floorThresholdVersion: 0 | 1;
+        width: number;
+        height: number;
+        constructionType: "masonry" | "framed";
+        dimensionReference: "nominal" | "rough-opening" | "masonry-opening" | "finish-opening";
+        doorCategory: "interior" | "garage";
+        doorType: "double" | "hinged" | "french" | "folding" | "pocket" | "barn" | "sliding" | "garage-sectional" | "garage-rollup" | "garage-tiltup";
+        leafCount: 2 | 1 | 3 | 4;
+        operationState: number;
+        slideDirection: "left" | "right";
+        trackStyle: "visible" | "none" | "pocket" | "overhead";
+        garagePanelCount: number;
+        openingKind: "door" | "opening";
+        openingShape: "rectangle" | "rounded" | "arch";
+        openingRadiusMode: "all" | "individual";
+        openingTopRadii: [number, number];
+        cornerRadius: number;
+        archHeight: number;
+        openingRevealRadius: number;
+        frameThickness: number;
+        frameDepth: number;
+        threshold: boolean;
+        thresholdHeight: number;
+        hingesSide: "left" | "right";
+        swingDirection: "inward" | "outward";
+        swingAngle: number;
+        segments: {
+            type: "glass" | "empty" | "panel";
+            heightRatio: number;
+            columnRatios: number[];
+            dividerThickness: number;
+            panelDepth: number;
+            panelInset: number;
+        }[];
+        handle: boolean;
+        handleHeight: number;
+        handleSide: "left" | "right";
+        contentPadding: [number, number];
+        doorCloser: boolean;
+        panicBar: boolean;
+        panicBarHeight: number;
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        provenance?: {
+            refs: {
+                id: string;
+                ns?: string | undefined;
+                role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            }[];
+            lineage?: {
+                op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        slots?: Record<string, string> | undefined;
+        source?: {
+            kind: "script";
+            language: "three" | "bpy";
+            script: string;
+            params: Record<string, string | number | boolean>;
+            artifact: string;
+            manifest: {
+                bounds: {
+                    min: [number, number, number];
+                    max: [number, number, number];
+                };
+                params: {
+                    id: string;
+                    kind: "string" | "number" | "boolean";
+                    default: string | number | boolean;
+                    label?: string | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    step?: number | undefined;
+                    unit?: string | undefined;
+                    options?: string[] | undefined;
+                }[];
+                parts: {
+                    id: string;
+                    label?: string | undefined;
+                    type?: string | undefined;
+                    bounds?: {
+                        min: [number, number, number];
+                        max: [number, number, number];
+                    } | undefined;
+                }[];
+                surfaces: {
+                    y: number;
+                    polygon: [number, number][];
+                    part?: string | undefined;
+                }[];
+                slots: {
+                    id: string;
+                    label?: string | undefined;
+                    color?: string | undefined;
+                    roughness?: number | undefined;
+                    metalness?: number | undefined;
+                    transparent?: boolean | undefined;
+                    emissive?: boolean | undefined;
+                }[];
+                anchors: {
+                    id: string;
+                    position: [number, number, number];
+                    normal?: [number, number, number] | undefined;
+                }[];
+                lights: {
+                    id: string;
+                    position: [number, number, number];
+                    color: string;
+                    intensity: number;
+                    distance?: number | undefined;
+                }[];
+                undersides: {
+                    polygon: [number, number][];
+                    plane: [number, number, number, number];
+                    part?: string | undefined;
+                }[];
+                animations: {
+                    name: string;
+                    duration: number;
+                }[];
+                cutout: boolean;
+                collider: boolean;
+                triangles: number;
+                cutters?: {
+                    host: "wall" | "slab" | "ceiling" | "mounted";
+                    polygon: number[][];
+                    minY: number;
+                    maxY: number;
+                }[] | undefined;
+            };
+            meta?: {
+                description?: string | undefined;
+                category?: string | undefined;
+                tags?: string[] | undefined;
+                parent?: string | undefined;
+            } | undefined;
+            images?: {
+                artifact: string;
+                thumbnail: string;
+                floorPlan: string;
+            } | undefined;
+        } | undefined;
+        side?: "front" | "back" | undefined;
+        verticalAnchor?: "wall" | "floor" | undefined;
+        wallId?: string | undefined;
+        roofSegmentId?: string | undefined;
+        roofFace?: "left" | "right" | "front" | "back" | undefined;
+        mark?: string | undefined;
+        roughOpeningWidth?: number | undefined;
+        roughOpeningHeight?: number | undefined;
+        masonryOpeningWidth?: number | undefined;
+        masonryOpeningHeight?: number | undefined;
+        finishOpeningWidth?: number | undefined;
+        finishOpeningHeight?: number | undefined;
+    } | {
+        object: "node";
+        parentId: string | null;
+        visible: boolean;
+        metadata: Record<string, unknown>;
+        id: `window_${string}`;
+        type: "window";
+        position: [number, number, number];
+        rotation: [number, number, number];
+        floorThresholdVersion: 0 | 1;
+        width: number;
+        height: number;
+        constructionType: "masonry" | "framed";
+        dimensionReference: "nominal" | "rough-opening" | "masonry-opening" | "finish-opening";
+        openingKind: "window" | "opening";
+        windowType: "fixed" | "sliding" | "casement" | "awning" | "hopper" | "single-hung" | "double-hung" | "bay" | "bow" | "louvered";
+        operationState: number;
+        awningDirection: "up" | "down";
+        casementStyle: "french" | "single";
+        hingesSide: "left" | "right";
+        openingShape: "rectangle" | "rounded" | "arch";
+        openingRadiusMode: "all" | "individual";
+        openingCornerRadii: [number, number, number, number];
+        cornerRadius: number;
+        archHeight: number;
+        openingRevealRadius: number;
+        frameThickness: number;
+        frameDepth: number;
+        columnRatios: number[];
+        rowRatios: number[];
+        columnDividerThickness: number;
+        rowDividerThickness: number;
+        sill: boolean;
+        sillDepth: number;
+        sillThickness: number;
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        provenance?: {
+            refs: {
+                id: string;
+                ns?: string | undefined;
+                role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            }[];
+            lineage?: {
+                op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        slots?: Record<string, string> | undefined;
+        source?: {
+            kind: "script";
+            language: "three" | "bpy";
+            script: string;
+            params: Record<string, string | number | boolean>;
+            artifact: string;
+            manifest: {
+                bounds: {
+                    min: [number, number, number];
+                    max: [number, number, number];
+                };
+                params: {
+                    id: string;
+                    kind: "string" | "number" | "boolean";
+                    default: string | number | boolean;
+                    label?: string | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    step?: number | undefined;
+                    unit?: string | undefined;
+                    options?: string[] | undefined;
+                }[];
+                parts: {
+                    id: string;
+                    label?: string | undefined;
+                    type?: string | undefined;
+                    bounds?: {
+                        min: [number, number, number];
+                        max: [number, number, number];
+                    } | undefined;
+                }[];
+                surfaces: {
+                    y: number;
+                    polygon: [number, number][];
+                    part?: string | undefined;
+                }[];
+                slots: {
+                    id: string;
+                    label?: string | undefined;
+                    color?: string | undefined;
+                    roughness?: number | undefined;
+                    metalness?: number | undefined;
+                    transparent?: boolean | undefined;
+                    emissive?: boolean | undefined;
+                }[];
+                anchors: {
+                    id: string;
+                    position: [number, number, number];
+                    normal?: [number, number, number] | undefined;
+                }[];
+                lights: {
+                    id: string;
+                    position: [number, number, number];
+                    color: string;
+                    intensity: number;
+                    distance?: number | undefined;
+                }[];
+                undersides: {
+                    polygon: [number, number][];
+                    plane: [number, number, number, number];
+                    part?: string | undefined;
+                }[];
+                animations: {
+                    name: string;
+                    duration: number;
+                }[];
+                cutout: boolean;
+                collider: boolean;
+                triangles: number;
+                cutters?: {
+                    host: "wall" | "slab" | "ceiling" | "mounted";
+                    polygon: number[][];
+                    minY: number;
+                    maxY: number;
+                }[] | undefined;
+            };
+            meta?: {
+                description?: string | undefined;
+                category?: string | undefined;
+                tags?: string[] | undefined;
+                parent?: string | undefined;
+            } | undefined;
+            images?: {
+                artifact: string;
+                thumbnail: string;
+                floorPlan: string;
+            } | undefined;
+        } | undefined;
+        side?: "front" | "back" | undefined;
+        verticalAnchor?: "wall" | "floor" | undefined;
+        wallId?: string | undefined;
+        dormerId?: string | undefined;
+        dormerFace?: "left" | "right" | "front" | "back" | undefined;
+        roofSegmentId?: string | undefined;
+        roofFace?: "left" | "right" | "front" | "back" | undefined;
+        mark?: string | undefined;
+        roughOpeningWidth?: number | undefined;
+        roughOpeningHeight?: number | undefined;
+        masonryOpeningWidth?: number | undefined;
+        masonryOpeningHeight?: number | undefined;
+        finishOpeningWidth?: number | undefined;
+        finishOpeningHeight?: number | undefined;
+    };
+    wallId: string;
+    localX: number;
+    t: number;
+    wallLength: number;
+    clamped: boolean;
+};
+export {};
+//# sourceMappingURL=wall-openings.d.ts.map

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

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

@@ -0,0 +1,231 @@
+import { refuseParamsWithoutScript } from '../agent-operations/add-object.js';
+import { refuse } from '../agent-tools/refusal.js';
+import { matchScriptSlotsToLibrary, scriptedSize, scriptSource } from '../lib/geometry-script-node.js';
+import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { DoorNode, getScaledDimensions, WindowNode, } from '../schema/index.js';
+import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
+import { getWallPlaneTop } from '../services/storey.js';
+import { resolveWallExteriorSide } from '../systems/wall/wall-assembly.js';
+import { getWallCurveLength, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { resolveWallTop } from '../systems/wall/wall-top.js';
+import { doorStyleLook, getWindowStyleOverrides, } from './opening-style-presets.js';
+import { windowTakesStyle } 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.
+ */
+export function resolveWallOpeningCeiling(wall, nodes) {
+    const support = wallSupportForNodes(wall, nodes);
+    return (resolveWallTop(wall, getWallPlaneTop(wall, wall.parentId ?? '', nodes), support.elevation) - support.elevation);
+}
+/** 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) {
+    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 };
+}
+/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+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 };
+}
+/**
+ * The first child of the wall (door, window, or wall-mounted item) that a rectangle centred on
+ * (`clampedX`, `clampedY`) would overlap. Items store their bottom Y; doors and windows their
+ * centre Y.
+ */
+export function findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
+    const wallNode = nodes[wallId];
+    if (!wallNode)
+        return null;
+    const newBottom = clampedY - height / 2;
+    const newTop = clampedY + height / 2;
+    const newLeft = clampedX - width / 2;
+    const newRight = clampedX + width / 2;
+    for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
+        if (childId === ignoreId)
+            continue;
+        const child = nodes[childId];
+        if (!child || child.metadata.isTransient)
+            continue;
+        let childLeft;
+        let childRight;
+        let childBottom;
+        let childTop;
+        if (child.type === 'item') {
+            const item = child;
+            if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
+                continue;
+            const [w, h] = getScaledDimensions(item);
+            childLeft = item.position[0] - w / 2;
+            childRight = item.position[0] + w / 2;
+            childBottom = item.position[1];
+            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;
+        }
+        else {
+            continue;
+        }
+        // Edges that meet are not an overlap, even when a decimal position lands them a hair apart.
+        if (newLeft < childRight - TOUCHING &&
+            newRight > childLeft + TOUCHING &&
+            newBottom < childTop - TOUCHING &&
+            newTop > childBottom + TOUCHING)
+            return child;
+    }
+    return null;
+}
+/** Whether a placement collides; a missing wall counts as blocked, as in the editor's tools. */
+export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
+    if (!nodes[wallId])
+        return true;
+    return findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) !== null;
+}
+const equalRatios = (count) => Array.from({ length: count }, () => 1 / count);
+const DEFAULTS = {
+    door: { width: 0.9, height: 2.1 },
+    window: { width: 1.5, height: 1.5, sillHeight: 0.9 },
+};
+const metres = (value) => `${value.toFixed(2)} m`;
+/**
+ * Plan a door or window on a wall with the editor's rules, or refuse with a code: the one
+ * operation behind `add_door` / `add_window` on every agent surface. The caller creates
+ * `node` under `wallId`.
+ */
+/**
+ * Which way a door on `wall` faces: out, when the wall knows its outside. A door's swing and a
+ * garage door's track run behind its facing (a garage door's track once ran on the street), so a door facing out opens and rolls inside, whichever way the wall was drawn. A wall
+ * that does not know its outside, or an inside wall, keeps its front.
+ */
+export function doorFacing(wall) {
+    const outside = resolveWallExteriorSide(wall);
+    if (outside === -1)
+        return { side: 'back', rotation: [0, Math.PI, 0] };
+    if (outside === 1)
+        return { side: 'front', rotation: [0, 0, 0] };
+    return { rotation: [0, 0, 0] };
+}
+/** The face a door placed by hand takes: out on an outside wall, else the face hovered. */
+export const placedDoorFace = (wall, hovered) => doorFacing(wall).side ?? hovered;
+export function planWallOpening(nodes, input) {
+    refuseParamsWithoutScript(nodes, input);
+    const { kind, wallId } = input;
+    if (!wallId)
+        refuse('wall_required', `Say which wall the ${kind} goes on (wallId), or pass nodeId to rebuild one.`);
+    const host = nodes[wallId];
+    if (!host)
+        refuse('wall_not_found', `Wall not found: ${wallId}.`, { wallId });
+    if (host.type !== 'wall')
+        refuse('not_a_wall', `Node ${wallId} is a ${host.type}, not a wall.`, {
+            wallId,
+            type: host.type,
+        });
+    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 });
+    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 });
+    const along = t ?? position;
+    if (along === undefined)
+        refuse('position_required', 'Say where on the wall: t (or position) from 0 at its start to 1 at its end.');
+    // The renderer draws a style's panes on a Fixed window only; an operable window draws its own
+    // sashes, so a style there would be written and never seen.
+    const windowType = input.windowType ?? 'fixed';
+    if (kind === 'window' && input.style && !windowTakesStyle(windowType))
+        refuse('style_needs_fixed_window', `A window style shapes a Fixed window's panes; a ${windowType} window draws its own sashes, so the style would not show. Pass windowType 'fixed' with the style, or drop the style.`, { windowType, style: input.style });
+    const { compiled } = input;
+    if (compiled && compiled.mount !== 'wall')
+        refuse('wrong_mount', `A ${kind}'s script uses mount 'wall'.`, { mount: compiled.mount });
+    const [scriptedWidth, scriptedHeight] = compiled ? scriptedSize(compiled.manifest) : [];
+    const width = scriptedWidth ?? input.width ?? DEFAULTS[kind].width;
+    const height = scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const wallLength = lengthOf(wall);
+    if (wallLength < 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;
+    const sillHeight = input.sillHeight ?? DEFAULTS.window.sillHeight;
+    const rawY = kind === 'door' ? height / 2 : sillHeight + height / 2;
+    const { clampedX, clampedY } = kind === 'door'
+        ? clampDoorToWall(wall, rawX, width, height)
+        : clampWindowToWall(wall, rawX, rawY, width, height, nodes);
+    if (!input.force) {
+        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height);
+        if (blocking) {
+            const span = blocking.type === 'item'
+                ? getScaledDimensions(blocking)[0]
+                : blocking.width;
+            const center = blocking.position[0];
+            refuse('opening_overlap', `A ${metres(width)} ${kind} at ${metres(clampedX)} on wall ${wallId} would overlap ${blocking.type} ${blocking.id} (${metres(center - span / 2)}–${metres(center + span / 2)}). Move it along the wall, or, if the person asked for the overlap, pass force, like holding Alt in the editor.`, { wallId, blockingId: blocking.id });
+        }
+    }
+    const levelId = wall.parentId;
+    const siblings = Object.values(nodes).filter((node) => {
+        if (node.type !== kind)
+            return false;
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        return parent?.parentId === levelId;
+    }).length;
+    const base = {
+        ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
+        name: input.name ?? `${kind === 'door' ? 'Door' : 'Window'} ${siblings + 1}`,
+        position: [clampedX, clampedY, 0],
+        rotation: [0, 0, 0],
+        wallId,
+        parentId: wallId,
+        width,
+        height,
+        ...(input.openingShape ? { openingShape: input.openingShape } : {}),
+        ...(input.archHeight === undefined ? {} : { archHeight: Math.min(input.archHeight, height) }),
+        ...(input.cornerRadius === undefined ? {} : { cornerRadius: input.cornerRadius }),
+        ...(compiled
+            ? {
+                source: scriptSource(compiled, input),
+                slots: matchScriptSlotsToLibrary(compiled.manifest),
+            }
+            : {}),
+    };
+    const node = kind === 'door'
+        ? DoorNode.parse({
+            ...base,
+            ...doorFacing(wall),
+            hingesSide: input.hingesSide ?? 'left',
+            swingDirection: input.swingDirection ?? 'inward',
+            ...(input.style ? doorStyleLook(input.style) : {}),
+            ...(input.doorType ? { doorType: input.doorType } : {}),
+            ...(input.openingKind ? { openingKind: input.openingKind } : {}),
+        })
+        : WindowNode.parse({
+            ...base,
+            ...getWindowStyleOverrides(input.style),
+            ...(input.windowType ? { windowType: input.windowType } : {}),
+            ...(input.columns ? { columnRatios: equalRatios(input.columns) } : {}),
+            ...(input.rows ? { rowRatios: equalRatios(input.rows) } : {}),
+        });
+    return {
+        node,
+        wallId,
+        localX: clampedX,
+        t: along,
+        wallLength,
+        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(clampedY - rawY) > 1e-9,
+        ...(kind === 'window' ? { sillHeight: clampedY - height / 2 } : {}),
+    };
+}