@pascal-app/core 1.0.5 → 1.0.7

package/dist/agent-operations/__fixtures__/unit-cases.js

@@ -0,0 +1,266 @@
+import { BuildingNode, LevelNode, UnitNode, ZoneNode } from '../../schema/index.js';
+// A building of flats on two storeys: a living room and a kitchen downstairs, a bedroom upstairs.
+// "Apartment A" holds the living room, "Apartment B" the bedroom; the kitchen is in no unit. A
+// second building, a shop, holds its own unit, so a listing can tell the buildings apart.
+const room = (id, parentId, name) => ZoneNode.parse({
+    id,
+    parentId,
+    name,
+    polygon: [
+        [0, 0],
+        [4, 0],
+        [4, 3],
+        [0, 3],
+    ],
+});
+function flatsScene() {
+    const living = room('zone_living', 'level_g', 'Living room');
+    const kitchen = room('zone_kitchen', 'level_g', 'Kitchen');
+    const bed = room('zone_bed', 'level_1', 'Bedroom');
+    const ground = LevelNode.parse({
+        id: 'level_g',
+        parentId: 'building_flats',
+        level: 0,
+        children: [living.id, kitchen.id],
+    });
+    const upper = LevelNode.parse({
+        id: 'level_1',
+        parentId: 'building_flats',
+        level: 1,
+        children: [bed.id],
+    });
+    const a = UnitNode.parse({
+        id: 'unit_a',
+        parentId: 'building_flats',
+        name: 'Apartment A',
+        members: [living.id],
+    });
+    const b = UnitNode.parse({
+        id: 'unit_b',
+        parentId: 'building_flats',
+        name: 'Apartment B',
+        members: [bed.id],
+    });
+    const flats = BuildingNode.parse({
+        id: 'building_flats',
+        name: 'Flats',
+        children: [ground.id, upper.id, a.id, b.id],
+    });
+    const shopRoom = room('zone_shop', 'level_shop', 'Shop floor');
+    const shopLevel = LevelNode.parse({
+        id: 'level_shop',
+        parentId: 'building_shop',
+        level: 0,
+        children: [shopRoom.id],
+    });
+    const shopUnit = UnitNode.parse({
+        id: 'unit_shop',
+        parentId: 'building_shop',
+        name: 'Shop 1',
+        kind: 'commercial',
+        members: [shopRoom.id],
+    });
+    const shop = BuildingNode.parse({
+        id: 'building_shop',
+        name: 'Shop',
+        children: [shopLevel.id, shopUnit.id],
+    });
+    const nodes = [flats, ground, upper, living, kitchen, bed, a, b, shop, shopLevel, shopRoom, shopUnit];
+    return {
+        nodes: Object.fromEntries(nodes.map((node) => [node.id, node])),
+        rootNodeIds: [flats.id, shop.id],
+    };
+}
+const viewed = { activeLevelId: 'level_g' };
+const unitHolding = (nodes, zoneId) => Object.values(nodes).find((node) => node.type === 'unit' && node.members.includes(zoneId));
+export const CREATE_UNIT_CASES = [
+    {
+        name: 'a duplex over two storeys of the viewed building, under that building',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { name: 'Duplex', memberZoneIds: ['zone_kitchen', 'zone_bed'], move: true },
+        context: viewed,
+        expect: {
+            result: {
+                name: 'Duplex',
+                kind: 'apartment',
+                buildingId: 'building_flats',
+                memberCount: 2,
+                members: ['zone_kitchen', 'zone_bed'],
+            },
+            after: { unit_b: { members: [] } },
+            check: (result, nodes) => {
+                const unit = nodes[result.unitId];
+                if (unit?.type !== 'unit')
+                    return ['no unit node was made'];
+                const building = nodes.building_flats;
+                return [
+                    ...(unit.parentId === 'building_flats' ? [] : ['the unit is not under its building']),
+                    ...(building?.type === 'building' && building.children.includes(unit.id)
+                        ? []
+                        : ['the building does not list the unit']),
+                ];
+            },
+            mentions: ['Duplex', '2 rooms', '1 moved from another unit'],
+        },
+    },
+    {
+        name: 'kind and colour are kept; a unit may hold no room yet',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { buildingId: 'building_flats', name: 'Suite 301', kind: 'hotel-room', color: '#123456' },
+        expect: {
+            result: { name: 'Suite 301', kind: 'hotel-room', color: '#123456', memberCount: 0 },
+            mentions: ['Made hotel-room'],
+        },
+    },
+    {
+        name: 'a zone already in another unit is refused, naming that unit',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { buildingId: 'building_flats', name: 'Apartment C', memberZoneIds: ['zone_living'] },
+        expect: { refusal: 'zone_in_other_unit', mentions: ['unit_a', 'Apartment A', 'move: true'] },
+    },
+    {
+        name: 'a zone of another building is refused',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { buildingId: 'building_flats', name: 'Apartment C', memberZoneIds: ['zone_shop'] },
+        expect: { refusal: 'zone_outside_building', mentions: ['zone_shop', 'building_flats'] },
+    },
+    {
+        name: 'a missing zone, or a node that is no zone, is refused',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { buildingId: 'building_flats', name: 'Apartment C', memberZoneIds: ['level_g'] },
+        expect: { refusal: 'zone_not_found', mentions: ['level_g', 'not a zone'] },
+    },
+    {
+        name: 'a missing building is refused',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { buildingId: 'building_missing', name: 'Apartment C' },
+        expect: { refusal: 'building_not_found' },
+    },
+    {
+        name: 'two buildings and no viewed floor: say which',
+        tool: 'create_unit',
+        scene: flatsScene,
+        input: { name: 'Apartment C' },
+        context: { activeLevelId: null },
+        expect: { refusal: 'building_required', mentions: ['building_flats', 'building_shop'] },
+    },
+];
+export const SET_UNIT_MEMBERS_CASES = [
+    {
+        name: 'replaces the rooms a unit holds, across storeys, listing a zone once',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'unit_a', memberZoneIds: ['zone_kitchen', 'zone_living', 'zone_kitchen'] },
+        expect: {
+            result: { unitId: 'unit_a', memberCount: 2, members: ['zone_kitchen', 'zone_living'] },
+            after: { unit_a: { members: ['zone_kitchen', 'zone_living'] }, unit_b: { members: ['zone_bed'] } },
+        },
+    },
+    {
+        name: 'an empty list empties the unit and deletes no room',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'unit_a', memberZoneIds: [] },
+        expect: {
+            result: { unitId: 'unit_a', memberCount: 0 },
+            present: ['zone_living'],
+            after: { unit_a: { members: [] } },
+        },
+    },
+    {
+        name: 'a zone in another unit is refused, naming that unit, and moves with move: true',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'unit_b', memberZoneIds: ['zone_bed', 'zone_living'] },
+        expect: { refusal: 'zone_in_other_unit', mentions: ['unit_a', 'Apartment A'] },
+    },
+    {
+        name: 'move: true takes the zone from the unit that held it',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'unit_b', memberZoneIds: ['zone_bed', 'zone_living'], move: true },
+        expect: {
+            result: { unitId: 'unit_b', memberCount: 2 },
+            after: { unit_a: { members: [] }, unit_b: { members: ['zone_bed', 'zone_living'] } },
+            check: (_result, nodes) => unitHolding(nodes, 'zone_living')?.id === 'unit_b' ? [] : ['the living room is not in B'],
+            mentions: ['1 moved from another unit'],
+        },
+    },
+    {
+        name: 'a unit that does not exist, or a node that is no unit, is refused',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'zone_living', memberZoneIds: [] },
+        expect: { refusal: 'unit_not_found', mentions: ['zone_living', 'not a unit'] },
+    },
+    {
+        name: 'a zone of another building is refused',
+        tool: 'set_unit_members',
+        scene: flatsScene,
+        input: { unitId: 'unit_a', memberZoneIds: ['zone_shop'] },
+        expect: { refusal: 'zone_outside_building' },
+    },
+];
+export const LIST_UNITS_CASES = [
+    {
+        name: 'every unit of the scene, with its report',
+        tool: 'list_units',
+        scene: flatsScene,
+        input: {},
+        readOnly: true,
+        expect: {
+            result: {},
+            contains: {
+                units: [
+                    {
+                        unitId: 'unit_a',
+                        name: 'Apartment A',
+                        kind: 'apartment',
+                        members: ['zone_living'],
+                        report: {
+                            memberCount: 1,
+                            levelSpan: { minOrdinal: 0, maxOrdinal: 0, count: 1 },
+                            grossAreaM2: 12,
+                            members: [
+                                { zoneId: 'zone_living', name: 'Living room', levelId: 'level_g', levelOrdinal: 0, areaM2: 12 },
+                            ],
+                        },
+                    },
+                    { unitId: 'unit_b', name: 'Apartment B' },
+                    { unitId: 'unit_shop', name: 'Shop 1', kind: 'commercial' },
+                ],
+            },
+            check: (result) => (result.units.length === 3 ? [] : ['expected 3 units']),
+        },
+    },
+    {
+        name: 'the units of one building',
+        tool: 'list_units',
+        scene: flatsScene,
+        input: { buildingId: 'building_shop' },
+        readOnly: true,
+        expect: {
+            result: { units: [{ unitId: 'unit_shop', name: 'Shop 1', kind: 'commercial' }] },
+            lacks: { units: [{ unitId: 'unit_a' }] },
+        },
+    },
+    {
+        name: 'a building that does not exist is refused',
+        tool: 'list_units',
+        scene: flatsScene,
+        input: { buildingId: 'building_missing' },
+        readOnly: true,
+        expect: { refusal: 'building_not_found' },
+    },
+];
+export const UNIT_CASES = [
+    ...CREATE_UNIT_CASES,
+    ...SET_UNIT_MEMBERS_CASES,
+    ...LIST_UNITS_CASES,
+];

