@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/level-reads.js

@@ -0,0 +1,168 @@
+import { area } from '../lib/polygon-boolean.js';
+import { roomFloorChoices } from '../lib/room-floor-choices.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { getWallTop } from '../services/storey.js';
+import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { resolveWallFaceChain } from '../systems/wall/wall-finish.js';
+import { resolveWallEffectiveHeight } from '../systems/wall/wall-top.js';
+import { targetLevel } from './level-target.js';
+import { contentCounts, levelIdOf, levelRole, nodesOnLevel } from './scene-queries.js';
+const round2 = (value) => Math.round(value * 100) / 100;
+function ofType(content, type) {
+    return content.filter((node) => node.type === type);
+}
+/**
+ * The height a wall stands at, as rendered: its own, or its storey's plane (clamped under a
+ * covering slab) above the slab it stands on. Pure over the scene, unlike the viewer's grid.
+ */
+export function wallResolvedHeight(nodes, wall) {
+    const levelId = levelIdOf(nodes, wall.id);
+    if (!levelId)
+        return resolveWallEffectiveHeight(wall, DEFAULT_LEVEL_HEIGHT, 0);
+    const onLevel = nodesOnLevel(nodes, levelId);
+    const support = computeWallSlabSupport(wall, ofType(onLevel, 'slab'), ofType(onLevel, 'wall'), wall.supportSlabId, undefined, 0, nodes);
+    return (getWallTop(wall, levelId, nodes, support.elevation) -
+        support.elevation);
+}
+export function wallSummary(nodes, wall) {
+    return {
+        id: wall.id,
+        name: wall.name,
+        start: wall.start,
+        end: wall.end,
+        length: round2(Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1])),
+        height: wall.height,
+        resolvedHeight: wallResolvedHeight(nodes, wall),
+        heightIsExplicit: wall.height !== undefined,
+        thickness: wall.thickness,
+        wallFaceChains: {
+            a: resolveWallFaceChain(wall, 'a'),
+            b: resolveWallFaceChain(wall, 'b'),
+        },
+        openings: wall.children.flatMap((id) => {
+            const child = nodes[id];
+            if (child?.type !== 'door' && child?.type !== 'window')
+                return [];
+            const { type, position, width, height } = child;
+            return [{ id, type, position, width, height }];
+        }),
+    };
+}
+function zoneSize(zone) {
+    const xs = zone.polygon.map((point) => point[0]);
+    const zs = zone.polygon.map((point) => point[1]);
+    return {
+        areaSqMeters: round2(area([{ outer: zone.polygon, holes: zone.holes ?? [] }])),
+        bounds: {
+            width: round2(Math.max(...xs) - Math.min(...xs)),
+            depth: round2(Math.max(...zs) - Math.min(...zs)),
+        },
+    };
+}
+const zoneSummary = (nodes, zone) => ({
+    id: zone.id,
+    name: zone.name,
+    color: zone.color,
+    polygon: zone.polygon,
+    holes: zone.holes ?? [],
+    wallMaterial: zone.wallMaterial ?? null,
+    wallOverrides: zone.wallOverrides ?? [],
+    ...zoneSize(zone),
+    floor_choices: roomFloorChoices(nodes, zone.id),
+});
+const itemSummary = (item) => ({
+    id: item.id,
+    name: item.name ?? item.asset.name,
+    parentId: item.parentId,
+    position: item.position,
+    assetId: item.asset.id,
+    category: item.asset.category,
+});
+// Listed on their own, or inside what holds them (openings in walls, flights in stairs).
+const SUMMARISED = new Set([
+    'wall',
+    'door',
+    'window',
+    'zone',
+    'slab',
+    'ceiling',
+    'item',
+    'floor-opening',
+    'stair',
+    'stair-segment',
+    'roof',
+    'roof-segment',
+]);
+/** Everything on a level, compactly: what to act on, with ids. Polygons stay in get_zones. */
+function levelSummary(nodes, level) {
+    const content = nodesOnLevel(nodes, level.id);
+    const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
+    return {
+        levelId: level.id,
+        levelName: level.name,
+        floorIndex: level.level,
+        role,
+        metadataRole,
+        isOccupiedStory: role === 'occupied',
+        isSupportLevel: role !== 'occupied',
+        referenceLevelId,
+        counts: contentCounts(content),
+        walls: ofType(content, 'wall').map((wall) => wallSummary(nodes, wall)),
+        zones: ofType(content, 'zone').map((zone) => ({
+            id: zone.id,
+            name: zone.name,
+            holes: zone.holes ?? [],
+            ...zoneSize(zone),
+            floor_choices: roomFloorChoices(nodes, zone.id),
+        })),
+        slabs: ofType(content, 'slab').map((slab) => ({
+            id: slab.id,
+            elevation: slab.elevation,
+            holeCount: slab.holes?.length ?? 0,
+        })),
+        ceilings: ofType(content, 'ceiling').map((ceiling) => ({
+            id: ceiling.id,
+            height: ceiling.height,
+            itemCount: ceiling.children.filter((id) => nodes[id]?.type === 'item').length,
+        })),
+        items: ofType(content, 'item').map(itemSummary),
+        openings: ofType(content, 'floor-opening').map((opening) => ({
+            id: opening.id,
+            polygon: opening.polygon,
+            hostZoneId: opening.hostZoneId ?? null,
+            source: opening.source,
+            drawnOn: opening.drawnOn,
+            cutsPrimary: opening.cutsPrimary,
+            cutsAdjacent: opening.cutsAdjacent,
+        })),
+        stairs: ofType(content, 'stair').map((stair) => ({
+            id: stair.id,
+            name: stair.name,
+            position: stair.position,
+        })),
+        roofs: ofType(content, 'roof').map((roof) => ({
+            id: roof.id,
+            name: roof.name,
+            segmentCount: roof.children.length,
+        })),
+        other: content
+            .filter((node) => !SUMMARISED.has(node.type))
+            .map((node) => ({ id: node.id, type: node.type, name: node.name })),
+    };
+}
+/** `get_level_summary`. */
+export const getLevelSummary = (nodes, input, context) => ({
+    result: levelSummary(nodes, targetLevel(nodes, input, context)),
+});
+/** `get_walls`. */
+export const getWalls = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    const walls = ofType(nodesOnLevel(nodes, level.id), 'wall');
+    return { result: { levelId: level.id, walls: walls.map((wall) => wallSummary(nodes, wall)) } };
+};
+/** `get_zones`. */
+export const getZones = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    const zones = ofType(nodesOnLevel(nodes, level.id), 'zone');
+    return { result: { levelId: level.id, zones: zones.map((zone) => zoneSummary(nodes, zone)) } };
+};

