@pascal-app/core 0.5.0 → 0.6.0

package/dist/schema/nodes/roof.js

@@ -1,12 +1,19 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { MaterialSchema as MaterialSchemaSchema } from '../material';
 import { RoofSegmentNode } from './roof-segment';
 export const RoofNode = BaseNode.extend({
     id: objectId('roof'),
     type: nodeType('roof'),
-    material: MaterialSchema.optional(),
+    material: MaterialSchemaSchema.optional(),
+    materialPreset: z.string().optional(),
+    topMaterial: MaterialSchemaSchema.optional(),
+    topMaterialPreset: z.string().optional(),
+    edgeMaterial: MaterialSchemaSchema.optional(),
+    edgeMaterialPreset: z.string().optional(),
+    wallMaterial: MaterialSchemaSchema.optional(),
+    wallMaterialPreset: z.string().optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
@@ -20,3 +27,52 @@ export const RoofNode = BaseNode.extend({
   - rotation: rotation around Y axis
   - children: array of RoofSegmentNode IDs
   `);
+function getLegacyRoofSurfaceMaterial(node) {
+    return {
+        material: node.material,
+        materialPreset: node.materialPreset,
+    };
+}
+export function getEffectiveRoofSurfaceMaterial(node, role) {
+    if (role === 'top') {
+        if (node.topMaterial !== undefined || typeof node.topMaterialPreset === 'string') {
+            return {
+                material: node.topMaterial,
+                materialPreset: typeof node.topMaterialPreset === 'string' ? node.topMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'edge') {
+        if (node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string') {
+            return {
+                material: node.edgeMaterial,
+                materialPreset: typeof node.edgeMaterialPreset === 'string' ? node.edgeMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'wall') {
+        if (node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string') {
+            return {
+                material: node.wallMaterial,
+                materialPreset: typeof node.wallMaterialPreset === 'string' ? node.wallMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'edge') {
+        if (node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string') {
+            return {
+                material: node.wallMaterial,
+                materialPreset: typeof node.wallMaterialPreset === 'string' ? node.wallMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'wall') {
+        if (node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string') {
+            return {
+                material: node.edgeMaterial,
+                materialPreset: typeof node.edgeMaterialPreset === 'string' ? node.edgeMaterialPreset : undefined,
+            };
+        }
+    }
+    return getLegacyRoofSurfaceMaterial(node);
+}

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

@@ -80,8 +80,8 @@ export declare const SiteNode: z.ZodObject<{
             dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
             attachTo: z.ZodOptional<z.ZodEnum<{
                 wall: "wall";
-                "wall-side": "wall-side";
                 ceiling: "ceiling";
+                "wall-side": "wall-side";
             }>>;
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

@@ -18,6 +18,7 @@ export declare const SlabNode: z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"slab">>;
     material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
             custom: "custom";
             white: "white";
@@ -48,9 +49,18 @@ export declare const SlabNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+    holeMetadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodDefault<z.ZodEnum<{
+            stair: "stair";
+            manual: "manual";
+        }>>;
+        stairId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
+    autoFromWalls: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SlabNode = z.infer<typeof SlabNode>;
 //# sourceMappingURL=slab.d.ts.map

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;AAIvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,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;AAKvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/slab.js

@@ -2,15 +2,22 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
+import { SurfaceHoleMetadata } from './surface-hole-metadata';
 export const SlabNode = BaseNode.extend({
     id: objectId('slab'),
     type: nodeType('slab'),
     material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
     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
+    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 stair-managed cutouts
   - elevation: elevation in meters
+  - autoFromWalls: whether the slab is automatically generated from a closed wall loop
   `);

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

@@ -29,6 +29,7 @@ export declare const StairSegmentNode: z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair-segment">>;
     material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
             custom: "custom";
             white: "white";
@@ -59,6 +60,7 @@ export declare const StairSegmentNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     segmentType: z.ZodDefault<z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schema/nodes/stair-segment.js

@@ -8,6 +8,7 @@ export const StairSegmentNode = BaseNode.extend({
     id: objectId('sseg'),
     type: nodeType('stair-segment'),
     material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),

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

@@ -1,4 +1,33 @@
 import { z } from 'zod';
+import { type MaterialSchema } from '../material';
+export declare const StairRailingMode: z.ZodEnum<{
+    left: "left";
+    right: "right";
+    none: "none";
+    both: "both";
+}>;
+export declare const StairType: z.ZodEnum<{
+    straight: "straight";
+    curved: "curved";
+    spiral: "spiral";
+}>;
+export declare const StairTopLandingMode: z.ZodEnum<{
+    none: "none";
+    integrated: "integrated";
+}>;
+export declare const StairSlabOpeningMode: z.ZodEnum<{
+    none: "none";
+    destination: "destination";
+}>;
+export type StairRailingMode = z.infer<typeof StairRailingMode>;
+export type StairType = z.infer<typeof StairType>;
+export type StairTopLandingMode = z.infer<typeof StairTopLandingMode>;
+export type StairSlabOpeningMode = z.infer<typeof StairSlabOpeningMode>;
+export type StairSurfaceMaterialRole = 'railing' | 'tread' | 'side';
+export type StairSurfaceMaterialSpec = {
+    material?: MaterialSchema;
+    materialPreset?: string;
+};
 export declare const StairNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -18,6 +47,7 @@ export declare const StairNode: z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair">>;
     material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
             custom: "custom";
             white: "white";
@@ -48,9 +78,143 @@ export declare const StairNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
+    railingMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    railingMaterialPreset: z.ZodOptional<z.ZodString>;
+    treadMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    treadMaterialPreset: z.ZodOptional<z.ZodString>;
+    sideMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    sideMaterialPreset: z.ZodOptional<z.ZodString>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    stairType: z.ZodDefault<z.ZodEnum<{
+        straight: "straight";
+        curved: "curved";
+        spiral: "spiral";
+    }>>;
+    fromLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    toLevelId: z.ZodDefault<z.ZodNullable<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>;
+    stepCount: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    innerRadius: z.ZodDefault<z.ZodNumber>;
+    sweepAngle: z.ZodDefault<z.ZodNumber>;
+    topLandingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        integrated: "integrated";
+    }>>;
+    topLandingDepth: z.ZodDefault<z.ZodNumber>;
+    showCenterColumn: z.ZodDefault<z.ZodBoolean>;
+    showStepSupports: z.ZodDefault<z.ZodBoolean>;
+    railingMode: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        none: "none";
+        both: "both";
+    }>>;
+    railingHeight: z.ZodDefault<z.ZodNumber>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`sseg_${string}`>>>>;
 }, z.core.$strip>;
 export type StairNode = z.infer<typeof StairNode>;
+export declare function getEffectiveStairSurfaceMaterial(node: StairNode, role: StairSurfaceMaterialRole): StairSurfaceMaterialSpec;
 //# sourceMappingURL=stair.d.ts.map

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;AAKvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"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,EAAE,KAAK,cAAc,EAA0C,MAAM,aAAa,CAAA;AAGzF,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,cAAc,CAAA;IACzB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DrB,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,CA2D1B"}

