@pascal-app/core 1.0.1 → 1.0.4

package/dist/agent-operations/__fixtures__/verify-scene-cases.js

@@ -0,0 +1,302 @@
+import { BuildingNode, CeilingNode, DoorNode, FloorOpeningNode, ItemNode, LevelNode, RoofNode, SlabNode, StairNode, StairSegmentNode, WallNode, WindowNode, ZoneNode, } from '../../schema/index.js';
+import { authoredItem } from './add-object-cases.js';
+const ROOM = [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+];
+/** Links parents' children and returns the graph, buildings as roots. */
+function scene(...nodes) {
+    const byId = Object.fromEntries(nodes.map((node) => [node.id, { ...node }]));
+    for (const node of Object.values(byId)) {
+        const parent = node.parentId ? byId[node.parentId] : undefined;
+        if (parent && Array.isArray(parent.children) && !parent.children.includes(node.id))
+            parent.children = [...parent.children, node.id];
+    }
+    return {
+        nodes: byId,
+        rootNodeIds: nodes.filter((node) => node.type === 'building').map((node) => node.id),
+    };
+}
+const building = (id = 'building_main') => BuildingNode.parse({ id });
+const level = (id, index, extra = {}) => LevelNode.parse({
+    id,
+    parentId: 'building_main',
+    level: index,
+    name: `Floor ${index}`,
+    height: 2.8,
+    ...extra,
+});
+/** A finished room on a level: four closed walls, a centred door, its zone, slab and ceiling. */
+function room(levelId, tag) {
+    const [wall, ...walls] = ROOM.map((start, i) => WallNode.parse({
+        id: i === 0 ? `wall_${tag}` : `wall_${tag}_${i}`,
+        parentId: levelId,
+        start,
+        end: ROOM[(i + 1) % ROOM.length],
+        height: 2.5,
+    }));
+    const door = DoorNode.parse({
+        id: `door_${tag}`,
+        parentId: wall.id,
+        wallId: wall.id,
+        position: [2, 1.05, 0],
+    });
+    return [
+        wall,
+        ...walls,
+        door,
+        ZoneNode.parse({ id: `zone_${tag}`, parentId: levelId, name: 'Room', polygon: ROOM }),
+        SlabNode.parse({ id: `slab_${tag}`, parentId: levelId, polygon: ROOM }),
+        CeilingNode.parse({ id: `ceiling_${tag}`, parentId: levelId, polygon: ROOM }),
+    ];
+}
+const STAIR_HOLE = [
+    [1.5, 0.2],
+    [2.5, 0.2],
+    [2.5, 2.2],
+    [1.5, 2.2],
+];
+const stairOn = (levelId, extra = {}) => {
+    const flight = StairSegmentNode.parse({
+        id: `sseg_${levelId}`,
+        parentId: `stair_${levelId}`,
+        width: 1,
+        length: 2,
+        height: 2.5,
+        stepCount: 10,
+    });
+    const stair = StairNode.parse({
+        id: `stair_${levelId}`,
+        parentId: levelId,
+        name: 'Main Stair',
+        position: [2, 0, 0.5],
+        ...extra,
+    });
+    return [stair, flight];
+};
+const asset = (id, dimensions) => ({
+    id,
+    name: id,
+    category: 'furniture',
+    thumbnail: `/items/${id}/thumbnail.webp`,
+    src: `/items/${id}/model.glb`,
+    dimensions,
+});
+const oneStorey = () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'));
+const twoStoreys = (...extra) => scene(building(), level('level_0', 0), level('level_1', 1), ...room('level_0', 'ground'), ...room('level_1', 'upper'), ...extra);
+const verify = (name, build, expectation, extra = {}) => ({
+    name,
+    tool: 'verify_scene',
+    scene: build,
+    input: {},
+    ...extra,
+    expect: {
+        result: expectation.result ?? {},
+        ...(expectation.contains && {
+            contains: { issues: expectation.contains.map((type) => ({ type })) },
+        }),
+        ...(expectation.lacks && { lacks: { issues: expectation.lacks.map((type) => ({ type })) } }),
+        ...(expectation.mentions && { mentions: expectation.mentions }),
+    },
+});
+export const VERIFY_SCENE_CASES = [
+    verify('a finished storey has no issues', oneStorey, {
+        result: {
+            ok: true,
+            valid: true,
+            levelCount: 1,
+            occupiedStoryCount: 1,
+            emptyLevelIds: [],
+            issues: [],
+            hasIssues: false,
+        },
+    }),
+    verify('the viewed floor is marked', oneStorey, { result: { activeLevelId: 'level_0', levels: [{ levelId: 'level_0', isActive: true }] } }, { context: { activeLevelId: 'level_0' }, surfaces: ['core', 'chat'] }),
+    verify('walls with no room and no door are reported', () => scene(building(), level('level_0', 0), WallNode.parse({ id: 'wall_bare', parentId: 'level_0', start: [0, 0], end: [4, 0] })), {
+        contains: ['walls_no_zones', 'walls_no_doors'],
+        lacks: ['wall_open_end'],
+        mentions: ['walls but no zones'],
+    }),
+    verify('a room with no floor or ceiling is reported', () => scene(building(), level('level_0', 0), ZoneNode.parse({ id: 'zone_bare', parentId: 'level_0', name: 'Room', polygon: ROOM })), { contains: ['zones_no_slabs', 'zones_no_ceilings'] }),
+    verify('an empty storey is reported by name and id', () => scene(building(), level('level_0', 0), level('level_1', 1), ...room('level_0', 'ground'), ...stairOn('level_0')), {
+        result: { emptyLevelIds: ['level_1'] },
+        contains: ['empty_levels'],
+        mentions: ['level_1'],
+    }),
+    verify('two storeys with no stair are reported', () => twoStoreys(), {
+        contains: ['missing_stair'],
+    }),
+    verify('a stair on a storey connects them', () => twoStoreys(...stairOn('level_0')), {
+        lacks: ['missing_stair'],
+    }),
+    verify('a roof-only level is neither a storey nor empty: one storey needs no stair', () => scene(building(), level('level_0', 0), level('level_roof', 1, { name: 'Roof' }), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' })), {
+        result: { occupiedStoryCount: 1, roofLevelIds: ['level_roof'], hasIssues: false },
+        lacks: ['missing_stair', 'empty_levels'],
+    }),
+    verify('two single-storey buildings need no stair', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), building('building_annex'), level('level_annex', 0, { parentId: 'building_annex' }), ...room('level_annex', 'annex')), { lacks: ['missing_stair'] }),
+    verify('a roof level with storey content is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' }), WallNode.parse({ id: 'wall_attic', parentId: 'level_roof', start: [0, 0], end: [4, 0] })), { contains: ['roof_level_occupied'] }),
+    verify('a declared roof level with no roof is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground')), { contains: ['roof_level_no_roof'] }),
+    verify('a roof on a storey is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_low', parentId: 'level_0' })), {
+        contains: ['roof_mixed_in_storey'],
+        mentions: ['dedicated roof level'],
+    }),
+    verify('a wall taller than its storey in a multi-storey building is reported', () => twoStoreys(...stairOn('level_0'), WallNode.parse({
+        id: 'wall_tall',
+        parentId: 'level_0',
+        start: [0, 3],
+        end: [4, 3],
+        height: 5.6,
+    })), {
+        contains: ['wall_spans_storeys'],
+        mentions: ['multi-story exterior walls should be split'],
+    }),
+    verify('a tall wall on a one-storey annex beside a two-storey house spans no storeys', () => scene(building(), level('level_0', 0), level('level_1', 1), ...room('level_0', 'ground'), ...room('level_1', 'upper'), ...stairOn('level_0'), building('building_annex'), level('level_annex', 0, { parentId: 'building_annex' }), ...room('level_annex', 'annex'), WallNode.parse({
+        id: 'wall_annex_tall',
+        parentId: 'level_annex',
+        start: [0, 3],
+        end: [4, 3],
+        height: 5.6,
+    })), { lacks: ['wall_spans_storeys'] }),
+    verify('an opening on the wrong wall, past its end and above its top is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), WallNode.parse({ id: 'wall_other', parentId: 'level_0', start: [0, 2], end: [4, 2] }), WindowNode.parse({
+        id: 'window_astray',
+        parentId: 'wall_ground',
+        wallId: 'wall_other',
+        position: [4.8, 2.4, 0],
+        width: 1,
+        height: 1,
+    })), {
+        contains: ['opening_wall_mismatch', 'opening_outside_wall', 'opening_outside_height'],
+        mentions: [
+            'window window_astray has wallId wall_other',
+            'window window_astray extends outside wall wall_ground',
+        ],
+    }),
+    verify('a stair reaching past its floor slab is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ...stairOn('level_0', { position: [3.6, 0, 1], rotation: Math.PI / 2 })), {
+        contains: ['stair_outside_slab'],
+        mentions: ['Stair Main Stair footprint extends outside source floor slab'],
+    }),
+    verify('a wall across a stair is reported', () => twoStoreys(...stairOn('level_0'), WallNode.parse({
+        id: 'wall_blocker',
+        parentId: 'level_0',
+        name: 'Stair Blocker',
+        start: [0, 2],
+        end: [4, 2],
+    })), { contains: ['stair_obstructed'], mentions: ['obstructs stair Main Stair'] }),
+    verify('a stair missing its opening in the floor above is reported', () => twoStoreys(...stairOn('level_0', {
+        fromLevelId: 'level_0',
+        toLevelId: 'level_1',
+        slabOpeningMode: 'destination',
+    })), { contains: ['stair_no_opening'], mentions: ['no destination slab opening'] }, 
+    // Only core: a live store cuts the opening itself when the scene loads, as the editor does.
+    { surfaces: ['core'] }),
+    // Since owned floor openings (#976) a stair's opening is a floor-opening node on the floor
+    // above, owned by the stair; the slab hole it cuts carries the opening, not the stair.
+    verify("a stair whose owned floor opening sits on the floor above has its opening", () => twoStoreys(...stairOn('level_0', {
+        fromLevelId: 'level_0',
+        toLevelId: 'level_1',
+        slabOpeningMode: 'destination',
+    }), FloorOpeningNode.parse({
+        id: 'floor-opening_stair',
+        parentId: 'level_1',
+        polygon: STAIR_HOLE,
+        source: 'stair',
+        ownerId: 'stair_level_0',
+        surfaceId: 'slab_upper',
+        drawnOn: 'floor',
+    })), { lacks: ['stair_no_opening'] }, { surfaces: ['core'] }),
+    verify('a stair whose only owned opening is drawn on its own ceiling still misses the floor above', () => twoStoreys(...stairOn('level_0', {
+        fromLevelId: 'level_0',
+        toLevelId: 'level_1',
+        slabOpeningMode: 'destination',
+    }), FloorOpeningNode.parse({
+        id: 'floor-opening_ceiling',
+        parentId: 'level_0',
+        polygon: STAIR_HOLE,
+        source: 'stair',
+        ownerId: 'stair_level_0',
+        drawnOn: 'ceiling',
+    })), { contains: ['stair_no_opening'] }, { surfaces: ['core'] }),
+    verify('a stair whose only owned opening is drawn on its own ceiling still misses the floor above', () => twoStoreys(...stairOn('level_0', {
+        fromLevelId: 'level_0',
+        toLevelId: 'level_1',
+        slabOpeningMode: 'destination',
+    }), FloorOpeningNode.parse({
+        id: 'floor-opening_ceiling',
+        parentId: 'level_0',
+        polygon: STAIR_HOLE,
+        source: 'stair',
+        ownerId: 'stair_level_0',
+        drawnOn: 'ceiling',
+    })), { contains: ['stair_no_opening'] }, { surfaces: ['core'] }),
+    verify("a stair's floor opening is checked in its own building, not in the house next door", () => scene(building(), level('level_0', 0), level('level_1', 1), ...room('level_0', 'ground'), ...room('level_1', 'upper').filter((node) => node.type !== 'slab'), SlabNode.parse({
+        id: 'slab_upper',
+        parentId: 'level_1',
+        polygon: ROOM,
+        holes: [
+            [
+                [1.5, 0.2],
+                [2.5, 0.2],
+                [2.5, 2.2],
+                [1.5, 2.2],
+            ],
+        ],
+        holeMetadata: [{ source: 'stair', stairId: 'stair_level_0' }],
+    }), ...stairOn('level_0', {
+        fromLevelId: 'level_0',
+        toLevelId: 'level_1',
+        slabOpeningMode: 'destination',
+    }), building('building_annex'), level('level_annex_0', 0, { parentId: 'building_annex' }), level('level_annex_1', 1, { parentId: 'building_annex' }), ...room('level_annex_0', 'annex_ground'), ...room('level_annex_1', 'annex_upper')), { lacks: ['stair_no_opening'] }, { surfaces: ['core'] }),
+    verify('furniture in front of a door is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ItemNode.parse({
+        id: 'item_toilet',
+        parentId: 'level_0',
+        position: [2, 0, 0.5],
+        asset: asset('toilet', [1, 0.9, 1]),
+    })), { contains: ['door_blocked'], mentions: ['door_ground'] }),
+    verify('overlapping furniture is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ItemNode.parse({
+        id: 'item_closet_a',
+        parentId: 'level_0',
+        position: [1, 0, 2],
+        asset: asset('closet', [2, 2.5, 1]),
+    }), ItemNode.parse({
+        id: 'item_closet_b',
+        parentId: 'level_0',
+        position: [1.3, 0, 2.1],
+        asset: asset('closet', [2, 2.5, 1]),
+    })), { contains: ['item_overlap'] }),
+    verify('a node its schema rejects fails validation', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), {
+        ...WallNode.parse({ id: 'wall_broken', parentId: 'level_0', start: [0, 3], end: [4, 3] }),
+        thickness: 'thick',
+    }), { result: { valid: false }, contains: ['schema_invalid'] }, 
+    // Only core: a live store and a bridge would not hold a node that fails its schema.
+    { surfaces: ['core'] }),
+    // Each authored object stands in for something Pascal has no type for: the list names the gaps.
+    verify('authored objects are listed with what they stand in for', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), authoredItem('item_lantern', 'level_0', {
+        name: 'Porch lantern',
+        category: 'light',
+        size: [0.2, 0.4, 0.2],
+    }), authoredItem('item_cornice', 'level_0', {
+        name: 'Cornice',
+        category: 'trim',
+        reason: 'Pascal has no cornice type.',
+        size: [4, 0.3, 0.4],
+    }), ItemNode.parse({
+        id: 'item_sofa',
+        parentId: 'level_0',
+        position: [2, 0, 2],
+        asset: asset('sofa', [2, 0.8, 0.9]),
+    })), {
+        result: {
+            authoredObjects: [
+                {
+                    id: 'item_cornice',
+                    name: 'Cornice',
+                    category: 'trim',
+                    reason: 'Pascal has no cornice type.',
+                },
+                { id: 'item_lantern', name: 'Porch lantern', category: 'light', reason: null },
+            ],
+        },
+    }),
+];

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

