@pascal-app/core 1.0.3 → 1.0.5

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"}

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

@@ -0,0 +1,65 @@
+import { type WallOpeningInput } from '../building/wall-openings.js';
+import { type Achieved } from './achieved.js';
+import type { SceneChanges, SceneNodes } from './types.js';
+/**
+ * add_door and add_window for every surface: the editor's placement rules (`planWallOpening`),
+ * the node to create, and the one result the MCP and the chat both pass through as it is.
+ */
+export declare function addWallOpening(nodes: SceneNodes, input: WallOpeningInput): {
+    changes: SceneChanges;
+    result: {
+        ok: true;
+        doorId: `door_${string}` | `window_${string}`;
+        wallId: string;
+        localX: number;
+        t: number;
+        wallLength: number;
+        clamped: boolean;
+        coordinateSystem: 'wall-local-meters';
+        sillHeight?: number | undefined;
+        message: string;
+        achieved: Achieved;
+    } | {
+        ok: true;
+        windowId: `door_${string}` | `window_${string}`;
+        wallId: string;
+        localX: number;
+        t: number;
+        wallLength: number;
+        clamped: boolean;
+        coordinateSystem: 'wall-local-meters';
+        sillHeight?: number | undefined;
+        message: string;
+        achieved: Achieved;
+    };
+};
+/**
+ * add_door / add_window with a nodeId, rebuilt from its script: the same answer as a new opening,
+ * 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): {
+    ok: true;
+    doorId: string;
+    wallId: string;
+    localX: number;
+    t: number;
+    wallLength: number;
+    clamped: boolean;
+    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';
+    sillHeight?: number | undefined;
+    message: string;
+    achieved: Achieved;
+};
+//# sourceMappingURL=wall-opening.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;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-opening.js

@@ -0,0 +1,55 @@
+import { planWallOpening } from '../building/wall-openings.js';
+import { achievedChanges } from './achieved.js';
+/**
+ * add_door and add_window for every surface: the editor's placement rules (`planWallOpening`),
+ * the node to create, and the one result the MCP and the chat both pass through as it is.
+ */
+export function addWallOpening(nodes, input) {
+    const plan = planWallOpening(nodes, input);
+    const changes = {
+        create: [{ node: plan.node, parentId: plan.wallId }],
+    };
+    return {
+        changes,
+        result: {
+            ok: true,
+            ...(input.kind === 'door' ? { doorId: plan.node.id } : { windowId: plan.node.id }),
+            wallId: plan.wallId,
+            localX: plan.localX,
+            t: plan.t,
+            wallLength: plan.wallLength,
+            clamped: plan.clamped,
+            coordinateSystem: 'wall-local-meters',
+            ...(plan.sillHeight === undefined ? {} : { sillHeight: plan.sillHeight }),
+            message: `Added ${input.kind} "${plan.node.name}" on wall ${plan.wallId}${plan.clamped ? ', slid to fit' : ''}`,
+            achieved: achievedChanges(nodes, changes),
+        },
+    };
+}
+/**
+ * add_door / add_window with a nodeId, rebuilt from its script: the same answer as a new opening,
+ * read from where it stands after the rebuild, with what the script reported.
+ */
+export function rebuiltOpeningResult(nodesAfter, nodeId, summary, achieved) {
+    const node = nodesAfter[nodeId];
+    const wall = node.wallId
+        ? nodesAfter[node.wallId]
+        : undefined;
+    const wallLength = wall?.type === 'wall'
+        ? Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1])
+        : 0;
+    return {
+        ok: true,
+        ...(node.type === 'door' ? { doorId: nodeId } : { windowId: nodeId }),
+        wallId: node.wallId ?? '',
+        localX: node.position[0],
+        t: wallLength ? node.position[0] / wallLength : 0,
+        wallLength,
+        clamped: false,
+        coordinateSystem: 'wall-local-meters',
+        ...(node.type === 'window' ? { sillHeight: node.position[1] - node.height / 2 } : {}),
+        message: `Rebuilt ${node.type} "${node.name ?? nodeId}" from its script`,
+        ...summary,
+        achieved,
+    };
+}

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/achieved.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+/** What the scene holds after a call that changes it (agent-operations `achievedChanges`). */
+export declare const achievedOutput: z.ZodObject<{
+    created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    updated: z.ZodNumber;
+    deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>;
+//# sourceMappingURL=achieved.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"achieved.d.ts","sourceRoot":"","sources":["../../src/agent-tools/achieved.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,8FAA8F;AAC9F,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAA"}

package/dist/agent-tools/achieved.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** What the scene holds after a call that changes it (agent-operations `achievedChanges`). */
+export const achievedOutput = z.object({
+    created: z.record(z.string(), z.number()),
+    updated: z.number(),
+    deleted: z.record(z.string(), z.number()),
+    unchanged: z.literal(true).optional(),
+});

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+/** The `params` field every scripted tool shares (add_object, add_window, add_door, add_column). */
+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<{
+    bpy: "bpy";
+    three: "three";
+}>>;
+export declare const addObjectTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        code: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodEnum<{
+            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<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            back: "back";
+            front: "front";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const getSourceTool: {
+    name: string;
+    title: string;
+    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

@@ -0,0 +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;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"}