@pascal-app/core 1.0.1 → 1.0.4

package/dist/agent-operations/place-items.js

@@ -0,0 +1,226 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { floorItemFit } from '../building/floor-item-fit.js';
+import { flushMountRotation, geometrySurfaceAt, geometryUndersideAt, mountsFlush, } from '../lib/geometry-surfaces.js';
+import { ItemNode } from '../schema/index.js';
+import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+import { collectDoorKeepouts } from './door-clearance.js';
+import { targetLevel } from './level-target.js';
+import { pointInPolygon, projectWorldPointToWallLocalX, wallLength, } from './plan-geometry.js';
+/**
+ * What belongs on the lot rather than in a room. Anything else placed outside every room of a
+ * level that has rooms is refused: in production a model that had fallen back to raw place_items
+ * put a bed on the lawn (2026-09-04).
+ */
+const OUTDOOR_ASSET = /tree|plant|shrub|bush|hedge|flower|palm|\bfir\b|bench|grill|bbq|barbecue|\bcar\b|vehicle|truck|bike|bicycle|pool|fence|gate|lamp ?post|street|outdoor|garden|patio|deck|swing|trampoline|planter|mailbox|umbrella|parasol/i;
+const isOutdoor = (asset) => OUTDOOR_ASSET.test(`${asset.name} ${asset.category ?? ''} ${(asset.tags ?? []).join(' ')}`);
+function roomsOn(nodes, levelId) {
+    return Object.values(nodes).flatMap((node) => node.type === 'zone' && node.parentId === levelId && node.polygon.length >= 3
+        ? [node.polygon]
+        : []);
+}
+const refused = (assetId, code, error) => ({
+    ok: false,
+    assetId,
+    code,
+    error,
+});
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * A floor item that does not fit where it is put (`floorItemFit`), refused with what to do:
+ * one its room cannot hold in any turn points to a smaller one; one in a door's way names the door
+ * and a spot in the room that clears every door, when there is one.
+ */
+function floorFit(nodes, levelId, entry, asset, doors) {
+    const misfit = floorItemFit(nodes, {
+        levelId,
+        x: entry.x,
+        z: entry.z,
+        rotationDeg: entry.rotation ?? 0,
+        dimensions: asset.dimensions,
+        doors,
+    });
+    if (!misfit)
+        return null;
+    const [width = 1, , depth = 1] = asset.dimensions ?? [1, 1, 1];
+    if (misfit.code === 'too_large_for_room')
+        return refused(entry.assetId, 'too_large_for_room', `"${asset.name}" is ${round(width)} × ${round(depth)} m; the room it stands in is ${round(misfit.room.width)} × ${round(misfit.room.depth)} m, so it fits in no turn. Pick a smaller one (search_assets), or build one at the room's size with add_object.`);
+    const { candidate } = misfit;
+    return refused(entry.assetId, 'blocks_door', `"${asset.name}" at (${entry.x}, ${entry.z}) stands in the space door ${misfit.doorId} needs to open and be walked through.${candidate
+        ? ` A spot that fits: (${round(candidate.x)}, ${round(candidate.z)}), turned ${candidate.rotationDeg}°.`
+        : ' No spot in this room clears its doors: pick a smaller one, or none.'}`);
+}
+/**
+ * On a wall: along it from its start, the height given for the item's bottom, on the side of the
+ * wall the point is on (the front faces the wall's left, the back is turned round), centred in the
+ * wall or, for a wall-side fixture, on its face. Kept inside the wall's span and height, as the
+ * editor's wall placement keeps it.
+ */
+function onWall(wall, entry, asset) {
+    const [width = 0, height = 0] = asset.dimensions ?? [1, 1, 1];
+    const wallHeight = wall.height ?? 2.5;
+    if (entry.y === undefined)
+        return refused(entry.assetId, 'height_required', `On wall ${wall.id}, give y: the height of the item's bottom above the floor (its top, y + ${height.toFixed(2)} m, must stay under the wall's ${wallHeight.toFixed(2)} m). Art centred at eye level is 1.5 − its height / 2; a sconce about 1.5.`);
+    if (height > wallHeight)
+        return refused(entry.assetId, 'item_too_tall', `"${asset.name}" is ${height.toFixed(2)} m tall; wall ${wall.id} is ${wallHeight.toFixed(2)} m. Pick a shorter item or a taller wall.`);
+    const length = wallLength(wall);
+    const along = projectWorldPointToWallLocalX(wall, [entry.x, 0, entry.z]);
+    const x = Math.max(width / 2, Math.min(length - width / 2, along));
+    const y = Math.max(0, Math.min(wallHeight - height, entry.y));
+    const [dx, dz] = [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]];
+    // The wall's left (its local +z) is its front.
+    const left = -dz * (entry.x - wall.start[0]) + dx * (entry.z - wall.start[1]) >= 0;
+    const side = left ? 'front' : 'back';
+    const z = asset.attachTo === 'wall-side' ? getWallLocalFaceZ(wall, left ? 'a' : 'b') : 0;
+    const turn = (left ? 0 : Math.PI) + ((entry.rotation ?? 0) * Math.PI) / 180;
+    return {
+        parentId: wall.id,
+        position: [x, y, z],
+        rotation: [0, turn, 0],
+        extra: { wallId: wall.id, wallT: length ? x / length : 0, side },
+        side,
+    };
+}
+/**
+ * On an item standing on the floor: in its frame (translation, turn, scale). An object built with
+ * add_object takes the item on its real surface under the point, or hangs a ceiling item from its
+ * underside above it; a catalog item, on its top. A height given (y above 0) is kept.
+ */
+function onItem(host, entry, asset) {
+    const [hx, hy, hz] = host.position;
+    const yaw = host.rotation[1] ?? 0;
+    const [dx, dz] = [entry.x - hx, entry.z - hz];
+    const lx = (Math.cos(yaw) * dx - Math.sin(yaw) * dz) / host.scale[0];
+    const lz = (Math.sin(yaw) * dx + Math.cos(yaw) * dz) / host.scale[2];
+    const turn = ((entry.rotation ?? 0) * Math.PI) / 180 - yaw;
+    const hanging = asset.attachTo === 'ceiling' && !!host.source;
+    const surface = host.source
+        ? hanging
+            ? geometryUndersideAt(host.source.manifest, lx, lz)
+            : geometrySurfaceAt(host.source.manifest, lx, lz)
+        : null;
+    const explicit = !hanging && entry.y !== undefined && entry.y > 0;
+    const flush = hanging && mountsFlush(asset);
+    const drop = hanging ? (flush ? 0.02 : (asset.dimensions?.[1] ?? 0)) : 0;
+    const y = explicit
+        ? entry.y - hy
+        : surface
+            ? surface.y * host.scale[1] - drop
+            : (host.asset.surface?.height ?? host.asset.dimensions[1]) * host.scale[1];
+    return {
+        parentId: host.id,
+        position: [lx * host.scale[0], y, lz * host.scale[2]],
+        // A flush fixture tilts with a sloped underside (a can in a vault plane).
+        rotation: flush && surface && 'normal' in surface
+            ? flushMountRotation(surface.normal, turn)
+            : [0, turn, 0],
+        ...(!explicit && surface?.part ? { restingOn: surface.part } : {}),
+    };
+}
+/**
+ * `place_items`: catalog items on a level's floor, or on the host each names (a wall, a ceiling,
+ * an item standing on the floor), each placed or refused on its own.
+ */
+export const placeItems = (nodes, input, context) => {
+    const catalog = context.catalog;
+    if (!catalog)
+        refuse('no_catalog', 'This host has no item library to place from; build it with add_object.');
+    const level = targetLevel(nodes, input, context);
+    const create = [];
+    const doorsOn = {};
+    const make = (asset, pose) => {
+        const node = ItemNode.parse({
+            name: asset.name,
+            parentId: pose.parentId,
+            position: pose.position,
+            rotation: pose.rotation,
+            asset,
+            ...pose.extra,
+        });
+        create.push({ node, parentId: pose.parentId });
+        return node;
+    };
+    const items = input.items.map((entry) => {
+        const { assetId, x, z, rotation = 0, targetNodeId } = entry;
+        const asset = catalog.find((candidate) => candidate.id === assetId);
+        if (!asset)
+            return refused(assetId, 'asset_not_found', `Asset "${assetId}" is not in the library. Find a valid id with search_assets.`);
+        const host = targetNodeId ? nodes[targetNodeId] : undefined;
+        if (targetNodeId && !host)
+            return refused(assetId, 'host_not_found', `Host not found: ${targetNodeId}.`);
+        if (host?.type === 'wall' || host?.type === 'ceiling' || host?.type === 'item') {
+            let pose;
+            if (host.type === 'wall')
+                pose = onWall(host, entry, asset);
+            else if (host.type === 'ceiling')
+                // Under its underside, its top flush with it.
+                pose = {
+                    parentId: host.id,
+                    position: [x, -(asset.dimensions?.[1] ?? 0), z],
+                    rotation: [0, (rotation * Math.PI) / 180, 0],
+                };
+            else {
+                if (nodes[host.parentId ?? '']?.type !== 'level')
+                    return refused(assetId, 'host_not_on_level', `${host.name ?? host.id} rests on ${host.parentId}: only an item standing on a floor hosts another here.`);
+                pose = onItem(host, entry, asset);
+            }
+            if ('ok' in pose)
+                return pose;
+            const node = make(asset, pose);
+            return {
+                ok: true,
+                itemId: node.id,
+                assetId,
+                name: asset.name,
+                x,
+                z,
+                hostId: host.id,
+                ...(pose.side ? { side: pose.side } : {}),
+                ...(pose.restingOn ? { restingOn: pose.restingOn } : {}),
+            };
+        }
+        // A floor: the level named, or the level holding the room or slab named.
+        const floorId = !host
+            ? level.id
+            : host.type === 'level'
+                ? host.id
+                : host.type === 'zone' || host.type === 'slab'
+                    ? (host.parentId ?? '')
+                    : null;
+        if (!floorId || nodes[floorId]?.type !== 'level')
+            return refused(assetId, 'unsupported_host', `A ${host?.type} hosts no item: name a wall, a ceiling, an item standing on the floor, or a room, slab or level for its floor.`);
+        const rooms = roomsOn(nodes, floorId);
+        const room = rooms.find((polygon) => pointInPolygon([x, z], polygon));
+        if (rooms.length && !isOutdoor(asset) && !room)
+            return refused(assetId, 'outside_rooms', `"${asset.name}" at (${x}, ${z}) is outside every room on this level: indoor items go inside a room (read the rooms with get_zones); trees and garden items may stand outside.`);
+        doorsOn[floorId] ??= collectDoorKeepouts(Object.values(nodes), { levelId: floorId });
+        const misfit = floorFit(nodes, floorId, entry, asset, doorsOn[floorId]);
+        if (misfit)
+            return misfit;
+        const node = make(asset, {
+            parentId: floorId,
+            position: [x, 0, z],
+            rotation: [0, (rotation * Math.PI) / 180, 0],
+        });
+        return {
+            ok: true,
+            itemId: node.id,
+            assetId,
+            name: asset.name,
+            x,
+            z,
+            ...(host ? { hostId: floorId } : {}),
+        };
+    });
+    const failed = items.length - create.length;
+    return {
+        result: {
+            ok: failed === 0,
+            levelId: level.id,
+            items,
+            message: failed
+                ? `Placed ${create.length} of ${items.length} items (${failed} refused).`
+                : `Placed ${create.length} item${create.length === 1 ? '' : 's'}.`,
+        },
+        ...(create.length ? { changes: { create } } : {}),
+    };
+};

