@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/circulation-spaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circulation-spaces.d.ts","sourceRoot":"","sources":["../../src/agent-operations/circulation-spaces.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAzM1B,YAAY,WAAW,MAAM;;EAyP5C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,GAAG,KAAK,CAqDtD;AAWD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,UASpE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,aAE/B,MAAM,SAAS,EAAE,KAAG,KAAK,GAAG,IAAI,CAIlD;AACD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,UAEjC,QAAQ,SAAS,MAAM,KAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAI9D;AACD,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM;;;;EAEtD;AACD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAQtE;AAqBD,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CASrF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,eAAe;;;cAU5F"}

package/dist/agent-operations/circulation-spaces.js

@@ -0,0 +1,368 @@
+import { createFloorOpeningIndex, openingsForSurface, } from '../lib/floor-opening-intent.js';
+import { groundLevelOf } from '../lib/ground-level.js';
+import { area as clippedArea, difference, intersection, union, } from '../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../lib/polygon-label.js';
+import { extractRooms } from '../lib/space-detection.js';
+import { getLevelElevations } from '../services/storey.js';
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall, sampleWallCenterline, } from '../systems/wall/wall-curve.js';
+import { getWallFaceOffsets } from '../systems/wall/wall-frame.js';
+import { pointInPolygon } from './plan-geometry.js';
+import { queryNodes } from './scene-queries.js';
+export const area = (polygon) => Math.abs(polygon.reduce((sum, [x, z], index) => {
+    const next = polygon[(index + 1) % polygon.length];
+    return next ? sum + x * next[1] - next[0] * z : sum;
+}, 0)) / 2;
+export const rotate = ([x, z], rotation) => [
+    x * Math.cos(rotation) + z * Math.sin(rotation),
+    -x * Math.sin(rotation) + z * Math.cos(rotation),
+];
+const cross = (origin, start, end) => (start[0] - origin[0]) * (end[1] - origin[1]) - (start[1] - origin[1]) * (end[0] - origin[0]);
+const touches = (point, start, end) => Math.abs(cross(start, end, point)) < 1e-9 &&
+    point[0] >= Math.min(start[0], end[0]) - 1e-9 &&
+    point[0] <= Math.max(start[0], end[0]) + 1e-9 &&
+    point[1] >= Math.min(start[1], end[1]) - 1e-9 &&
+    point[1] <= Math.max(start[1], end[1]) + 1e-9;
+const segmentsCross = (from, to, start, end) => (cross(from, to, start) * cross(from, to, end) < 0 &&
+    cross(start, end, from) * cross(start, end, to) < 0) ||
+    touches(start, from, to) ||
+    touches(end, from, to) ||
+    touches(from, start, end) ||
+    touches(to, start, end);
+export const walkable = (space) => space.kind === 'zone' ||
+    space.kind === 'floor' ||
+    space.kind === 'outside' ||
+    space.kind === 'outdoor';
+export const keyOf = (space) => space.kind === 'zone' || space.kind === 'floor' || space.kind === 'outdoor'
+    ? space.key
+    : space.kind;
+export const crossesWall = (floor, from, to) => floor.walls.some(([start, end]) => segmentsCross(from, to, start, end));
+export const liftOrigin = (lift) => [lift.position[0], lift.position[2]];
+function shaftOf(lift) {
+    const [cx, cz] = liftOrigin(lift);
+    const [halfWidth, halfDepth] = [
+        (lift.shaftWidth ?? lift.width) / 2,
+        (lift.shaftDepth ?? lift.depth) / 2,
+    ];
+    return [
+        [-halfWidth, -halfDepth],
+        [halfWidth, -halfDepth],
+        [halfWidth, halfDepth],
+        [-halfWidth, halfDepth],
+    ].map((corner) => {
+        const [x, z] = rotate(corner, lift.rotation ?? 0);
+        return [cx + x, cz + z];
+    });
+}
+function liftService(nodes) {
+    return (lift, levelId) => {
+        const level = nodes[levelId], from = nodes[lift.fromLevelId ?? ''], to = nodes[lift.toLevelId ?? ''];
+        if (level?.type !== 'level' || from?.type !== 'level' || to?.type !== 'level')
+            return false;
+        if (level.parentId !== from.parentId || level.parentId !== to.parentId)
+            return false;
+        return (level.level >= Math.min(from.level, to.level) &&
+            level.level <= Math.max(from.level, to.level) &&
+            !(lift.disabledLevelIds ?? []).includes(levelId));
+    };
+}
+function zonesOf(on, apartmentOfZone) {
+    const zones = on
+        .filter((node) => node.type === 'zone' && node.polygon.length >= 3)
+        .flatMap((zone) => {
+        if (zone.type !== 'zone')
+            return [];
+        return [
+            {
+                id: zone.id,
+                polygon: zone.polygon,
+                holes: zone.holes ?? [],
+                area: area(zone.polygon) - (zone.holes ?? []).reduce((sum, hole) => sum + area(hole), 0),
+                outdoor: false,
+                elevation: 0,
+                apartment: apartmentOfZone.get(zone.id),
+            },
+        ];
+    });
+    // Nested room zones inherit their enclosing apartment's membership: the apartment that holds
+    // most of the room. A room beside it holds nothing of it, even where the room's vertex average
+    // falls inside (an arc's samples pull it across the arc).
+    const shape = (zone) => ({ outer: zone.polygon, holes: zone.holes });
+    for (const zone of zones) {
+        if (zone.apartment)
+            continue;
+        zone.apartment = zones.find((other) => other.apartment &&
+            other.area > zone.area &&
+            clippedArea(intersection(shape(zone), shape(other))) > zone.area / 2)?.apartment;
+    }
+    return zones.filter((zone) => {
+        const smaller = zones.filter((other) => other.area < zone.area);
+        return (!smaller.length ||
+            difference({ outer: zone.polygon, holes: zone.holes }, smaller.map((other) => ({ outer: other.polygon, holes: other.holes }))).length > 0);
+    });
+}
+function wallSegments(walls) {
+    return walls.flatMap((wall) => {
+        const points = sampleWallCenterline(wall, isCurvedWall(wall) ? 24 : 1).map(({ x, y }) => [x, y]);
+        return points.slice(1).flatMap((point, index) => {
+            const previous = points[index];
+            return previous ? [[previous, point]] : [];
+        });
+    });
+}
+function enclosedFootprint(on, walls) {
+    const pockets = extractRooms(walls).map((room) => ({
+        polygon: room.referencePolygon,
+        area: area(room.referencePolygon),
+    }));
+    const courts = on.filter((node) => node.type === 'zone' && node.hasFloor === false && node.hasCeiling === false);
+    const declared = on.flatMap((node) => node.type === 'zone' &&
+        node.hasFloor !== false &&
+        (node.enclosureStatus === 'enclosed' || (node.boundarySeparatorIds?.length ?? 0) > 0)
+        ? [{ outer: node.polygon, holes: node.holes ?? [] }]
+        : []);
+    const enclosed = pockets.length
+        ? union([...pockets.map((pocket) => pocket.polygon), ...declared])
+        : union(on.flatMap((node) => node.type === 'zone' && (node.hasFloor !== false || node.hasCeiling !== false)
+            ? [{ outer: node.polygon, holes: node.holes ?? [] }]
+            : []));
+    const interior = difference(enclosed, courts.flatMap((node) => node.type === 'zone' ? [{ outer: node.polygon, holes: node.holes ?? [] }] : []));
+    return { pockets, interior, enclosed };
+}
+function outdoorZone(nodes, zone, slabs, outside, groundElevation, elevation) {
+    const source = nodes[zone.id];
+    const outdoor = outside || (source?.type === 'zone' && source.hasFloor === false && source.hasCeiling === false);
+    const surfaceElevation = outdoorElevation(slabs, polygonInteriorPoint(zone, true), groundElevation);
+    return {
+        ...zone,
+        outdoor,
+        elevation: outdoor ? surfaceElevation : elevation,
+    };
+}
+function walkingFloor(slabs, interior) {
+    const authored = slabs.find((slab) => slab.plateRole === 'base');
+    if (authored)
+        return authored;
+    let best = slabs[0];
+    let largest = 0;
+    for (const slab of slabs) {
+        if (slab.support === 'open')
+            continue;
+        const overlap = clippedArea(intersection({ outer: slab.polygon, holes: slab.holes ?? [] }, interior));
+        if (overlap > largest) {
+            best = slab;
+            largest = overlap;
+        }
+    }
+    return best;
+}
+function floorOf(nodes, level, context) {
+    const on = queryNodes(nodes, { parentId: level.id });
+    const slabs = on.filter((node) => node.type === 'slab');
+    const walls = on.filter((node) => node.type === 'wall');
+    const { pockets, interior, enclosed } = enclosedFootprint(on, walls);
+    const base = walkingFloor(slabs, interior);
+    const ground = level.id === context.groundByBuilding.get(level.parentId);
+    const groundElevation = context.elevations.get(level.id)?.baseY ?? 0;
+    const elevation = groundElevation + (base?.elevation ?? 0);
+    // An open-supported floor (a porch deck, a cantilevered deck, a bridge) outside the enclosed
+    // footprint is outdoor walking ground at its own elevation, on any level, whether or not the
+    // house is enclosed yet. The rest are outdoor only on the ground floor, outside an enclosed
+    // footprint.
+    const outdoor = (polygon, holes, open = false) => (open || (ground && enclosed.length > 0)) &&
+        clippedArea(intersection({ outer: polygon, holes }, interior)) < 1e-6;
+    const surfaces = slabs.map((slab) => ({
+        id: slab.id,
+        polygon: slab.polygon,
+        holes: slab.holes ?? [],
+        elevation: groundElevation + slab.elevation,
+        outdoor: outdoor(slab.polygon, slab.holes ?? [], slab.support === 'open'),
+    }));
+    const zones = zonesOf(on, context.apartmentOfZone).map((zone) => ground
+        ? outdoorZone(nodes, zone, surfaces, outdoor(zone.polygon, zone.holes), groundElevation, elevation)
+        : { ...zone, elevation });
+    return {
+        id: level.id,
+        name: level.name ?? `Level ${level.level}`,
+        elevation,
+        groundElevation,
+        ground,
+        belowGround: context.belowGround.has(level.id),
+        slabs: surfaces,
+        interior,
+        voids: openingsForSurface(nodes, level.id, 'floor', context.openings).map((opening) => opening.polygon),
+        shafts: context.elevators.filter((lift) => context.serves(lift, level.id)).map(shaftOf),
+        zones,
+        pockets,
+        walls: wallSegments(walls),
+    };
+}
+export function floorsOf(nodes) {
+    const levels = queryNodes(nodes, { type: 'level' }).sort((left, right) => left.level - right.level);
+    const apartments = queryNodes(nodes, { type: 'unit' }).filter((node) => node.type === 'unit' && (node.kind ?? 'apartment') === 'apartment');
+    const apartmentOfZone = new Map(apartments.flatMap((unit) => unit.type === 'unit'
+        ? unit.members.map((member) => [member, unit.id])
+        : []));
+    const elevators = queryNodes(nodes, { type: 'elevator' });
+    const serves = liftService(nodes);
+    // The ground floor is the one the building stands at grade on, the line the underground reads:
+    // a basement under it has a door onto earth, not an entrance. Without a line (a stack with every
+    // floor under the ground, levels in no building) it is the lowest floor with a slab.
+    const groundByBuilding = new Map();
+    const belowGround = new Set();
+    for (const level of levels) {
+        const line = level.parentId
+            ? groundLevelOf(nodes, level.parentId)
+            : null;
+        const underLine = line !== null && level.level < line.level.level;
+        if (underLine)
+            belowGround.add(level.id);
+        if (groundByBuilding.has(level.parentId))
+            continue;
+        if (queryNodes(nodes, { type: 'slab', parentId: level.id }).length === 0)
+            continue;
+        if (underLine)
+            continue;
+        groundByBuilding.set(level.parentId, level.id);
+    }
+    const context = {
+        apartmentOfZone,
+        elevators,
+        serves,
+        groundByBuilding,
+        belowGround,
+        openings: createFloorOpeningIndex(nodes),
+        elevations: getLevelElevations(nodes),
+    };
+    return {
+        floors: levels.map((level) => floorOf(nodes, level, context)),
+        apartments,
+        elevators,
+        serves,
+        liftOrigin,
+    };
+}
+export function spaceAt(floor, point) {
+    if (floor.shafts.some((shaft) => pointInPolygon(point, shaft, false)))
+        return { kind: 'shaft' };
+    if (floor.voids.some((hole) => pointInPolygon(point, hole, false)))
+        return { kind: 'void' };
+    const court = floor.zones.find((zone) => zone.outdoor &&
+        pointInPolygon(point, zone.polygon) &&
+        !zone.holes.some((hole) => pointInPolygon(point, hole, false)));
+    if (court)
+        return { kind: 'outdoor', key: `zone:${court.id}`, area: court.area };
+    const covering = floor.slabs.filter((slab) => pointInPolygon(point, slab.polygon));
+    if (covering.length &&
+        covering.every((slab) => slab.holes.some((hole) => pointInPolygon(point, hole, false))))
+        return { kind: 'void' };
+    if (!covering.length)
+        return floor.ground ? { kind: 'outside' } : { kind: 'open-air' };
+    const garden = covering.find((slab) => slab.outdoor && !slab.holes.some((hole) => pointInPolygon(point, hole, false)));
+    if (garden)
+        return {
+            kind: 'outdoor',
+            key: `outdoor:${garden.id}`,
+            area: area(garden.polygon) - garden.holes.reduce((sum, hole) => sum + area(hole), 0),
+        };
+    let best;
+    for (const zone of floor.zones)
+        if ((!best || zone.area < best.area) &&
+            pointInPolygon(point, zone.polygon) &&
+            !zone.holes.some((hole) => pointInPolygon(point, hole, false)))
+            best = zone;
+    if (best)
+        return {
+            kind: 'zone',
+            key: `zone:${best.id}`,
+            area: best.area,
+            ...(best.apartment ? { apartment: best.apartment } : {}),
+        };
+    let pocket = -1;
+    floor.pockets.forEach((candidate, index) => {
+        if ((pocket < 0 || candidate.area < (floor.pockets[pocket]?.area ?? Infinity)) &&
+            pointInPolygon(point, candidate.polygon))
+            pocket = index;
+    });
+    return {
+        kind: 'floor',
+        key: pocket >= 0 ? `floor:${floor.id}:${pocket}` : `floor:${floor.id}:${covering[0]?.id}`,
+    };
+}
+function outdoorElevation(slabs, point, groundElevation) {
+    const covering = slabs.filter((slab) => pointInPolygon(point, slab.polygon) &&
+        !slab.holes.some((hole) => pointInPolygon(point, hole, false)));
+    return covering.length ? Math.max(...covering.map((slab) => slab.elevation)) : groundElevation;
+}
+export function spaceElevation(floor, space, point) {
+    if (space.kind === 'outside')
+        return floor.groundElevation;
+    if (space.kind !== 'outdoor')
+        return floor.elevation;
+    if (point)
+        return outdoorElevation(floor.slabs, point, floor.groundElevation);
+    return (floor.zones.find((zone) => `zone:${zone.id}` === space.key)?.elevation ??
+        floor.slabs.find((slab) => `outdoor:${slab.id}` === space.key)?.elevation ??
+        floor.groundElevation);
+}
+export function floorSpaceReader(nodes) {
+    const floors = new Map(floorsOf(nodes).floors.map((floor) => [floor.id, floor]));
+    return (levelId, point) => {
+        const floor = floors.get(levelId);
+        return floor ? spaceAt(floor, point) : null;
+    };
+}
+export function wallSidesReader(nodes) {
+    const floors = new Map(floorsOf(nodes).floors.map((floor) => [floor.id, floor]));
+    return (wall, along) => {
+        const floor = floors.get(wall.parentId ?? '');
+        return floor ? doorSides(floor, wall, along) : null;
+    };
+}
+export function doorFrame(wall, along) {
+    return getWallCurveFrameAt(wall, along / (getWallCurveLength(wall) || 1));
+}
+export function doorSidePoints(wall, along) {
+    const frame = doorFrame(wall, along);
+    const offsets = getWallFaceOffsets(wall);
+    const at = (offset) => [
+        frame.point.x + frame.normal.x * offset,
+        frame.point.y + frame.normal.y * offset,
+    ];
+    return [at(offsets.a + 0.03), at(offsets.b - 0.03)];
+}
+function doorFaceSpace(floor, centre, normal, offset, direction) {
+    const probe = (distance) => [
+        centre[0] + normal[0] * (offset + direction * distance),
+        centre[1] + normal[1] * (offset + direction * distance),
+    ];
+    const near = probe(0.03), far = probe(0.4);
+    const nearest = spaceAt(floor, near), beyond = spaceAt(floor, far);
+    if (crossesWall(floor, near, far))
+        return nearest;
+    // Keep the original landing-hazard check without jumping across another room's wall.
+    if (beyond.kind === 'shaft' || beyond.kind === 'void')
+        return beyond;
+    return nearest.kind === 'floor' ? beyond : nearest;
+}
+export function doorSides(floor, wall, along) {
+    const frame = doorFrame(wall, along);
+    const offsets = getWallFaceOffsets(wall);
+    const centre = [frame.point.x, frame.point.y], normal = [frame.normal.x, frame.normal.y];
+    return [
+        doorFaceSpace(floor, centre, normal, offsets.a, 1),
+        doorFaceSpace(floor, centre, normal, offsets.b, -1),
+    ];
+}
+export function spaceRegion(scene, graph, node) {
+    const source = node.sourceId ? scene[node.sourceId] : undefined;
+    if (source?.type === 'zone' || source?.type === 'slab')
+        return { outer: source.polygon, holes: source.holes ?? [] };
+    if (node.kind !== 'floor')
+        return undefined;
+    const floor = graph.floors.find((floor) => floor.id === node.levelId);
+    const pocket = floor?.pockets.find((_, index) => node.id === `floor:${floor.id}:${index}`);
+    if (pocket)
+        return { outer: pocket.polygon, holes: [] };
+    const slab = floor?.slabs.find((slab) => node.id === `floor:${floor.id}:${slab.id}`);
+    return slab ? { outer: slab.polygon, holes: slab.holes } : undefined;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/agent-operations/collections.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAE1B,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,EAAE,qBAAqB,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAE9E,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,UAAU,CAAA;IACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,oBAAoB,CAAA;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qGAAqG;AACrG,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC7C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,GAClD,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAOlC;AA0DD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,mBAAmB,GACzB,qBAAqB,CAoDvB;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,EAAE,YAAY,EAAE,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,CAWvB"}
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/agent-operations/collections.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAE1B,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,EAAE,qBAAqB,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAE9E,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,UAAU,CAAA;IACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,oBAAoB,CAAA;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qGAAqG;AACrG,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC7C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,GAClD,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAOlC;AA0DD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,mBAAmB,GACzB,qBAAqB,CAoDvB;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,EAAE,YAAY,EAAE,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,CAWvB"}

package/dist/agent-operations/collections.js

@@ -1,4 +1,6 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { queryCollections } from '../runtime/node-queries.js';
+import { untracked } from '../runtime/reader.js';
 import { COLLECTION_TEMPLATES, generateCollectionId, } from '../schema/index.js';
 import { levelIdOf } from './scene-queries.js';
 /** The scene's collections after `writes` (a surface applies `SceneChanges.collections` with it). */
@@ -68,14 +70,13 @@ function itemMirrorUpdates(nodes, collectionId, before, after) {
  * the scene's collection with the template, or else the name, and creates it when there is none.
  */
 export function editCollection(scene, input) {
-    const all = Object.values(scene.collections);
-    const nameKey = input.name?.toLowerCase();
+    // A lookup by template or name reads which collections match, absent ones included.
     const existing = input.collectionId
         ? collectionById(scene, input.collectionId)
         : input.template
-            ? all.find((collection) => collection.template === input.template)
-            : nameKey
-                ? all.find((collection) => collection.name.toLowerCase() === nameKey)
+            ? queryCollections(scene.collections, { template: input.template })[0]
+            : input.name
+                ? queryCollections(scene.collections, { name: input.name })[0]
                 : refuse('collection_required', 'Pass a collectionId, a template or a name.');
     if (input.delete) {
         if (!existing)
@@ -100,8 +101,9 @@ export function editCollection(scene, input) {
     };
     const removed = new Set(input.remove ?? []);
     const nodeIds = [...new Set([...base.nodeIds, ...(input.add ?? [])])].filter((id) => !removed.has(id));
+    // The fields this call does not set are copied through, not read.
     const next = {
-        ...base,
+        ...untracked(base),
         ...(input.name ? { name: input.name } : {}),
         ...(input.color ? { color: input.color } : {}),
         ...(input.template ? { template: input.template } : {}),
@@ -119,7 +121,7 @@ export function editCollection(scene, input) {
 export function listCollections(scene, { collectionId }) {
     const collections = collectionId
         ? [collectionById(scene, collectionId)]
-        : Object.values(scene.collections);
+        : queryCollections(scene.collections, {});
     return {
         result: {
             count: collections.length,

package/dist/agent-operations/corner-window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corner-window.d.ts","sourceRoot":"","sources":["../../src/agent-operations/corner-window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,2BAA2B,CAAA;AACpF,OAAO,EAAE,UAAU,EAAiC,MAAM,oBAAoB,CAAA;AAG9E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAC3D,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEpE,KAAK,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CAkBhE,CAAA;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,EAAE,CA+CxF"}
+{"version":3,"file":"corner-window.d.ts","sourceRoot":"","sources":["../../src/agent-operations/corner-window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,2BAA2B,CAAA;AACpF,OAAO,EAAE,UAAU,EAAiC,MAAM,oBAAoB,CAAA;AAG9E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAC3D,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEpE,KAAK,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CAkBhE,CAAA;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,EAAE,CA6CxF"}

package/dist/agent-operations/corner-window.js

@@ -2,6 +2,7 @@ import { planCornerWindow } from '../building/corner-window.js';
 import { cornerPair, wallEndPoint, windowCornerEnd } from '../lib/corner-pair.js';
 import { achievedChanges } from './achieved.js';
 import { targetLevel } from './level-target.js';
+import { queryNodes } from './scene-queries.js';
 import { registerSceneCheck } from './verify-scene.js';
 /**
  * `add_corner_window`: one window on each of the two walls meeting at a corner, joined, on the level
@@ -35,10 +36,7 @@ const round = (value) => Math.round(value * 100) / 100;
 export function cornerWindowIssues(nodes) {
     const issues = [];
     const atCorner = new Map();
-    for (const node of Object.values(nodes)) {
-        if (node.type !== 'window')
-            continue;
-        const window = node;
+    for (const window of queryNodes(nodes, { type: 'window' })) {
         const pair = cornerPair(nodes, window);
         // Informational: what broke the pair (a side deleted or moved, a wall moved) was a choice.
         if (window.corner && !pair) {

package/dist/agent-operations/create-roof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-roof.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-roof.ts"],"names":[],"mappings":"AAGA,OAAO,EAKL,KAAK,WAAW,EAGhB,KAAK,cAAc,EACnB,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAA;AAQlB,OAAO,KAAK,EAAgB,cAAc,EAA4B,MAAM,SAAS,CAAA;AAErF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAI1B,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAmID,0GAA0G;AAC1G,wBAAgB,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,CA4B3D;AAiCD;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA0KtD,CAAA"}
+{"version":3,"file":"create-roof.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-roof.ts"],"names":[],"mappings":"AAGA,OAAO,EAKL,KAAK,WAAW,EAGhB,KAAK,cAAc,EACnB,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAA;AAQlB,OAAO,KAAK,EAAgB,cAAc,EAA4B,MAAM,SAAS,CAAA;AAErF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAI1B,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAiID,0GAA0G;AAC1G,wBAAgB,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,CA4B3D;AA+BD;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA0KtD,CAAA"}

package/dist/agent-operations/create-roof.js

@@ -8,7 +8,7 @@ import { applySceneChanges } from './apply-changes.js';
 import { requireLevel } from './level-target.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
 import { buildingFrame, roofRectangles } from './roof-footprint.js';
-import { levelRole, levelsOf } from './scene-queries.js';
+import { levelRole, levelsOf, queryNodes } from './scene-queries.js';
 const mm = (value) => Math.round(value * 1000) / 1000;
 /** A storey a roof can cover: one with a footprint (`footprintPolygons`). */
 const hasFootprint = (nodes, levelId) => footprintPolygons(nodes, levelId).length > 0;
@@ -76,7 +76,7 @@ function coveredStorey(nodes, input, rectangle, context) {
  * still gaps, got a roof over a few rooms only).
  */
 function wallOutline(nodes, storeyId) {
-    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === storeyId);
+    const walls = queryNodes(nodes, { type: 'wall', parentId: storeyId });
     if (walls.length < 3)
         return [];
     const bridges = gapBridges(walls).map((gap, index) => ({
@@ -145,11 +145,9 @@ function footprintPolygons(nodes, storeyId) {
     const outline = wallOutline(nodes, storeyId);
     if (outline.length)
         return outline;
-    const on = (type) => Object.values(nodes).filter((node) => node.type === type &&
-        node.parentId === storeyId &&
-        !(node.type === 'slab' &&
-            node.metadata &&
-            node.metadata.balcony));
+    const on = (type) => queryNodes(nodes, { type, parentId: storeyId }).filter((node) => !(node.type === 'slab' &&
+        node.metadata &&
+        node.metadata.balcony));
     const plates = on('slab');
     return (plates.length ? plates : on('zone')).map((node) => node.polygon);
 }

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

@@ -1,13 +1,16 @@
+import { type WallOpeningInput } from '../building/wall-openings.js';
+import { type DoorNode } from '../schema/index.js';
 import { type LevelTargetInput } from './level-target.js';
 import { type Vec2 } from './plan-geometry.js';
 import type { AgentOperation } from './types.js';
-type OpeningSpec = {
+type OpeningSpec = Pick<WallOpeningInput, 'doorType' | 'sidelightLeft' | 'sidelightRight' | 'transomHeight' | 'leafCount' | 'slidingStyle' | 'slideDirection' | 'windowType' | 'columns' | 'rows' | 'sashGrid' | 'windowHandle' | 'sillInterior' | 'shutters' | 'shutterWidth' | 'openingDirection' | 'tiltTurnMode' | 'sillOverhang' | 'sillInteriorDepth' | 'sillInteriorThickness' | 'sillInteriorOverhang' | 'shutterOpen' | 'shutterSides' | 'rollerShutter' | 'rollerShutterBoxHeight' | 'rollerShutterOpen'> & {
     wallIndex: number;
     t?: number;
     width?: number;
     height?: number;
     sillHeight?: number;
     hingesSide?: 'left' | 'right';
+    handleStyle?: DoorNode['handleStyle'];
     handleSide?: 'left' | 'right';
     swingDirection?: 'inward' | 'outward';
     style?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-room.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,cAAc,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,eAAe,GAAG,gBAAgB,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAYD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE;;;EAWxE;AAiDD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAuMtD,CAAA"}
+{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-room.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAS9F,OAAO,EAGL,KAAK,QAAQ,EAKd,MAAM,WAAW,CAAA;AAElB,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,WAAW,GAAG,IAAI,CACrB,gBAAgB,EACd,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,cAAc,GACd,gBAAgB,GAChB,YAAY,GACZ,SAAS,GACT,MAAM,GACN,UAAU,GACV,cAAc,GACd,cAAc,GACd,UAAU,GACV,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,mBAAmB,GACnB,uBAAuB,GACvB,sBAAsB,GACtB,aAAa,GACb,cAAc,GACd,eAAe,GACf,wBAAwB,GACxB,mBAAmB,CACtB,GAAG;IACF,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,WAAW,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACrC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,cAAc,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,eAAe,GAAG,gBAAgB,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAYD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE;;;EAWxE;AA+CD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAyMtD,CAAA"}

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

@@ -3,6 +3,7 @@ import { doorFacing, planWallOpening } from '../building/wall-openings.js';
 import { createZone, walledRoomAt } from '../commands/structure/create-zone.js';
 import { structureChangeBatch } from '../commands/structure/shared.js';
 import { levelFootprintLoops } from '../lib/building-footprint.js';
+import { doorPositionForFacing } from '../lib/door-opening.js';
 import { foundationReadingOfLevel } from '../lib/foundation-construction.js';
 import { foundationWallRule, levelHoldsFoundationWalls } from '../lib/foundation-wall.js';
 import { isAllocatedRoomName } from '../lib/room-name.js';
@@ -11,7 +12,7 @@ import { generateId, } from '../schema/index.js';
 import { applySceneChanges } from './apply-changes.js';
 import { targetLevel } from './level-target.js';
 import { polygonArea } from './plan-geometry.js';
-import { levelRole } from './scene-queries.js';
+import { levelRole, queryNodes } from './scene-queries.js';
 // A wall counts as running along a polygon edge when both its ends sit this close to the edge's line.
 const EDGE_TOLERANCE = 0.2;
 const lerp = (a, b, t) => [
@@ -32,7 +33,7 @@ export function edgeProjection(a, b, point) {
         t: (rx * dx + rz * dz) / lengthSq,
     };
 }
-const wallsOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
+const wallsOn = (nodes, levelId) => queryNodes(nodes, { type: 'wall', parentId: levelId });
 /** The walls of the level that run along the edge a → b, both ends on its line. */
 function wallsAlong(nodes, levelId, a, b) {
     return wallsOn(nodes, levelId).filter((wall) => {
@@ -58,7 +59,7 @@ function wallAt(nodes, levelId, a, b, point) {
 }
 /** The construction the host derived for the room: its floor plate and its ceiling. */
 function derivedSurfaces(nodes, levelId, zoneId) {
-    const children = Object.values(nodes).filter((node) => node.parentId === levelId);
+    const children = queryNodes(nodes, { parentId: levelId });
     const slab = children.find((node) => node.type === 'slab' && node.boundary === 'auto' && node.zoneIds?.includes(zoneId));
     const ceiling = children.find((node) => node.type === 'ceiling' && node.boundary === 'auto' && node.zoneId === zoneId);
     return { slabId: slab?.id ?? null, ceilingId: ceiling?.id ?? null };
@@ -234,7 +235,9 @@ export const createRoom = (nodes, input, context) => {
                 if (door?.type !== 'door' || wall?.type !== 'wall')
                     return [];
                 const facing = doorFacing(wall);
-                return facing.side && facing.side !== door.side ? [{ id, data: facing }] : [];
+                return facing.side && facing.side !== door.side
+                    ? [{ id, data: { ...facing, position: doorPositionForFacing(door, facing.rotation) } }]
+                    : [];
             });
             return {
                 result: { ...result, ...derivedSurfaces(derived, level.id, plan.zoneId) },

package/dist/agent-operations/create-stair.js

@@ -13,7 +13,7 @@ import { applySceneChanges } from './apply-changes.js';
 import { requireLevel, targetLevel } from './level-target.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
 import { refuseRoofLevel } from './roof-writes.js';
-import { levelsOf } from './scene-queries.js';
+import { levelsOf, queryNodes } from './scene-queries.js';
 /** The margin round a stair's opening when none is given, as the editor's stair tool cuts it. */
 const OPENING_MARGIN = 0.08;
 const KIND = { straight: 'a staircase', l: 'an L staircase', u: 'a U staircase' };
@@ -113,7 +113,7 @@ export const createStair = (nodes, input, context) => {
     const withUpper = applySceneChanges(nodes, changes);
     const rotation = input.rotation ?? 0;
     const width = input.width ?? 1;
-    const stairs = Object.values(nodes).filter((node) => node.type === 'stair').length;
+    const stairs = queryNodes(nodes, { type: 'stair' }).length;
     const railingMode = input.railingMode ?? 'both';
     // A flight to no level rises as asked, else its storey's height, and keeps that rise; one to a
     // level follows the storey (no totalRise) and keeps tracking it.