@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/__fixtures__/add-object-cases.d.ts

@@ -3,7 +3,8 @@ import type { AgentSurface, SceneGraph } from './cases.js';
 /**
  * `add_object`, the one way to author an object Pascal has no type for. Each new object says what
  * it stands in for (its reason, listed by verify_scene), so every one names a gap in Pascal; one
- * on a floor shaped like a wall or a floor plate is refused with the tool to use; one named
+ * on a floor shaped like a wall, or like a floor plate with no floor under it (a rug lies over
+ * one), is refused with the tool to use; one named
  * after something Pascal builds gets a hint, not a refusal (a word gate once refused "entry door
  * pull handle (brass)", and the agent relabelled it until the label named nothing).
  *
@@ -37,6 +38,12 @@ export type AddObjectCase = {
  * plain box (12 triangles) unless it has more detail.
  */
 export declare function compiledSolid([width, height, depth]: [number, number, number], mount?: GeometryScriptMount, triangles?: number): CompiledGeometryScript;
+/**
+ * What a compile that could not measure the object leaves in the manifest: a mesh at a position
+ * that is not a number made every bound NaN. A structured clone (the chat's worker) keeps NaN; a
+ * JSON hop (a tab job answering the server) turns it to null.
+ */
+export declare function compiledUnmeasured(hop: 'clone' | 'json', mount?: GeometryScriptMount): CompiledGeometryScript;
 /** An object add_object built earlier, with the reason it was given. */
 export declare function authoredItem(id: string, parentId: string, fields: {
     name: string;
@@ -45,106 +52,52 @@ export declare function authoredItem(id: string, parentId: string, fields: {
     size: [number, number, number];
 }): {
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
-    metadata: Record<string, unknown>;
-    id: `item_${string}`;
-    type: "item";
-    position: [number, number, number];
-    rotation: [number, number, number];
-    scale: [number, number, number];
-    children: string[];
-    asset: {
-        id: string;
-        category: string;
-        name: string;
-        thumbnail: string;
-        source: "library" | "community" | "mine";
-        src: string;
-        dimensions: [number, number, number];
-        offset: [number, number, number];
-        rotation: [number, number, number];
-        scale: [number, number, number];
-        floorPlanUrl?: string | undefined;
-        isDraft?: boolean | undefined;
-        attachTo?: "wall" | "ceiling" | "wall-side" | undefined;
-        recessed?: boolean | undefined;
-        tags?: string[] | undefined;
-        functionTags?: string[] | undefined;
-        surface?: {
-            height: number;
-        } | undefined;
-        interactive?: {
-            controls: ({
-                kind: "toggle";
-                label?: string | undefined;
-                default?: boolean | undefined;
-            } | {
-                kind: "slider";
-                label: string;
-                min: number;
-                max: number;
-                step: number;
-                displayMode: "slider" | "stepper" | "dial";
-                unit?: string | undefined;
-                default?: number | undefined;
-            } | {
-                kind: "temperature";
-                label: string;
-                min: number;
-                max: number;
-                unit: "C" | "F";
-                default?: number | undefined;
-            })[];
-            effects: ({
-                kind: "animation";
-                clips: {
-                    on?: string | undefined;
-                    off?: string | undefined;
-                    loop?: string | undefined;
-                };
-                mode?: "ambient" | "open-close" | undefined;
-                control?: number | undefined;
-            } | {
-                kind: "light";
-                color: string;
-                intensityRange: [number, number];
-                offset: [number, number, number];
-                distance?: number | undefined;
-            })[];
-        } | undefined;
-    };
-    name?: string | undefined;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
-        mode: "perspective" | "orthographic";
+        mode: "orthographic" | "perspective";
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    metadata: Record<string, unknown>;
     provenance?: {
         refs: {
-            id: string;
             ns?: string | undefined;
-            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
         }[];
         lineage?: {
-            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
             fromIds: string[];
         } | undefined;
     } | undefined;
-    side?: "front" | "back" | undefined;
+    id: `item_${string}`;
+    type: "item";
+    position: [number, number, number];
+    rotation: [number, number, number];
+    scale: [number, number, number];
+    side?: "back" | "front" | undefined;
+    children: string[];
     wallId?: string | undefined;
     wallT?: number | undefined;
     roofSegmentId?: string | undefined;
-    roofFace?: "left" | "right" | "front" | "back" | undefined;
+    roofFace?: "back" | "front" | "left" | "right" | undefined;
     blockFaceId?: string | undefined;
     supportSlabId?: string | undefined;
     collectionIds?: `collection_${string}`[] | undefined;
     slots?: Record<string, string> | undefined;
     source?: {
         kind: "script";
-        language: "three" | "bpy";
+        meta?: {
+            description?: string | undefined;
+            category?: string | undefined;
+            tags?: string[] | undefined;
+            parent?: string | undefined;
+        } | undefined;
+        language: "bpy" | "three";
         script: string;
         params: Record<string, string | number | boolean>;
         artifact: string;
@@ -155,9 +108,9 @@ export declare function authoredItem(id: string, parentId: string, fields: {
             };
             params: {
                 id: string;
-                kind: "string" | "number" | "boolean";
-                default: string | number | boolean;
                 label?: string | undefined;
+                kind: "boolean" | "number" | "string";
+                default: string | number | boolean;
                 min?: number | undefined;
                 max?: number | undefined;
                 step?: number | undefined;
@@ -174,9 +127,9 @@ export declare function authoredItem(id: string, parentId: string, fields: {
                 } | undefined;
             }[];
             surfaces: {
+                part?: string | undefined;
                 y: number;
                 polygon: [number, number][];
-                part?: string | undefined;
             }[];
             slots: {
                 id: string;
@@ -200,36 +153,95 @@ export declare function authoredItem(id: string, parentId: string, fields: {
                 distance?: number | undefined;
             }[];
             undersides: {
+                part?: string | undefined;
                 polygon: [number, number][];
                 plane: [number, number, number, number];
-                part?: string | undefined;
             }[];
             animations: {
                 name: string;
                 duration: number;
             }[];
-            cutout: boolean;
-            collider: boolean;
-            triangles: number;
             cutters?: {
-                host: "wall" | "slab" | "ceiling" | "mounted";
+                host: "ceiling" | "mounted" | "slab" | "wall";
                 polygon: number[][];
                 minY: number;
                 maxY: number;
             }[] | undefined;
+            cutout: boolean;
+            collider: boolean;
+            triangles: number;
+            coverage?: number | undefined;
+            uncovered?: {
+                min: [number, number];
+                max: [number, number];
+            }[] | undefined;
         };
-        meta?: {
-            description?: string | undefined;
-            category?: string | undefined;
-            tags?: string[] | undefined;
-            parent?: string | undefined;
-        } | undefined;
         images?: {
             artifact: string;
             thumbnail: string;
             floorPlan: string;
         } | undefined;
     } | undefined;
+    asset: {
+        id: string;
+        category: string;
+        name: string;
+        thumbnail: string;
+        floorPlanUrl?: string | undefined;
+        source: "community" | "library" | "mine";
+        isDraft?: boolean | undefined;
+        src: string;
+        dimensions: [number, number, number];
+        attachTo?: "ceiling" | "wall" | "wall-side" | undefined;
+        recessed?: boolean | undefined;
+        tags?: string[] | undefined;
+        functionTags?: string[] | undefined;
+        offset: [number, number, number];
+        rotation: [number, number, number];
+        scale: [number, number, number];
+        surface?: {
+            height: number;
+        } | undefined;
+        interactive?: {
+            controls: ({
+                kind: "toggle";
+                label?: string | undefined;
+                default?: boolean | undefined;
+            } | {
+                kind: "slider";
+                label: string;
+                min: number;
+                max: number;
+                step: number;
+                unit?: string | undefined;
+                displayMode: "dial" | "slider" | "stepper";
+                default?: number | undefined;
+            } | {
+                kind: "temperature";
+                label: string;
+                min: number;
+                max: number;
+                unit: "C" | "F";
+                default?: number | undefined;
+            })[];
+            effects: ({
+                kind: "animation";
+                mode?: "ambient" | "open-close" | undefined;
+                control?: number | undefined;
+                clips: {
+                    on?: string | undefined;
+                    off?: string | undefined;
+                    loop?: string | undefined;
+                };
+            } | {
+                kind: "light";
+                color: string;
+                intensityRange: [number, number];
+                distance?: number | undefined;
+                offset: [number, number, number];
+            })[];
+        } | undefined;
+    };
 };
 export declare const ADD_OBJECT_CASES: AddObjectCase[];
 //# sourceMappingURL=add-object-cases.d.ts.map

package/dist/agent-operations/__fixtures__/add-object-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-object-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/add-object-cases.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,sBAAsB,EAE3B,KAAK,mBAAmB,EAIzB,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,UAAU,CAAA;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE,sBAAsB,CAAA;IAChC,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;IAC3C,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;IACzB,MAAM,EACF;QACE,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,mEAAmE;QACnE,aAAa,CAAC,EAAE,IAAI,CAAA;KACrB,GACD;QACE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,8EAA8E;QAC9E,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,oCAAoC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KACpB,CAAA;CACN,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAChD,KAAK,GAAE,mBAA6B,EACpC,SAAS,SAAK,GACb,sBAAsB,CAYxB;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB5F;AAgDD,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAgH3C,CAAA"}
+{"version":3,"file":"add-object-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/add-object-cases.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,sBAAsB,EAE3B,KAAK,mBAAmB,EAKzB,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,UAAU,CAAA;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE,sBAAsB,CAAA;IAChC,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;IAC3C,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;IACzB,MAAM,EACF;QACE,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,mEAAmE;QACnE,aAAa,CAAC,EAAE,IAAI,CAAA;KACrB,GACD;QACE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,8EAA8E;QAC9E,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,oCAAoC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KACpB,CAAA;CACN,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAChD,KAAK,GAAE,mBAA6B,EACpC,SAAS,SAAK,GACb,sBAAsB,CAYxB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,GAAG,MAAM,EACrB,KAAK,GAAE,mBAA6B,GACnC,sBAAsB,CASxB;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB5F;AA6GD,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAyW3C,CAAA"}

package/dist/agent-operations/__fixtures__/add-object-cases.js

@@ -1,6 +1,6 @@
 import { artifactUrl } from '../../lib/artifact-store.js';
 import { scriptSource } from '../../lib/geometry-script-node.js';
-import { BuildingNode, GeometryArtifactManifest, ItemNode, LevelNode, WallNode, } from '../../schema/index.js';
+import { BuildingNode, GeometryArtifactManifest, ItemNode, LevelNode, SlabNode, WallNode, } from '../../schema/index.js';
 /**
  * A compile of a solid of this size, bottom-centre at the origin, as the compiler reports it: a
  * plain box (12 triangles) unless it has more detail.
@@ -18,6 +18,21 @@ export function compiledSolid([width, height, depth], mount = 'floor', triangles
         }),
     };
 }
+/**
+ * What a compile that could not measure the object leaves in the manifest: a mesh at a position
+ * that is not a number made every bound NaN. A structured clone (the chat's worker) keeps NaN; a
+ * JSON hop (a tab job answering the server) turns it to null.
+ */
+export function compiledUnmeasured(hop, mount = 'floor') {
+    const solid = compiledSolid([1.2, 2.8, 0.6], mount);
+    const nan = [Number.NaN, Number.NaN, Number.NaN];
+    const compiled = {
+        ...solid,
+        params: { width: 7.7, display: true },
+        manifest: { ...solid.manifest, bounds: { min: nan, max: nan } },
+    };
+    return hop === 'json' ? JSON.parse(JSON.stringify(compiled)) : compiled;
+}
 /** An object add_object built earlier, with the reason it was given. */
 export function authoredItem(id, parentId, fields) {
     const compiled = compiledSolid(fields.size);
@@ -66,6 +81,60 @@ function floorScene() {
         rootNodeIds: [building.id],
     };
 }
+/** The floor with its declared roof level over it, the level a roof just placed brings into view. */
+function roofedFloorScene() {
+    const { nodes, rootNodeIds } = floorScene();
+    const roofLevel = LevelNode.parse({
+        id: 'level_roof',
+        parentId: 'building_main',
+        level: 1,
+        height: 2,
+        metadata: { role: 'roof' },
+    });
+    const building = nodes.building_main;
+    return {
+        nodes: {
+            ...nodes,
+            [building.id]: { ...building, children: [...building.children, roofLevel.id] },
+            [roofLevel.id]: roofLevel,
+        },
+        rootNodeIds,
+    };
+}
+/**
+ * The floor with a slab of a level beside its walls, as the host stores a room's floor plate: a
+ * child of the level, its outline in the level's x and z.
+ */
+function floorWithSlab(polygon, { holes = [], levelId = 'level_0' } = {}) {
+    return () => {
+        const { nodes, rootNodeIds } = levelId === 'level_0' ? floorScene() : roofedFloorScene();
+        const slab = SlabNode.parse({
+            id: 'slab_living',
+            parentId: levelId,
+            polygon,
+            holes,
+            boundary: 'auto',
+        });
+        const level = nodes[levelId];
+        return {
+            nodes: {
+                ...nodes,
+                [level.id]: { ...level, children: [...level.children, slab.id] },
+                [slab.id]: slab,
+            },
+            rootNodeIds,
+        };
+    };
+}
+/** A living room's floor: 6 m along x, 5 m along z. */
+const LIVING_ROOM = [
+    [0, 0],
+    [6, 0],
+    [6, 5],
+    [0, 5],
+];
+/** The owner's rug (2026-10-19, "add a living room"): 2.40 × 3.18 m and 0.02 m thick. */
+const RUG = [2.4, 0.02, 3.18];
 const CODE = 'export default function build({ THREE }) { return new THREE.Group() }';
 const create = (name, input, size, expect, mount = 'floor', triangles) => ({
     name,
@@ -75,6 +144,29 @@ const create = (name, input, size, expect, mount = 'floor', triangles) => ({
     expect,
 });
 export const ADD_OBJECT_CASES = [
+    // A roof just placed selects its level: an object given no host then landed among the roofs, the
+    // storey's plan short of it. Refused, naming the storey it covers so one retry lands.
+    {
+        name: 'an object given no host while the roof level is in view is refused, naming the storey it covers',
+        scene: roofedFloorScene,
+        input: { code: CODE, name: 'Side table', reason: 'Pascal has no side table.' },
+        compiled: compiledSolid([0.5, 0.6, 0.5]),
+        context: { activeLevelId: 'level_roof' },
+        expect: { refusal: 'roof_level', mentions: ['"Side table"', 'level_0'] },
+    },
+    // Named onto the roof level, it goes up with the roof.
+    {
+        name: 'an object named onto the roof level is made there: it goes up with the roof',
+        scene: roofedFloorScene,
+        input: {
+            code: CODE,
+            name: 'Chimney cap',
+            reason: 'Pascal has no chimney cap.',
+            parentId: 'level_roof',
+        },
+        compiled: compiledSolid([0.6, 0.4, 0.6]),
+        expect: { result: { mount: 'floor' }, node: { parentId: 'level_roof' } },
+    },
     create('a new object keeps what it stands in for', {
         name: 'Cornice',
         category: 'trim',
@@ -92,6 +184,46 @@ export const ADD_OBJECT_CASES = [
     // Live over the MCP (2026-10-05): the script ran and its artifacts were stored before the missing
     // reason was refused.
     create('a new object without a reason is refused before its script runs', { name: 'Planter', reason: undefined }, [1.2, 0.5, 0.4], { refusal: 'reason_required', mentions: ['reason'], beforeCompile: true }),
+    // An agent's cabinet script put a material where a position goes, with one param on: the compile
+    // answered with NaN bounds and the item schema threw its raw validation array at the model.
+    {
+        name: 'an object whose bounds are not numbers is refused before its asset is built',
+        scene: floorScene,
+        input: {
+            code: CODE,
+            name: 'Library wall',
+            category: 'cabinet',
+            reason: 'Pascal has no library wall.',
+            params: { width: 7.7, display: true },
+        },
+        compiled: compiledUnmeasured('clone'),
+        expect: {
+            refusal: 'unmeasurable_object',
+            mentions: ['"Library wall" cannot be measured', '"display":true', 'nothing was added'],
+        },
+    },
+    {
+        name: 'bounds that crossed a JSON hop as null are refused the same way',
+        scene: floorScene,
+        input: {
+            code: CODE,
+            name: 'Library wall',
+            category: 'cabinet',
+            reason: 'Pascal has no library wall.',
+        },
+        compiled: compiledUnmeasured('json'),
+        expect: { refusal: 'unmeasurable_object', mentions: ['"Library wall" cannot be measured'] },
+    },
+    {
+        name: 'an edit whose rebuild cannot be measured is refused and leaves the object as it was',
+        scene: floorScene,
+        input: { nodeId: 'item_screen', code: CODE, params: { display: true } },
+        compiled: compiledUnmeasured('clone'),
+        expect: {
+            refusal: 'unmeasurable_object',
+            mentions: ['item_screen cannot be measured', 'nothing was changed'],
+        },
+    },
     // Production saw whole houses of plain custom solids, nothing editable as walls or rooms.
     create('a plain box with a wall’s size is refused: walls exist', { name: 'Panel', category: 'panel' }, [4, 2.7, 0.2], { refusal: 'use_walls', mentions: ['add_wall'] }),
     // A bookcase and a breeze-block screen (about 1.4 m wide and the tall box's height)
@@ -100,8 +232,176 @@ export const ADD_OBJECT_CASES = [
     create('a bookcase is built: furniture may have a wall’s box', { name: 'Bookcase', category: 'furniture' }, [1.2, 2.1, 0.35], { result: { mount: 'floor' }, node: { name: 'Bookcase' } }, 'floor', 96),
     create('a floor plate is refused, measured as drawn in x and z: slabs exist', { name: 'Terrace', category: 'deck' }, [8.05, 0.15, 13.52], { refusal: 'use_slab', mentions: ['slab', '8.05 × 13.52'] }),
     create('a turned floor plate is measured as it stands', { name: 'Terrace', category: 'deck', rotation: 90 }, [8.05, 0.15, 13.52], { refusal: 'use_slab', mentions: ['13.52 × 8.05'] }),
+    // A flat object is refused only where it would serve as a floor: with no floor under it. The
+    // owner's rug was refused twice on a living room's floor and the agent painted one instead.
+    {
+        name: 'a rug lying over a room’s floor is furniture and is built',
+        scene: floorWithSlab(LIVING_ROOM),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [3, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { result: { mount: 'floor' }, node: { name: 'Fringed wool rug', parentId: 'level_0' } },
+    },
+    {
+        name: 'a rug hanging over a floor’s edge, most of it on the floor, is built',
+        scene: floorWithSlab(LIVING_ROOM),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [0.5, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { result: { mount: 'floor' }, node: { name: 'Fringed wool rug' } },
+    },
+    {
+        name: 'the same plate on a level with no floor stays refused, with its fact',
+        scene: floorScene,
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [3, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: {
+            refusal: 'use_slab',
+            mentions: [
+                '2.40 × 3.18 m in x and z, 0.02 m thick, on the floor) is a floor plate: build it as a slab.',
+            ],
+        },
+    },
+    {
+        name: 'the same plate where the level’s floor is not stays refused: bare ground beside a floor',
+        scene: floorWithSlab(LIVING_ROOM),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [12, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { refusal: 'use_slab', mentions: ['is a floor plate: build it as a slab.'] },
+    },
+    {
+        name: 'a plate mostly past the floor’s edge is a floor, not a rug: refused',
+        scene: floorWithSlab(LIVING_ROOM),
+        input: {
+            code: CODE,
+            name: 'Terrace',
+            category: 'deck',
+            reason: 'Pascal has no deck type.',
+            position: [-0.9, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { refusal: 'use_slab', mentions: ['is a floor plate: build it as a slab.'] },
+    },
+    {
+        name: 'a plate over the opening cut in a floor has no floor under it: refused',
+        scene: floorWithSlab(LIVING_ROOM, {
+            holes: [
+                [
+                    [1, 0.5],
+                    [5, 0.5],
+                    [5, 4.5],
+                    [1, 4.5],
+                ],
+            ],
+        }),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [3, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { refusal: 'use_slab', mentions: ['is a floor plate: build it as a slab.'] },
+    },
+    {
+        name: 'a floor on another level is no floor under the plate: refused',
+        scene: floorWithSlab(LIVING_ROOM, { levelId: 'level_roof' }),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [3, 0, 2.5],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { refusal: 'use_slab', mentions: ['is a floor plate: build it as a slab.'] },
+    },
+    // The floor is read where the plate stands, turned as it is: a strip of floor 1.4 m deep holds
+    // 44% of the rug along z and 58% of the rug turned a quarter.
+    {
+        name: 'a rug short of the floor strip it lies along is refused, built once turned to lie along it',
+        scene: floorWithSlab([
+            [0, 0],
+            [8, 0],
+            [8, 1.4],
+            [0, 1.4],
+        ]),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [4, 0, 0.7],
+        },
+        compiled: compiledSolid(RUG),
+        expect: { refusal: 'use_slab', mentions: ['is a floor plate: build it as a slab.'] },
+    },
+    {
+        name: 'the same rug turned a quarter, 58% on the strip, is built',
+        scene: floorWithSlab([
+            [0, 0],
+            [8, 0],
+            [8, 1.4],
+            [0, 1.4],
+        ]),
+        input: {
+            code: CODE,
+            name: 'Fringed wool rug',
+            category: 'rug',
+            reason: 'Pascal has no rug type.',
+            position: [4, 0, 0.7],
+            rotation: 90,
+        },
+        compiled: compiledSolid(RUG),
+        expect: { result: { mount: 'floor' }, node: { name: 'Fringed wool rug' } },
+    },
     create('a plate held off the floor is built: a canopy is no slab', { name: 'Canopy', category: 'canopy', position: [3, 2.6, 1] }, [4, 0.2, 3], { result: { mount: 'floor' }, node: { name: 'Canopy' } }),
     create('a wall-side object shaped like a wall is built: it dresses the wall', { name: 'Wainscot', category: 'panel', parentId: 'wall_south', position: [3, 0, 0] }, [4, 2.6, 0.05], { result: { mount: 'wall-side' }, node: { parentId: 'wall_south' } }, 'wall-side'),
+    create('a back-side wall mount defaults to facing away from its wall', { parentId: 'wall_south', side: 'back' }, [1, 1, 0.04], { result: { mount: 'wall-side' }, node: { side: 'back', rotation: [0, Math.PI, 0] } }, 'wall-side'),
+    create('a front-side wall mount defaults to facing away from its wall', { parentId: 'wall_south', side: 'front' }, [1, 1, 0.04], { result: { mount: 'wall-side' }, node: { side: 'front', rotation: [0, 0, 0] } }, 'wall-side'),
+    create('an explicit back-side wall mount rotation remains explicit', { parentId: 'wall_south', side: 'back', rotation: 0 }, [1, 1, 0.04], { result: { mount: 'wall-side' }, node: { side: 'back', rotation: [0, 0, 0] } }, 'wall-side'),
+    {
+        name: 'rebuilding a saved back-side wall object preserves its rotation',
+        scene: () => {
+            const scene = floorScene();
+            const previous = ItemNode.parse(scene.nodes.item_screen);
+            scene.nodes.item_screen = ItemNode.parse({
+                ...previous, parentId: 'wall_south', wallId: 'wall_south', side: 'back',
+                asset: { ...previous.asset, attachTo: 'wall-side' },
+            });
+            const wall = WallNode.parse(scene.nodes.wall_south);
+            scene.nodes.wall_south = { ...wall, children: [previous.id] };
+            const level = LevelNode.parse(scene.nodes.level_0);
+            scene.nodes.level_0 = { ...level, children: [wall.id] };
+            return scene;
+        },
+        input: { nodeId: 'item_screen', code: CODE },
+        compiled: compiledSolid([1, 1, 0.04], 'wall-side'),
+        expect: { result: { nodeId: 'item_screen' }, node: { rotation: [0, 0, 0], side: 'back' } },
+    },
     create('a name naming a Pascal type is built, with a hint naming the tool for it', { name: 'Spiral staircase', category: 'stair' }, [1.6, 2.8, 1.6], { result: { mount: 'floor' }, mentions: ['is something Pascal builds: create_stair'] }),
     create('a type word that only qualifies the name is built', { name: 'entry door pull handle (brass)', category: 'hardware', position: [1, 0.9, 1] }, [0.04, 0.6, 0.06], { result: { mount: 'floor' }, node: { name: 'entry door pull handle (brass)' } }),
     // The editor's inspector and resize handles rebuild an object through the same operation: a

package/dist/agent-operations/__fixtures__/add-stair-cases.d.ts

@@ -0,0 +1,3 @@
+import type { AgentToolCase } from './cases.js';
+export declare const ADD_STAIR_CASES: AgentToolCase[];
+//# sourceMappingURL=add-stair-cases.d.ts.map

package/dist/agent-operations/__fixtures__/add-stair-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-stair-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/add-stair-cases.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAmJ5C,eAAO,MAAM,eAAe,EAAE,aAAa,EAyK1C,CAAA"}