package/dist/agent-operations/plan-geometry.d.ts

@@ -0,0 +1,24 @@
+import type { WallNode } from '../schema/index.js';
+export type Vec2 = [number, number];
+export type Vec3 = [number, number, number];
+export declare function distance2D(a: Vec2, b: Vec2): number;
+export declare function wallLength(wall: Pick<WallNode, 'start' | 'end'>): number;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function wallLocalXFromT(wall: Pick<WallNode, 'start' | 'end'>, t: number, width: number): number;
+export declare function projectWorldPointToWallLocalX(wall: Pick<WallNode, 'start' | 'end'>, position: Vec3): number;
+export declare function polygonArea(points: Vec2[]): number;
+export declare function polygonBounds(points: Vec2[]): {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+    width: number;
+    depth: number;
+    centerX: number;
+    centerZ: number;
+};
+export declare function pointInBoundsWithPadding(x: number, z: number, bounds: ReturnType<typeof polygonBounds>, padding: number): boolean;
+export declare function pointOnSegment(point: Vec2, a: Vec2, b: Vec2, tolerance?: number): boolean;
+export declare function pointInPolygon(point: Vec2, polygon: Vec2[], includeBoundary?: boolean): boolean;
+export declare function polygonContainsPolygon(outer: Vec2[], inner: Vec2[]): boolean;
+//# sourceMappingURL=plan-geometry.d.ts.map