package/dist/schema/nodes/stair.js

@@ -1,22 +1,123 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { MaterialSchema as MaterialSchemaSchema } from '../material';
 import { StairSegmentNode } from './stair-segment';
+export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
+export const StairType = z.enum(['straight', 'curved', 'spiral']);
+export const StairTopLandingMode = z.enum(['none', 'integrated']);
+export const StairSlabOpeningMode = z.enum(['none', 'destination']);
 export const StairNode = BaseNode.extend({
     id: objectId('stair'),
     type: nodeType('stair'),
-    material: MaterialSchema.optional(),
+    material: MaterialSchemaSchema.optional(),
+    materialPreset: z.string().optional(),
+    railingMaterial: MaterialSchemaSchema.optional(),
+    railingMaterialPreset: z.string().optional(),
+    treadMaterial: MaterialSchemaSchema.optional(),
+    treadMaterialPreset: z.string().optional(),
+    sideMaterial: MaterialSchemaSchema.optional(),
+    sideMaterialPreset: z.string().optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
+    stairType: StairType.default('straight'),
+    fromLevelId: z.string().nullable().default(null),
+    toLevelId: z.string().nullable().default(null),
+    slabOpeningMode: StairSlabOpeningMode.default('none'),
+    openingOffset: z.number().default(0),
+    width: z.number().default(1.0),
+    totalRise: z.number().default(2.5),
+    stepCount: z.number().default(10),
+    thickness: z.number().default(0.25),
+    fillToFloor: z.boolean().default(true),
+    innerRadius: z.number().default(0.9),
+    sweepAngle: z.number().default(Math.PI / 2),
+    topLandingMode: StairTopLandingMode.default('none'),
+    topLandingDepth: z.number().default(0.9),
+    showCenterColumn: z.boolean().default(true),
+    showStepSupports: z.boolean().default(true),
+    railingMode: StairRailingMode.default('none'),
+    railingHeight: z.number().default(0.92),
     // Child stair segment IDs
     children: z.array(StairSegmentNode.shape.id).default([]),
 }).describe(dedent `
   Stair node - a container for stair segments.
-  Acts as a group that holds one or more StairSegmentNodes (flights and landings).
-  Segments chain together based on their attachmentSide to form complex staircase shapes.
+  Acts as a group that either holds one or more StairSegmentNodes (straight stairs)
+  or stores stair-level geometry properties for curved stairs.
   - position: center position of the stair group
   - rotation: rotation around Y axis
-  - children: array of StairSegmentNode IDs
+  - stairType: straight (segment-based), curved (arc-based), or spiral
+  - fromLevelId / toLevelId: source and destination levels used for auto slab cutouts
+  - 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
+  - totalRise: total stair height
+  - stepCount: number of visible steps
+  - thickness: stair slab / tread thickness
+  - fillToFloor: whether the stair mass fills down to the floor or uses tread thickness only
+  - innerRadius: inner curve radius for curved stairs
+  - sweepAngle: total curved stair sweep in radians
+  - topLandingMode: optional integrated top landing for spiral stairs
+  - topLandingDepth: depth used to size the integrated spiral top landing
+  - showCenterColumn: whether spiral stairs render a center column
+  - showStepSupports: whether spiral stairs render step support brackets
+  - railingMode: whether to render railings and on which side(s)
+  - railingHeight: top height of the railing above the stair surface
+  - children: array of StairSegmentNode IDs for straight stairs
   `);
