@pascal-app/core 1.0.6 → 1.0.7

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

@@ -86,6 +86,11 @@ export declare const WindowNode: z.ZodObject<{
             url: z.ZodString;
             repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
             scale: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            normalMap: z.ZodOptional<z.ZodString>;
+            normalScale: z.ZodOptional<z.ZodNumber>;
+            bumpMap: z.ZodOptional<z.ZodString>;
+            bumpScale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -158,6 +163,16 @@ export declare const WindowNode: z.ZodObject<{
                 color: z.ZodString;
                 intensity: z.ZodNumber;
                 distance: z.ZodOptional<z.ZodNumber>;
+                spot: z.ZodOptional<z.ZodObject<{
+                    direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    angle: z.ZodNumber;
+                    softness: z.ZodNumber;
+                }, z.core.$strip>>;
+                shadows: z.ZodOptional<z.ZodBoolean>;
+                glow: z.ZodOptional<z.ZodObject<{
+                    size: z.ZodNumber;
+                    strength: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>>;
             undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 part: z.ZodOptional<z.ZodString>;
@@ -181,6 +196,17 @@ export declare const WindowNode: z.ZodObject<{
             }, z.core.$strip>>>;
             cutout: z.ZodDefault<z.ZodBoolean>;
             collider: z.ZodDefault<z.ZodBoolean>;
+            shape: z.ZodOptional<z.ZodObject<{
+                tolerance: z.ZodNumber;
+                bands: z.ZodArray<z.ZodObject<{
+                    y0: z.ZodNumber;
+                    y1: z.ZodNumber;
+                    polygons: z.ZodArray<z.ZodObject<{
+                        outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                        holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
             triangles: z.ZodNumber;
             coverage: z.ZodOptional<z.ZodNumber>;
             uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -254,8 +280,17 @@ export declare const WindowNode: z.ZodObject<{
         louvered: "louvered";
         "single-hung": "single-hung";
         sliding: "sliding";
+        "tilt-turn": "tilt-turn";
     }>>;
     operationState: z.ZodDefault<z.ZodNumber>;
+    openingDirection: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    tiltTurnMode: z.ZodOptional<z.ZodEnum<{
+        tilt: "tilt";
+        turn: "turn";
+    }>>;
     awningDirection: z.ZodDefault<z.ZodEnum<{
         down: "down";
         up: "up";
@@ -282,7 +317,9 @@ export declare const WindowNode: z.ZodObject<{
     archHeight: z.ZodDefault<z.ZodNumber>;
     openingRevealRadius: z.ZodDefault<z.ZodNumber>;
     frameThickness: z.ZodDefault<z.ZodNumber>;
-    frameDepth: z.ZodDefault<z.ZodNumber>;
+    frameDepth: z.ZodOptional<z.ZodNumber>;
+    windowHandle: z.ZodOptional<z.ZodBoolean>;
+    sashGrid: z.ZodOptional<z.ZodBoolean>;
     columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
     rowRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
     columnDividerThickness: z.ZodDefault<z.ZodNumber>;
@@ -301,6 +338,34 @@ export declare const WindowNode: z.ZodObject<{
     sill: z.ZodDefault<z.ZodBoolean>;
     sillDepth: z.ZodDefault<z.ZodNumber>;
     sillThickness: z.ZodDefault<z.ZodNumber>;
+    sillOverhang: z.ZodOptional<z.ZodNumber>;
+    sillInterior: z.ZodOptional<z.ZodBoolean>;
+    sillInteriorDepth: z.ZodOptional<z.ZodNumber>;
+    sillInteriorThickness: z.ZodOptional<z.ZodNumber>;
+    sillInteriorOverhang: z.ZodOptional<z.ZodNumber>;
+    shutters: z.ZodOptional<z.ZodEnum<{
+        "board-batten": "board-batten";
+        louvered: "louvered";
+        none: "none";
+        panel: "panel";
+    }>>;
+    shutterWidth: z.ZodOptional<z.ZodNumber>;
+    shutterOpen: z.ZodOptional<z.ZodNumber>;
+    shutterSides: z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        left: "left";
+        right: "right";
+    }>>;
+    rollerShutter: z.ZodOptional<z.ZodEnum<{
+        box: "box";
+        concealed: "concealed";
+        none: "none";
+    }>>;
+    rollerShutterBoxHeight: z.ZodOptional<z.ZodNumber>;
+    rollerShutterOpen: z.ZodOptional<z.ZodNumber>;
+    casingFaceA: z.ZodOptional<z.ZodBoolean>;
+    casingFaceB: z.ZodOptional<z.ZodBoolean>;
+    casingWidth: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type WindowNode = z.infer<typeof WindowNode>;
 //# sourceMappingURL=window.d.ts.map

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;AAMvB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyGrB,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;AAMvB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2JrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -17,8 +17,9 @@ export const WindowNode = BaseNode.extend({
     type: nodeType('window'),
     material: MaterialSchema.optional(),
     // Per-slot material overrides on the unified slot model. Keys: `frame`,
-    // `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`) or a plain
-    // `#rrggbb` colour. Absent = the frame/glass default. Mirrors `ShelfNode.slots`.
+    // `glass`, `hardware`, `shutters`, `sill`, `casing-a`, `casing-b`. Value = a
+    // `MaterialRef` (`library:<id>` / `scene:<id>`) or a plain
+    // `#rrggbb` colour. Hardware follows the frame unless painted.
     slots: z.record(z.string(), z.string()).optional(),
     /**
      * A three.js script the window is built from instead of its parametric frame, as on an item:
@@ -63,6 +64,8 @@ export const WindowNode = BaseNode.extend({
     // Window family
     windowType: WindowType.default('fixed'),
     operationState: z.number().min(0).max(1).default(0),
+    openingDirection: z.enum(['outward', 'inward']).optional(),
+    tiltTurnMode: z.enum(['tilt', 'turn']).optional(),
     awningDirection: z.enum(['up', 'down']).default('up'),
     casementStyle: z.enum(['single', 'french']).default('single'),
     hingesSide: z.enum(['left', 'right']).default('left'),
@@ -76,7 +79,15 @@ export const WindowNode = BaseNode.extend({
     openingRevealRadius: z.number().default(0.025),
     // Frame
     frameThickness: z.number().default(0.05),
-    frameDepth: z.number().default(0.07),
+    frameDepth: z
+        .number()
+        .optional()
+        .describe("Frame depth through the wall; left out, the frame is exactly the host wall's thickness."),
+    windowHandle: z.boolean().optional().describe('Show the operable sash handle (absent = true).'),
+    sashGrid: z
+        .boolean()
+        .optional()
+        .describe('Apply pane divisions per operable sash (absent = false).'),
     // Divisions — ratios allow non-uniform panes
     // [0.5, 0.5] = two equal panes
     // [0.6, 0.4] = one larger, one smaller
@@ -98,13 +109,47 @@ export const WindowNode = BaseNode.extend({
     sill: z.boolean().default(true),
     sillDepth: z.number().default(0.08),
     sillThickness: z.number().default(0.03),
+    sillOverhang: z.number().nonnegative().optional(),
+    sillInterior: z.boolean().optional(),
+    sillInteriorDepth: z.number().positive().optional(),
+    sillInteriorThickness: z.number().positive().optional(),
+    sillInteriorOverhang: z.number().nonnegative().optional(),
+    shutters: z.enum(['none', 'louvered', 'panel', 'board-batten']).optional(),
+    shutterWidth: z.number().positive().optional(),
+    shutterOpen: z.number().min(0).max(1).optional(),
+    shutterSides: z.enum(['both', 'left', 'right']).optional(),
+    rollerShutter: z.enum(['none', 'box', 'concealed']).optional(),
+    rollerShutterBoxHeight: z.number().positive().optional(),
+    rollerShutterOpen: z.number().min(0).max(1).optional(),
+    // Casing: flat boards on the finished faces of the host wall around the
+    // opening, never inside it, so the wall cutout stays width × height. The
+    // faces are the host's `a` / `b` (WallFace), not the unit's own front and
+    // back, so flipping the window leaves its casing where it is. Optional, never
+    // defaulted, so loading a saved opening adds no fields: absent faces are
+    // uncased, an absent width is 2 in.
+    casingFaceA: z.boolean().optional(),
+    casingFaceB: z.boolean().optional(),
+    casingWidth: z.number().positive().optional(),
 }).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
+  - width/height: overall outer dimensions, which are also the wall cutout
   - windowType: explicit window family, defaulting old windows to fixed
-  - frameThickness: width of the frame members
+  - frameThickness: width of the frame members (new windows use 0.020 m; absent in saved windows keeps 0.05 m)
   - frameDepth: how deep the frame sits within the wall
   - columnRatios/rowRatios: pane division ratios
+  - windowHandle: show the interior handle on casement, awning, hopper and tilt-turn sashes (absent = true)
+  - sashGrid: pane divisions per operable sash (absent = false; saved windows keep no bars)
+  - openingDirection: casement/awning swing toward exterior or interior; absent preserves placement-face motion
+  - tiltTurnMode: tilt inward up to 15 degrees (default), or turn inward up to 90 degrees
+  - sillInterior: room-side stool board (absent = false); depth/thickness/overhang default to 0.06/0.03/0.015 m
+  - sillOverhang: exterior sill extension on each side (absent = 0.4 times sillDepth)
+  - shutterOpen/shutterSides: 0 closed to 1 open (default 1), both/left/right (default both); leaves over 0.75 m bifold and stack when open
+  - rollerShutter/rollerShutterOpen: none (default), box on the exterior wall, or concealed inside the reveal; curtain fraction up (default 1)
+  - rollerShutterBoxHeight: exterior box height in metres (default 0.18), box mount only
+  - concealed roller: 0.03 m lintel strip, 0.025 x 0.03 m jamb guides inside the reveal; curtain 0.02 m outside the frame plane, width minus 0.05 m
+  - shutters/shutterWidth: exterior shutters (absent = none); width per side defaults to width / 2 for both sides or full width for left/right only, uncapped; paired shutters meet with a 0.01 m overlap lip
   - sill: whether to show a window sill
+  - casingFaceA/casingFaceB: picture-frame casing on the host wall's face a / b, around the cutout (absent means off; new openings enable both)
+  - casingWidth: face width of the casing boards (2 in by default)
   - corner: joined to a window on the other wall at this wall's start or end (a corner window)
 `);

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

@@ -74,6 +74,16 @@ export declare const ZoneFloorScript: z.ZodObject<{
             color: z.ZodString;
             intensity: z.ZodNumber;
             distance: z.ZodOptional<z.ZodNumber>;
+            spot: z.ZodOptional<z.ZodObject<{
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                angle: z.ZodNumber;
+                softness: z.ZodNumber;
+            }, z.core.$strip>>;
+            shadows: z.ZodOptional<z.ZodBoolean>;
+            glow: z.ZodOptional<z.ZodObject<{
+                size: z.ZodNumber;
+                strength: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
             part: z.ZodOptional<z.ZodString>;
@@ -97,6 +107,17 @@ export declare const ZoneFloorScript: z.ZodObject<{
         }, z.core.$strip>>>;
         cutout: z.ZodDefault<z.ZodBoolean>;
         collider: z.ZodDefault<z.ZodBoolean>;
+        shape: z.ZodOptional<z.ZodObject<{
+            tolerance: z.ZodNumber;
+            bands: z.ZodArray<z.ZodObject<{
+                y0: z.ZodNumber;
+                y1: z.ZodNumber;
+                polygons: z.ZodArray<z.ZodObject<{
+                    outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                    holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         triangles: z.ZodNumber;
         coverage: z.ZodOptional<z.ZodNumber>;
         uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -243,6 +264,16 @@ export declare const ZoneNode: z.ZodObject<{
                     color: z.ZodString;
                     intensity: z.ZodNumber;
                     distance: z.ZodOptional<z.ZodNumber>;
+                    spot: z.ZodOptional<z.ZodObject<{
+                        direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                        angle: z.ZodNumber;
+                        softness: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    shadows: z.ZodOptional<z.ZodBoolean>;
+                    glow: z.ZodOptional<z.ZodObject<{
+                        size: z.ZodNumber;
+                        strength: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>>;
                 undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
                     part: z.ZodOptional<z.ZodString>;
@@ -266,6 +297,17 @@ export declare const ZoneNode: z.ZodObject<{
                 }, z.core.$strip>>>;
                 cutout: z.ZodDefault<z.ZodBoolean>;
                 collider: z.ZodDefault<z.ZodBoolean>;
+                shape: z.ZodOptional<z.ZodObject<{
+                    tolerance: z.ZodNumber;
+                    bands: z.ZodArray<z.ZodObject<{
+                        y0: z.ZodNumber;
+                        y1: z.ZodNumber;
+                        polygons: z.ZodArray<z.ZodObject<{
+                            outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                            holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
                 triangles: z.ZodNumber;
                 coverage: z.ZodOptional<z.ZodNumber>;
                 uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -280,6 +322,32 @@ export declare const ZoneNode: z.ZodObject<{
             }, z.core.$strip>>;
             inputs: z.ZodString;
         }, z.core.$strip>>;
+        drop: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    roomType: z.ZodOptional<z.ZodEnum<{
+        deck: "deck";
+        patio: "patio";
+        porch: "porch";
+    }>>;
+    porchFraming: z.ZodOptional<z.ZodObject<{
+        auto: z.ZodOptional<z.ZodBoolean>;
+        postSize: z.ZodOptional<z.ZodString>;
+        postSpacing: z.ZodOptional<z.ZodNumber>;
+        beamSize: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    decking: z.ZodOptional<z.ZodObject<{
+        boardSize: z.ZodOptional<z.ZodEnum<{
+            "2x4": "2x4";
+            "2x6": "2x6";
+            "5/4x6": "5/4x6";
+            composite: "composite";
+        }>>;
+        gap: z.ZodOptional<z.ZodNumber>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            diagonal: "diagonal";
+            parallel: "parallel";
+            perpendicular: "perpendicular";
+        }>>;
     }, z.core.$strip>>;
     ceiling: z.ZodOptional<z.ZodObject<{
         regions: z.ZodOptional<z.ZodArray<z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsD,CAAA;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4FpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsD,CAAA;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4HpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -34,6 +34,34 @@ export const ZoneNode = BaseNode.extend({
         finish: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
         regions: z.array(SurfacePaintRegion).optional(),
         script: ZoneFloorScript.optional(),
+        // How far the floor steps down from the floor it would otherwise share, metres (a porch
+        // 1.5 in under the house), so it follows the house's floor. An `elevation` wins over it.
+        drop: z.number().min(0).optional(),
+    })
+        .optional(),
+    // The outdoor room types: a porch (a covered floor a step down from the house), a
+    // deck (a framed floor) or a patio (an uncovered slab). Such a room is outdoors whatever covers
+    // it (`lib/outdoor-room`). Absent, an ordinary room.
+    roomType: z.enum(['porch', 'deck', 'patio']).optional(),
+    // A porch's posts and the beam on them (`lib/porch-framing`): placed by the structure kernel
+    // while `auto` holds (absent = on; a deck's or patio's only once `auto` is true), at these sizes
+    // and at most `postSpacing` metres apart.
+    porchFraming: z
+        .object({
+        auto: z.boolean().optional(),
+        postSize: z.string().optional(),
+        postSpacing: z.number().positive().optional(),
+        beamSize: z.string().optional(),
+    })
+        .optional(),
+    // A deck's boards (`lib/deck-boards`): their stock, the gap between them in metres and the way
+    // they run against the house, the joists under them following. Absent, 5/4x6 boards 1/4 in apart
+    // running along the house.
+    decking: z
+        .object({
+        boardSize: z.enum(['5/4x6', '2x6', '2x4', 'composite']).optional(),
+        gap: z.number().positive().optional(),
+        direction: z.enum(['parallel', 'diagonal', 'perpendicular']).optional(),
     })
         .optional(),
     // Painted parts of the room's ceiling. The automatic ceilings are rebuilt
@@ -91,6 +119,10 @@ export const ZoneNode = BaseNode.extend({
   - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
   - floor.regions / ceiling.regions: painted parts of the room's floor and ceiling ([x, z] polygons, later wins)
   - floor.script: a three.js module that builds the room's floor finish (boards, tiles) for its floor polygon, drawn over the floor; it owns its colours
+  - floor.drop: metres the floor steps down from the floor it would share (a porch under the house's floor); an explicit floor.elevation wins
+  - roomType: "porch", "deck" or "patio" for a room outside the house (outdoors even when covered); absent, an ordinary room
+  - porchFraming: a porch's posts and beam (auto placement on unless false; a deck's or patio's only when auto is true; post size, max post spacing in metres, beam size)
+  - decking: a deck's boards (boardSize "5/4x6" | "2x6" | "2x4" | "composite", gap in metres, direction "parallel" | "diagonal" | "perpendicular" to the house); absent, 5/4x6 at 1/4 in along the house
   - floorStepFinish: finish of the room's steps; floorStepOverrides: per-doorway step finishes keyed by door id (or the lower room id), optional step index
   - enclosureStatus: auto-detected, explicitly enclosed, or open
   - clearDimensionPolicy: optional room clear-dimension datum preference

package/dist/schema/scene-material.d.ts

@@ -34,6 +34,11 @@ export declare const SceneMaterial: z.ZodObject<{
             url: z.ZodString;
             repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
             scale: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            normalMap: z.ZodOptional<z.ZodString>;
+            normalScale: z.ZodOptional<z.ZodNumber>;
+            bumpMap: z.ZodOptional<z.ZodString>;
+            bumpScale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/dist/schema/scene-material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-material.d.ts","sourceRoot":"","sources":["../../src/schema/scene-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,eAAe,GAAG,OAAO,MAAM,EAAE,CAAA;AAC7C,eAAO,MAAM,uBAAuB,QAAO,eAAoC,CAAA;AAE/E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}
+{"version":3,"file":"scene-material.d.ts","sourceRoot":"","sources":["../../src/schema/scene-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,eAAe,GAAG,OAAO,MAAM,EAAE,CAAA;AAC7C,eAAO,MAAM,uBAAuB,QAAO,eAAoC,CAAA;AAE/E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}