@pascal-app/core 1.0.4 → 1.0.5

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

@@ -1 +1 @@
-{"version":3,"file":"wall-opening-cases.d.ts","sourceRoot":"","sources":["../../../src/building/__fixtures__/wall-opening-cases.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,eAAO,MAAM,aAAa;;;IAGxB,qCAAqC;;IAErC,0CAA0C;;IAE1C,qCAAqC;;IAErC,yEAAyE;;;IAGzE,4BAA4B;;IAE5B,oEAAoE;;IAEpE,iGAAiG;;;IAGjG,4DAA4D;;IAE5D,8FAA8F;;CAEtF,CAAA;AAaV,sFAAsF;AACtF,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C3B;AAED,eAAO,MAAM,qBAAqB,wKASxB,CAAA;AACV,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,GAAG,YAAY,CAAA;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,EACF;QAAE,OAAO,EAAE,kBAAkB,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GACpD;QACE,MAAM,EAAE,MAAM,CAAA;QACd,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,OAAO,CAAA;QAChB,WAAW,CAAC,EAAE,OAAO,CAAA;QACrB,oCAAoC;QACpC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC/B,CAAA;CACN,CAAA;AAiBD,eAAO,MAAM,kBAAkB,EAAE,SAAS,eAAe,EA6MxD,CAAA"}
+{"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

@@ -126,6 +126,40 @@ export const WALL_OPENING_CASES = [
         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',
@@ -187,10 +221,36 @@ export const WALL_OPENING_CASES = [
         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 sits on a 0.9 m sill by default',
+        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.
@@ -198,7 +258,7 @@ export const WALL_OPENING_CASES = [
         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.65, clamped: false },
+        expect: { localX: 2, centerY: 1.25, clamped: false },
     },
     {
         name: 'a style on a window that is not Fixed is refused, naming the Fixed type',

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/ground-level.d.ts

@@ -0,0 +1,26 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+/**
+ * Making `levelId` the building's ground floor, as the level panel's "Set as ground floor" and the
+ * agent's `set_ground_level` do: the building names it (`groundLevelId`), is seated so that level's
+ * floor datum, the top of the foundation, stands over grade as the building's foundation
+ * construction seats it (`GroundSeat.aboveGrade`: 0.203 m on block, by region and style); its
+ * position moves in height, the plan stays where it is, and the
+ * floor indices are renumbered so it is index 0 and the ones under it are the basements. Every
+ * floor keeps its place relative to the others. One change set, one undo step. `null` for an id
+ * that is no level of a building.
+ */
+export declare function buildGroundLevelChanges({ nodes, levelId, }: {
+    nodes: Record<AnyNodeId, AnyNode>;
+    levelId: string;
+}): {
+    buildingId: `building_${string}`;
+    seat: import("../index.js").GroundSeat;
+    moveBy: number;
+    renumbered: boolean;
+    unchanged: boolean;
+    update: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+} | null;
+//# sourceMappingURL=ground-level.d.ts.map

package/dist/building/ground-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-level.d.ts","sourceRoot":"","sources":["../../src/building/ground-level.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA2B,MAAM,WAAW,CAAA;AAG5E;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,OAAO,GACR,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAA;CAChB;;;;;;;YAoC0B,SAAS;cAIvB,OAAO,CAAC,OAAO,CAAC;;SAQ5B"}

package/dist/building/ground-level.js

@@ -0,0 +1,58 @@
+import { groundSeat } from '../lib/ground-seat.js';
+import { getLevelElevations } from '../services/storey.js';
+/**
+ * Making `levelId` the building's ground floor, as the level panel's "Set as ground floor" and the
+ * agent's `set_ground_level` do: the building names it (`groundLevelId`), is seated so that level's
+ * floor datum, the top of the foundation, stands over grade as the building's foundation
+ * construction seats it (`GroundSeat.aboveGrade`: 0.203 m on block, by region and style); its
+ * position moves in height, the plan stays where it is, and the
+ * floor indices are renumbered so it is index 0 and the ones under it are the basements. Every
+ * floor keeps its place relative to the others. One change set, one undo step. `null` for an id
+ * that is no level of a building.
+ */
+export function buildGroundLevelChanges({ nodes, levelId, }) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const buildingId = getLevelElevations(nodes).get(levelId)?.buildingId;
+    const building = buildingId ? nodes[buildingId] : undefined;
+    if (building?.type !== 'building')
+        return null;
+    // Seat against the level asked for, not the one the building names today.
+    const asNamed = {
+        ...nodes,
+        [building.id]: { ...building, groundLevelId: level.id },
+    };
+    const before = groundSeat(nodes, building.id);
+    const seat = groundSeat(asNamed, building.id);
+    if (!seat)
+        return null;
+    const [x, y, z] = building.position;
+    // Micrometres: the seat is measured through sums of storey heights, and a stored height keeps no noise.
+    const moveBy = seat.atFoundationTop ? 0 : Math.round((seat.aboveGrade - seat.offset) * 1e6) / 1e6;
+    const shift = level.level;
+    const renumbered = Object.values(nodes).filter((node) => node.type === 'level' &&
+        shift !== 0 &&
+        getLevelElevations(nodes).get(node.id)?.buildingId === building.id);
+    const unchanged = before?.explicit === true && before.levelId === level.id && seat.atFoundationTop && shift === 0;
+    return {
+        buildingId: building.id,
+        seat,
+        moveBy,
+        renumbered: renumbered.length > 0,
+        unchanged,
+        update: [
+            {
+                id: building.id,
+                data: {
+                    groundLevelId: level.id,
+                    position: [x, Math.round((y + moveBy) * 1e6) / 1e6, z],
+                },
+            },
+            ...renumbered.map((other) => ({
+                id: other.id,
+                data: { level: other.level - shift },
+            })),
+        ],
+    };
+}

package/dist/building/index.d.ts

@@ -1,7 +1,12 @@
+export * from './corner-window.js';
 export * from './door-types.js';
 export * from './floor-item-fit.js';
+export { buildGroundLevelChanges } from './ground-level.js';
 export * from './level-duplication.js';
+export { buildLevelBelowChanges } from './level-insertion.js';
+export * from './merge-windows.js';
 export * from './opening-style-presets.js';
+export { type RgbaImage, warpImage } from './photo-elevation.js';
 export * from './wall-openings.js';
 export * from './window-types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/building/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/building/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/building/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AACxD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,KAAK,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7D,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA"}

package/dist/building/index.js

@@ -1,6 +1,11 @@
+export * from './corner-window.js';
 export * from './door-types.js';
 export * from './floor-item-fit.js';
+export { buildGroundLevelChanges } from './ground-level.js';
 export * from './level-duplication.js';
+export { buildLevelBelowChanges } from './level-insertion.js';
+export * from './merge-windows.js';
 export * from './opening-style-presets.js';
+export { warpImage } from './photo-elevation.js';
 export * from './wall-openings.js';
 export * from './window-types.js';