package/dist/agent-operations/level-target.d.ts

@@ -0,0 +1,11 @@
+import type { LevelNode } from '../schema/index.js';
+import type { AgentContext, SceneNodes } from './types.js';
+export type LevelTargetInput = {
+    levelId?: string;
+    level?: string;
+};
+/** A level named by id, or a refusal saying what the id is instead. */
+export declare function requireLevel(nodes: SceneNodes, levelId: string): LevelNode;
+/** The level a read targets: the one named, else the viewed floor, else the lowest storey. */
+export declare function targetLevel(nodes: SceneNodes, { levelId, level }: LevelTargetInput, context: AgentContext): LevelNode;
+//# sourceMappingURL=level-target.d.ts.map

package/dist/agent-operations/level-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-target.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-target.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEnE,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAY1E;AAED,8FAA8F;AAC9F,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,gBAAgB,EACpC,OAAO,EAAE,YAAY,GACpB,SAAS,CAaX"}

package/dist/agent-operations/level-target.js

@@ -0,0 +1,29 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { levelRole, levelsOf } from './scene-queries.js';
+/** A level named by id, or a refusal saying what the id is instead. */
+export function requireLevel(nodes, levelId) {
+    const node = nodes[levelId];
+    if (!node)
+        refuse('level_not_found', `Level not found: ${levelId}. Use an id list_levels returned.`, {
+            levelId,
+        });
+    if (node.type !== 'level')
+        refuse('not_a_level', `Node ${levelId} is a ${node.type}, not a level.`, {
+            levelId,
+            type: node.type,
+        });
+    return node;
+}
+/** The level a read targets: the one named, else the viewed floor, else the lowest storey. */
+export function targetLevel(nodes, { levelId, level }, context) {
+    if (levelId && level && levelId !== level)
+        refuse('conflicting_level', `levelId (${levelId}) and level (${level}) disagree; they are the same field, pass one.`, { levelId, level });
+    const named = levelId ?? level ?? context.activeLevelId;
+    if (named)
+        return requireLevel(nodes, named);
+    const levels = levelsOf(nodes);
+    const lowest = levels.find((entry) => levelRole(nodes, entry).role === 'occupied') ?? levels[0];
+    if (!lowest)
+        refuse('no_levels', 'The scene has no level yet.');
+    return lowest;
+}