package/dist/agent-operations/plan-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-geometry.d.ts","sourceRoot":"","sources":["../../src/agent-operations/plan-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,MAAM,CAExE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,QAAQ,EAAE,IAAI,GACb,MAAM,CAWR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CASlD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAiBA;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CAOvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,eAAe,UAAO,GAAG,OAAO,CAgB5F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAE5E"}

package/dist/agent-operations/plan-geometry.js

@@ -0,0 +1,94 @@
+export function distance2D(a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    return Math.sqrt(dx * dx + dz * dz);
+}
+export function wallLength(wall) {
+    return distance2D(wall.start, wall.end);
+}
+export function clamp(value, min, max) {
+    if (max < min)
+        return (min + max) / 2;
+    return Math.max(min, Math.min(max, value));
+}
+export function wallLocalXFromT(wall, t, width) {
+    const length = wallLength(wall);
+    return clamp(t * length, width / 2, length - width / 2);
+}
+export function projectWorldPointToWallLocalX(wall, position) {
+    const [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    const dx = ex - sx;
+    const dz = ez - sz;
+    const len = Math.sqrt(dx * dx + dz * dz);
+    if (len === 0)
+        return 0;
+    const px = position[0] - sx;
+    const pz = position[2] - sz;
+    const distance = px * (dx / len) + pz * (dz / len);
+    return clamp(distance, 0, len);
+}
+export function polygonArea(points) {
+    if (points.length < 3)
+        return 0;
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return Math.abs(area) / 2;
+}
+export function polygonBounds(points) {
+    const xs = points.map((p) => p[0]);
+    const zs = points.map((p) => p[1]);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minZ = Math.min(...zs);
+    const maxZ = Math.max(...zs);
+    return {
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+        width: maxX - minX,
+        depth: maxZ - minZ,
+        centerX: (minX + maxX) / 2,
+        centerZ: (minZ + maxZ) / 2,
+    };
+}
+export function pointInBoundsWithPadding(x, z, bounds, padding) {
+    return (x >= bounds.minX + padding &&
+        x <= bounds.maxX - padding &&
+        z >= bounds.minZ + padding &&
+        z <= bounds.maxZ - padding);
+}
+export function pointOnSegment(point, a, b, tolerance = 1e-6) {
+    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
+    if (Math.abs(cross) > tolerance)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -tolerance)
+        return false;
+    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    return dot <= lenSq + tolerance;
+}
+export function pointInPolygon(point, polygon, includeBoundary = true) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    const [x, z] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[i];
+        const b = polygon[j];
+        if (pointOnSegment(point, a, b))
+            return includeBoundary;
+        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+export function polygonContainsPolygon(outer, inner) {
+    return inner.every((point) => pointInPolygon(point, outer, true));
+}

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

