@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

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

@@ -0,0 +1,4 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { LeanToExtensionNode } from './schema';
+export declare const leanToExtensionDefinition: NodeDefinition<typeof LeanToExtensionNode>;
+//# sourceMappingURL=definition.d.ts.map

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

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

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

@@ -0,0 +1,433 @@
+import { findLevelAncestorId, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, publishResolvedElevationGuide, } from '@pascal-app/editor';
+import { buildLeanToExtensionFloorplan } from './floorplan';
+import { leanToResizeAffordance, leanToRotateAffordance } from './floorplan-affordances';
+import { leanToFloorplanMoveTarget } from './floorplan-move';
+import { buildLeanToExtensionGeometry, leanToExtensionGeometryKey } from './geometry';
+import { leanToWallLocalPose, resolveLeanToEdgeSnapTargets, resolveLeanToHighEdgeHeightSnap, resolveLeanToLayout, resolveLeanToSpanResizeProposal, } from './layout';
+import { leanToManagedPreviewOverrides } from './managed-preview';
+import { leanToPaint } from './paint';
+import { deriveLeanToResizePatch, leanToExtensionParametrics } from './parametrics';
+import { applyLeanToRoofAttachment, resolveLeanToRoofAttachment } from './roof-attachment';
+import { LeanToExtensionNode } from './schema';
+import { leanToSlots } from './slots';
+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 leanToExtensionDefinition = {
+    kind: 'lean-to-extension',
+    schemaVersion: 13,
+    schema: LeanToExtensionNode,
+    category: 'structure',
+    snapProfile: 'structural',
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool'),
+        },
+    },
+    defaults: () => {
+        const parsed = LeanToExtensionNode.parse({});
+        const { id: _id, type: _type, ...defaults } = parsed;
+        return defaults;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        slots: () => leanToSlots(),
+        paint: leanToPaint,
+    },
+    relations: {
+        cascadeDelete: 'descendants',
+        hosts: ['column', 'roof'],
+    },
+    parametrics: leanToExtensionParametrics,
+    handles: leanToExtensionHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    geometry: buildLeanToExtensionGeometry,
+    geometryKey: leanToExtensionGeometryKey,
+    system: {
+        module: () => import('./system'),
+        priority: 1,
+    },
+    floorplan: buildLeanToExtensionFloorplan,
+    floorplanMoveTarget: leanToFloorplanMoveTarget,
+    floorplanAffordances: {
+        'lean-to-resize': leanToResizeAffordance,
+        'lean-to-rotate': leanToRotateAffordance,
+    },
+    affordanceTools: { move: () => import('./move-tool') },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    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' },
+    ],
+    presentation: {
+        label: 'Canopy',
+        description: 'An attached mono-pitch or freestanding mono, gable, or butterfly canopy with managed structure and drainage.',
+        icon: { kind: 'url', src: '/icons/lean-to-extension.webp' },
+        paletteSection: 'structure',
+        paletteGroup: 'roof-features',
+        paletteOrder: 105,
+    },
+    mcp: {
+        description: 'An open canopy that can attach to a wall or upper slab edge, stand freestanding with a mono, gable, or butterfly roof, or wrap around a conical roof base. It composes standard roof segments, gutters, downspouts, editable column children, framing, and beams.',
+    },
+};

package/dist/lean-to-extension/floorplan-affordances.d.ts

@@ -0,0 +1,4 @@
+import { type FloorplanAffordance, type LeanToExtensionNode } from '@pascal-app/core';
+export declare const leanToResizeAffordance: FloorplanAffordance<LeanToExtensionNode>;
+export declare const leanToRotateAffordance: FloorplanAffordance<LeanToExtensionNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/lean-to-extension/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAIxB,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,mBAAmB,CAmG3E,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,mBAAmB,CAyC3E,CAAA"}

package/dist/lean-to-extension/floorplan-affordances.js

