@pascal-app/core 1.0.3 → 1.0.5

package/dist/building/__fixtures__/wall-opening-cases.d.ts.map

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

package/dist/building/__fixtures__/wall-opening-cases.js

@@ -0,0 +1,367 @@
+import { BuildingNode, DoorNode, ItemNode, LevelNode, WallNode } from '../../schema/index.js';
+/**
+ * The edge cases of `add_door` / `add_window`, written before the operation: one table that the
+ * core operation, the MCP tool and the hosted chat's executor all run, so the three layers cannot
+ * disagree. The editor's manual tools are the reference for what is possible: curved walls take
+ * no openings, overlapping placements need a force (Alt in the editor), positions clamp onto the
+ * wall and windows under its ceiling. `wall_too_short` is the one guard the editor lacks.
+ */
+export const OPENING_SCENE = {
+    buildingId: 'building_openings',
+    levelId: 'level_openings',
+    /** 4 m straight wall, 2.5 m tall. */
+    main: 'wall_main',
+    /** 0.8 m: shorter than a default door. */
+    short: 'wall_short',
+    /** 0.9 m: exactly a default door. */
+    exact: 'wall_exact',
+    /** 4 m wall with a door centred at 2.0 m (1.55–2.45 m, 0–2.1 m high). */
+    busy: 'wall_busy',
+    existingDoor: 'door_existing',
+    /** 4 m wall bowed 0.5 m. */
+    curved: 'wall_curved',
+    /** 4 m wall with no height of its own: the 2.8 m storey decides. */
+    storey: 'wall_storey',
+    /** 4 m wall carrying a 1.2 m wall-mounted shelf centred at 2.0 m (1.4–2.6 m, 1.0–1.6 m high). */
+    shelved: 'wall_shelved',
+    wallShelf: 'item_wall_shelf',
+    /** 4 m outside wall, its outside at the front (+normal). */
+    outFront: 'wall_out_front',
+    /** 4 m outside wall drawn the other way: its outside at the back, as a garage wall can be. */
+    outBack: 'wall_out_back',
+};
+const wall = (id, z, length, extra = {}) => WallNode.parse({
+    id,
+    parentId: OPENING_SCENE.levelId,
+    start: [0, z],
+    end: [length, z],
+    thickness: 0.2,
+    height: 2.5,
+    ...extra,
+});
+/** A fresh scene graph for every case: one building, one 2.8 m storey, nine walls. */
+export function openingScene() {
+    // No height of its own: the storey decides.
+    const { height: _height, ...storeyWall } = wall(OPENING_SCENE.storey, 10, 4);
+    const walls = [
+        wall(OPENING_SCENE.main, 0, 4),
+        wall(OPENING_SCENE.short, 2, 0.8),
+        wall(OPENING_SCENE.exact, 4, 0.9),
+        { ...wall(OPENING_SCENE.busy, 6, 4), children: [OPENING_SCENE.existingDoor] },
+        wall(OPENING_SCENE.curved, 8, 4, { curveOffset: 0.5 }),
+        storeyWall,
+        { ...wall(OPENING_SCENE.shelved, 12, 4), children: [OPENING_SCENE.wallShelf] },
+        wall(OPENING_SCENE.outFront, 14, 4, { frontSide: 'exterior', backSide: 'interior' }),
+        wall(OPENING_SCENE.outBack, 16, 4, { frontSide: 'interior', backSide: 'exterior' }),
+    ];
+    const door = DoorNode.parse({
+        id: OPENING_SCENE.existingDoor,
+        parentId: OPENING_SCENE.busy,
+        wallId: OPENING_SCENE.busy,
+        position: [2, 1.05, 0],
+        width: 0.9,
+        height: 2.1,
+    });
+    const shelf = ItemNode.parse({
+        id: OPENING_SCENE.wallShelf,
+        parentId: OPENING_SCENE.shelved,
+        wallId: OPENING_SCENE.shelved,
+        position: [2, 1, 0],
+        asset: {
+            id: 'wall-shelf',
+            name: 'Wall shelf',
+            category: 'storage',
+            thumbnail: '/items/wall-shelf/thumbnail.webp',
+            src: '/items/wall-shelf/model.glb',
+            dimensions: [1.2, 0.6, 0.3],
+            attachTo: 'wall',
+        },
+    });
+    const level = LevelNode.parse({
+        id: OPENING_SCENE.levelId,
+        parentId: OPENING_SCENE.buildingId,
+        level: 0,
+        height: 2.8,
+        children: walls.map((w) => w.id),
+    });
+    const building = BuildingNode.parse({ id: OPENING_SCENE.buildingId, children: [level.id] });
+    const nodes = Object.fromEntries([building, level, ...walls, door, shelf].map((node) => [node.id, node]));
+    return { nodes, rootNodeIds: [building.id] };
+}
+export const WALL_OPENING_REFUSALS = [
+    'wall_not_found',
+    'not_a_wall',
+    'curved_wall',
+    'position_required',
+    'conflicting_position',
+    'wall_too_short',
+    'opening_overlap',
+    'style_needs_fixed_window',
+];
+const { main, short, exact, busy, curved, storey, shelved, wallShelf, levelId, existingDoor, outFront, outBack, } = OPENING_SCENE;
+export const WALL_OPENING_CASES = [
+    // Which way it faces. A door's swing and a garage door's track run behind its facing, so a door
+    // on an outside wall faces out whichever way the wall was drawn (a garage door's track once ran
+    // on the street). An inside wall keeps the wall's front.
+    {
+        name: 'a door on an outside wall faces out',
+        tool: 'add_door',
+        input: { wallId: outFront, t: 0.5 },
+        expect: { localX: 2, centerY: 1.05, clamped: false, node: { side: 'front', rotation: [0, 0, 0] } },
+    },
+    {
+        name: 'a garage door on an outside wall drawn the other way faces out, its track inside',
+        tool: 'add_door',
+        input: { wallId: outBack, t: 0.5, width: 2.4, doorType: 'garage-sectional' },
+        expect: {
+            localX: 2,
+            centerY: 1.05,
+            clamped: false,
+            node: { side: 'back', rotation: [0, Math.PI, 0] },
+        },
+    },
+    {
+        name: "a door on an inside wall keeps the wall's front",
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5 },
+        expect: { localX: 2, centerY: 1.05, clamped: false, node: { rotation: [0, 0, 0] } },
+    },
+    // Its hardware: the handle hangs opposite the hinges unless placed.
+    {
+        name: 'a right-hinged door takes its handle on the left',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5, hingesSide: 'right' },
+        expect: {
+            localX: 2,
+            centerY: 1.05,
+            clamped: false,
+            node: { hingesSide: 'right', handleSide: 'left' },
+        },
+    },
+    {
+        name: 'a left-hinged door takes its handle on the right',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5 },
+        expect: {
+            localX: 2,
+            centerY: 1.05,
+            clamped: false,
+            node: { hingesSide: 'left', handleSide: 'right' },
+        },
+    },
+    {
+        name: 'a handle side given is kept',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5, hingesSide: 'right', handleSide: 'right' },
+        expect: {
+            localX: 2,
+            centerY: 1.05,
+            clamped: false,
+            node: { hingesSide: 'right', handleSide: 'right' },
+        },
+    },
+    // Where it goes
+    {
+        name: 'a door at t 0.5 is centred',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5 },
+        expect: { localX: 2, centerY: 1.05, clamped: false },
+    },
+    {
+        name: 'a door at the start slides onto the wall',
+        tool: 'add_door',
+        input: { wallId: main, t: 0 },
+        expect: { localX: 0.45, centerY: 1.05, clamped: true },
+    },
+    {
+        name: 'a door at the end slides onto the wall',
+        tool: 'add_door',
+        input: { wallId: main, t: 1 },
+        expect: { localX: 3.55, centerY: 1.05, clamped: true },
+    },
+    {
+        name: 'position is an alias of t',
+        tool: 'add_door',
+        input: { wallId: main, position: 0.25 },
+        expect: { localX: 1, centerY: 1.05, clamped: false },
+    },
+    {
+        name: 'equal t and position agree',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.25, position: 0.25 },
+        expect: { localX: 1, centerY: 1.05, clamped: false },
+    },
+    {
+        name: 'a wall exactly as long as the door takes it',
+        tool: 'add_door',
+        input: { wallId: exact, t: 0.5 },
+        expect: { localX: 0.45, centerY: 1.05, clamped: false },
+    },
+    {
+        name: 'a wall with no height of its own takes a door',
+        tool: 'add_door',
+        input: { wallId: storey, t: 0.5 },
+        expect: { localX: 2, centerY: 1.05, clamped: false },
+    },
+    // A gap's advice says to reopen a passage, and no tool made an opening with no leaf; the editor's door panel has Door / Opening.
+    {
+        name: 'a passage with no leaf is an opening, in the outline asked',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5, openingKind: 'opening', openingShape: 'arch' },
+        expect: {
+            localX: 2,
+            centerY: 1.05,
+            clamped: false,
+            node: { openingKind: 'opening', openingShape: 'arch' },
+        },
+    },
+    {
+        name: 'a door style changes the panels, not the size',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.5, style: 'glass' },
+        expect: { localX: 2, centerY: 1.05, clamped: false, glassPanels: true },
+    },
+    // The agents' windows are centred on the wall unless a sill is given: a 1.5 m window on the
+    // 2.5 m wall spans 0.5–2.0 m. (A 0.9 m default put the same window at 0.9–2.4 m, under the top.)
+    {
+        name: 'a window with no sill is centred on its wall',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5 },
+        expect: { localX: 2, centerY: 1.25, clamped: false },
+    },
+    {
+        name: 'a window of another height is centred on the wall too',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, height: 1 },
+        expect: { localX: 2, centerY: 1.25, clamped: false },
+    },
+    {
+        name: 'a wall with no height of its own centres the window on the storey',
+        tool: 'add_window',
+        input: { wallId: storey, t: 0.5 },
+        expect: { localX: 2, centerY: 1.4, clamped: false },
+    },
+    {
+        name: 'a tall window is centred with room above and below',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, height: 2.4 },
+        expect: { localX: 2, centerY: 1.25, clamped: false },
+    },
+    {
+        name: 'a window given a 0.9 m sill keeps it',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, sillHeight: 0.9 },
+        expect: { localX: 2, centerY: 1.65, clamped: false },
+    },
+    // A style shapes a Fixed window's panes; an operable window draws its own sashes and ignores them.
+    {
+        name: 'a Fixed window takes a style',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, windowType: 'fixed', style: 'double-hung' },
+        expect: { localX: 2, centerY: 1.25, clamped: false },
+    },
+    {
+        name: 'a style on a window that is not Fixed is refused, naming the Fixed type',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, windowType: 'casement', style: 'double-hung' },
+        expect: { refusal: 'style_needs_fixed_window', mentions: ["'fixed'", 'casement'] },
+    },
+    {
+        name: 'a window keeps the sill it is given',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, sillHeight: 1, height: 1.2 },
+        expect: { localX: 2, centerY: 1.6, clamped: false },
+    },
+    {
+        name: 'a window above the ceiling slides down under it',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5, sillHeight: 1.5, height: 1.5 },
+        expect: { localX: 2, centerY: 1.75, clamped: true },
+    },
+    {
+        name: 'a wall with no height uses the storey for its ceiling',
+        tool: 'add_window',
+        input: { wallId: storey, t: 0.5, sillHeight: 1.5, height: 1.2 },
+        expect: { localX: 2, centerY: 2.1, clamped: false },
+    },
+    // Openings already on the wall
+    {
+        name: 'a door overlapping another is refused',
+        tool: 'add_door',
+        input: { wallId: busy, t: 0.55 },
+        expect: { refusal: 'opening_overlap', mentions: [existingDoor] },
+    },
+    {
+        name: 'a window overlapping a door is refused',
+        tool: 'add_window',
+        input: { wallId: busy, t: 0.5 },
+        expect: { refusal: 'opening_overlap', mentions: [existingDoor] },
+    },
+    {
+        name: 'a door over a wall-mounted item is refused with the item\'s span',
+        tool: 'add_door',
+        input: { wallId: shelved, t: 0.5 },
+        expect: { refusal: 'opening_overlap', mentions: [wallShelf, '1.40 m–2.60 m'] },
+    },
+    {
+        name: 'openings whose edges touch both fit',
+        tool: 'add_door',
+        input: { wallId: busy, t: 0.725 },
+        expect: { localX: 2.9, centerY: 1.05, clamped: false },
+    },
+    {
+        name: 'force places over another opening, like Alt in the editor',
+        tool: 'add_door',
+        input: { wallId: busy, t: 0.55, force: true },
+        expect: { localX: 2.2, centerY: 1.05, clamped: false },
+    },
+    // Refusals
+    {
+        name: 'no position is refused',
+        tool: 'add_door',
+        input: { wallId: main },
+        expect: { refusal: 'position_required' },
+    },
+    {
+        name: 'different t and position are refused',
+        tool: 'add_door',
+        input: { wallId: main, t: 0.2, position: 0.6 },
+        expect: { refusal: 'conflicting_position' },
+    },
+    {
+        name: 'an unknown wall is refused',
+        tool: 'add_door',
+        input: { wallId: 'wall_missing', t: 0.5 },
+        expect: { refusal: 'wall_not_found', mentions: ['wall_missing'] },
+    },
+    {
+        name: 'a node that is not a wall is refused',
+        tool: 'add_window',
+        input: { wallId: levelId, t: 0.5 },
+        expect: { refusal: 'not_a_wall', mentions: ['level'] },
+    },
+    {
+        name: 'a wall shorter than the door is refused',
+        tool: 'add_door',
+        input: { wallId: short, t: 0.5 },
+        expect: { refusal: 'wall_too_short', mentions: ['0.80 m', '0.90 m'] },
+    },
+    {
+        name: 'a wall shorter than the window is refused',
+        tool: 'add_window',
+        input: { wallId: short, t: 0.5 },
+        expect: { refusal: 'wall_too_short', mentions: ['0.80 m', '1.50 m'] },
+    },
+    {
+        name: 'a curved wall takes no door, like in the editor',
+        tool: 'add_door',
+        input: { wallId: curved, t: 0.5 },
+        expect: { refusal: 'curved_wall' },
+    },
+    {
+        name: 'a curved wall takes no window, like in the editor',
+        tool: 'add_window',
+        input: { wallId: curved, t: 0.9 },
+        expect: { refusal: 'curved_wall' },
+    },
+];

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