package/dist/agent-operations/__fixtures__/verify-scene-cases.d.ts

@@ -65,7 +65,7 @@ export declare const level: (id: string, index: number, extra?: Record<string, u
     } | undefined;
     id: `level_${string}`;
     type: "level";
-    children: (`block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
+    children: (`beam_${string}` | `block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
     level: number;
     baseElevation: number;
     height?: number | undefined;
@@ -73,6 +73,83 @@ export declare const level: (id: string, index: number, extra?: Record<string, u
 /** A finished room on a level: four closed walls, a centred door, its zone, slab and ceiling. */
 export declare function room(levelId: string, tag: string): AnyNode[];
 export declare const stairOn: (levelId: string, extra?: Record<string, unknown>) => ({
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `sseg_${string}`;
+    type: "stair-segment";
+    material?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+    position: [number, number, number];
+    rotation: number;
+    segmentType: "landing" | "stair";
+    width: number;
+    length: number;
+    height: number;
+    stepCount: number;
+    attachmentSide: "front" | "left" | "right";
+    fillToFloor: boolean;
+    construction?: {
+        mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+        waistThickness: number;
+        treadThickness: number;
+        riserThickness: number;
+        nosing: number;
+        finishThickness: number;
+        closedRisers: boolean;
+        stringerWidth: number;
+        stringerDepth: number;
+    } | undefined;
+    winder?: {
+        turn: "left" | "right";
+        innerGap: number;
+        walkingLineOffset: number;
+        division: "equal-angle" | "equal-going";
+    } | undefined;
+    thickness: number;
+} | {
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -113,6 +190,11 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     materialPreset?: string | undefined;
@@ -131,6 +213,11 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     railingMaterialPreset?: string | undefined;
@@ -149,6 +236,11 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     treadMaterialPreset?: string | undefined;
@@ -167,6 +259,11 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
             url: string;
             repeat?: [number, number] | undefined;
             scale?: number | undefined;
+            offset?: [number, number] | undefined;
+            normalMap?: string | undefined;
+            normalScale?: number | undefined;
+            bumpMap?: string | undefined;
+            bumpScale?: number | undefined;
         } | undefined;
     } | undefined;
     sideMaterialPreset?: string | undefined;
@@ -205,6 +302,17 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
         stringerWidth: number;
         stringerDepth: number;
     } | undefined;
+    structure?: {
+        type: "concrete" | "steel-stringers" | "wood-stringers";
+        stringerStock: "2x10" | "2x12";
+        stringerType: "cut" | "housed";
+        stringerSpacing: number;
+        stringerCount?: number | undefined;
+        treadStock?: "2x12" | "2x6-pair" | "5/4x6-pair" | "plywood-finish" | undefined;
+        closedRisers?: boolean | undefined;
+        treated?: boolean | undefined;
+        nosing?: number | undefined;
+    } | undefined;
     innerRadius: number;
     sweepAngle: number;
     topLandingMode: "integrated" | "none";
@@ -235,78 +343,6 @@ export declare const stairOn: (levelId: string, extra?: Record<string, unknown>)
     railingTopReach?: number | undefined;
     railingPostThrough?: boolean | undefined;
     children: `sseg_${string}`[];
-} | {
-    object: "node";
-    name?: string | undefined;
-    parentId: string | null;
-    visible: boolean;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "orthographic" | "perspective";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
-    metadata: Record<string, unknown>;
-    provenance?: {
-        refs: {
-            ns?: string | undefined;
-            id: string;
-            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
-        }[];
-        lineage?: {
-            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
-            fromIds: string[];
-        } | undefined;
-    } | undefined;
-    id: `sseg_${string}`;
-    type: "stair-segment";
-    material?: {
-        id?: string | undefined;
-        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
-        properties?: {
-            color: string;
-            roughness: number;
-            metalness: number;
-            opacity: number;
-            transparent: boolean;
-            side: "back" | "double" | "front";
-        } | undefined;
-        texture?: {
-            url: string;
-            repeat?: [number, number] | undefined;
-            scale?: number | undefined;
-        } | undefined;
-    } | undefined;
-    materialPreset?: string | undefined;
-    slots?: Record<string, string> | undefined;
-    position: [number, number, number];
-    rotation: number;
-    segmentType: "landing" | "stair";
-    width: number;
-    length: number;
-    height: number;
-    stepCount: number;
-    attachmentSide: "front" | "left" | "right";
-    fillToFloor: boolean;
-    construction?: {
-        mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
-        waistThickness: number;
-        treadThickness: number;
-        riserThickness: number;
-        nosing: number;
-        finishThickness: number;
-        closedRisers: boolean;
-        stringerWidth: number;
-        stringerDepth: number;
-    } | undefined;
-    winder?: {
-        turn: "left" | "right";
-        innerGap: number;
-        walkingLineOffset: number;
-        division: "equal-angle" | "equal-going";
-    } | undefined;
-    thickness: number;
 })[];
 export declare const VERIFY_SCENE_CASES: AgentToolCase[];
 export {};

