@pascal-app/core 1.0.3 → 1.0.5

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

@@ -1,8 +1,9 @@
 import { z } from 'zod';
+export { DoorType } from './opening-types.js';
 export declare const DoorSegment: z.ZodObject<{
     type: z.ZodEnum<{
-        glass: "glass";
         empty: "empty";
+        glass: "glass";
         panel: "panel";
     }>;
     heightRatio: z.ZodNumber;
@@ -12,42 +13,31 @@ export declare const DoorSegment: z.ZodObject<{
     panelInset: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type DoorSegment = z.infer<typeof DoorSegment>;
+/** Glazed leaves over a low panel: the French door (porte-fenêtre) glazing. */
+export declare const FRENCH_DOOR_SEGMENTS: DoorSegment[];
 export declare const DoorCategory: z.ZodEnum<{
-    interior: "interior";
     garage: "garage";
+    interior: "interior";
 }>;
 export declare const OpeningConstructionType: z.ZodEnum<{
     framed: "framed";
     masonry: "masonry";
 }>;
 export declare const OpeningDimensionReference: z.ZodEnum<{
+    "finish-opening": "finish-opening";
+    "masonry-opening": "masonry-opening";
     nominal: "nominal";
     "rough-opening": "rough-opening";
-    "masonry-opening": "masonry-opening";
-    "finish-opening": "finish-opening";
-}>;
-export declare const DoorType: z.ZodEnum<{
-    double: "double";
-    hinged: "hinged";
-    french: "french";
-    folding: "folding";
-    pocket: "pocket";
-    barn: "barn";
-    sliding: "sliding";
-    "garage-sectional": "garage-sectional";
-    "garage-rollup": "garage-rollup";
-    "garage-tiltup": "garage-tiltup";
 }>;
 export declare const DoorTrackStyle: z.ZodEnum<{
-    visible: "visible";
     none: "none";
-    pocket: "pocket";
     overhead: "overhead";
+    pocket: "pocket";
+    visible: "visible";
 }>;
 export type DoorCategory = z.infer<typeof DoorCategory>;
 export type OpeningConstructionType = z.infer<typeof OpeningConstructionType>;
 export type OpeningDimensionReference = z.infer<typeof OpeningDimensionReference>;
-export type DoorType = z.infer<typeof DoorType>;
 export type DoorTrackStyle = z.infer<typeof DoorTrackStyle>;
 export declare const DoorNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -58,28 +48,54 @@ export declare const DoorNode: 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";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`door_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"door">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -88,9 +104,9 @@ export declare const DoorNode: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{
@@ -100,19 +116,129 @@ export declare const DoorNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"script">;
+        meta: z.ZodOptional<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            parent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        language: z.ZodDefault<z.ZodEnum<{
+            bpy: "bpy";
+            three: "three";
+        }>>;
+        script: z.ZodString;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        artifact: z.ZodString;
+        manifest: z.ZodObject<{
+            bounds: z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>;
+            params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>;
+                default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                step: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                bounds: z.ZodOptional<z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                y: z.ZodNumber;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                roughness: z.ZodOptional<z.ZodNumber>;
+                metalness: z.ZodOptional<z.ZodNumber>;
+                transparent: z.ZodOptional<z.ZodBoolean>;
+                emissive: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                color: z.ZodString;
+                intensity: z.ZodNumber;
+                distance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>>;
+            animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                duration: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                host: z.ZodEnum<{
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                    slab: "slab";
+                    wall: "wall";
+                }>;
+                polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                minY: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutout: z.ZodDefault<z.ZodBoolean>;
+            collider: z.ZodDefault<z.ZodBoolean>;
+            triangles: z.ZodNumber;
+            coverage: z.ZodOptional<z.ZodNumber>;
+            uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        images: z.ZodOptional<z.ZodObject<{
+            artifact: z.ZodString;
+            thumbnail: z.ZodString;
+            floorPlan: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
-        front: "front";
         back: "back";
+        front: "front";
+    }>>;
+    verticalAnchor: z.ZodOptional<z.ZodEnum<{
+        floor: "floor";
+        wall: "wall";
     }>>;
+    floorThresholdVersion: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
     wallId: z.ZodOptional<z.ZodString>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     roofFace: z.ZodOptional<z.ZodEnum<{
-        front: "front";
         back: "back";
-        right: "right";
+        front: "front";
         left: "left";
+        right: "right";
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
@@ -122,10 +248,10 @@ export declare const DoorNode: z.ZodObject<{
         masonry: "masonry";
     }>>;
     dimensionReference: z.ZodDefault<z.ZodEnum<{
+        "finish-opening": "finish-opening";
+        "masonry-opening": "masonry-opening";
         nominal: "nominal";
         "rough-opening": "rough-opening";
-        "masonry-opening": "masonry-opening";
-        "finish-opening": "finish-opening";
     }>>;
     roughOpeningWidth: z.ZodOptional<z.ZodNumber>;
     roughOpeningHeight: z.ZodOptional<z.ZodNumber>;
@@ -134,32 +260,32 @@ export declare const DoorNode: z.ZodObject<{
     finishOpeningWidth: z.ZodOptional<z.ZodNumber>;
     finishOpeningHeight: z.ZodOptional<z.ZodNumber>;
     doorCategory: z.ZodDefault<z.ZodEnum<{
-        interior: "interior";
         garage: "garage";
+        interior: "interior";
     }>>;
     doorType: z.ZodDefault<z.ZodEnum<{
+        barn: "barn";
         double: "double";
-        hinged: "hinged";
-        french: "french";
         folding: "folding";
-        pocket: "pocket";
-        barn: "barn";
-        sliding: "sliding";
-        "garage-sectional": "garage-sectional";
+        french: "french";
         "garage-rollup": "garage-rollup";
+        "garage-sectional": "garage-sectional";
         "garage-tiltup": "garage-tiltup";
+        hinged: "hinged";
+        pocket: "pocket";
+        sliding: "sliding";
     }>>;
     leafCount: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
     operationState: z.ZodDefault<z.ZodNumber>;
     slideDirection: z.ZodDefault<z.ZodEnum<{
-        right: "right";
         left: "left";
+        right: "right";
     }>>;
     trackStyle: z.ZodDefault<z.ZodEnum<{
-        visible: "visible";
         none: "none";
-        pocket: "pocket";
         overhead: "overhead";
+        pocket: "pocket";
+        visible: "visible";
     }>>;
     garagePanelCount: z.ZodDefault<z.ZodNumber>;
     openingKind: z.ZodDefault<z.ZodEnum<{
@@ -167,9 +293,9 @@ export declare const DoorNode: z.ZodObject<{
         opening: "opening";
     }>>;
     openingShape: z.ZodDefault<z.ZodEnum<{
+        arch: "arch";
         rectangle: "rectangle";
         rounded: "rounded";
-        arch: "arch";
     }>>;
     openingRadiusMode: z.ZodDefault<z.ZodEnum<{
         all: "all";
@@ -184,8 +310,8 @@ export declare const DoorNode: z.ZodObject<{
     threshold: z.ZodDefault<z.ZodBoolean>;
     thresholdHeight: z.ZodDefault<z.ZodNumber>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        right: "right";
         left: "left";
+        right: "right";
     }>>;
     swingDirection: z.ZodDefault<z.ZodEnum<{
         inward: "inward";
@@ -194,8 +320,8 @@ export declare const DoorNode: z.ZodObject<{
     swingAngle: z.ZodDefault<z.ZodNumber>;
     segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
-            glass: "glass";
             empty: "empty";
+            glass: "glass";
             panel: "panel";
         }>;
         heightRatio: z.ZodNumber;
@@ -207,8 +333,8 @@ export declare const DoorNode: z.ZodObject<{
     handle: z.ZodDefault<z.ZodBoolean>;
     handleHeight: z.ZodDefault<z.ZodNumber>;
     handleSide: z.ZodDefault<z.ZodEnum<{
-        right: "right";
         left: "left";
+        right: "right";
     }>>;
     contentPadding: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     doorCloser: z.ZodDefault<z.ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,YAAY;;;EAAiC,CAAA;AAC1D,eAAO,MAAM,uBAAuB;;;EAAgC,CAAA;AACpE,eAAO,MAAM,yBAAyB;;;;;EAKpC,CAAA;AACF,eAAO,MAAM,QAAQ;;;;;;;;;;;EAWnB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;EAAoD,CAAA;AAE/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACjF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE1C,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,EAAE,WAAW,EAiB7C,CAAA;AAED,eAAO,MAAM,YAAY;;;EAAiC,CAAA;AAC1D,eAAO,MAAM,uBAAuB;;;EAAgC,CAAA;AACpE,eAAO,MAAM,yBAAyB;;;;;EAKpC,CAAA;AACF,eAAO,MAAM,cAAc;;;;;EAAoD,CAAA;AAE/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACjF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2GnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/door.js

@@ -1,7 +1,10 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { GeometryScriptSource } from '../geometry-source.js';
 import { MaterialSchema } from '../material.js';
+import { DEFAULT_DOOR_CONTENT_PADDING, DoorType, defaultDoorSegments } from './opening-types.js';
+export { DoorType } from './opening-types.js';
 export const DoorSegment = z.object({
     type: z.enum(['panel', 'glass', 'empty']),
     heightRatio: z.number(),
@@ -12,6 +15,25 @@ export const DoorSegment = z.object({
     panelDepth: z.number().default(0.01), // + raised, - recessed
     panelInset: z.number().default(0.04),
 });
+/** Glazed leaves over a low panel: the French door (porte-fenêtre) glazing. */
+export const FRENCH_DOOR_SEGMENTS = [
+    {
+        type: 'glass',
+        heightRatio: 0.76,
+        columnRatios: [1, 1],
+        dividerThickness: 0.025,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+    {
+        type: 'panel',
+        heightRatio: 0.24,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.012,
+        panelInset: 0.035,
+    },
+];
 export const DoorCategory = z.enum(['interior', 'garage']);
 export const OpeningConstructionType = z.enum(['framed', 'masonry']);
 export const OpeningDimensionReference = z.enum([
@@ -20,30 +42,27 @@ export const OpeningDimensionReference = z.enum([
     'masonry-opening',
     'finish-opening',
 ]);
-export const DoorType = z.enum([
-    'hinged',
-    'double',
-    'french',
-    'folding',
-    'pocket',
-    'barn',
-    'sliding',
-    'garage-sectional',
-    'garage-rollup',
-    'garage-tiltup',
-]);
 export const DoorTrackStyle = z.enum(['none', 'visible', 'pocket', 'overhead']);
 export const DoorNode = BaseNode.extend({
     id: objectId('door'),
     type: nodeType('door'),
     material: MaterialSchema.optional(),
     // Per-slot material overrides on the unified slot model. Keys: `panel` (the
-    // door body), `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`).
-    // Absent = the body/glass default. Mirrors `ShelfNode.slots`.
+    // door body), `frame`, `glass`, `hardware`. Value = a `MaterialRef`
+    // (`library:<id>` / `scene:<id>`) or a plain `#rrggbb` colour. Absent = the
+    // door-wide `material` on panel and frame, else the slot default. Mirrors
+    // `ShelfNode.slots`.
     slots: z.record(z.string(), z.string()).optional(),
+    /**
+     * A three.js script the door is built from instead of its parametric frame, as on an item:
+     * width and height are the compiled bounds and the wall cuts the script's `cutout` mesh.
+     */
+    source: GeometryScriptSource.optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     side: z.enum(['front', 'back']).optional(),
+    verticalAnchor: z.enum(['wall', 'floor']).optional(),
+    floorThresholdVersion: z.union([z.literal(0), z.literal(1)]).default(1),
     wallId: z.string().optional(),
     // Alternative host: a roof-segment's generated wall face (base wall
     // under the roof or a coplanar gable end). When set, `position` is
@@ -99,30 +118,15 @@ export const DoorNode = BaseNode.extend({
         .max(Math.PI / 2)
         .default(0),
     // Leaf segments — stacked top to bottom, each with its own column split
-    segments: z.array(DoorSegment).default([
-        {
-            type: 'panel',
-            heightRatio: 0.4,
-            columnRatios: [1],
-            dividerThickness: 0.03,
-            panelDepth: 0.01,
-            panelInset: 0.04,
-        },
-        {
-            type: 'panel',
-            heightRatio: 0.6,
-            columnRatios: [1],
-            dividerThickness: 0.03,
-            panelDepth: 0.01,
-            panelInset: 0.04,
-        },
-    ]),
+    segments: z.array(DoorSegment).default(defaultDoorSegments),
     // Handle
     handle: z.boolean().default(true),
     handleHeight: z.number().default(1.05),
     handleSide: z.enum(['left', 'right']).default('right'),
     // Leaf inner margin — space between leaf edge and segment content area [x, y]
-    contentPadding: z.tuple([z.number(), z.number()]).default([0.04, 0.04]),
+    contentPadding: z
+        .tuple([z.number(), z.number()])
+        .default(() => [...DEFAULT_DOOR_CONTENT_PADDING]),
     // Emergency / commercial hardware
     doorCloser: z.boolean().default(false),
     panicBar: z.boolean().default(false),