@pascal-app/core 0.7.0 → 0.9.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"skylight.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/skylight.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;EAA6B,CAAA;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,eAAO,MAAM,mBAAmB,+DAAgE,CAAA;AAEhG,eAAO,MAAM,YAAY;;;;;;EAA8B,CAAA;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;EAA6C,CAAA;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,eAAO,MAAM,sBAAsB;;;EAAqB,CAAA;AACxD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,mBAAmB,CAAA;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,sBAAsB,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0G2B,CAAA;AAI7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schema/nodes/skylight.js

@@ -0,0 +1,152 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const SkylightMaterialRole = z.enum(['frame', 'glass']);
+export const SKYLIGHT_TYPE_ORDER = ['flat', 'walk-on', 'lantern', 'opening', 'sliding'];
+export const SkylightType = z.enum(SKYLIGHT_TYPE_ORDER);
+export const SkylightOpeningSide = z.enum(['top', 'bottom', 'left', 'right']);
+export const SkylightSlideDirection = z.enum(['x', 'z']);
+export const SKYLIGHT_TYPE_PRESETS = {
+    flat: {
+        label: 'Flat roof skylight',
+        width: 0.9,
+        height: 1.2,
+        frameThickness: 0.055,
+        frameDepth: 0.08,
+        glassThickness: 0.012,
+        curb: true,
+        curbHeight: 0.08,
+        cutoutOffset: 0,
+        lanternHeight: 0.25,
+        lanternTopScale: 0,
+        openingAngle: 0,
+        openingSide: 'top',
+        operationState: 0,
+        motorHousing: false,
+        slideFraction: 0,
+        slideDirection: 'z',
+        trackWidth: 0.04,
+        motorHousingSize: 0.08,
+    },
+    'walk-on': {
+        label: 'Walk-on rooflight',
+        width: 1.2,
+        height: 1.8,
+        frameThickness: 0.035,
+        frameDepth: 0.045,
+        glassThickness: 0.04,
+        curb: false,
+        curbHeight: 0,
+        cutoutOffset: 0,
+        lanternHeight: 0.25,
+        lanternTopScale: 0,
+        openingAngle: 0,
+        openingSide: 'top',
+        operationState: 0,
+        motorHousing: false,
+        slideFraction: 0,
+        slideDirection: 'z',
+        trackWidth: 0.04,
+        motorHousingSize: 0.08,
+    },
+    lantern: {
+        label: 'Roof lantern',
+        width: 1.4,
+        height: 1.4,
+        frameThickness: 0.06,
+        frameDepth: 0.08,
+        glassThickness: 0.012,
+        curb: true,
+        curbHeight: 0.16,
+        cutoutOffset: 0,
+        lanternHeight: 0.45,
+        lanternTopScale: 0,
+        openingAngle: 0,
+        openingSide: 'top',
+        operationState: 0,
+        motorHousing: false,
+        slideFraction: 0,
+        slideDirection: 'z',
+        trackWidth: 0.04,
+        motorHousingSize: 0.08,
+    },
+    opening: {
+        label: 'Opening skylight',
+        width: 0.9,
+        height: 1.2,
+        frameThickness: 0.06,
+        frameDepth: 0.035,
+        glassThickness: 0.014,
+        curb: true,
+        curbHeight: 0.1,
+        cutoutOffset: 0,
+        lanternHeight: 0.25,
+        lanternTopScale: 0,
+        openingAngle: Math.PI / 8,
+        openingSide: 'top',
+        operationState: 1,
+        motorHousing: false,
+        slideFraction: 0,
+        slideDirection: 'z',
+        trackWidth: 0.04,
+        motorHousingSize: 0.08,
+    },
+    sliding: {
+        label: 'Sliding skylight',
+        width: 1.4,
+        height: 1.1,
+        frameThickness: 0.055,
+        frameDepth: 0.08,
+        glassThickness: 0.012,
+        curb: true,
+        curbHeight: 0.08,
+        cutoutOffset: 0,
+        lanternHeight: 0.25,
+        lanternTopScale: 0,
+        openingAngle: 0,
+        openingSide: 'top',
+        operationState: 0.35,
+        motorHousing: false,
+        slideFraction: 0.35,
+        slideDirection: 'x',
+        trackWidth: 0.045,
+        motorHousingSize: 0.08,
+    },
+};
+const DEFAULT = SKYLIGHT_TYPE_PRESETS.flat;
+export const SkylightNode = BaseNode.extend({
+    id: objectId('skylight'),
+    type: nodeType('skylight'),
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+    glassMaterial: MaterialSchema.optional(),
+    glassMaterialPreset: z.string().optional(),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    width: z.number().default(DEFAULT.width),
+    height: z.number().default(DEFAULT.height),
+    frameThickness: z.number().default(DEFAULT.frameThickness),
+    frameDepth: z.number().default(DEFAULT.frameDepth),
+    skylightType: SkylightType.default('flat'),
+    glassThickness: z.number().default(DEFAULT.glassThickness),
+    lanternHeight: z.number().default(DEFAULT.lanternHeight),
+    lanternTopScale: z.number().default(DEFAULT.lanternTopScale),
+    openingAngle: z.number().default(DEFAULT.openingAngle),
+    openingSide: SkylightOpeningSide.default(DEFAULT.openingSide),
+    operationState: z.number().min(0).max(1).default(DEFAULT.operationState),
+    motorHousing: z.boolean().default(DEFAULT.motorHousing),
+    slideFraction: z.number().min(0).max(1).default(DEFAULT.slideFraction),
+    slideDirection: SkylightSlideDirection.default(DEFAULT.slideDirection),
+    trackWidth: z.number().default(DEFAULT.trackWidth),
+    motorHousingSize: z.number().default(DEFAULT.motorHousingSize),
+    curb: z.boolean().default(DEFAULT.curb),
+    curbHeight: z.number().default(DEFAULT.curbHeight),
+    cutoutOffset: z.number().default(DEFAULT.cutoutOffset),
+    surfaceNormal: z.tuple([z.number(), z.number(), z.number()]).optional(),
+}).describe(dedent `
+  Skylight — a framed glass opening hosted on a roof segment. Five
+  type variants drive different geometry (flat / walk-on / lantern /
+  opening / sliding) and animation states.
+  `);

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