package/dist/agent-operations/__fixtures__/verify-scene-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-scene-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/verify-scene-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAeb,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAExD;;;GAGG;AAEH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1B,eAAO,MAAM,IAAI,EAAE,EAAE,EAKpB,CAAA;AAED,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAcrD;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuD,CAAA;AAC5E,eAAO,MAAM,KAAK,OAAQ,MAAM,SAAS,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3E,CAAA;AAEJ,iGAAiG;AACjG,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAwB5D;AAoBD,eAAO,MAAM,OAAO,YAAa,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBtE,CAAA;AAgDD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+mB7C,CAAA"}
+{"version":3,"file":"verify-scene-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/verify-scene-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAeb,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAExD;;;GAGG;AAEH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1B,eAAO,MAAM,IAAI,EAAE,EAAE,EAKpB,CAAA;AAED,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAcrD;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuD,CAAA;AAC5E,eAAO,MAAM,KAAK,OAAQ,MAAM,SAAS,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3E,CAAA;AAEJ,iGAAiG;AACjG,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAwB5D;AAoBD,eAAO,MAAM,OAAO,YAAa,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBtE,CAAA;AAgDD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+mB7C,CAAA"}

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

@@ -1 +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;AAU3D,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,CAwFpD,CAAA"}
+{"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;AAkB3D,OAAO,EAAE,UAAU,EAAE,KAAK,sBAAsB,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAIlG,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,CAoHpD,CAAA"}

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