package/dist/agent-operations/list-levels.d.ts

@@ -0,0 +1,4 @@
+import type { AgentOperation } from './types.js';
+/** `list_levels`: every level of every building, in floor order, with its role. */
+export declare const listLevels: AgentOperation;
+//# sourceMappingURL=list-levels.d.ts.map

package/dist/agent-operations/list-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-levels.d.ts","sourceRoot":"","sources":["../../src/agent-operations/list-levels.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,cAiDxB,CAAA"}

package/dist/agent-operations/list-levels.js

@@ -0,0 +1,54 @@
+import { levelGradeStanding } from '../lib/grade-standing.js';
+import { groundSeat } from '../lib/ground-seat.js';
+import { levelRole, levelsOf } from './scene-queries.js';
+/** `list_levels`: every level of every building, in floor order, with its role. */
+export const listLevels = (nodes, _input, context) => {
+    const groundLevels = Object.values(nodes)
+        .filter((node) => node.type === 'building')
+        .flatMap((building) => {
+        const seat = groundSeat(nodes, building.id);
+        return seat
+            ? [
+                {
+                    buildingId: building.id,
+                    levelId: seat.levelId,
+                    named: seat.explicit,
+                    floorElevation: seat.floorElevation,
+                    gradeElevation: seat.gradeElevation,
+                    floorOverGrade: Math.round(seat.offset * 1000) / 1000,
+                    seated: seat.seated,
+                },
+            ]
+            : [];
+    });
+    const levels = levelsOf(nodes).map((level) => {
+        const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
+        return {
+            id: level.id,
+            name: level.name,
+            floorIndex: level.level,
+            parentId: level.parentId,
+            role,
+            metadataRole,
+            isOccupiedStory: role === 'occupied',
+            isSupportLevel: role !== 'occupied',
+            referenceLevelId,
+            childCount: Array.isArray(level.children) ? level.children.length : 0,
+            gradeStanding: levelGradeStanding(nodes, level.id),
+            isGroundLevel: groundLevels.some((ground) => ground.levelId === level.id),
+            isActive: level.id === context.activeLevelId,
+        };
+    });
+    const occupiedStoryCount = levels.filter((level) => level.isOccupiedStory).length;
+    return {
+        result: {
+            activeLevelId: context.activeLevelId,
+            groundLevels,
+            levelCount: levels.length,
+            occupiedStoryCount,
+            supportLevelCount: levels.length - occupiedStoryCount,
+            roofLevelIds: levels.filter((level) => level.role === 'roof').map((level) => level.id),
+            levels,
+        },
+    };
+};

package/dist/agent-operations/material-preset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Why a write (an update's data, a created node, a tool's arguments) may not
+ * store a `materialPreset` / `*MaterialPreset` value or a `slots` entry, or
+ * null. A preset or slot value that names no catalog material renders as the
+ * default finish, and a slot the node does not have never renders, so the
+ * caller would believe a finish landed that never shows. A slot also takes a
+ * plain `#rrggbb` colour. Restating a node's current value passes, so an older
+ * node's bad value never blocks an unrelated edit.
+ */
+export declare function unknownMaterialPresetRefusal(data: Record<string, unknown>, current?: Record<string, unknown>): string | null;
+//# sourceMappingURL=material-preset.d.ts.map

