@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/verify-scene.js

@@ -1,17 +1,32 @@
 import { levelBuildingId } from '../building/level-duplication.js';
+import { levelGradeStanding } from '../lib/grade-standing.js';
+import { groundSeat } from '../lib/ground-seat.js';
 import { getLevelDisplayName } from '../lib/level-name.js';
+import { HIDDEN_SITE_NOTE } from '../lib/node-visibility.js';
+import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
 import { detectOpenWallEnds } from '../lib/room-graph.js';
+import { siteBrief } from '../lib/site-placement.js';
+import { nodeRegistry } from '../registry/index.js';
 import { AnyNode as AnyNodeSchema } from '../schema/index.js';
-import { getStoredLevelHeight } from '../services/storey.js';
+import { nodeSchemaForKind } from '../schema/compiled-node-parsers.js';
+import { isCeilingGeometry } from '../services/roof-level.js';
+import { isRoofOnStoreyWalls } from '../services/roof-move.js';
+import { getStoredLevelHeight, getWallCoveringSlabs, getWallTop } from '../services/storey.js';
+import { getStoreyDatum } from '../services/storey-datum.js';
 import { computeSegmentTransforms, rotateXZ } from '../systems/stair/stair-footprint.js';
-import { resolveStairTotalRise } from '../systems/stair/stair-rise-query.js';
+import { resolveStairTotalRise, stairClimbsToNoStorey, stairReachesStoreyAbove, } from '../systems/stair/stair-rise-query.js';
 import { measureStair } from '../systems/stair/stair-sizing.js';
 import { checkOpeningWithinWall, formatOpeningBoundsIssue } from '../validation/opening-bounds.js';
+import { ceilingObjectObservations, } from './ceiling-object-observations.js';
 import { layoutIssuesFromScene } from './layout-clearance.js';
 import { wallResolvedHeight } from './level-reads.js';
 import { pointInPolygon, polygonContainsPolygon } from './plan-geometry.js';
+import { roomFindings } from './room-findings.js';
+import { EMPTY_SESSION } from './scene-checkpoint.js';
 import { changesSince } from './scene-measure.js';
 import { contentCounts, levelIdOf, levelRole, levelsOf, nodesOnLevel, } from './scene-queries.js';
+import { reviewSince } from './scene-review.js';
+import { wallObjectObservations } from './wall-object-observations.js';
 export const CHECKPOINT_ORDER = 100;
 const checks = [];
 const reports = [];
@@ -131,32 +146,90 @@ function parentListsChild(parent, childId) {
             child.id === childId);
     });
 }
