@pascal-app/core 0.5.1 → 0.6.0

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,8 +1,9 @@
 import { z } from 'zod';
+import { type MaterialSchema } from '../material';
 export declare const StairRailingMode: z.ZodEnum<{
-    none: "none";
     left: "left";
     right: "right";
+    none: "none";
     both: "both";
 }>;
 export declare const StairType: z.ZodEnum<{
@@ -14,9 +15,19 @@ 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>;
@@ -36,6 +47,73 @@ 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";
+            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>>;
+    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";
@@ -66,6 +144,40 @@ export declare const StairNode: z.ZodObject<{
             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<{
@@ -73,6 +185,13 @@ export declare const StairNode: z.ZodObject<{
         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>;
@@ -88,13 +207,14 @@ export declare const StairNode: z.ZodObject<{
     showCenterColumn: z.ZodDefault<z.ZodBoolean>;
     showStepSupports: z.ZodDefault<z.ZodBoolean>;
     railingMode: z.ZodDefault<z.ZodEnum<{
-        none: "none";
         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,gBAAgB;;;;;EAA4C,CAAA;AACzE,eAAO,MAAM,SAAS;;;;EAA2C,CAAA;AACjE,eAAO,MAAM,mBAAmB;;;EAAiC,CAAA;AAEjE,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;AAErE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CrB,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,19 +1,31 @@
 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),
@@ -36,6 +48,9 @@ export const StairNode = BaseNode.extend({
   - position: center position of the stair group
   - 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
+  - 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
@@ -51,3 +66,58 @@ export const StairNode = BaseNode.extend({
   - 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"}

package/dist/schema/nodes/wall.js

@@ -2,17 +2,26 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
+import { DoorNode } from './door';
 import { ItemNode } from './item';
-// import { DoorNode } from "./door";
-// import { ItemNode } from "./item";
-// import { WindowNode } from "./window";
+import { WindowNode } from './window';
 export const WallNode = BaseNode.extend({
     id: objectId('wall'),
     type: nodeType('wall'),
-    children: z.array(ItemNode.shape.id).default([]),
+    children: z
+        .array(z.union([ItemNode.shape.id, DoorNode.shape.id, WindowNode.shape.id]))
+        .default([]),
+    // Legacy single-material wall finish. Read for backward compatibility only.
     material: MaterialSchema.optional(),
+    // Legacy single-material wall finish preset. Read for backward compatibility only.
+    materialPreset: z.string().optional(),
+    interiorMaterial: MaterialSchema.optional(),
+    interiorMaterialPreset: z.string().optional(),
+    exteriorMaterial: MaterialSchema.optional(),
+    exteriorMaterialPreset: z.string().optional(),
     thickness: z.number().optional(),
     height: z.number().optional(),
+    curveOffset: z.number().optional(),
     // e.g., start/end points for path
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),
@@ -23,9 +32,41 @@ export const WallNode = BaseNode.extend({
   Wall node - used to represent a wall in the building
   - thickness: thickness in meters
   - height: height in meters
+  - 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
   - size: size of the wall in grid units
   - frontSide: whether the front side faces interior, exterior, or unknown
   - backSide: whether the back side faces interior, exterior, or unknown
   `);
+function getConfiguredWallSurfaceMaterial(wall, side) {
+    if (side === 'interior') {
+        return {
+            material: wall.interiorMaterial,
+            materialPreset: wall.interiorMaterialPreset,
+        };
+    }
+    return {
+        material: wall.exteriorMaterial,
+        materialPreset: wall.exteriorMaterialPreset,
+    };
+}
+function hasSurfaceMaterial(spec) {
+    return spec.material !== undefined || typeof spec.materialPreset === 'string';
+}
+export function getEffectiveWallSurfaceMaterial(wall, side) {
+    const configured = getConfiguredWallSurfaceMaterial(wall, side);
+    if (hasSurfaceMaterial(configured)) {
+        return configured;
+    }
+    return {
+        material: wall.material,
+        materialPreset: wall.materialPreset,
+    };
+}
+export function getWallSurfaceMaterialSignature(spec) {
+    return JSON.stringify({
+        material: spec.material ?? null,
+        materialPreset: spec.materialPreset ?? null,
+    });
+}

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

@@ -18,6 +18,7 @@ export declare const WindowNode: z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"window">>;
     material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
             custom: "custom";
             white: "white";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCrB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}