@pascal-app/core 0.9.2 → 1.0.0-beta.1

package/dist/schema/nodes/level.js

@@ -1,45 +1,24 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
-import { CeilingNode } from './ceiling';
-import { ColumnNode } from './column';
-import { FenceNode } from './fence';
-import { GuideNode } from './guide';
-import { ItemNode } from './item';
-import { MeasurementNode } from './measurement';
-import { RoofNode } from './roof';
-import { ScanNode } from './scan';
-import { ShelfNode } from './shelf';
-import { SlabNode } from './slab';
-import { SpawnNode } from './spawn';
-import { StairNode } from './stair';
-import { WallNode } from './wall';
-import { ZoneNode } from './zone';
+const LevelChildId = z.string().transform((id) => id);
 export const LevelNode = BaseNode.extend({
     id: objectId('level'),
     type: nodeType('level'),
-    children: z
-        .array(z.union([
-        WallNode.shape.id,
-        FenceNode.shape.id,
-        ColumnNode.shape.id,
-        ItemNode.shape.id,
-        ZoneNode.shape.id,
-        SlabNode.shape.id,
-        CeilingNode.shape.id,
-        RoofNode.shape.id,
-        StairNode.shape.id,
-        ScanNode.shape.id,
-        GuideNode.shape.id,
-        MeasurementNode.shape.id,
-        SpawnNode.shape.id,
-        ShelfNode.shape.id,
-    ]))
-        .default([]),
+    // The node registry owns child-kind validity. Persisted level relationships
+    // must also admit IDs minted by plugins that core cannot enumerate.
+    children: z.array(LevelChildId).default([]),
     // Specific props
     level: z.number().default(0),
+    /**
+     * Stored storey height in meters (floor-to-floor). No zod default on
+     * purpose: absence marks unmigrated legacy data and gates the load-time
+     * migration; a schema default would materialize silently through .parse().
+     */
+    height: z.number().optional(),
 }).describe(dedent `
   Level node - used to represent a level in the building
-  - children: array of floor, wall, ceiling, roof, item nodes
+  - children: array of architectural, equipment, and MEP distribution nodes
   - level: level number
+  - height: storey height in meters (floor-to-floor); absent only on unmigrated legacy data
   `);

package/dist/schema/nodes/shelf.d.ts