@@ -0,0 +1,16 @@
+import type { SceneChanges, SceneNodes } from './types.js';
+export type Achieved = {
+    created: Record<string, number>;
+    updated: number;
+    deleted: Record<string, number>;
+    /** The call left the scene as it was: what it reports was not built. */
+    unchanged?: true;
+};
+/**
+ * What a mutating call really changed, read from the scene before and after its changes, so a
+ * result never claims what the scene does not hold (a facade was once reported "applied" on 432
+ * walls that placed no window). Cheap: one pass over the ids; a scene check per call is not (2.7 s
+ * on a scene of 4,362 nodes).
+ */
+export declare function achievedChanges(before: SceneNodes, changes: SceneChanges): Achieved;
+//# sourceMappingURL=achieved.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"achieved.d.ts","sourceRoot":"","sources":["../../src/agent-operations/achieved.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wEAAwE;IACxE,SAAS,CAAC,EAAE,IAAI,CAAA;CACjB,CAAA;AAWD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,QAAQ,CAanF"}

package/dist/agent-operations/achieved.js

@@ -0,0 +1,28 @@
+import { applySceneChanges } from './apply-changes.js';
+const countByType = (ids, nodes) => {
+    const counts = {};
+    for (const id of ids) {
+        const type = nodes[id]?.type;
+        if (type)
+            counts[type] = (counts[type] ?? 0) + 1;
+    }
+    return counts;
+};
+/**
+ * What a mutating call really changed, read from the scene before and after its changes, so a
+ * result never claims what the scene does not hold (a facade was once reported "applied" on 432
+ * walls that placed no window). Cheap: one pass over the ids; a scene check per call is not (2.7 s
+ * on a scene of 4,362 nodes).
+ */
+export function achievedChanges(before, changes) {
+    const after = applySceneChanges(before, changes);
+    const created = Object.keys(after).filter((id) => !(id in before));
+    const deleted = Object.keys(before).filter((id) => !(id in after));
+    const updated = (changes.update ?? []).filter(({ id }) => id in before && id in after && before[id] !== after[id]).length;
+    return {
+        created: countByType(created, after),
+        updated,
+        deleted: countByType(deleted, before),
+        ...(created.length || deleted.length || updated ? {} : { unchanged: true }),
+    };
+}