@@ -1,9 +1,12 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { getFloorPlacedElevation } from '../hooks/spatial-grid/floor-placed-elevation.js';
+import { FRAMING_POST_MIN_HEIGHT, FRAMING_POST_SIZES, framingPostBasePatch, framingPostFields, framingPostTopAt, } from '../lib/framing-post.js';
 import { matchScriptSlotsToLibrary, requireMeasured, 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';
+import { queryNodes } from './scene-queries.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
@@ -41,14 +44,26 @@ export const addColumn = (nodes, input, context) => {
     if (compiled)
         requireMeasured(compiled, { label: input.name, nodeId: input.nodeId, tool: 'add_column' });
     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({
+    const post = (input.role ?? previous?.role) === 'post';
+    if (!post && (input.postSize !== undefined || input.postBase !== undefined))
+        refuse('not_a_post', 'postSize and postBase require role post or an existing framing post.');
+    const newPost = post && previous?.role !== 'post';
+    const { nodeId: _, code: _code, params: _params, level: _level, compiled: _compiled, x, y, z, rotation, postSize, ...fields } = input;
+    let node = ColumnNode.parse({
         ...previous,
+        ...(newPost ? framingPostFields(postSize, input.postBase) : {}),
         ...fields,
+        ...(postSize
+            ? {
+                width: FRAMING_POST_SIZES[postSize],
+                depth: FRAMING_POST_SIZES[postSize],
+                radius: FRAMING_POST_SIZES[postSize] / 2,
+            }
+            : {}),
         ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
         name: input.name ??
             previous?.name ??
-            `Column ${Object.values(nodes).filter((node) => node.type === 'column').length + 1}`,
+            (post ? 'Post' : `Column ${queryNodes(nodes, { type: 'column' }).length + 1}`),
         parentId: parent.id,
         position: [
             x ?? previous?.position[0] ?? 0,
@@ -67,6 +82,20 @@ export const addColumn = (nodes, input, context) => {
             }
             : {}),
     });
+    if (post && (newPost || postSize !== undefined || input.postBase !== undefined))
+        node = ColumnNode.parse({
+            ...node,
+            ...framingPostBasePatch(node, input.postBase ?? node.postBase ?? 'none'),
+        });
+    if (newPost && input.height === undefined && !compiled) {
+        const base = getFloorPlacedElevation({ node, nodes, position: node.position, levelId: parent.id }) +
+            node.position[1];
+        const { top } = framingPostTopAt(nodes, parent.id, [node.position[0], node.position[2]], {
+            baseElevation: base,
+            side: node.width,
+        });
+        node = { ...node, height: Math.max(FRAMING_POST_MIN_HEIGHT, top - base) };
+    }
     const slotIds = new Set(compiled?.manifest.slots.map((slot) => slot.id));
     const orphanedSlots = compiled
         ? Object.keys(previous?.slots ?? {}).filter((id) => !slotIds.has(id))

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

@@ -1 +1 @@
-{"version":3,"file":"add-fence.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAGnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAO7C,KAAK,aAAa,GAAG,gBAAgB,GAAG;IACtC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IAClC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyClD,CAAA"}
+{"version":3,"file":"add-fence.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAInE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAO7C,KAAK,aAAa,GAAG,gBAAgB,GAAG;IACtC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IAClC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyClD,CAAA"}

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

@@ -3,6 +3,7 @@ import { FenceNode } from '../schema/index.js';
 import { targetLevel } from './level-target.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
 import { refuseRoofLevel } from './roof-writes.js';
+import { queryNodes } from './scene-queries.js';
 /** A fence side shorter than this is a slip, not a fence. */
 const FENCE_MIN_SIDE = 0.1;
 const round = (value) => Math.round(value * 100) / 100;
@@ -23,7 +24,7 @@ export const addFence = (nodes, input, context) => {
     const short = sides.find(([a, b]) => Math.hypot(b[0] - a[0], b[1] - a[1]) < FENCE_MIN_SIDE);
     if (short)
         refuse('fence_too_short', `The side from [${short[0]}] to [${short[1]}] is shorter than ${FENCE_MIN_SIDE * 100} cm: drop the repeated point.`, { start: short[0], end: short[1] });
-    const first = Object.values(nodes).filter((node) => node.type === 'fence').length;
+    const first = queryNodes(nodes, { type: 'fence' }).length;
     const fences = sides.map(([start, end], i) => FenceNode.parse({
         name: `Fence ${first + i + 1}`,
         parentId: level.id,

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

@@ -1 +1 @@
-{"version":3,"file":"add-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-level.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAuB,MAAM,WAAW,CAAA;AAK7D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAErF,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;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyDlD,CAAA"}
+{"version":3,"file":"add-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-level.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAuB,MAAM,WAAW,CAAA;AAK7D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAErF,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,CAsBd;AAuCD;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyDlD,CAAA"}

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

@@ -6,7 +6,7 @@ import { BuildingNode, LevelNode, SiteNode } from '../schema/index.js';
 import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
 import { storeyInsertIndex } from '../services/roof-level.js';
 import { applySceneChanges } from './apply-changes.js';
-import { levelsOf } from './scene-queries.js';
+import { levelsOf, queryNodes } 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) {
@@ -24,7 +24,7 @@ export function targetBuilding(nodes, buildingId, context) {
     const holder = viewed?.parentId ? nodes[viewed.parentId] : undefined;
     if (holder?.type === 'building')
         return holder;
-    const buildings = Object.values(nodes).filter((node) => node.type === 'building');
+    const buildings = queryNodes(nodes, { type: 'building' });
     if (buildings.length === 1)
         return buildings[0];
     if (!buildings.length)
@@ -36,7 +36,7 @@ export function targetBuilding(nodes, buildingId, context) {
  * 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 standing = queryNodes(nodes, { type: 'site' })[0];
     const site = standing ? null : SiteNode.parse({ children: [] });
     const siteId = standing?.id ?? site.id;
     const building = BuildingNode.parse({ parentId: siteId, children: [] });
@@ -72,7 +72,7 @@ function freshStart(nodes, input) {
  * one), or under its lowest level — the editor's +.
  */
 export const addLevel = (nodes, input, context) => {
-    if (!(input.buildingId || Object.values(nodes).some((node) => node.type === 'building')))
+    if (!(input.buildingId || queryNodes(nodes, { type: 'building' }).length))
         return freshStart(nodes, input);
     const building = targetBuilding(nodes, input.buildingId, context);
     const floors = levelsOf(nodes)