@pascal-app/core 1.0.1 → 1.0.4

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":"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"}

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

@@ -0,0 +1,307 @@
+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] } },
+    },
+    // 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 },
+    },
+    {
+        name: 'a window sits on a 0.9 m sill by default',
+        tool: 'add_window',
+        input: { wallId: main, t: 0.5 },
+        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.65, 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/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"}

package/dist/building/door-types.js

@@ -0,0 +1,167 @@
+import { defaultDoorSegments } from '../schema/nodes/opening-types.js';
+import { doorStyleLook, doorStylesOf } from './opening-style-presets.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 const DOOR_TYPE_SIZES = {
+    hinged: { width: 0.9, height: 2.1 },
+    double: { width: 1.5, height: 2.1 },
+    french: { width: 1.5, height: 2.1 },
+    folding: { width: 1.8, height: 2.1 },
+    pocket: { width: 0.9, height: 2.1 },
+    barn: { width: 1, height: 2.1 },
+    sliding: { width: 1.5, height: 2.1 },
+    'garage-sectional': { width: 2.7, height: 2.4 },
+    'garage-rollup': { width: 2.7, height: 2.4 },
+    'garage-tiltup': { width: 2.7, height: 2.4 },
+};
+const frenchSegments = () => [
+    {
+        type: 'glass',
+        heightRatio: 0.76,
+        columnRatios: [1, 1],
+        dividerThickness: 0.025,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+    {
+        type: 'panel',
+        heightRatio: 0.24,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.012,
+        panelInset: 0.035,
+    },
+];
+const foldingSegments = () => [
+    {
+        type: 'panel',
+        heightRatio: 1,
+        columnRatios: [1],
+        dividerThickness: 0.02,
+        panelDepth: 0.008,
+        panelInset: 0.025,
+    },
+];
+const segmentsOf = (type) => type === 'hinged' || type === 'double'
+    ? defaultDoorSegments()
+    : type === 'french' || type === 'sliding'
+        ? frenchSegments()
+        : foldingSegments();
+/**
+ * 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 function doorTypeFields(type, door = {}) {
+    const segments = segmentsOf(type);
+    const sliding = {
+        leafCount: 1,
+        openingShape: 'rectangle',
+        handle: true,
+        handleSide: 'right',
+        slideDirection: door.slideDirection ?? 'left',
+        operationState: door.operationState ?? 0,
+        threshold: false,
+        contentPadding: [0.035, 0.045],
+    };
+    const garage = {
+        doorCategory: 'garage',
+        leafCount: 1,
+        handle: false,
+        threshold: false,
+        openingShape: 'rectangle',
+        trackStyle: 'overhead',
+        operationState: 0,
+        garagePanelCount: 4,
+        contentPadding: [0.04, 0.04],
+    };
+    switch (type) {
+        case 'double':
+        case 'french':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                leafCount: 2,
+                handleSide: 'right',
+                segments,
+                ...(type === 'french' ? { contentPadding: [0.045, 0.055] } : {}),
+            };
+        case 'folding':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                leafCount: 4,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'visible',
+                operationState: Math.max(door.operationState ?? 0, 0.65),
+                threshold: false,
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        case 'pocket':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                trackStyle: 'pocket',
+                segments,
+            };
+        case 'barn':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                trackStyle: 'visible',
+                segments,
+            };
+        case 'sliding':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                leafCount: 2,
+                trackStyle: 'visible',
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        case 'garage-sectional':
+            return {
+                ...garage,
+                doorType: type,
+                garagePanelCount: Math.max(3, Math.min(8, door.garagePanelCount ?? 4)),
+                segments,
+            };
+        case 'garage-rollup':
+        case 'garage-tiltup':
+            return { ...garage, doorType: type, segments };
+        case 'hinged':
+            return { doorCategory: 'interior', doorType: type, leafCount: 1, segments, threshold: true };
+    }
+}
+/** The style a door keeps through a type change: one chosen over the leaf its type came with. */
+function chosenStyle(door) {
+    const [style] = doorStylesOf(door);
+    if (!style)
+        return undefined;
+    const own = doorTypeFields(door.doorType, door);
+    const ownPadding = own.contentPadding ?? door.contentPadding;
+    const isOwn = doorStylesOf({ segments: own.segments ?? [], contentPadding: ownPadding }).includes(style);
+    return isOwn ? undefined : style;
+}
+/**
+ * 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 function doorTypeChange(door, type) {
+    const { width, height } = DOOR_TYPE_SIZES[type];
+    const kept = chosenStyle(door);
+    return {
+        ...doorTypeFields(type, door),
+        width,
+        height,
+        position: [door.position[0], height / 2, door.position[2]],
+        ...(kept ? doorStyleLook(kept) : {}),
+    };
+}

package/dist/building/floor-item-fit.d.ts

@@ -0,0 +1,38 @@
+import { type DoorKeepout } from '../agent-operations/door-clearance.js';
+import type { SceneNodes } from '../agent-operations/types.js';
+export type FloorItemRoom = {
+    id: string;
+    name: string;
+    width: number;
+    depth: number;
+};
+export type FloorItemMisfit = {
+    code: 'too_large_for_room';
+    room: FloorItemRoom;
+} | {
+    code: 'blocks_door';
+    room?: FloorItemRoom;
+    doorId: string;
+    /** A spot in the room that clears every door, when there is one. */
+    candidate?: {
+        x: number;
+        z: number;
+        rotationDeg: number;
+    };
+};
+/**
+ * Whether a floor item fits where it stands. An item its room cannot hold in any turn, or one
+ * standing in the space a door needs (as verify_scene's blocked-door check sees it), does not fit.
+ * place_items refuses it, the editor warns. Items overlapping is not a misfit: a chair under its
+ * table and a bed on its rug overlap by design.
+ */
+export declare function floorItemFit(nodes: SceneNodes, item: {
+    levelId: string;
+    x: number;
+    z: number;
+    rotationDeg: number;
+    dimensions: readonly number[] | undefined;
+    /** The level's door keepouts, when the caller already has them. */
+    doors?: DoorKeepout[];
+}): FloorItemMisfit | null;
+//# sourceMappingURL=floor-item-fit.d.ts.map