package/dist/agent-operations/material-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-preset.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-preset.ts"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,GAAG,IAAI,CAkCf"}

package/dist/agent-operations/material-preset.js

@@ -0,0 +1,68 @@
+import { LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, parseMaterialColor, parseMaterialRef, } from '../material-library.js';
+import { nodeSlotDeclarations } from '../node-slots/index.js';
+import { AnyNode } from '../schema/index.js';
+import { isLibraryMaterialId } from './material-refs.js';
+const isPresetField = (key) => key === 'materialPreset' || key.endsWith('MaterialPreset');
+function isKnownMaterialRef(value) {
+    const ref = parseMaterialRef(value);
+    return !!ref && (ref.kind === 'scene' || isLibraryMaterialId(ref.id));
+}
+function presetCatalogLine() {
+    const byCategory = new Map();
+    for (const item of MATERIAL_CATALOG) {
+        const ids = byCategory.get(item.category) ?? [];
+        ids.push(item.id);
+        byCategory.set(item.category, ids);
+    }
+    return [...byCategory].map(([category, ids]) => `${category}: ${ids.join(', ')}`).join('; ');
+}
+// The slot ids the node exposes as it stands before this write's own slot
+// keys (a block's slot list includes the keys of its `slots`); null when its
+// kind declares none or the node does not parse.
+function declaredSlotIds(data, current) {
+    const parsed = AnyNode.safeParse({ ...current, ...data, slots: current?.slots ?? {} });
+    if (!parsed.success)
+        return null;
+    return nodeSlotDeclarations(parsed.data)?.map((slot) => slot.slotId) ?? null;
+}
+/**
+ * Why a write (an update's data, a created node, a tool's arguments) may not
+ * store a `materialPreset` / `*MaterialPreset` value or a `slots` entry, or
+ * null. A preset or slot value that names no catalog material renders as the
+ * default finish, and a slot the node does not have never renders, so the
+ * caller would believe a finish landed that never shows. A slot also takes a
+ * plain `#rrggbb` colour. Restating a node's current value passes, so an older
+ * node's bad value never blocks an unrelated edit.
+ */
+export function unknownMaterialPresetRefusal(data, current) {
+    const unknown = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (!isPresetField(key) || typeof value !== 'string')
+            continue;
+        if (current && current[key] === value)
+            continue;
+        if (!isKnownMaterialRef(value))
+            unknown.push(`${key} ${JSON.stringify(value)}`);
+    }
+    const parts = [];
+    if (data.slots && typeof data.slots === 'object') {
+        const currentSlots = current?.slots;
+        const changed = Object.entries(data.slots).filter((entry) => typeof entry[1] === 'string' && currentSlots?.[entry[0]] !== entry[1]);
+        for (const [slot, value] of changed) {
+            if (!(parseMaterialColor(value) || isKnownMaterialRef(value))) {
+                unknown.push(`slots.${slot} ${JSON.stringify(value)}`);
+            }
+        }
+        const slotIds = changed.length > 0 ? declaredSlotIds(data, current) : null;
+        const missing = slotIds ? changed.filter(([slot]) => !slotIds.includes(slot)) : [];
+        if (missing.length > 0) {
+            parts.push(`A ${String(data.type ?? current?.type)} has no slot ${missing.map(([slot]) => JSON.stringify(slot)).join(', ')}; its slots are ${slotIds?.join(', ')}.`);
+        }
+    }
+    if (unknown.length > 0) {
+        parts.push(`Unknown material (${unknown.join(', ')}). A material is "${LIBRARY_MATERIAL_REF_PREFIX}<id>" with an id from ${presetCatalogLine()}. A slot also takes a plain colour such as "#2f5585"; to colour a whole node, paint it with material: { properties: { color: "#rrggbb" } }.`);
+    }
+    if (parts.length === 0)
+        return null;
+    return `${parts.join(' ')} Nothing was changed.`;
+}

