@pascal-app/core 0.5.1 → 0.7.0

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type MaterialSchema } from '../material';
 export declare const StairRailingMode: z.ZodEnum<{
     none: "none";
     left: "left";
@@ -7,16 +8,26 @@ export declare const StairRailingMode: z.ZodEnum<{
 }>;
 export declare const StairType: z.ZodEnum<{
     straight: "straight";
-    curved: "curved";
     spiral: "spiral";
+    curved: "curved";
 }>;
 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,8 +47,107 @@ 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<{
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+            custom: "custom";
+        }>>;
+        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<{
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+            custom: "custom";
+        }>>;
+        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<{
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
             custom: "custom";
+        }>>;
+        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<{
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -47,6 +157,7 @@ export declare const StairNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
+            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -66,13 +177,21 @@ export declare const StairNode: z.ZodObject<{
             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";
+        curved: "curved";
+    }>>;
+    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>;
@@ -97,4 +216,5 @@ export declare const StairNode: z.ZodObject<{
     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,10 +18,76 @@ 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<{
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+            custom: "custom";
+        }>>;
+        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>;
+    interiorMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
             custom: "custom";
+        }>>;
+        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<{
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -30,6 +97,7 @@ export declare const WallNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
+            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -49,8 +117,10 @@ export declare const WallNode: z.ZodObject<{
             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

@@ -1,4 +1,17 @@
 import { z } from 'zod';
+export declare const WindowType: z.ZodEnum<{
+    sliding: "sliding";
+    fixed: "fixed";
+    casement: "casement";
+    awning: "awning";
+    hopper: "hopper";
+    "single-hung": "single-hung";
+    "double-hung": "double-hung";
+    bay: "bay";
+    bow: "bow";
+    louvered: "louvered";
+}>;
+export type WindowType = z.infer<typeof WindowType>;
 export declare const WindowNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -18,8 +31,8 @@ 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";
             brick: "brick";
             concrete: "concrete";
@@ -29,6 +42,7 @@ export declare const WindowNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
+            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -57,6 +71,48 @@ export declare const WindowNode: z.ZodObject<{
     wallId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    openingKind: z.ZodDefault<z.ZodEnum<{
+        window: "window";
+        opening: "opening";
+    }>>;
+    windowType: z.ZodDefault<z.ZodEnum<{
+        sliding: "sliding";
+        fixed: "fixed";
+        casement: "casement";
+        awning: "awning";
+        hopper: "hopper";
+        "single-hung": "single-hung";
+        "double-hung": "double-hung";
+        bay: "bay";
+        bow: "bow";
+        louvered: "louvered";
+    }>>;
+    operationState: z.ZodDefault<z.ZodNumber>;
+    awningDirection: z.ZodDefault<z.ZodEnum<{
+        up: "up";
+        down: "down";
+    }>>;
+    casementStyle: z.ZodDefault<z.ZodEnum<{
+        french: "french";
+        single: "single";
+    }>>;
+    hingesSide: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    openingShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        rounded: "rounded";
+        arch: "arch";
+    }>>;
+    openingRadiusMode: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingCornerRadii: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    archHeight: z.ZodDefault<z.ZodNumber>;
+    openingRevealRadius: z.ZodDefault<z.ZodNumber>;
     frameThickness: z.ZodDefault<z.ZodNumber>;
     frameDepth: z.ZodDefault<z.ZodNumber>;
     columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;

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;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -2,6 +2,18 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
+export const WindowType = z.enum([
+    'fixed',
+    'sliding',
+    'casement',
+    'awning',
+    'hopper',
+    'single-hung',
+    'double-hung',
+    'bay',
+    'bow',
+    'louvered',
+]);
 export const WindowNode = BaseNode.extend({
     id: objectId('window'),
     type: nodeType('window'),
@@ -14,6 +26,22 @@ export const WindowNode = BaseNode.extend({
     // Overall dimensions
     width: z.number().default(1.5),
     height: z.number().default(1.5),
+    // Opening mode - when set to "opening", the window is only a shaped cutout
+    openingKind: z.enum(['window', 'opening']).default('window'),
+    // Window family
+    windowType: WindowType.default('fixed'),
+    operationState: z.number().min(0).max(1).default(0),
+    awningDirection: z.enum(['up', 'down']).default('up'),
+    casementStyle: z.enum(['single', 'french']).default('single'),
+    hingesSide: z.enum(['left', 'right']).default('left'),
+    openingShape: z.enum(['rectangle', 'rounded', 'arch']).default('rectangle'),
+    openingRadiusMode: z.enum(['all', 'individual']).default('all'),
+    openingCornerRadii: z
+        .tuple([z.number(), z.number(), z.number(), z.number()])
+        .default([0.15, 0.15, 0.15, 0.15]),
+    cornerRadius: z.number().default(0.15),
+    archHeight: z.number().default(0.35),
+    openingRevealRadius: z.number().default(0.025),
     // Frame
     frameThickness: z.number().default(0.05),
     frameDepth: z.number().default(0.07),
@@ -32,6 +60,7 @@ export const WindowNode = BaseNode.extend({
 }).describe(dedent `Window node - a parametric window placed on a wall
   - position: center of the window in wall-local coordinate system
   - width/height: overall outer dimensions
+  - windowType: explicit window family, defaulting old windows to fixed
   - frameThickness: width of the frame members
   - frameDepth: how deep the frame sits within the wall
   - columnRatios/rowRatios: pane division ratios