@pascal-app/core 1.0.4 → 1.0.6

package/dist/agent-operations/material-refs.d.ts

@@ -1,4 +1,4 @@
-import { type MaterialSurface } from '../material-library.js';
+import type { MaterialSurface } from '../material-kinds.js';
 import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
 /** The surface a node's finish goes on, by its kind and the role or field painted. */
 export declare function finishSurface(type: string, role?: string): MaterialSurface | undefined;
@@ -7,6 +7,12 @@ export declare function finishSurface(type: string, role?: string): MaterialSurf
  * wall's wall materials, as the library tags them), then by the words they share with it.
  */
 export declare function nearestLibraryMaterials(asked: string, surface?: MaterialSurface, count?: number): string[];
+/**
+ * Whether a library id renders: the catalog's, or a well-formed community material's (`mtl_…`),
+ * which the host checks (the hosted MCP against its database, before the call). The materials a
+ * host registered can be a part of its library (those its scene uses), so they never refuse one.
+ */
+export declare function isLibraryMaterialId(id: string): boolean;
 /**
  * A material ref that renders: a library id the catalog holds (`library:<id>`, or the bare id), or
  * a scene material (`scene:<id>`, checked against the scene's materials when the host lends them).

package/dist/agent-operations/material-refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material-refs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-refs.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AA+B9E,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAGtF;AAYD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,EACzB,KAAK,SAAI,GACR,MAAM,EAAE,CAWV;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,EACzB,EACE,KAAa,EACb,SAAS,GACV,GAAE;IACD,8FAA8F;IAC9F,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,qDAAqD;IACrD,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAA;CACxD,GACL,MAAM,CAmCR"}
+{"version":3,"file":"material-refs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-refs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAOxD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AA+B9E,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAGtF;AAYD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,EACzB,KAAK,SAAI,GACR,MAAM,EAAE,CAWV;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,EACzB,EACE,KAAa,EACb,SAAS,GACV,GAAE;IACD,8FAA8F;IAC9F,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,qDAAqD;IACrD,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAA;CACxD,GACL,MAAM,CAiCR"}

package/dist/agent-operations/material-refs.js

@@ -1,5 +1,5 @@
 import { refuse } from '../agent-tools/refusal.js';
-import { getCatalogMaterialById, MATERIAL_CATALOG, parseMaterialRef, } from '../material-library.js';
+import { getCatalogMaterialById, isCommunityMaterialId, MATERIAL_CATALOG, parseMaterialRef, } from '../material-library.js';
 const SURFACE_WORDS = {
     roof: 'roofing',
     wall: 'wall material',
@@ -55,6 +55,14 @@ export function nearestLibraryMaterials(asked, surface, count = 3) {
         .slice(0, count)
         .map(({ entry }) => named(entry));
 }
+/**
+ * Whether a library id renders: the catalog's, or a well-formed community material's (`mtl_…`),
+ * which the host checks (the hosted MCP against its database, before the call). The materials a
+ * host registered can be a part of its library (those its scene uses), so they never refuse one.
+ */
+export function isLibraryMaterialId(id) {
+    return !!getCatalogMaterialById(id) || isCommunityMaterialId(id);
+}
 /**
  * A material ref that renders: a library id the catalog holds (`library:<id>`, or the bare id), or
  * a scene material (`scene:<id>`, checked against the scene's materials when the host lends them).
@@ -73,10 +81,7 @@ export function requireMaterialRef(asked, field, surface, { paint = false, mater
             });
         return asked;
     }
-    // A community material (`library:mtl_…`): the host checks it against its catalog.
-    if (parsed?.kind === 'library' && parsed.id.startsWith('mtl_'))
-        return asked;
-    if (parsed?.kind === 'library' && getCatalogMaterialById(parsed.id))
+    if (parsed?.kind === 'library' && isLibraryMaterialId(parsed.id))
         return `library:${parsed.id}`;
     const words = wordsOf(asked);
     const shares = (text) => words.some((word) => text.toLowerCase().includes(word));

package/dist/agent-operations/merge-windows.d.ts

@@ -0,0 +1,6 @@
+import type { AgentOperation } from './types.js';
+/** `merge_windows`: two windows that exist become one, a corner window or one wide window. */
+export declare const mergeWindowsOperation: AgentOperation<{
+    windowIds: [string, string];
+}>;
+//# sourceMappingURL=merge-windows.d.ts.map