package/dist/agent-operations/add-column.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { addColumnTool } from '../agent-tools/columns.js';
+import { ColumnNode, type CompiledGeometryScript, type GeometryScriptParamValue } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type AddColumnInput = z.infer<z.ZodObject<typeof addColumnTool.input>> & {
+    compiled?: CompiledGeometryScript;
+};
+/**
+ * The params a column's script compiles with for this edit: native sizes edit
+ * the declared params, keeping the module's other values. Undefined when the
+ * edit leaves the geometry alone (a rename, a move), so nothing recompiles.
+ */
+export declare function columnScriptParams(node: ColumnNode | undefined, input: {
+    code?: string;
+    params?: Record<string, GeometryScriptParamValue>;
+    height?: number;
+    width?: number;
+    depth?: number;
+}): {
+    [x: string]: string | number | boolean;
+} | undefined;
+export declare const addColumn: AgentOperation<AddColumnInput>;
+//# sourceMappingURL=add-column.d.ts.map

package/dist/agent-operations/add-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-column.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAS3D,OAAO,EAAE,UAAU,EAAE,KAAK,sBAAsB,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAGlG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,GAAG;IAC9E,QAAQ,CAAC,EAAE,sBAAsB,CAAA;CAClC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,KAAK,EAAE;IACL,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;IACjD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;;cAeF;AAED,eAAO,MAAM,SAAS,EAAE,cAAc,CAAC,cAAc,CAsFpD,CAAA"}