package/dist/agent-operations/material-refs.d.ts

@@ -0,0 +1,30 @@
+import type { MaterialSurface } from '../material-kinds.js';
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
+/** The surface a node's finish goes on, by its kind and the role or field painted. */
+export declare function finishSurface(type: string, role?: string): MaterialSurface | undefined;
+/**
+ * Library ids nearest a name asked for: those that suit the surface first (a roof's roofing, a
+ * wall's wall materials, as the library tags them), then by the words they share with it.
+ */
+export declare function nearestLibraryMaterials(asked: string, surface?: MaterialSurface, count?: number): string[];
+/**
+ * Whether a library id renders: the catalog's, or a well-formed community material's (`mtl_…`),
+ * which the host checks (the hosted MCP against its database, before the call). The materials a
+ * host registered can be a part of its library (those its scene uses), so they never refuse one.
+ */
+export declare function isLibraryMaterialId(id: string): boolean;
+/**
+ * A material ref that renders: a library id the catalog holds (`library:<id>`, or the bare id), or
+ * a scene material (`scene:<id>`, checked against the scene's materials when the host lends them).
+ * Anything else would fall back to a default with no word (an unknown preset came out grey), so it
+ * is refused, naming the nearest library ids for the surface; when the library has nothing of the
+ * kind like it, the refusal says so, and that a colour is the nearest (a corrugated roof was once
+ * offered bricks).
+ */
+export declare function requireMaterialRef(asked: string, field?: string, surface?: MaterialSurface, { paint, materials, }?: {
+    /** Whether to point to `paint` for a colour (paint passes it); else a flat library colour. */
+    paint?: boolean;
+    /** The scene's materials, when the host has them. */
+    materials?: Readonly<Record<SceneMaterialId, SceneMaterial>>;
+}): string;
+//# sourceMappingURL=material-refs.d.ts.map

package/dist/agent-operations/material-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-refs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-refs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAOxD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AA+B9E,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAGtF;AAYD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,EACzB,KAAK,SAAI,GACR,MAAM,EAAE,CAWV;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,EACzB,EACE,KAAa,EACb,SAAS,GACV,GAAE;IACD,8FAA8F;IAC9F,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,qDAAqD;IACrD,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAA;CACxD,GACL,MAAM,CAiCR"}

package/dist/agent-operations/material-refs.js