package/dist/agent-operations/merge-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-windows.d.ts","sourceRoot":"","sources":["../../src/agent-operations/merge-windows.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAI3D,8FAA8F;AAC9F,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC;IAAE,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAyBjF,CAAA"}

package/dist/agent-operations/merge-windows.js

@@ -0,0 +1,27 @@
+import { mergeWindows } from '../building/merge-windows.js';
+import { achievedChanges } from './achieved.js';
+const round = (value) => Math.round(value * 1000) / 1000;
+/** `merge_windows`: two windows that exist become one, a corner window or one wide window. */
+export const mergeWindowsOperation = (nodes, input) => {
+    const merge = mergeWindows(nodes, input.windowIds[0], input.windowIds[1]);
+    const changes = {
+        update: merge.changes.update.map(({ id, data }) => ({ id, data: data })),
+        delete: merge.changes.delete,
+    };
+    return {
+        changes,
+        result: {
+            ok: true,
+            kind: merge.kind === 'corner' ? 'corner' : 'same_wall',
+            windowIds: merge.windowIds,
+            removedIds: merge.removedIds,
+            wallIds: merge.wallIds,
+            sillHeight: round(merge.sillHeight),
+            height: round(merge.height),
+            ...(merge.width === undefined ? {} : { width: round(merge.width) }),
+            ...(merge.angle === undefined ? {} : { angle: merge.angle }),
+            message: merge.message,
+            achieved: achievedChanges(nodes, changes),
+        },
+    };
+};

package/dist/agent-operations/move-roofs.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `move_roofs_to_roof_level`: the roof panel's "Move to the roof level" for agents. The roofs a
+ * storey holds on its own walls go to the level the rule gives them, standing where they stood.
+ */
+export declare const moveRoofsToRoofLevel: AgentOperation<{
+    levelId: string;
+}>;
+//# sourceMappingURL=move-roofs.d.ts.map

package/dist/agent-operations/move-roofs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-roofs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/move-roofs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAwBpE,CAAA"}

package/dist/agent-operations/move-roofs.js

@@ -0,0 +1,29 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { planRoofsOffStorey } from '../services/roof-move.js';
+import { requireLevel } from './level-target.js';
+/**
+ * `move_roofs_to_roof_level`: the roof panel's "Move to the roof level" for agents. The roofs a
+ * storey holds on its own walls go to the level the rule gives them, standing where they stood.
+ */
+export const moveRoofsToRoofLevel = (nodes, input) => {
+    const storey = requireLevel(nodes, input.levelId);
+    const move = planRoofsOffStorey(nodes, storey.id);
+    const name = `${getLevelDisplayName(storey)} (${storey.id})`;
+    if (!move)
+        refuse('no_roof_on_walls', `${name} holds no roof standing on its walls, so none hides its plan: a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong.`, { levelId: storey.id });
+    const roofIds = move.changes.update
+        .filter(({ id }) => nodes[id]?.type === 'roof')
+        .map(({ id }) => id);
+    const created = move.plan.kind === 'roof' ? move.plan.create : null;
+    const target = (created ?? nodes[move.plan.levelId]);
+    return {
+        result: {
+            roofIds,
+            roofLevelId: move.plan.levelId,
+            createdRoofLevelId: created?.id ?? null,
+            message: `Moved ${roofIds.length} roof${roofIds.length === 1 ? '' : 's'} off ${name} onto ${getLevelDisplayName(target)} (${target.id}), standing where ${roofIds.length === 1 ? 'it' : 'they'} stood.`,
+        },
+        changes: move.changes,
+    };
+};

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

@@ -6,7 +6,8 @@ import type { AgentOperation } from './types.js';
  * was refused and an unknown preset fell back to grey. A colour is the nearest of the library's
  * flat colours, said with how near; a native material is kept as a scene material. Slots are
  * written as the editor's slot paint writes them, a wall's faces through its paint plan, a roof's
- * role through its role field.
+ * role through its role field, on the roof: a roof shows one finish per surface, so a segment's
+ * finish goes on its roof.
  */
 type PaintInput = {
     targets: string[];

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/paint.ts"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,cAAc,EAKpB,MAAM,WAAW,CAAA;AAMlB,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAEvE;;;;;;;GAOG;AAEH,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,IAAI,CAAA;CACb,CAAA;AA6HD,eAAO,MAAM,KAAK,EAAE,cAAc,CAAC,UAAU,CAuI5C,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/paint.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,cAAc,EAOpB,MAAM,WAAW,CAAA;AAMlB,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAEvE;;;;;;;;GAQG;AAEH,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,IAAI,CAAA;CACb,CAAA;AAsKD,eAAO,MAAM,KAAK,EAAE,cAAc,CAAC,UAAU,CA8M5C,CAAA"}

