@pascal-app/core 1.0.3 → 1.0.5

package/dist/building/merge-windows.js

@@ -0,0 +1,189 @@
+import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { CORNER_REACH_M, cornerAngle, cornerLinkClears, cornerPair, fusesAtCorner, isWrappableAngle, wallEndPoint, wallLengthOf, windowEndGap, } from '../lib/corner-pair.js';
+import { findWallChildOverlap, resolveWallOpeningCeiling } from './wall-openings.js';
+/** The widest gap between two windows on one wall that still merges them (m). */
+export const MERGE_GAP_M = 0.3;
+/** What two windows share on a corner window: the second takes the first's. */
+const SHARED = [
+    'height',
+    'windowType',
+    'frameThickness',
+    'frameDepth',
+    'sill',
+    'sillDepth',
+    'sillThickness',
+];
+const metres = (value) => `${value.toFixed(2)} m`;
+const round = (value) => Math.round(value * 100) / 100;
+function windowOf(nodes, id) {
+    const node = nodes[id];
+    if (!node)
+        refuse('window_not_found', `Window not found: ${id}.`, { windowId: id });
+    if (node.type !== 'window')
+        refuse('not_a_window', `Node ${id} is a ${node.type}, not a window.`, {
+            windowId: id,
+            type: node.type,
+        });
+    const window = node;
+    const wall = nodes[window.parentId ?? ''];
+    if (wall?.type !== 'wall')
+        refuse('window_not_on_wall', `Window ${id} is not on a straight wall (a roof or dormer window), so it cannot join another.`, { windowId: id });
+    return { window, wall: wall };
+}
+const sillOf = (window) => window.position[1] - window.height / 2;
+const headOf = (window) => window.position[1] + window.height / 2;
+/** The shared point of two walls' ends, with the end of each there; null when they share none. */
+function sharedCorner(a, b) {
+    for (const endA of ['start', 'end'])
+        for (const endB of ['start', 'end']) {
+            const [p, q] = [wallEndPoint(a, endA), wallEndPoint(b, endB)];
+            if (Math.hypot(p[0] - q[0], p[1] - q[1]) <= 1e-3)
+                return { endA, endB, point: p };
+        }
+    return null;
+}
+/**
+ * The plan to merge two windows, or a refusal that says why. Pure: `changes` is for the caller to
+ * apply (the editor's store, an agent operation's `SceneChanges`).
+ */
+export function mergeWindows(nodes, firstId, secondId) {
+    if (firstId === secondId)
+        refuse('same_window', 'Pick two different windows to merge.');
+    const first = windowOf(nodes, firstId);
+    const second = windowOf(nodes, secondId);
+    for (const [mine, other] of [
+        [first.window, second.window],
+        [second.window, first.window],
+    ]) {
+        const partnerId = cornerPair(nodes, mine)?.partner.id;
+        if (partnerId === other.id)
+            refuse('windows_already_joined', `${mine.id} and ${other.id} already wrap this corner.`, {
+                windowIds: [mine.id, other.id],
+            });
+        if (partnerId)
+            refuse('window_already_joined', `Window ${mine.id} already wraps a corner with ${partnerId}; unwrap it before joining it to ${other.id}.`, { windowId: mine.id, partnerId });
+    }
+    return first.wall.id === second.wall.id
+        ? mergeOnOneWall(nodes, first, second)
+        : mergeAtCorner(nodes, first, second);
+}
+/** The links the merged windows' old, broken pairs leave on windows other than these two. */
+function brokenLinkClears(nodes, ...windows) {
+    const ids = new Set(windows.map((window) => window.id));
+    return windows
+        .flatMap((window) => cornerLinkClears(nodes, window.id))
+        .filter(({ id }) => !ids.has(id))
+        .map(({ id, data }) => ({ id: id, data: data }));
+}
+function mergeOnOneWall(nodes, first, second) {
+    const wall = first.wall;
+    const [a, b] = [first.window, second.window];
+    const [leftOf, rightOf] = a.position[0] <= b.position[0] ? [a, b] : [b, a];
+    const gap = rightOf.position[0] - rightOf.width / 2 - (leftOf.position[0] + leftOf.width / 2);
+    if (gap > MERGE_GAP_M + 1e-9)
+        refuse('windows_not_adjacent', `${a.id} and ${b.id} are ${metres(gap)} apart on wall ${wall.id}; windows join when at most ${metres(MERGE_GAP_M)} separates them.`, { windowIds: [a.id, b.id], gap, limit: MERGE_GAP_M });
+    // The union of the two: a window inside the other, or wider than it, does not shrink it.
+    const outerLeft = Math.min(a.position[0] - a.width / 2, b.position[0] - b.width / 2);
+    const outerRight = Math.max(a.position[0] + a.width / 2, b.position[0] + b.width / 2);
+    const bottom = Math.min(sillOf(a), sillOf(b));
+    const top = Math.max(headOf(a), headOf(b));
+    const centre = [(outerLeft + outerRight) / 2, (bottom + top) / 2];
+    const between = findWallChildOverlap(wall.id, nodes, centre[0], centre[1], outerRight - outerLeft, top - bottom, [a.id, b.id]);
+    if (between)
+        refuse('opening_between', `${between.type === 'item' ? 'An item' : `A ${between.type}`}, ${between.id}, sits between ${a.id} and ${b.id} on wall ${wall.id}, so they cannot become one window.`, { windowIds: [a.id, b.id], blockingId: between.id });
+    const width = outerRight - outerLeft;
+    return {
+        kind: 'same-wall',
+        windowIds: [a.id],
+        removedIds: [b.id],
+        wallIds: [wall.id],
+        sillHeight: bottom,
+        height: top - bottom,
+        width,
+        changes: {
+            update: [
+                {
+                    id: a.id,
+                    data: {
+                        width,
+                        height: top - bottom,
+                        position: [centre[0], centre[1], a.position[2]],
+                        ...(a.corner ? { corner: undefined } : {}),
+                    },
+                },
+                ...brokenLinkClears(nodes, a, b),
+            ],
+            delete: [b.id],
+        },
+        message: `Merged ${b.id} into ${a.id}: one window ${metres(width)} wide on wall ${wall.id}, from a sill of ${metres(bottom)} to ${metres(top)}. Its type and style are ${a.id}'s, the window named first.`,
+    };
+}
+function mergeAtCorner(nodes, first, second) {
+    const [a, b] = [first.window, second.window];
+    const joint = sharedCorner(first.wall, second.wall);
+    if (!joint || first.wall.parentId !== second.wall.parentId)
+        refuse('walls_not_meeting', `Wall ${first.wall.id} and wall ${second.wall.id} do not meet at a corner, so ${a.id} and ${b.id} cannot wrap one. On one wall, windows side by side merge instead.`, { wallIds: [first.wall.id, second.wall.id] });
+    const angle = cornerAngle({ wall: first.wall, end: joint.endA }, { wall: second.wall, end: joint.endB });
+    if (!isWrappableAngle(angle))
+        refuse('corner_angle', `The walls meet at ${Math.round(angle)}°: too close to ${angle < 90 ? 'folded back' : 'straight'} for a corner window.`, { angle });
+    const sides = [
+        { ...first, end: joint.endA },
+        { ...second, end: joint.endB },
+    ];
+    for (const { window, wall, end } of sides) {
+        const gap = windowEndGap(wall, window, end);
+        if (gap > CORNER_REACH_M + 1e-9)
+            refuse('window_not_at_corner', `Window ${window.id} is ${metres(gap)} from the corner of wall ${wall.id}; a window joins a corner window when it is within ${metres(CORNER_REACH_M)} of the corner.`, { windowId: window.id, gap, limit: CORNER_REACH_M });
+    }
+    const ceiling = resolveWallOpeningCeiling(second.wall, nodes);
+    if (headOf(a) > ceiling + 1e-6)
+        refuse('height_exceeds_wall', `Window ${a.id} is taller than wall ${second.wall.id} (${metres(headOf(a))} against ${metres(ceiling)}), so ${b.id} cannot take its height and sill. Name the other window first, or lower ${a.id}.`, { windowId: b.id, wallId: second.wall.id });
+    // Each side slides to the corner, keeping its width, if no other opening is in the way.
+    const post = fusesAtCorner(a) ? 'none' : 'post';
+    const centreAt = (window, wall, end) => end === 'start' ? window.width / 2 : wallLengthOf(wall) - window.width / 2;
+    const placed = sides.map(({ window, wall, end }, index) => {
+        const x = centreAt(window, wall, end);
+        const y = a.position[1];
+        const blocking = findWallChildOverlap(wall.id, nodes, x, y, window.width, a.height, window.id);
+        if (blocking)
+            refuse('opening_overlap', `Sliding ${window.id} to the corner of wall ${wall.id} would overlap ${blocking.type} ${blocking.id}.`, { windowId: window.id, blockingId: blocking.id });
+        const corner = { end, partnerId: sides[1 - index].window.id, post };
+        const aligned = index === 0
+            ? {}
+            : Object.fromEntries(SHARED.map((key) => [key, a[key]]).filter(([, v]) => v !== undefined));
+        return {
+            id: window.id,
+            data: { ...aligned, position: [x, y, window.position[2]], corner },
+        };
+    });
+    return {
+        kind: 'corner',
+        windowIds: [a.id, b.id],
+        removedIds: [],
+        wallIds: [first.wall.id, second.wall.id],
+        sillHeight: sillOf(a),
+        height: a.height,
+        angle: round(angle),
+        changes: { update: [...placed, ...brokenLinkClears(nodes, a, b)], delete: [] },
+        message: `Joined ${a.id} and ${b.id} as one corner window across ${first.wall.id} and ${second.wall.id} (${Math.round(angle)}°), ${post === 'none' ? 'the glass fused at the corner' : `the ${a.windowType} frames meeting at the corner`}. Both take ${a.id}'s height and sill (${metres(a.height)} tall from ${metres(sillOf(a))}) and type, as it was named first.`,
+    };
+}
+/**
+ * What the Merge windows button does for a selection: nothing unless exactly two windows are
+ * selected; otherwise the merge they would make, or the refusal, whose code and details the panel
+ * words for a person (its message is written for agents, with node ids and metres).
+ */
+export function windowMergeOffer(nodes, selectedIds) {
+    if (selectedIds.length !== 2)
+        return null;
+    if (selectedIds.some((id) => nodes[id]?.type !== 'window'))
+        return null;
+    try {
+        return { merge: mergeWindows(nodes, selectedIds[0], selectedIds[1]), refusal: null };
+    }
+    catch (error) {
+        if (isAgentRefusal(error))
+            return { merge: null, refusal: error };
+        throw error;
+    }
+}

