@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/wall-object-observations.js

@@ -3,6 +3,7 @@ import { area, difference, intersection, union, } from '../lib/polygon-boolean.j
 import { boundsOf, boxCorners, frame, rotateVector, transformPoint, } from '../procedural-items/spatial.js';
 import { getLevelElevations, getWallTop } from '../services/storey.js';
 import { getWallBodyCenterOffset, getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+import { queryNodes } from './scene-queries.js';
 const TOLERANCE = 0.001;
 const MIN_FACE_AREA = 0.04;
 const finiteVector = (v) => v.length === 3 && v.every(Number.isFinite);
@@ -60,16 +61,14 @@ function scriptGeometry(item, wall) {
 }
 function wallSolid(wall, nodes) {
     const support = wallSupportForNodes(wall, nodes).elevation;
-    const height = getWallTop(wall, wall.parentId, nodes, support) - support;
+    const height = Math.max(getWallTop(wall, wall.parentId, nodes, support, 0), getWallTop(wall, wall.parentId, nodes, support, 1)) - support;
     const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
     if (![height, length, support, wall.thickness ?? 0.1].every(Number.isFinite) ||
         height <= 0 ||
         length <= 0)
         return;
     const holes = [];
-    for (const child of Object.values(nodes)) {
-        if (child.parentId !== wall.id)
-            continue;
+    for (const child of queryNodes(nodes, { parentId: wall.id })) {
         // Wall cutters have no persisted XY outline: their bounds cannot prove solid contact.
         if ((child.type === 'item' || child.type === 'door' || child.type === 'window') &&
             child.source?.manifest.cutout)
@@ -108,9 +107,8 @@ export function wallObjectObservations(nodes, rendered = {}) {
     const elevations = getLevelElevations(nodes);
     const solids = new Map();
     const peers = [];
-    for (const item of Object.values(nodes)) {
-        if (item.type !== 'item' ||
-            !item.visible ||
+    for (const item of queryNodes(nodes, { type: 'item' })) {
+        if (!item.visible ||
             item.roofSegmentId ||
             item.blockFaceId ||
             (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') ||

package/dist/agent-operations/wall-skirting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-skirting.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-skirting.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,eAAe,EACrB,MAAM,WAAW,CAAA;AAIlB,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAEvE,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,mEAAmE;IACnE,KAAK,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,MAAM,CAAA;IAC1B,2HAA2H;IAC3H,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AA0BD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CA6DhE,CAAA"}
+{"version":3,"file":"wall-skirting.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-skirting.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,eAAe,EACrB,MAAM,WAAW,CAAA;AAIlB,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAEvE,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,mEAAmE;IACnE,KAAK,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,MAAM,CAAA;IAC1B,2HAA2H;IAC3H,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AA0BD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CA+DhE,CAAA"}

package/dist/agent-operations/wall-skirting.js

@@ -40,6 +40,8 @@ export const setWallSkirting = (nodes, input, context) => {
             });
         if (wall.wallType === 'curtain')
             refuse('curtain_wall', `Wall ${id} is a curtain wall: it has no skirting.`, { target: id });
+        if (wall.wallType === 'railing')
+            refuse('railing_wall', `Wall ${id} is a railing: it has no skirting.`, { target: id });
         const faces = input.faces === undefined ? roomFaces(nodes, wall) : getWallTrimFaces(input.faces);
         const { skirting } = wallTrimPatch(wall, 'skirting', {
             enabled: input.enabled ?? true,

package/dist/agent-operations/wall-type.d.ts

@@ -0,0 +1,49 @@
+import type { AgentOperation, SceneNodes } from './types.js';
+export declare function wallTypeChoices(nodes: SceneNodes): {
+    id: string;
+    label: string;
+    assembly: {
+        layers: {
+            id: string;
+            role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
+            thickness: number;
+            core?: true | undefined;
+            spacing?: number | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[];
+        backing?: {
+            id: string;
+            role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
+            thickness: number;
+            core?: true | undefined;
+            spacing?: number | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[] | undefined;
+        face?: "exterior" | "front" | undefined;
+        presetId?: string | undefined;
+        cavityInsulation?: string | undefined;
+    };
+}[];
+export declare function wallTypePatch(nodes: SceneNodes, type: string): {
+    assembly: import("../index.js").Assembly;
+    thickness: number;
+};
+export declare const setWallType: AgentOperation<{
+    wallIds: string[];
+    type: string | null;
+}>;
+//# sourceMappingURL=wall-type.d.ts.map

package/dist/agent-operations/wall-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-type.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-type.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAShD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM;;;EAK5D;AAED,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAqBlF,CAAA"}

package/dist/agent-operations/wall-type.js

@@ -0,0 +1,31 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { projectWallTypes, WALL_ASSEMBLY_PRESETS, wallAssemblyPatch, } from '../systems/wall/wall-assembly.js';
+import { queryNodes } from './scene-queries.js';
+export function wallTypeChoices(nodes) {
+    const sites = queryNodes(nodes, { type: 'site' }).filter((site) => !site.parentId);
+    return [
+        ...WALL_ASSEMBLY_PRESETS,
+        ...projectWallTypes(nodes, sites.map((site) => site.id)),
+    ];
+}
+export function wallTypePatch(nodes, type) {
+    const choice = wallTypeChoices(nodes).find((entry) => entry.id === type);
+    if (!choice)
+        refuse('unknown_wall_type', `Unknown wall type: ${type}. Read get_walls.wallTypes.`, { type });
+    return wallAssemblyPatch(structuredClone(choice.assembly));
+}
+export const setWallType = (nodes, input) => {
+    const data = input.type === null ? { assembly: undefined } : wallTypePatch(nodes, input.type);
+    const ids = [...new Set(input.wallIds)];
+    for (const id of ids) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            refuse('target_not_found', `${id} is not a wall: nothing was changed.`, { target: id });
+        if (wall.wallType === 'curtain' || wall.wallType === 'railing')
+            refuse(`${wall.wallType}_wall`, `Wall ${id} is a ${wall.wallType} wall: it takes no assembly.`, { target: id });
+    }
+    return {
+        result: { ok: true, wallIds: ids, type: input.type },
+        changes: { update: ids.map((id) => ({ id, data: structuredClone(data) })) },
+    };
+};

package/dist/agent-operations/zone-coverage.d.ts

@@ -0,0 +1,85 @@
+import { type MultiPolygon, type Ring } from '../lib/polygon-boolean.js';
+import type { WallNode, ZoneNode } from '../schema/index.js';
+/**
+ * Do a level's zones tile the floor its walls enclose? Two findings, both measured on the clear floor (the wall bodies are not
+ * floor, so a zone drawn on a wall's centre line or on its face is the same):
+ *
+ * - `zones_overlap`: two rooms of the house that both lie on the same clear floor, by `ZONE_OVERLAP_MIN_M2` or more, at least
+ *   `COVERAGE_MIN_WIDTH_M` wide. A pair of rooms that `space_many_rooms` already names (both lie in one enclosed space) is not
+ *   reported again.
+ * - `floor_unclaimed`: floor inside a space the walls enclose that no zone and no stair claims, by `FLOOR_UNCLAIMED_MIN_M2` or
+ *   more, at least `COVERAGE_MIN_WIDTH_M` wide. A space no zone covers past half is `space_no_room`, not repeated here. Any zone
+ *   claims the floor it lies on (a room, an alfresco, a void, an analysis area), and a stair claims the floor under it.
+ *
+ * "At least 15 cm wide" is an opening: what is left when every point within 7.5 cm of the region's edge is taken out and the rest
+ * grown back, so a gap under 15 cm, or a hairline along a wall that joins a real gap, does not count. The width said is the short
+ * side of the rectangle with the piece's area and perimeter. All three tolerances are said in the message.
+ *
+ * A boolean that fails reads as an empty region (`polygon-boolean` swallows the error), which here would mean "nothing is claimed";
+ * when what should be claimed is not empty and its union is, the level is not measured and says nothing.
+ */
+export declare const ZONE_OVERLAP_MIN_M2 = 0.1;
+export declare const FLOOR_UNCLAIMED_MIN_M2 = 0.3;
+export declare const COVERAGE_MIN_WIDTH_M = 0.15;
+type Zone = ZoneNode;
+type Wall = WallNode;
+type Place = [number, number];
+export type ZonesOverlapIssue = {
+    type: 'zones_overlap';
+    message: string;
+    severity: 'warning';
+    levelId: string;
+    zoneIds: string[];
+    nodeIds: string[];
+    at: Place;
+    /** m² */
+    area: number;
+    /** m, the short side of the rectangle with the piece's area and perimeter */
+    width: number;
+};
+export type FloorUnclaimedIssue = {
+    type: 'floor_unclaimed';
+    message: string;
+    severity: 'warning';
+    levelId: string;
+    /** The zones within 30 cm of the unclaimed floor, nearest first. */
+    zoneIds: string[];
+    wallIds: string[];
+    nodeIds: string[];
+    at: Place;
+    /** m² */
+    area: number;
+    /** m, the short side of the rectangle with the piece's area and perimeter */
+    width: number;
+};
+/** The short side of the rectangle with this area and perimeter: exact for a rectangle, a quarter of the perimeter for a fat shape. */
+export declare function equivalentWidth(areaM2: number, perimeterM: number): number;
+/**
+ * The wall bodies of a level as one region: where there is wall there is no floor. Detected spaces run to the walls' centre lines, so
+ * both rules take them out. Null when the walls have footprints and their union failed.
+ */
+export declare function wallBodies(walls: readonly Wall[]): MultiPolygon | null;
+/** Pairs of rooms that lie on the same clear floor. `skip(a, b)` leaves a pair out (rooms of one space, which space_many_rooms names). */
+export declare function zonesOverlapIssues(input: {
+    levelId: string;
+    levelName: string;
+    rooms: readonly Zone[];
+    bodies: MultiPolygon;
+    skip?: (a: Zone, b: Zone) => boolean;
+}): ZonesOverlapIssue[];
+/** Floor inside the given spaces that no zone and no stair claims and no wall stands on. */
+export declare function floorUnclaimedIssues(input: {
+    levelId: string;
+    levelName: string;
+    /** The spaces to look in: the ones the walls enclose and the zones cover past half. */
+    spaces: readonly {
+        polygon: Ring;
+        holes?: Ring[];
+        wallIds: string[];
+    }[];
+    zones: readonly Zone[];
+    stairs: readonly Ring[];
+    bodies: MultiPolygon;
+}): FloorUnclaimedIssue[];
+export {};
+//# sourceMappingURL=zone-coverage.d.ts.map

package/dist/agent-operations/zone-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-coverage.d.ts","sourceRoot":"","sources":["../../src/agent-operations/zone-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,YAAY,EAGjB,KAAK,IAAI,EAEV,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAGnD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAA;AACtC,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAIxC,KAAK,IAAI,GAAG,QAAQ,CAAA;AACpB,KAAK,IAAI,GAAG,QAAQ,CAAA;AACpB,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,eAAe,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,EAAE,EAAE,KAAK,CAAA;IACT,SAAS;IACT,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,iBAAiB,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,EAAE,EAAE,KAAK,CAAA;IACT,SAAS;IACT,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAgBD,uIAAuI;AACvI,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1E;AAoED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,YAAY,GAAG,IAAI,CAOtE;AAsBD,0IAA0I;AAC1I,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IACtB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,KAAK,OAAO,CAAA;CACrC,GAAG,iBAAiB,EAAE,CA6BtB;AAUD,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,uFAAuF;IACvF,MAAM,EAAE,SAAS;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;IACvE,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IACtB,MAAM,EAAE,SAAS,IAAI,EAAE,CAAA;IACvB,MAAM,EAAE,YAAY,CAAA;CACrB,GAAG,mBAAmB,EAAE,CA4CxB"}

package/dist/agent-operations/zone-coverage.js

@@ -0,0 +1,208 @@
+import { area as areaOf, containsPoint, difference, distanceToBoundary, intersection, union, } from '../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../lib/polygon-label.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+/**
+ * Do a level's zones tile the floor its walls enclose? Two findings, both measured on the clear floor (the wall bodies are not
+ * floor, so a zone drawn on a wall's centre line or on its face is the same):
+ *
+ * - `zones_overlap`: two rooms of the house that both lie on the same clear floor, by `ZONE_OVERLAP_MIN_M2` or more, at least
+ *   `COVERAGE_MIN_WIDTH_M` wide. A pair of rooms that `space_many_rooms` already names (both lie in one enclosed space) is not
+ *   reported again.
+ * - `floor_unclaimed`: floor inside a space the walls enclose that no zone and no stair claims, by `FLOOR_UNCLAIMED_MIN_M2` or
+ *   more, at least `COVERAGE_MIN_WIDTH_M` wide. A space no zone covers past half is `space_no_room`, not repeated here. Any zone
+ *   claims the floor it lies on (a room, an alfresco, a void, an analysis area), and a stair claims the floor under it.
+ *
+ * "At least 15 cm wide" is an opening: what is left when every point within 7.5 cm of the region's edge is taken out and the rest
+ * grown back, so a gap under 15 cm, or a hairline along a wall that joins a real gap, does not count. The width said is the short
+ * side of the rectangle with the piece's area and perimeter. All three tolerances are said in the message.
+ *
+ * A boolean that fails reads as an empty region (`polygon-boolean` swallows the error), which here would mean "nothing is claimed";
+ * when what should be claimed is not empty and its union is, the level is not measured and says nothing.
+ */
+export const ZONE_OVERLAP_MIN_M2 = 0.1;
+export const FLOOR_UNCLAIMED_MIN_M2 = 0.3;
+export const COVERAGE_MIN_WIDTH_M = 0.15;
+/** A zone's nearest neighbours are named within this distance, m. */
+const NEAR_M = 0.3;
+const round2 = (value) => Math.round(value * 100) / 100;
+function perimeter(polygon) {
+    return [polygon.outer, ...polygon.holes].reduce((sum, ring) => sum +
+        ring.reduce((length, point, i) => {
+            const next = ring[(i + 1) % ring.length];
+            return length + Math.hypot(next[0] - point[0], next[1] - point[1]);
+        }, 0), 0);
+}
+/** The short side of the rectangle with this area and perimeter: exact for a rectangle, a quarter of the perimeter for a fat shape. */
+export function equivalentWidth(areaM2, perimeterM) {
+    return (perimeterM - Math.sqrt(Math.max(0, perimeterM * perimeterM - 16 * areaM2))) / 4;
+}
+/** A union, or null when it failed: non-empty input whose union is empty. */
+function unionOrNull(inputs) {
+    const parts = inputs.flatMap((input) => !Array.isArray(input)
+        ? [input]
+        : Array.isArray(input[0])
+            ? [{ outer: input, holes: [] }]
+            : input);
+    if (!parts.length)
+        return [];
+    const joined = union(parts);
+    return joined.length ? joined : null;
+}
+/** The rectangles of half-width `r` along each edge of the rings, a little past each end: what is within `r` of the region's edge. */
+function edgeBands(rings, r) {
+    return rings.flatMap((ring) => ring.flatMap((a, i) => {
+        const b = ring[(i + 1) % ring.length];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (length < 1e-6)
+            return [];
+        const ux = ((b[0] - a[0]) / length) * r;
+        const uz = ((b[1] - a[1]) / length) * r;
+        return [
+            [
+                [a[0] - ux - uz, a[1] - uz + ux],
+                [b[0] + ux - uz, b[1] + uz + ux],
+                [b[0] + ux + uz, b[1] + uz - ux],
+                [a[0] - ux + uz, a[1] - uz - ux],
+            ],
+        ];
+    }));
+}
+/**
+ * The part of a piece that is wide enough: its edge taken in by `COVERAGE_MIN_WIDTH_M / 2` on every side, then given back where
+ * something is left. Nothing if a boolean fails on the way.
+ */
+function wideEnough(piece) {
+    const r = COVERAGE_MIN_WIDTH_M / 2;
+    const rims = unionOrNull(edgeBands([piece.outer, ...piece.holes], r));
+    if (!rims)
+        return [];
+    const core = difference(piece, rims);
+    if (!core.length)
+        return [];
+    const back = unionOrNull([
+        ...core,
+        ...edgeBands(core.flatMap((p) => [p.outer, ...p.holes]), r),
+    ]);
+    return back ? intersection(back, piece) : [];
+}
+/** The pieces of a region at least `COVERAGE_MIN_WIDTH_M` wide and `minM2` big, each with its area and width. */
+function strips(region, minM2) {
+    return region
+        .flatMap((piece) => wideEnough(piece))
+        .flatMap((piece) => {
+        const area = areaOf([piece]);
+        const width = equivalentWidth(area, perimeter(piece));
+        return area >= minM2 && width >= COVERAGE_MIN_WIDTH_M - 1e-6 ? [{ piece, area, width }] : [];
+    });
+}
+/**
+ * The wall bodies of a level as one region: where there is wall there is no floor. Detected spaces run to the walls' centre lines, so
+ * both rules take them out. Null when the walls have footprints and their union failed.
+ */
+export function wallBodies(walls) {
+    const miters = calculateLevelMiters([...walls]);
+    const rings = walls.flatMap((wall) => {
+        const points = getWallPlanFootprint(wall, miters);
+        return points.length >= 3 ? [points.map((point) => [point.x, point.y])] : [];
+    });
+    return unionOrNull(rings);
+}
+const shapeOf = (zone) => ({
+    outer: zone.polygon,
+    holes: (zone.holes ?? []),
+});
+const where = (piece) => {
+    const [x, z] = polygonInteriorPoint({ polygon: piece.outer, holes: piece.holes }, true);
+    return [round2(x), round2(z)];
+};
+/** "a strip 0.45 m wide", or for a shape as fat as it is long "a region about 3 m across". */
+function shapeWords(area, width) {
+    return area / width >= 2 * width
+        ? `a strip ${round2(width)} m wide`
+        : `a region about ${round2(width)} m across`;
+}
+const RULE_TAIL = (minM2) => `(not reported under ${minM2} m² or narrower than ${Math.round(COVERAGE_MIN_WIDTH_M * 100)} cm; wall bodies are not floor)`;
+/** Pairs of rooms that lie on the same clear floor. `skip(a, b)` leaves a pair out (rooms of one space, which space_many_rooms names). */
+export function zonesOverlapIssues(input) {
+    const { levelId, levelName, rooms, bodies, skip } = input;
+    const issues = [];
+    if (rooms.length < 2)
+        return issues;
+    for (let i = 0; i < rooms.length; i++) {
+        for (let j = i + 1; j < rooms.length; j++) {
+            const a = rooms[i];
+            const b = rooms[j];
+            if (skip?.(a, b))
+                continue;
+            const shared = intersection(shapeOf(a), shapeOf(b));
+            if (!shared.length)
+                continue;
+            const clear = bodies.length ? difference(shared, bodies) : shared;
+            for (const strip of strips(clear, ZONE_OVERLAP_MIN_M2)) {
+                const at = where(strip.piece);
+                issues.push({
+                    type: 'zones_overlap',
+                    message: `On ${levelName}, "${a.name || a.id}" and "${b.name || b.id}" overlap on ${round2(strip.area)} m² of floor (${shapeWords(strip.area, strip.width)}) around (${at[0]}, ${at[1]}) ${RULE_TAIL(ZONE_OVERLAP_MIN_M2)}.`,
+                    severity: 'warning',
+                    levelId,
+                    zoneIds: [a.id, b.id],
+                    nodeIds: [a.id, b.id],
+                    at,
+                    area: round2(strip.area),
+                    width: round2(strip.width),
+                });
+            }
+        }
+    }
+    return issues;
+}
+/** How far a zone lies from a piece, m: 0 when a vertex or the piece's place is inside it. */
+function distanceTo(zone, samples) {
+    const shape = [shapeOf(zone)];
+    return Math.min(...samples.map((point) => (containsPoint(shape, point) ? 0 : distanceToBoundary(shape, point))));
+}
+/** Floor inside the given spaces that no zone and no stair claims and no wall stands on. */
+export function floorUnclaimedIssues(input) {
+    const { levelId, levelName, spaces, zones, stairs, bodies } = input;
+    const placed = zones.filter((zone) => zone.polygon.length >= 3);
+    const claimed = unionOrNull([
+        ...placed.map((zone) => shapeOf(zone)),
+        ...stairs.filter((ring) => ring.length >= 3).map((ring) => ({ outer: ring, holes: [] })),
+        ...bodies,
+    ]);
+    if (!claimed)
+        return [];
+    const issues = [];
+    for (const space of spaces) {
+        const whole = { outer: space.polygon, holes: space.holes ?? [] };
+        const left = claimed.length ? difference(whole, claimed) : [whole];
+        for (const strip of strips(left, FLOOR_UNCLAIMED_MIN_M2)) {
+            const at = where(strip.piece);
+            const samples = [at, ...strip.piece.outer];
+            const near = placed
+                .map((zone) => ({ zone, distance: distanceTo(zone, samples) }))
+                .filter((x) => x.distance <= NEAR_M)
+                .sort((x, y) => x.distance - y.distance)
+                .map((x) => x.zone);
+            const zoneIds = near.map((zone) => zone.id);
+            issues.push({
+                type: 'floor_unclaimed',
+                message: `On ${levelName}, ${round2(strip.area)} m² of floor inside the walls (${shapeWords(strip.area, strip.width)}) around (${at[0]}, ${at[1]}) is claimed by no zone or stair${near.length
+                    ? `; nearest ${near
+                        .slice(0, 3)
+                        .map((zone) => `"${zone.name || zone.id}"`)
+                        .join(', ')}`
+                    : ''} ${RULE_TAIL(FLOOR_UNCLAIMED_MIN_M2)}.`,
+                severity: 'warning',
+                levelId,
+                zoneIds,
+                wallIds: space.wallIds,
+                nodeIds: [...zoneIds, ...space.wallIds],
+                at,
+                area: round2(strip.area),
+                width: round2(strip.width),
+            });
+        }
+    }
+    return issues;
+}

package/dist/agent-tools/add-object.d.ts

@@ -1,4 +1,20 @@
 import { z } from 'zod';
+/** A piece Pascal's own model writes from its description (`add_object`'s `piece`). */
+export declare const objectPiece: z.ZodObject<{
+    description: z.ZodString;
+    size: z.ZodObject<{
+        width: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        height: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        depth: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+    }, z.core.$strip>;
+    mount: z.ZodDefault<z.ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+        "wall-side": "wall-side";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ObjectPiece = z.infer<typeof objectPiece>;
 /** The `params` field every scripted tool shares (add_object, add_window, add_door, add_column). */
 export declare const scriptParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
 /** The `language` field every scripted tool shares. */
@@ -14,6 +30,20 @@ export declare const addObjectTool: {
         description: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         code: z.ZodOptional<z.ZodString>;
+        piece: z.ZodOptional<z.ZodObject<{
+            description: z.ZodString;
+            size: z.ZodObject<{
+                width: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+                height: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+                depth: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            }, z.core.$strip>;
+            mount: z.ZodDefault<z.ZodEnum<{
+                ceiling: "ceiling";
+                floor: "floor";
+                "wall-side": "wall-side";
+            }>>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         language: z.ZodOptional<z.ZodEnum<{
             bpy: "bpy";
             three: "three";
@@ -27,6 +57,7 @@ export declare const addObjectTool: {
             back: "back";
             front: "front";
         }>>;
+        exact: z.ZodOptional<z.ZodBoolean>;
         name: z.ZodOptional<z.ZodString>;
         category: z.ZodOptional<z.ZodString>;
         reason: z.ZodOptional<z.ZodString>;

package/dist/agent-tools/add-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-object.d.ts","sourceRoot":"","sources":["../../src/agent-tools/add-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqCvB,oGAAoG;AACpG,eAAO,MAAM,YAAY,wGAKtB,CAAA;AAEH,uDAAuD;AACvD,eAAO,MAAM,cAAc;;;GAE1B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CAkDzB,CAAA;AAED,eAAO,MAAM,aAAa;IACxB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QAGN,IAAI;;;;;CAKP,CAAA"}
+{"version":3,"file":"add-object.d.ts","sourceRoot":"","sources":["../../src/agent-tools/add-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA0CvB,uFAAuF;AACvF,eAAO,MAAM,WAAW;;;;;;;;;;;;;kBA+Bb,CAAA;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,oGAAoG;AACpG,eAAO,MAAM,YAAY,wGAKtB,CAAA;AAEH,uDAAuD;AACvD,eAAO,MAAM,cAAc;;;GAE1B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DzB,CAAA;AAED,eAAO,MAAM,aAAa;IACxB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QAGN,IAAI;;;;;CAKP,CAAA"}

package/dist/agent-tools/add-object.js

@@ -15,24 +15,54 @@ One object is one feature that changes together: a table, a bench, a porch, a ra
 
 Conventions (they make the object work in Pascal; follow them):
 - Metres, Y up, modelled in its installed orientation. Floor and wall mounts put the bottom-centre of the visible bounds at the placement point. Ceiling mounts put the top-centre there: visible geometry extends down in negative local Y, with its top at Y = 0. Wall-side mounts put the bottom-centre of the back face there (back at Z = 0, facing +Z). Normalization translates geometry; it does not flip it.
-- Paint: name every material slot_<finish> (slot_trim, slot_frame, slot_metal) and reuse one material per finish; a material named "glass" renders as glass.
+- Paint: name every material slot_<finish> (slot_trim, slot_frame, slot_metal) and reuse one material per finish; a material named "glass" renders as glass. A slot's colour is shown as the library finish it matches (wood, metal, the nearest flat colour); exact: true keeps each colour as written.
 - Parts: name the few groups a person would point at part:<id> (part:column_left, part:canopy, part:landing), usually 2–24, a group per part, not every mesh. Set userData.type on parts someone would look for: column, beam, slab, roof, railing, panel, trim, step, light.
-- Lights: add a THREE.PointLight or SpotLight named light:<id> where the bulb is; it becomes a switchable light.
+- Lights: add a THREE.PointLight or SpotLight named light:<id> where the bulb is; it becomes a switchable light. A SpotLight keeps its aim (its target), angle and penumbra (a sconce's cone, a recessed downlight). castShadow = true makes it cast shadows (only the couple nearest the view do at once, so keep it for the lights that shape a room). userData.glow = { size, strength } draws a soft halo around the lamp in its colour (size across in metres, about 0.15 for a sconce to 0.4 for a lantern; strength default 1), strongest at dusk and night.
 - Motion: put THREE.AnimationClips on the returned group's .animations, as in any three.js project; tracks target <objectName>.<property> or <object.uuid>.<property> and may use any transform property (position, rotation, rotation[y], quaternion, scale); material and visibility tracks do not animate. A clip named open becomes the object's open/close control (close plays a clip named close, or open reversed); a clip named loop runs continuously; every other clip gets its own play toggle labelled with its name (name it for the person: "Twirl", "Music"). Write as many clips as the object needs.
 - Cuts: a mesh named cutout cuts only the mounted host; cut:wall, cut:ceiling and cut:slab require that host kind (floor items cut their support slab). The hidden cutter must reach the host; walls use its real shape, ceilings and slabs its through-hole footprint.
 - Sockets: an empty Object3D named anchor:<id> marks where other things attach.
-- No textures, network or DOM. At most 300k triangles, 32 materials, 60 m per side.
+- No textures, network or DOM. At most 300k triangles (every instance of an InstancedMesh counts), 32 materials, 60 m per side.
 
 Blender instead (language 'bpy'): when the shape is easier with Blender's modelling (bevelled or rounded edges, subdivision-smooth and organic forms, booleans, curves and text, solidify, array, screw and other modifiers), write a bpy module:
   import bpy, bmesh
   PARAMS = {"width": {"default": 1.8, "min": 1.2, "max": 2.6, "step": 0.05, "unit": "m", "label": "Width"}}
   MOUNT = "floor"
   def build(params): ...   # add objects to the empty scene; everything in it is exported, modifiers applied
-The same conventions in Blender terms: metres, Z up, the front faces -Y (Blender's Front view); part:<id>, light:<id> (a light object; its custom property intensity sets the brightness, default 2), anchor:<id> (an empty), cutout, cut:wall|ceiling|slab and collider are object names; userData is the object's custom properties (obj["type"] = "panel"); slot_<finish> are material names. A clip is one action named open, close, loop or anything else, assigned to every object that moves in it. Use the data API and bmesh, not operators that need a 3D viewport. A Blender build takes a few seconds.
+The same conventions in Blender terms: metres, Z up, the front faces -Y (Blender's Front view); part:<id>, light:<id> (a point or spot light object; its custom properties intensity sets the brightness, default 2, shadows = True casts shadows, glow = {"size": 0.2, "strength": 1} draws the halo), anchor:<id> (an empty), cutout, cut:wall|ceiling|slab and collider are object names; userData is the object's custom properties (obj["type"] = "panel"); slot_<finish> are material names. A clip is one action named open, close, loop or anything else, assigned to every object that moves in it. Use the data API and bmesh, not operators that need a 3D viewport. A Blender build takes a few seconds.
 
 Several objects: they do not depend on each other, so several add_object calls can go in one step, or in one run_batch call (a call per object; each is reported on its own with its receipt, and one that fails does not stop the others).
 
+From words instead of code: pass piece (what it is in your own words, its size and mount) with name, category and reason. Pascal's own model writes its module in the background under these conventions, compile-checked and repaired, many at a time; the call answers at once with the piece's id and status pending, so go on working. Where the host offers it; each piece spends credits. Given position (or parentId), the object is placed there when its module lands; given neither, it is only made, and author_scene items place it, as many times as they name its id (piece). A piece that fails comes back in author_scene's report.
+
 Edit: pass nodeId with new code and/or params (params alone rebuild the stored script; get_source provides the current code and params when needed); identity, placement, paint and the params you leave out are kept. The result lists the size, parts, slots, lights, animations and params.`;
+const pieceLength = (axis) => measurement('length', 'm', { description: axis, positive: true });
+/** A piece Pascal's own model writes from its description (`add_object`'s `piece`). */
+export const objectPiece = z
+    .object({
+    description: z
+        .string()
+        .trim()
+        .min(1)
+        .max(2000)
+        .describe('The object in your own words: what it is, its form, materials, colours and details, as you would brief a modeller.'),
+    size: z
+        .object({
+        width: pieceLength('Along X.'),
+        height: pieceLength('Along Y.'),
+        depth: pieceLength('Along Z, its front toward +Z.'),
+    })
+        .describe('Its visible bounds in its own frame.'),
+    mount: z
+        .enum(['floor', 'wall-side', 'ceiling'])
+        .default('floor')
+        .describe('floor (default), wall-side (its back on a wall face) or ceiling (hanging, its top on the ceiling).'),
+    id: z
+        .string()
+        .regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/)
+        .optional()
+        .describe('Your own id for it (letters, digits, - and _), which author_scene items name; default: one is made. A new piece with an id used before replaces it.'),
+})
+    .strict();
 /** The `params` field every scripted tool shares (add_object, add_window, add_door, add_column). */
 export const scriptParams = z
     .record(z.string(), z.union([z.number(), z.boolean(), z.string()]))
@@ -50,7 +80,10 @@ export const addObjectTool = {
             .min(1)
             .max(48_000)
             .optional()
-            .describe('The module (see the tool description). Required to create; omit to rebuild an object with new params.'),
+            .describe('The module (see the tool description). Required to create, unless piece is given; omit to rebuild an object with new params.'),
+        piece: objectPiece
+            .optional()
+            .describe("Instead of code, to create: the object in words, written by Pascal's model in the background (see the tool description)."),
         language: scriptLanguage,
         params: scriptParams,
         nodeId: NodeId.optional().describe('Edit this existing authored object instead of creating one.'),
@@ -67,6 +100,10 @@ export const addObjectTool = {
             .enum(['front', 'back'])
             .optional()
             .describe('Which wall face a wall-side object sits on.'),
+        exact: z
+            .boolean()
+            .optional()
+            .describe("Keep the module's slot colours exactly as written, with their roughness and metalness, instead of the library finishes they match (glass stays glass, a glowing slot its own material). On an edit, the module's colours replace the slots' paint."),
         ...geometryMetaFields,
         name: geometryMetaFields.name.describe('What the user would call it ("Low oak table").'),
         category: geometryMetaFields.category.describe('What it is, one word or two ("table", "bench", "porch", "lantern", "trim").'),
@@ -81,9 +118,9 @@ export const addObjectTool = {
 export const getSourceTool = {
     name: 'get_source',
     title: 'Read object script',
-    description: "The module (three.js or Blender bpy, named by language) an object (or a window, door or column built from code) runs, with its params and their current values; a room's id reads its floor script, the module that builds its floor finish; a wall's id with face reads that face's script (face may be left out when only one face has one). Optional source evidence when the current module is needed. An edited module can be passed back with the same nodeId: to add_object for an object, to add_window / add_door / add_column for their respective kinds.",
+    description: "Read the code module a scripted node runs and return it with its language (three.js or Blender bpy) and its params at their current values. It reads the module of an object, or of a window, door or column built from code; a room's id reads its floor script, the module that builds its floor finish; a slab's id reads its surface script, the module that builds its top's finish; a wall's id with face reads that face's script (face may be left out when only one face has one). Optional source evidence when the current module is needed. An edited module can be passed back with the same nodeId: to add_object for an object, to add_window / add_door / add_column for their respective kinds.",
     input: {
-        nodeId: NodeId.describe('An object, window, door or column built from code, a room with a floor script, or a wall with a face script.'),
+        nodeId: NodeId.describe('An object, window, door or column built from code, a room with a floor script, a slab with a surface script, or a wall with a face script.'),
         face: z
             .enum(['a', 'b'])
             .optional()

package/dist/agent-tools/assets.d.ts

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+/** Results per query when a search names no limit, and the most it may ask for. */
+export declare const SEARCH_ASSETS_LIMIT = 24;
+export declare const SEARCH_ASSETS_MAX_LIMIT = 60;
 export declare const searchAssetsTool: {
     name: string;
     title: string;
@@ -8,6 +11,7 @@ export declare const searchAssetsTool: {
             query: z.ZodString;
             category: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        limit: z.ZodOptional<z.ZodNumber>;
     };
 };
 export declare const viewAssetsTool: {

package/dist/agent-tools/assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/agent-tools/assets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;IAC3B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;;;;CAaV,CAAA;AAED,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,GAAG;;CAMN,CAAA"}
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/agent-tools/assets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,eAAO,MAAM,gBAAgB;IAC3B,IAAI;IACJ,KAAK;IACL,WAAW;IACX,KAAK;QACH,OAAO;;;;QAYP,KAAK;;CAUR,CAAA;AAED,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,GAAG;;CAMN,CAAA"}