@@ -47,6 +47,7 @@ export declare const ShelfNode: z.ZodObject<{
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/shelf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/shelf.js

@@ -42,6 +42,8 @@ export const ShelfNode = BaseNode.extend({
     children: z.array(ItemNode.shape.id).default([]),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     // Dimensions (meters). Schema-level defaults intentionally reproduce
     // the v1 wall-shelf so existing v1 scenes that omit the v2-introduced
     // fields (style / rows / columns / with*) load with their original

package/dist/schema/nodes/site.d.ts

@@ -21,6 +21,15 @@ export declare const SiteNode: z.ZodObject<{
         type: z.ZodLiteral<"polygon">;
         points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     }, z.core.$strip>>>;
+    terrain: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"heightfield">;
+        origin: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        spacing: z.ZodNumber;
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+        step: z.ZodNumber;
+        heights: z.ZodString;
+    }, z.core.$strip>>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type SiteNode = z.infer<typeof SiteNode>;

package/dist/schema/nodes/site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;iBAsBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/site.js

@@ -2,16 +2,12 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
+import { TerrainData } from '../terrain';
 // 2D Polygon
 const PropertyLineData = z.object({
     type: z.literal('polygon'),
     points: z.array(z.tuple([z.number(), z.number()])),
 });
-// 3D Polygon/Mesh
-// const TerrainData = z.object({
-//   type: z.literal('terrain'),
-//   points: z.array(z.tuple([z.number(), z.number(), z.number()])),
-// })
 export const SiteNode = BaseNode.extend({
     id: objectId('site'),
     type: nodeType('site'),
@@ -26,10 +22,16 @@ export const SiteNode = BaseNode.extend({
             [-15, 15],
         ],
     }),
-    // terrain: TerrainData,
+    /**
+     * Sculpted ground. Absent means flat ground at the datum — the state every
+     * scene that predates terrain is in, and the state an untouched site stays in
+     * so ~11 KB of base64 zeroes does not land in every saved scene.
+     */
+    terrain: TerrainData.optional(),
     children: z.array(z.string()).default([]),
 }).describe(dedent `
   Site node - used to represent a site
   - polygon: polygon data
+  - terrain: optional sculpted heightfield; absent means flat ground
   - children: array of child node ids (buildings, items)
   `);

package/dist/schema/nodes/slab.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const MIN_SLAB_THICKNESS = 0.02;
 export declare const SlabNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -63,6 +64,10 @@ export declare const SlabNode: z.ZodObject<{
         elevatorId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    recessed: z.ZodDefault<z.ZodBoolean>;
+    recessedRimElevation: z.ZodOptional<z.ZodNumber>;
+    fillToTerrain: z.ZodOptional<z.ZodBoolean>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SlabNode = z.infer<typeof SlabNode>;

package/dist/schema/nodes/slab.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/slab.js

@@ -3,6 +3,10 @@ import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
 import { SurfaceHoleMetadata } from './surface-hole-metadata';
+// Edit-time floor for `thickness` — a thinner slab z-fights the ceiling's
+// −0.01 underside offset. Applies to edits only; migration writes legacy
+// intervals verbatim (including degenerate zero-thickness slabs).
+export const MIN_SLAB_THICKNESS = 0.02;
 export const SlabNode = BaseNode.extend({
     id: objectId('slab'),
     type: nodeType('slab'),
@@ -15,13 +19,21 @@ export const SlabNode = BaseNode.extend({
     polygon: z.array(z.tuple([z.number(), z.number()])),
     holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     holeMetadata: z.array(SurfaceHoleMetadata).default([]),
-    elevation: z.number().default(0.05), // Elevation in meters
+    elevation: z.number().default(0.05), // Walking surface (slab top), meters above the level plane
+    thickness: z.number().default(0.05), // Grows downward from the surface
+    recessed: z.boolean().default(false),
+    recessedRimElevation: z.number().finite().optional(),
+    fillToTerrain: z.boolean().optional(),
     autoFromWalls: z.boolean().default(false),
 }).describe(dedent `
   Slab node - used to represent a slab/floor in the building
   - polygon: array of [x, z] points defining the slab boundary
   - holes: array of [x, z] polygons representing cutouts in the slab
   - holeMetadata: metadata parallel to holes, used to preserve manual and auto-managed cutouts
-  - elevation: elevation in meters
+  - elevation: the walking surface (slab top), in meters above the level plane
+  - thickness: grows downward from the surface; the solid occupies [elevation - thickness, elevation]
+  - recessed: open recess (pool) whose floor sits at elevation
+  - recessedRimElevation: optional rim anchor for a raised/lowered recess; absent means the level plane
+  - fillToTerrain: extends a solid slab's perimeter downward to terrain without changing its flat top or authored thickness
   - autoFromWalls: whether the slab is automatically generated from a closed wall loop
   `);

package/dist/schema/nodes/spawn.d.ts

@@ -19,6 +19,7 @@ export declare const SpawnNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"spawn">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SpawnNode = z.infer<typeof SpawnNode>;
 //# sourceMappingURL=spawn.d.ts.map

package/dist/schema/nodes/spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;iBAOpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/spawn.js

@@ -5,4 +5,6 @@ export const SpawnNode = BaseNode.extend({
     type: nodeType('spawn'),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.number().default(0),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
 });

package/dist/schema/nodes/stair.d.ts

@@ -181,6 +181,7 @@ export declare const StairNode: z.ZodObject<{
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     stairType: z.ZodDefault<z.ZodEnum<{
         straight: "straight";
         spiral: "spiral";
@@ -188,13 +189,14 @@ export declare const StairNode: z.ZodObject<{
     }>>;
     fromLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     toLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    deckSlabId: z.ZodOptional<z.ZodString>;
     slabOpeningMode: z.ZodDefault<z.ZodEnum<{
         none: "none";
         destination: "destination";
     }>>;
     openingOffset: z.ZodDefault<z.ZodNumber>;
     width: z.ZodDefault<z.ZodNumber>;
-    totalRise: z.ZodDefault<z.ZodNumber>;
+    totalRise: z.ZodOptional<z.ZodNumber>;
     stepCount: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;

package/dist/schema/nodes/stair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIvE,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AACjE,eAAO,MAAM,oBAAoB;;;EAAkC,CAAA;AAEnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AACjD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AACnE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AASjD,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,wBAAwB,GAC7B,wBAAwB,CAmE1B"}
+{"version":3,"file":"stair.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIvE,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AACjE,eAAO,MAAM,oBAAoB;;;EAAkC,CAAA;AAEnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AACjD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AACnE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsErB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AASjD,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,wBAAwB,GAC7B,wBAAwB,CAmE1B"}

package/dist/schema/nodes/stair.js

@@ -24,13 +24,19 @@ export const StairNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     stairType: StairType.default('straight'),
     fromLevelId: z.string().nullable().default(null),
     toLevelId: z.string().nullable().default(null),
+    // Destination deck (a slab id). When set, the stair's rise follows that
+    // slab's elevation live. An explicit `totalRise` still wins when BOTH are
+    // set (edge case — the panel clears the custom rise when attaching).
+    deckSlabId: z.string().optional(),
     slabOpeningMode: StairSlabOpeningMode.default('none'),
     openingOffset: z.number().default(0),
     width: z.number().default(1.0),
-    totalRise: z.number().default(2.5),
+    totalRise: z.number().optional(),
     stepCount: z.number().default(10),
     thickness: z.number().default(0.25),
     fillToFloor: z.boolean().default(true),
@@ -52,6 +58,7 @@ export const StairNode = BaseNode.extend({
   - rotation: rotation around Y axis
   - stairType: straight (segment-based), curved (arc-based), or spiral
   - fromLevelId / toLevelId: source and destination levels used for auto slab cutouts
+  - deckSlabId: destination deck (slab) — the rise derives from its elevation while set
   - slabOpeningMode: whether a destination-level slab opening is generated for this stair
   - openingOffset: extra opening expansion applied after the cutout polygon is computed
   - width: stair width

package/dist/schema/nodes/structural-grid.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const StructuralGridNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`structural-grid_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"structural-grid">>;
+    start: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    end: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    label: z.ZodDefault<z.ZodString>;
+    showStartBubble: z.ZodDefault<z.ZodBoolean>;
+    showEndBubble: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type StructuralGridNode = z.infer<typeof StructuralGridNode>;
+//# sourceMappingURL=structural-grid.d.ts.map

package/dist/schema/nodes/structural-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-grid.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/structural-grid.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;iBAe9B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schema/nodes/structural-grid.js

@@ -0,0 +1,17 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const StructuralGridNode = BaseNode.extend({
+    id: objectId('structural-grid'),
+    type: nodeType('structural-grid'),
+    start: z.tuple([z.number(), z.number()]).default([0, 0]),
+    end: z.tuple([z.number(), z.number()]).default([0, 5]),
+    label: z.string().trim().min(1).max(12).default('1'),
+    showStartBubble: z.boolean().default(true),
+    showEndBubble: z.boolean().default(true),
+}).describe(dedent `
+  Structural grid node - a persistent floor-plan datum axis with identification bubbles
+  - start/end: level-local plan coordinates defining the grid axis extent
+  - label: axis identifier, commonly numeric in one direction and alphabetic in the other
+  - showStartBubble/showEndBubble: independently control the two endpoint identifiers
+  `);

package/dist/schema/nodes/wall.d.ts

@@ -245,6 +245,9 @@ export declare const WallNode: z.ZodObject<{
     thickness: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     curveOffset: z.ZodOptional<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
+    supportOffset: z.ZodOptional<z.ZodNumber>;
+    fillToTerrain: z.ZodOptional<z.ZodBoolean>;
     faceBands: z.ZodOptional<z.ZodPreprocess<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         count: z.ZodDefault<z.ZodNumber>;
@@ -360,7 +363,7 @@ export type WallSurfaceSide = 'interior' | 'exterior';
 export type WallFaceBand = 'lower' | 'middle' | 'upper' | 'top';
 export type WallBandSurfaceSlotId = 'lowerInterior' | 'middleInterior' | 'upperInterior' | 'topInterior' | 'lowerExterior' | 'middleExterior' | 'upperExterior' | 'topExterior';
 export declare const WALL_SLOT_DEFAULT: Record<WallSurfaceSide, string>;
-export declare function getWallFaceBandConfig(wall: Pick<WallNode, 'height' | 'faceBands'>): {
+export declare function getWallFaceBandConfig(wall: Pick<WallNode, 'height' | 'faceBands'>, effectiveWallHeight: number): {
     enabled: boolean;
     count: number;
     lowerHeight: number;
@@ -370,7 +373,7 @@ export declare function getWallFaceBandConfig(wall: Pick<WallNode, 'height' | 'f
     middleTop: number;
     upperTop: number;
 };
-export declare function getWallFaceBandForHeight(wall: Pick<WallNode, 'height' | 'faceBands'>, y: number): WallFaceBand;
+export declare function getWallFaceBandForHeight(wall: Pick<WallNode, 'height' | 'faceBands'>, y: number, effectiveWallHeight: number): WallFaceBand;
 export declare function getWallBandSlotId(side: WallSurfaceSide, band: WallFaceBand): WallBandSurfaceSlotId;
 export declare function buildWallFaceBandCountPatch(wall: Pick<WallNode, 'faceBands' | 'slots'>, count: number): Pick<WallNode, 'faceBands' | 'slots'>;
 export declare function buildEnabledWallFaceBandPatch(wall: Pick<WallNode, 'faceBands' | 'slots'>): Pick<WallNode, 'faceBands' | 'slots'>;

package/dist/schema/nodes/wall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAK5C,eAAO,MAAM,iBAAiB;;;;EAA2C,CAAA;AACzE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAkB1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,qBAAqB,EAAE,cAMnC,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,cAMhC,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,cAOrC,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;CAIrB,CAAA;AAUV,eAAO,MAAM,kBAAkB;;;;;;kBAMJ,CAAA;AAC3B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,sBAAsB,EAAE,kBAMpC,CAAA;AAED,eAAO,MAAM,0BAA0B,6BAA6B,CAAA;AACpE,eAAO,MAAM,uBAAuB,yBAAyB,CAAA;AAC7D,eAAO,MAAM,4BAA4B,yBAAyB,CAAA;AAClE,eAAO,MAAM,kCAAkC;;;;;CAKE,CAAA;AAEjD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;CAiB7B,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,0BAA0B,CAAA;AAEvE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,UAAU,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;AAC/D,MAAM,MAAM,qBAAqB,GAC7B,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,aAAa,CAAA;AAOjB,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAG7D,CAAA;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC5C,mBAAmB,EAAE,MAAM;;;;;;;;;EAqB5B;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC5C,CAAC,EAAE,MAAM,EACT,mBAAmB,EAAE,MAAM,GAC1B,YAAY,CAQd;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,YAAY,GACjB,qBAAqB,CAGvB;AAsCD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,EAC3C,KAAK,EAAE,MAAM,GACZ,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,CA8CvC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,GAC1C,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,CAEvC;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAmBrF;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACzC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACzC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACjD,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACjD,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAChC,CAAA;AAuBD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,eAAe,GACpB,uBAAuB,CAUzB;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAKrF"}

package/dist/schema/nodes/wall.js

@@ -132,6 +132,14 @@ export const WallNode = BaseNode.extend({
     thickness: z.number().optional(),
     height: z.number().optional(),
     curveOffset: z.number().optional(),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
+    // Vertical offset from the elected support surface. Ground-hosted chained
+    // walls use this to preserve one construction plane without copying terrain.
+    supportOffset: z.number().finite().optional(),
+    // Extend downward from the authored wall base to the terrain while keeping
+    // the wall body height and top unchanged.
+    fillToTerrain: z.boolean().optional(),
     faceBands: WallFaceBandConfig.optional(),
     skirting: WallTrimConfig.optional(),
     crown: WallTrimConfig.optional(),
@@ -146,6 +154,7 @@ export const WallNode = BaseNode.extend({
   Wall node - used to represent a wall in the building
   - thickness: thickness in meters
   - height: height in meters
+  - fillToTerrain: extends the wall downward to the terrain without changing its authored height
   - curveOffset: midpoint sagitta offset used to bend the wall into an arc
   - start: start point of the wall in level coordinate system
   - end: end point of the wall in level coordinate system
@@ -162,8 +171,8 @@ export const WALL_SLOT_DEFAULT = {
     interior: WALL_SURFACE_SLOT_DEFAULTS.interior,
     exterior: WALL_SURFACE_SLOT_DEFAULTS.exterior,
 };
-export function getWallFaceBandConfig(wall) {
-    const wallHeight = wall.height ?? 2.5;
+export function getWallFaceBandConfig(wall, effectiveWallHeight) {
+    const wallHeight = Math.max(0, effectiveWallHeight);
     const raw = { ...WALL_FACE_BAND_DEFAULT, ...(wall.faceBands ?? {}) };
     const count = raw.enabled ? Math.max(1, Math.min(4, Math.round(raw.count ?? 3))) : 1;
     const lowerHeight = count >= 2 ? Math.max(0, Math.min(wallHeight, raw.lowerHeight)) : 0;
@@ -180,8 +189,8 @@ export function getWallFaceBandConfig(wall) {
         upperTop: lowerHeight + middleHeight + upperHeight,
     };
 }
-export function getWallFaceBandForHeight(wall, y) {
-    const bands = getWallFaceBandConfig(wall);
+export function getWallFaceBandForHeight(wall, y, effectiveWallHeight) {
+    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
     if (!bands.enabled)
         return 'upper';
     if (y < bands.lowerTop)

package/dist/schema/nodes/window.d.ts

@@ -12,6 +12,18 @@ export declare const WindowType: z.ZodEnum<{
     louvered: "louvered";
 }>;
 export type WindowType = z.infer<typeof WindowType>;
+export declare const WindowConstructionType: z.ZodEnum<{
+    framed: "framed";
+    masonry: "masonry";
+}>;
+export declare const WindowDimensionReference: z.ZodEnum<{
+    nominal: "nominal";
+    "rough-opening": "rough-opening";
+    "masonry-opening": "masonry-opening";
+    "finish-opening": "finish-opening";
+}>;
+export type WindowConstructionType = z.infer<typeof WindowConstructionType>;
+export type WindowDimensionReference = z.infer<typeof WindowDimensionReference>;
 export declare const WindowNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -79,6 +91,23 @@ export declare const WindowNode: z.ZodObject<{
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    mark: z.ZodOptional<z.ZodString>;
+    constructionType: z.ZodDefault<z.ZodEnum<{
+        framed: "framed";
+        masonry: "masonry";
+    }>>;
+    dimensionReference: z.ZodDefault<z.ZodEnum<{
+        nominal: "nominal";
+        "rough-opening": "rough-opening";
+        "masonry-opening": "masonry-opening";
+        "finish-opening": "finish-opening";
+    }>>;
+    roughOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    roughOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    finishOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    finishOpeningHeight: z.ZodOptional<z.ZodNumber>;
     openingKind: z.ZodDefault<z.ZodEnum<{
         window: "window";
         opening: "opening";

package/dist/schema/nodes/window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuErB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -14,6 +14,13 @@ export const WindowType = z.enum([
     'bow',
     'louvered',
 ]);
+export const WindowConstructionType = z.enum(['framed', 'masonry']);
+export const WindowDimensionReference = z.enum([
+    'nominal',
+    'rough-opening',
+    'masonry-opening',
+    'finish-opening',
+]);
 export const WindowNode = BaseNode.extend({
     id: objectId('window'),
     type: nodeType('window'),
@@ -38,6 +45,17 @@ export const WindowNode = BaseNode.extend({
     // Overall dimensions
     width: z.number().default(1.5),
     height: z.number().default(1.5),
+    // Construction-document identity and optional manufacturer rough opening.
+    // Legacy scenes omit these fields and continue to parse unchanged.
+    mark: z.string().trim().max(16).optional(),
+    constructionType: WindowConstructionType.default('framed'),
+    dimensionReference: WindowDimensionReference.default('nominal'),
+    roughOpeningWidth: z.number().positive().optional(),
+    roughOpeningHeight: z.number().positive().optional(),
+    masonryOpeningWidth: z.number().positive().optional(),
+    masonryOpeningHeight: z.number().positive().optional(),
+    finishOpeningWidth: z.number().positive().optional(),
+    finishOpeningHeight: z.number().positive().optional(),
     // Opening mode - when set to "opening", the window is only a shaped cutout
     openingKind: z.enum(['window', 'opening']).default('window'),
     // Window family

package/dist/schema/nodes/zone.d.ts

@@ -19,6 +19,26 @@ export declare const ZoneNode: z.ZodObject<{
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
     boundaryWallIds: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>>>;
+    spaceRole: z.ZodDefault<z.ZodEnum<{
+        generic: "generic";
+        room: "room";
+    }>>;
+    roomNumber: z.ZodDefault<z.ZodString>;
+    enclosureStatus: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        enclosed: "enclosed";
+        open: "open";
+    }>>;
+    floorFinish: z.ZodDefault<z.ZodString>;
+    wallFinish: z.ZodDefault<z.ZodString>;
+    ceilingFinish: z.ZodDefault<z.ZodString>;
+    ceilingHeight: z.ZodDefault<z.ZodNumber>;
+    occupancy: z.ZodDefault<z.ZodString>;
+    clearDimensionPolicy: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        "inside-faces": "inside-faces";
+        "finish-faces": "finish-faces";
+    }>>;
     color: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
 }, z.core.$strip>;

package/dist/schema/nodes/zone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;iBA0BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -11,6 +11,17 @@ export const ZoneNode = BaseNode.extend({
     // stored polygon remains a fallback for missing or temporarily open walls.
     autoFromWalls: z.boolean().default(false),
     boundaryWallIds: z.array(objectId('wall')).default([]),
+    // Generic zones remain available for sites and analysis. Architectural
+    // room documentation is opt-in so legacy zone behavior is unchanged.
+    spaceRole: z.enum(['generic', 'room']).default('generic'),
+    roomNumber: z.string().trim().max(32).default(''),
+    enclosureStatus: z.enum(['auto', 'enclosed', 'open']).default('auto'),
+    floorFinish: z.string().trim().max(120).default(''),
+    wallFinish: z.string().trim().max(120).default(''),
+    ceilingFinish: z.string().trim().max(120).default(''),
+    ceilingHeight: z.number().min(0.1).default(2.7),
+    occupancy: z.string().trim().max(80).default(''),
+    clearDimensionPolicy: z.enum(['none', 'inside-faces', 'finish-faces']).default('none'),
     // Visual styling
     color: z.string().default('#3b82f6'), // Default blue
     metadata: z.json().optional().default({}),
@@ -23,6 +34,10 @@ export const ZoneNode = BaseNode.extend({
   - polygon: array of [x, z] points defining the zone boundary
   - autoFromWalls: whether the boundary follows an enclosed wall loop
   - boundaryWallIds: wall ids that prove the procedural enclosure
+  - spaceRole: generic site/analysis zone or architectural room
+  - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
+  - enclosureStatus: auto-detected, explicitly enclosed, or open
+  - clearDimensionPolicy: optional room clear-dimension datum preference
   - color: hex color for visual styling
   - metadata: zone metadata (optional)
   `);

package/dist/schema/terrain.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** Current authoring and decoding ceiling. */
+export declare const MAX_TERRAIN_SIDE = 257;
+/**
+ * The persisted shape of a terrain heightfield.
+ *
+ * Kept in `schema/` rather than beside the codec because this is the contract
+ * the scene graph validates on load, and `lib/terrain-codec.ts` imports the type
+ * from here so there is exactly one definition of the wire format.
+ *
+ * `heights` is base64 of little-endian Int16 — see `lib/terrain-codec.ts` for why
+ * that beats a JSON number array, and why it is not compressed. The schema is
+ * intentionally loose about the *contents* of that string: validating base64
+ * here would duplicate the decoder, and `decodeTerrainField` already returns
+ * `null` for anything it cannot read, which is the behaviour a corrupt scene
+ * needs (load flat, don't fail the project).
+ */
+export declare const TerrainData: z.ZodObject<{
+    type: z.ZodLiteral<"heightfield">;
+    origin: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    spacing: z.ZodNumber;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    step: z.ZodNumber;
+    heights: z.ZodString;
+}, z.core.$strip>;
+export type TerrainData = z.infer<typeof TerrainData>;
+//# sourceMappingURL=terrain.d.ts.map

package/dist/schema/terrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.d.ts","sourceRoot":"","sources":["../../src/schema/terrain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,8CAA8C;AAC9C,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;;;;;;;;iBAYtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}