package/dist/building/opening-style-presets.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Style presets for doors and windows: what a door's leaf or a window's panes look like, never how
+ * it opens (doorType, windowType) or its size. `add_door`, `add_window` and `create_room`'s
+ * doors[] / windows[] apply them by name; the door and window panels show them as their Style row
+ * and read a node's style back from its fields.
+ */
+import type { DoorSegment } from '../schema/index.js';
+export declare const DOOR_STYLES: readonly ['panel', 'glass', 'modern', 'paneled-glass', 'french', 'shaker', 'six-panel', 'craftsman', 'half-louvered', 'barn'];
+export type DoorStyle = (typeof DOOR_STYLES)[number];
+export declare const DOOR_STYLE_DESCRIPTIONS: Record<DoorStyle, string>;
+/** The Style row's labels; the stored and agent value is the style itself. */
+export declare const DOOR_STYLE_LABELS: Record<DoorStyle, string>;
+/** Every field a door style owns. */
+export type DoorStyleLook = {
+    segments: DoorSegment[];
+    contentPadding: [number, number];
+};
+/**
+ * A door style's whole look: applied, it replaces the last style's (a panel door after a modern one
+ * gets its margin back), and the panel reads a style back by these fields alone.
+ */
+export declare function doorStyleLook(style: DoorStyle): DoorStyleLook;
+/** The styles a door's leaf is, in list order: none for a leaf made by hand (the panel's Custom). */
+export declare function doorStylesOf(door: DoorStyleLook): DoorStyle[];
+export declare const WINDOW_STYLES: readonly ['single', 'double-hung', 'triple-hung', 'casement', 'sliding', 'grid', 'tall-grid', 'wide-grid', 'horizontal-bands', 'transom', 'picture'];
+export type WindowStyle = (typeof WINDOW_STYLES)[number];
+/**
+ * The styles the panel's Style row and the window tool's L chip offer: one per look. 'picture'
+ * draws what 'single' draws, so it is not offered; agents may still ask for it (an alias).
+ */
+export declare const WINDOW_STYLE_CHOICES: readonly WindowStyle[];
+export declare const WINDOW_STYLE_DESCRIPTIONS: Record<WindowStyle, string>;
+/** The Style row's labels; the stored and agent value is the style itself. */
+export declare const WINDOW_STYLE_LABELS: Record<WindowStyle, string>;
+interface WindowStyleOverrides {
+    columnRatios?: number[];
+    rowRatios?: number[];
+}
+export declare function getWindowStyleOverrides(style: WindowStyle | undefined): WindowStyleOverrides;
+/** The style a window's panes are, as the panel offers it: one per look, none for panes set by hand. */
+export declare function windowStylesOf(window: {
+    columnRatios: number[];
+    rowRatios: number[];
+}): WindowStyle[];
+export {};
+//# sourceMappingURL=opening-style-presets.d.ts.map

