@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/search-assets.d.ts

@@ -0,0 +1,14 @@
+import type { AgentOperation } from './types.js';
+type SearchAssetsInput = {
+    queries: {
+        query: string;
+        category?: string;
+    }[];
+};
+/**
+ * `search_assets`: the host's item library, one group of hits per query. A miss names the other
+ * sources there are for the need, as a fact.
+ */
+export declare const searchAssets: AgentOperation<SearchAssetsInput>;
+export {};
+//# sourceMappingURL=search-assets.d.ts.map

package/dist/agent-operations/search-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-assets.d.ts","sourceRoot":"","sources":["../../src/agent-operations/search-assets.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,iBAAiB,GAAG;IAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAA;AAY5E;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,iBAAiB,CA0B1D,CAAA"}

package/dist/agent-operations/search-assets.js

@@ -0,0 +1,43 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { OTHER_SOURCES } from '../agent-tools/sources.js';
+function matches(item, { query, category }) {
+    if (category && item.category !== category)
+        return false;
+    const haystack = [item.id, item.name, item.category, ...(item.tags ?? [])].join(' ').toLowerCase();
+    return query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean)
+        .every((term) => haystack.includes(term));
+}
+/**
+ * `search_assets`: the host's item library, one group of hits per query. A miss names the other
+ * sources there are for the need, as a fact.
+ */
+export const searchAssets = (_nodes, { queries }, context) => {
+    const catalog = context.catalog;
+    if (!catalog)
+        refuse('no_catalog', 'This host has no item library to search; nothing can be placed from one.');
+    const groups = queries.map((entry) => {
+        const results = catalog
+            .filter((item) => matches(item, entry))
+            .map((item) => ({
+            id: item.id,
+            name: item.name,
+            category: item.category,
+            dimensions: item.dimensions ?? [1, 1, 1],
+            attachTo: item.attachTo ?? null,
+        }));
+        return { query: entry.query, total: results.length, results };
+    });
+    const missed = groups.filter((group) => group.total === 0).map((group) => `"${group.query}"`);
+    return {
+        result: {
+            groups,
+            total: groups.reduce((sum, group) => sum + group.total, 0),
+            ...(missed.length && {
+                hint: `Nothing in the library matches ${missed.join(', ')}. ${OTHER_SOURCES}`,
+            }),
+        },
+    };
+};

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

@@ -0,0 +1,18 @@
+import type { MaterialCategory, MaterialSurface } from '../material-kinds.js';
+import type { AgentOperation } from './types.js';
+type SearchMaterialsInput = {
+    queries: {
+        query?: string;
+        kind?: MaterialCategory;
+        surface?: MaterialSurface;
+        offset?: number;
+    }[];
+};
+/**
+ * `search_materials`: the library's materials by words, best first, and the words none answers;
+ * without a query, a browse of a kind, a surface or the whole library. Either lists a page at a
+ * time, saying how many more there are and the offset that lists them.
+ */
+export declare const searchMaterials: AgentOperation<SearchMaterialsInput>;
+export {};
+//# sourceMappingURL=search-materials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search-materials.d.ts","sourceRoot":"","sources":["../../src/agent-operations/search-materials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAM1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,oBAAoB,GAAG;IAC1B,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;QAAC,OAAO,CAAC,EAAE,eAAe,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CACnG,CAAA;AA+HD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CAkDhE,CAAA"}

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