@@ -0,0 +1,144 @@
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall, snapScalar, useLiveNodeOverrides, } from '@pascal-app/core';
+import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive } from '@pascal-app/editor';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+import { resolveLeanToEdgeSnapTargets, resolveLeanToPlanCenter, resolveLeanToSpanResizeProposal, } from './layout';
+import { deriveLeanToResizePatch } from './parametrics';
+import { moveLeanToAlongSlabEdge } from './placement';
+export const leanToResizeAffordance = {
+    start({ node, nodes, payload, initialPlanPoint, sceneApi }) {
+        if (!sceneApi)
+            return { affectedIds: [], apply() { }, canCommit: () => false };
+        const wall = node.parentId
+            ? nodes[node.parentId]
+            : undefined;
+        const { dimension, side = 1 } = payload;
+        const outwardSign = Math.cos(node.rotation[1]) >= 0 ? 1 : -1;
+        let along;
+        let outward;
+        if (wall?.type === 'wall' && isCurvedWall(wall)) {
+            const arcLength = Math.max(1e-6, getWallCurveLength(wall));
+            const t = Math.max(0, Math.min(1, node.position[0] / arcLength));
+            const frame = getWallCurveFrameAt(wall, t);
+            along = [frame.tangent.x, frame.tangent.y];
+            outward = [frame.normal.x * outwardSign, frame.normal.y * outwardSign];
+        }
+        else if (wall?.type === 'wall') {
+            const dx = wall.end[0] - wall.start[0];
+            const dz = wall.end[1] - wall.start[1];
+            const length = Math.max(1e-6, Math.hypot(dx, dz));
+            along = [dx / length, dz / length];
+            outward = [-along[1] * outwardSign, along[0] * outwardSign];
+        }
+        else {
+            const cos = Math.cos(node.rotation[1]);
+            const sin = Math.sin(node.rotation[1]);
+            along = [cos, -sin];
+            outward = [sin, cos];
+        }
+        const axis = dimension === 'projection' ? outward : along;
+        const initialAxis = initialPlanPoint[0] * axis[0] + initialPlanPoint[1] * axis[1];
+        const initialValue = dimension === 'projection' ? node.projection : node.span;
+        let lastPatch = {};
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint, modifiers }) {
+                const currentAxis = planPoint[0] * axis[0] + planPoint[1] * axis[1];
+                const raw = initialValue + (currentAxis - initialAxis) * side;
+                const step = !modifiers.altKey && isGridSnapActive() ? getSegmentGridStep() : 0;
+                const value = Math.max(0.5, step > 0 ? snapScalar(raw, step) : raw);
+                if (dimension === 'projection') {
+                    lastPatch = {
+                        projection: value,
+                        ...deriveLeanToResizePatch(node, { projection: value }),
+                    };
+                }
+                else if (wall?.type === 'wall') {
+                    const proposal = resolveLeanToSpanResizeProposal({
+                        node,
+                        wall,
+                        rawSpan: value,
+                        side: side > 0 ? 'right' : 'left',
+                        edgeSnapTargets: modifiers.altKey
+                            ? []
+                            : resolveLeanToEdgeSnapTargets(node, wall, nodes),
+                    });
+                    lastPatch = {
+                        span: proposal.span,
+                        autoSpan: false,
+                        position: proposal.position,
+                        ...(proposal.target
+                            ? {
+                                highEdgeHeight: proposal.highEdgeHeight,
+                                lowEdgeHeight: proposal.lowEdgeHeight,
+                                pitch: proposal.pitch,
+                            }
+                            : {}),
+                    };
+                }
+                else {
+                    const centerShift = (side * (value - node.span)) / 2;
+                    const proposedPosition = [
+                        node.position[0] + along[0] * centerShift,
+                        node.position[1],
+                        node.position[2] + along[1] * centerShift,
+                    ];
+                    const resolved = node.hostKind === 'slab-edge'
+                        ? moveLeanToAlongSlabEdge({ ...node, autoSpan: false, span: value }, [proposedPosition[0], proposedPosition[2]], nodes)
+                        : null;
+                    lastPatch = {
+                        span: value,
+                        autoSpan: false,
+                        position: resolved?.position ?? proposedPosition,
+                        ...(resolved ? { hostSlabEdgeT: resolved.hostSlabEdgeT } : {}),
+                    };
+                }
+                useLiveNodeOverrides.getState().set(node.id, lastPatch);
+                sceneApi.markDirty(node.id);
+            },
+            canCommit: () => Object.keys(lastPatch).length > 0,
+            commit() {
+                useLiveNodeOverrides.getState().clear(node.id);
+                sceneApi.update(node.id, lastPatch);
+            },
+        };
+    },
+};
+export const leanToRotateAffordance = {
+    start({ node, initialPlanPoint, sceneApi }) {
+        if (!(sceneApi && node.hostKind === 'freestanding')) {
+            return { affectedIds: [], apply() { }, canCommit: () => false };
+        }
+        const nodeId = node.id;
+        const [centerX, centerZ] = resolveLeanToPlanCenter(node);
+        const rotationY = node.rotation[1];
+        const center = [
+            node.position[0] + centerX * Math.cos(rotationY) + centerZ * Math.sin(rotationY),
+            node.position[2] - centerX * Math.sin(rotationY) + centerZ * Math.cos(rotationY),
+        ];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - center[1], initialPlanPoint[0] - center[0]);
+        let lastRotation = node.rotation[1];
+        return {
+            affectedIds: [nodeId],
+            apply({ planPoint }) {
+                const delta = rotateAffordanceDelta({
+                    center,
+                    initialAngle,
+                    planPoint,
+                    free: !isAngleSnapActive(),
+                });
+                lastRotation = node.rotation[1] - delta;
+                useLiveNodeOverrides.getState().set(nodeId, {
+                    rotation: [node.rotation[0], lastRotation, node.rotation[2]],
+                });
+                sceneApi.markDirty(nodeId);
+            },
+            canCommit: () => true,
+            commit() {
+                useLiveNodeOverrides.getState().clear(nodeId);
+                sceneApi.update(nodeId, {
+                    rotation: [node.rotation[0], lastRotation, node.rotation[2]],
+                });
+            },
+        };
+    },
+};

package/dist/lean-to-extension/floorplan-move.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanMoveTarget, type LeanToExtensionNode } from '@pascal-app/core';
+export declare const leanToFloorplanMoveTarget: FloorplanMoveTarget<LeanToExtensionNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/lean-to-extension/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAExB,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAyCzB,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,mBAAmB,CAoI9E,CAAA"}