package/dist/building/opening-style-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-style-presets.d.ts","sourceRoot":"","sources":["../../src/building/opening-style-presets.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAK5C,eAAO,MAAM,WAAW,YACtB,OAAO,EACP,OAAO,EACP,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,WAAW,EACX,eAAe,EACf,MAAM,CACE,CAAA;AACV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpD,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAW7D,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAWvD,CAAA;AAED,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AA4BzF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAiC7D;AAaD,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,CAG7D;AAID,eAAO,MAAM,aAAa,YACxB,QAAQ,EACR,aAAa,EACb,aAAa,EACb,UAAU,EACV,SAAS,EACT,MAAM,EACN,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,SAAS,CACD,CAAA;AACV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,WAAW,EAEtD,CAAA;AAED,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAYjE,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAY3D,CAAA;AAED,UAAU,oBAAoB;IAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,oBAAoB,CAiC5F;AAED,wGAAwG;AACxG,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,GAAG,WAAW,EAAE,CAKhB"}

package/dist/building/opening-style-presets.js

@@ -0,0 +1,195 @@
+/**
+ * Style presets for doors and windows: what a door's leaf or a window's panes look like, never how
+ * it opens (doorType, windowType) or its size. `add_door`, `add_window` and `create_room`'s
+ * doors[] / windows[] apply them by name; the door and window panels show them as their Style row
+ * and read a node's style back from its fields.
+ */
+import { DEFAULT_DOOR_CONTENT_PADDING, defaultDoorSegments } from '../schema/nodes/opening-types.js';
+// ── Doors ────────────────────────────────────────────────────────────────────
+export const DOOR_STYLES = [
+    'panel',
+    'glass',
+    'modern',
+    'paneled-glass',
+    'french',
+    'shaker',
+    'six-panel',
+    'craftsman',
+    'half-louvered',
+    'barn',
+];
+export const DOOR_STYLE_DESCRIPTIONS = {
+    panel: 'Classic raised-panel door (default).',
+    glass: 'Mostly glass; modern interior or patio door.',
+    modern: 'Flat slab, no panels, no glass — minimalist look.',
+    'paneled-glass': 'Glass top, panel bottom — common entry door.',
+    french: 'Two narrow vertical glass leaves — French door look.',
+    shaker: 'Single flat panel with a clean inset — minimalist.',
+    'six-panel': 'Classic 6-panel (3 rows × 2 columns) — traditional interior.',
+    craftsman: '4 narrow vertical raised panels stacked — craftsman style.',
+    'half-louvered': 'Top half horizontal slats, bottom half panel — closet / laundry.',
+    barn: 'Wide single recessed panel — sliding-barn look.',
+};
+/** The Style row's labels; the stored and agent value is the style itself. */
+export const DOOR_STYLE_LABELS = {
+    panel: 'Panel',
+    glass: 'Glass',
+    modern: 'Modern',
+    'paneled-glass': 'Paneled glass',
+    french: 'French',
+    shaker: 'Shaker',
+    'six-panel': 'Six-panel',
+    craftsman: 'Craftsman',
+    'half-louvered': 'Half-louvered',
+    barn: 'Barn',
+};
+const PANEL_DIVIDER = 0.03;
+const PANEL_DEPTH = 0.01;
+const PANEL_INSET = 0.04;
+function panelSegment(type, heightRatio, columnRatios = [1], overrides = {}) {
+    return {
+        type,
+        heightRatio,
+        columnRatios,
+        dividerThickness: PANEL_DIVIDER,
+        panelDepth: PANEL_DEPTH,
+        panelInset: PANEL_INSET,
+        ...overrides,
+    };
+}
+const look = (segments, contentPadding = DEFAULT_DOOR_CONTENT_PADDING) => ({ segments, contentPadding: [...contentPadding] });
+/**
+ * A door style's whole look: applied, it replaces the last style's (a panel door after a modern one
+ * gets its margin back), and the panel reads a style back by these fields alone.
+ */
+export function doorStyleLook(style) {
+    switch (style) {
+        case 'panel':
+            return look(defaultDoorSegments());
+        case 'glass':
+            return look([panelSegment('glass', 1)]);
+        case 'modern':
+            // A flush slab: one panel over the whole leaf. An 'empty' segment is no leaf at all (a front
+            // door once rendered as an open frame).
+            return look([panelSegment('panel', 1, [1], { panelDepth: 0, panelInset: 0 })], [0, 0]);
+        case 'paneled-glass':
+            return look([panelSegment('glass', 0.55), panelSegment('panel', 0.45)]);
+        case 'french':
+            return look([panelSegment('glass', 1, [0.5, 0.5])]);
+        case 'shaker':
+            return look([panelSegment('panel', 1, [1], { panelDepth: -0.005, panelInset: 0.06 })]);
+        case 'six-panel':
+            return look([0.34, 0.33, 0.33].map((ratio) => panelSegment('panel', ratio, [0.5, 0.5])));
+        case 'craftsman':
+            return look([0.25, 0.25, 0.25, 0.25].map((ratio) => panelSegment('panel', ratio)));
+        case 'half-louvered':
+            // Slats as narrow raised bars on the top half: an 'empty' row would be a hole in the leaf.
+            // The door system always raises a panel by |panelDepth|, so a slat reads only when it is
+            // deep and narrow against its gap: ten bars about 7 cm tall, 2.2 cm proud, 2.8 cm apart.
+            return look([
+                ...Array.from({ length: 10 }, () => panelSegment('panel', 0.5 / 10, [1], { panelDepth: 0.022, panelInset: 0.014 })),
+                panelSegment('panel', 0.5),
+            ]);
+        case 'barn':
+            return look([panelSegment('panel', 1, [1], { panelDepth: -0.02, panelInset: 0.08 })]);
+    }
+}
+const same = (a, b) => {
+    if (typeof a === 'number' && typeof b === 'number')
+        return Math.abs(a - b) < 1e-6;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((value, i) => same(value, b[i]));
+    if (a && b && typeof a === 'object' && typeof b === 'object')
+        return Object.keys({ ...a, ...b }).every((key) => same(a[key], b[key]));
+    return a === b;
+};
+/** The styles a door's leaf is, in list order: none for a leaf made by hand (the panel's Custom). */
+export function doorStylesOf(door) {
+    const { segments, contentPadding } = door;
+    return DOOR_STYLES.filter((style) => same(doorStyleLook(style), { segments, contentPadding }));
+}
+// ── Windows ──────────────────────────────────────────────────────────────────
+export const WINDOW_STYLES = [
+    'single',
+    'double-hung',
+    'triple-hung',
+    'casement',
+    'sliding',
+    'grid',
+    'tall-grid',
+    'wide-grid',
+    'horizontal-bands',
+    'transom',
+    'picture',
+];
+/**
+ * The styles the panel's Style row and the window tool's L chip offer: one per look. 'picture'
+ * draws what 'single' draws, so it is not offered; agents may still ask for it (an alias).
+ */
+export const WINDOW_STYLE_CHOICES = WINDOW_STYLES.filter((style) => style !== 'picture');
+export const WINDOW_STYLE_DESCRIPTIONS = {
+    single: 'Single pane with a frame — simplest look (default).',
+    'double-hung': 'Two stacked sashes — classic American style.',
+    'triple-hung': 'Three stacked sashes — taller and slimmer.',
+    casement: 'Two side-by-side panes — vertical mullion.',
+    sliding: 'Three side-by-side panes — wide / sliding-door look.',
+    grid: '2×2 grid of panes — colonial / cottage style.',
+    'tall-grid': '2 columns × 3 rows — taller proportions.',
+    'wide-grid': '3 columns × 2 rows — wider proportions.',
+    'horizontal-bands': '4 stacked horizontal bands — modernist strip window.',
+    transom: 'Short row on top + larger pane below — transom over a base.',
+    picture: "Alias of 'single': one pane, no internal divisions.",
+};
+/** The Style row's labels; the stored and agent value is the style itself. */
+export const WINDOW_STYLE_LABELS = {
+    single: 'Single',
+    'double-hung': 'Double-hung',
+    'triple-hung': 'Triple-hung',
+    casement: 'Casement',
+    sliding: 'Sliding',
+    grid: 'Grid',
+    'tall-grid': 'Tall grid',
+    'wide-grid': 'Wide grid',
+    'horizontal-bands': 'Horizontal bands',
+    transom: 'Transom',
+    picture: 'Picture',
+};
+export function getWindowStyleOverrides(style) {
+    if (!style || style === 'single' || style === 'picture') {
+        return { columnRatios: [1], rowRatios: [1] };
+    }
+    if (style === 'double-hung') {
+        return { columnRatios: [1], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'triple-hung') {
+        return { columnRatios: [1], rowRatios: [1 / 3, 1 / 3, 1 / 3] };
+    }
+    if (style === 'casement') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [1] };
+    }
+    if (style === 'sliding') {
+        return { columnRatios: [1 / 3, 1 / 3, 1 / 3], rowRatios: [1] };
+    }
+    if (style === 'grid') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'tall-grid') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [1 / 3, 1 / 3, 1 / 3] };
+    }
+    if (style === 'wide-grid') {
+        return { columnRatios: [1 / 3, 1 / 3, 1 / 3], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'horizontal-bands') {
+        return { columnRatios: [1], rowRatios: [0.25, 0.25, 0.25, 0.25] };
+    }
+    if (style === 'transom') {
+        // Smaller transom row on top, larger main pane below.
+        return { columnRatios: [1], rowRatios: [0.3, 0.7] };
+    }
+    return {};
+}
+/** The style a window's panes are, as the panel offers it: one per look, none for panes set by hand. */
+export function windowStylesOf(window) {
+    const { columnRatios, rowRatios } = window;
+    return WINDOW_STYLE_CHOICES.filter((style) => same(getWindowStyleOverrides(style), { columnRatios, rowRatios }));
+}