package/dist/agent-operations/add-column.js

@@ -0,0 +1,97 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { matchScriptSlotsToLibrary, scriptedSize, scriptSource, withSourceMeta, } from '../lib/geometry-script-node.js';
+import { resettledPosition } from '../lib/geometry-surfaces.js';
+import { ColumnNode } from '../schema/index.js';
+import { editedScriptParams, refuseParamsWithoutScript } from './add-object.js';
+import { targetLevel } from './level-target.js';
+/**
+ * The params a column's script compiles with for this edit: native sizes edit
+ * the declared params, keeping the module's other values. Undefined when the
+ * edit leaves the geometry alone (a rename, a move), so nothing recompiles.
+ */
+export function columnScriptParams(node, input) {
+    const sizes = ['height', 'width', 'depth'].filter((key) => input[key] !== undefined);
+    if (!(input.code || (node?.source && (input.params || sizes.length > 0))))
+        return undefined;
+    const params = { ...editedScriptParams(node, input.params) };
+    for (const key of sizes) {
+        if (node?.source && !input.code && !node.source.manifest.params.some((spec) => spec.id === key))
+            refuse('missing_size_param', `This column's script has no ${key} parameter. Rebuild its code to make ${key} editable.`, { id: node.id, dimension: key });
+        params[key] = input[key];
+    }
+    return params;
+}
+export const addColumn = (nodes, input, context) => {
+    const previous = input.nodeId ? nodes[input.nodeId] : undefined;
+    if (input.nodeId && !previous)
+        refuse('node_not_found', `Node not found: ${input.nodeId}.`);
+    if (previous && previous.type !== 'column')
+        refuse('not_a_column', `${previous.id} is not a column.`);
+    refuseParamsWithoutScript(nodes, input);
+    const parent = previous
+        ? nodes[previous.parentId]
+        : targetLevel(nodes, { level: input.level }, context);
+    if (parent?.type !== 'level')
+        refuse('not_a_level', 'A column belongs to a level.');
+    if (!previous && (input.x === undefined || input.z === undefined))
+        refuse('position_required', 'Pass x and z for the column support point.');
+    const { compiled } = input;
+    if (compiled && compiled.mount !== 'floor')
+        refuse('wrong_mount', "A column's script uses mount 'floor'.");
+    const dimensions = compiled ? scriptedSize(compiled.manifest) : undefined;
+    const { nodeId: _, code: _code, params: _params, level: _level, compiled: _compiled, x, y, z, rotation, ...fields } = input;
+    const node = ColumnNode.parse({
+        ...previous,
+        ...fields,
+        ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
+        name: input.name ??
+            previous?.name ??
+            `Column ${Object.values(nodes).filter((node) => node.type === 'column').length + 1}`,
+        parentId: parent.id,
+        position: [
+            x ?? previous?.position[0] ?? 0,
+            y ?? previous?.position[1] ?? 0,
+            z ?? previous?.position[2] ?? 0,
+        ],
+        rotation: rotation === undefined ? previous?.rotation : (rotation * Math.PI) / 180,
+        ...(previous?.source && !compiled ? { source: withSourceMeta(previous.source, input) } : {}),
+        ...(compiled && dimensions
+            ? {
+                source: scriptSource(compiled, input, previous?.source),
+                slots: matchScriptSlotsToLibrary(compiled.manifest, previous?.slots, previous?.source?.manifest),
+                width: dimensions[0],
+                height: dimensions[1],
+                depth: dimensions[2],
+            }
+            : {}),
+    });
+    const slotIds = new Set(compiled?.manifest.slots.map((slot) => slot.id));
+    const orphanedSlots = compiled
+        ? Object.keys(previous?.slots ?? {}).filter((id) => !slotIds.has(id))
+        : [];
+    const resettled = [];
+    if (compiled && previous) {
+        for (const id of previous.children) {
+            const child = nodes[id];
+            if (child?.type !== 'item' || child.wallId)
+                continue;
+            const position = resettledPosition(compiled.manifest, child, [1, 1, 1]);
+            if (position?.some((value, i) => Math.abs(value - child.position[i]) > 1e-4))
+                resettled.push({ id, data: { position } });
+        }
+    }
+    return {
+        result: {
+            ok: true,
+            columnId: node.id,
+            nodeId: node.id,
+            height: node.height,
+            width: node.width,
+            depth: node.depth,
+            ...(orphanedSlots.length ? { orphanedSlots } : {}),
+        },
+        changes: previous
+            ? { update: [{ id: node.id, data: node }, ...resettled] }
+            : { create: [{ node, parentId: parent.id }] },
+    };
+};

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