package/dist/building/floor-item-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-item-fit.d.ts","sourceRoot":"","sources":["../../src/building/floor-item-fit.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAGjB,MAAM,oCAAoC,CAAA;AAG3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAG3D,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtF,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,GACnD;IACE,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,oEAAoE;IACpE,SAAS,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CAC1D,CAAA;AAEL;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE;IACJ,OAAO,EAAE,MAAM,CAAA;IACf,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;IACzC,mEAAmE;IACnE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;CACtB,GACA,eAAe,GAAG,IAAI,CA0CxB"}

package/dist/building/floor-item-fit.js

@@ -0,0 +1,47 @@
+import { collectDoorKeepouts, itemBlocksDoorKeepout, itemPlanAabb, } from '../agent-operations/door-clearance.js';
+import { findValidPlacement } from '../agent-operations/layout-clearance.js';
+import { pointInPolygon, polygonBounds } from '../agent-operations/plan-geometry.js';
+/**
+ * Whether a floor item fits where it stands. An item its room cannot hold in any turn, or one
+ * standing in the space a door needs (as verify_scene's blocked-door check sees it), does not fit.
+ * place_items refuses it, the editor warns. Items overlapping is not a misfit: a chair under its
+ * table and a bed on its rug overlap by design.
+ */
+export function floorItemFit(nodes, item) {
+    const zone = Object.values(nodes).find((node) => node.type === 'zone' &&
+        node.parentId === item.levelId &&
+        node.polygon.length >= 3 &&
+        pointInPolygon([item.x, item.z], node.polygon));
+    const bounds = zone ? polygonBounds(zone.polygon) : undefined;
+    const room = zone &&
+        bounds && {
+        id: zone.id,
+        name: zone.name,
+        width: bounds.maxX - bounds.minX,
+        depth: bounds.maxZ - bounds.minZ,
+    };
+    const [width = 1, , depth = 1] = item.dimensions ?? [1, 1, 1];
+    if (room) {
+        const fits = (a, b) => a <= room.width && b <= room.depth;
+        if (!fits(width, depth) && !fits(depth, width))
+            return { code: 'too_large_for_room', room };
+    }
+    const doors = item.doors ?? collectDoorKeepouts(Object.values(nodes), { levelId: item.levelId });
+    const footprint = itemPlanAabb([item.x, 0, item.z], item.dimensions, (item.rotationDeg * Math.PI) / 180);
+    const door = doors.find((keepout) => itemBlocksDoorKeepout(footprint, keepout));
+    if (!door)
+        return null;
+    const { candidate } = findValidPlacement({
+        primary: { x: item.x, z: item.z, rotationDeg: item.rotationDeg },
+        dimensions: item.dimensions,
+        doorKeepouts: doors.map((keepout) => keepout.aabb),
+        occupied: [],
+        roomBounds: bounds,
+    });
+    return {
+        code: 'blocks_door',
+        ...(room ? { room } : {}),
+        doorId: door.doorId,
+        ...(candidate ? { candidate } : {}),
+    };
+}

package/dist/building/index.d.ts

@@ -0,0 +1,7 @@
+export * from './door-types.js';
+export * from './floor-item-fit.js';
+export * from './level-duplication.js';
+export * from './opening-style-presets.js';
+export * from './wall-openings.js';
+export * from './window-types.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/building/index.js

@@ -0,0 +1,6 @@
+export * from './door-types.js';
+export * from './floor-item-fit.js';
+export * from './level-duplication.js';
+export * from './opening-style-presets.js';
+export * from './wall-openings.js';
+export * from './window-types.js';