package/dist/building/photo-elevation.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Straightening a photo of a flat face: the plane-to-plane perspective transform (a homography)
+ * between metres on the face and pixels in the photo, and the warp that draws the face head-on.
+ * Several faces of one photo share its camera: the vanishing points of their lines give its focal
+ * length and rotation, and each face's homography is K·[along up origin].
+ * Pure over numbers and RGBA buffers, so the chat (canvas) and the MCP (any codec) share it.
+ */
+type Pt = [number, number];
+type Segment = readonly [Pt, Pt];
+export type Vec3 = [number, number, number];
+/**
+ * Row-major 3 × 3. A fitted one has `h[8]` normalised to 1; a camera's keeps its third row as the
+ * depth in metres, positive in front of the camera.
+ */
+export type Homography = number[];
+export type RgbaImage = {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+export declare function applyHomography(h: Homography, [x, y]: Pt): Pt | null;
+export declare function multiplyHomography(a: Homography, b: Homography): Homography;
+export declare function invertHomography(h: Homography): Homography | null;
+/**
+ * The homography taking each `from` to its `to`, fitted over all pairs by least squares on
+ * conditioned coordinates, so one point picked a few pixels off moves the fit, not breaks it.
+ * Null for fewer than four pairs or points that do not span the plane.
+ */
+export declare function solveHomography(pairs: readonly {
+    from: Pt;
+    to: Pt;
+}[]): Homography | null;
+/** Where the lines through `a` and through `b` cross; null when they are parallel. */
+export declare function lineIntersection(a: readonly [Pt, Pt], b: readonly [Pt, Pt]): Pt | null;
+type PhotoSize = {
+    width: number;
+    height: number;
+};
+/**
+ * Where lines that are parallel on the building meet in the photo: their vanishing point, as a unit
+ * homogeneous point (x, y, w) about the photo's centre with its longer side as unit, so lines
+ * parallel in the photo give w = 0 (a point at infinity) instead of a division by zero. Least
+ * squares over all the lines, each weighted by its length. Null for fewer than two distinct lines.
+ */
+export declare function vanishingPoint(segments: readonly Segment[], photo: PhotoSize): Vec3 | null;
+/** Root mean square distance, in photo pixels, of each segment's ends from the line through its middle and `direction`'s vanishing point. */
+export declare function vanishingResidualPx(camera: PhotoCamera, direction: Vec3, segments: readonly Segment[]): number;
+/**
+ * The photo's camera: square pixels, no skew, no lens distortion (straight lines stay straight).
+ * The principal point is at the photo's centre across; its height is fitted, since a
+ * perspective-corrected or shift photo keeps verticals parallel by moving it toward the horizon.
+ */
+export type PhotoCamera = {
+    width: number;
+    height: number;
+    /** Focal length, in photo pixels. */
+    focal: number;
+    /** Where the optical axis meets the photo, in photo pixels. */
+    centre: Pt;
+    /** World up, in camera coordinates: x right, y down, z forward. */
+    up: Vec3;
+};
+/** A face's axes in camera coordinates: along it left to right as seen, up, and out toward the camera. */
+export type FaceAxes = {
+    along: Vec3;
+    up: Vec3;
+    normal: Vec3;
+};
+/** A face's plane: its axes, and `normal · P` of its points, negative since it faces the camera. */
+export type CameraFace = FaceAxes & {
+    distance: number;
+};
+export type CameraFailure = 'needs_second_direction' | 'at_infinity' | 'unsolved';
+/**
+ * The photo's camera from vanishing points (from `vanishingPoint`): the vertical one when the
+ * verticals were picked, one per face, and which faces meet at a right angle. First the focal
+ * length and the principal point's height (`focalAndCentre`), then the rotation: up from the
+ * verticals (or across two faces), each face's direction from its vanishing point, made level, and
+ * turned so the face looks at the camera (`probe` is a photo pixel on it). `focalSpread` is the
+ * ratio between the largest and the smallest focal length the well-placed pairs give on their own:
+ * 1 when they agree.
+ */
+export declare function solvePhotoCamera(input: {
+    photo: PhotoSize;
+    vertical: Vec3 | null;
+    faces: readonly {
+        vanishing: Vec3;
+        probe: Pt;
+    }[];
+    perpendicular: readonly (readonly [number, number])[];
+}): {
+    camera: PhotoCamera;
+    faces: FaceAxes[];
+    focalSpread: number;
+} | {
+    failure: CameraFailure;
+};
+/** The ray from the camera through a photo pixel, in camera coordinates (its depth is 1). */
+export declare function photoRay(camera: PhotoCamera, [x, y]: Pt): Vec3;
+/** Where a photo pixel's ray meets a face's plane, in camera coordinates; null behind the camera. */
+export declare function pointOnFace(camera: PhotoCamera, face: CameraFace, pixel: Pt): Vec3 | null;
+/** A photo pixel's place on a face, (along, up) in the face's units, from where its normal meets it. */
+export declare function faceCoordinates(camera: PhotoCamera, face: CameraFace, pixel: Pt): Pt | null;
+/**
+ * The plane of a face from the camera and its two vertical edges `width` apart (the walls' extent):
+ * the one distance that puts them so far apart. Null when the edges come out the wrong way round.
+ */
+export declare function faceAtWidth(camera: PhotoCamera, axes: FaceAxes, edges: {
+    left: readonly Pt[];
+    right: readonly Pt[];
+}, width: number): CameraFace | null;
+/** The plane of a face through the corner it shares with another: `corner` is that edge's pixels. */
+export declare function faceThroughCorner(camera: PhotoCamera, axes: FaceAxes, other: CameraFace, corner: readonly Pt[]): CameraFace | null;
+/**
+ * Metres on a face, from `origin` (its face coordinates), to photo pixels: K·[along up origin].
+ * Its third row is the depth in metres, so a point behind the camera has w < 0.
+ */
+export declare function cameraFaceHomography(camera: PhotoCamera, face: CameraFace, origin: Pt): Homography;
+/**
+ * An image `width` × `height` whose every pixel samples `src` (bilinear) where `toSource` maps
+ * its centre. What falls outside the source stays transparent.
+ */
+export declare function warpImage(src: RgbaImage, toSource: Homography, width: number, height: number): RgbaImage;
+export {};
+//# sourceMappingURL=photo-elevation.d.ts.map

package/dist/building/photo-elevation.d.ts.map

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