@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/lean-to-extension/definition.d.ts

@@ -1,4 +1,178 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { LeanToExtensionNode } from './schema.js';
-export declare const leanToExtensionDefinition: NodeDefinition<typeof LeanToExtensionNode>;
+export declare const leanToExtensionDefinition: 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<`leanto_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"lean-to-extension">>;
+    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>>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`column_${string}`>>, import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`roof_${string}`>>]>>>;
+    canopyForm: import("zod").ZodDefault<import("zod").ZodEnum<{
+        butterfly: "butterfly";
+        gable: "gable";
+        mono: "mono";
+    }>>;
+    hostKind: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "conical-roof": "conical-roof";
+        freestanding: "freestanding";
+        "slab-edge": "slab-edge";
+        wall: "wall";
+    }>>;
+    hostHeightOffset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    hostSlabId: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`slab_${string}`>>>;
+    hostSlabEdgeIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hostSlabEdgeT: import("zod").ZodOptional<import("zod").ZodNumber>;
+    span: import("zod").ZodDefault<import("zod").ZodNumber>;
+    autoSpan: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    projection: import("zod").ZodDefault<import("zod").ZodNumber>;
+    spanArcCenterZ: import("zod").ZodOptional<import("zod").ZodNumber>;
+    spanArcRadius: import("zod").ZodOptional<import("zod").ZodNumber>;
+    highEdgeHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lowEdgeHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    pitch: import("zod").ZodDefault<import("zod").ZodNumber>;
+    resizeLock: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "preserve-high-edge": "preserve-high-edge";
+        "preserve-low-edge": "preserve-low-edge";
+        "preserve-pitch": "preserve-pitch";
+    }>>;
+    leftEndCondition: import("zod").ZodDefault<import("zod").ZodEnum<{
+        joined: "joined";
+        open: "open";
+        "wall-abutment": "wall-abutment";
+    }>>;
+    rightEndCondition: import("zod").ZodDefault<import("zod").ZodEnum<{
+        joined: "joined";
+        open: "open";
+        "wall-abutment": "wall-abutment";
+    }>>;
+    autoMiterCorners: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    sideFlashing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    flashingProjection: import("zod").ZodDefault<import("zod").ZodNumber>;
+    flashingHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    highSideMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "independent-high-beam": "independent-high-beam";
+        "wall-ledger": "wall-ledger";
+    }>>;
+    ledgerVerticalOffset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lowBeamInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    gutterEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    gutterProfile: import("zod").ZodDefault<import("zod").ZodEnum<{
+        box: "box";
+        "half-round": "half-round";
+        "k-style": "k-style";
+    }>>;
+    gutterSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+    downspoutEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    downspoutPosition: import("zod").ZodDefault<import("zod").ZodNumber>;
+    connectionMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        auto: "auto";
+        manual: "manual";
+    }>>;
+    hostRoofId: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`roof_${string}`>>>;
+    hostRoofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    hostRoofEdge: import("zod").ZodOptional<import("zod").ZodEnum<{
+        "+X": "+X";
+        "+Z": "+Z";
+        "-X": "-X";
+        "-Z": "-Z";
+    }>>;
+    hostRoofEdgeRange: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    connectionOffset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    connectionInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    matchHostRoofMaterial: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    matchHostRoofStructure: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    roofThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shingleThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    highOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lowOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    leftOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rightOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    coveringType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        generic: "generic";
+        "metal-panel": "metal-panel";
+        shingle: "shingle";
+    }>>;
+    beamWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    beamHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ledgerDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ledgerHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rafterWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rafterHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rafterSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rafterEndInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    framingStrategy: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "covering-specific": "covering-specific";
+        hidden: "hidden";
+        purlins: "purlins";
+        rafters: "rafters";
+    }>>;
+    purlinWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    purlinHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    purlinSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postLayoutMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        count: "count";
+        "target-spacing": "target-spacing";
+    }>>;
+    postSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    omittedPostSlots: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        side: import("zod").ZodEnum<{
+            high: "high";
+            low: "low";
+        }>;
+        index: import("zod").ZodNumber;
+        layoutCount: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>>;
+    postBracing: import("zod").ZodDefault<import("zod").ZodEnum<{
+        knee: "knee";
+        none: "none";
+    }>>;
+    footingStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "base-plate": "base-plate";
+        "concrete-pad": "concrete-pad";
+        none: "none";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/lean-to-extension/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAuZ9C,eAAO,MAAM,yBAAyB,EAAE,cAAc,CAAC,OAAO,mBAAmB,CAuEhF,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGrC,CAAA"}

package/dist/lean-to-extension/definition.edit.d.ts

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

package/dist/lean-to-extension/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.edit.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAuZnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,eAAO,MAAM,+BAA+B,EAAE,oBAAoB,CAAC,OAAO,mBAAmB,CA8B5F,CAAA"}

package/dist/lean-to-extension/definition.edit.js

@@ -0,0 +1,392 @@
+import { findLevelAncestorId, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, publishResolvedElevationGuide, } from '@pascal-app/editor';
+import { buildLeanToExtensionFloorplan } from './floorplan.js';
+import { leanToResizeAffordance, leanToRotateAffordance } from './floorplan-affordances.js';
+import { leanToFloorplanMoveTarget } from './floorplan-move.js';
+import { leanToWallLocalPose, resolveLeanToEdgeSnapTargets, resolveLeanToHighEdgeHeightSnap, resolveLeanToLayout, resolveLeanToSpanResizeProposal, } from './layout.js';
+import { leanToManagedPreviewOverrides } from './managed-preview.js';
+import { leanToPaint } from './paint.js';
+import { deriveLeanToResizePatch, leanToExtensionParametrics } from './parametrics.js';
+import { applyLeanToRoofAttachment, resolveLeanToRoofAttachment } from './roof-attachment.js';
+const HEIGHT_HANDLE_OFFSET = 0.25;
+const SPAN_HANDLE_OFFSET = 0.3;
+const PITCH_HANDLE_OFFSET = 0.3;
+const ROOF_EDGE_SNAP_TOLERANCE = 0.3;
+const MIN_PITCH = 1;
+const MAX_PITCH = 45;
+function resolveConicalHost(node, sceneApi) {
+    if (!(node.hostKind === 'conical-roof' && node.parentId))
+        return null;
+    const segment = sceneApi.get(node.parentId);
+    return segment?.type === 'roof-segment' && segment.roofType === 'conical' ? segment : null;
+}
+function resolveHostWall(node, sceneApi) {
+    if (!node.parentId)
+        return null;
+    const wall = sceneApi.get(node.parentId);
+    return wall?.type === 'wall' ? wall : null;
+}
+function resolveAdjacentHeightSnap(node, newValue, sceneApi) {
+    const wall = resolveHostWall(node, sceneApi);
+    if (!wall)
+        return null;
+    return resolveLeanToHighEdgeHeightSnap(node, newValue, resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()));
+}
+function resolveHighEdgeConnectionSnap(node, newValue, sceneApi) {
+    const wall = resolveHostWall(node, sceneApi);
+    if (!wall)
+        return newValue;
+    const attachment = resolveLeanToRoofAttachment({ ...node, highEdgeHeight: newValue }, wall, sceneApi.nodes());
+    if (attachment && Math.abs(attachment.highEdgeHeight - newValue) <= ROOF_EDGE_SNAP_TOLERANCE) {
+        return attachment.highEdgeHeight;
+    }
+    return resolveAdjacentHeightSnap(node, newValue, sceneApi)?.highEdgeHeight ?? newValue;
+}
+function publishAdjacentHeightGuide(node, sceneApi) {
+    const wall = resolveHostWall(node, sceneApi);
+    const nodes = sceneApi.nodes();
+    const match = wall ? resolveAdjacentHeightSnap(node, node.highEdgeHeight, sceneApi) : null;
+    if (!(wall && match) || Math.abs(match.highEdgeHeight - node.highEdgeHeight) > 1e-4) {
+        clearStructuralElevationGuide(node.id);
+        return;
+    }
+    const pose = leanToWallLocalPose(wall, node, 0);
+    publishResolvedElevationGuide({
+        nodeId: node.id,
+        levelId: findLevelAncestorId(node.id, nodes),
+        anchor: [pose.position[0], pose.position[2]],
+    }, {
+        id: `${match.target.nodeId ?? 'lean-to'}:high-edge`,
+        elevation: match.target.roofEdgeY,
+        anchor: match.target.anchor ?? [pose.position[0], pose.position[2]],
+        label: 'Neighbor shed edge',
+    });
+}
+function highEdgeHeightPatch(node, newValue, sceneApi) {
+    if (node.hostKind === 'slab-edge') {
+        return {
+            ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
+            hostHeightOffset: node.hostHeightOffset + newValue - node.highEdgeHeight,
+            connectionMode: 'manual',
+        };
+    }
+    const conicalHost = resolveConicalHost(node, sceneApi);
+    if (conicalHost) {
+        return {
+            ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
+            hostHeightOffset: newValue - conicalHost.wallHeight,
+            connectionMode: 'manual',
+            hostRoofId: undefined,
+            hostRoofSegmentId: undefined,
+            hostRoofEdge: undefined,
+            hostRoofEdgeRange: undefined,
+            connectionInset: 0,
+        };
+    }
+    const wall = resolveHostWall(node, sceneApi);
+    const attachment = wall
+        ? resolveLeanToRoofAttachment({ ...node, highEdgeHeight: newValue }, wall, sceneApi.nodes())
+        : null;
+    if (attachment && Math.abs(attachment.highEdgeHeight - newValue) <= 1e-4) {
+        const connected = applyLeanToRoofAttachment(node, attachment);
+        return {
+            highEdgeHeight: connected.highEdgeHeight,
+            lowEdgeHeight: connected.lowEdgeHeight,
+            connectionMode: connected.connectionMode,
+            hostRoofId: connected.hostRoofId,
+            hostRoofSegmentId: connected.hostRoofSegmentId,
+            hostRoofEdge: connected.hostRoofEdge,
+            hostRoofEdgeRange: connected.hostRoofEdgeRange,
+            connectionInset: connected.connectionInset,
+            span: connected.span,
+            position: connected.position,
+            roofThickness: connected.roofThickness,
+            shingleThickness: connected.shingleThickness,
+        };
+    }
+    return {
+        ...deriveLeanToResizePatch(node, { highEdgeHeight: newValue }),
+        connectionMode: 'manual',
+        hostRoofId: undefined,
+        hostRoofSegmentId: undefined,
+        hostRoofEdge: undefined,
+        hostRoofEdgeRange: undefined,
+        connectionInset: 0,
+    };
+}
+function highEdgeHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        min: 0.8,
+        max: 1000,
+        currentValue: (node) => node.highEdgeHeight,
+        connectionSnap: resolveHighEdgeConnectionSnap,
+        apply: highEdgeHeightPatch,
+        previewOverrides: (node, newValue, sceneApi) => leanToManagedPreviewOverrides(node, highEdgeHeightPatch(node, newValue, sceneApi), sceneApi),
+        onDrag: publishAdjacentHeightGuide,
+        onDragEnd: (node) => clearStructuralElevationGuide(node.id),
+        placement: {
+            position: (node) => [0, node.highEdgeHeight + HEIGHT_HANDLE_OFFSET, 0],
+        },
+        measureLabel: 'High edge height',
+    };
+}
+function pitchPatch(node, lowEdgeHeight) {
+    const pitch = Math.max(MIN_PITCH, Math.min(MAX_PITCH, (Math.atan2(node.highEdgeHeight - lowEdgeHeight, Math.max(0.001, node.projection)) * 180) /
+        Math.PI));
+    return {
+        pitch,
+        lowEdgeHeight: node.highEdgeHeight - node.projection * Math.tan((pitch * Math.PI) / 180),
+    };
+}
+function pitchHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: (node) => resolveLeanToLayout({ ...node, pitch: MAX_PITCH }).lowEdgeHeight,
+        max: (node) => resolveLeanToLayout({ ...node, pitch: MIN_PITCH }).lowEdgeHeight,
+        gridSnap: true,
+        currentValue: (node) => resolveLeanToLayout(node).lowEdgeHeight,
+        apply: (node, lowEdgeHeight) => pitchPatch(node, lowEdgeHeight),
+        previewOverrides: (node, lowEdgeHeight, sceneApi) => leanToManagedPreviewOverrides(node, pitchPatch(node, lowEdgeHeight), sceneApi),
+        placement: {
+            position: (node) => {
+                const layout = resolveLeanToLayout(node);
+                return [
+                    0,
+                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
+                    node.projection + Math.max(0, node.lowOverhang) + PITCH_HANDLE_OFFSET,
+                ];
+            },
+        },
+    };
+}
+function spanPatch(node, span, side, sceneApi) {
+    const wall = sceneApi ? resolveHostWall(node, sceneApi) : null;
+    if (wall && sceneApi) {
+        const proposal = resolveLeanToSpanResizeProposal({
+            node,
+            wall,
+            rawSpan: span,
+            side,
+            edgeSnapTargets: resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()),
+            tolerance: 1e-4,
+        });
+        return {
+            span: proposal.span,
+            autoSpan: false,
+            position: proposal.position,
+            ...(proposal.target
+                ? {
+                    highEdgeHeight: proposal.highEdgeHeight,
+                    lowEdgeHeight: proposal.lowEdgeHeight,
+                    pitch: proposal.pitch,
+                }
+                : {}),
+        };
+    }
+    const localSign = side === 'right' ? 1 : -1;
+    const centerShift = (localSign * (span - node.span)) / 2;
+    const cos = Math.cos(node.rotation[1]);
+    const sin = Math.sin(node.rotation[1]);
+    const deltaX = centerShift * cos;
+    const deltaZ = -centerShift * sin;
+    return {
+        span,
+        autoSpan: false,
+        position: [
+            Math.abs(deltaX) < 1e-12 ? node.position[0] : node.position[0] + deltaX,
+            node.position[1],
+            Math.abs(deltaZ) < 1e-12 ? node.position[2] : node.position[2] + deltaZ,
+        ],
+    };
+}
+function spanHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: 0.5,
+        max: (node, sceneApi) => {
+            const wall = resolveHostWall(node, sceneApi);
+            return wall
+                ? resolveLeanToSpanResizeProposal({
+                    node,
+                    wall,
+                    rawSpan: 100,
+                    side,
+                    tolerance: 0,
+                }).span
+                : 100;
+        },
+        currentValue: (node) => node.span,
+        connectionSnap: (node, span, sceneApi) => {
+            const wall = resolveHostWall(node, sceneApi);
+            if (!wall)
+                return span;
+            return resolveLeanToSpanResizeProposal({
+                node,
+                wall,
+                rawSpan: span,
+                side,
+                edgeSnapTargets: resolveLeanToEdgeSnapTargets(node, wall, sceneApi.nodes()),
+            }).span;
+        },
+        apply: (node, span, sceneApi) => spanPatch(node, span, side, sceneApi),
+        previewOverrides: (node, span, sceneApi) => leanToManagedPreviewOverrides(node, spanPatch(node, span, side, sceneApi), sceneApi),
+        visible: (node) => node.hostKind !== 'conical-roof',
+        placement: {
+            position: (node) => {
+                const layout = resolveLeanToLayout(node);
+                return [
+                    sign * (node.span / 2 + SPAN_HANDLE_OFFSET),
+                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
+                    node.projection,
+                ];
+            },
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        measureLabel: 'Span',
+    };
+}
+function circularRadiusPatch(node, radius) {
+    return {
+        span: 2 * Math.PI * radius,
+        autoSpan: true,
+        position: [0, node.position[1], radius],
+        spanArcCenterZ: -radius,
+        spanArcRadius: radius,
+    };
+}
+function circularRadiusHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: 0.25,
+        max: 12.5,
+        gridSnap: true,
+        currentValue: (node) => node.spanArcRadius ?? node.span / (2 * Math.PI),
+        apply: (node, radius) => circularRadiusPatch(node, radius),
+        previewOverrides: (node, radius, sceneApi) => {
+            const patch = circularRadiusPatch(node, radius);
+            const host = resolveConicalHost(node, sceneApi);
+            const entries = host
+                ? [[host.id, { width: radius * 2, depth: radius * 2 }]]
+                : [];
+            entries.push(...leanToManagedPreviewOverrides(node, patch, sceneApi));
+            return entries;
+        },
+        commit: (node, patch, sceneApi) => {
+            const host = resolveConicalHost(node, sceneApi);
+            const radius = patch.spanArcRadius;
+            if (!(host && typeof radius === 'number'))
+                return;
+            sceneApi.update(host.id, {
+                width: radius * 2,
+                depth: radius * 2,
+            });
+        },
+        visible: (node, sceneApi) => resolveConicalHost(node, sceneApi) !== null,
+        placement: {
+            position: (node) => {
+                const layout = resolveLeanToLayout(node);
+                const radius = node.spanArcRadius ?? node.span / (2 * Math.PI);
+                return [
+                    sign * (radius + layout.projection + node.lowOverhang + SPAN_HANDLE_OFFSET),
+                    layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
+                    -radius,
+                ];
+            },
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        measureLabel: 'Host radius',
+    };
+}
+function freestandingRotationHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (node, delta) => ({
+            rotation: [node.rotation[0], node.rotation[1] - delta, node.rotation[2]],
+        }),
+        visible: (node) => node.hostKind === 'freestanding',
+        placement: {
+            position: (node) => [
+                node.span / 2 + SPAN_HANDLE_OFFSET,
+                resolveLeanToLayout(node).lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
+                node.projection / 2,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (node) => Math.hypot(node.span / 2, node.projection / 2) + 0.12,
+            y: (node) => resolveLeanToLayout(node).lowEdgeHeight + HEIGHT_HANDLE_OFFSET,
+        },
+    };
+}
+const leanToExtensionHandles = [
+    highEdgeHeightHandle(),
+    pitchHandle(),
+    freestandingRotationHandle(),
+];
+leanToExtensionHandles.push({
+    kind: 'linear-resize',
+    axis: 'z',
+    anchor: 'min',
+    min: 0.5,
+    max: 1000,
+    currentValue: (node) => node.projection,
+    apply: (node, projection) => ({
+        projection,
+        ...deriveLeanToResizePatch(node, { projection }),
+    }),
+    placement: {
+        position: (node) => {
+            const layout = resolveLeanToLayout(node);
+            return [0, layout.lowEdgeHeight + HEIGHT_HANDLE_OFFSET, node.projection];
+        },
+    },
+    measureLabel: 'Projection',
+});
+leanToExtensionHandles.push(spanHandle('right'), spanHandle('left'));
+leanToExtensionHandles.push(circularRadiusHandle('right'), circularRadiusHandle('left'));
+export const leanToExtensionEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool.js'),
+        },
+    },
+    capabilities: {
+        paint: leanToPaint,
+    },
+    parametrics: leanToExtensionParametrics,
+    handles: leanToExtensionHandles,
+    floorplan: buildLeanToExtensionFloorplan,
+    floorplanMoveTarget: leanToFloorplanMoveTarget,
+    floorplanAffordances: {
+        'lean-to-resize': leanToResizeAffordance,
+        'lean-to-rotate': leanToRotateAffordance,
+    },
+    affordanceTools: { move: () => import('./move-tool.js') },
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    toolHints: [
+        {
+            key: 'Left click',
+            label: 'Place canopy or set the next run point',
+        },
+        { key: 'R / T', label: 'Rotate or flip the run side' },
+        { key: 'F', label: 'Cycle mono / gable / butterfly' },
+        { key: 'Esc', label: 'End run / cancel' },
+    ],
+};