@pascal-app/core 1.0.6 → 1.0.7

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

@@ -1,4 +1,5 @@
 import type { SceneNodes } from './types.js';
+import { type FloorUnclaimedIssue, type ZonesOverlapIssue } from './zone-coverage.js';
 /** A space the walls and separators enclose, where a finding about it places it. */
 type SpacePlace = {
     levelId: string;
@@ -11,14 +12,16 @@ type SpacePlace = {
 /**
  * A level's rooms against the spaces its walls and separators enclose (the editor's detected
  * spaces): a space no zone covers, a space several zones split, a room the walls do not close, a
- * room with no name.
+ * room with no name, two rooms on the same floor, floor in a covered space that no zone claims.
  */
 export type RoomFinding = ({
     type: 'space_no_room';
     message: string;
+    severity?: undefined;
 } & SpacePlace) | ({
     type: 'space_many_rooms';
     message: string;
+    severity?: undefined;
     zoneIds: string[];
 } & SpacePlace) | {
     type: 'room_not_enclosed';
@@ -33,7 +36,7 @@ export type RoomFinding = ({
     severity: 'info';
     levelId: string;
     zoneId: string;
-};
+} | ZonesOverlapIssue | FloorUnclaimedIssue;
 /**
  * A room is a zone with `spaceRole: 'room'`, or a generic one walls of a room's height bound along
  * most of its outline, which may be a room drawn before its last wall (no reconcile could adopt

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

@@ -1 +1 @@
-{"version":3,"file":"room-findings.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-findings.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,oFAAoF;AACpF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,CAAC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAAC,GACzD,CAAC;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,UAAU,CAAC,GAC/E;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AA6EhG;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAmF3C"}
+{"version":3,"file":"room-findings.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-findings.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EACL,KAAK,mBAAmB,EAGxB,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAA;AAExB,oFAAoF;AACpF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,CAAC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,UAAU,CAAC,GAC/E,CAAC;IACC,IAAI,EAAE,kBAAkB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,GAAG,UAAU,CAAC,GACf;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5F,iBAAiB,GACjB,mBAAmB,CAAA;AA6EvB;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAmH3C"}

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

@@ -3,6 +3,8 @@ import { polygonInteriorPoint } from '../lib/polygon-label.js';
 import { distanceToSegment } from '../lib/room-topology-index.js';
 import { detectSpacesForLevel } from '../lib/space-detection.js';
 import { nodesOnLevel } from './scene-queries.js';
+import { stairFootprintPolygons } from './stair-plan-footprint.js';
+import { floorUnclaimedIssues, wallBodies, zonesOverlapIssues, } from './zone-coverage.js';
 /** No name, or the bare word an older scene or a blank name leaves: "Room", "Zone". */
 const PLACEHOLDER_NAME = /^\s*(room|zone)?\s*$/i;
 /** A space is covered, a room enclosed, a zone in a space, and a zone walled like a room, past half. */
@@ -82,12 +84,18 @@ export function roomFindings(nodes, levelId, levelName) {
     const roomWalls = walls.filter((wall) => (wall.height ?? ROOM_WALL_HEIGHT) >= ROOM_WALL_HEIGHT);
     const rooms = zones.map((zone) => zone.spaceRole === 'room' || walled(zone, roomWalls) >= HALF);
     const issues = [];
+    /** The rooms each `space_many_rooms` names, which `zones_overlap` leaves to it. */
+    const splitSpaces = [];
+    /** The spaces zones cover past half: floor left over in them is a finding, a bare space is `space_no_room`. */
+    const coveredSpaces = [];
     spaces.forEach((space, index) => {
         const shape = spaceShapes[index];
         // A mezzanine stands over its room, and a zone no room (an analysis area) lies in it: neither
         // splits the space.
         const inside = zones.filter((zone, z) => rooms[z] && zone.floor?.support !== 'open' && covered(zoneShapes[z], [shape]) >= HALF);
         const noRoom = covered(shape, zoneShapes) < HALF;
+        if (!noRoom)
+            coveredSpaces.push(space);
         if (!noRoom && inside.length < 2)
             return;
         const spaceArea = round(shape.area);
@@ -98,6 +106,8 @@ export function roomFindings(nodes, levelId, levelName) {
             at: [x, z],
             wallIds: space.wallIds,
         };
+        if (!noRoom)
+            splitSpaces.push(new Set(inside.map((zone) => zone.id)));
         const where = `On ${levelName}, walls ${space.wallIds.join(', ')} enclose a ${spaceArea.toFixed(1)} m² space at (${x.toFixed(2)}, ${z.toFixed(2)})`;
         issues.push(noRoom
             ? { type: 'space_no_room', message: `${where} with no room over it.`, ...place }
@@ -139,5 +149,25 @@ export function roomFindings(nodes, levelId, levelName) {
                 zoneId: zone.id,
             });
     });
+    const floored = zones.filter((zone, index) => rooms[index] && zone.floor?.support !== 'open' && zone.hasFloor !== false);
+    // walls whose bodies cannot be read leave the floor unmeasured: neither rule says anything on this level
+    const bodies = wallBodies(walls);
+    if (bodies)
+        issues.push(...zonesOverlapIssues({
+            levelId,
+            levelName,
+            rooms: floored,
+            bodies,
+            skip: (a, b) => splitSpaces.some((ids) => ids.has(a.id) && ids.has(b.id)),
+        }), ...floorUnclaimedIssues({
+            levelId,
+            levelName,
+            spaces: coveredSpaces,
+            zones,
+            bodies,
+            stairs: onLevel
+                .filter((node) => node.type === 'stair')
+                .flatMap((stair) => stairFootprintPolygons(nodes, stair)),
+        }));
     return { spaces: spaces.length, issues };
 }

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

@@ -0,0 +1,87 @@
+import type { AnyNode, SceneMaterial, WallFace, WallNode, ZoneNode } from '../schema/index.js';
+import type { SceneNodes } from './types.js';
+/**
+ * What the rooms of a level show, read from the scene: the finish of each room's floor, of the
+ * wall faces that look into it and of its ceiling, and which rooms carry each finish. Pure facts
+ * for the write tools' results and the reads, as the renderer resolves them:
+ *
+ * - a floor shows the room's painted parts over the room's own `floor.finish` over its floor
+ *   plate's own surface (a slot older scenes carry: `paint` does not write a plate rooms derive);
+ * - a wall face shows its painted parts over the room's override for that face over the room's
+ *   `wallMaterial` over the wall's own finish (what `paint` writes on the wall);
+ * - a ceiling shows the room's painted parts over the ceiling's own surface.
+ *
+ * The painted parts of a floor and a ceiling are named apart, never folded into the finish a room
+ * shows as a whole; the painted parts of a wall face (`faceRegions`) are not read here. Nothing
+ * written reads `default`, as `paint` says it.
+ */
+export type FinishFact = {
+    /** The ref the finish is written as; null for the default and for an inline material. */
+    ref: string | null;
+    name: string;
+    /** The library's kind (wood, tile, colors…), for a library material. */
+    kind?: string;
+    /** The colour the library or the scene gives it, where it gives one. */
+    color?: string;
+};
+type Materials = Readonly<Record<string, SceneMaterial>> | undefined;
+type Finish = string | Record<string, unknown> | null | undefined;
+/** Nobody chose a finish here: the surface shows what the kind declares. */
+export declare const isDefaultFinish: (fact: FinishFact) => boolean;
+/** A finish as its words: the library's name and kind, the scene material's name, or the ref. */
+export declare function describeFinish(finish: Finish, materials?: Materials): FinishFact;
+export type RoomFinishes = {
+    floor?: FinishFact & {
+        regions?: {
+            id: string;
+            finish: FinishFact;
+        }[];
+    };
+    /** The wall faces that look into the room, by the finish each shows. */
+    walls?: {
+        faces: number;
+        finishes: {
+            finish: FinishFact;
+            faces: number;
+        }[];
+    };
+    ceiling?: FinishFact & {
+        regions?: {
+            id: string;
+            finish: FinishFact;
+        }[];
+    };
+};
+/** What one face of a wall shows to a room: the room's override for it, the room's finish, else the wall's own. */
+export declare function wallFaceFinish(zone: ZoneNode, wall: WallNode, face: WallFace, materials: Materials): FinishFact;
+/** What one room shows, from the nodes of its level. */
+export declare function roomFinishes(nodes: SceneNodes, zone: ZoneNode, content: readonly AnyNode[], materials?: Materials): RoomFinishes;
+export type FinishGroup = {
+    finish: FinishFact;
+    rooms: string[];
+};
+export type LevelFinishes = {
+    levelId: string;
+    levelName?: string;
+    floors?: FinishGroup[];
+    walls?: FinishGroup[];
+    ceilings?: FinishGroup[];
+};
+export type FinishSurface = 'floors' | 'walls' | 'ceilings';
+/**
+ * The rooms of a level by the finish each surface shows: which finish, and the rooms it is in.
+ * `surfaces` names the ones read and `roomIds` the rooms (all of them by default); null where no
+ * room read shows any of them.
+ */
+export declare function levelFinishes(nodes: SceneNodes, levelId: string, materials?: Materials, surfaces?: readonly FinishSurface[], roomIds?: ReadonlySet<string>): LevelFinishes | null;
+/**
+ * What the rooms a write changed now show, each surface for the rooms it was written on, read from
+ * the scene as it stands: the rooms the call touched and no others, and no row for a finish none of
+ * them shows (`default`: the rest of the level is `get_zones`'s). Per level; none where nothing is
+ * left to say.
+ */
+export declare function changedFinishes(nodes: SceneNodes, written: Partial<Record<FinishSurface, readonly string[]>>, materials?: Materials): LevelFinishes[];
+/** The rooms that show a painted surface: those a wall's painted faces look into, a ceiling's room. */
+export declare function roomsShowing(nodes: SceneNodes, node: AnyNode, roles: readonly string[]): string[];
+export {};
+//# sourceMappingURL=room-finishes.d.ts.map

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

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

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

@@ -0,0 +1,193 @@
+import { roomFloorPlate } from '../lib/room-floor-plate.js';
+import { getCatalogMaterialById, getLibraryMaterialIdFromRef, getSceneMaterialIdFromRef, } from '../material-library.js';
+import { getWallZoneSpans, resolveWallFaceChain } from '../systems/wall/wall-finish.js';
+import { levelIdOf, nodesOnLevel } from './scene-queries.js';
+const DEFAULT_FINISH = { ref: null, name: 'default' };
+/** Nobody chose a finish here: the surface shows what the kind declares. */
+export const isDefaultFinish = (fact) => fact.ref === null && fact.name === DEFAULT_FINISH.name;
+/** The colour an inline material (a stored finish record) or a scene material carries. */
+function colourOf(spec) {
+    if (!spec || typeof spec !== 'object')
+        return undefined;
+    const record = spec;
+    const own = record.properties?.color ?? record.color;
+    if (typeof own === 'string')
+        return own;
+    return record.material ? colourOf(record.material) : undefined;
+}
+/** A finish as its words: the library's name and kind, the scene material's name, or the ref. */
+export function describeFinish(finish, materials) {
+    if (finish === undefined || finish === null || finish === '')
+        return DEFAULT_FINISH;
+    if (typeof finish !== 'string') {
+        const color = colourOf(finish);
+        return { ref: null, name: 'an inline material', ...(color ? { color } : {}) };
+    }
+    const libraryId = getLibraryMaterialIdFromRef(finish);
+    if (libraryId) {
+        const item = getCatalogMaterialById(libraryId);
+        if (!item)
+            return { ref: finish, name: finish };
+        return {
+            ref: finish,
+            name: item.label,
+            kind: item.category,
+            ...(item.previewColor ? { color: item.previewColor } : {}),
+        };
+    }
+    const sceneId = getSceneMaterialIdFromRef(finish);
+    const scene = sceneId ? materials?.[sceneId] : undefined;
+    if (scene) {
+        const color = colourOf(scene.material);
+        return { ref: finish, name: scene.name, ...(color ? { color } : {}) };
+    }
+    return { ref: finish, name: finish };
+}
+/** One finish's identity, so rooms painted alike group together. */
+const keyOf = (fact) => fact.ref ?? (fact.name === DEFAULT_FINISH.name ? 'default' : `inline:${fact.color ?? ''}`);
+/** What a plate or a ceiling shows of its own: its surface slot, else its older finish fields. */
+const ownSurface = (node) => node ? (node.slots?.surface ?? node.material ?? node.materialPreset) : undefined;
+const regionsOf = (regions, materials) => regions?.length
+    ? { regions: regions.map((r) => ({ id: r.id, finish: describeFinish(r.finish, materials) })) }
+    : {};
+/** What one face of a wall shows to a room: the room's override for it, the room's finish, else the wall's own. */
+export function wallFaceFinish(zone, wall, face, materials) {
+    const override = zone.wallOverrides?.find((entry) => entry.wallId === wall.id && entry.face === face);
+    let finish = override?.finish ?? zone.wallMaterial;
+    if (finish === undefined) {
+        // The wall's own face: a chosen slot, an older finish, or nothing chosen.
+        const own = resolveWallFaceChain(wall, face);
+        finish =
+            own.kind === 'ref'
+                ? own.ref
+                : own.kind === 'legacy'
+                    ? (own.spec.materialPreset ?? own.spec.material)
+                    : undefined;
+    }
+    return describeFinish(finish, materials);
+}
+/** The wall faces that look into a room, and what each shows (the room's finish, else the wall's own). */
+function wallFaceFinishes(nodes, zone, materials) {
+    const shown = new Map();
+    let faces = 0;
+    for (const wallId of zone.boundaryWallIds ?? []) {
+        const wall = nodes[wallId];
+        if (wall?.type !== 'wall')
+            continue;
+        const looking = new Set(getWallZoneSpans(wall, [zone]).map((span) => span.face));
+        for (const face of looking) {
+            const fact = wallFaceFinish(zone, wall, face, materials);
+            const entry = shown.get(keyOf(fact)) ?? { finish: fact, faces: 0 };
+            entry.faces += 1;
+            shown.set(keyOf(fact), entry);
+            faces += 1;
+        }
+    }
+    return faces ? { faces, finishes: [...shown.values()] } : undefined;
+}
+/** What one room shows, from the nodes of its level. */
+export function roomFinishes(nodes, zone, content, materials) {
+    const shown = {};
+    if (zone.hasFloor !== false) {
+        const slabs = content.filter((node) => node.type === 'slab');
+        shown.floor = {
+            ...describeFinish(zone.floor?.finish ?? ownSurface(roomFloorPlate(slabs, zone.id)), materials),
+            ...regionsOf(zone.floor?.regions, materials),
+        };
+    }
+    const walls = wallFaceFinishes(nodes, zone, materials);
+    if (walls)
+        shown.walls = walls;
+    if (zone.hasCeiling !== false) {
+        const ceiling = content.find((node) => node.type === 'ceiling' && node.zoneId === zone.id);
+        if (ceiling)
+            shown.ceiling = {
+                ...describeFinish(ownSurface(ceiling), materials),
+                ...regionsOf(zone.ceiling?.regions, materials),
+            };
+    }
+    return shown;
+}
+/** The finish a surface shows as a whole, its painted parts left aside. */
+const wholeFinish = ({ ref, name, kind, color }) => ({
+    ref,
+    name,
+    ...(kind ? { kind } : {}),
+    ...(color ? { color } : {}),
+});
+const rooms = (content) => content.filter((node) => node.type === 'zone' && node.spaceRole === 'room');
+/**
+ * The rooms of a level by the finish each surface shows: which finish, and the rooms it is in.
+ * `surfaces` names the ones read and `roomIds` the rooms (all of them by default); null where no
+ * room read shows any of them.
+ */
+export function levelFinishes(nodes, levelId, materials, surfaces = ['floors', 'walls', 'ceilings'], roomIds) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const content = nodesOnLevel(nodes, levelId);
+    const floors = new Map();
+    const walls = new Map();
+    const ceilings = new Map();
+    const add = (groups, finish, room) => {
+        const group = groups.get(keyOf(finish)) ?? { finish, rooms: [] };
+        group.rooms.push(room);
+        groups.set(keyOf(finish), group);
+    };
+    const named = rooms(content).filter((zone) => !roomIds || roomIds.has(zone.id));
+    if (!named.length)
+        return null;
+    for (const zone of named) {
+        const shown = roomFinishes(nodes, zone, content, materials);
+        if (shown.floor)
+            add(floors, wholeFinish(shown.floor), zone.name);
+        for (const entry of shown.walls?.finishes ?? [])
+            add(walls, entry.finish, entry.faces < shown.walls.faces
+                ? `${zone.name} (${entry.faces} of ${shown.walls.faces} wall faces)`
+                : zone.name);
+        if (shown.ceiling)
+            add(ceilings, wholeFinish(shown.ceiling), zone.name);
+    }
+    const read = (surface, groups) => surfaces.includes(surface) && groups.size ? { [surface]: [...groups.values()] } : {};
+    const shown = {
+        ...read('floors', floors),
+        ...read('walls', walls),
+        ...read('ceilings', ceilings),
+    };
+    if (!Object.keys(shown).length)
+        return null;
+    return { levelId, ...(level.name ? { levelName: level.name } : {}), ...shown };
+}
+/**
+ * What the rooms a write changed now show, each surface for the rooms it was written on, read from
+ * the scene as it stands: the rooms the call touched and no others, and no row for a finish none of
+ * them shows (`default`: the rest of the level is `get_zones`'s). Per level; none where nothing is
+ * left to say.
+ */
+export function changedFinishes(nodes, written, materials) {
+    const byLevel = new Map();
+    for (const [surface, roomIds] of Object.entries(written)) {
+        const levelIds = [...new Set(roomIds.flatMap((id) => levelIdOf(nodes, id) ?? []))];
+        for (const levelId of levelIds) {
+            const shown = levelFinishes(nodes, levelId, materials, [surface], new Set(roomIds));
+            const groups = shown?.[surface]?.filter((group) => keyOf(group.finish) !== 'default');
+            if (shown && groups?.length)
+                byLevel.set(levelId, { ...byLevel.get(levelId), ...shown, [surface]: groups });
+        }
+    }
+    return [...byLevel.values()];
+}
+/** The rooms that show a painted surface: those a wall's painted faces look into, a ceiling's room. */
+export function roomsShowing(nodes, node, roles) {
+    if (node.type === 'ceiling')
+        return node.zoneId ? [node.zoneId] : [];
+    if (node.type !== 'wall')
+        return [];
+    const levelId = levelIdOf(nodes, node.id);
+    if (!levelId)
+        return [];
+    return rooms(nodesOnLevel(nodes, levelId))
+        .filter((zone) => zone.boundaryWallIds?.includes(node.id) &&
+        getWallZoneSpans(node, [zone]).some((span) => roles.includes(span.face)))
+        .map((zone) => zone.id);
+}

package/dist/agent-operations/room-floor-script.d.ts

@@ -13,9 +13,9 @@ export type SetRoomFloorScriptInput = {
 /**
  * `setRoomFloorScript`: a room's floor finish built by a three.js module, or the module taken off.
  * The host reads the room's floor (`floorScriptInputs`), compiles the module for it (geometry-script
- * `inputs`: the module reads `params.polygon`, `params.holes`, `params.elevation`, in level
- * coordinates) and stores the artifacts; this writes the result on the zone, with the key of the
- * floor it was built for. When the structure re-derives the room's floor the script is stale and
+ * `inputs`: the module reads `params.polygon` and `params.holes` in the level's plan x/z, and lays
+ * its finish from y = 0, the floor's surface) and stores the artifacts; this writes the result on
+ * the zone, with the key of the floor it was built for, and the renderer stands it on the plate. When the structure re-derives the room's floor the script is stale and
  * `refreshFinishScripts` runs it again. The script owns the floor's colours: paint on that floor is
  * refused while it is there.
  */

package/dist/agent-operations/room-floor-script.js

@@ -6,9 +6,9 @@ const round = (value) => Math.round(value * 1000) / 1000;
 /**
  * `setRoomFloorScript`: a room's floor finish built by a three.js module, or the module taken off.
  * The host reads the room's floor (`floorScriptInputs`), compiles the module for it (geometry-script
- * `inputs`: the module reads `params.polygon`, `params.holes`, `params.elevation`, in level
- * coordinates) and stores the artifacts; this writes the result on the zone, with the key of the
- * floor it was built for. When the structure re-derives the room's floor the script is stale and
+ * `inputs`: the module reads `params.polygon` and `params.holes` in the level's plan x/z, and lays
+ * its finish from y = 0, the floor's surface) and stores the artifacts; this writes the result on
+ * the zone, with the key of the floor it was built for, and the renderer stands it on the plate. When the structure re-derives the room's floor the script is stale and
  * `refreshFinishScripts` runs it again. The script owns the floor's colours: paint on that floor is
  * refused while it is there.
  */

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

@@ -0,0 +1,90 @@
+import { type RoomUse } from '../building/room-use.js';
+import { type SceneMaterial, type WallFace } from '../schema/index.js';
+import { type FinishFact } from './room-finishes.js';
+import { type Tiled } from './room-tile.js';
+import { type WetReading } from './room-wet.js';
+import type { SceneNodes } from './types.js';
+/**
+ * What each room of a scene shows and holds, read from the stored nodes alone (no brief, no model):
+ * the use its name gives it, whether its floor or its wall faces are tiled, whether those faces
+ * carry skirting, and the pieces standing in it. The room checks (`room-checks.ts`) judge these.
+ */
+export type RoomPiece = {
+    id: string;
+    /**
+     * What it is: a catalog or authored item's category, or, where the author gave only a generic one
+     * ("furniture"), its name without the words of its room and its number; `cabinet-run`, `shelf`, a
+     * placed design's recipe name.
+     */
+    kind: string;
+    /**
+     * Which recipe: a catalog item's id; an authored item's script, whatever parameters, size and
+     * colours it was run with (`script:<hash>`); a placed design's recipe; a run's make-up. Two pieces
+     * made by one function for two rooms have two artifacts and one script.
+     */
+    design: string;
+    /**
+     * An authored piece's size to 5 cm and its finishes: two pieces of one kind and one look are
+     * alike though two scripts made them. Absent for a piece with a recipe of its own.
+     */
+    look?: string;
+    name: string;
+    /** A piece hung on a wall: the wall, the face it is on and the metres along the wall. */
+    hung?: {
+        wallId: string;
+        face: WallFace;
+        u: number;
+    };
+};
+export type RoomReading = {
+    id: string;
+    name: string;
+    levelId: string;
+    levelName: string;
+    use: RoomUse;
+    /** False for a porch, alfresco, balcony or any room open on a side: no finish is owed there as indoors. */
+    indoor: boolean;
+    /**
+     * `fact` is what the floor shows as a whole, its painted parts (rugs) left aside; `atDefault` where nobody chose a finish and no
+     * script lays it; `held` where a floor plate of its own, a drawn slab it was taken from, or slabs over half its footprint are under it.
+     */
+    floor: {
+        finish: string;
+        tiled: Tiled;
+        fact: FinishFact;
+        atDefault: boolean;
+        held: boolean;
+    };
+    /**
+     * `facts` are the finishes the wall faces that look in show, each once.
+     */
+    walls: {
+        finishes: string[];
+        tiled: Tiled;
+        faces: number;
+        facts: FinishFact[];
+    };
+    /** A wet room's walls read against what a wet room is tiled to; absent for the other rooms. */
+    wet?: WetReading;
+    skirting: {
+        faces: number;
+        withSkirting: number;
+    };
+    pieces: RoomPiece[];
+};
+/** Tiled on the floor or on the walls; `unknown` while either surface cannot be read and none is tile. */
+export declare const roomTiled: (room: Pick<RoomReading, 'floor' | 'walls'>) => Tiled;
+/** Room contents and openings along its wall spans, including either side of a shared doorway. */
+export declare function roomIssueScope(nodes: SceneNodes, requested: string): {
+    roomId: `zone_${string}`;
+    room: string;
+    nodeIds: string[];
+}[];
+/**
+ * Every room of the scene (a zone that is a room and has a floor) as the checks read it, in level
+ * order then by name. `materials` are the scene's, when the host has them, to name `scene:` finishes.
+ */
+export declare function readRooms(nodes: SceneNodes, options?: {
+    materials?: Readonly<Record<string, SceneMaterial>>;
+}): RoomReading[];
+//# sourceMappingURL=room-readings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-readings.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-readings.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,OAAO,EAEb,MAAM,sBAAsB,CAAA;AAK7B,OAAO,EAKL,KAAK,aAAa,EAElB,KAAK,QAAQ,EAGd,MAAM,WAAW,CAAA;AAKlB,OAAO,EAAkB,KAAK,UAAU,EAAiC,MAAM,iBAAiB,CAAA;AAChG,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,EAAW,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA;AAErD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;GAIG;AAEH,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAA;IACV;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,yFAAyF;IACzF,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,GAAG,EAAE,OAAO,CAAA;IACZ,2GAA2G;IAC3G,MAAM,EAAE,OAAO,CAAA;IACf;;;OAGG;IACH,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAA;IAC5F;;OAEG;IACH,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,EAAE,CAAA;QAClB,KAAK,EAAE,KAAK,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,UAAU,EAAE,CAAA;KACpB,CAAA;IACD,+FAA+F;IAC/F,GAAG,CAAC,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAA;IACjD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAOD,0GAA0G;AAC1G,eAAO,MAAM,SAAS,SAAU,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC,KAAG,KACtB,CAAA;AAuVjD,kGAAkG;AAClG,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM;;;;IA4BlE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAA;CAAO,GACpE,WAAW,EAAE,CAsCf"}