@pascal-app/core 1.0.6 → 1.0.7

package/dist/agent-operations/project-files.d.ts

@@ -6,4 +6,14 @@ export type ProjectFileToolExecutor = (request: {
     signal?: AbortSignal;
 }) => Promise<unknown>;
 export declare function executeProjectFileTool(name: string, raw: unknown, execute: ProjectFileToolExecutor, signal?: AbortSignal): Promise<unknown>;
+/**
+ * A project file's bytes, for a caller who may edit the project: `author_scene`'s payload by
+ * reference. Refuses a missing file or one over maxBytes.
+ */
+export type ProjectFileReader = (request: {
+    projectId?: string;
+    fileId: string;
+    maxBytes: number;
+    signal?: AbortSignal;
+}) => Promise<Uint8Array>;
 //# sourceMappingURL=project-files.d.ts.map

package/dist/agent-operations/project-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-operations/project-files.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAGpG,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE;IAC9C,IAAI,EAAE,mBAAmB,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEtB,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,uBAAuB,EAChC,MAAM,CAAC,EAAE,WAAW,oBA0BrB"}
+{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-operations/project-files.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAGpG,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE;IAC9C,IAAI,EAAE,mBAAmB,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEtB,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,uBAAuB,EAChC,MAAM,CAAC,EAAE,WAAW,oBA0BrB;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA"}

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

@@ -0,0 +1,41 @@
+import { type CirculationGeometryReason } from './circulation-geometry.js';
+import { type CirculationGraph, type CirculationIssue } from './circulation-graph.js';
+import type { SceneNodes } from './types.js';
+export { floorSpaceReader, type Space, wallSidesReader } from './circulation-spaces.js';
+/** Why a level is or is not reached from an entrance; null when it is. */
+export type CirculationLevelReason = 'no_connection' | 'no_landing' | 'no_entrance' | 'not_measured';
+/** Whether a level can be reached from an entrance: true, false, or null where it cannot be measured. */
+export type CirculationLevel = {
+    levelId: string;
+    name: string;
+    buildingId: string | null;
+    reachable: boolean | null;
+    reason: CirculationLevelReason | null;
+    spaces: number;
+    reachedSpaces: number;
+};
+export type CirculationReach = {
+    /** The graph the reading measures: raw, or without the geometry that cannot be measured. */
+    graph: CirculationGraph;
+    geometry: CirculationGeometryReason[];
+    /** A multiple-building, tilted or floorless scene has no frame to measure a route in. */
+    frameLimited: boolean;
+    entrance: boolean;
+    reached: Set<string>;
+    /** Graph nodes whose route is not measurable: neither reached nor proven cut off. */
+    unmeasured: Set<string>;
+    /** Per level that holds a space to reach. */
+    levels: CirculationLevel[];
+    /** Level ids where a flight or lift serves the level but arrives at no floor. */
+    landingTrouble: Set<string>;
+    /** Spaces behind a door whose approach from outside cannot be measured. */
+    behindUnmeasuredEntrance: Set<string>;
+};
+/**
+ * The one reading of reach that verify_scene and the circulation findings share: what is reached from
+ * any entrance, what is unmeasured, and, per level, whether an entrance reaches it at all.
+ */
+export declare function circulationReach(nodes: SceneNodes, rawGraph: CirculationGraph, geometry?: CirculationGeometryReason[]): CirculationReach;
+export declare function circulationGraphIssues(nodes: SceneNodes, rawGraph: CirculationGraph, reach?: CirculationReach): CirculationIssue[];
+export declare function circulationDiagnostics(nodes: SceneNodes): CirculationIssue[];
+//# sourceMappingURL=reachability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reachability.d.ts","sourceRoot":"","sources":["../../src/agent-operations/reachability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,yBAAyB,EAI/B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAMtB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,EAAE,gBAAgB,EAAE,KAAK,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AA4DpF,0EAA0E;AAC1E,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG,YAAY,GAAG,aAAa,GAAG,cAAc,CAAA;AAEpG,yGAAyG;AACzG,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAA;IACzB,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAA;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4FAA4F;IAC5F,KAAK,EAAE,gBAAgB,CAAA;IACvB,QAAQ,EAAE,yBAAyB,EAAE,CAAA;IACrC,yFAAyF;IACzF,YAAY,EAAE,OAAO,CAAA;IACrB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpB,qFAAqF;IACrF,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACvB,6CAA6C;IAC7C,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,iFAAiF;IACjF,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC3B,2EAA2E;IAC3E,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACtC,CAAA;AAYD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,GAAE,yBAAyB,EAAgD,GAClF,gBAAgB,CAoElB;AAKD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,GAAE,gBAAoD,GAC1D,gBAAgB,EAAE,CAsEpB;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAE5E"}

package/dist/agent-operations/reachability.js

@@ -0,0 +1,199 @@
+import { resolveBuildingForLevel, resolveLevelId } from '../lib/node-ancestry.js';
+import { getLevelAbove } from '../services/storey.js';
+import { circulationGeometryReasons, measuredCirculationGraph, unmeasuredRouteIds, } from './circulation-geometry.js';
+import { buildCirculationGraph, circulationLinks, exteriorEntranceEdges, nodeName, reachedFrom, } from './circulation-graph.js';
+import { queryNodes } from './scene-queries.js';
+export { floorSpaceReader, wallSidesReader } from './circulation-spaces.js';
+const listed = (names) => names.length > 8
+    ? `${names.slice(0, 8).join(', ')} and ${names.length - 8} more`
+    : names.join(', ');
+function apartmentIssues(nodes, graph, entrance, rawGraph, cutOff) {
+    const links = circulationLinks(graph);
+    const groundIds = new Set(graph.floors.filter((floor) => floor.ground).map((floor) => floor.id));
+    const starts = entrance
+        ? ['outside']
+        : [...graph.nodes.values()]
+            .filter((node) => node.levelId && groundIds.has(node.levelId) && !node.apartment)
+            .map((node) => node.id);
+    const everywhere = reachedFrom(links, starts);
+    const shared = reachedFrom(links, starts, (id) => !graph.nodes.get(id)?.apartment);
+    const rawLinks = circulationLinks(rawGraph);
+    const unmeasured = unmeasuredRouteIds(reachedFrom(rawLinks, starts), everywhere);
+    const unmeasuredShared = unmeasuredRouteIds(reachedFrom(rawLinks, starts, (id) => !rawGraph.nodes.get(id)?.apartment), shared);
+    const unreachable = [], through = [];
+    for (const unit of queryNodes(nodes, { type: 'unit' })) {
+        if ((unit.kind ?? 'apartment') !== 'apartment')
+            continue;
+        const keys = [...graph.nodes.values()]
+            .filter((node) => node.apartment === unit.id)
+            .map((node) => node.id);
+        if (!keys.length)
+            continue;
+        if (!keys.some((id) => everywhere.has(id))) {
+            const onCutOffLevels = keys.every((id) => cutOff.has(graph.nodes.get(id)?.levelId ?? ''));
+            if (!(onCutOffLevels || keys.some((id) => unmeasured.has(id))))
+                unreachable.push(unit.id);
+        }
+        else if (!keys.some((id) => shared.has(id) || unmeasuredShared.has(id)))
+            through.push(unit.id);
+    }
+    const issues = [];
+    if (unreachable.length)
+        issues.push({
+            type: 'apartment_unreachable',
+            message: `${unreachable.length} apartment${unreachable.length === 1 ? '' : 's'} cannot be reached from ${entrance ? 'the entrance' : "the ground floor's corridors"}: ${listed(unreachable.map((id) => nodeName(nodes, id)))}.`,
+            nodeIds: unreachable,
+        });
+    if (through.length)
+        issues.push({
+            type: 'reached_through_apartment',
+            message: `${through.length} apartment${through.length === 1 ? ' is' : 's are'} reached only by crossing another apartment: ${listed(through.map((id) => nodeName(nodes, id)))}.`,
+            nodeIds: through,
+        });
+    return issues;
+}
+const FRAME_REASONS = ['multiple_buildings', 'tilted_buildings', 'floor_missing'];
+function stairLevelIds(nodes, id) {
+    const stair = nodes[id];
+    if (stair?.type !== 'stair')
+        return [];
+    const foot = stair.fromLevelId ?? resolveLevelId(stair, nodes);
+    const head = stair.toLevelId ?? (foot ? getLevelAbove(foot, nodes)?.id : undefined);
+    return [foot, head].filter((levelId) => typeof levelId === 'string');
+}
+/**
+ * The one reading of reach that verify_scene and the circulation findings share: what is reached from
+ * any entrance, what is unmeasured, and, per level, whether an entrance reaches it at all.
+ */
+export function circulationReach(nodes, rawGraph, geometry = circulationGeometryReasons(nodes, rawGraph)) {
+    const frameLimited = geometry.some((reason) => FRAME_REASONS.includes(reason.code));
+    const graph = frameLimited ? rawGraph : measuredCirculationGraph(nodes, rawGraph, geometry);
+    const entrance = exteriorEntranceEdges(graph).length > 0;
+    const reached = reachedFrom(circulationLinks(graph), entrance ? ['outside'] : []);
+    const rawLinks = circulationLinks(rawGraph);
+    const noRoute = !entrance && geometry.length > 0;
+    const behindUnmeasuredEntrance = reachedFrom(rawLinks, rawGraph.unmeasuredEntrances
+        .map((unmeasured) => unmeasured.spaceId)
+        .filter((id) => rawGraph.nodes.has(id)), (id) => id !== 'outside');
+    const unmeasured = new Set([
+        ...unmeasuredRouteIds(reachedFrom(rawLinks, ['outside']), reached),
+        ...[...behindUnmeasuredEntrance].filter((id) => !reached.has(id)),
+        ...(noRoute ? [...rawGraph.nodes.keys()].filter((id) => !reached.has(id)) : []),
+    ]);
+    const landingTrouble = new Set();
+    for (const issue of rawGraph.issues) {
+        if (issue.type !== 'stair_has_no_landing' && issue.type !== 'lift_door_blocked')
+            continue;
+        for (const id of issue.levelIds ?? [])
+            landingTrouble.add(id);
+        for (const nodeId of issue.nodeIds)
+            for (const id of stairLevelIds(nodes, nodeId))
+                landingTrouble.add(id);
+    }
+    const levels = rawGraph.floors.flatMap((floor) => {
+        const spaces = [...rawGraph.nodes.values()].filter((node) => node.levelId === floor.id &&
+            (node.kind === 'room' || node.kind === 'zone' || node.kind === 'floor') &&
+            !rawGraph.nonSpaces.has(node.id));
+        if (!spaces.length)
+            return [];
+        const reachedSpaces = spaces.filter((node) => reached.has(node.id)).length;
+        const lost = (node) => unmeasured.has(node.id) || !graph.nodes.has(node.id);
+        const [reachable, reason] = frameLimited
+            ? [null, 'not_measured']
+            : !entrance
+                ? [null, 'no_entrance']
+                : reachedSpaces
+                    ? [true, null]
+                    : spaces.some(lost)
+                        ? [null, 'not_measured']
+                        : [false, landingTrouble.has(floor.id) ? 'no_landing' : 'no_connection'];
+        return [
+            {
+                levelId: floor.id,
+                name: floor.name,
+                buildingId: resolveBuildingForLevel(floor.id, nodes) ?? null,
+                reachable,
+                reason,
+                spaces: spaces.length,
+                reachedSpaces,
+            },
+        ];
+    });
+    return {
+        graph,
+        geometry,
+        frameLimited,
+        entrance,
+        reached,
+        unmeasured,
+        levels,
+        landingTrouble,
+        behindUnmeasuredEntrance,
+    };
+}
+const levelFact = (name, building) => `${name} of ${building} has no walkable stair or lift to it from an entrance`;
+export function circulationGraphIssues(nodes, rawGraph, reach = circulationReach(nodes, rawGraph)) {
+    const issues = [...rawGraph.issues];
+    const { geometry } = reach;
+    issues.push(...geometry.map((reason) => ({
+        type: 'circulation_not_measured',
+        message: reason.message,
+        nodeIds: reason.nodeIds,
+        reasonCode: reason.code,
+    })));
+    if (reach.frameLimited)
+        return issues;
+    const { graph, entrance, reached, unmeasured } = reach;
+    if (!entrance && geometry.length)
+        return issues;
+    const ground = graph.floors.find((floor) => floor.ground);
+    const spaces = [...graph.nodes.values()].filter((node) => (node.kind === 'room' || node.kind === 'zone' || node.kind === 'floor') &&
+        !graph.nonSpaces.has(node.id));
+    if (!entrance && ground && spaces.length)
+        issues.push({
+            type: 'no_exterior_door',
+            message: `No door, open edge or entrance steps connect outside to an interior space on ${ground.name}: the building cannot be entered.`,
+            nodeIds: [ground.id],
+            levelIds: [ground.id],
+        });
+    // A level no entrance reaches is one fact about the level; its rooms are not raised one by one.
+    const cutOff = new Set(reach.levels.filter((level) => level.reachable === false).map((level) => level.levelId));
+    for (const level of reach.levels) {
+        if (level.reachable !== false)
+            continue;
+        const building = (level.buildingId && nodes[level.buildingId]?.name) || 'the building';
+        issues.push({
+            type: 'missing_stair',
+            message: `${levelFact(level.name, building)}.`,
+            nodeIds: [level.levelId],
+            levelIds: [level.levelId],
+            ...(level.reason ? { reasonCode: level.reason } : {}),
+        });
+    }
+    const rooms = spaces.filter((node) => !reached.has(node.id) &&
+        (!node.apartment || unmeasured.has(node.id)) &&
+        !(cutOff.has(node.levelId ?? '') && !unmeasured.has(node.id)));
+    for (const room of rooms) {
+        const limited = unmeasured.has(room.id);
+        const entryUnmeasured = limited && reach.behindUnmeasuredEntrance.has(room.id);
+        issues.push({
+            type: limited ? 'circulation_not_measured' : 'room_unreachable',
+            message: entryUnmeasured
+                ? `${room.name} access is not measured because the door that enters it opens high above the modeled ground.`
+                : limited
+                    ? `${room.name} access is not measured because its route crosses unmeasured walking geometry.`
+                    : `${room.name} cannot be reached from outside through modeled doors, openings, open edges, stairs or lifts.`,
+            ...(limited
+                ? { reasonCode: entryUnmeasured ? 'entrance_not_measured' : 'route_not_measured' }
+                : {}),
+            nodeIds: [room.sourceId ?? room.levelId ?? room.id],
+            levelIds: room.levelId ? [room.levelId] : [],
+            spaceId: room.id,
+        });
+    }
+    issues.push(...apartmentIssues(nodes, graph, entrance, rawGraph, cutOff));
+    return issues;
+}
+export function circulationDiagnostics(nodes) {
+    return circulationGraphIssues(nodes, buildCirculationGraph(nodes));
+}

package/dist/agent-operations/room-checks.d.ts

@@ -0,0 +1,60 @@
+import type { SceneMaterial } from '../schema/index.js';
+import { type RoomReading } from './room-readings.js';
+import type { SceneNodes } from './types.js';
+import { type WallFaceReading } from './wall-face-defaults.js';
+/**
+ * What the rooms of a scene owe, checked at the end of a turn: a wet room with no tile, rooms with no
+ * skirting, a piece hung on the face of the wall that looks into another room than the one it names.
+ * Like the coherence checks they guide and never forbid: each says what the scene shows and leaves
+ * the maker to fix it or keep it. A finding fires only where the nodes can be read to the end (an
+ * inline material, a script-built face or a scene ref with no scene materials is `unknown`, and
+ * unknown fires nothing).
+ */
+export declare const ROOM_CHECK_CODES: readonly ['room_wet_untiled', 'rooms_no_skirting', 'rooms_skirting_partial', 'wall_faces_default', 'rooms_floors_default', 'room_no_floor'];
+export type RoomCheckCode = (typeof ROOM_CHECK_CODES)[number];
+export type RoomCheckIssue = {
+    type: RoomCheckCode;
+    message: string;
+    severity: 'warning';
+    nodeIds: string[];
+};
+/**
+ * A wet room (bathroom, shower room, WC, laundry) whose walls are not tiled as a wet room is: to
+ * `WET_TILED_TO_M` on the walls its fixtures stand against, and to the ceiling around its shower. A
+ * tiled floor does not make up for walls that splash.
+ */
+export declare function wetRoomIssues(rooms: readonly RoomReading[]): RoomCheckIssue[];
+/**
+ * Skirting, from the faces of a room's walls: the rooms a finished floor meets in view (bedrooms,
+ * living and dining rooms, offices, hallways) that have none on any face. When some rooms have it
+ * the finding names the ones left bare; when none has it, it is about the scene, and only for a
+ * house of at least `HOUSE_MIN_ROOMS` such rooms. Rooms with no known wall face are not read.
+ */
+export declare function skirtingIssue(rooms: readonly RoomReading[]): RoomCheckIssue | null;
+/**
+ * Skirting on part of a room's faces: a room the skirting is owed in (see `skirtingIssue`) that has it
+ * on some of the wall faces looking in and not on the others. A room with none is `skirtingIssue`'s.
+ */
+export declare function partialSkirtingIssue(rooms: readonly RoomReading[]): RoomCheckIssue | null;
+/** Rooms with no floor under them: no plate of their own, no drawn slab they were taken from, and slabs over less than half their footprint. */
+export declare function noFloorIssue(rooms: readonly RoomReading[]): RoomCheckIssue | null;
+/**
+ * The floors of the indoor rooms that show the default, as one finding that names the rooms and
+ * says how many other rooms show a finish. Fewer than `HOUSE_MIN_ROOMS` rooms all at the default
+ * are a test or a demonstration and say nothing. A ceiling at its default is normal and is not
+ * read; the wall faces are read apart (`wallFaceDefaultIssue`): by wall, not through a room.
+ */
+export declare function floorDefaultIssue(rooms: readonly RoomReading[]): RoomCheckIssue | null;
+/**
+ * The wall faces nobody gave a finish, read from the walls themselves (`readWallFaces`): one finding
+ * that names each wall with its default faces, how long they are, where they run in plan and which
+ * room they face (or stand inside), and how many of the faces read show the default. The walls of a
+ * scene of fewer than `HOUSE_MIN_ROOMS` rooms whose faces are all at the default are a test or a
+ * demonstration and say nothing.
+ */
+export declare function wallFaceDefaultIssue(read: WallFaceReading, roomsRead: number): RoomCheckIssue | null;
+/** Every room check on a scene. */
+export declare function roomCheckIssues(nodes: SceneNodes, options?: {
+    materials?: Readonly<Record<string, SceneMaterial>>;
+}): RoomCheckIssue[];
+//# sourceMappingURL=room-checks.d.ts.map

package/dist/agent-operations/room-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-checks.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-checks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,KAAK,WAAW,EAAa,MAAM,iBAAiB,CAAA;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEhG;;;;;;;GAOG;AAEH,eAAO,MAAM,gBAAgB,YAC3B,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,CACP,CAAA;AACV,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE7D,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAeD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,EAAE,CA6B7E;AAQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,GAAG,IAAI,CAsBlF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,GAAG,IAAI,CAkBzF;AAED,gJAAgJ;AAChJ,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,GAAG,IAAI,CASjF;AAID;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,GAAG,IAAI,CAetF;AA4BD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,MAAM,GAChB,cAAc,GAAG,IAAI,CAiBvB;AAED,mCAAmC;AACnC,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAA;CAAO,GACpE,cAAc,EAAE,CAmBlB"}

package/dist/agent-operations/room-checks.js

@@ -0,0 +1,226 @@
+import { isSkirtedRoomUse, isWetRoomUse } from '../building/room-use.js';
+import { readRooms } from './room-readings.js';
+import { WET_TILED_TO_M } from './room-wet.js';
+import { registerSceneCheck } from './verify-scene.js';
+import { readWallFaces } from './wall-face-defaults.js';
+/**
+ * What the rooms of a scene owe, checked at the end of a turn: a wet room with no tile, rooms with no
+ * skirting, a piece hung on the face of the wall that looks into another room than the one it names.
+ * Like the coherence checks they guide and never forbid: each says what the scene shows and leaves
+ * the maker to fix it or keep it. A finding fires only where the nodes can be read to the end (an
+ * inline material, a script-built face or a scene ref with no scene materials is `unknown`, and
+ * unknown fires nothing).
+ */
+export const ROOM_CHECK_CODES = [
+    'room_wet_untiled',
+    'rooms_no_skirting',
+    'rooms_skirting_partial',
+    'wall_faces_default',
+    'rooms_floors_default',
+    'room_no_floor',
+];
+const WORDS_SHOWN = 6;
+/** Names as a sentence lists them: the first few, then how many more. */
+const listed = (names) => names.length <= WORDS_SHOWN
+    ? names.join(', ')
+    : `${names.slice(0, WORDS_SHOWN).join(', ')} and ${names.length - WORDS_SHOWN} more`;
+const finishes = (room) => `its floor is ${room.floor.finish} and its walls ${room.walls.finishes.join(', ') || 'unfinished'}`;
+const metres = (value) => `${value.toFixed(2)} m`;
+/**
+ * A wet room (bathroom, shower room, WC, laundry) whose walls are not tiled as a wet room is: to
+ * `WET_TILED_TO_M` on the walls its fixtures stand against, and to the ceiling around its shower. A
+ * tiled floor does not make up for walls that splash.
+ */
+export function wetRoomIssues(rooms) {
+    return rooms.flatMap((room) => {
+        const wet = room.wet;
+        if (wet?.verdict !== 'no' || !isWetRoomUse(room.use))
+            return [];
+        const where = wet.byFixtures ? 'the walls its fixtures stand against' : 'its walls';
+        const bareShower = wet.showers.find((shower) => shower.full === 'no');
+        const [lead, fix] = wet.tiled === 'no'
+            ? [
+                !wet.anyTile
+                    ? `shows no tile on ${where}`
+                    : wet.tiledTo && wet.tiledTo > 0.05
+                        ? `has tile up to ${metres(wet.tiledTo)} on ${where}`
+                        : `has tile on part of ${where}, along less than most of their length`,
+                `tile ${where} to ${metres(WET_TILED_TO_M)}`,
+            ]
+            : [
+                `is tiled to ${metres(WET_TILED_TO_M)} but not to the ceiling around its shower (${bareShower?.name})`,
+                `tile the walls around ${bareShower?.name} to the ceiling`,
+            ];
+        return [
+            {
+                type: 'room_wet_untiled',
+                message: `${room.name} (${room.use}, ${room.levelName}) ${lead}: ${finishes(room)}. A wet room is usually tiled to ${metres(WET_TILED_TO_M)} on the walls its fixtures stand against and to the ceiling around its shower, whatever its floor; ${fix}, or keep the finish if it is intended.`,
+                severity: 'warning',
+                nodeIds: [room.id],
+            },
+        ];
+    });
+}
+/**
+ * Fewer rooms than this are a room or two, not a house: bare wall bases there say nothing of a
+ * finishing recipe, and a scene of one room is mostly a test or a demonstration.
+ */
+const HOUSE_MIN_ROOMS = 3;
+/**
+ * Skirting, from the faces of a room's walls: the rooms a finished floor meets in view (bedrooms,
+ * living and dining rooms, offices, hallways) that have none on any face. When some rooms have it
+ * the finding names the ones left bare; when none has it, it is about the scene, and only for a
+ * house of at least `HOUSE_MIN_ROOMS` such rooms. Rooms with no known wall face are not read.
+ */
+export function skirtingIssue(rooms) {
+    const bare = rooms.filter((room) => isSkirtedRoomUse(room.use) && room.skirting.faces > 0 && !room.skirting.withSkirting);
+    if (!bare.length)
+        return null;
+    const skirted = rooms.filter((room) => room.skirting.withSkirting > 0);
+    const nodeIds = bare.map((room) => room.id);
+    if (!skirted.length)
+        return bare.length < HOUSE_MIN_ROOMS
+            ? null
+            : {
+                type: 'rooms_no_skirting',
+                message: `No room of the scene has skirting: ${listed(bare.map((room) => room.name))} (${bare.length}) show bare wall bases. Skirting is the skirting field of the wall: set it on the walls of these rooms, or keep the bare bases if they are intended.`,
+                severity: 'warning',
+                nodeIds,
+            };
+    return {
+        type: 'rooms_no_skirting',
+        message: `${listed(bare.map((room) => room.name))} have no skirting while ${listed(skirted.map((room) => room.name))} do. Skirting is the skirting field of the wall: set it on the walls of these rooms, or keep them bare if that is intended.`,
+        severity: 'warning',
+        nodeIds,
+    };
+}
+/**
+ * Skirting on part of a room's faces: a room the skirting is owed in (see `skirtingIssue`) that has it
+ * on some of the wall faces looking in and not on the others. A room with none is `skirtingIssue`'s.
+ */
+export function partialSkirtingIssue(rooms) {
+    const partial = rooms.filter((room) => isSkirtedRoomUse(room.use) &&
+        room.skirting.withSkirting > 0 &&
+        room.skirting.withSkirting < room.skirting.faces);
+    if (!partial.length)
+        return null;
+    return {
+        type: 'rooms_skirting_partial',
+        message: `Skirting is on part of the wall faces of ${listed(partial.map((room) => `${room.name} (${room.skirting.withSkirting} of ${room.skirting.faces} faces)`))}: ${plural(partial.length, 'room')} of the ${plural(rooms.filter((room) => isSkirtedRoomUse(room.use)).length, 'room')} that owe it.`,
+        severity: 'warning',
+        nodeIds: partial.map((room) => room.id),
+    };
+}
+/** Rooms with no floor under them: no plate of their own, no drawn slab they were taken from, and slabs over less than half their footprint. */
+export function noFloorIssue(rooms) {
+    const bare = rooms.filter((room) => room.indoor && !room.floor.held);
+    if (!bare.length)
+        return null;
+    return {
+        type: 'room_no_floor',
+        message: `No floor plate or slab is under ${listed(bare.map((room) => `${room.name} (${room.levelName})`))}: slabs cover less than half of ${bare.length === 1 ? 'its footprint' : 'each footprint'}.`,
+        severity: 'warning',
+        nodeIds: bare.map((room) => room.id),
+    };
+}
+const plural = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+/**
+ * The floors of the indoor rooms that show the default, as one finding that names the rooms and
+ * says how many other rooms show a finish. Fewer than `HOUSE_MIN_ROOMS` rooms all at the default
+ * are a test or a demonstration and say nothing. A ceiling at its default is normal and is not
+ * read; the wall faces are read apart (`wallFaceDefaultIssue`): by wall, not through a room.
+ */
+export function floorDefaultIssue(rooms) {
+    const indoor = rooms.filter((room) => room.indoor);
+    const bare = indoor.filter((room) => room.floor.atDefault);
+    if (!bare.length || (bare.length === indoor.length && indoor.length < HOUSE_MIN_ROOMS))
+        return null;
+    return {
+        type: 'rooms_floors_default',
+        message: `Floors at the default, no finish written for them: ${listed(bare.map((room) => room.name))}${bare.length === indoor.length
+            ? ` (all ${plural(indoor.length, 'room')} read)`
+            : `; the other ${plural(indoor.length - bare.length, 'room')} read show a finish`}.`,
+        severity: 'warning',
+        nodeIds: bare.map((room) => room.id),
+    };
+}
+const two = (value) => value.toFixed(2);
+const spot = (point) => `${point[0]}, ${point[1]}`;
+/** Where a default face is, as the finding says it: the rooms it faces, or the room its wall stands in. */
+const placeOf = (face) => face.facing.length
+    ? `facing ${listed(face.facing)}`
+    : face.standsIn.length
+        ? `inside ${listed(face.standsIn)}`
+        : 'with no room on that side';
+/** One wall's default faces as a clause: both faces together when they are alike, else each face. */
+function wallClause(faces) {
+    const [one] = faces;
+    const alike = faces.length === 2 &&
+        Math.abs(faces[0].metres - faces[1].metres) < 0.01 &&
+        placeOf(faces[0]) === placeOf(faces[1]);
+    const how = alike
+        ? `both faces ${two(faces[0].metres)} m ${placeOf(faces[0])}`
+        : faces.map((face) => `face ${face.face} ${two(face.metres)} m ${placeOf(face)}`).join(', ');
+    const first = faces.reduce((a, b) => (b.stretches[0][0] < a.stretches[0][0] ? b : a));
+    const last = faces.reduce((a, b) => (b.stretches.at(-1)[1] > a.stretches.at(-1)[1] ? b : a));
+    return `“${one.wallName}” (${one.levelName}): ${how}, from ${spot(first.from)} to ${spot(last.to)}`;
+}
+/**
+ * The wall faces nobody gave a finish, read from the walls themselves (`readWallFaces`): one finding
+ * that names each wall with its default faces, how long they are, where they run in plan and which
+ * room they face (or stand inside), and how many of the faces read show the default. The walls of a
+ * scene of fewer than `HOUSE_MIN_ROOMS` rooms whose faces are all at the default are a test or a
+ * demonstration and say nothing.
+ */
+export function wallFaceDefaultIssue(read, roomsRead) {
+    if (!read.defaults.length)
+        return null;
+    const bare = new Set(read.defaults.map((face) => `${face.wallId}/${face.face}`)).size;
+    if (bare >= read.faces && roomsRead < HOUSE_MIN_ROOMS)
+        return null;
+    const byWall = new Map();
+    for (const face of read.defaults)
+        byWall.set(face.wallId, [...(byWall.get(face.wallId) ?? []), face]);
+    const metres = read.defaults.reduce((sum, face) => sum + face.metres, 0);
+    const total = (faces) => Math.round(faces.reduce((sum, face) => sum + face.metres, 0) * 100);
+    const longest = [...byWall.values()].sort((p, q) => total(q) - total(p));
+    return {
+        type: 'wall_faces_default',
+        message: `Wall faces at the default, no finish written for them: ${listed(longest.map(wallClause))}; ${bare} of ${plural(read.faces, 'wall face')} read (${metres.toFixed(1)} of ${read.metres.toFixed(1)} m) show the default.`,
+        severity: 'warning',
+        nodeIds: [...byWall.keys()],
+    };
+}
+/** Every room check on a scene. */
+export function roomCheckIssues(nodes, options = {}) {
+    const rooms = readRooms(nodes, { materials: options.materials });
+    const wallFaces = wallFaceDefaultIssue(readWallFaces(nodes), rooms.filter((room) => room.indoor).length);
+    if (!rooms.length)
+        return wallFaces ? [wallFaces] : [];
+    const skirting = skirtingIssue(rooms);
+    const partial = partialSkirtingIssue(rooms);
+    const noFloor = noFloorIssue(rooms);
+    const floors = floorDefaultIssue(rooms);
+    return [
+        ...wetRoomIssues(rooms),
+        ...(skirting ? [skirting] : []),
+        ...(partial ? [partial] : []),
+        ...(noFloor ? [noFloor] : []),
+        ...(wallFaces ? [wallFaces] : []),
+        ...(floors ? [floors] : []),
+    ];
+}
+registerSceneCheck({
+    name: 'room checks',
+    order: 70,
+    run: (nodes, _input, context) => {
+        try {
+            return roomCheckIssues(nodes, { materials: context?.materials });
+        }
+        catch {
+            // A scene the readers cannot walk (a wall stored without its start) is the schema check's to
+            // report, not a reason for verify_scene to fail.
+            return [];
+        }
+    },
+});

package/dist/agent-operations/room-faces.d.ts

@@ -0,0 +1,30 @@
+import type { WallFace, WallNode, ZoneNode } from '../schema/index.js';
+import type { SceneNodes } from './types.js';
+/**
+ * A stretch of one face of one wall that a room stands on: the unit every room-level wall write
+ * and read works in. `u0..u1` are metres from the wall's start along its reference line (along the
+ * chord for a curved wall), the coordinates a face's paint regions use; `whole` is a stretch that
+ * runs the face's full length, so a region over it can leave `u` unbounded and follow the wall when
+ * it is lengthened.
+ */
+export type RoomWallFace = {
+    wallId: string;
+    face: WallFace;
+    t0: number;
+    t1: number;
+    u0: number;
+    u1: number;
+    /** The wall's reference length (its chord), metres. */
+    length: number;
+    whole: boolean;
+    curved: boolean;
+};
+/** The walls that bound a room and carry a finish: its boundary walls, curtain walls left out. */
+export declare function roomBoundaryWalls(nodes: SceneNodes, zone: ZoneNode): WallNode[];
+/**
+ * The faces that look into a room, a stretch each, in the order of the room's boundary walls: for a
+ * partition the face of this room and not the other's, for a wall that runs on past the room only the
+ * stretch the room stands on.
+ */
+export declare function roomWallFaces(nodes: SceneNodes, zone: ZoneNode): RoomWallFace[];
+//# sourceMappingURL=room-faces.d.ts.map

package/dist/agent-operations/room-faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-faces.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-faces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAG7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAID,kGAAkG;AAClG,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAI/E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,YAAY,EAAE,CAgB/E"}

package/dist/agent-operations/room-faces.js

@@ -0,0 +1,31 @@
+import { isCurvedWall } from '../systems/wall/wall-curve.js';
+import { getWallZoneSpans } from '../systems/wall/wall-finish.js';
+const WHOLE = 1e-3;
+/** The walls that bound a room and carry a finish: its boundary walls, curtain walls left out. */
+export function roomBoundaryWalls(nodes, zone) {
+    return (zone.boundaryWallIds ?? [])
+        .map((id) => nodes[id])
+        .filter((wall) => wall?.type === 'wall' && wall.wallType !== 'curtain');
+}
+/**
+ * The faces that look into a room, a stretch each, in the order of the room's boundary walls: for a
+ * partition the face of this room and not the other's, for a wall that runs on past the room only the
+ * stretch the room stands on.
+ */
+export function roomWallFaces(nodes, zone) {
+    return roomBoundaryWalls(nodes, zone).flatMap((wall) => {
+        const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+        const curved = isCurvedWall(wall);
+        return getWallZoneSpans(wall, [zone]).map((span) => ({
+            wallId: wall.id,
+            face: span.face,
+            t0: span.t0,
+            t1: span.t1,
+            u0: span.t0 * length,
+            u1: span.t1 * length,
+            length,
+            whole: span.t0 < WHOLE && span.t1 > 1 - WHOLE,
+            curved,
+        }));
+    });
+}