package/dist/agent-operations/paint.js

@@ -1,13 +1,17 @@
 import { refuse } from '../agent-tools/refusal.js';
-import { ceilingSlots, columnSlots, doorSlots, fenceSlots, slabSlots, wallSlots, windowSlots, } from '../node-slots/index.js';
+import { wallFaceScriptPaintRefusal } from '../lib/wall-face-script.js';
+import { GLAZED_ROOF_SLOTS, nodeSlotDeclarations } from '../node-slots/index.js';
 import { nearestLibraryColorRef } from '../procedural-items/library-colors.js';
-import { getEffectiveSegmentSurfaceMaterial, } from '../schema/index.js';
+import { getEffectiveSegmentSurfaceMaterial, getWallTrimSlotId, isGlazedRoofSegment, } from '../schema/index.js';
 import { buildWallFinishLayout, getWallLevelZones } from '../systems/wall/wall-finish.js';
 import { planWallPaint } from '../systems/wall/wall-paint-plan.js';
-import { roomSideFaces } from '../systems/wall/wall-room-sides.js';
+import { roomFaceCover } from '../systems/wall/wall-room-sides.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
 import { resolveInlinePaintMaterial } from './scene-materials.js';
-const ROOF_ROLES = ['top', 'edge', 'wall'];
+const WALL_TRIMS = ['skirting', 'crown', 'chairRail'];
+const ROOF_ROLES = ['top', 'edge', 'wall', 'fascia'];
+/** The surfaces the roof itself holds; its fascia is held by each of its segments. */
+const SHELL_ROLES = ['top', 'edge', 'wall'];
 /** The surfaces painted when no role is named: what "paint the column" means. */
 const DEFAULT_ROLES = {
     wall: ['a', 'b', 'curtain-frame', 'curtain-solid'],
@@ -17,26 +21,15 @@ const DEFAULT_ROLES = {
     fence: ['posts', 'infill', 'base', 'rail'],
     door: ['panel', 'frame'],
     window: ['frame'],
+    'roof-segment': ['glazing-frame', 'glazing-solid'],
+    block: ['body'],
 };
-function slotsOf(node) {
-    switch (node.type) {
-        case 'wall':
-            return wallSlots(node);
-        case 'column':
-            return columnSlots(node);
-        case 'slab':
-            return slabSlots();
-        case 'ceiling':
-            return ceilingSlots();
-        case 'fence':
-            return fenceSlots(node);
-        case 'door':
-            return doorSlots();
-        case 'window':
-            return windowSlots();
-        default:
-            return null;
-    }
+/** The roles painted without one named: the kind's defaults, or the one surface it has. */
+function defaultRoles(type, ids) {
+    const defaults = DEFAULT_ROLES[type];
+    if (defaults)
+        return defaults.filter((role) => ids.includes(role));
+    return ids.length === 1 ? [...ids] : [];
 }
 /** The finish asked for, as the ref it writes; refused when it is unknown. */
 function finishOf(input, surface, context) {
@@ -80,8 +73,8 @@ function changedData(before, after) {
     }
     return data;
 }
-/** A roof's or a segment's role written, its inline material for that role gone with it. */
-function paintRoofRole(node, role, ref) {
+/** A node's role written as `<role>MaterialPreset`, its inline material for that role gone with it. */
+function paintRoleField(node, role, ref) {
     const next = { ...node };
     delete next[`${role}Material`];
     if (ref)
@@ -90,6 +83,30 @@ function paintRoofRole(node, role, ref) {
         delete next[`${role}MaterialPreset`];
     return next;
 }
+/**
+ * A segment without a finish of its own for a role, so its roof's shows there. A catch-all finish
+ * (`material`, `materialPreset`) goes too, written on the segment's other roles, which keep it.
+ */
+function withoutOwnRole(segment, role) {
+    const next = { ...segment };
+    if (segment.material !== undefined || segment.materialPreset !== undefined) {
+        for (const other of SHELL_ROLES) {
+            if (other === role)
+                continue;
+            const shown = getEffectiveSegmentSurfaceMaterial(segment, other);
+            next[`${other}Material`] = shown.material;
+            next[`${other}MaterialPreset`] = shown.materialPreset;
+        }
+        delete next.material;
+        delete next.materialPreset;
+    }
+    delete next[`${role}Material`];
+    delete next[`${role}MaterialPreset`];
+    for (const key of Object.keys(next))
+        if (next[key] === undefined)
+            delete next[key];
+    return next;
+}
 /**
  * A wall face painted whole, as the editor's Paint paints each part of it: the face's own finish,
  * and the finish of each room it is turned to, which shows over the face's own. Painted parts
@@ -104,6 +121,23 @@ function paintWallFace(nodes, wall, face, ref) {
     }
     return plan;
 }
+/**
+ * The faces of a wall turned out of its rooms, or into them: by the rooms on its sides, else by
+ * the sides it keeps (`frontSide` and `backSide`, as a generator or the room structure wrote
+ * them). A partition, with a room on each face, is interior on both. A face rooms stand on only in
+ * part (a wall running on past its rooms, into a garden) is both: it is refused, so the caller
+ * names the face to paint whole.
+ */
+function wallFacesTurned(scene, wall, side) {
+    const cover = roomFaceCover(scene, wall.id);
+    const faces = ['a', 'b'];
+    const part = faces.find((face) => cover[face] === 'part');
+    if (part)
+        refuse('side_unknown', `Wall ${wall.id}'s face ${part} is in a room for part of its length and outside for the rest: name the face to paint whole, a or b.`, { target: wall.id });
+    if (cover.a === 'none' && cover.b === 'none')
+        return faces.filter((face) => (face === 'a' ? wall.frontSide : wall.backSide) === side);
+    return faces.filter((face) => (cover[face] === 'whole') === (side === 'interior'));
+}
 export const paint = (nodes, input, context) => {
     // A refused material's nearest are the first target's kind: a roof is offered roofing.
     const first = input.targets[0] ? nodes[input.targets[0]] : undefined;
@@ -114,47 +148,113 @@ export const paint = (nodes, input, context) => {
     const scene = () => ({ ...nodes, ...written });
     const painted = [];
     const keptParts = [];
-    for (const id of input.targets) {
+    const throughRoof = [];
+    const modelRoles = [];
+    // A roof with glazed segments: its roles go on the roof for its standard segments, its glazing's
+    // on each glazed segment; a role only one kind has paints that kind.
+    const targets = [
+        ...new Set(input.targets.flatMap((id) => {
+            const node = nodes[id];
+            if (node?.type !== 'roof')
+                return [id];
+            const segments = node.children
+                .map((childId) => nodes[childId])
+                .filter((child) => child?.type === 'roof-segment');
+            const glazed = segments.filter(isGlazedRoofSegment).map((segment) => segment.id);
+            if (!glazed.length)
+                return [id];
+            const standard = glazed.length < segments.length;
+            const roles = [...(standard ? ROOF_ROLES : []), ...GLAZED_ROOF_SLOTS];
+            if (input.role !== undefined && !roles.includes(input.role))
+                refuse('unknown_role', `Roof ${id}'s roles are ${roles.join(', ')}.`, {
+                    target: id,
+                    roles,
+                });
+            const roofRole = input.role === undefined || ROOF_ROLES.includes(input.role);
+            return [...(standard && roofRole ? [id] : []), ...(roofRole && input.role ? [] : glazed)];
+        })),
+    ];
+    for (const id of targets) {
         const node = current(id);
         if (!node)
             refuse('target_not_found', `Nothing to paint: ${id} is not in the scene (a room edit may have replaced its walls: read the scene again). Nothing was painted.`, { target: id });
-        if (node.type === 'roof' || node.type === 'roof-segment') {
+        if (node.type === 'roof' || (node.type === 'roof-segment' && !isGlazedRoofSegment(node))) {
             const role = (input.role ?? 'top');
             if (!ROOF_ROLES.includes(role))
                 refuse('unknown_role', `A roof's roles are ${ROOF_ROLES.join(', ')}.`, {
                     target: id,
                     roles: [...ROOF_ROLES],
                 });
-            if (node.type === 'roof') {
-                // A segment's own finish for the role, or its catch-all, shows over its roof's.
-                const shadowing = node.children.filter((childId) => {
-                    const segment = current(childId);
-                    if (segment?.type !== 'roof-segment')
-                        return false;
-                    const own = getEffectiveSegmentSurfaceMaterial(segment, role);
-                    return own.material !== undefined || own.materialPreset !== undefined;
-                });
-                if (shadowing.length)
-                    refuse('shadowed_field', `The roof's ${role} would not show: segments ${shadowing.join(', ')} have their own. Paint the segments instead.`, { target: id, segments: shadowing });
+            const roof = node.type === 'roof' ? node : current(node.parentId ?? '');
+            if (roof?.type !== 'roof')
+                refuse('not_paintable', `Roof segment ${id} has no roof to paint.`, { target: id });
+            if (node.type === 'roof-segment')
+                throughRoof.push(id);
+            if (painted.some((entry) => entry.id === roof.id && entry.roles.includes(role)))
+                continue;
+            const segments = roof.children.flatMap((childId) => {
+                const segment = current(childId);
+                return segment?.type === 'roof-segment' ? [segment] : [];
+            });
+            if (role === 'fascia') {
+                // Each segment holds its fascia: the boards take it on every segment of the roof.
+                for (const segment of segments)
+                    written[segment.id] = paintRoleField(segment, role, ref);
+            }
+            else {
+                written[roof.id] = paintRoleField(roof, role, ref);
+                // The roof's finish shows on every segment: none keeps one of its own for the role.
+                for (const segment of segments)
+                    written[segment.id] = withoutOwnRole(segment, role);
+            }
+            painted.push({ id: roof.id, roles: [role] });
+            continue;
+        }
+        // A catalog item's surfaces are its model's (slot_<id> materials), which an operation cannot
+        // read: a host that has (assetViews) lets this name them; its role is written by name, as the
+        // editor's Paint writes the one clicked.
+        const declared = nodeSlotDeclarations(node);
+        if (!declared && node.type === 'item') {
+            const own = Object.keys(node.slots ?? {});
+            if (!input.role) {
+                const surfaces = context.assetViews?.[node.asset.id]?.surfaces ?? [];
+                const facts = [
+                    ...(surfaces.length ? [`its surfaces: ${surfaces.join(', ')}`] : []),
+                    ...(own.length ? [`painted so far: ${own.join(', ')}`] : []),
+                ];
+                refuse('unknown_role', `Item ${id}'s surfaces are its model's: name one as role${facts.length ? ` (${facts.join('; ')})` : ''}.`, { target: id, roles: surfaces.length ? [...surfaces] : own });
             }
-            written[id] = paintRoofRole(node, role, ref);
-            painted.push({ id, roles: [role] });
+            const slots = { ...(node.slots ?? {}) };
+            if (ref)
+                slots[input.role] = ref;
+            else
+                delete slots[input.role];
+            written[id] = { ...node, slots };
+            modelRoles.push(`${id} ${input.role}`);
+            painted.push({ id, roles: [input.role] });
             continue;
         }
-        const slots = slotsOf(node);
-        if (!slots)
-            refuse('not_paintable', `A ${node.type} has no finish paint gives: paint walls, columns, slabs, ceilings, fences, doors, windows or roofs.`, { target: id, type: node.type });
-        const ids = slots.map((slot) => slot.slotId);
+        if (!declared?.length)
+            refuse('not_paintable', `A ${node.type} has no surface paint gives: paint walls, slabs, ceilings, roofs, columns, fences, doors, windows, stairs, blocks, cabinets, shelves, items and the other built parts.`, { target: id, type: node.type });
+        const ids = declared.map((slot) => slot.slotId);
         let roles;
-        if (input.role === 'exterior' || input.role === 'interior') {
+        // On a wall, exterior and interior are its faces' sides; elsewhere they are slots by name.
+        if (node.type === 'wall' && (input.role === 'exterior' || input.role === 'interior')) {
             // A curtain wall has frame, glass and panels where a wall has faces.
-            if (node.type !== 'wall' || !ids.includes('a'))
-                refuse('unknown_role', `A ${node.type === 'wall' ? 'curtain wall' : node.type} has no ${input.role} face: its roles are ${ids.join(', ')}.`, { target: id, roles: ids });
-            const sides = roomSideFaces(scene(), id);
-            const face = input.role === 'interior' ? sides.inside : sides.outside;
-            if (!face)
-                refuse('side_unknown', `Wall ${id} has rooms on both sides or none: name its face, a or b.`, { target: id });
-            roles = [face];
+            if (!ids.includes('a'))
+                refuse('unknown_role', `A curtain wall has no ${input.role} face: its roles are ${ids.join(', ')}.`, { target: id, roles: ids });
+            roles = wallFacesTurned(scene(), node, input.role);
+            if (!roles.length)
+                refuse('side_unknown', `Wall ${id} has no ${input.role} face by its rooms or its stored sides: name its face, a or b.`, { target: id });
+        }
+        else if (node.type === 'wall' && WALL_TRIMS.includes(input.role)) {
+            // A trim named without a face is the trim on both faces, as a wall without a role is.
+            roles = ['a', 'b'].map((face) => getWallTrimSlotId(face, input.role));
+            if (!roles.every((role) => ids.includes(role)))
+                refuse('unknown_role', `A ${node.type}'s roles are ${ids.join(', ')}.`, {
+                    target: id,
+                    roles: ids,
+                });
         }
         else if (input.role) {
             if (!ids.includes(input.role))
@@ -165,7 +265,7 @@ export const paint = (nodes, input, context) => {
             roles = [input.role];
         }
         else
-            roles = (DEFAULT_ROLES[node.type] ?? []).filter((role) => ids.includes(role));
+            roles = defaultRoles(node.type, ids);
         if (!roles.length)
             refuse('unknown_role', `Name the ${node.type}'s surface: its roles are ${ids.join(', ')}.`, {
                 target: id,
@@ -175,6 +275,12 @@ export const paint = (nodes, input, context) => {
             const target = current(id);
             if (target.type === 'wall') {
                 const face = role === 'a' || role === 'b' ? role : null;
+                const scripted = face ? wallFaceScriptPaintRefusal(target, face) : undefined;
+                if (scripted)
+                    refuse('face_built_by_script', `${scripted.message} Nothing was painted.`, {
+                        target: id,
+                        face,
+                    });
                 Object.assign(written, face
                     ? paintWallFace(scene(), target, face, ref)
                     : planWallPaint(scene(), target, { kind: 'slot', slotId: role }, ref));
@@ -199,7 +305,11 @@ export const paint = (nodes, input, context) => {
     const createdMaterial = finish.created ? finish.sceneMaterial : undefined;
     const note = [
         finish.note,
+        throughRoof.length &&
+            `${throughRoof.join(', ')} ${throughRoof.length === 1 ? 'is a roof segment' : 'are roof segments'}: the finish went on the roof, which shows one finish per surface.`,
         keptParts.length && `Painted parts keep their own finish (${keptParts.join('; ')}).`,
+        modelRoles.length &&
+            `${modelRoles.join(', ')}: an item's surfaces are its model's, so a role its model lacks does not show.`,
     ]
         .filter(Boolean)
         .join(' ');

package/dist/agent-operations/photo-elevation.d.ts

@@ -0,0 +1,155 @@
+import { type Homography, type Vec3 } from '../building/photo-elevation.js';
+import type { SceneNodes } from './types.js';
+type Pt = [number, number];
+export type PhotoFaceInput = {
+    name?: string;
+    /** The walls of the face on one storey, end to end: their extent is the width. */
+    wallIds: string[];
+    /**
+     * Two points on each vertical edge of the face as seen, as fractions of the image. A face whose
+     * far edge leaves the photo gives only the corner it shares with another face of the call.
+     */
+    edges: {
+        left?: Pt[];
+        right?: Pt[];
+    };
+    /**
+     * The same feature on at least two storeys, two points along each, with its storey, and the
+     * feature's height above that floor when known (window heads 2.1 m): it sets the camera's height.
+     */
+    rows: {
+        levelId: string;
+        points: Pt[];
+        height?: number;
+    }[];
+    /** More horizontal lines on the face, two points each: they steady its vanishing point. */
+    lines?: Pt[][];
+    /**
+     * Points at known places on the face (window and door corners, eave ends): metres along it from
+     * its left end as seen, metres up from a floor (the face's, by default), and where the photo
+     * shows them. Each one steadies the pose.
+     */
+    points?: {
+        along: number;
+        height: number;
+        levelId?: string;
+        point: Pt;
+    }[];
+};
+export type PhotoElevationInput = {
+    faces: PhotoFaceInput[];
+    /**
+     * The camera's focal length on a 36 × 24 mm frame, when known: a frontal photo does not show
+     * it. A phone's main camera is about 26 mm.
+     */
+    focal35mm?: number;
+    /** More vertical lines anywhere on the building, two points each: they steady the camera's tilt. */
+    verticals?: Pt[][];
+};
+export type PhotoFacePlan = {
+    name: string;
+    widthMeters: number;
+    /**
+     * Metres along the face from its left end at the drawing's left and right sides: 0 and the
+     * width, unless the face runs out of the photo.
+     */
+    leftMeters: number;
+    rightMeters: number;
+    /** Metres above the lowest row's feature at the top and bottom of the drawing. */
+    topMeters: number;
+    bottomMeters: number;
+    pxPerMetre: number;
+    outWidth: number;
+    outHeight: number;
+    /** Drawing pixel to photo pixel. */
+    toSource: Homography;
+    /** Photo pixels per metre up each side of the drawing: few, and panes blur. */
+    sourcePxPerMetre: {
+        left: number;
+        right: number;
+    };
+    /** Root mean square of the picked points against the fit, in photo pixels. */
+    residualPx: number;
+    /** The picked feature on every storey the drawing shows, in drawing pixels. */
+    featureLines: {
+        levelId: string;
+        name: string;
+        y: number;
+    }[];
+    /** Where each row meets each edge in the photo, for a close-up to check. */
+    corners: {
+        edge: 'left' | 'right';
+        levelId: string;
+        point: Pt;
+        rowLine: [Pt, Pt];
+        edgeLine: [Pt, Pt];
+    }[];
+    /**
+     * Floor to floor between the rows' storeys, as the photo measures it and as the scene has it.
+     * Only with the camera: without it, the storeys are the drawing's vertical scale.
+     */
+    storeyHeight?: {
+        photo: number;
+        scene: number;
+    };
+    warnings: string[];
+};
+/** The camera several faces of the photo share. */
+export type PhotoCameraSummary = {
+    focalPx: number;
+    /** The focal length on a 36 × 24 mm frame: a phone's main camera is about 24–28 mm. */
+    focal35mm: number;
+    horizontalFovDeg: number;
+    /**
+     * Where the optical axis meets the photo, down from its top, in photo pixels: about half the
+     * photo's height for a phone photo as taken, near the horizon for a perspective-corrected one.
+     */
+    principalPointY: number;
+    /** The optical axis above the horizon (up is positive), and how far the photo is turned. */
+    pitchDeg: number;
+    rollDeg: number;
+    /** Camera from world, row-major: world x along the first face, y up, z out of it. */
+    rotation: number[];
+    /** The camera in the scene, for view_scene; null when the faces leave its side unknown. */
+    pose: PhotoPose | null;
+    assumptions: string;
+    warnings: string[];
+};
+/** Where the photo was taken from, in the scene's coordinates (y up), as view_scene takes it. */
+export type PhotoPose = {
+    projection: 'perspective';
+    position: Vec3;
+    target: Vec3;
+    /** The camera's up, which carries the photo's roll. */
+    up: Vec3;
+    /** Vertical field of view, degrees. */
+    fov: number;
+    /** The photo's width over its height. */
+    aspect: number;
+    /** How far below the photo's middle its optical axis meets it, as a share of its height. */
+    shift: number;
+    /** What set the camera's height: the rows' feature height, or the edges' foot taken for the ground. */
+    anchoredBy: 'row height' | 'edge base';
+    /** The focal length was taken (focal35mm, else a phone's), not read from the photo. */
+    focalAssumed: boolean;
+    /** The picked edges against the walls' ends projected through the pose, in photo pixels. */
+    edgeResidualPx: number;
+    /** How far the eye moves, in metres, when the picks move by their own error. */
+    spread?: number;
+};
+/**
+ * Plans the straightening of each face of a photo, pixels being the host's. Several faces, or one
+ * whose far edge leaves the photo, share the photo's one camera, found from the vanishing points
+ * of the picked lines: each face is then K·[along up origin], metric from its walls' width, and
+ * the storeys are measured. One face with both edges, or faces no camera fits, are each fitted
+ * from their own rows × edges, their heights from the storeys.
+ */
+export declare function planPhotoElevation(nodes: SceneNodes, input: PhotoElevationInput, image: {
+    width: number;
+    height: number;
+}): {
+    faces: PhotoFacePlan[];
+    camera: PhotoCameraSummary | null;
+};
+export {};
+//# sourceMappingURL=photo-elevation.d.ts.map

package/dist/agent-operations/photo-elevation.d.ts.map

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