@@ -0,0 +1,105 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { getCatalogMaterialById, isCommunityMaterialId, MATERIAL_CATALOG, parseMaterialRef, } from '../material-library.js';
+const SURFACE_WORDS = {
+    roof: 'roofing',
+    wall: 'wall material',
+    floor: 'flooring',
+    ceiling: 'ceiling material',
+    furniture: 'joinery material',
+    outdoor: 'outdoor material',
+};
+/** The surface a kind's finish covers, as the library tags materials; a roof's `wall` role is a wall. */
+const KIND_SURFACES = {
+    roof: 'roof',
+    'roof-segment': 'roof',
+    dormer: 'roof',
+    wall: 'wall',
+    column: 'wall',
+    slab: 'floor',
+    stair: 'floor',
+    'stair-segment': 'floor',
+    ceiling: 'ceiling',
+    fence: 'outdoor',
+    chimney: 'outdoor',
+    door: 'furniture',
+    window: 'furniture',
+    item: 'furniture',
+    cabinet: 'furniture',
+    shelf: 'furniture',
+};
+/** The surface a node's finish goes on, by its kind and the role or field painted. */
+export function finishSurface(type, role) {
+    const surface = KIND_SURFACES[type];
+    return surface === 'roof' && role && /^wall(MaterialPreset)?$/.test(role) ? 'wall' : surface;
+}
+const wordsOf = (asked) => asked
+    .toLowerCase()
+    .replace(/^library:/, '')
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+const named = (entry) => `library:${entry.id} (${entry.label})`;
+const suits = (entry, surface) => entry.surfaces?.includes(surface) ?? false;
+/**
+ * Library ids nearest a name asked for: those that suit the surface first (a roof's roofing, a
+ * wall's wall materials, as the library tags them), then by the words they share with it.
+ */
+export function nearestLibraryMaterials(asked, surface, count = 3) {
+    const words = wordsOf(asked);
+    const score = (text) => words.filter((word) => text.includes(word)).length;
+    return MATERIAL_CATALOG.map((entry) => ({
+        entry,
+        fit: surface && suits(entry, surface) ? 1 : 0,
+        score: score(`${entry.id} ${entry.label}`.toLowerCase()),
+    }))
+        .sort((a, b) => b.fit - a.fit || b.score - a.score || a.entry.id.localeCompare(b.entry.id))
+        .slice(0, count)
+        .map(({ entry }) => named(entry));
+}
+/**
+ * Whether a library id renders: the catalog's, or a well-formed community material's (`mtl_…`),
+ * which the host checks (the hosted MCP against its database, before the call). The materials a
+ * host registered can be a part of its library (those its scene uses), so they never refuse one.
+ */
+export function isLibraryMaterialId(id) {
+    return !!getCatalogMaterialById(id) || isCommunityMaterialId(id);
+}
+/**
+ * A material ref that renders: a library id the catalog holds (`library:<id>`, or the bare id), or
+ * a scene material (`scene:<id>`, checked against the scene's materials when the host lends them).
+ * Anything else would fall back to a default with no word (an unknown preset came out grey), so it
+ * is refused, naming the nearest library ids for the surface; when the library has nothing of the
+ * kind like it, the refusal says so, and that a colour is the nearest (a corrugated roof was once
+ * offered bricks).
+ */
+export function requireMaterialRef(asked, field, surface, { paint = false, materials, } = {}) {
+    const parsed = parseMaterialRef(asked.includes(':') ? asked : `library:${asked}`);
+    if (parsed?.kind === 'scene') {
+        if (materials && !Object.hasOwn(materials, parsed.id))
+            refuse('unknown_material', `${asked} is not one of this scene's materials.`, {
+                material: asked,
+                ...(field ? { field } : {}),
+            });
+        return asked;
+    }
+    if (parsed?.kind === 'library' && isLibraryMaterialId(parsed.id))
+        return `library:${parsed.id}`;
+    const words = wordsOf(asked);
+    const shares = (text) => words.some((word) => text.toLowerCase().includes(word));
+    const kind = surface ? MATERIAL_CATALOG.filter((entry) => suits(entry, surface)) : [];
+    const alike = kind.filter((entry) => shares(`${entry.id} ${entry.label}`));
+    const nearest = nearestLibraryMaterials(asked, surface);
+    // Only names sharing a word: with none, the ranking is alphabetical and names bricks for a roof.
+    const byName = nearestLibraryMaterials(asked).filter(shares);
+    const head = `${field ? `${field}: ` : ''}${asked} is not in the material library`;
+    const colour = paint
+        ? 'a colour with paint'
+        : 'a flat colour, library:preset-<colour> (library:preset-midgrey, library:preset-tan)';
+    const message = surface && !alike.length
+        ? `${head}, which has no ${SURFACE_WORDS[surface]} like it. Its ${SURFACE_WORDS[surface]}: ${kind.length ? kind.slice(0, 5).map(named).join(', ') : 'none'}.${byName.length ? ` Nearest by name: ${byName.join(', ')}.` : ''} Or ${colour} is the nearest.`
+        : `${head}. Nearest: ${nearest.join(', ')}; or give ${colour}.`;
+    return refuse('unknown_material', `${message} search_materials finds one by words.`, {
+        material: asked,
+        ...(field ? { field } : {}),
+        nearest,
+    });
+}

package/dist/agent-operations/merge-windows.d.ts

@@ -0,0 +1,6 @@
+import type { AgentOperation } from './types.js';
+/** `merge_windows`: two windows that exist become one, a corner window or one wide window. */
+export declare const mergeWindowsOperation: AgentOperation<{
+    windowIds: [string, string];
+}>;
+//# sourceMappingURL=merge-windows.d.ts.map

