@pascal-app/core 1.0.4 → 1.0.6

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

@@ -0,0 +1,249 @@
+import { getOpeningWallCut, wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { area, difference, intersection, union, } from '../lib/polygon-boolean.js';
+import { boundsOf, boxCorners, frame, rotateVector, transformPoint, } from '../procedural-items/spatial.js';
+import { getLevelElevations, getWallTop } from '../services/storey.js';
+import { getWallBodyCenterOffset, getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+const TOLERANCE = 0.001;
+const MIN_FACE_AREA = 0.04;
+const finiteVector = (v) => v.length === 3 && v.every(Number.isFinite);
+const rectangle = (left, bottom, right, top) => [
+    [left, bottom],
+    [right, bottom],
+    [right, top],
+    [left, top],
+];
+function projectedHull(corners) {
+    const points = corners
+        .map(([x, y]) => [x, y])
+        .sort((a, b) => a[0] - b[0] || a[1] - b[1])
+        .filter((p, i, all) => !i || p[0] !== all[i - 1][0] || p[1] !== all[i - 1][1]);
+    const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    const half = (input) => {
+        const hull = [];
+        for (const p of input) {
+            while (hull.length > 1 && cross(hull.at(-2), hull.at(-1), p) <= 0)
+                hull.pop();
+            hull.push(p);
+        }
+        hull.pop();
+        return hull;
+    };
+    return [...half(points), ...half([...points].reverse())];
+}
+function scriptGeometry(item, wall) {
+    const bounds = item.source?.manifest.bounds;
+    const assetScale = item.asset.scale ?? [1, 1, 1];
+    if (!bounds ||
+        item.source?.manifest.animations?.length ||
+        ![
+            bounds.min,
+            bounds.max,
+            item.position,
+            item.rotation,
+            item.scale,
+            item.asset.offset,
+            item.asset.rotation,
+            assetScale,
+        ].every(finiteVector) ||
+        bounds.min.some((v, axis) => v > bounds.max[axis]) ||
+        [...item.scale, ...assetScale].some((v) => v <= 0))
+        return;
+    const z = item.asset.attachTo === 'wall-side'
+        ? getWallLocalFaceZ(wall, item.side === 'front' ? 'a' : 'b')
+        : item.position[2] + getWallBodyCenterOffset(wall);
+    const pose = frame([item.position[0], item.position[1], z], item.rotation);
+    const corners = boxCorners(bounds.min, bounds.max).map((point) => {
+        const rotated = rotateVector(point.map((v, axis) => v * assetScale[axis]), item.asset.rotation);
+        return transformPoint(pose, rotated.map((v, axis) => (v + item.asset.offset[axis]) * item.scale[axis]));
+    });
+    return corners.every(finiteVector) ? { corners, faces: [] } : undefined;
+}
+function wallSolid(wall, nodes) {
+    const support = wallSupportForNodes(wall, nodes).elevation;
+    const height = getWallTop(wall, wall.parentId, nodes, support) - support;
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    if (![height, length, support, wall.thickness ?? 0.1].every(Number.isFinite) ||
+        height <= 0 ||
+        length <= 0)
+        return;
+    const holes = [];
+    for (const child of Object.values(nodes)) {
+        if (child.parentId !== wall.id)
+            continue;
+        // Wall cutters have no persisted XY outline: their bounds cannot prove solid contact.
+        if ((child.type === 'item' || child.type === 'door' || child.type === 'window') &&
+            child.source?.manifest.cutout)
+            return;
+        if (child.type !== 'door' && child.type !== 'window')
+            continue;
+        const cut = getOpeningWallCut(wall, child, nodes);
+        // For shaped openings the enclosing rectangle conservatively withholds evidence.
+        holes.push(rectangle(child.position[0] - child.width / 2, cut.bottom - support, child.position[0] + child.width / 2, cut.top - support));
+    }
+    return difference(rectangle(0, 0, length, height), union(holes));
+}
+function facePatches(faces) {
+    const patches = [];
+    for (const face of faces) {
+        if (!finiteVector(face.normal) ||
+            !Number.isFinite(face.depth) ||
+            Math.abs(face.normal[2]) < 0.999 ||
+            face.polygon.length < 3 ||
+            face.polygon.some((p) => !p.every(Number.isFinite)))
+            continue;
+        const sign = Math.sign(face.normal[2]);
+        const existing = patches.find((patch) => patch.sign === sign && Math.abs(patch.depth - face.depth) < 1e-5);
+        if (existing)
+            existing.rings.push(face.polygon);
+        else
+            patches.push({ depth: face.depth, sign, rings: [face.polygon] });
+    }
+    return patches
+        .map(({ rings, ...patch }) => ({ ...patch, polygons: union(rings) }))
+        .filter((patch) => area(patch.polygons) >= MIN_FACE_AREA);
+}
+/** Bounds contact is not exact mesh intersection; rendered face patches are assessed only when supplied. */
+export function wallObjectObservations(nodes, rendered = {}) {
+    const observations = [];
+    const elevations = getLevelElevations(nodes);
+    const solids = new Map();
+    const peers = [];
+    for (const item of Object.values(nodes)) {
+        if (item.type !== 'item' ||
+            !item.visible ||
+            item.roofSegmentId ||
+            item.blockFaceId ||
+            (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') ||
+            item.source?.manifest.animations?.length ||
+            item.source?.manifest.cutout)
+            continue;
+        const wall = item.parentId ? nodes[item.parentId] : undefined;
+        const level = wall?.parentId ? nodes[wall.parentId] : undefined;
+        if (wall?.type !== 'wall' ||
+            !wall.visible ||
+            wall.curveOffset ||
+            level?.type !== 'level' ||
+            !level.visible ||
+            !finiteVector(item.rotation) ||
+            !finiteVector(item.scale) ||
+            item.scale.some((v) => v <= 0) ||
+            ![...wall.start, ...wall.end, wall.thickness ?? 0.1, elevations.get(level.id)?.baseY].every(Number.isFinite) ||
+            (wall.thickness ?? 0.1) <= 0)
+            continue;
+        if (!solids.has(wall.id))
+            solids.set(wall.id, wallSolid(wall, nodes));
+        const solid = solids.get(wall.id);
+        const geometry = rendered[item.id] ?? scriptGeometry(item, wall);
+        // A wall-side item with no `side` is drawn on the back face (the item system and the plan
+        // symbols read `side === 'front' ? a : b`): observed where it is drawn.
+        const side = item.side === 'front' ? 'front' : 'back';
+        const sign = side === 'front' ? 1 : -1;
+        const hostFace = getWallLocalFaceZ(wall, sign > 0 ? 'a' : 'b');
+        const oppositeFace = getWallLocalFaceZ(wall, sign > 0 ? 'b' : 'a');
+        const evidence = {
+            itemId: item.id,
+            wallId: wall.id,
+            levelId: level.id,
+            side,
+            coordinateFrame: 'building',
+            evidence: geometry
+                ? rendered[item.id]
+                    ? 'rendered_bounds'
+                    : 'script_bounds'
+                : 'mount_orientation',
+        };
+        if (geometry?.corners.length && geometry.corners.every(finiteVector)) {
+            const local = boundsOf(geometry.corners);
+            const projection = projectedHull(geometry.corners);
+            const solidArea = solid ? area(intersection(projection, solid)) : undefined;
+            // Entirely in a cutout (or outside the finite host) is not wall contact evidence.
+            if (solidArea !== undefined && solidArea <= 1e-6)
+                continue;
+            const support = wallSupportForNodes(wall, nodes).elevation;
+            const wallPose = frame([wall.start[0], (elevations.get(level.id)?.baseY ?? 0) + support, wall.start[1]], [0, -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]), 0]);
+            const world = boundsOf(geometry.corners.map((p) => transformPoint(wallPose, p)));
+            evidence.bounds = { min: world.min, max: world.max };
+            const overlap = Math.min(local.max[2], Math.max(hostFace, oppositeFace)) -
+                Math.max(local.min[2], Math.min(hostFace, oppositeFace));
+            if (solidArea !== undefined && overlap > TOLERANCE) {
+                observations.push({
+                    ...evidence,
+                    type: 'item_wall_body_overlap',
+                    overlapDepthMeters: overlap,
+                    overlapAreaSquareMeters: solidArea,
+                    toleranceMeters: TOLERANCE,
+                    message: `Object ${item.id} transformed bounds overlap wall ${wall.id} body by ${overlap.toFixed(3)} m in depth over ${solidArea.toFixed(3)} m² in projection; bounds overlap is not an exact mesh intersection`,
+                });
+            }
+            const beyond = sign > 0 ? oppositeFace - local.min[2] : local.max[2] - oppositeFace;
+            if (solidArea !== undefined && beyond > TOLERANCE)
+                observations.push({
+                    ...evidence,
+                    type: 'item_through_wall',
+                    beyondOppositeFaceMeters: beyond,
+                    toleranceMeters: TOLERANCE,
+                    message: `Object ${item.id} transformed bounds extend ${beyond.toFixed(3)} m beyond the opposite face of wall ${wall.id}`,
+                });
+            const patches = facePatches(geometry.faces);
+            peers.push({ evidence, patches });
+            if (solid)
+                for (const patch of patches) {
+                    // Opposed normals describe hidden back-to-wall contact, not two competing visible faces.
+                    if (patch.sign !== sign || Math.abs(patch.depth - hostFace) > TOLERANCE)
+                        continue;
+                    const overlapArea = area(intersection(patch.polygons, solid));
+                    if (overlapArea < MIN_FACE_AREA)
+                        continue;
+                    observations.push({
+                        ...evidence,
+                        evidence: 'rendered_faces',
+                        type: 'item_wall_coplanar_face',
+                        overlapAreaSquareMeters: overlapArea,
+                        separationMeters: Math.abs(patch.depth - hostFace),
+                        toleranceMeters: TOLERANCE,
+                        message: `Object ${item.id} has ${overlapArea.toFixed(3)} m² of rendered outward face within ${TOLERANCE} m of host wall ${wall.id} face; coplanar visible faces can depth-fight`,
+                    });
+                }
+        }
+        if (item.source && !finiteVector(item.asset.rotation))
+            continue;
+        const correctedFront = item.source
+            ? rotateVector([0, 0, 1], item.asset.rotation)
+            : [0, 0, 1];
+        const front = rotateVector(correctedFront.map((v, axis) => v * item.scale[axis]), item.rotation);
+        const dot = (front[2] * sign) / Math.hypot(...front);
+        if (dot < -0.5)
+            observations.push({
+                ...evidence,
+                type: 'item_faces_wall',
+                evidence: 'mount_orientation',
+                frontDotOutward: dot,
+                message: `Object ${item.id} mounted on wall ${wall.id} ${side} side has its corrected +Z front toward the wall (front·outward ${dot.toFixed(3)})`,
+            });
+    }
+    for (let i = 0; i < peers.length; i++)
+        for (const other of peers.slice(i + 1)) {
+            const item = peers[i];
+            if (item.evidence.wallId !== other.evidence.wallId)
+                continue;
+            for (const a of item.patches)
+                for (const b of other.patches) {
+                    if (a.sign !== b.sign || Math.abs(a.depth - b.depth) > TOLERANCE)
+                        continue;
+                    const overlap = area(intersection(a.polygons, b.polygons));
+                    if (overlap < MIN_FACE_AREA)
+                        continue;
+                    observations.push({
+                        ...item.evidence,
+                        evidence: 'rendered_faces',
+                        type: 'item_wall_object_coplanar_face',
+                        otherItemId: other.evidence.itemId,
+                        overlapAreaSquareMeters: overlap,
+                        separationMeters: Math.abs(a.depth - b.depth),
+                        toleranceMeters: TOLERANCE,
+                        message: `Wall-mounted objects ${item.evidence.itemId} and ${other.evidence.itemId} have ${overlap.toFixed(3)} m² of same-facing rendered faces within ${TOLERANCE} m; coplanar visible faces can depth-fight`,
+                    });
+                }
+        }
+    return observations;
+}

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

@@ -8,29 +8,29 @@ import type { SceneChanges, SceneNodes } from './types.js';
 export declare function addWallOpening(nodes: SceneNodes, input: WallOpeningInput): {
     changes: SceneChanges;
     result: {
-        message: string;
-        achieved: Achieved;
-        sillHeight?: number | undefined;
+        ok: true;
+        doorId: `door_${string}` | `window_${string}`;
         wallId: string;
         localX: number;
         t: number;
         wallLength: number;
         clamped: boolean;
-        coordinateSystem: "wall-local-meters";
-        doorId: `door_${string}` | `window_${string}`;
-        ok: true;
-    } | {
+        coordinateSystem: 'wall-local-meters';
+        sillHeight?: number | undefined;
         message: string;
         achieved: Achieved;
-        sillHeight?: number | undefined;
+    } | {
+        ok: true;
+        windowId: `door_${string}` | `window_${string}`;
         wallId: string;
         localX: number;
         t: number;
         wallLength: number;
         clamped: boolean;
-        coordinateSystem: "wall-local-meters";
-        windowId: `door_${string}` | `window_${string}`;
-        ok: true;
+        coordinateSystem: 'wall-local-meters';
+        sillHeight?: number | undefined;
+        message: string;
+        achieved: Achieved;
     };
 };
 /**
@@ -38,28 +38,28 @@ export declare function addWallOpening(nodes: SceneNodes, input: WallOpeningInpu
  * read from where it stands after the rebuild, with what the script reported.
  */
 export declare function rebuiltOpeningResult(nodesAfter: SceneNodes, nodeId: string, summary: Record<string, unknown>, achieved: Achieved): {
-    achieved: Achieved;
-    message: string;
-    sillHeight?: number | undefined;
+    ok: true;
+    doorId: string;
     wallId: string;
     localX: number;
     t: number;
     wallLength: number;
     clamped: boolean;
-    coordinateSystem: "wall-local-meters";
-    doorId: string;
-    ok: true;
-} | {
-    achieved: Achieved;
-    message: string;
+    coordinateSystem: 'wall-local-meters';
     sillHeight?: number | undefined;
+    message: string;
+    achieved: Achieved;
+} | {
+    ok: true;
+    windowId: string;
     wallId: string;
     localX: number;
     t: number;
     wallLength: number;
     clamped: boolean;
-    coordinateSystem: "wall-local-meters";
-    windowId: string;
-    ok: true;
+    coordinateSystem: 'wall-local-meters';
+    sillHeight?: number | undefined;
+    message: string;
+    achieved: Achieved;
 };
 //# sourceMappingURL=wall-opening.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wall-opening.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-opening.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAClF,OAAO,EAAE,KAAK,QAAQ,EAAmB,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxE;AAUD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAwBnB"}
+{"version":3,"file":"wall-opening.d.ts","sourceRoot":"","sources":["../../src/agent-operations/wall-opening.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAClF,OAAO,EAAE,KAAK,QAAQ,EAAmB,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,gBAAgB;;;;;;;;;;0BAejD,mBAAmB;;;;;;;;;;;;0BAAnB,mBAAmB;;;;;EAM1C;AAUD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,QAAQ,EAAE,QAAQ;;;;;;;;sBAkBE,mBAAmB;;;;;;;;;;;;sBAAnB,mBAAmB;;;;EAMxC"}

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

@@ -0,0 +1,24 @@
+import { type WallTrimProfile } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type SetWallSkirtingInput = {
+    wallIds: string[];
+    /** False hides the skirting and keeps its settings; absent or true shows it. */
+    enabled?: boolean;
+    /** Metres up the face from its base. */
+    height?: number;
+    /** Metres it stands proud of the face (stored as `proud`). */
+    depth?: number;
+    profile?: WallTrimProfile;
+    /** The faces it runs along; absent, the faces a room stands on. */
+    faces?: 'a' | 'b' | 'both';
+    /** A `library:` / `scene:` ref or a `#rrggbb` colour, painted as `paint` paints it; absent keeps the skirting's finish. */
+    finish?: string;
+};
+/**
+ * `setWallSkirting`: a wall's skirting (baseboard) shown, sized and finished in one write, the one
+ * the wall panel makes. It is a property of the wall, so it follows the wall wherever the wall
+ * goes, steps with its base and breaks at its doors and floor-length openings. The finish is the
+ * skirting slot of each face it runs along, painted through `paint`.
+ */
+export declare const setWallSkirting: AgentOperation<SetWallSkirtingInput>;
+//# sourceMappingURL=wall-skirting.d.ts.map

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

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

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

@@ -0,0 +1,85 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { getWallTrimFaces, getWallTrimSlotId, } from '../schema/index.js';
+import { roomFaceCover } from '../systems/wall/wall-room-sides.js';
+import { wallTrimPatch } from '../systems/wall/wall-trim.js';
+import { paint } from './paint.js';
+/**
+ * The faces a wall's skirting runs along when none are named: those a room stands on, else those
+ * its stored sides call interior. A wall with neither is refused, so the caller names its faces.
+ */
+function roomFaces(nodes, wall) {
+    const cover = roomFaceCover(nodes, wall.id);
+    const faces = ['a', 'b'].filter((face) => cover[face] !== 'none');
+    if (faces.length)
+        return faces;
+    const interior = ['a', 'b'].filter((face) => (face === 'a' ? wall.frontSide : wall.backSide) === 'interior');
+    if (interior.length)
+        return interior;
+    refuse('side_unknown', `Wall ${wall.id} has no room on either face: name the faces its skirting runs along, a, b or both.`, { target: wall.id });
+}
+const positive = (value, field) => {
+    if (value !== undefined && !(Number.isFinite(value) && value > 0))
+        refuse('invalid_size', `A skirting's ${field} is a length above 0 m.`, { field });
+};
+/**
+ * `setWallSkirting`: a wall's skirting (baseboard) shown, sized and finished in one write, the one
+ * the wall panel makes. It is a property of the wall, so it follows the wall wherever the wall
+ * goes, steps with its base and breaks at its doors and floor-length openings. The finish is the
+ * skirting slot of each face it runs along, painted through `paint`.
+ */
+export const setWallSkirting = (nodes, input, context) => {
+    positive(input.height, 'height');
+    positive(input.depth, 'depth');
+    const scratch = { ...nodes };
+    const walls = [];
+    for (const id of new Set(input.wallIds)) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            refuse('target_not_found', `${id} is not a wall in the scene: nothing was changed.`, {
+                target: id,
+            });
+        if (wall.wallType === 'curtain')
+            refuse('curtain_wall', `Wall ${id} is a curtain wall: it has no skirting.`, { target: id });
+        const faces = input.faces === undefined ? roomFaces(nodes, wall) : getWallTrimFaces(input.faces);
+        const { skirting } = wallTrimPatch(wall, 'skirting', {
+            enabled: input.enabled ?? true,
+            sides: faces.length === 2 ? 'both' : faces[0],
+            ...(input.height === undefined ? {} : { height: input.height }),
+            ...(input.depth === undefined ? {} : { proud: input.depth }),
+            ...(input.profile === undefined ? {} : { profile: input.profile }),
+        });
+        scratch[id] = { ...wall, skirting };
+        walls.push({ id, faces, height: skirting.height, depth: skirting.proud });
+    }
+    let note;
+    if (input.finish !== undefined) {
+        const finish = /^#[0-9a-fA-F]{6}$/.test(input.finish)
+            ? { color: input.finish }
+            : { material: input.finish };
+        for (const face of ['a', 'b']) {
+            const targets = walls.filter((wall) => wall.faces.includes(face)).map((wall) => wall.id);
+            if (!targets.length)
+                continue;
+            const painted = paint(scratch, { targets, role: getWallTrimSlotId(face, 'skirting'), ...finish }, context);
+            for (const { id, data } of painted.changes?.update ?? [])
+                scratch[id] = { ...scratch[id], ...data };
+            note ??= painted.result.note;
+        }
+    }
+    const update = Object.keys(scratch).flatMap((id) => {
+        const [before, after] = [
+            nodes[id],
+            scratch[id],
+        ];
+        if (before === after)
+            return [];
+        const data = Object.fromEntries(Object.keys(after)
+            .filter((key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]))
+            .map((key) => [key, after[key]]));
+        return Object.keys(data).length ? [{ id, data: data }] : [];
+    });
+    return {
+        result: { ok: true, walls, ...(note ? { note } : {}) },
+        changes: { update },
+    };
+};

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