@@ -0,0 +1,87 @@
+import type { AgentOperation } from './types.js';
+type RoomTransformInput = {
+    zoneId: string;
+    translate?: number[];
+    rotate?: {
+        angle: number;
+        pivot?: number[];
+    };
+    force?: boolean;
+};
+type SlabTarget = {
+    slabId?: string;
+    slabIds?: string[];
+};
+/** The room and floor-construction tools' operations, by tool name. */
+export declare const ROOM_OPERATIONS: {
+    readonly cut_floor_opening: AgentOperation<{
+        levelId?: string;
+        zoneId?: string;
+        levelIds?: string[];
+        polygon?: number[][];
+        rect?: {
+            x: number;
+            z: number;
+            width: number;
+            depth: number;
+        };
+        drawnOn?: "floor" | "ceiling";
+        cutsPrimary?: boolean;
+        cutsAdjacent?: boolean;
+    }>;
+    readonly remove_floor_opening: AgentOperation<{
+        id: string;
+    }>;
+    readonly set_floor_foundation: AgentOperation<SlabTarget & {
+        patch: unknown;
+    }>;
+    readonly set_room_floor_construction: AgentOperation<{
+        zoneId: string;
+        slabId?: string;
+        patch: unknown;
+    }>;
+    readonly rebase_floor_reference: AgentOperation<SlabTarget & {
+        referenceFloorElevation: number | null;
+    }>;
+    readonly create_mezzanine: AgentOperation<{
+        hostZoneId: string;
+        polygon: number[][];
+        elevation?: number;
+        thickness?: number;
+    }>;
+    readonly move_zone: AgentOperation<RoomTransformInput>;
+    readonly duplicate_zone: AgentOperation<RoomTransformInput & {
+        translate: number[];
+    }>;
+    readonly rotate_zone: AgentOperation<{
+        zoneId: string;
+        quarterTurns: number;
+        gridStep?: number;
+        force?: boolean;
+    }>;
+    readonly lock_outside_faces: AgentOperation<{
+        levelId?: string;
+        zoneIds?: string[];
+    }>;
+    readonly set_zone_intent: AgentOperation<{
+        zoneId: string;
+        patch: unknown;
+    }>;
+    readonly divide_zone: AgentOperation<{
+        zoneId: string;
+        cut?: number[][];
+        path?: number[][];
+        closed?: boolean;
+        startBoundaryId?: string;
+        endBoundaryId?: string;
+    }>;
+    readonly merge_zones: AgentOperation<{
+        zoneIds: string[];
+    }>;
+    readonly delete_zone: AgentOperation<{
+        zoneId: string;
+        contents: "delete" | "keep";
+    }>;
+};
+export {};
+//# sourceMappingURL=room-structure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-structure.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-structure.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,cAAc,EAAmD,MAAM,SAAS,CAAA;AA6G9F,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAUD,KAAK,UAAU,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AA+JzD,uEAAuE;AACvE,eAAO,MAAM,eAAe;;kBA7JhB,MAAM;iBACP,MAAM;mBACJ,MAAM,EAAE;kBACT,MAAM,EAAE,EAAE;eACb;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE;kBACnD,OAAO,GAAG,SAAS;sBACf,OAAO;uBACN,OAAO;;;YAagC,MAAM;;;eAMU,OAAO;;;gBAUrE,MAAM;iBACL,MAAM;eACR,OAAO;;;iCAU0B,MAAM,GAAG,IAAI;;;oBAQzC,MAAM;iBACT,MAAM,EAAE,EAAE;oBACP,MAAM;oBACN,MAAM;;;;mBAgB2D,MAAM,EAAE;;;gBAW7E,MAAM;sBACA,MAAM;mBACT,MAAM;gBACT,OAAO;;;kBAc2C,MAAM;kBAAY,MAAM,EAAE;;;gBAY/B,MAAM;eAAS,OAAO;;;gBAOnE,MAAM;cACR,MAAM,EAAE,EAAE;eACT,MAAM,EAAE,EAAE;iBACR,OAAO;0BACE,MAAM;wBACR,MAAM;;;iBAc6B,MAAM,EAAE;;;gBAMT,MAAM;kBAAY,QAAQ,GAAG,MAAM;;CAyB7E,CAAA"}

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