@@ -0,0 +1,56 @@
+import type { AnyNode, WindowNode } from '../schema/index.js';
+import { type WallOpeningInput } from './wall-openings.js';
+type Nodes = Readonly<Record<string, AnyNode>>;
+type Point = [number, number];
+export type CornerWindowInput = {
+    corner: Point;
+    /** The level whose walls meet at the corner. */
+    levelId: string;
+    /** The two walls, when more than two meet at the corner. */
+    wallIds?: [string, string];
+    /** How far the glass runs along each wall from the corner (m), unless `widths` names the wall. */
+    width?: number;
+    widths?: Record<string, number>;
+    height?: number;
+    sillHeight?: number;
+    post?: 'none' | 'post';
+    windowType?: WallOpeningInput['windowType'];
+    style?: string;
+};
+/**
+ * A corner window: one window on each of the two walls of `levelId` meeting at `corner`, each
+ * running to it, joined, at any angle the walls make. Each side is placed by add_window's rules,
+ * and the two keep one sill: with none given, both are centred on the lower of the two walls.
+ */
+export declare function planCornerWindow(nodes: Nodes, input: CornerWindowInput): {
+    windows: WindowNode[];
+    wallIds: [string, string];
+    angle: number;
+};
+/** The partner's update for a change to one side of a corner window; null when nothing shared changed. */
+export declare function cornerPartnerUpdates(nodes: Nodes, windowId: string, patch: Partial<WindowNode>): Partial<WindowNode> | null;
+/**
+ * The editor's Wrap the corner: a window within `CORNER_REACH_M` of a corner where exactly one other
+ * wall ends is slid to the corner and joined to the window waiting there on that wall, adopted
+ * (`mergeWindows`); with none waiting, it gets a partner on that wall, of its width (as far as the
+ * wall allows), height, sill and type. `create` is the partner to add, if any; `updates` are the
+ * windows that change, by id.
+ */
+export declare function wrapCorner(nodes: Nodes, windowId: string): {
+    create: WindowNode | null;
+    updates: Record<string, Partial<WindowNode>>;
+};
+/** The editor's Unwrap: both windows stay, plain, where they are. */
+export declare function unwrapCorner(nodes: Nodes, windowId: string): Record<string, Partial<WindowNode>>;
+/**
+ * After a window moved: its `corner` cleared on both sides when it is no longer one side of its
+ * pair (dragged off the corner, or onto another wall); nothing while the pair holds.
+ */
+export declare function strayCornerClears(nodes: Nodes, windowId: string): Record<string, Partial<WindowNode>>;
+/**
+ * A new width for one side of a corner window, its corner end kept at the corner (the panel's
+ * Width and Other side): the free edge moves, as far as the wall allows.
+ */
+export declare function cornerSideWidth(nodes: Nodes, windowId: string, width: number): Partial<WindowNode> | null;
+export {};
+//# sourceMappingURL=corner-window.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"corner-window.d.ts","sourceRoot":"","sources":["../../src/building/corner-window.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAuB,UAAU,EAAE,MAAM,WAAW,CAAA;AAEzE,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAA;AAExB,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAC9C,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,KAAK,CAAA;IACb,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1B,kGAAkG;IAClG,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAA;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB;aAqE9D,UAAU,EAAE;aACkB,CAAC,MAAM,EAAE,MAAM,CAAC;;EAGtD;AAaD,0GAA0G;AAC1G,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GACzB,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAW5B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,GACf;IAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAA;CAAE,CAqE7E;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAEhG;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAKrC;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAQ5B"}