@@ -3,33 +3,33 @@ import { z } from 'zod';
 export declare const scriptParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
 /** The `language` field every scripted tool shares. */
 export declare const scriptLanguage: z.ZodOptional<z.ZodEnum<{
-    three: "three";
     bpy: "bpy";
+    three: "three";
 }>>;
 export declare const addObjectTool: {
     name: string;
     title: string;
     description: string;
     input: {
-        name: z.ZodOptional<z.ZodString>;
-        category: z.ZodOptional<z.ZodString>;
-        reason: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         code: z.ZodOptional<z.ZodString>;
         language: z.ZodOptional<z.ZodEnum<{
-            three: "three";
             bpy: "bpy";
+            three: "three";
         }>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
         nodeId: z.ZodOptional<z.ZodString>;
         parentId: z.ZodOptional<z.ZodString>;
         position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         side: z.ZodOptional<z.ZodEnum<{
-            front: "front";
             back: "back";
+            front: "front";
         }>>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
     };
 };
 export declare const getSourceTool: {
@@ -38,6 +38,10 @@ export declare const getSourceTool: {
     description: string;
     input: {
         nodeId: z.ZodString;
+        face: z.ZodOptional<z.ZodEnum<{
+            a: "a";
+            b: "b";
+        }>>;
     };
 };
 //# sourceMappingURL=add-object.d.ts.map

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

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

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

@@ -3,7 +3,7 @@ import { geometryMetaFields } from '../schema/geometry-metadata.js';
 import { GeometryScriptLanguage } from '../schema/geometry-source.js';
 import { measurement } from './measurement.js';
 import { NodeId } from './node-id.js';
-const DESCRIPTION = `Build an object by writing a plain three.js module, the way you would in any three.js project. Use it for what the catalog and the structure tools cannot reproduce faithfully: custom columns and capitals, mouldings and trim, panels, lanterns and fixtures, exposed beams, vaulted or tray ceiling bodies, canopies, a porch, railings, built-ins. Pascal runs the module in a sandbox, stores the result and places it as one object the user can move, paint, and ask you to edit again.
+const DESCRIPTION = `Author parametric Three.js furniture, decor and custom objects of any shape, dimensions or style, whether or not the catalog holds something similar (the catalog is a limited set that varies by server). Examples include a low oak table, a slatted bench, a paper lantern, built-ins, custom columns and capitals, mouldings and trim, panels, exposed beams, ceiling bodies, canopies, a porch and railings. Pascal runs the module in a sandbox, stores the result and places it as one object the user can move, paint, and ask you to edit again.
 
 Module shape (import THREE from the three package as usual; the addons below too):
   // also available: three/addons/utils/BufferGeometryUtils.js, three/addons/geometries/{RoundedBoxGeometry,ConvexGeometry,LoftGeometry,ParametricGeometry}.js, three-bvh-csg (Brush, Evaluator, SUBTRACTION, ADDITION, INTERSECTION)
@@ -11,10 +11,10 @@ Module shape (import THREE from the three package as usual; the addons below too
   export const mount = 'floor'   // 'floor' | 'wall-side' (on a wall face) | 'wall' (through a wall, like a window) | 'ceiling'
   export default function build({ params, THREE }) { const group = new THREE.Group(); /* … */ return group }
 
-One object is one feature that changes together: a porch, a railing run, a fireplace surround, a ceiling with its beams. Never a whole house, and never walls, rooms, floors, roofs, stairs, doors or windows: those have their own tools. A new object says what it stands in for (reason): the scene check lists every authored object with its reason, so each names something Pascal has no type for. On a floor, a plain box with a wall's size or a floor plate is refused with the tool to use (use_walls, use_slab); a detailed object with a wall's size (a bookcase, a screen), or one named after something Pascal builds, is built with a hint naming the tool.
+One object is one feature that changes together: a table, a bench, a porch, a railing run, a fireplace surround, a ceiling with its beams. Never a whole house, and never walls, rooms, floors, roofs, stairs, doors or windows: those have their own tools. A new object's reason records its design intent: what the authored shape, dimensions or style contributes to the request. The scene check lists every authored object with its reason; no catalog-exhaustion proof is required. On a floor, a plain box with a wall's size or a floor plate is refused with the tool to use (use_walls, use_slab); a detailed object with a wall's size (a bookcase, a screen), or one named after something Pascal builds, is built with a hint naming the tool.
 
 Conventions (they make the object work in Pascal; follow them):
-- Metres, Y up, modelled as it stands. Pascal puts the bottom-centre of the bounds at the placement point; for wall-side the back face sits on the wall and the object faces +Z.
+- Metres, Y up, modelled in its installed orientation. Floor and wall mounts put the bottom-centre of the visible bounds at the placement point. Ceiling mounts put the top-centre there: visible geometry extends down in negative local Y, with its top at Y = 0. Wall-side mounts put the bottom-centre of the back face there (back at Z = 0, facing +Z). Normalization translates geometry; it does not flip it.
 - Paint: name every material slot_<finish> (slot_trim, slot_frame, slot_metal) and reuse one material per finish; a material named "glass" renders as glass.
 - Parts: name the few groups a person would point at part:<id> (part:column_left, part:canopy, part:landing), usually 2–24, a group per part, not every mesh. Set userData.type on parts someone would look for: column, beam, slab, roof, railing, panel, trim, step, light.
 - Lights: add a THREE.PointLight or SpotLight named light:<id> where the bulb is; it becomes a switchable light.
@@ -30,7 +30,9 @@ Blender instead (language 'bpy'): when the shape is easier with Blender's modell
   def build(params): ...   # add objects to the empty scene; everything in it is exported, modifiers applied
 The same conventions in Blender terms: metres, Z up, the front faces -Y (Blender's Front view); part:<id>, light:<id> (a light object; its custom property intensity sets the brightness, default 2), anchor:<id> (an empty), cutout, cut:wall|ceiling|slab and collider are object names; userData is the object's custom properties (obj["type"] = "panel"); slot_<finish> are material names. A clip is one action named open, close, loop or anything else, assigned to every object that moves in it. Use the data API and bmesh, not operators that need a 3D viewport. A Blender build takes a few seconds.
 
-Edit: pass nodeId with new code and/or params (params alone rebuild the stored script; read it first with get_source to change the code); identity, placement, paint and the params you leave out are kept. The result lists the size, parts, slots, lights, animations and params.`;
+Several objects: they do not depend on each other, so several add_object calls can go in one step, or in one run_batch call (a call per object; each is reported on its own with its receipt, and one that fails does not stop the others).
+
+Edit: pass nodeId with new code and/or params (params alone rebuild the stored script; get_source provides the current code and params when needed); identity, placement, paint and the params you leave out are kept. The result lists the size, parts, slots, lights, animations and params.`;
 /** The `params` field every scripted tool shares (add_object, add_window, add_door, add_column). */
 export const scriptParams = z
     .record(z.string(), z.union([z.number(), z.boolean(), z.string()]))
@@ -57,30 +59,34 @@ export const addObjectTool = {
             .array(z.number())
             .length(3)
             .optional()
-            .describe('Placement in the host frame, metres. Level: [x, y, z] (y = 0 on the floor). Wall: [distance along the wall from its start, height of the bottom, 0].'),
+            .describe('Placement of the mount origin in the host frame, metres. Floor: [x, y, z] locates the bottom-centre (y = 0 on the level floor). Ceiling: [x, y, z] locates the top-centre (y = 0 on the drawn ceiling attachment plane; negative y lowers it). Wall / wall-side: [distance along the wall from its start, height of the bottom, 0]; wall-side also anchors the back face.'),
         rotation: measurement('angle', 'deg', {
-            description: 'Y-axis rotation (default: 0).',
+            description: 'Y-axis rotation in the host frame. New wall-side back mounts default to 180° so +Z faces away from the wall; other new objects default to 0°. An edit keeps its saved rotation unless given.',
         }).optional(),
         side: z
             .enum(['front', 'back'])
             .optional()
             .describe('Which wall face a wall-side object sits on.'),
         ...geometryMetaFields,
-        name: geometryMetaFields.name.describe('What the user would call it ("Front porch").'),
-        category: geometryMetaFields.category.describe('What it is, one word or two ("porch", "lantern", "ceiling", "trim").'),
+        name: geometryMetaFields.name.describe('What the user would call it ("Low oak table").'),
+        category: geometryMetaFields.category.describe('What it is, one word or two ("table", "bench", "porch", "lantern", "trim").'),
         reason: z
             .string()
             .min(1)
             .max(200)
             .optional()
-            .describe('What it stands in for: why no Pascal tool or catalog item builds it ("no cornice type"). Required to create; an edit keeps it unless given.'),
+            .describe('Design intent: why this authored shape, size or style suits the request ("low oak table for the Japandi seating area"). Required to create; an edit keeps it unless given. No catalog-exhaustion proof is required.'),
     },
 };
 export const getSourceTool = {
     name: 'get_source',
     title: 'Read object script',
-    description: 'The module (three.js or Blender bpy, named by language) an object (or a window, door or column built from code) runs, with its params and their current values. Read it before changing its code, then pass the edited module back with the same nodeId: to add_object for an object, to add_window / add_door / add_column for their respective kinds.',
+    description: "The module (three.js or Blender bpy, named by language) an object (or a window, door or column built from code) runs, with its params and their current values; a room's id reads its floor script, the module that builds its floor finish; a wall's id with face reads that face's script (face may be left out when only one face has one). Optional source evidence when the current module is needed. An edited module can be passed back with the same nodeId: to add_object for an object, to add_window / add_door / add_column for their respective kinds.",
     input: {
-        nodeId: NodeId.describe('An object, window, door or column built from code.'),
+        nodeId: NodeId.describe('An object, window, door or column built from code, a room with a floor script, or a wall with a face script.'),
+        face: z
+            .enum(['a', 'b'])
+            .optional()
+            .describe("A wall's face whose script to read; needed when both faces have one."),
     },
 };

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

@@ -10,4 +10,12 @@ export declare const searchAssetsTool: {
         }, z.core.$strip>>;
     };
 };