@@ -20,6 +20,7 @@ export declare const SlabNode: z.ZodObject<{
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -29,7 +30,6 @@ export declare const SlabNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -55,9 +55,11 @@ export declare const SlabNode: z.ZodObject<{
     holeMetadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
         source: z.ZodDefault<z.ZodEnum<{
             stair: "stair";
+            elevator: "elevator";
             manual: "manual";
         }>>;
         stairId: z.ZodOptional<z.ZodString>;
+        elevatorId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBpB,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

@@ -17,7 +17,7 @@ export const SlabNode = BaseNode.extend({
   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
+  - holeMetadata: metadata parallel to holes, used to preserve manual and auto-managed cutouts
   - elevation: elevation in meters
   - autoFromWalls: whether the slab is automatically generated from a closed wall loop
   `);

package/dist/schema/nodes/solar-panel.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+export declare const SolarPanelMaterialRole: z.ZodEnum<{
+    panel: "panel";
+    frame: "frame";
+}>;
+export type SolarPanelMaterialRole = z.infer<typeof SolarPanelMaterialRole>;
+export declare const SolarPanelNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`solarpanel_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"solar-panel">>;
+    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>;
+    panelMaterial: 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>>;
+    panelMaterialPreset: z.ZodOptional<z.ZodString>;
+    panelTypePreset: z.ZodOptional<z.ZodEnum<{
+        residential: "residential";
+        "residential-large": "residential-large";
+        compact: "compact";
+        frameless: "frameless";
+    }>>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    rows: z.ZodDefault<z.ZodNumber>;
+    columns: z.ZodDefault<z.ZodNumber>;
+    panelWidth: z.ZodDefault<z.ZodNumber>;
+    panelHeight: z.ZodDefault<z.ZodNumber>;
+    gapX: z.ZodDefault<z.ZodNumber>;
+    gapY: z.ZodDefault<z.ZodNumber>;
+    mountingType: z.ZodDefault<z.ZodEnum<{
+        flush: "flush";
+        tilted: "tilted";
+    }>>;
+    tiltAngle: z.ZodDefault<z.ZodNumber>;
+    standoffHeight: z.ZodDefault<z.ZodNumber>;
+    frameThickness: z.ZodDefault<z.ZodNumber>;
+    frameDepth: z.ZodDefault<z.ZodNumber>;
+    surfaceNormal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+export type SolarPanelNode = z.infer<typeof SolarPanelNode>;
+//# sourceMappingURL=solar-panel.d.ts.map

package/dist/schema/nodes/solar-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solar-panel.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/solar-panel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;EAA6B,CAAA;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmD1B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/schema/nodes/solar-panel.js

@@ -0,0 +1,47 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { SolarPanelPresetKey } from '../../solar-panel-presets';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const SolarPanelMaterialRole = z.enum(['frame', 'panel']);
+export const SolarPanelNode = BaseNode.extend({
+    id: objectId('solarpanel'),
+    type: nodeType('solar-panel'),
+    // Frame / rail material — aluminum mounting rails.
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+    // Panel surface material — dark photovoltaic glass.
+    panelMaterial: MaterialSchema.optional(),
+    panelMaterialPreset: z.string().optional(),
+    // Visual preset that drove panelWidth / panelHeight / frameThickness /
+    // frameDepth. Cleared whenever any of those four is edited manually.
+    panelTypePreset: SolarPanelPresetKey.optional(),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    // Grid layout.
+    rows: z.number().int().min(1).max(20).default(2),
+    columns: z.number().int().min(1).max(20).default(3),
+    // Individual panel dimensions (meters). Defaults match the 'residential' preset.
+    panelWidth: z.number().default(1.0),
+    panelHeight: z.number().default(1.65),
+    // Gaps between panels.
+    gapX: z.number().default(0.02),
+    gapY: z.number().default(0.02),
+    // Mounting type — flush (flat on the slope) or tilted (angled up).
+    mountingType: z.enum(['flush', 'tilted']).default('flush'),
+    tiltAngle: z.number().default(15),
+    standoffHeight: z.number().default(0.05),
+    // Frame.
+    frameThickness: z.number().default(0.04),
+    frameDepth: z.number().default(0.04),
+    // Surface normal at placement point (segment-local). Captured from a
+    // raycast on the shingle surface during placement / move. Falls back
+    // to the analytical normal in the renderer if absent.
+    surfaceNormal: z.tuple([z.number(), z.number(), z.number()]).optional(),
+}).describe(dedent `
+  Solar panel array — a grid of photovoltaic panels mounted on a roof
+  segment. Position is segment-local (x along width, z along depth);
+  the Y component is captured from the raycast hit on the shingle
+  surface, with an analytical fallback in the renderer when it's 0.
+  `);

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

@@ -31,6 +31,7 @@ export declare const StairSegmentNode: z.ZodObject<{
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -40,7 +41,6 @@ export declare const StairSegmentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type MaterialSchema } from '../material';
+import type { MaterialSchema as MaterialSchemaType } from '../material';
 export declare const StairRailingMode: z.ZodEnum<{
     none: "none";
     left: "left";
@@ -25,7 +25,7 @@ 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;
+    material?: MaterialSchemaType;
     materialPreset?: string;
 };
 export declare const StairNode: z.ZodObject<{
@@ -49,6 +49,7 @@ export declare const StairNode: z.ZodObject<{
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -58,7 +59,6 @@ export declare const StairNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -82,6 +82,7 @@ export declare const StairNode: z.ZodObject<{
     railingMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -91,7 +92,6 @@ export declare const StairNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -115,6 +115,7 @@ export declare const StairNode: z.ZodObject<{
     treadMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -124,7 +125,6 @@ export declare const StairNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -148,6 +148,7 @@ export declare const StairNode: z.ZodObject<{
     sideMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
             white: "white";
             brick: "brick";
             concrete: "concrete";
@@ -157,7 +158,6 @@ export declare const StairNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-            custom: "custom";
         }>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;

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

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

package/dist/schema/nodes/stair.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema as MaterialSchemaSchema } from '../material';
+import { MaterialSchema } from '../material';
 import { StairSegmentNode } from './stair-segment';
 export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
 export const StairType = z.enum(['straight', 'curved', 'spiral']);
@@ -10,13 +10,13 @@ export const StairSlabOpeningMode = z.enum(['none', 'destination']);
 export const StairNode = BaseNode.extend({
     id: objectId('stair'),
     type: nodeType('stair'),
-    material: MaterialSchemaSchema.optional(),
+    material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
-    railingMaterial: MaterialSchemaSchema.optional(),
+    railingMaterial: MaterialSchema.optional(),
     railingMaterialPreset: z.string().optional(),
-    treadMaterial: MaterialSchemaSchema.optional(),
+    treadMaterial: MaterialSchema.optional(),
     treadMaterialPreset: z.string().optional(),
-    sideMaterial: MaterialSchemaSchema.optional(),
+    sideMaterial: MaterialSchema.optional(),
     sideMaterialPreset: z.string().optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
@@ -105,10 +105,12 @@ export function getEffectiveStairSurfaceMaterial(node, role) {
         material: node.sideMaterial,
         materialPreset: typeof node.sideMaterialPreset === 'string' ? node.sideMaterialPreset : undefined,
     };
-    if (role === 'tread' && (sideFallback.material !== undefined || sideFallback.materialPreset !== undefined)) {
+    if (role === 'tread' &&
+        (sideFallback.material !== undefined || sideFallback.materialPreset !== undefined)) {
         return sideFallback;
     }
-    if (role === 'side' && (treadFallback.material !== undefined || treadFallback.materialPreset !== undefined)) {
+    if (role === 'side' &&
+        (treadFallback.material !== undefined || treadFallback.materialPreset !== undefined)) {
         return treadFallback;
     }
     if (role === 'railing') {

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

@@ -2,9 +2,11 @@ import { z } from 'zod';
 export declare const SurfaceHoleMetadata: z.ZodObject<{
     source: z.ZodDefault<z.ZodEnum<{
         stair: "stair";
+        elevator: "elevator";
         manual: "manual";
     }>>;
     stairId: z.ZodOptional<z.ZodString>;
+    elevatorId: 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

@@ -1 +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"}
+{"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;;;;;;;;iBAK9B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export const SurfaceHoleMetadata = z.object({
-    source: z.enum(['manual', 'stair']).default('manual'),
+    // Stair/elevator auto-openings use stairId/elevatorId so sync can replace only its own holes.
+    source: z.enum(['manual', 'stair', 'elevator']).default('manual'),
     stairId: z.string().optional(),
+    elevatorId: z.string().optional(),
 });

package/dist/schema/nodes/turbine-vent.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export declare const TurbineVentNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`tvent_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"turbine-vent">>;
+    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.ZodDefault<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    neckHeight: z.ZodDefault<z.ZodNumber>;
+    baseOverhang: z.ZodDefault<z.ZodNumber>;
+    vaneCount: z.ZodDefault<z.ZodNumber>;
+    spinSpeed: z.ZodDefault<z.ZodNumber>;
+    style: z.ZodDefault<z.ZodEnum<{
+        globe: "globe";
+        cylinder: "cylinder";
+    }>>;
+}, z.core.$strip>;
+export type TurbineVentNode = z.infer<typeof TurbineVentNode>;
+//# sourceMappingURL=turbine-vent.d.ts.map

package/dist/schema/nodes/turbine-vent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turbine-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/turbine-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0C3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/schema/nodes/turbine-vent.js

@@ -0,0 +1,41 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const TurbineVentNode = BaseNode.extend({
+    id: objectId('tvent'),
+    type: nodeType('turbine-vent'),
+    material: MaterialSchema.optional(),
+    // Default to the white preset so a freshly-placed turbine reads as
+    // clean painted/galvanised metal and the paint inspector shows "White"
+    // as the current selection (matches box-vent's reasoning).
+    materialPreset: z.string().default('preset-white'),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    // Overall diameter of the spinning head at its widest point.
+    diameter: z.number().default(0.32),
+    // Total height from the flange base to the top knob.
+    height: z.number().default(0.42),
+    // Height of the throat cylinder between the flange and the head. The
+    // head occupies the remaining `height - neckHeight`.
+    neckHeight: z.number().default(0.09),
+    // How far the flange flashing flares past the throat on every side.
+    baseOverhang: z.number().default(0.05),
+    // Number of curved vanes around the head. More vanes read denser /
+    // finer; fewer read as a chunkier industrial turbine.
+    vaneCount: z.number().int().default(20),
+    // Idle spin speed in radians/second. 0 = static (the head holds still),
+    // which is the default — a newly-placed turbine starts paused and is set
+    // spinning via the panel's Play toggle or the Spin Speed slider. Driven by
+    // the renderer's `useFrame`, not stored per-frame.
+    spinSpeed: z.number().default(0),
+    // `globe`   → classic spherical whirlybird (bulged barrel + domed top)
+    // `cylinder`→ straight-barrel turbine with a flat disc top
+    style: z.enum(['globe', 'cylinder']).default('globe'),
+}).describe(dedent `
+  Turbine vent (whirlybird) — a wind-driven spinning exhaust vent that
+  sits on a roof slope. A finned head spins on a throat above a flange.
+  Parented to a roof-segment; position is segment-local. Rotation is
+  around the segment's vertical axis (post-slope tilt).
+  `);