@@ -0,0 +1,14 @@
+import { BuildingNode } from '../schema/index.js';
+import type { AgentContext, AgentOperation, SceneNodes } from './types.js';
+type AddLevelInput = {
+    buildingId?: string;
+    position?: 'above' | 'below';
+    name?: string;
+    height?: number;
+};
+/** The building named, else the one holding the viewed floor, else the scene's only building. */
+export declare function targetBuilding(nodes: SceneNodes, buildingId: string | undefined, context: AgentContext): BuildingNode;
+/** `add_level`: an empty level over the building's highest, or under its lowest — the editor's +. */
+export declare const addLevel: AgentOperation<AddLevelInput>;
+export {};
+//# sourceMappingURL=add-level.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAuB,MAAM,WAAW,CAAA;AAG7D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvE,KAAK,aAAa,GAAG;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,YAAY,GACpB,YAAY,CAwBd;AAuCD,qGAAqG;AACrG,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CA4BlD,CAAA"}

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

@@ -0,0 +1,94 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { BuildingNode, LevelNode, SiteNode } from '../schema/index.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { levelsOf } from './scene-queries.js';
+/** The building named, else the one holding the viewed floor, else the scene's only building. */
+export function targetBuilding(nodes, buildingId, context) {
+    if (buildingId) {
+        const node = nodes[buildingId];
+        if (!node)
+            refuse('building_not_found', `Building not found: ${buildingId}.`, { buildingId });
+        if (node.type !== 'building')
+            refuse('not_a_building', `Node ${buildingId} is a ${node.type}, not a building.`, {
+                buildingId,
+                type: node.type,
+            });
+        return node;
+    }
+    const viewed = context.activeLevelId ? nodes[context.activeLevelId] : undefined;
+    const holder = viewed?.parentId ? nodes[viewed.parentId] : undefined;
+    if (holder?.type === 'building')
+        return holder;
+    const buildings = Object.values(nodes).filter((node) => node.type === 'building');
+    if (buildings.length === 1)
+        return buildings[0];
+    if (!buildings.length)
+        refuse('no_building', 'The scene has no building to add a level to.');
+    return refuse('building_required', `The scene has ${buildings.length} buildings; say which: ${buildings.map((building) => building.id).join(', ')}.`, { buildingIds: buildings.map((building) => building.id) });
+}
+/**
+ * On a scene with no building, the editor's own empty scene: a site (unless one stands), its
+ * building, the ground level. An agent that cleared the scene to restart begins again here.
+ */
+function freshStart(nodes, input) {
+    const standing = Object.values(nodes).find((node) => node.type === 'site');
+    const site = standing ? null : SiteNode.parse({ children: [] });
+    const siteId = standing?.id ?? site.id;
+    const building = BuildingNode.parse({ parentId: siteId, children: [] });
+    const level = LevelNode.parse({
+        parentId: building.id,
+        level: 0,
+        height: input.height ?? DEFAULT_LEVEL_HEIGHT,
+        children: [],
+        ...(input.name ? { name: input.name } : {}),
+    });
+    return {
+        result: {
+            ok: true,
+            levelId: level.id,
+            buildingId: building.id,
+            ...(site ? { siteId: site.id } : {}),
+            floorIndex: 0,
+            ...(level.name ? { name: level.name } : {}),
+            height: level.height,
+            message: `The scene had no building: made ${site ? 'a site, ' : ''}a building and its ground level.`,
+        },
+        changes: {
+            create: [
+                ...(site ? [{ node: site }] : []),
+                { node: building, parentId: siteId },
+                { node: level, parentId: building.id },
+            ],
+        },
+    };
+}
+/** `add_level`: an empty level over the building's highest, or under its lowest — the editor's +. */
+export const addLevel = (nodes, input, context) => {
+    if (!(input.buildingId || Object.values(nodes).some((node) => node.type === 'building')))
+        return freshStart(nodes, input);
+    const building = targetBuilding(nodes, input.buildingId, context);
+    const floors = levelsOf(nodes)
+        .filter((level) => level.parentId === building.id || building.children.includes(level.id))
+        .map((level) => level.level);
+    const below = input.position === 'below';
+    const floorIndex = !floors.length ? 0 : below ? Math.min(...floors) - 1 : Math.max(...floors) + 1;
+    const level = LevelNode.parse({
+        parentId: building.id,
+        level: floorIndex,
+        height: input.height ?? DEFAULT_LEVEL_HEIGHT,
+        children: [],
+        ...(input.name ? { name: input.name } : {}),
+    });
+    return {
+        result: {
+            ok: true,
+            levelId: level.id,
+            buildingId: building.id,
+            floorIndex,
+            ...(level.name ? { name: level.name } : {}),
+            height: level.height,
+            message: `Added ${level.name ?? `level ${floorIndex}`} ${below ? 'below' : 'above'} the existing levels of ${building.name ?? building.id}.`,
+        },
+        changes: { create: [{ node: level, parentId: building.id }] },
+    };
+};