+export declare const viewAssetsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        ids: z.ZodArray<z.ZodString>;
+    };
+};
 //# sourceMappingURL=assets.d.ts.map

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

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

package/dist/agent-tools/assets.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 export const searchAssetsTool = {
     name: 'search_assets',
     title: 'Search assets',
-    description: "Search the item library (furniture, fixtures, lights, plants, outdoor) by keyword, several queries in one call; call it before placing an item to get a valid asset id. A query matches the items whose name, id, category or tags hold every one of its words. Returns one group per query, each item with its id, name, category, dimensions [width, height, depth] in metres and attachTo (null on the floor, else 'wall', 'wall-side' or 'ceiling'). Batch related lookups (sofa, coffee table, tv stand) instead of separate calls.",
+    description: "Search the item library (furniture, fixtures, lights, plants, outdoor) by keyword, with one or several queries in a call. The catalog is a limited set that varies by server: what a search returns is what exists. Results provide valid asset ids and placement facts when these are not already known. A query matches the items whose name, id, category or tags hold every one of its words. Returns one group per query, each item with its id, name, category, dimensions [width, height, depth] in metres and attachTo (null on the floor, else 'wall', 'wall-side' or 'ceiling'). Related lookups (sofa, coffee table, tv stand) can share a call.",
     input: {
         queries: z
             .array(z.object({
@@ -16,3 +16,15 @@ export const searchAssetsTool = {
             .describe('One or more searches to run in a single call.'),
     },
 };
+export const viewAssetsTool = {
+    name: 'view_assets',
+    title: 'View catalog items',
+    description: 'Pictures of catalog items by id, each with its size and the names of its paintable surfaces (paint takes one as role).',
+    input: {
+        ids: z
+            .array(z.string().min(1))
+            .min(1)
+            .max(6)
+            .describe('One to six catalog item ids, as search_assets or furnish_room returned them.'),
+    },
+};