package/dist/agent-operations/merge-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-windows.d.ts","sourceRoot":"","sources":["../../src/agent-operations/merge-windows.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAI3D,8FAA8F;AAC9F,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC;IAAE,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAyBjF,CAAA"}

package/dist/agent-operations/merge-windows.js

@@ -0,0 +1,27 @@
+import { mergeWindows } from '../building/merge-windows.js';
+import { achievedChanges } from './achieved.js';
+const round = (value) => Math.round(value * 1000) / 1000;
+/** `merge_windows`: two windows that exist become one, a corner window or one wide window. */
+export const mergeWindowsOperation = (nodes, input) => {
+    const merge = mergeWindows(nodes, input.windowIds[0], input.windowIds[1]);
+    const changes = {
+        update: merge.changes.update.map(({ id, data }) => ({ id, data: data })),
+        delete: merge.changes.delete,
+    };
+    return {
+        changes,
+        result: {
+            ok: true,
+            kind: merge.kind === 'corner' ? 'corner' : 'same_wall',
+            windowIds: merge.windowIds,
+            removedIds: merge.removedIds,
+            wallIds: merge.wallIds,
+            sillHeight: round(merge.sillHeight),
+            height: round(merge.height),
+            ...(merge.width === undefined ? {} : { width: round(merge.width) }),
+            ...(merge.angle === undefined ? {} : { angle: merge.angle }),
+            message: merge.message,
+            achieved: achievedChanges(nodes, changes),
+        },
+    };
+};

package/dist/agent-operations/move-roofs.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `move_roofs_to_roof_level`: the roof panel's "Move to the roof level" for agents. The roofs a
+ * storey holds on its own walls go to the level the rule gives them, standing where they stood.
+ */
+export declare const moveRoofsToRoofLevel: AgentOperation<{
+    levelId: string;
+}>;
+//# sourceMappingURL=move-roofs.d.ts.map

package/dist/agent-operations/move-roofs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-roofs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/move-roofs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAwBpE,CAAA"}

package/dist/agent-operations/move-roofs.js

@@ -0,0 +1,29 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { planRoofsOffStorey } from '../services/roof-move.js';
+import { requireLevel } from './level-target.js';
+/**
+ * `move_roofs_to_roof_level`: the roof panel's "Move to the roof level" for agents. The roofs a
+ * storey holds on its own walls go to the level the rule gives them, standing where they stood.
+ */
+export const moveRoofsToRoofLevel = (nodes, input) => {
+    const storey = requireLevel(nodes, input.levelId);
+    const move = planRoofsOffStorey(nodes, storey.id);
+    const name = `${getLevelDisplayName(storey)} (${storey.id})`;
+    if (!move)
+        refuse('no_roof_on_walls', `${name} holds no roof standing on its walls, so none hides its plan: a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong.`, { levelId: storey.id });
+    const roofIds = move.changes.update
+        .filter(({ id }) => nodes[id]?.type === 'roof')
+        .map(({ id }) => id);
+    const created = move.plan.kind === 'roof' ? move.plan.create : null;
+    const target = (created ?? nodes[move.plan.levelId]);
+    return {
+        result: {
+            roofIds,
+            roofLevelId: move.plan.levelId,
+            createdRoofLevelId: created?.id ?? null,
+            message: `Moved ${roofIds.length} roof${roofIds.length === 1 ? '' : 's'} off ${name} onto ${getLevelDisplayName(target)} (${target.id}), standing where ${roofIds.length === 1 ? 'it' : 'they'} stood.`,
+        },
+        changes: move.changes,
+    };
+};

package/dist/agent-operations/node-patch.d.ts

@@ -0,0 +1,3 @@
+import type { AnyNode } from '../schema/index.js';
+export declare function honestNodePatch(current: AnyNode, data: Readonly<Record<string, unknown>>): Record<string, unknown>;
+//# sourceMappingURL=node-patch.d.ts.map

package/dist/agent-operations/node-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-patch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/node-patch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA8ExC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwDzB"}