package/dist/building/corner-window.js

@@ -0,0 +1,179 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { CORNER_REACH_M, cornerAngle, cornerLinkClears, cornerPair, fusesAtCorner, isWrappableAngle, wallEndPoint, wallLengthOf, wallsEndingAt, windowEndGap, windowNearCornerEnd, } from '../lib/corner-pair.js';
+import { mergeWindows } from './merge-windows.js';
+import { centredWindowSill, DEFAULT_WINDOW, planWallOpening, } from './wall-openings.js';
+/**
+ * A corner window: one window on each of the two walls of `levelId` meeting at `corner`, each
+ * running to it, joined, at any angle the walls make. Each side is placed by add_window's rules,
+ * and the two keep one sill: with none given, both are centred on the lower of the two walls.
+ */
+export function planCornerWindow(nodes, input) {
+    const point = input.corner;
+    const meeting = wallsEndingAt(nodes, input.levelId, point).filter(({ wall }) => !input.wallIds || input.wallIds.includes(wall.id));
+    if (meeting.length < 2)
+        refuse('no_corner', `No two walls of level ${input.levelId}${input.wallIds ? ` among ${input.wallIds.join(', ')}` : ''} end at (${point.join(', ')}): a corner window goes where two walls of one level meet; get_walls gives their ends.`, { corner: point, levelId: input.levelId });
+    if (meeting.length > 2)
+        refuse('corner_ambiguous', `${meeting.length} walls end at (${point.join(', ')}): say which two with wallIds (${meeting.map(({ wall }) => wall.id).join(', ')}).`, { corner: point, wallIds: meeting.map(({ wall }) => wall.id) });
+    const [a, b] = meeting;
+    const angle = cornerAngle(a, b);
+    if (!isWrappableAngle(angle))
+        refuse('corner_angle', `The walls at (${point.join(', ')}) meet at ${Math.round(angle)}°: too close to ${angle < 90 ? 'folded back' : 'straight'} for a corner window. Along a straight run, one add_window is the window.`, { angle });
+    const sillHeight = input.sillHeight ??
+        centredWindowSill([a.wall, b.wall], input.height ?? DEFAULT_WINDOW.height, nodes);
+    const windows = [a, b].map(({ wall, end }) => {
+        const width = input.widths?.[wall.id] ?? input.width ?? 1.2;
+        const length = wallLengthOf(wall);
+        if (width > length)
+            refuse('width_exceeds_wall', `Wall ${wall.id} is ${length.toFixed(2)} m long, too short for a ${width.toFixed(2)} m side of the corner window.`, { wallId: wall.id, width, length });
+        const centre = end === 'start' ? width / 2 : length - width / 2;
+        return {
+            end,
+            node: planWallOpening(nodes, {
+                kind: 'window',
+                wallId: wall.id,
+                t: centre / length,
+                width,
+                ...(input.height === undefined ? {} : { height: input.height }),
+                sillHeight,
+                ...(input.windowType ? { windowType: input.windowType } : {}),
+                ...(input.style ? { style: input.style } : {}),
+            }).node,
+        };
+    });
+    const [first, second] = windows;
+    const fuses = fusesAtCorner(first.node);
+    if (input.post === 'none' && !fuses)
+        refuse('corner_not_fused', `A ${first.node.windowType} window keeps its frame at the corner, so its glass cannot fuse there: only a fixed window's does. Pass post "post", or windowType "fixed".`, { windowType: first.node.windowType });
+    const post = input.post ?? (fuses ? 'none' : 'post');
+    return {
+        windows: [
+            { ...first.node, corner: { end: first.end, partnerId: second.node.id, post } },
+            { ...second.node, corner: { end: second.end, partnerId: first.node.id, post } },
+        ],
+        wallIds: [a.wall.id, b.wall.id],
+        angle,
+    };
+}
+/** What both sides of a corner window share: changed on one, it changes on the other. */
+const SHARED = [
+    'height',
+    'windowType',
+    'frameThickness',
+    'frameDepth',
+    'sill',
+    'sillDepth',
+    'sillThickness',
+];
+/** The partner's update for a change to one side of a corner window; null when nothing shared changed. */
+export function cornerPartnerUpdates(nodes, windowId, patch) {
+    const window = nodes[windowId];
+    if (window?.type !== 'window')
+        return null;
+    const pair = cornerPair(nodes, window);
+    if (!pair)
+        return null;
+    const update = {};
+    for (const key of SHARED)
+        if (patch[key] !== undefined)
+            update[key] = patch[key];
+    if (patch.position)
+        update.position = [pair.partner.position[0], patch.position[1], pair.partner.position[2]];
+    if (patch.corner?.post)
+        update.corner = { ...pair.partner.corner, post: patch.corner.post };
+    return Object.keys(update).length ? update : null;
+}
+/**
+ * The editor's Wrap the corner: a window within `CORNER_REACH_M` of a corner where exactly one other
+ * wall ends is slid to the corner and joined to the window waiting there on that wall, adopted
+ * (`mergeWindows`); with none waiting, it gets a partner on that wall, of its width (as far as the
+ * wall allows), height, sill and type. `create` is the partner to add, if any; `updates` are the
+ * windows that change, by id.
+ */
+export function wrapCorner(nodes, windowId) {
+    const window = nodes[windowId];
+    const end = window?.type === 'window' ? windowNearCornerEnd(nodes, window) : null;
+    const wall = window ? nodes[window.parentId ?? ''] : undefined;
+    if (!window || !end || wall?.type !== 'wall')
+        refuse('no_corner', `This window is not within ${CORNER_REACH_M.toFixed(2)} m of a corner of its wall.`);
+    const others = wallsEndingAt(nodes, wall.parentId ?? undefined, wallEndPoint(wall, end)).filter((meeting) => meeting.wall.id !== wall.id);
+    if (others.length !== 1)
+        refuse('no_corner', 'A corner window needs exactly one other wall ending at this corner.');
+    const { wall: other, end: otherEnd } = others[0];
+    if (!isWrappableAngle(cornerAngle({ wall, end }, { wall: other, end: otherEnd })))
+        refuse('corner_angle', 'The walls meet at too sharp or too flat an angle for a corner window.');
+    // A window already waiting at the other wall's corner is adopted, the nearest first.
+    const waiting = Object.values(nodes)
+        .filter((node) => node.type === 'window' &&
+        node.parentId === other.id &&
+        node.id !== window.id &&
+        !cornerPair(nodes, node) &&
+        windowNearCornerEnd(nodes, node) === otherEnd)
+        .sort((a, b) => windowEndGap(other, a, otherEnd) - windowEndGap(other, b, otherEnd))[0];
+    if (waiting) {
+        const merge = mergeWindows(nodes, window.id, waiting.id);
+        return {
+            create: null,
+            updates: Object.fromEntries(merge.changes.update.map(({ id, data }) => [id, data])),
+        };
+    }
+    const width = Math.min(window.width, wallLengthOf(other));
+    const centre = otherEnd === 'start' ? width / 2 : wallLengthOf(other) - width / 2;
+    const sillHeight = window.position[1] - window.height / 2;
+    const partner = planWallOpening(nodes, {
+        kind: 'window',
+        wallId: other.id,
+        t: centre / wallLengthOf(other),
+        width,
+        height: window.height,
+        sillHeight,
+        windowType: window.windowType,
+    }).node;
+    const post = fusesAtCorner(window) ? 'none' : 'post';
+    const slidTo = end === 'start' ? window.width / 2 : wallLengthOf(wall) - window.width / 2;
+    return {
+        create: {
+            ...partner,
+            columnRatios: window.columnRatios,
+            rowRatios: window.rowRatios,
+            corner: { end: otherEnd, partnerId: window.id, post },
+        },
+        updates: {
+            // The partner of a pair this window has left (it was dragged here) is plain again.
+            ...unwrapCorner(nodes, window.id),
+            [window.id]: {
+                corner: { end, partnerId: partner.id, post },
+                ...(Math.abs(windowEndGap(wall, window, end)) > 1e-6
+                    ? { position: [slidTo, window.position[1], window.position[2]] }
+                    : {}),
+            },
+        },
+    };
+}
+/** The editor's Unwrap: both windows stay, plain, where they are. */
+export function unwrapCorner(nodes, windowId) {
+    return Object.fromEntries(cornerLinkClears(nodes, windowId).map(({ id, data }) => [id, data]));
+}
+/**
+ * After a window moved: its `corner` cleared on both sides when it is no longer one side of its
+ * pair (dragged off the corner, or onto another wall); nothing while the pair holds.
+ */
+export function strayCornerClears(nodes, windowId) {
+    const window = nodes[windowId];
+    if (window?.type !== 'window' || !window.corner || cornerPair(nodes, window))
+        return {};
+    return unwrapCorner(nodes, windowId);
+}
+/**
+ * A new width for one side of a corner window, its corner end kept at the corner (the panel's
+ * Width and Other side): the free edge moves, as far as the wall allows.
+ */
+export function cornerSideWidth(nodes, windowId, width) {
+    const window = nodes[windowId];
+    const pair = window?.type === 'window' ? cornerPair(nodes, window) : null;
+    if (!window || !pair)
+        return null;
+    const length = wallLengthOf(pair.wall);
+    const clamped = Math.max(0.1, Math.min(width, length));
+    const centre = pair.end === 'start' ? clamped / 2 : length - clamped / 2;
+    return { width: clamped, position: [centre, window.position[1], window.position[2]] };
+}

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