@@ -0,0 +1,144 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { createMezzanine, cutFloorOpening, deleteZone, divideZone, duplicateZone, lockOutsideFaces, mergeZones, rebaseFloorReference, removeFloorOpening, resolveZoneTransformHosts, rotateZone, setFloorFoundation, setRoomFloorConstruction, setZoneIntent, transformZone, } from '../commands/structure/index.js';
+import { containsPoint } from '../lib/polygon-boolean.js';
+import { generateId } from '../schema/index.js';
+import { mergeSceneChanges } from './apply-changes.js';
+/** A plan's ordered changes as one set, landing where applying them one by one does. */
+function sceneChanges(changes) {
+    return mergeSceneChanges(changes.map((change) => change.op === 'create'
+        ? { create: [{ node: change.node, parentId: change.node.parentId ?? undefined }] }
+        : change.op === 'update'
+            ? { update: [{ id: change.id, data: change.data }] }
+            : { delete: [change.id] }));
+}
+/** The commands throw a plain Error for an edit they cannot make ("Room not found: …"). */
+function plan(command) {
+    try {
+        return command();
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'Error')
+            refuse('structure_refused', error.message);
+        throw error;
+    }
+}
+/**
+ * A room or floor command's plan as a shared tool's outcome, as the editor applies it: conflicts
+ * are answers and change nothing unless forced; otherwise the plan's changes, then — once the host
+ * has re-derived rooms and ceilings — the copied fixtures onto their new ceilings, and the result's
+ * rooms read from the derived scene (a room the reconciler re-minted is found by its seed).
+ */
+function roomOutcome(nodes, plan, force = false) {
+    const result = (zoneId = plan.zoneId, zoneIds) => ({
+        changes: plan.changes.length,
+        ...(zoneId ? { zoneId } : {}),
+        ...(plan.openingId ? { openingId: plan.openingId } : {}),
+        ...(plan.openingIds ? { openingIds: plan.openingIds } : {}),
+        ...(plan.hints ? { hints: plan.hints } : {}),
+        ...(plan.idMap
+            ? {
+                idMap: Object.fromEntries(Object.entries(plan.idMap).map(([id, targets]) => [
+                    id,
+                    targets.map((target) => (target === plan.zoneId ? zoneId : target)),
+                ])),
+            }
+            : {}),
+        ...(zoneIds ? { zoneIds } : {}),
+        ...(plan.payload ? { payload: plan.payload } : {}),
+        ...(plan.separatorId ? { separatorId: plan.separatorId } : {}),
+        ...(plan.separatorIds ? { separatorIds: plan.separatorIds } : {}),
+        ...(plan.conflicts ? { conflicts: plan.conflicts } : {}),
+    });
+    if (!plan.changes.length || (plan.conflicts?.length && !force))
+        return { result: result() };
+    let plannedZone = plan.zoneId ? nodes[plan.zoneId] : undefined;
+    for (const change of plan.changes) {
+        if (change.op === 'create' && change.node.id === plan.zoneId)
+            plannedZone = change.node;
+        else if (change.op === 'update' && change.id === plan.zoneId && plannedZone?.type === 'zone')
+            plannedZone = { ...plannedZone, ...change.data };
+    }
+    return {
+        result: result(),
+        changes: sceneChanges(plan.changes),
+        afterReconcile: (derived) => {
+            let zoneId = plan.zoneId;
+            if (zoneId && !derived[zoneId] && plannedZone?.type === 'zone' && plannedZone.seed) {
+                const { seed, parentId } = plannedZone;
+                zoneId =
+                    Object.values(derived).find((node) => node.type === 'zone' &&
+                        node.parentId === parentId &&
+                        containsPoint([{ outer: node.polygon, holes: node.holes }], seed))?.id ?? zoneId;
+            }
+            const zoneIds = plan.separatorIds?.length && !plan.conflicts?.length
+                ? Object.values(derived)
+                    .filter((node) => node.type === 'zone' &&
+                    plan.separatorIds.some((id) => node.boundarySeparatorIds.includes(id)))
+                    .map((node) => node.id)
+                    .sort()
+                : undefined;
+            const hosts = resolveZoneTransformHosts(derived, plan);
+            return {
+                result: result(zoneId, zoneIds),
+                ...(hosts.length ? { changes: sceneChanges(hosts) } : {}),
+            };
+        },
+    };
+}
+const points = (list) => list;
+const transform = ({ translate, rotate, ...input }) => ({
+    ...input,
+    ...(translate ? { translate: translate } : {}),
+    ...(rotate
+        ? { rotate: { angle: rotate.angle, ...(rotate.pivot ? { pivot: rotate.pivot } : {}) } }
+        : {}),
+    mintId: generateId,
+});
+const cutFloorOpeningOperation = (nodes, { polygon, ...input }) => roomOutcome(nodes, plan(() => cutFloorOpening(nodes, {
+    ...input,
+    ...(polygon ? { polygon: points(polygon) } : {}),
+    mintId: generateId,
+})));
+const removeFloorOpeningOperation = (nodes, { id }) => roomOutcome(nodes, plan(() => removeFloorOpening(nodes, id)));
+const setFloorFoundationOperation = (nodes, input) => roomOutcome(nodes, plan(() => setFloorFoundation(nodes, { ...input, patch: input.patch })));
+const setRoomFloorConstructionOperation = (nodes, input) => roomOutcome(nodes, plan(() => setRoomFloorConstruction(nodes, { ...input, patch: input.patch })));
+const rebaseFloorReferenceOperation = (nodes, input) => roomOutcome(nodes, plan(() => rebaseFloorReference(nodes, input)));
+const createMezzanineOperation = (nodes, input) => roomOutcome(nodes, plan(() => createMezzanine(nodes, { ...input, polygon: points(input.polygon), mintId: generateId })));
+const moveZoneOperation = (nodes, input) => roomOutcome(nodes, plan(() => transformZone(nodes, transform(input))), input.force);
+const duplicateZoneOperation = (nodes, input) => roomOutcome(nodes, plan(() => duplicateZone(nodes, { ...transform(input), translate: input.translate })), input.force);
+const rotateZoneOperation = (nodes, input) => roomOutcome(nodes, plan(() => rotateZone(nodes, {
+    ...input,
+    quarterTurns: input.quarterTurns,
+    mintId: generateId,
+})), input.force);
+const lockOutsideFacesOperation = (nodes, { levelId, zoneIds }) => {
+    if (Boolean(levelId) === Boolean(zoneIds))
+        refuse('target_required', 'Supply either levelId or zoneIds.');
+    return roomOutcome(nodes, plan(() => lockOutsideFaces(nodes, levelId ? { levelId } : { zoneIds: zoneIds })));
+};
+const setZoneIntentOperation = (nodes, input) => roomOutcome(nodes, plan(() => setZoneIntent(nodes, { ...input, patch: input.patch })));
+const divideZoneOperation = (nodes, { cut, path, ...input }) => roomOutcome(nodes, plan(() => divideZone(nodes, {
+    ...input,
+    ...(cut ? { cut: points(cut) } : {}),
+    ...(path ? { path: points(path) } : {}),
+    mintId: generateId,
+})));
+const mergeZonesOperation = (nodes, { zoneIds }) => roomOutcome(nodes, plan(() => mergeZones(nodes, { zoneIds: zoneIds })));
+const deleteZoneOperation = (nodes, input) => roomOutcome(nodes, plan(() => deleteZone(nodes, input)));
+/** The room and floor-construction tools' operations, by tool name. */
+export const ROOM_OPERATIONS = {
+    cut_floor_opening: cutFloorOpeningOperation,
+    remove_floor_opening: removeFloorOpeningOperation,
+    set_floor_foundation: setFloorFoundationOperation,
+    set_room_floor_construction: setRoomFloorConstructionOperation,
+    rebase_floor_reference: rebaseFloorReferenceOperation,
+    create_mezzanine: createMezzanineOperation,
+    move_zone: moveZoneOperation,
+    duplicate_zone: duplicateZoneOperation,
+    rotate_zone: rotateZoneOperation,
+    lock_outside_faces: lockOutsideFacesOperation,
+    set_zone_intent: setZoneIntentOperation,
+    divide_zone: divideZoneOperation,
+    merge_zones: mergeZonesOperation,
+    delete_zone: deleteZoneOperation,
+};

