@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof/definition.d.ts

@@ -1,9 +1,326 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { RoofNode } from './schema.js';
-/**
- * Roof is a composite node with `roof-segment` children that own the
- * per-segment geometry. Its floor-plan contribution merges those child
- * footprints so a multi-segment roof reads as one shape.
- */
-export declare const roofDefinition: NodeDefinition<typeof RoofNode>;
+export declare const roofDefinition: 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<`roof_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"roof">>;
+    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>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    topMaterial: 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>>;
+    topMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    edgeMaterial: 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>>;
+    edgeMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    wallMaterial: 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>>;
+    wallMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    heelMaterial: 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>>;
+    heelMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    support: import("zod").ZodDefault<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"level">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"walls">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"roof">;
+        roofSegmentId: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`rseg_${string}`>>;
+        localPosition: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        curbHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>], "kind">>;
+    assembly: import("zod").ZodOptional<import("zod").ZodObject<{
+        layers: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            role: import("zod").ZodEnum<{
+                air: "air";
+                covering: "covering";
+                deck: "deck";
+                fill: "fill";
+                finish: "finish";
+                furring: "furring";
+                glazing: "glazing";
+                insulation: "insulation";
+                lining: "lining";
+                membrane: "membrane";
+                sheathing: "sheathing";
+                shell: "shell";
+                structure: "structure";
+                substrate: "substrate";
+                underlay: "underlay";
+            }>;
+            thickness: import("zod").ZodNumber;
+            core: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+            material: import("zod").ZodOptional<import("zod").ZodString>;
+            slot: import("zod").ZodOptional<import("zod").ZodString>;
+            returns: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            display: import("zod").ZodOptional<import("zod").ZodEnum<{
+                construction: "construction";
+                finished: "finished";
+            }>>;
+            inset: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bottom: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lift: import("zod").ZodOptional<import("zod").ZodNumber>;
+            src: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        backing: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            role: import("zod").ZodEnum<{
+                air: "air";
+                covering: "covering";
+                deck: "deck";
+                fill: "fill";
+                finish: "finish";
+                furring: "furring";
+                glazing: "glazing";
+                insulation: "insulation";
+                lining: "lining";
+                membrane: "membrane";
+                sheathing: "sheathing";
+                shell: "shell";
+                structure: "structure";
+                substrate: "substrate";
+                underlay: "underlay";
+            }>;
+            thickness: import("zod").ZodNumber;
+            core: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+            material: import("zod").ZodOptional<import("zod").ZodString>;
+            slot: import("zod").ZodOptional<import("zod").ZodString>;
+            returns: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            display: import("zod").ZodOptional<import("zod").ZodEnum<{
+                construction: "construction";
+                finished: "finished";
+            }>>;
+            inset: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bottom: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lift: import("zod").ZodOptional<import("zod").ZodNumber>;
+            src: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>>;
+        face: import("zod").ZodOptional<import("zod").ZodEnum<{
+            exterior: "exterior";
+            front: "front";
+        }>>;
+        presetId: import("zod").ZodOptional<import("zod").ZodString>;
+        cavityInsulation: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`rseg_${string}`>>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA6K1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/roof/definition.edit.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAgBvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqFxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAyGtE,CAAA"}

package/dist/roof/definition.edit.js

@@ -0,0 +1,183 @@
+import { DRAFTING_SURFACE_EXTENSION_KEY, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
+import { MIN_ROOF_FOOTPRINT } from './definition.render.js';
+import { buildRoofFloorplan } from './floorplan.js';
+import { roofFloorplanAffectedIds, roofFloorplanSiblingOverrides } from './floorplan-overrides.js';
+import { roofPaint } from './paint.js';
+import { roofPanelModel } from './panel-model.js';
+import { roofParametrics } from './parametrics.js';
+import useRoofFootprintSource, { irregularRoomHintVisibility, noRoomHintVisibility, } from './roof-footprint-source.js';
+import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode.js';
+import useRoofRidgeMode from './roof-ridge-mode.js';
+const MOVE_FRONT_OFFSET = 0.35;
+function getRoofFootprintBounds(node, sceneApi) {
+    let bounds = null;
+    for (const childId of node.children ?? []) {
+        const segment = sceneApi.get(childId);
+        if (segment?.type !== 'roof-segment')
+            continue;
+        const halfWidth = Math.max(segment.width, MIN_ROOF_FOOTPRINT) / 2;
+        const halfDepth = Math.max(segment.depth, MIN_ROOF_FOOTPRINT) / 2;
+        const cos = Math.cos(segment.rotation ?? 0);
+        const sin = Math.sin(segment.rotation ?? 0);
+        const corners = [
+            [-halfWidth, -halfDepth],
+            [halfWidth, -halfDepth],
+            [halfWidth, halfDepth],
+            [-halfWidth, halfDepth],
+        ];
+        for (const [x, z] of corners) {
+            const localX = segment.position[0] + x * cos + z * sin;
+            const localZ = segment.position[2] - x * sin + z * cos;
+            bounds =
+                bounds === null
+                    ? { maxX: localX, maxZ: localZ, minX: localX, minZ: localZ }
+                    : {
+                        maxX: Math.max(bounds.maxX, localX),
+                        maxZ: Math.max(bounds.maxZ, localZ),
+                        minX: Math.min(bounds.minX, localX),
+                        minZ: Math.min(bounds.minZ, localZ),
+                    };
+        }
+    }
+    return bounds ?? { maxX: 0.5, maxZ: 0.5, minX: -0.5, minZ: -0.5 };
+}
+function roofMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            position: (node, sceneApi) => {
+                const bounds = getRoofFootprintBounds(node, sceneApi);
+                return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + MOVE_FRONT_OFFSET];
+            },
+        },
+        apply: (node, position) => ({
+            position: [position[0], position[1], position[2]],
+            ...(node.support?.kind === 'walls' && Math.abs(position[1] - node.position[1]) > 1e-4
+                ? { support: { kind: 'level' } }
+                : {}),
+        }),
+        snapExtents: (node, sceneApi) => {
+            const bounds = getRoofFootprintBounds(node, sceneApi);
+            const width = Math.max(bounds.maxX - bounds.minX, MIN_ROOF_FOOTPRINT);
+            const depth = Math.max(bounds.maxZ - bounds.minZ, MIN_ROOF_FOOTPRINT);
+            const swap = Math.abs(Math.sin(node.rotation ?? 0)) > 0.9;
+            return [swap ? depth : width, swap ? width : depth];
+        },
+    };
+}
+const roofHandles = [roofMoveHandle()];
+function isManagedLeanToRoof(node) {
+    const metadata = node.metadata;
+    if (!(metadata && typeof metadata === 'object' && !Array.isArray(metadata)))
+        return false;
+    const record = metadata;
+    return record.managedByLeanTo !== undefined && record.leanToRole === 'roof';
+}
+function resolveRoofHandles(node) {
+    return isManagedLeanToRoof(node) ? [] : roofHandles;
+}
+export const roofEditContribution = {
+    snapProfile: 'structural',
+    // Drafted as a 2-corner footprint (axis-aligned bbox), not a directional
+    // edge → no angle-lock mode (grid / lines / off only).
+    snapDraftDirectional: false,
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: roofPanelModel,
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'roof',
+        },
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+            tool: () => import('./floorplan-tool.js'),
+        },
+    },
+    capabilities: {
+        paint: roofPaint,
+    },
+    // Bespoke free-floating move (drag-to-place with R/T rotation and
+    // wall/fence snapping). Routes through `MoveTool`'s registry-affordance
+    // lookup — no hardcoded dispatcher arm. Shared with roof-segment / stair
+    // / stair-segment via `shared/move-roof-tool`.
+    affordanceTools: {
+        move: () => import('../shared/move-roof-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Set roof footprint' },
+        {
+            key: 'P',
+            label: 'Placement',
+            visible: conicalRoofToolHintVisibility,
+            chip: {
+                subscribe: (onChange) => useRoofPlacementMode.subscribe(onChange),
+                value: () => useRoofPlacementMode.getState().mode,
+                cycle: () => useRoofPlacementMode.getState().cycleMode(),
+                labels: {
+                    auto: 'Placement: Auto',
+                    ground: 'Placement: Ground',
+                    roof: 'Placement: Roof',
+                },
+                icons: {
+                    auto: 'lucide:scan-search',
+                    ground: 'lucide:land-plot',
+                    roof: 'lucide:house',
+                },
+                tooltip: 'Placement surface - click or press P to cycle',
+            },
+        },
+        {
+            key: 'R',
+            label: 'Ridge direction',
+            visible: standardRoofToolHintVisibility,
+            chip: {
+                subscribe: (onChange) => useRoofRidgeMode.subscribe(onChange),
+                value: () => useRoofRidgeMode.getState().mode,
+                cycle: () => useRoofRidgeMode.getState().toggle(),
+                labels: {
+                    long: 'Ridge: Long side',
+                    short: 'Ridge: Short side',
+                },
+                icons: {
+                    long: 'lucide:rectangle-horizontal',
+                    short: 'lucide:rectangle-vertical',
+                },
+                tooltip: 'Ridge direction - click or press R to turn it 90°',
+            },
+        },
+        // Room makes nothing where there is no room to roof: say why, where a click would do nothing.
+        {
+            key: 'Room',
+            label: 'Not a rectangle: draw this roof instead',
+            visible: irregularRoomHintVisibility,
+        },
+        { key: 'Room', label: 'Point inside a room, porch or deck', visible: noRoomHintVisibility },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    toolOptions: [
+        {
+            id: 'footprintSource',
+            label: 'Create from',
+            choices: [
+                {
+                    value: 'draw',
+                    label: 'Draw',
+                    description: 'Draw the roof footprint with two corner clicks.',
+                },
+                {
+                    value: 'room',
+                    label: 'Room',
+                    description: 'Hover a room to preview its boundary, then click to place.',
+                },
+            ],
+            subscribe: (onChange) => useRoofFootprintSource.subscribe(onChange),
+            value: () => useRoofFootprintSource.getState().source,
+            set: (value) => useRoofFootprintSource.getState().setSource(value === 'room' ? 'room' : 'draw'),
+            // Conical roofs always build from a curved wall pick; the row would lie.
+            visible: standardRoofToolHintVisibility,
+        },
+    ],
+    parametrics: roofParametrics,
+    handles: resolveRoofHandles,
+    floorplan: buildRoofFloorplan,
+    floorplanSiblingOverrides: roofFloorplanSiblingOverrides,
+    floorplanAffectedIds: roofFloorplanAffectedIds,
+};