@@ -0,0 +1,165 @@
+import { getDynamicLibraryMaterials, MATERIAL_CATALOG, } from '../material-library.js';
+/** The most a group lists at a time: a search's best, a browse by name. */
+const SEARCH_RESULTS = 12;
+const BROWSE_RESULTS = 150;
+/**
+ * Building words as the library writes them: a plan or a brief says timber, weatherboard, render
+ * where the library says wood, siding, stucco.
+ */
+const SAME = {
+    timber: ['wood'],
+    weatherboard: ['siding', 'clapboard'],
+    cladding: ['siding', 'clapboard', 'board', 'batten'],
+    render: ['stucco', 'plaster'],
+    rendered: ['stucco', 'plaster'],
+    sheeting: ['metal', 'seam'],
+    sheet: ['metal', 'seam'],
+    decking: ['wood', 'plank', 'board'],
+    paving: ['stone', 'tile', 'concrete', 'ground'],
+    pavers: ['stone', 'tile', 'concrete'],
+    gray: ['grey'],
+    grey: ['gray'],
+};
+/** Surface words: a material suiting the surface answers them. */
+const SURFACE_WORDS = {
+    roof: 'roof',
+    roofing: 'roof',
+    wall: 'wall',
+    facade: 'wall',
+    floor: 'floor',
+    flooring: 'floor',
+    ceiling: 'ceiling',
+    soffit: 'ceiling',
+    outdoor: 'outdoor',
+    garden: 'outdoor',
+};
+/** Shade words, by the material's colour: relative luminance (0 black, 1 white) and saturation. */
+const SHADES = {
+    dark: ({ luminance }) => luminance < 0.25,
+    black: ({ luminance }) => luminance < 0.08,
+    light: ({ luminance }) => luminance > 0.6,
+    pale: ({ luminance }) => luminance > 0.6,
+    white: ({ luminance }) => luminance > 0.75,
+    grey: ({ luminance, saturation }) => luminance > 0.04 && luminance < 0.75 && saturation < 0.2,
+    gray: ({ luminance, saturation }) => luminance > 0.04 && luminance < 0.75 && saturation < 0.2,
+};
+function shadeOf(hex) {
+    const match = /^#?([0-9a-f]{6})$/i.exec(hex ?? '');
+    if (!match)
+        return null;
+    const srgb = [0, 2, 4].map((i) => Number.parseInt(match[1].slice(i, i + 2), 16) / 255);
+    const [r, g, b] = srgb.map((c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+    const max = Math.max(...srgb);
+    return {
+        luminance: 0.2126 * r + 0.7152 * g + 0.0722 * b,
+        saturation: max ? (max - Math.min(...srgb)) / max : 0,
+    };
+}
+const stem = (word) => (word.length > 4 && word.endsWith('s') ? word.slice(0, -1) : word);
+/** A word that searches: three letters or more, or any word with a digit ("48" of a plank). */
+const searches = (word) => (word.length > 2 || /\d/.test(word)) && !STOP_WORDS.has(word);
+/** Words that tell no material from another: "white render for the walls" asks for three things. */
+const STOP_WORDS = new Set(['and', 'the', 'for', 'with', 'from', 'into', 'some', 'like', 'its']);
+const wordsOf = (text) => text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+/** Whether a material can go on a surface: one that names no surface goes anywhere (flat colours). */
+const suits = (material, surface) => !material.surfaces || material.surfaces.includes(surface);
+/** A material's id with its words run together, as a piece of it is asked ("plank48"). */
+const idRun = (material) => material.id.toLowerCase().replace(/[^a-z0-9]/g, '');
+/**
+ * Whether a material answers a query word: by a word of its text (whole, or begun by a form of four
+ * letters or more: tile answers tiles, for never answers forest), the trade vocabulary, shade or
+ * the surface it is made for.
+ */
+function answers(material, text, word) {
+    const forms = [word, stem(word), ...(SAME[word] ?? []), ...(SAME[stem(word)] ?? [])];
+    const said = (token, form) => token === form || stem(token) === form || (form.length >= 4 && token.startsWith(form));
+    if (forms.some((form) => text.some((token) => said(token, form))))
+        return true;
+    if ((word.length >= 4 || /\d/.test(word)) && idRun(material).includes(word))
+        return true;
+    const shade = SHADES[word];
+    const colour = shadeOf(material.previewColor);
+    if (shade && colour && shade(colour))
+        return true;
+    // A surface word asks for a material made for it (floor is flooring), not one that can go there.
+    const surface = SURFACE_WORDS[word] ?? SURFACE_WORDS[stem(word)];
+    return !!surface && !!material.surfaces?.includes(surface);
+}
+/** Pascal's library, then what the host registered besides (a registration never shadows one). */
+function libraryMaterials() {
+    const pascal = new Set(MATERIAL_CATALOG.map((material) => material.id));
+    return [
+        ...MATERIAL_CATALOG,
+        ...getDynamicLibraryMaterials().filter((material) => !pascal.has(material.id)),
+    ];
+}
+const asResult = (material) => ({
+    ref: `library:${material.id}`,
+    label: material.label,
+    kind: material.category,
+    surfaces: material.surfaces ?? [],
+    ...(material.previewColor ? { color: material.previewColor } : {}),
+});
+const byName = (a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id);
+/** Colour options for a finish the library lacks: nearest library colour, or exact native. */
+const missingMaterialFacts = `paint with color gives the nearest library colour and says how far it moved (ΔE); a native material, paint with material: { properties: { color } }, keeps the exact colour.`;
+/**
+ * `search_materials`: the library's materials by words, best first, and the words none answers;
+ * without a query, a browse of a kind, a surface or the whole library. Either lists a page at a
+ * time, saying how many more there are and the offset that lists them.
+ */
+export const searchMaterials = (_nodes, { queries }) => {
+    const library = libraryMaterials();
+    const groups = queries.map(({ query = '', kind, surface, offset = 0 }) => {
+        const pool = library.filter((material) => (!kind || material.category === kind) && (!surface || suits(material, surface)));
+        const asked = {
+            ...(query ? { query } : {}),
+            ...(kind ? { kind } : {}),
+            ...(surface ? { surface } : {}),
+            ...(offset ? { offset } : {}),
+        };
+        const page = (listed, size) => {
+            const more = listed.length - offset - size;
+            return {
+                results: listed.slice(offset, offset + size).map(asResult),
+                ...(more > 0 ? { more, next: offset + size } : {}),
+            };
+        };
+        if (!query.trim())
+            return { ...asked, ...page([...pool].sort(byName), BROWSE_RESULTS) };
+        // A query of words too short or too common to tell materials apart finds nothing; it
+        // never browses the library in its place.
+        const said = wordsOf(query);
+        const words = said.filter(searches);
+        if (!words.length)
+            return { ...asked, results: [], missing: said };
+        const scored = pool.map((material) => {
+            const text = wordsOf(`${material.id} ${material.label} ${material.category} ${material.description ?? ''}`);
+            return { material, hits: words.filter((word) => answers(material, text, word)) };
+        });
+        // A three-letter piece nothing answers as a word ("cco" of stucco) is looked for in ids.
+        for (const word of words) {
+            if (word.length !== 3 || scored.some(({ hits }) => hits.includes(word)))
+                continue;
+            for (const entry of scored)
+                if (idRun(entry.material).includes(word))
+                    entry.hits.push(word);
+        }
+        const missing = words.filter((word) => !scored.some(({ hits }) => hits.includes(word)));
+        const best = scored
+            .filter(({ hits }) => hits.length)
+            .sort((a, b) => b.hits.length - a.hits.length || byName(a.material, b.material))
+            .map(({ material }) => material);
+        return { ...asked, ...page(best, SEARCH_RESULTS), ...(missing.length ? { missing } : {}) };
+    });
+    const lacking = groups.some((group) => 'missing' in group);
+    return {
+        result: {
+            groups,
+            message: `Materials as library:<id> refs for paint: a search best first, a browse by name. A long list says how many more there are (more) and the offset that lists them (next). The words no material answers are under missing: the library lacks them.${lacking ? ` ${missingMaterialFacts}` : ''}`,
+        },
+    };
+};

package/dist/agent-operations/set-checkpoint.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `set_checkpoint`: the scene now, remembered under a name. The operation takes the checkpoint and
+ * hands it back for the host to keep with the session; nothing in the scene changes.
+ */
+export declare const setCheckpoint: AgentOperation<{
+    name: string;
+}>;
+//# sourceMappingURL=set-checkpoint.d.ts.map

package/dist/agent-operations/set-checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-checkpoint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-checkpoint.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CA+B1D,CAAA"}

package/dist/agent-operations/set-checkpoint.js

@@ -0,0 +1,31 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { EMPTY_SESSION, MAX_CHECKPOINT_NODES, MAX_CHECKPOINTS, takeCheckpoint, } from './scene-checkpoint.js';
+/**
+ * `set_checkpoint`: the scene now, remembered under a name. The operation takes the checkpoint and
+ * hands it back for the host to keep with the session; nothing in the scene changes.
+ */
+export const setCheckpoint = (nodes, input, context) => {
+    const name = input.name.trim();
+    if (!name)
+        refuse('name_required', 'Give the checkpoint a name, e.g. "walls done".');
+    const session = context.session ?? EMPTY_SESSION;
+    const names = Object.keys(session.checkpoints);
+    const replaced = names.includes(name);
+    if (!replaced && names.length >= MAX_CHECKPOINTS)
+        refuse('too_many_checkpoints', `A session keeps at most ${MAX_CHECKPOINTS} checkpoints and has ${names.join(', ')}. Use one of those names to replace it.`, { checkpoints: names });
+    const size = Object.keys(nodes).length;
+    if (size > MAX_CHECKPOINT_NODES)
+        refuse('scene_too_large', `The scene has ${size} nodes; a checkpoint is kept for at most ${MAX_CHECKPOINT_NODES}.`, { nodes: size });
+    const checkpoint = takeCheckpoint(nodes, name, session.made.length);
+    return {
+        result: {
+            ok: true,
+            name,
+            replaced,
+            nodes: size,
+            checkpoints: replaced ? names : [...names, name],
+            message: `Checkpoint "${name}" kept with this session. verify_scene({ since: "${name}" }) lists what changes after it.`,
+        },
+        keep: { checkpoint },
+    };
+};

package/dist/agent-operations/set-ground-level.d.ts

@@ -0,0 +1,12 @@
+import type { AgentOperation } from './types.js';
+type SetGroundLevelInput = {
+    levelId: string;
+};
+/**
+ * `set_ground_level`: the level asked for becomes the building's ground floor — named on the
+ * building, its floor the top of the foundation over grade (as the building's region and style seat it), index 0 — the same change the level panel's "Set as ground floor"
+ * writes (`buildGroundLevelChanges`).
+ */
+export declare const setGroundLevel: AgentOperation<SetGroundLevelInput>;
+export {};
+//# sourceMappingURL=set-ground-level.d.ts.map

package/dist/agent-operations/set-ground-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-ground-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-ground-level.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,mBAAmB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,mBAAmB,CAuD9D,CAAA"}

package/dist/agent-operations/set-ground-level.js

@@ -0,0 +1,61 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { buildGroundLevelChanges } from '../building/ground-level.js';
+import { requireLevel } from './level-target.js';
+import { levelRole } from './scene-queries.js';
+/**
+ * `set_ground_level`: the level asked for becomes the building's ground floor — named on the
+ * building, its floor the top of the foundation over grade (as the building's region and style seat it), index 0 — the same change the level panel's "Set as ground floor"
+ * writes (`buildGroundLevelChanges`).
+ */
+export const setGroundLevel = (nodes, input) => {
+    const level = requireLevel(nodes, input.levelId);
+    const { role } = levelRole(nodes, level);
+    if (role !== 'occupied')
+        refuse('not_a_storey', `${level.name ?? level.id} (${level.id}) is a ${role === 'roof' ? 'roof' : 'support'} level, not a storey: it cannot stand at grade as the ground floor.`, { levelId: level.id, role });
+    const built = buildGroundLevelChanges({
+        nodes: nodes,
+        levelId: level.id,
+    });
+    if (!built)
+        refuse('no_building', `Level ${level.id} is not in a building, so it has no ground line.`, {
+            levelId: level.id,
+        });
+    const { seat, moveBy } = built;
+    const floorElevation = Math.round((seat.floorElevation + moveBy) * 1e6) / 1e6;
+    const name = level.name ?? level.id;
+    const { aboveGrade, foundation } = seat;
+    const construction = {
+        region: foundation.region,
+        construction: foundation.construction.id,
+        basis: foundation.basis,
+    };
+    const inches = Math.round(aboveGrade / 0.0254);
+    if (built.unchanged)
+        return {
+            result: {
+                ok: true,
+                unchanged: true,
+                levelId: level.id,
+                buildingId: built.buildingId,
+                floorElevation: seat.floorElevation,
+                aboveGrade,
+                foundation: construction,
+                message: `${name} is already the ground floor, its floor ${aboveGrade} m (${inches} in) over grade (${foundation.construction.label} foundation; ${foundation.basis}).`,
+            },
+        };
+    return {
+        result: {
+            ok: true,
+            levelId: level.id,
+            buildingId: built.buildingId,
+            floorElevation,
+            gradeElevation: seat.gradeElevation,
+            aboveGrade,
+            foundation: construction,
+            movedBuildingBy: moveBy,
+            renumbered: built.renumbered,
+            message: `${name} is the ground floor: its floor, the top of the foundation where the wood framing starts, stands ${aboveGrade} m (${inches} in) over grade (${floorElevation.toFixed(2)} m over grade ${seat.gradeElevation.toFixed(2)} m), as a ${foundation.construction.label} foundation seats it: ${foundation.construction.seatBasis}; ${foundation.basis}. The levels with a lower index are below grade${moveBy === 0 ? '' : `; the building moved ${moveBy.toFixed(2)} m in height, its plan where it was`}.`,
+        },
+        changes: { update: built.update },
+    };
+};

package/dist/agent-operations/site.d.ts

@@ -0,0 +1,21 @@
+import { type YardKey } from '../lib/site-placement.js';
+import type { AgentOperation } from './types.js';
+type SiteInput = {
+    building?: string;
+    site?: string;
+};
+type PlaceBuildingInput = {
+    building?: string;
+    outline?: number[][];
+    yards?: Partial<Record<YardKey, number>>;
+    rotationDeg?: number;
+};
+/**
+ * `get_site`: the site a building stands on, in its level coordinates; a lot no building stands
+ * on yet, in site coordinates.
+ */
+export declare const getSite: AgentOperation<SiteInput>;
+/** `place_building`: stand a building on its site by its pose, its walls untouched. */
+export declare const placeBuilding: AgentOperation<PlaceBuildingInput>;
+export {};
+//# sourceMappingURL=site.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../src/agent-operations/site.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,OAAO,EACb,MAAM,uBAAuB,CAAA;AAI9B,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,SAAS,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACrD,KAAK,kBAAkB,GAAG;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAA;IACxC,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,cAAc,CAAC,SAAS,CA4B7C,CAAA;AA2CD,uFAAuF;AACvF,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC,kBAAkB,CAmD5D,CAAA"}

package/dist/agent-operations/site.js

@@ -0,0 +1,123 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { isSiteFlatwork } from '../lib/site-flatwork.js';
+import { describeSiteBrief, placeBuildingPose, roundedSiteBrief, siteBrief, } from '../lib/site-placement.js';
+import { targetBuilding } from './add-level.js';
+import { pointInPolygon } from './plan-geometry.js';
+const r2 = (n) => Math.round(n * 100) / 100 || 0;
+/**
+ * `get_site`: the site a building stands on, in its level coordinates; a lot no building stands
+ * on yet, in site coordinates.
+ */
+export const getSite = (nodes, input, context) => {
+    if (input.site) {
+        const site = nodes[input.site];
+        if (!site)
+            refuse('site_not_found', `Site not found: ${input.site}.`, { siteId: input.site });
+        if (site.type !== 'site')
+            refuse('not_a_site', `Node ${input.site} is a ${site.type}, not a site.`, {
+                siteId: input.site,
+                type: site.type,
+            });
+    }
+    const anyBuilding = Object.values(nodes).some((node) => node.type === 'building');
+    const building = input.building || (anyBuilding && !input.site)
+        ? targetBuilding(nodes, input.building, context)
+        : null;
+    // a site named alone is read for the building viewed when it stands there
+    const brief = siteBrief(nodes, building ? { buildingId: building.id } : { siteId: input.site, levelId: context.activeLevelId });
+    if (!brief)
+        refuse('no_site', 'The scene has no site with a lot: add_level starts one.');
+    if (input.site && brief.siteId !== input.site)
+        refuse('building_not_on_site', `${building?.id} stands on ${brief.siteId}, not on ${input.site}: name one or the other.`, { buildingId: building?.id, siteId: input.site });
+    return { result: { ...roundedSiteBrief(brief), summary: describeSiteBrief(brief) } };
+};
+function footprintFacts(footprint) {
+    const b = footprint.bounds;
+    return {
+        footprint: {
+            size: [r2(b.maxX - b.minX), r2(b.maxZ - b.minZ)],
+            bounds: { minX: r2(b.minX), minZ: r2(b.minZ), maxX: r2(b.maxX), maxZ: r2(b.maxZ) },
+            centre: [r2(footprint.centre[0]), r2(footprint.centre[1])],
+        },
+        yards: Object.fromEntries(Object.entries(footprint.yards).map(([key, m]) => [key, m == null ? null : r2(m)])),
+        fit: footprint.fit,
+        overhang: {
+            lotM: r2(footprint.overhang.lotM),
+            setbacksM: r2(footprint.overhang.setbacksM),
+            sides: footprint.overhang.sides,
+        },
+    };
+}
+/**
+ * What stands on the building's levels outside its footprint and moves with it: fences, paths and
+ * the floor items out of doors (a plant cannot be told from a patio chair, so all of them).
+ */
+function outdoorOnLevels(nodes, buildingId, rings) {
+    const building = nodes[buildingId];
+    const levels = new Set(building?.type === 'building' ? building.children : []);
+    const outside = (x, z) => !rings.some((ring) => pointInPolygon([x, z], ring));
+    const moved = [];
+    for (const node of Object.values(nodes)) {
+        if (!(node.parentId && levels.has(node.parentId)))
+            continue;
+        const flatwork = node.type === 'slab' && isSiteFlatwork(node);
+        const outdoorItem = node.type === 'item' && outside(node.position[0] ?? 0, node.position[2] ?? 0);
+        if (node.type === 'fence' || flatwork || outdoorItem)
+            moved.push({ id: node.id, type: node.type, ...(node.name ? { name: node.name } : {}) });
+    }
+    return moved;
+}
+/** `place_building`: stand a building on its site by its pose, its walls untouched. */
+export const placeBuilding = (nodes, input, context) => {
+    const building = targetBuilding(nodes, input.building, context);
+    const placed = placeBuildingPose(nodes, {
+        buildingId: building.id,
+        ...(input.outline
+            ? { outline: input.outline.map((p) => [p[0] ?? 0, p[1] ?? 0]) }
+            : {}),
+        ...(input.yards ? { yards: input.yards } : {}),
+        ...(input.rotationDeg === undefined ? {} : { rotationDeg: input.rotationDeg }),
+    });
+    if (!placed.ok)
+        refuse(placed.code, placed.message, { buildingId: building.id });
+    const facts = footprintFacts(placed.footprint);
+    const rotationDeg = Math.round(((placed.rotation[1] * 180) / Math.PI) * 10) / 10 || 0;
+    const [x, , z] = placed.position;
+    const movedWithIt = placed.moved
+        ? outdoorOnLevels(nodes, building.id, placed.footprint.rings)
+        : [];
+    const where = `${describeSiteBrief({ ...placed.brief, footprint: placed.footprint }).at(-1)}.`;
+    const message = [
+        placed.moved
+            ? `${building.name ?? 'The building'} now stands at site [${r2(x)}, ${r2(z)}], ${rotationDeg}°. Its walls keep their level coordinates; draw new ones in the same frame.`
+            : `${building.name ?? 'The building'} already stands there: nothing moved.`,
+        where,
+        placed.brief.placeholder
+            ? 'The lot is the new-project placeholder: say so, and ask for the address or the site plan.'
+            : '',
+        movedWithIt.length
+            ? `${movedWithIt.length} outdoor node(s) on its levels moved with it (fences, paths, plants, outdoor furniture): re-trace them to the lot.`
+            : '',
+    ].filter(Boolean);
+    return {
+        result: {
+            ok: true,
+            buildingId: building.id,
+            position: placed.position.map(r2),
+            rotationDeg,
+            moved: placed.moved,
+            ...facts,
+            ...(movedWithIt.length ? { movedWithIt: movedWithIt.slice(0, 24) } : {}),
+            message: message.join(' '),
+        },
+        ...(placed.moved
+            ? {
+                changes: {
+                    update: [
+                        { id: building.id, data: { position: placed.position, rotation: placed.rotation } },
+                    ],
+                },
+            }
+            : {}),
+    };
+};

package/dist/agent-operations/stairs.d.ts

@@ -0,0 +1,5 @@
+import type { FitStairInput, MeasureStairInput } from '../agent-tools/stairs.js';
+import type { AgentOperation } from './types.js';
+export declare const measureStairOperation: AgentOperation<MeasureStairInput>;
+export declare const fitStair: AgentOperation<FitStairInput>;
+//# sourceMappingURL=stairs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stairs.d.ts","sourceRoot":"","sources":["../../src/agent-operations/stairs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAM7E,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAWvE,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,iBAAiB,CAQnE,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAoDlD,CAAA"}

package/dist/agent-operations/stairs.js

@@ -0,0 +1,70 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { StairDesignTargets } from '../schema/nodes/stair-design-targets.js';
+import { planStairPreset, proposeStairLayouts } from '../systems/stair/stair-presets.js';
+import { measureStair, planStairSizingEdit } from '../systems/stair/stair-sizing.js';
+import { applySceneChanges } from './apply-changes.js';
+function requireStair(nodes, stairId) {
+    const stair = nodes[stairId];
+    if (stair?.type !== 'stair')
+        refuse('stair_required', `Stair ${stairId} was not found. Choose a stair id from the scene.`, {
+            stairId,
+        });
+    return stair;
+}
+export const measureStairOperation = (nodes, input) => {
+    const stair = requireStair(nodes, input.stairId);
+    return {
+        result: {
+            measurements: measureStair(stair, nodes),
+            layouts: proposeStairLayouts(stair, nodes, input.available),
+        },
+    };
+};
+export const fitStair = (scene, input) => {
+    const original = requireStair(scene, input.stairId);
+    const stair = input.targets
+        ? {
+            ...original,
+            designTargets: StairDesignTargets.parse({ ...original.designTargets, ...input.targets }),
+        }
+        : original;
+    const nodes = { ...scene, [stair.id]: stair };
+    let changes;
+    if (input.layout) {
+        const plan = planStairPreset(stair, nodes, { ...input, layout: input.layout });
+        changes = {
+            delete: plan.removeIds,
+            create: plan.segments
+                .filter((segment) => !nodes[segment.id])
+                .map((node) => ({ node, parentId: stair.id })),
+            update: [
+                ...plan.segments
+                    .filter((segment) => nodes[segment.id])
+                    .map((segment) => ({ id: segment.id, data: segment })),
+                { id: stair.id, data: plan.stair },
+            ],
+        };
+    }
+    else {
+        if (input.turn ||
+            input.width !== undefined ||
+            input.landingDepth !== undefined ||
+            input.turningStrategy ||
+            input.innerGap !== undefined ||
+            input.walkingLineOffset !== undefined ||
+            input.division)
+            refuse('stair_layout_required', 'Choose a straight, L or U layout when specifying layout options.', { stairId: stair.id });
+        const updates = planStairSizingEdit(stair, nodes, input.fitRun);
+        if (input.targets)
+            updates[0].data = {
+                ...updates[0].data,
+                designTargets: stair.designTargets,
+            };
+        changes = { update: updates };
+    }
+    const next = applySceneChanges(scene, changes);
+    return {
+        changes,
+        result: { stairId: stair.id, measurements: measureStair(next[stair.id], next) },
+    };
+};