package/dist/agent-operations/scene-materials.d.ts

@@ -0,0 +1,15 @@
+import { MaterialSchema } from '../schema/material.js';
+import { type SceneMaterial, type SceneMaterialId } from '../schema/scene-material.js';
+/**
+ * A native material as the editor's Paint keeps a one-off: the scene's equal material when it has
+ * one (compared as the schema reads both), else a new scene material. Refused where the host
+ * cannot store scene materials, so no node points at a material nothing keeps.
+ */
+export declare function resolveInlinePaintMaterial(materials: Readonly<Record<SceneMaterialId, SceneMaterial>> | undefined, input: MaterialSchema, name?: string): {
+    ref: string;
+    sceneMaterial: SceneMaterial;
+    created: boolean;
+};
+/** The scene materials a node points at, in its slots and its role fields alike. */
+export declare function referencedSceneMaterialIds(value: unknown): Set<string>;
+//# sourceMappingURL=scene-materials.d.ts.map

package/dist/agent-operations/scene-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-materials.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-materials.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAA;AAqBjC;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,EACvE,KAAK,EAAE,cAAc,EACrB,IAAI,CAAC,EAAE,MAAM,GACZ;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAqBjE;AAED,oFAAoF;AACpF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAWtE"}

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

@@ -0,0 +1,62 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { parseMaterialRef, toSceneMaterialRef } from '../material-library.js';
+import { MaterialSchema } from '../schema/material.js';
+import { generateSceneMaterialId, } from '../schema/scene-material.js';
+/** Whether two parsed values are the same, whatever their keys' order. */
+function equal(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object')
+        return false;
+    if (Array.isArray(a) || Array.isArray(b))
+        return (Array.isArray(a) &&
+            Array.isArray(b) &&
+            a.length === b.length &&
+            a.every((value, index) => equal(value, b[index])));
+    const left = a;
+    const right = b;
+    return (Object.keys(left).length === Object.keys(right).length &&
+        Object.keys(left).every((key) => Object.hasOwn(right, key) && equal(left[key], right[key])));
+}
+/**
+ * A native material as the editor's Paint keeps a one-off: the scene's equal material when it has
+ * one (compared as the schema reads both), else a new scene material. Refused where the host
+ * cannot store scene materials, so no node points at a material nothing keeps.
+ */
+export function resolveInlinePaintMaterial(materials, input, name) {
+    if (!materials)
+        refuse('materials_unavailable', 'This host cannot keep native materials: give a library material or a colour. Nothing was painted.');
+    const parsed = MaterialSchema.safeParse(input);
+    if (!parsed.success)
+        refuse('invalid_material', `Not a native material: ${parsed.error.message}`);
+    for (const existing of Object.values(materials)) {
+        const normalized = MaterialSchema.safeParse(existing.material);
+        if (normalized.success && equal(normalized.data, parsed.data))
+            return { ref: toSceneMaterialRef(existing.id), sceneMaterial: existing, created: false };
+    }
+    let id = generateSceneMaterialId();
+    while (materials[id])
+        id = generateSceneMaterialId();
+    const sceneMaterial = {
+        id,
+        name: name ?? `Material ${Object.keys(materials).length + 1}`,
+        material: parsed.data,
+    };
+    return { ref: toSceneMaterialRef(id), sceneMaterial, created: true };
+}
+/** The scene materials a node points at, in its slots and its role fields alike. */
+export function referencedSceneMaterialIds(value) {
+    const ids = new Set();
+    const visit = (entry) => {
+        if (typeof entry === 'string') {
+            const parsed = parseMaterialRef(entry);
+            if (parsed?.kind === 'scene')
+                ids.add(parsed.id);
+        }
+        else if (entry && typeof entry === 'object')
+            for (const child of Object.values(entry))
+                visit(child);
+    };
+    visit(value);
+    return ids;
+}