@pascal-app/core 1.0.5 → 1.0.7

package/dist/agent-operations/furniture-kind.js

@@ -1,3 +1,4 @@
+import { foldRoomName } from '../building/room-use.js';
 import { getScaledDimensions, LOW_PROFILE_ITEM_SURFACE_MAX_HEIGHT } from '../schema/index.js';
 const read = (asset) => `${asset.id} ${asset.name ?? ''}`.toLowerCase().replace(/[_]+/g, ' ');
 /** An armchair is a free-standing seat of the living group, not a chair of a table. */
@@ -9,13 +10,36 @@ const BEDSIDE = /bedside|night ?stand/;
 const WALKED_AROUND = /(?:^|[^a-z])(?:island|peninsula|bar)(?![a-z])|utensil/;
 const FREE = /table|rug|carpet|plant|lamp|ottoman|pouf/;
 const WALL = /fridge|refrigerator|counter|kitchen|stove|oven|cooktop|sink|tv[ -]?(?:stand|unit)|television|dresser|wardrobe|closet|sofa|couch|loveseat|(?:^|[^a-z])bed(?![a-z])|toilet|bath|shower|bookcase|bookshelf|cabinet|washing|washer|dryer|coat/;
-/** Only a named, flat floor covering is nonblocking, never an arbitrary short solid or low top surface. */
+/** What the catalogue (or the agent) filed a floor covering under, English or French, folded. */
+const RUG_CATEGORY = /^(?:rugs?|carpets?|tapis|(?:floor|parking)[ -]?mats?)$/;
+/** The words that name one when the category says nothing: the asset's id and name, folded. */
+const RUG_WORD = /(?:^|[^a-z])(?:rugs?|carpets?|tapis|(?:floor|parking)[ -]?mats?)(?![a-z])/;
+/** What the catalogue (or the agent) filed a vehicle under, English or French, folded. */
+const VEHICLE_CATEGORY = /^(?:vehicles?|cars?|automobiles?|voitures?)$/;
+/** The words that name one when the category says nothing: the asset's id and name, folded. */
+const VEHICLE_WORD = /(?:^|[^a-z])(?:cars?|hatchbacks?|sedans?|suvs?|utes?|vehicles?|voitures?)(?![a-z])/;
+/**
+ * A car, a ute: filed as a vehicle, or named as one when nothing is filed. What stands in a garage
+ * to be driven out of it, so the garage door's opening is its way and not a thing it obstructs.
+ */
+export function isVehicle(item) {
+    const category = foldRoomName(item.asset.category ?? '');
+    if (category)
+        return VEHICLE_CATEGORY.test(category);
+    return VEHICLE_WORD.test(foldRoomName(read(item.asset)));
+}
+/**
+ * Only a flat floor covering is nonblocking, never an arbitrary short solid or low top surface. It is
+ * a rug by what it is filed under (its category: "rug", "rugs", "tapis"), else by what it is called
+ * in English or French, and in both cases it must lie flat on the floor.
+ */
 export function isFloorUnderlay(item) {
-    const text = read(item.asset);
-    if (!/(?:^|[^a-z])(?:rug|carpet|(?:floor|parking)[ -]?mat)(?![a-z])/.test(text) ||
-        WALL.test(text) ||
-        CHAIR.test(text) ||
-        /table|desk|ottoman|pouf/.test(text) ||
+    const category = foldRoomName(item.asset.category ?? '');
+    const filedAsRug = RUG_CATEGORY.test(category);
+    const text = foldRoomName(read(item.asset));
+    if (!(filedAsRug || RUG_WORD.test(text)) ||
+        (!filedAsRug &&
+            (WALL.test(text) || CHAIR.test(text) || /table|desk|ottoman|pouf/.test(text))) ||
         item.asset.attachTo)
         return false;
     const dims = getScaledDimensions(item);
@@ -36,6 +60,69 @@ export function isFloorUnderlay(item) {
         top >= bottom &&
         top <= LOW_PROFILE_ITEM_SURFACE_MAX_HEIGHT);
 }
+/** What the catalogue (or the agent) files wall panelling and trim under, English or French, folded. */
+const WALL_DRESSING_CATEGORY = /^(?:trim|paneling|panelling|wainscot(?:ing)?|boiseries?|(?:wall ?)?panels?|moulding|molding)$/;
+/**
+ * Wall panelling and trim are the wall's own surface: an item filed under them is read by its strips
+ * (its box is the room's) in a collision and in a door's clearance. A piece beside it keeps the gap
+ * it keeps from anything else.
+ */
+export function isWallDressing(item) {
+    return WALL_DRESSING_CATEGORY.test(foldRoomName(item.asset.category ?? ''));
+}
+/** What each role is filed under, folded, with hyphens as spaces: the category says it first. */
+const ROLE_CATEGORY = {
+    bedside: /^(?:night ?stands?|bedside(?: tables?)?|night tables?|chevets?)$/,
+    bed: /^(?:(?:double|single|twin|king|queen|bunk|kids?) )?(?:beds?|lits?)$/,
+    seat: /^(?:(?:dining|desk|office|kitchen|bar|counter|outdoor|garden|terrace|work|accent) )?(?:chairs?|stools?)$|^(?:chaises?|tabourets?)$/,
+    worktop: /^(?:desks?|bureaux?|(?:dining|kitchen|outdoor|garden|terrace|work|writing|office|meeting|conference|picnic) tables?)$/,
+    sofa: /^(?:(?:corner|sectional|leather|fabric) )?(?:sofas?|couch(?:es)?|loveseats?|canapes?)$/,
+    sidetable: /^(?:(?:side|end|accent|occasional|lamp) tables?|side|gueridons?)$/,
+};
+/** A category that says nothing about what the piece is (or only "table"): its id and name decide. */
+const GENERIC_CATEGORY = /^(?:furniture|furnishings?|other|misc\w*|custom|objects?|items?|home|interior|seating|tables?)?$/;
+/** The words that name each role, English or French, folded: only for a piece whose category does not. */
+const ROLE_WORDS = {
+    bedside: /chevets?|bedside|night ?stands?|night tables?/,
+    bed: /(?:^|[^a-z])(?:beds?|lits?)(?![a-z])/,
+    seat: /(?:^|[^a-z])(?:chairs?|stools?|chaises?|tabourets?)(?![a-z])/,
+    worktop: /(?:^|[^a-z])(?:tables?|desks?|bureaux?)(?![a-z])/,
+    sofa: /(?:^|[^a-z])(?:sofas?|couch(?:es)?|canapes?|loveseats?)(?![a-z])/,
+    sidetable: /gueridons?|(?:side|end) tables?|bout de canape|d'appoint/,
+};
+/** "Bout de lit" is a bench, "coffee table" and "console" are not tables to sit at. */
+const ROLE_NOT = {
+    bed: /(?:\bde|\bdu|\bof|\bfor|\bd') (?:beds?|lits?)\b/,
+    worktop: /basse|coffee|chevet|bedside|night|console|gueridon|appoint|side table|end table/,
+};
+const PAIR_ROLES = ['bedside', 'bed', 'seat', 'sidetable', 'sofa', 'worktop'];
+function pairRole(item) {
+    const category = foldRoomName(item.asset.category ?? '').replace(/[-_]+/g, ' ');
+    const filed = PAIR_ROLES.find((role) => ROLE_CATEGORY[role].test(category));
+    if (filed)
+        return filed;
+    if (!GENERIC_CATEGORY.test(category))
+        return null;
+    const text = foldRoomName(read(item.asset));
+    if (ARMCHAIR.test(text))
+        return null;
+    return (PAIR_ROLES.find((role) => ROLE_WORDS[role].test(text) && !ROLE_NOT[role]?.test(text)) ?? null);
+}
+const DESIGNED_PAIRS = [
+    ['bed', 'bedside'],
+    ['seat', 'worktop'],
+    ['sofa', 'sidetable'],
+];
+/**
+ * Whether two items are designed to stand together, a few centimetres apart: a nightstand beside a
+ * bed, a chair or stool at a desk or table, a sofa beside a side table. Such a pair being close is
+ * the design, not a finding; two of them overlapping is still one. Read from what each is filed
+ * under (its category), by its words only where the category says nothing.
+ */
+export function designedTogether(a, b) {
+    const roles = [pairRole(a), pairRole(b)];
+    return DESIGNED_PAIRS.some(([first, second]) => (roles[0] === first && roles[1] === second) || (roles[0] === second && roles[1] === first));
+}
 /**
  * Wall-bound pieces (a fridge, a counter, a bed, a sofa) stand against a wall and never in the
  * middle of a room; free-standing ones (a dining table, a rug, a plant) may take the middle; a chair
@@ -55,6 +142,18 @@ export function furnitureKind(asset) {
         return 'free';
     return WALL.test(text) ? 'wall' : 'free';
 }
+/** A sofa stands off the wall on its rug and stools stand at an island: in an open plan neither is in the middle of the room. */
+const FLOATS_IN_OPEN_PLAN = /sofa|couch|loveseat|stool/;
+/**
+ * The word that makes a piece wall-bound ("fridge", "counter"), for a piece that is judged to stand
+ * against a wall; null for every other piece, a sofa or stools that float by design included.
+ */
+export function wallBoundWord(asset) {
+    const text = read(asset);
+    if (furnitureKind(asset) !== 'wall' || FLOATS_IN_OPEN_PLAN.test(text))
+        return null;
+    return WALL.exec(text)?.[0].trim() ?? BEDSIDE.exec(text)?.[0] ?? 'piece';
+}
 /**
  * What a piece faces when it does not stand against a wall, as a pattern for the name of the item
  * it belongs with: the coffee table and the TV face the sofa, a chair faces its table.

package/dist/agent-operations/ground-reader.d.ts

@@ -0,0 +1,10 @@
+import type { SceneNodes } from './types.js';
+type Pt = [number, number];
+/**
+ * The terrain under a level's plan point, as a height in the level's building frame, or null when
+ * the level has no building. A site with no persisted terrain is the flat datum plane. The
+ * building's own offset and turn put its plan in the site's frame, where the terrain is read.
+ */
+export declare function groundReader(nodes: SceneNodes): (levelId: string, [x, z]: Pt) => number | null;
+export {};
+//# sourceMappingURL=ground-reader.d.ts.map

package/dist/agent-operations/ground-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-reader.d.ts","sourceRoot":"","sources":["../../src/agent-operations/ground-reader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1B;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,aAG3B,MAAM,UAAU,EAAE,KAAG,MAAM,GAAG,IAAI,CAcpD"}

package/dist/agent-operations/ground-reader.js

@@ -0,0 +1,25 @@
+import { resolveBuildingForLevel } from '../lib/node-ancestry.js';
+import { heightAt } from '../lib/terrain-field.js';
+import { persistedTerrainFieldOf } from '../lib/terrain-source-persisted.js';
+import { queryNodes } from './scene-queries.js';
+/**
+ * The terrain under a level's plan point, as a height in the level's building frame, or null when
+ * the level has no building. A site with no persisted terrain is the flat datum plane. The
+ * building's own offset and turn put its plan in the site's frame, where the terrain is read.
+ */
+export function groundReader(nodes) {
+    const sites = queryNodes(nodes, { type: 'site' });
+    const field = sites.length === 1 ? persistedTerrainFieldOf(sites[0]) : null;
+    return (levelId, [x, z]) => {
+        const buildingId = resolveBuildingForLevel(levelId, nodes);
+        const building = buildingId ? nodes[buildingId] : undefined;
+        if (building?.type !== 'building')
+            return null;
+        const [cos, sin] = [Math.cos(building.rotation[1]), Math.sin(building.rotation[1])];
+        const [siteX, siteZ] = [
+            cos * x + sin * z + building.position[0],
+            -sin * x + cos * z + building.position[2],
+        ];
+        return (field ? heightAt(field, siteX, siteZ) : 0) - building.position[1];
+    };
+}

package/dist/agent-operations/index.d.ts

@@ -1,4 +1,7 @@
 import type { AgentOperation } from './types.js';
+import './room-checks.js';
+import './unreachable-rooms-check.js';
+import './usage-checks.js';
 export * from './achieved.js';
 export * from './add-column.js';
 export * from './add-fence.js';
@@ -7,7 +10,9 @@ export * from './add-object.js';
 export * from './add-wall.js';
 export * from './apply-changes.js';
 export * from './apply-outcome.js';
+export * from './asset-catalog.js';
 export * from './author-scene.js';
+export * from './author-scene-checks.js';
 export * from './authored-scene-merge.js';
 export * from './collections.js';
 export * from './corner-window.js';
@@ -19,11 +24,13 @@ export * from './design-brief.js';
 export * from './designs.js';
 export * from './door-clearance.js';
 export * from './duplicate-level.js';
+export * from './duplicate-node.js';
 export * from './find-by-type.js';
 export * from './furnish-room.js';
 export * from './get-node.js';
 export * from './hosted-services.js';
 export * from './layout-clearance.js';
+export { findBlockedDoors } from './layout-clearance.js';
 export * from './level-height-fill.js';
 export * from './level-reads.js';
 export * from './level-target.js';
@@ -31,6 +38,8 @@ export * from './list-levels.js';
 export * from './material-preset.js';
 export * from './material-refs.js';
 export * from './merge-windows.js';
+export * from './move-node.js';
+export * from './move-plan.js';
 export * from './move-roofs.js';
 export * from './node-patch.js';
 export * from './paint.js';
@@ -39,7 +48,9 @@ export * from './plan-geometry.js';
 export * from './point-context.js';
 export * from './project-files.js';
 export * from './roof-writes.js';
+export { ROOM_CHECK_CODES } from './room-checks.js';
 export * from './room-floor-script.js';
+export { type RoomReading, readRooms } from './room-readings.js';
 export * from './room-structure.js';
 export * from './scene-materials.js';
 export * from './scene-measure.js';
@@ -48,13 +59,16 @@ export * from './scene-view.js';
 export * from './search-assets.js';
 export * from './search-materials.js';
 export * from './site.js';
+export * from './slab-surface-script.js';
 export * from './stairs.js';
 export * from './types.js';
+export * from './units.js';
 export * from './verify-scene.js';
 export * from './wall-face-script.js';
 export * from './wall-object-observations.js';
 export * from './wall-opening.js';
 export * from './wall-skirting.js';
+export * from './wall-type.js';
 /** Each shared agent tool's operation, by tool name: what every surface executes. */
 export declare const AGENT_OPERATIONS: {
     readonly cut_floor_opening: AgentOperation<{
@@ -228,6 +242,44 @@ export declare const AGENT_OPERATIONS: {
                 kind: "open";
                 design: string;
             } | undefined;
+            form?: {
+                kind: "bounded";
+                quote: string;
+                reading: string;
+                massing?: {
+                    plan?: "bay" | "courtyard" | "detached" | "h" | "l" | "polygon" | "rectangle" | "t" | "u" | "wing" | undefined;
+                    volumes?: number | undefined;
+                    heights?: "one" | "several" | undefined;
+                } | undefined;
+            } | {
+                kind: "open";
+                design: string;
+                massing?: {
+                    plan?: "bay" | "courtyard" | "detached" | "h" | "l" | "polygon" | "rectangle" | "t" | "u" | "wing" | undefined;
+                    volumes?: number | undefined;
+                    heights?: "one" | "several" | undefined;
+                } | undefined;
+            } | undefined;
+            facade?: {
+                kind: "bounded";
+                quote: string;
+                reading: string;
+                treatment?: {
+                    cladding?: ("brick" | "metal" | "render" | "siding" | "stone" | "wood")[] | undefined;
+                    bands?: ("base" | "cornice" | "course")[] | undefined;
+                    elements?: ("balconies" | "corners" | "curtain-wall" | "entrance" | "guard" | "porch" | "posts" | "shutters" | "surrounds")[] | undefined;
+                    rhythm?: "free" | "regular" | undefined;
+                } | undefined;
+            } | {
+                kind: "open";
+                design: string;
+                treatment?: {
+                    cladding?: ("brick" | "metal" | "render" | "siding" | "stone" | "wood")[] | undefined;
+                    bands?: ("base" | "cornice" | "course")[] | undefined;
+                    elements?: ("balconies" | "corners" | "curtain-wall" | "entrance" | "guard" | "porch" | "posts" | "shutters" | "surrounds")[] | undefined;
+                    rhythm?: "free" | "regular" | undefined;
+                } | undefined;
+            } | undefined;
             pieces?: {
                 kind: "bounded";
                 quote: string;
@@ -304,17 +356,43 @@ export declare const AGENT_OPERATIONS: {
                 none: string;
             };
         };
-        asIs?: {
-            assetId: string;
-            reason: string;
+        rooms?: {
+            name: string;
+            use: "bathroom" | "bedroom" | "dining" | "garage" | "hallway" | "kitchen" | "laundry" | "living" | "office" | "other";
+            distinct?: string | undefined;
+            finishes: {
+                floor: string;
+                walls: string;
+                tiled: boolean;
+                skirting: boolean;
+                dressing?: ("accent" | "chairRail" | "crown" | "splashback" | "tiles-full" | "tiles-to-height" | "wainscot")[] | undefined;
+            };
+            pieces: string[];
         }[] | undefined;
     }>;
-    readonly add_wall: AgentOperation<import("./level-target.js").LevelTargetInput & {
+    readonly add_wall: AgentOperation<{
+        levelId?: string | undefined;
+        level?: string | undefined;
         start: number[];
         end: number[];
-        thickness?: number;
-        height?: number;
-        curveOffset?: number;
+        type?: string | undefined;
+        wallType?: "railing" | "standard" | undefined;
+        railing?: {
+            style?: "balusters" | "boards" | "cable" | "glass" | "metal" | "post-and-rail" | undefined;
+            postSpacing?: number | undefined;
+            postSize?: number | undefined;
+            infillSize?: number | undefined;
+            infillGap?: number | undefined;
+            bottomClearance?: number | undefined;
+            cap?: boolean | undefined;
+        } | undefined;
+        thickness?: number | undefined;
+        height?: number | undefined;
+        curveOffset?: number | undefined;
+    }>;
+    readonly set_wall_type: AgentOperation<{
+        wallIds: string[];
+        type: string | null;
     }>;
     readonly add_fence: AgentOperation<import("./level-target.js").LevelTargetInput & {
         points: number[][];
@@ -400,6 +478,14 @@ export declare const AGENT_OPERATIONS: {
     readonly delete_node: AgentOperation<{
         id: string;
     }>;
+    readonly move_node: AgentOperation<import("./move-plan.js").MoveTarget & {
+        id: string;
+    }>;
+    readonly duplicate_node: AgentOperation<{
+        ids: string[];
+        offset?: number[];
+        targetLevelId?: string;
+    }>;
     readonly find_by_type: AgentOperation<import("./find-by-type.js").FindByTypeInput>;
     readonly create_room: AgentOperation<import("./level-target.js").LevelTargetInput & {
         name: string;
@@ -409,28 +495,30 @@ export declare const AGENT_OPERATIONS: {
         wallThickness?: number;
         outdoor?: boolean;
         rename?: boolean;
-        doors?: {
+        doors?: (Pick<import("../building/index.js").WallOpeningInput, "columns" | "doorType" | "leafCount" | "openingDirection" | "rollerShutter" | "rollerShutterBoxHeight" | "rollerShutterOpen" | "rows" | "sashGrid" | "shutterOpen" | "shutterSides" | "shutterWidth" | "shutters" | "sidelightLeft" | "sidelightRight" | "sillInterior" | "sillInteriorDepth" | "sillInteriorOverhang" | "sillInteriorThickness" | "sillOverhang" | "slideDirection" | "slidingStyle" | "tiltTurnMode" | "transomHeight" | "windowHandle" | "windowType"> & {
             wallIndex: number;
             t?: number;
             width?: number;
             height?: number;
             sillHeight?: number;
             hingesSide?: 'left' | 'right';
+            handleStyle?: import("../index.js").DoorNode['handleStyle'];
             handleSide?: 'left' | 'right';
             swingDirection?: 'inward' | 'outward';
             style?: string;
-        }[];
-        windows?: {
+        })[];
+        windows?: (Pick<import("../building/index.js").WallOpeningInput, "columns" | "doorType" | "leafCount" | "openingDirection" | "rollerShutter" | "rollerShutterBoxHeight" | "rollerShutterOpen" | "rows" | "sashGrid" | "shutterOpen" | "shutterSides" | "shutterWidth" | "shutters" | "sidelightLeft" | "sidelightRight" | "sillInterior" | "sillInteriorDepth" | "sillInteriorOverhang" | "sillInteriorThickness" | "sillOverhang" | "slideDirection" | "slidingStyle" | "tiltTurnMode" | "transomHeight" | "windowHandle" | "windowType"> & {
             wallIndex: number;
             t?: number;
             width?: number;
             height?: number;
             sillHeight?: number;
             hingesSide?: 'left' | 'right';
+            handleStyle?: import("../index.js").DoorNode['handleStyle'];
             handleSide?: 'left' | 'right';
             swingDirection?: 'inward' | 'outward';
             style?: string;
-        }[];
+        })[];
     }>;
     readonly furnish_room: AgentOperation<import("./level-target.js").LevelTargetInput & {
         zoneId?: string;
@@ -444,6 +532,7 @@ export declare const AGENT_OPERATIONS: {
         color?: string;
         material?: string | import("../index.js").MaterialSchema;
         materialName?: string;
+        exact?: boolean;
         erase?: true;
     }>;
     readonly place_in_room: AgentOperation<import("./place-in-room.js").PlaceInRoomInput>;
@@ -452,6 +541,7 @@ export declare const AGENT_OPERATIONS: {
             query: string;
             category?: string;
         }[];
+        limit?: number;
     }>;
     readonly view_assets: AgentOperation<{
         ids: string[];
@@ -474,6 +564,22 @@ export declare const AGENT_OPERATIONS: {
         yards?: Partial<Record<import("../index.js").YardKey, number>>;
         rotationDeg?: number;
     }>;
+    readonly create_unit: AgentOperation<{
+        buildingId?: string;
+        name: string;
+        kind?: import("../index.js").UnitKind;
+        color?: string;
+        memberZoneIds?: string[];
+        move?: boolean;
+    }>;
+    readonly set_unit_members: AgentOperation<{
+        unitId: string;
+        memberZoneIds: string[];
+        move?: boolean;
+    }>;
+    readonly list_units: AgentOperation<{
+        buildingId?: string;
+    }>;
     readonly run_batch: AgentOperation<{
         calls: {
             tool: string;
@@ -482,7 +588,7 @@ export declare const AGENT_OPERATIONS: {
         onRefusal?: 'stop' | 'skip';
     }>;
 };
-export { type AssetViewFacts, type AssetViewIO, type AssetViewLoader, type AssetViewSubject, assetViewNeeds, assetViewsReadCatalog, createAssetViewLoader, createFetchAssetViewIO, readGlbSurfaces, } from './asset-views.js';
+export { type AssetViewFacts, type AssetViewIO, type AssetViewLoader, type AssetViewSubject, assetViewNeeds, createAssetViewLoader, createFetchAssetViewIO, readGlbSurfaces, } from './asset-views.js';
 export { type PhotoFacePlan, planPhotoElevation } from './photo-elevation.js';
 export { recordMade } from './record-made.js';
 export { EMPTY_SESSION, keepInSession, madeEntries, parseSessionRecord, type SessionKeep, type SessionRecord, startOfSession, } from './scene-checkpoint.js';

package/dist/agent-operations/index.d.ts.map

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

package/dist/agent-operations/index.js

@@ -14,12 +14,14 @@ import { deleteNode } from './delete-node.js';
 import { designBrief, gatedByBrief } from './design-brief.js';
 import { placeDesign, validateDesignOperation } from './designs.js';
 import { duplicateLevel } from './duplicate-level.js';
+import { duplicateNode } from './duplicate-node.js';
 import { findByType } from './find-by-type.js';
 import { furnishRoom } from './furnish-room.js';
 import { getNode } from './get-node.js';
 import { getLevelSummary, getWalls, getZones } from './level-reads.js';
 import { listLevels } from './list-levels.js';
 import { mergeWindowsOperation } from './merge-windows.js';
+import { moveNode } from './move-node.js';
 import { moveRoofsToRoofLevel } from './move-roofs.js';
 import { paint } from './paint.js';
 import { placeInRoom } from './place-in-room.js';
@@ -31,7 +33,12 @@ import { setCheckpoint } from './set-checkpoint.js';
 import { setGroundLevel } from './set-ground-level.js';
 import { getSite, placeBuilding } from './site.js';
 import { fitStair, measureStairOperation } from './stairs.js';
+import { createUnit, listUnits, setUnitMembers } from './units.js';
 import { verifyScene } from './verify-scene.js';
+import { setWallType } from './wall-type.js';
+import './room-checks.js';
+import './unreachable-rooms-check.js';
+import './usage-checks.js';
 export * from './achieved.js';
 export * from './add-column.js';
 export * from './add-fence.js';
@@ -40,7 +47,9 @@ export * from './add-object.js';
 export * from './add-wall.js';
 export * from './apply-changes.js';
 export * from './apply-outcome.js';
+export * from './asset-catalog.js';
 export * from './author-scene.js';
+export * from './author-scene-checks.js';
 export * from './authored-scene-merge.js';
 export * from './collections.js';
 export * from './corner-window.js';
@@ -52,11 +61,14 @@ export * from './design-brief.js';
 export * from './designs.js';
 export * from './door-clearance.js';
 export * from './duplicate-level.js';
+export * from './duplicate-node.js';
 export * from './find-by-type.js';
 export * from './furnish-room.js';
 export * from './get-node.js';
 export * from './hosted-services.js';
 export * from './layout-clearance.js';
+// The door check that reads an item's real shape, not the plain one of door-clearance.
+export { findBlockedDoors } from './layout-clearance.js';
 export * from './level-height-fill.js';
 export * from './level-reads.js';
 export * from './level-target.js';
@@ -64,6 +76,8 @@ export * from './list-levels.js';
 export * from './material-preset.js';
 export * from './material-refs.js';
 export * from './merge-windows.js';
+export * from './move-node.js';
+export * from './move-plan.js';
 export * from './move-roofs.js';
 export * from './node-patch.js';
 export * from './paint.js';
@@ -72,7 +86,9 @@ export * from './plan-geometry.js';
 export * from './point-context.js';
 export * from './project-files.js';
 export * from './roof-writes.js';
+export { ROOM_CHECK_CODES } from './room-checks.js';
 export * from './room-floor-script.js';
+export { readRooms } from './room-readings.js';
 export * from './room-structure.js';
 export * from './scene-materials.js';
 export * from './scene-measure.js';
@@ -81,13 +97,16 @@ export * from './scene-view.js';
 export * from './search-assets.js';
 export * from './search-materials.js';
 export * from './site.js';
+export * from './slab-surface-script.js';
 export * from './stairs.js';
 export * from './types.js';
+export * from './units.js';
 export * from './verify-scene.js';
 export * from './wall-face-script.js';
 export * from './wall-object-observations.js';
 export * from './wall-opening.js';
 export * from './wall-skirting.js';
+export * from './wall-type.js';
 const SINGLE_OPERATIONS = {
     measure_stair: measureStairOperation,
     fit_stair: fitStair,
@@ -104,6 +123,7 @@ const SINGLE_OPERATIONS = {
     set_checkpoint: setCheckpoint,
     design_brief: designBrief,
     add_wall: addWall,
+    set_wall_type: setWallType,
     add_fence: addFence,
     add_corner_window: addCornerWindow,
     merge_windows: mergeWindowsOperation,
@@ -114,6 +134,8 @@ const SINGLE_OPERATIONS = {
     move_roofs_to_roof_level: moveRoofsToRoofLevel,
     place_items: gatedByBrief('place_items', placeItems),
     delete_node: deleteNode,
+    move_node: moveNode,
+    duplicate_node: duplicateNode,
     find_by_type: findByType,
     create_room: createRoom,
     furnish_room: gatedByBrief('furnish_room', furnishRoom),
@@ -125,6 +147,9 @@ const SINGLE_OPERATIONS = {
     get_site: getSite,
     place_building: placeBuilding,
     ...ROOM_OPERATIONS,
+    create_unit: createUnit,
+    set_unit_members: setUnitMembers,
+    list_units: listUnits,
 };
 // add_object is no single operation: its host compiles the module first, so it exists here only as
 // the batch's call, which places what the host built.
@@ -135,7 +160,7 @@ export const AGENT_OPERATIONS = {
     ...SINGLE_OPERATIONS,
     run_batch: createBatchOperation(BATCHED_OPERATIONS, AGENT_TOOL_CONTRACTS),
 };
-export { assetViewNeeds, assetViewsReadCatalog, createAssetViewLoader, createFetchAssetViewIO, readGlbSurfaces, } from './asset-views.js';
+export { assetViewNeeds, createAssetViewLoader, createFetchAssetViewIO, readGlbSurfaces, } from './asset-views.js';
 export { planPhotoElevation } from './photo-elevation.js';
 export { recordMade } from './record-made.js';
 export { EMPTY_SESSION, keepInSession, madeEntries, parseSessionRecord, startOfSession, } from './scene-checkpoint.js';

package/dist/agent-operations/item-solids.d.ts

@@ -0,0 +1,39 @@
+import { type MultiPolygon } from '../lib/polygon-boolean.js';
+import type { GeometryArtifactManifest } from '../schema/index.js';
+/**
+ * The real shape of an item, for the plan checks that read wall panelling: the solids its script says
+ * it is made of, each a plan polygon between two heights, instead of the one box round its bounds.
+ * Other items stay their box, since the faces of a script leave out its rails, backs and foliage. A script reports its
+ * upward faces (`surfaces`, a height and an outline) and its downward faces (`undersides`); every
+ * upward face is the top of a solid that goes down to the highest downward face below it that
+ * overlaps it in plan, else to the bottom of the bounds, and a thing with only downward faces (a
+ * pendant's shade) hangs from the face to the top of its bounds. Legs without a face of their own
+ * are not modelled, which only ever leaves out matter, and a script with no faces has no solids.
+ */
+export type ItemSolid = {
+    polygons: MultiPolygon;
+    y0: number;
+    y1: number;
+};
+/** A manifest point, mapped to the level's frame. */
+export type ToLevel = (point: [number, number, number]) => [number, number, number];
+/** The solids a manifest's faces describe, in the level's frame, or null when it reports none. */
+export declare function manifestSolids(manifest: Pick<GeometryArtifactManifest, 'bounds' | 'surfaces' | 'undersides'>, toLevel: ToLevel): ItemSolid[] | null;
+export type SolidsRelation = {
+    /** How deep the two reach into each other where they share height and plan, 0 when they do not. */
+    overlapArea: number;
+    /** The least plan distance between solids that share height; infinity when none do. */
+    gap: number;
+};
+/**
+ * How two items' solids stand to each other. Two solids share height when they reach into each
+ * other by more than `stack` (a thing resting on another sinks a little into it): one that only
+ * rests on the other, or lies clear above or below it, is neither overlapping nor close. Plan
+ * overlap counts from `minArea` (square metres), which leaves a touching edge or a boolean's
+ * sliver out.
+ */
+export declare function relateSolids(a: readonly ItemSolid[], b: readonly ItemSolid[], options: {
+    stack: number;
+    minArea: number;
+}): SolidsRelation;
+//# sourceMappingURL=item-solids.d.ts.map

package/dist/agent-operations/item-solids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-solids.d.ts","sourceRoot":"","sources":["../../src/agent-operations/item-solids.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAGzD;;;;;;;;;GASG;AAEH,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1E,qDAAqD;AACrD,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAqCnF,kGAAkG;AAClG,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,UAAU,GAAG,YAAY,CAAC,EAC9E,OAAO,EAAE,OAAO,GACf,SAAS,EAAE,GAAG,IAAI,CA8CpB;AA2BD,MAAM,MAAM,cAAc,GAAG;IAC3B,mGAAmG;IACnG,WAAW,EAAE,MAAM,CAAA;IACnB,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,SAAS,SAAS,EAAE,EACvB,CAAC,EAAE,SAAS,SAAS,EAAE,EACvB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1C,cAAc,CAkBhB"}