@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/door/definition.d.ts

@@ -1,23 +1,351 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { DoorNode } from './schema.js';
-/**
- * Door — Phase 5 batch kind. Hosted on walls, cuts holes in them,
- * animated open/close state.
- *
- * Capabilities:
- *  - **No `movable`**: door's move is bespoke wall-bound drag (slide
- *    along the wall, snap to wall start/end). Capability-driven dispatch
- *    keeps legacy `MoveDoorTool`.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Stages:
- *  - A: registered.
- *  - B: deferred — door geometry (frame / leaf / glass / hardware /
- *    segments) is ~800 lines in DoorSystem; extraction is a focused
- *    session. `def.renderer` (wrap-export of legacy DoorRenderer) +
- *    `def.system` (DoorSystem + DoorAnimationSystem bundle) hold parity.
- *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
- *    `openingPolygons` short-circuits door entries when registered.
- */
-export declare const doorDefinition: NodeDefinition<typeof DoorNode>;
+export declare const doorDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`door_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"door">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    source: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"script">;
+        meta: import("zod").ZodOptional<import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            parent: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        language: import("zod").ZodDefault<import("zod").ZodEnum<{
+            bpy: "bpy";
+            three: "three";
+        }>>;
+        script: import("zod").ZodString;
+        params: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>>;
+        artifact: import("zod").ZodString;
+        manifest: import("zod").ZodObject<{
+            bounds: import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>;
+            params: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                kind: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>;
+                default: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>;
+                min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                step: import("zod").ZodOptional<import("zod").ZodNumber>;
+                unit: import("zod").ZodOptional<import("zod").ZodString>;
+                options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>>;
+            parts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                type: import("zod").ZodOptional<import("zod").ZodString>;
+                bounds: import("zod").ZodOptional<import("zod").ZodObject<{
+                    min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            surfaces: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                y: import("zod").ZodNumber;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            slots: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                color: import("zod").ZodOptional<import("zod").ZodString>;
+                roughness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                metalness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                transparent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                emissive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>>;
+            anchors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                normal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            lights: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                color: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+                distance: import("zod").ZodOptional<import("zod").ZodNumber>;
+                spot: import("zod").ZodOptional<import("zod").ZodObject<{
+                    direction: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    angle: import("zod").ZodNumber;
+                    softness: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>;
+                shadows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                glow: import("zod").ZodOptional<import("zod").ZodObject<{
+                    size: import("zod").ZodNumber;
+                    strength: import("zod").ZodDefault<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            undersides: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                plane: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+            animations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                duration: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                host: import("zod").ZodEnum<{
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                    slab: "slab";
+                    wall: "wall";
+                }>;
+                polygon: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>;
+                minY: import("zod").ZodNumber;
+                maxY: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutout: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            collider: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            shape: import("zod").ZodOptional<import("zod").ZodObject<{
+                tolerance: import("zod").ZodNumber;
+                bands: import("zod").ZodArray<import("zod").ZodObject<{
+                    y0: import("zod").ZodNumber;
+                    y1: import("zod").ZodNumber;
+                    polygons: import("zod").ZodArray<import("zod").ZodObject<{
+                        outer: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                        holes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            triangles: import("zod").ZodNumber;
+            coverage: import("zod").ZodOptional<import("zod").ZodNumber>;
+            uncovered: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>;
+        images: import("zod").ZodOptional<import("zod").ZodObject<{
+            artifact: import("zod").ZodString;
+            thumbnail: import("zod").ZodString;
+            floorPlan: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    side: import("zod").ZodOptional<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+    }>>;
+    verticalAnchor: import("zod").ZodOptional<import("zod").ZodEnum<{
+        floor: "floor";
+        wall: "wall";
+    }>>;
+    floorThresholdVersion: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>]>>;
+    wallId: import("zod").ZodOptional<import("zod").ZodString>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    roofFace: import("zod").ZodOptional<import("zod").ZodEnum<{
+        back: "back";
+        front: "front";
+        left: "left";
+        right: "right";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    sidelightLeft: import("zod").ZodOptional<import("zod").ZodNumber>;
+    sidelightRight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    transomHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    slidingStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        bypass: "bypass";
+        patio: "patio";
+    }>>;
+    mark: import("zod").ZodOptional<import("zod").ZodString>;
+    constructionType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        framed: "framed";
+        masonry: "masonry";
+    }>>;
+    dimensionReference: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "finish-opening": "finish-opening";
+        "masonry-opening": "masonry-opening";
+        nominal: "nominal";
+        "rough-opening": "rough-opening";
+    }>>;
+    roughOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    roughOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    masonryOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    masonryOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    finishOpeningWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    finishOpeningHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    doorCategory: import("zod").ZodDefault<import("zod").ZodEnum<{
+        garage: "garage";
+        interior: "interior";
+    }>>;
+    doorType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        barn: "barn";
+        double: "double";
+        folding: "folding";
+        french: "french";
+        "garage-rollup": "garage-rollup";
+        "garage-sectional": "garage-sectional";
+        "garage-tiltup": "garage-tiltup";
+        hinged: "hinged";
+        pocket: "pocket";
+        sliding: "sliding";
+    }>>;
+    leafCount: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>, import("zod").ZodLiteral<4>, import("zod").ZodLiteral<6>, import("zod").ZodLiteral<8>]>>;
+    operationState: import("zod").ZodDefault<import("zod").ZodNumber>;
+    slideDirection: import("zod").ZodDefault<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    trackStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        none: "none";
+        overhead: "overhead";
+        pocket: "pocket";
+        visible: "visible";
+    }>>;
+    garagePanelCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    openingKind: import("zod").ZodDefault<import("zod").ZodEnum<{
+        door: "door";
+        opening: "opening";
+    }>>;
+    openingShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        arch: "arch";
+        rectangle: "rectangle";
+        rounded: "rounded";
+    }>>;
+    openingRadiusMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingTopRadii: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    cornerRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    archHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    openingRevealRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    threshold: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    thresholdHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    casingFaceA: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    casingFaceB: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    casingWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hingesSide: import("zod").ZodDefault<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swingDirection: import("zod").ZodDefault<import("zod").ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    swingAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    segments: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            empty: "empty";
+            glass: "glass";
+            panel: "panel";
+        }>;
+        heightRatio: import("zod").ZodNumber;
+        columnRatios: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodNumber>>;
+        dividerThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+        panelDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+        panelInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>>;
+    handle: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    handleStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        bar: "bar";
+        knob: "knob";
+        lever: "lever";
+        "lever-curved": "lever-curved";
+        plate: "plate";
+    }>>;
+    handleHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    handleSide: import("zod").ZodDefault<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    contentPadding: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    doorCloser: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    panicBar: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    panicBarStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        crossbar: "crossbar";
+        touchbar: "touchbar";
+    }>>;
+    panicBarRods: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    panicBarHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/door/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AA4BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA8KnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAiJ1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

package/dist/door/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { DoorNode } from './schema.js';
+export declare const doorEditContribution: NodeEditContribution<typeof DoorNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/door/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/door/definition.edit.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAiBvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAiMxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAuDtE,CAAA"}

package/dist/door/definition.edit.js

@@ -0,0 +1,241 @@
+import { getDoorOpeningSize } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
+import { buildDoorFloorplanSchedule } from '../shared/opening-documentation.js';
+import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime.js';
+import { createOpeningPropertyPreview } from '../shared/opening-property-preview.js';
+import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host.js';
+import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host.js';
+import { scriptedOpeningHandles } from '../shared/scripted-opening-handles.js';
+import { readHostWallCeiling, readHostWallCeilingMaxWidth } from '../shared/wall-opening-ceiling.js';
+import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides.js';
+import { buildDoorContextualDimensions } from './contextual-dimensions.js';
+import { scaleHandleHeight } from './door-math.js';
+import { doorWidthAffordance } from './floorplan-affordances.js';
+import { doorFloorplanMoveTarget } from './floorplan-move.js';
+import { doorPaint } from './paint.js';
+import { doorParametrics } from './parametrics.js';
+import { DOOR_PLACEMENT_HINTS } from './placement.js';
+const SIDE_HANDLE_OFFSET = 0.24;
+const HEIGHT_HANDLE_OFFSET = 0.24;
+const MIN_DOOR_HEIGHT = 0.5;
+const MIN_DOOR_WIDTH = 0.3;
+// How far the move cross floats off the wall face (+Z, the door's facing
+// normal) so it's grabbable instead of buried in the leaf/frame.
+const MOVE_HANDLE_LIFT = 0.12;
+function readWallLength(door, scene) {
+    const hostId = door.wallId || door.parentId;
+    if (!hostId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(hostId);
+    if (wall?.type !== 'wall' || !wall.start || !wall.end)
+        return Number.POSITIVE_INFINITY;
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+// Width arrow on the door-local +X (right) or -X (left) side. Drag grows
+// the door from the anchored OPPOSITE edge; the door's wall-local center
+// re-centers so the anchored edge stays put.
+function doorWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
+        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_DOOR_WIDTH,
+        max: (n, scene) => {
+            // Roof-hosted doors clamp against the face profile.
+            const roofMax = readRoofFaceWidthMax(n, scene, sign);
+            if (roofMax !== null)
+                return Math.max(MIN_DOOR_WIDTH, roofMax);
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'x', sign);
+            if (curtainMax !== undefined)
+                return curtainMax;
+            const lengthMax = readWallLength(n, scene) - (getDoorOpeningSize(n).width - n.width);
+            // rotation[1] = π flips the door, so its visual right edge moves toward lower wall-local S.
+            const growSign = sign * Math.cos(n.rotation[1]) > 0 ? 1 : -1;
+            const fixedEdgeS = n.position[0] - (growSign * n.width) / 2;
+            const topY = n.position[1] - n.height / 2 + getDoorOpeningSize(n).height;
+            return Math.max(MIN_DOOR_WIDTH, readHostWallCeilingMaxWidth(n.wallId || n.parentId, scene, fixedEdgeS, growSign, topY, lengthMax, n));
+        },
+        currentValue: (n) => n.width,
+        onDrag: (node) => publishOpeningResizeGuides(node, false),
+        apply: (initial, newWidth) => {
+            // Anchored edge stays fixed in wall-local coords. Door rotation is
+            // applied by the inner ride group (the renderer mounts a nested
+            // <group> at the door's pose), so the apply math here is in
+            // door-local coords AND the patch.position must be in wall-local
+            // coords. We compute the anchored wall-local point from the
+            // initial node, then derive the new wall-local center from it.
+            const rotY = initial.rotation[1];
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: newWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            // door-local: +X axis lives along door's own X. Inner ride group
+            // applies door.rotation, so we sit purely on door-local +X / -X.
+            position: (n) => [
+                -getDoorOpeningSize(n).leafOffsetX +
+                    sign * (getDoorOpeningSize(n).width / 2 + SIDE_HANDLE_OFFSET),
+                0,
+                0,
+            ],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+function doorHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min', // bottom anchored at wall-local Y = position[1] - height/2
+        min: MIN_DOOR_HEIGHT,
+        max: (n, scene) => {
+            const roofMax = readRoofFaceHeightMax(n, scene, 1);
+            if (roofMax !== null)
+                return Math.max(MIN_DOOR_HEIGHT, roofMax);
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', 1);
+            if (curtainMax !== undefined)
+                return curtainMax;
+            const bottom = n.position[1] - n.height / 2;
+            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId || n.parentId, scene, n) -
+                bottom -
+                (getDoorOpeningSize(n).height - n.height));
+        },
+        currentValue: (n) => n.height,
+        onDrag: (node) => publishOpeningResizeGuides(node, true),
+        apply: (initial, newHeight) => {
+            const bottom = initial.position[1] - initial.height / 2;
+            // Scale the handle so it tracks the door instead of staying glued to a
+            // fixed floor height (shared with the panel's Height slider).
+            return {
+                height: newHeight,
+                position: [initial.position[0], bottom + newHeight / 2, initial.position[2]],
+                handleHeight: scaleHandleHeight(initial.handleHeight, initial.height, newHeight),
+            };
+        },
+        placement: {
+            position: (n) => [0, getDoorOpeningSize(n).height - n.height / 2 + HEIGHT_HANDLE_OFFSET, 0],
+        },
+        portal: 'grandparent',
+    };
+}
+// Press-drag move grip at the door centre, standing in the wall face. Routes
+// through the same move tool as the floating Move button (3D
+// `affordanceTools.move`, 2D `floorplanMoveTarget`) — wall slide + re-host onto
+// another wall — but `engageMoveDrag` commits on release, with no second click.
+function doorMoveHandle() {
+    return {
+        kind: 'tap-action',
+        shape: 'move-cross',
+        plane: 'node-normal',
+        portal: 'grandparent',
+        cursor: 'move',
+        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
+        placement: {
+            position: () => [0, 0, MOVE_HANDLE_LIFT],
+        },
+    };
+}
+function doorRadiusHandle(index) {
+    const sign = index === 0 ? -1 : 1;
+    return {
+        kind: 'corner-radius',
+        corner: [sign, 1],
+        width: (node) => node.width,
+        height: (node) => node.height,
+        currentValue: (node) => node.openingRadiusMode === 'individual'
+            ? (node.openingTopRadii[index] ?? 0)
+            : node.cornerRadius,
+        max: (node) => Math.min(node.width / 2, node.height),
+        apply: (node, radius, _scene, modifiers) => {
+            if (!modifiers.shiftKey) {
+                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
+            }
+            const radii = node.openingRadiusMode === 'individual'
+                ? [...node.openingTopRadii]
+                : [node.cornerRadius, node.cornerRadius];
+            radii[index] = radius;
+            return {
+                openingShape: 'rounded',
+                openingRadiusMode: 'individual',
+                openingTopRadii: radii,
+            };
+        },
+        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
+        visible: (node) => node.openingShape !== 'arch',
+        portal: 'grandparent',
+    };
+}
+const doorHandles = [
+    doorMoveHandle(),
+    doorWidthHandle('left'),
+    doorWidthHandle('right'),
+    doorHeightHandle(),
+    doorRadiusHandle(0),
+    doorRadiusHandle(1),
+];
+export const doorEditContribution = {
+    snapProfile: 'item',
+    facingIndicator: true,
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildDoorContextualDimensions,
+            schedule: buildDoorFloorplanSchedule,
+            // Swap hinge / swing side from the action bar, in 2D and 3D.
+            actionMenu: { actions: () => import('./actions.js') },
+        },
+    },
+    capabilities: {
+        paint: doorPaint,
+    },
+    parametrics: doorParametrics,
+    handles: (node) => node.source
+        ? [doorMoveHandle(), ...scriptedOpeningHandles(node, doorWidthHandle, doorHeightHandle)]
+        : doorHandles,
+    preview: () => import('./preview.js'),
+    floorplanDependsOnSiblings: true,
+    // Opening symbols position from `ctx.parent` (the host wall); merge the
+    // walls' live drag overrides so the symbol tracks a wall / group drag in
+    // realtime instead of jumping on commit.
+    floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
+    // Stage D — placement (`def.tool`) + move-on-wall (`def.
+    // affordanceTools.move`). Both ports of the legacy tools at
+    // `editor/components/tools/door/`, relocated into the kind folder and
+    // wired through ToolManager's registry-first dispatch (`def.tool` for
+    // build-mode placement, `getRegistryAffordanceTool` for the move-on-
+    // pick flow). Same legacy semantics: wall-event-driven snap, clamped
+    // wall-local coords, hasWallChildOverlap guard, live mesh updates.
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    // 2D move-on-floorplan handler. When `useEditor.movingNode` is a
+    // door and the floor plan is active, `FloorplanRegistryMoveOverlay`
+    // dispatches to this instead of the generic translate path — pointer
+    // snaps to the nearest wall, projects onto the wall axis, snaps
+    // local-X to 0.5m, clamps inside wall bounds.
+    floorplanMoveTarget: doorFloorplanMoveTarget,
+    // 2D drag affordances. `resize-width` drives the door's two side
+    // arrows — pointer-down on either arrow starts an anchored width drag
+    // (opposite edge stays fixed, clamped to wall bounds).
+    floorplanAffordances: {
+        'resize-width': doorWidthAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place door on wall' },
+        ...DOOR_PLACEMENT_HINTS,
+        { key: 'R', label: 'Flip side' },
+        { key: 'Alt', label: 'Force place' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};