@@ -0,0 +1,22 @@
+import type { DoorNode } from '../schema/index.js';
+import { type DoorType } from '../schema/nodes/opening-types.js';
+/** A door type's own size: the door panel's Type row sets it, and add_door takes it when none is given. */
+export declare const DOOR_TYPE_SIZES: Record<DoorType, {
+    width: number;
+    height: number;
+}>;
+type TypeSource = Partial<Pick<DoorNode, 'operationState' | 'slideDirection' | 'garagePanelCount'>>;
+/**
+ * What a door type writes besides its size, for the door panel's Type row and add_door alike: its
+ * leaves, its track and the leaf it comes with (an agent's sliding door had no track, as the agent
+ * set doorType alone).
+ */
+export declare function doorTypeFields(type: DoorType, door?: TypeSource): Partial<DoorNode>;
+/**
+ * The door panel's Type row: the type's fields and size, the door kept on the floor, and a style
+ * the person chose kept (a modern door made sliding stays modern; a plain one made French takes
+ * the French glazing).
+ */
+export declare function doorTypeChange(door: DoorNode, type: DoorType): Partial<DoorNode>;
+export {};
+//# sourceMappingURL=door-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"door-types.d.ts","sourceRoot":"","sources":["../../src/building/door-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,WAAW,CAAA;AACtD,OAAO,EAAE,KAAK,QAAQ,EAAuB,MAAM,+BAA+B,CAAA;AAGlF,2GAA2G;AAC3G,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAW/E,CAAA;AAuCD,KAAK,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,CAAC,CAAA;AAEnG;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuFvF;AAcD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAUhF"}