+function getLegacyStairSurfaceMaterial(node) {
+    return {
+        material: node.material,
+        materialPreset: node.materialPreset,
+    };
+}
+export function getEffectiveStairSurfaceMaterial(node, role) {
+    if (role === 'railing') {
+        if (node.railingMaterial !== undefined || typeof node.railingMaterialPreset === 'string') {
+            return {
+                material: node.railingMaterial,
+                materialPreset: typeof node.railingMaterialPreset === 'string' ? node.railingMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'tread') {
+        if (node.treadMaterial !== undefined || typeof node.treadMaterialPreset === 'string') {
+            return {
+                material: node.treadMaterial,
+                materialPreset: typeof node.treadMaterialPreset === 'string' ? node.treadMaterialPreset : undefined,
+            };
+        }
+    }
+    if (role === 'side') {
+        if (node.sideMaterial !== undefined || typeof node.sideMaterialPreset === 'string') {
+            return {
+                material: node.sideMaterial,
+                materialPreset: typeof node.sideMaterialPreset === 'string' ? node.sideMaterialPreset : undefined,
+            };
+        }
+    }
+    const treadFallback = {
+        material: node.treadMaterial,
+        materialPreset: typeof node.treadMaterialPreset === 'string' ? node.treadMaterialPreset : undefined,
+    };
+    const sideFallback = {
+        material: node.sideMaterial,
+        materialPreset: typeof node.sideMaterialPreset === 'string' ? node.sideMaterialPreset : undefined,
+    };
+    if (role === 'tread' && (sideFallback.material !== undefined || sideFallback.materialPreset !== undefined)) {
+        return sideFallback;
+    }
+    if (role === 'side' && (treadFallback.material !== undefined || treadFallback.materialPreset !== undefined)) {
+        return treadFallback;
+    }
+    if (role === 'railing') {
+        if (treadFallback.material !== undefined || treadFallback.materialPreset !== undefined) {
+            return treadFallback;
+        }
+        if (sideFallback.material !== undefined || sideFallback.materialPreset !== undefined) {
+            return sideFallback;
+        }
+    }
+    return getLegacyStairSurfaceMaterial(node);
+}

package/dist/schema/nodes/surface-hole-metadata.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const SurfaceHoleMetadata: z.ZodObject<{
+    source: z.ZodDefault<z.ZodEnum<{
+        stair: "stair";
+        manual: "manual";
+    }>>;
+    stairId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SurfaceHoleMetadata = z.infer<typeof SurfaceHoleMetadata>;
+//# sourceMappingURL=surface-hole-metadata.d.ts.map

package/dist/schema/nodes/surface-hole-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-hole-metadata.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/surface-hole-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;iBAG9B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schema/nodes/surface-hole-metadata.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const SurfaceHoleMetadata = z.object({
+    source: z.enum(['manual', 'stair']).default('manual'),
+    stairId: z.string().optional(),
+});

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MaterialSchema } from '../material';
 export declare const WallNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -17,8 +18,9 @@ export declare const WallNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"wall">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`door_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>]>>>;
     material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
             custom: "custom";
             white: "white";
@@ -49,8 +51,76 @@ export declare const WallNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
+    interiorMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    interiorMaterialPreset: z.ZodOptional<z.ZodString>;
+    exteriorMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    exteriorMaterialPreset: z.ZodOptional<z.ZodString>;
     thickness: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
+    curveOffset: z.ZodOptional<z.ZodNumber>;
     start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     frontSide: z.ZodDefault<z.ZodEnum<{
@@ -65,4 +135,20 @@ export declare const WallNode: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 export type WallNode = z.infer<typeof WallNode>;
+export type WallSurfaceSide = 'interior' | 'exterior';
+export type WallSurfaceMaterialSpec = {
+    material?: z.infer<typeof MaterialSchema>;
+    materialPreset?: string;
+};
+type WallSurfaceMaterialSource = {
+    material?: z.infer<typeof MaterialSchema>;
+    materialPreset?: string;
+    interiorMaterial?: z.infer<typeof MaterialSchema>;
+    interiorMaterialPreset?: string;
+    exteriorMaterial?: z.infer<typeof MaterialSchema>;
+    exteriorMaterialPreset?: string;
+};
+export declare function getEffectiveWallSurfaceMaterial(wall: WallSurfaceMaterialSource, side: WallSurfaceSide): WallSurfaceMaterialSpec;
+export declare function getWallSurfaceMaterialSignature(spec: WallSurfaceMaterialSpec): string;
+export {};
 //# sourceMappingURL=wall.d.ts.map

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":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"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,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,UAAU,CAAA;AAErD,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"}