-function schemaErrors(nodes) {
+/** How many of a kind no schema knows an issue names. */
+const UNKNOWN_KIND_IDS = 5;
+/**
+ * A stored node with the fields its schema defaults filled where it lacks them (a level stored with
+ * no `children`), else the node itself: a host reads its own state by identity (the editor's
+ * rendered-mesh evidence checks the node is the store's current one).
+ */
+function withDefaults(node, parsed) {
+    const stored = node;
+    const filled = Object.entries(parsed).filter(([key, value]) => stored[key] === undefined && value !== undefined);
+    return filled.length === 0 ? node : { ...node, ...Object.fromEntries(filled) };
+}
+/**
+ * Every node checked by its kind's schema: the host's where it lends one, else the registered
+ * kind's, else core's. The checks that measure read each node with its defaults filled. A node its schema
+ * rejects is listed field by field and left `unread`: they could not read it. A node of a kind no
+ * schema here knows (a plugin's, where the plugin is not loaded) is counted by kind and kept as
+ * stored: the checks never read it.
+ */
+function checkSchemas(scene, hostSchema) {
     const errors = [];
-    for (const [id, node] of Object.entries(nodes)) {
-        const parsed = AnyNodeSchema.safeParse(node);
-        if (parsed.success)
+    const unknownKinds = new Map();
+    const unread = new Set();
+    const measured = {};
+    for (const [id, node] of Object.entries(scene)) {
+        const type = node?.type;
+        const schema = typeof type === 'string' && type !== ''
+            ? (hostSchema?.(type) ?? nodeRegistry.get(type)?.schema ?? nodeSchemaForKind(type))
+            : AnyNodeSchema;
+        if (!schema) {
+            unknownKinds.set(String(type), [...(unknownKinds.get(String(type)) ?? []), id]);
+            measured[id] = node;
+            continue;
+        }
+        const parsed = schema.safeParse(node);
+        if (parsed.success) {
+            measured[id] = withDefaults(node, parsed.data);
             continue;
+        }
         for (const issue of parsed.error.issues)
             errors.push({ nodeId: id, path: issue.path.join('.'), message: issue.message });
+        unread.add(id);
     }
-    return errors;
+    return { errors, unknownKinds, unread, measured };
 }
 /**
- * `verify_scene`: a self-check after complex edits. Per-level content and roles, then every
- * practical problem found, typed: rooms missing floors or ceilings, roof levels misused, storeys
- * with no stair, openings off their wall, stairs off their slab, blocked doors, overlapping
- * furniture, nodes their schema rejects.
+ * `verify_scene`: a self-check after complex edits. Per-level content, roles and enclosed spaces,
+ * then every practical problem found, typed: spaces with no room, rooms the walls do not close or
+ * with no name, rooms missing floors or ceilings, roof levels misused, storeys with no stair,
+ * openings off their wall, stairs off their slab, blocked doors, overlapping furniture, and every
+ * field a node's schema rejects, by node and path; a kind no schema here knows, once per kind.
  */
-export const verifyScene = (nodes, input, context) => {
+export const verifyScene = (scene, input, context) => {
+    const { errors, unknownKinds, unread, measured: nodes } = checkSchemas(scene, context.nodeSchema);
     const onLevel = (levelId) => nodesOnLevel(nodes, levelId);
     const ofType = (content, type) => content.filter((node) => node.type === type);
+    // A level holding a node its schema rejects is measured once that node is fixed: around it, a
+    // room would read open for the wall left out, a door off its wall, a sofa far from any wall. So
+    // are its building's stairs, which a level, a slab or a stair left out would change.
+    const unreadOn = new Map();
+    const holdingUnread = new Set();
+    for (const id of unread) {
+        const levelId = levelIdOf(scene, id);
+        if (levelId)
+            unreadOn.set(levelId, [...(unreadOn.get(levelId) ?? []), id]);
+        for (let at = scene[id]?.parentId; at && !holdingUnread.has(at); at = scene[at]?.parentId)
+            holdingUnread.add(at);
+    }
+    // What the checks across levels read: the scene without the levels that wait.
+    const settled = unreadOn.size === 0
+        ? nodes
+        : Object.fromEntries(Object.entries(nodes).filter(([id]) => !unreadOn.has(levelIdOf(scene, id) ?? '')));
+    // A roof level holds the roof, no rooms.
+    const rooms = new Map();
     const levels = levelsOf(nodes).map((level) => {
         const content = contentCounts(onLevel(level.id));
         const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
+        const levelName = getLevelDisplayName(level);
+        const found = role === 'roof' ? { spaces: 0, issues: [] } : roomFindings(nodes, level.id, levelName);
+        rooms.set(level.id, found.issues);
+        const unreadIds = unreadOn.get(level.id);
         return {
             levelId: level.id,
-            levelName: getLevelDisplayName(level),
+            levelName,
             floorIndex: level.level,
             role,
             metadataRole,
@@ -166,15 +239,22 @@ export const verifyScene = (nodes, input, context) => {
             isActive: level.id === context.activeLevelId,
             isEmpty: Object.values(content).every((count) => count === 0),
             content,
+            /** The spaces its walls and separators enclose. */
+            spaces: found.spaces,
+            /** Nodes on it its schema rejects: its counts leave them out, its findings wait for them. */
+            ...(unreadIds && { unread: unreadIds }),
         };
     });
+    const buildingOf = (levelId) => levelBuildingId(nodes, nodes[levelId]);
     const issues = [];
     const report = (type, message, informational = false) => issues.push({ type, message, ...(informational ? { severity: 'info' } : {}) });
-    const empty = levels.filter((level) => level.isEmpty);
+    const empty = levels.filter((level) => level.isEmpty && !level.unread);
     if (empty.length > 0)
         report('empty_levels', `${empty.length} empty level(s): ${empty.map((level) => `${level.levelName} (${level.levelId})`).join(', ')}`);
     for (const level of levels) {
         const { content, levelName } = level;
+        if (level.unread)
+            continue;
         // A free-standing wall (garden wall, half wall) is legitimate, not something to repair.
         for (const end of detectOpenWallEnds(nodes, level.levelId)) {
             if (end.reason === 'isolated')
@@ -190,15 +270,27 @@ export const verifyScene = (nodes, input, context) => {
             });
         }
         if (level.role === 'roof') {
-            if (content.roofs === 0)
+            // Roof geometry a plugin draws (roof planes) is no `roof` node, and is still the roof.
+            if (onLevel(level.levelId).length === 0)
                 report('roof_level_no_roof', `${levelName} is a roof support level but has no roof geometry; add or move roof geometry there rather than deleting the support level to satisfy story count`);
-            if (occupiedContent(content) > 0)
-                report('roof_level_occupied', `${levelName} is a roof support level but contains occupied-story content; move rooms, walls, stairs, slabs, ceilings, and items to an occupied story and keep the roof level for roof geometry only`);
-            const reference = level.referenceLevelId ? nodes[level.referenceLevelId] : undefined;
-            if (reference?.type === 'level' && level.floorIndex <= reference.level)
-                report('roof_level_below_reference', `${levelName} roof support level should be above its reference occupied level ${reference.name ?? reference.id}`);
+            const retainedCeilings = onLevel(level.levelId).filter((node) => node.type === 'item' && isCeilingGeometry(node)).length;
+            if (occupiedContent(content) - retainedCeilings > 0)
+                report('roof_level_occupied', `${levelName} is a roof support level but contains occupied-story content; move rooms, walls, stairs, slabs, native room ceilings, and ordinary items to an occupied story; roof geometry and classified retained ceiling shells can stay`);
+            // An empty storey counts: it is a floor still to be built, and the roof goes above it.
+            const storeyAbove = levels.find((other) => other.isOccupiedStory &&
+                other.floorIndex > level.floorIndex &&
+                buildingOf(other.levelId) === buildingOf(level.levelId));
+            if (storeyAbove)
+                report('roof_level_not_on_top', `${levelName} is a roof level below the storey ${storeyAbove.levelName} (${storeyAbove.levelId}): exploded and solo views show its roof inside the building. A building's roof level stays above its storeys: move the storey under it, or the roof onto the roof level on top.`);
             continue;
         }
+        // The ground line: a basement the stack stands at grade is drawn over the terrain, not in it.
+        const asNodes = nodes;
+        if (level.floorIndex < 0 && levelGradeStanding(asNodes, level.levelId) === 'at-grade')
+            report('basement_at_grade', `${levelName} is floor index ${level.floorIndex}, below the ground floor, but its floor stands at grade (${(getStoreyDatum(nodes, level.levelId)?.floorElevation ?? 0).toFixed(2)} m): its walls rise from the terrain instead of standing down in it. set_ground_level on the level that stands at grade (the floor over it) seats the building, and the levels under it read below grade.`, true);
+        const seat = groundSeat(asNodes, buildingOf(level.levelId) ?? '');
+        if (seat?.levelId === level.levelId && seat.explicit && !seat.seated)
+            report('ground_level_unseated', `${levelName} is the ground floor, but its floor datum stands ${seat.offset.toFixed(2)} m ${seat.offset > 0 ? 'over' : 'under'} grade (${seat.gradeElevation.toFixed(2)} m); a seated ground floor stands between grade and ${seat.aboveGrade} m (the top of the ${seat.foundation.construction.label} foundation) over it. set_ground_level on it seats the building.`, true);
         if (content.walls > 0 && content.zones === 0)
             report('walls_no_zones', `${levelName} has walls but no zones/rooms`);
         if (content.zones > 0 && content.slabs === 0)
@@ -207,8 +299,36 @@ export const verifyScene = (nodes, input, context) => {
             report('zones_no_ceilings', `${levelName} has zones but no ceilings`);
         if (content.walls > 0 && content.doors === 0)
             report('walls_no_doors', `${levelName} has walls but no doors`);
-        if (content.roofs > 0 && (content.walls > 0 || content.zones > 0 || content.stairs > 0))
-            report('roof_mixed_in_storey', `${levelName} mixes roof geometry with occupied-level content; place roofs on a dedicated roof level for solo/exploded level views`);
+        issues.push(...rooms.get(level.levelId));
+        // A roof standing on the walls of the storey holding it: the ones move_roofs_to_roof_level
+        // takes off. A porch's on its posts, a lower wing's on the walls below, are where they belong.
+        const onWalls = nodes[level.levelId].children.filter((id) => isRoofOnStoreyWalls(nodes, id));
+        if (onWalls.length > 0)
+            report('roof_mixed_in_storey', `${levelName} mixes roof geometry with occupied-level content; place roofs on a dedicated roof level for solo/exploded level views. On its own walls: ${onWalls.join(', ')}; move_roofs_to_roof_level with levelId ${level.levelId} moves them there as they stand (never delete and rebuild them); by hand, "Move to the roof level" on the roof's panel`);
+    }
+    for (const level of levels) {
+        for (const wall of ofType(onLevel(level.levelId), 'wall')) {
+            const base = wallSupportForNodes(wall, nodes).elevation;
+            const wallTop = getWallTop(wall, level.levelId, nodes, base);
+            for (const { slab, top: slabTop, underside: slabUnderside } of getWallCoveringSlabs(wall, level.levelId, nodes)) {
+                const penetration = Math.max(0, Math.min(wallTop, slabTop) - Math.max(base, slabUnderside));
+                const coplanar = Math.abs(wallTop - slabTop) <= 1e-6;
+                if (penetration <= 1e-6 && !coplanar)
+                    continue;
+                issues.push({
+                    type: 'wall_covering_slab_contact',
+                    message: `Wall ${wall.id} top at ${wallTop.toFixed(3)}m intersects covering slab ${slab.id} [${slabUnderside.toFixed(3)}, ${slabTop.toFixed(3)}]m${coplanar ? ' and is coplanar with its walking surface' : ''}; check the wall height or the slab opening.`,
+                    wallId: wall.id,
+                    slabId: slab.id,
+                    levelId: level.levelId,
+                    wallTop,
+                    slabUnderside,
+                    slabTop,
+                    penetration,
+                    coplanar,
+                });
+            }
+        }
     }
     // Storeys are counted per building: separate buildings need no stair between them, and a wall
     // can only span the storeys of its own building.
@@ -220,17 +340,20 @@ export const verifyScene = (nodes, input, context) => {
         const buildingId = levelBuildingId(nodes, node) ?? '';
         storeysByBuilding.set(buildingId, [...(storeysByBuilding.get(buildingId) ?? []), level]);
     }
+    // Porch or deck steps, a flight to no level, stand on a storey without connecting it to another.
     for (const [buildingId, storeys] of storeysByBuilding) {
         if (storeys.length < 2)
             continue;
-        const stairs = levels
+        if (holdingUnread.has(buildingId))
+            continue;
+        const connected = levels
             .filter((level) => {
             const node = nodes[level.levelId];
             return (levelBuildingId(nodes, node) ?? '') === buildingId;
         })
-            .reduce((sum, level) => sum + level.content.stairs, 0);
-        if (stairs === 0)
-            report('missing_stair', `${nodes[buildingId]?.name ?? 'The building'} has ${storeys.length} storeys and no stair: add one on the ground floor, in the hall or entry, to connect them.`);
+            .some((level) => ofType(onLevel(level.levelId), 'stair').some((stair) => stairReachesStoreyAbove(stair, nodes)));
+        if (!connected)
+            report('missing_stair', `${nodes[buildingId]?.name ?? 'The building'} has ${storeys.length} storeys and no stair between them: add one on the ground floor, in the hall or entry, to connect them.`);
     }
     for (const storeys of storeysByBuilding.values()) {
         if (storeys.length < 2)
@@ -245,7 +368,7 @@ export const verifyScene = (nodes, input, context) => {
             }
         }
     }
-    for (const node of Object.values(nodes)) {
+    for (const node of Object.values(settled)) {
         if (node.type !== 'door' && node.type !== 'window')
             continue;
         const parent = node.parentId ? nodes[node.parentId] : undefined;
@@ -260,16 +383,20 @@ export const verifyScene = (nodes, input, context) => {
         for (const issue of checkOpeningWithinWall(node, parent, wallResolvedHeight(nodes, parent)))
             report(issue.kind === 'along_wall' ? 'opening_outside_wall' : 'opening_outside_height', formatOpeningBoundsIssue(issue));
     }
-    for (const stair of Object.values(nodes).filter((node) => node.type === 'stair')) {
+    for (const stair of Object.values(settled).filter((node) => node.type === 'stair')) {
+        const sourceLevelId = levelIdOf(nodes, stair.id);
+        if (sourceLevelId && holdingUnread.has(buildingOf(sourceLevelId) ?? ''))
+            continue;
         const stairName = stair.name ?? stair.id;
         for (const diagnostic of measureStair(stair, nodes).diagnostics)
             report(`stair_${diagnostic.code.replaceAll('-', '_')}`, `Stair ${stairName}: ${diagnostic.message}`, diagnostic.code.endsWith('-target'));
-        const sourceLevelId = levelIdOf(nodes, stair.id);
         if (sourceLevelId) {
             const sourceName = nodes[sourceLevelId]?.name ?? sourceLevelId;
             const footprints = stairFootprintPolygons(nodes, stair);
             const sourceSlabs = ofType(onLevel(sourceLevelId), 'slab');
+            // Porch, deck or garden steps start on the ground, off the floor slab.
             if (sourceSlabs.length > 0 &&
+                !stairClimbsToNoStorey(stair, nodes) &&
                 footprints.some((footprint) => !sourceSlabs.some((slab) => polygonContainsPolygon(slab.polygon, footprint))))
                 report('stair_outside_slab', `Stair ${stairName} footprint extends outside source floor slab on ${sourceName}`);
             for (const wall of ofType(onLevel(sourceLevelId), 'wall'))
@@ -310,25 +437,73 @@ export const verifyScene = (nodes, input, context) => {
                     report('stair_opening_outside_slab', `Stair ${stairName} opening extends outside slab ${slab.name ?? slab.id}`);
         }
     }
-    const errors = schemaErrors(nodes);
-    for (const error of errors.slice(0, 5))
-        report('schema_invalid', `Schema: ${error.nodeId}.${error.path} ${error.message}`);
-    if (errors.length > 5)
-        report('schema_invalid', `Schema: ${errors.length - 5} additional validation errors`);
+    // Where each building stands on its lot: past the lot line or into the required yards is a
+    // problem, off-centre is not.
+    for (const building of Object.values(nodes)) {
+        if (building.type !== 'building')
+            continue;
+        const brief = siteBrief(nodes, { buildingId: building.id });
+        if (!brief)
+            continue;
+        const name = building.name ?? 'The building';
+        if (brief.buildable.state === 'none')
+            report('buildable_area_none', `The setbacks leave nothing to build on this lot: check the site's setbacks before standing ${name} on it.`);
+        const footprint = brief.footprint;
+        if (!footprint)
+            continue;
+        const sides = footprint.overhang.sides.join(', ');
+        if (footprint.fit === 'outside')
+            report('footprint_outside_site', `${name} reaches ${footprint.overhang.lotM.toFixed(1)} m past the lot line (${sides}): place_building centres it in the buildable area; a plan bigger than the lot needs saying so.`);
+        else if (footprint.fit === 'lot' && brief.buildable.state !== 'none')
+            report('footprint_outside_setbacks', `${name} stands ${footprint.overhang.setbacksM.toFixed(1)} m into the required yards (${sides}): place_building centres it in the buildable area.`);
+    }
+    for (const { nodeId, path, message } of errors)
+        issues.push({
+            type: 'schema_invalid',
+            message: `Schema: ${path ? `${nodeId}.${path}` : nodeId} ${message}`,
+            nodeId,
+            path,
+        });
+    for (const [kind, nodeIds] of unknownKinds)
+        issues.push({
+            type: 'schema_unknown_kind',
+            message: `No schema here knows kind ${kind} (${nodeIds.length} node${nodeIds.length === 1 ? '' : 's'}): a plugin's, not checked here.`,
+            severity: 'info',
+            kind,
+            count: nodeIds.length,
+            nodeIds: nodeIds.slice(0, UNKNOWN_KIND_IDS),
+        });
+    // A hidden site, read as stored: a malformed one is still hidden.
+    for (const [id, site] of Object.entries(scene))
+        if (site?.type === 'site' && site.visible === false)
+            issues.push({
+                type: 'site_hidden',
+                message: `Site ${id} is hidden. ${HIDDEN_SITE_NOTE}`,
+                severity: 'info',
+                nodeId: id,
+            });
     // Door keep-outs and item–item footprint overlaps (rotation-aware).
-    issues.push(...layoutIssuesFromScene(Object.values(nodes)));
+    issues.push(...layoutIssuesFromScene(Object.values(settled)));
+    issues.push(...ceilingObjectObservations(settled));
+    issues.push(...wallObjectObservations(settled));
     for (const check of checks)
         if (check.order < CHECKPOINT_ORDER)
-            issues.push(...check.run(nodes, input ?? {}));
+            issues.push(...check.run(settled, input ?? {}));
     // What the edits since the host's checkpoint lost, by place.
-    const since = context.checkpoint
-        ? changesSince(context.checkpoint, nodes)
+    const hosted = context.checkpoint
+        ? changesSince(context.checkpoint, scene)
         : null;
-    if (since)
-        issues.push(...since.issues);
+    if (hosted)
+        issues.push(...hosted.issues);
+    // The look back: what the agent did since a moment it named. The places the registered families
+    // lost count as issues, as a window gone from its place always did.
+    const session = context.session ?? EMPTY_SESSION;
+    const since = typeof input?.since === 'string' ? reviewSince(session, input.since, scene) : null;
+    if (since?.places)
+        issues.push(...since.places.issues);
     for (const check of checks)
         if (check.order >= CHECKPOINT_ORDER)
-            issues.push(...check.run(nodes, input ?? {}));
+            issues.push(...check.run(settled, input ?? {}));
     const occupiedStoryCount = levels.filter((level) => level.isOccupiedStory).length;
     return {
         result: {
@@ -342,12 +517,16 @@ export const verifyScene = (nodes, input, context) => {
             levels,
             emptyLevelIds: empty.map((level) => level.levelId),
             issues,
-            hasIssues: issues.some((issue) => issue.severity !== 'info'),
+            hasIssues: issues.some((issue) => !('severity' in issue && issue.severity === 'info')),
             ...authoredObjects(nodes),
             ...Object.assign({}, ...reports.map((report) => report.run(nodes))),
-            ...(since && {
-                sinceCheckpoint: { name: context.checkpoint.name, changes: since.changes },
+            ...(Object.keys(session.checkpoints).length
+                ? { checkpoints: Object.keys(session.checkpoints) }
+                : {}),
+            ...(hosted && {
+                sinceCheckpoint: { name: context.checkpoint.name, changes: hosted.changes },
             }),
+            ...(since && { since }),
         },
     };
 };

package/dist/agent-operations/wall-face-script.d.ts

@@ -0,0 +1,28 @@
+import { type WallFaceScriptInputs } from '../lib/wall-face-script.js';
+import { type CompiledGeometryScript } from '../schema/index.js';
+import type { WallFace } from '../schema/nodes/wall.js';
+import type { AgentOperation } from './types.js';
+export type SetWallFaceScriptInput = {
+    wallId: string;
+    face: WallFace;
+    /** The module compiled for `inputs` (`wallFaceScriptInputs` of the face, read before compiling). */
+    compiled: CompiledGeometryScript;
+    inputs: WallFaceScriptInputs;
+    /** Metres above the face's base the script stops at; absent, it covers the whole face. */
+    toHeight?: number;
+} | {
+    wallId: string;
+    face: WallFace;
+    remove: true;
+};
+/**
+ * `setWallFaceScript`: one wall face's finish built by a three.js module, or the module taken off.
+ * The host reads the face (`wallFaceScriptInputs`), compiles the module for it (geometry-script
+ * `inputs`: the module reads `params.outline`, `params.holes`, `params.base`, `params.thickness`
+ * in the face's frame) and stores the artifacts; this writes the result on the wall, with the key
+ * of the face it was built for. When the wall or its openings change the script is stale and
+ * `refreshFinishScripts` runs it again. A script to the top owns the face's colours: paint on that
+ * face is refused while it is there.
+ */
+export declare const setWallFaceScript: AgentOperation<SetWallFaceScriptInput>;
+//# sourceMappingURL=wall-face-script.d.ts.map

package/dist/agent-operations/wall-face-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-face-script.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-face-script.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,oBAAoB,EAG1B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,KAAK,sBAAsB,EAAiC,MAAM,WAAW,CAAA;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,sBAAsB,GAC9B;IACE,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,oGAAoG;IACpG,QAAQ,EAAE,sBAAsB,CAAA;IAChC,MAAM,EAAE,oBAAoB,CAAA;IAC5B,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GACD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAA;AAIpD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,sBAAsB,CAoEpE,CAAA"}

package/dist/agent-operations/wall-face-script.js

@@ -0,0 +1,62 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { scriptedSize } from '../lib/geometry-script-node.js';
+import { wallFaceScriptInputs, wallFaceScriptRecord, } from '../lib/wall-face-script.js';
+import { WallFaceScript } from '../schema/index.js';
+const round = (value) => Math.round(value * 1000) / 1000;
+/**
+ * `setWallFaceScript`: one wall face's finish built by a three.js module, or the module taken off.
+ * The host reads the face (`wallFaceScriptInputs`), compiles the module for it (geometry-script
+ * `inputs`: the module reads `params.outline`, `params.holes`, `params.base`, `params.thickness`
+ * in the face's frame) and stores the artifacts; this writes the result on the wall, with the key
+ * of the face it was built for. When the wall or its openings change the script is stale and
+ * `refreshFinishScripts` runs it again. A script to the top owns the face's colours: paint on that
+ * face is refused while it is there.
+ */
+export const setWallFaceScript = (nodes, input) => {
+    const wall = nodes[input.wallId];
+    if (wall?.type !== 'wall')
+        refuse('target_not_found', `${input.wallId} is not a wall in the scene: nothing was changed.`, {
+            target: input.wallId,
+        });
+    const name = wall.name?.trim() || wall.id;
+    const { face } = input;
+    if ('remove' in input) {
+        if (!wall.finishScripts?.[face])
+            return { result: { ok: true, wallId: wall.id, face, removed: false } };
+        const { [face]: _, ...kept } = wall.finishScripts;
+        const finishScripts = Object.keys(kept).length ? kept : undefined;
+        return {
+            result: { ok: true, wallId: wall.id, face, removed: true },
+            changes: { update: [{ id: wall.id, data: { finishScripts } }] },
+        };
+    }
+    const { compiled, toHeight } = input;
+    if (compiled.language !== 'three')
+        refuse('three_only', `A wall face script is a three.js module: it is given the face, which a Blender build is not. Nothing was changed on ${name}.`, { target: wall.id });
+    if (toHeight !== undefined && !(toHeight > 0))
+        refuse('invalid_height', `toHeight is metres above the face's base, above 0: nothing was changed on ${name}.`, {
+            target: wall.id,
+        });
+    if (!wallFaceScriptInputs(nodes, wall.id, face, toHeight))
+        refuse('no_face', `${name}'s face ${face} has nothing a script can build on (a curved or curtain wall, or no height): nothing was changed.`, { target: wall.id });
+    const { min, max } = compiled.manifest.bounds;
+    if (![...min, ...max].every(Number.isFinite))
+        refuse('unmeasurable_object', `${name}'s face script built geometry that cannot be measured: a mesh in it has a position, rotation or scale that is not a number. Nothing was changed.`, { target: wall.id });
+    const script = WallFaceScript.parse(wallFaceScriptRecord(compiled, input.inputs, toHeight, wall.finishScripts?.[face]));
+    return {
+        result: {
+            ok: true,
+            wallId: wall.id,
+            face,
+            size: scriptedSize(compiled.manifest).map(round),
+            slots: compiled.manifest.slots.map((slot) => slot.id),
+            triangles: compiled.manifest.triangles,
+            note: toHeight === undefined
+                ? `The script owns the colours of ${name}'s face ${face}: painting that face is refused until the script is removed. It runs again whenever the wall or its openings change.`
+                : `The script builds ${name}'s face ${face} up to ${round(toHeight)} m; the face above stays paintable. It runs again whenever the wall or its openings change.`,
+        },
+        changes: {
+            update: [{ id: wall.id, data: { finishScripts: { ...wall.finishScripts, [face]: script } } }],
+        },
+    };
+};

package/dist/agent-operations/wall-object-observations.d.ts

@@ -0,0 +1,41 @@
+import { type Ring } from '../lib/polygon-boolean.js';
+import type { AnyNode } from '../schema/index.js';
+type Vec3 = [number, number, number];
+export type WallObjectFace = {
+    normal: Vec3;
+    depth: number;
+    polygon: Ring;
+};
+/** Geometry evidence in the host wall's local frame, after all corrective model transforms. */
+export type WallObjectGeometry = {
+    corners: Vec3[];
+    faces: WallObjectFace[];
+};
+type Evidence = {
+    severity?: 'info';
+    itemId: string;
+    wallId: string;
+    levelId: string;
+    side: 'front' | 'back';
+    coordinateFrame: 'building';
+    bounds?: {
+        min: Vec3;
+        max: Vec3;
+    };
+    evidence: 'script_bounds' | 'rendered_bounds' | 'rendered_faces' | 'mount_orientation';
+};
+export type WallObjectObservation = Evidence & {
+    type: 'item_wall_body_overlap' | 'item_through_wall' | 'item_faces_wall' | 'item_wall_coplanar_face' | 'item_wall_object_coplanar_face';
+    message: string;
+    overlapDepthMeters?: number;
+    beyondOppositeFaceMeters?: number;
+    overlapAreaSquareMeters?: number;
+    frontDotOutward?: number;
+    otherItemId?: string;
+    separationMeters?: number;
+    toleranceMeters?: number;
+};
+/** Bounds contact is not exact mesh intersection; rendered face patches are assessed only when supplied. */
+export declare function wallObjectObservations(nodes: Readonly<Record<string, AnyNode>>, rendered?: Readonly<Record<string, WallObjectGeometry>>): WallObjectObservation[];
+export {};
+//# sourceMappingURL=wall-object-observations.d.ts.map

package/dist/agent-operations/wall-object-observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-object-observations.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,IAAI,EAEV,MAAM,wBAAwB,CAAA;AAQ/B,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAI5D,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3E,+FAA+F;AAC/F,MAAM,MAAM,kBAAkB,GAAG;IAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAC7E,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,CAAA;IACjC,QAAQ,EAAE,eAAe,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,mBAAmB,CAAA;CACvF,CAAA;AACD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG;IAC7C,IAAI,EACA,wBAAwB,GACxB,mBAAmB,GACnB,iBAAiB,GACjB,yBAAyB,GACzB,gCAAgC,CAAA;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAiID,4GAA4G;AAC5G,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAM,GAC1D,qBAAqB,EAAE,CAoJzB"}