@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof/definition.js

@@ -1,254 +1,4 @@
-import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
-import { buildRoofFloorplan } from './floorplan.js';
-import { roofPanelModel } from './panel-model.js';
-import { roofParametrics } from './parametrics.js';
-import useRoofFootprintSource from './roof-footprint-source.js';
-import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode.js';
-import { RoofNode } from './schema.js';
-const MOVE_FRONT_OFFSET = 0.35;
-const MIN_ROOF_FOOTPRINT = 1;
-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;
-}
-/**
- * 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 const roofDefinition = {
-    kind: 'roof',
-    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,
-    schemaVersion: 4,
-    schema: RoofNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    extensions: {
-        [PANEL_MODEL_EXTENSION]: roofPanelModel,
-        [DRAFTING_SURFACE_EXTENSION_KEY]: {
-            kind: 'roof',
-        },
-    },
-    defaults: () => {
-        const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        reveal: {
-            phase: 'roof',
-            style: 'assemble',
-            height: 4,
-            // The roof lifts out of the way while the furniture drops in, then seats again.
-            clears: { for: 'furnishing', height: 2.4 },
-        },
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        // F2 layers stack inward from the covering-top plane along the facet
-        // normal; the body is their sum and the roof stores no thickness.
-        assembly: { reference: 'covering', measure: 'normal', body: () => null },
-        // Contribute a plan AABB to the alignment-guide candidate pool so a roof
-        // (and any moving sibling) snaps against the roof's outer silhouette.
-        // Roof has no centred-box footprint — it's the union of its
-        // `roof-segment` children — so we hand the bridge a resolved `aabb`
-        // directly. The roof moves by its origin via `move-roof-tool`, so it
-        // only ever contributes static candidates; the relocatable-box path
-        // never needs to apply to roofs.
-        alignmentFootprint: (node, nodes) => {
-            const roof = node;
-            if (!nodes)
-                return null;
-            const cos = Math.cos(roof.rotation ?? 0);
-            const sin = Math.sin(roof.rotation ?? 0);
-            let minX = Number.POSITIVE_INFINITY;
-            let minZ = Number.POSITIVE_INFINITY;
-            let maxX = Number.NEGATIVE_INFINITY;
-            let maxZ = Number.NEGATIVE_INFINITY;
-            let any = false;
-            for (const childId of roof.children ?? []) {
-                const segment = nodes[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 sCos = Math.cos(segment.rotation ?? 0);
-                const sSin = Math.sin(segment.rotation ?? 0);
-                for (const [cx, cz] of [
-                    [-halfWidth, -halfDepth],
-                    [halfWidth, -halfDepth],
-                    [halfWidth, halfDepth],
-                    [-halfWidth, halfDepth],
-                ]) {
-                    // Segment corner → roof-local.
-                    const rx = segment.position[0] + cx * sCos + cz * sSin;
-                    const rz = segment.position[2] - cx * sSin + cz * sCos;
-                    // Roof-local → world (apply roof rotation, then position).
-                    const wx = roof.position[0] + rx * cos + rz * sin;
-                    const wz = roof.position[2] - rx * sin + rz * cos;
-                    if (wx < minX)
-                        minX = wx;
-                    if (wx > maxX)
-                        maxX = wx;
-                    if (wz < minZ)
-                        minZ = wz;
-                    if (wz > maxZ)
-                        maxZ = wz;
-                    any = true;
-                }
-            }
-            return any ? { shape: 'aabb', minX, minZ, maxX, maxZ } : null;
-        },
-    },
-    // 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: 'Rotate roof direction 90°',
-            visible: standardRoofToolHintVisibility,
-        },
-        { 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,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 3,
-    },
-    presentation: {
-        label: 'Roof',
-        description: 'A pitched / hip / gable roof composed of one or more segments.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 100,
-    },
-    mcp: {
-        description: 'A roof composed of segmented planes (gable / hip / shed).',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { roofEditContribution } from './definition.edit.js';
+import { roofRenderDefinition } from './definition.render.js';
+export const roofDefinition = composeNodeDefinition(roofRenderDefinition, roofEditContribution);

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

@@ -0,0 +1,7 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { RoofNode } from './schema.js';
+export declare const MIN_ROOF_FOOTPRINT = 1;
+export declare const roofRenderDefinition: NodeRenderDefinition<typeof RoofNode> & {
+    kind: 'roof';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/roof/definition.render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA2FxF,CAAA"}

package/dist/roof/definition.render.js

@@ -0,0 +1,101 @@
+import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
+import { RoofNode } from './schema.js';
+export const MIN_ROOF_FOOTPRINT = 1;
+export const roofRenderDefinition = {
+    kind: 'roof',
+    schemaVersion: 4,
+    schema: RoofNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        reveal: {
+            phase: 'roof',
+            style: 'assemble',
+            height: 4,
+            // The roof lifts out of the way while the furniture drops in, then seats again.
+            clears: { for: 'furnishing', height: 2.4 },
+        },
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // F2 layers stack inward from the covering-top plane along the facet
+        // normal; the body is their sum and the roof stores no thickness.
+        assembly: { reference: 'covering', measure: 'normal', body: () => null },
+        // Contribute a plan AABB to the alignment-guide candidate pool so a roof
+        // (and any moving sibling) snaps against the roof's outer silhouette.
+        // Roof has no centred-box footprint — it's the union of its
+        // `roof-segment` children — so we hand the bridge a resolved `aabb`
+        // directly. The roof moves by its origin via `move-roof-tool`, so it
+        // only ever contributes static candidates; the relocatable-box path
+        // never needs to apply to roofs.
+        alignmentFootprint: (node, nodes) => {
+            const roof = node;
+            if (!nodes)
+                return null;
+            const cos = Math.cos(roof.rotation ?? 0);
+            const sin = Math.sin(roof.rotation ?? 0);
+            let minX = Number.POSITIVE_INFINITY;
+            let minZ = Number.POSITIVE_INFINITY;
+            let maxX = Number.NEGATIVE_INFINITY;
+            let maxZ = Number.NEGATIVE_INFINITY;
+            let any = false;
+            for (const childId of roof.children ?? []) {
+                const segment = nodes[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 sCos = Math.cos(segment.rotation ?? 0);
+                const sSin = Math.sin(segment.rotation ?? 0);
+                for (const [cx, cz] of [
+                    [-halfWidth, -halfDepth],
+                    [halfWidth, -halfDepth],
+                    [halfWidth, halfDepth],
+                    [-halfWidth, halfDepth],
+                ]) {
+                    // Segment corner → roof-local.
+                    const rx = segment.position[0] + cx * sCos + cz * sSin;
+                    const rz = segment.position[2] - cx * sSin + cz * sCos;
+                    // Roof-local → world (apply roof rotation, then position).
+                    const wx = roof.position[0] + rx * cos + rz * sin;
+                    const wz = roof.position[2] - rx * sin + rz * cos;
+                    if (wx < minX)
+                        minX = wx;
+                    if (wx > maxX)
+                        maxX = wx;
+                    if (wz < minZ)
+                        minZ = wz;
+                    if (wz > maxZ)
+                        maxZ = wz;
+                    any = true;
+                }
+            }
+            return any ? { shape: 'aabb', minX, minZ, maxX, maxZ } : null;
+        },
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Roof',
+        description: 'A pitched / hip / gable roof composed of one or more segments.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 100,
+    },
+    mcp: {
+        description: 'A roof composed of segmented planes (gable / hip / shed).',
+    },
+};

package/dist/roof/floorplan-overrides.d.ts

@@ -0,0 +1,22 @@
+import type { AnyNode, AnyNodeId, LiveTransformLike } from '@pascal-app/core';
+/**
+ * A roof's plan is drawn by the roof node from its segments (`ctx.children`) and its level's
+ * other roofs (`ctx.siblings`), which a drag moves through live overrides and transforms, not the
+ * scene. Projecting those into the builder's snapshot keeps the outline, ridges, hips and valleys
+ * on the segment while it is moved, resized or turned, in 2D or 3D.
+ */
+export declare function roofFloorplanSiblingOverrides(args: {
+    nodeId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+    liveTransforms: Map<string, LiveTransformLike>;
+    liveOverrides: Map<string, Record<string, unknown>>;
+}): Record<AnyNodeId, AnyNode>;
+/**
+ * The roofs whose plan a live roof or segment edit changes: every roof on its level, since a
+ * wing's ridge runs on to the main roof's slope and their valleys are drawn by one of the two.
+ */
+export declare function roofFloorplanAffectedIds(args: {
+    node: AnyNode;
+    nodes: Record<AnyNodeId, AnyNode>;
+}): readonly AnyNodeId[];
+//# sourceMappingURL=floorplan-overrides.d.ts.map

package/dist/roof/floorplan-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAK7E;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC9C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAsB7B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;CAClC,GAAG,SAAS,SAAS,EAAE,CASvB"}

package/dist/roof/floorplan-overrides.js

@@ -0,0 +1,46 @@
+const isRoofPart = (node) => node?.type === 'roof' || node?.type === 'roof-segment';
+/**
+ * A roof's plan is drawn by the roof node from its segments (`ctx.children`) and its level's
+ * other roofs (`ctx.siblings`), which a drag moves through live overrides and transforms, not the
+ * scene. Projecting those into the builder's snapshot keeps the outline, ridges, hips and valleys
+ * on the segment while it is moved, resized or turned, in 2D or 3D.
+ */
+export function roofFloorplanSiblingOverrides(args) {
+    const { nodes, liveOverrides, liveTransforms } = args;
+    if (liveOverrides.size === 0 && liveTransforms.size === 0)
+        return nodes;
+    let out = null;
+    for (const [id, live] of liveTransforms) {
+        const existing = nodes[id];
+        if (!isRoofPart(existing))
+            continue;
+        out ??= { ...nodes };
+        out[id] = {
+            ...existing,
+            position: live.position,
+            rotation: live.rotation,
+        };
+    }
+    for (const [id, override] of liveOverrides) {
+        const existing = out?.[id] ?? nodes[id];
+        if (!isRoofPart(existing) || Object.keys(override).length === 0)
+            continue;
+        out ??= { ...nodes };
+        out[id] = { ...existing, ...override };
+    }
+    return out ?? nodes;
+}
+/**
+ * The roofs whose plan a live roof or segment edit changes: every roof on its level, since a
+ * wing's ridge runs on to the main roof's slope and their valleys are drawn by one of the two.
+ */
+export function roofFloorplanAffectedIds(args) {
+    const { node, nodes } = args;
+    const roof = node.type === 'roof-segment' && node.parentId ? nodes[node.parentId] : node;
+    if (roof?.type !== 'roof')
+        return [];
+    const level = roof.parentId ? nodes[roof.parentId] : undefined;
+    const onLevel = level?.children ?? [];
+    const roofs = onLevel.filter((id) => id !== roof.id && nodes[id]?.type === 'roof');
+    return [roof.id, ...roofs];
+}

package/dist/roof/floorplan-tool.d.ts

@@ -0,0 +1,9 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/**
+ * The roof tool in 2D-only view. The 3D `RoofTool` lives in the canvas, which never renders while
+ * its pane is hidden, so in 2D-only view this commits instead, from the plan's own grid events: it
+ * snaps the corners, writes them into the plan's draft rectangle (or hovers the room, or for a cone
+ * the curved wall) and writes the roof. Split and 3D views keep the 3D tool as the one owner.
+ */
+export default function RoofFloorplanTool({ activeLevelId, sceneApi, selectNode, }: FloorplanToolContext): null;
+//# sourceMappingURL=floorplan-tool.d.ts.map

package/dist/roof/floorplan-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan-tool.tsx"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,oBAAoB,EAM1B,MAAM,oBAAoB,CAAA;AAoB3B;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,aAAa,EACb,QAAQ,EACR,UAAU,GACX,EAAE,oBAAoB,QAkLtB"}

package/dist/roof/floorplan-tool.js

@@ -0,0 +1,168 @@
+'use client';
+import { emitter, RoofType as RoofTypeSchema, } from '@pascal-app/core';
+import { clearSurfacePlanSnapFeedback, markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, visibleScene, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect } from 'react';
+import { createConicalRoofSectorAboveWall } from './conical-roof.js';
+import { parseRoofFootprintSource, pickConicalRoofWall, pickRoofRoom, roofFootprintPreviewIds, } from './roof-footprint.js';
+import useRoofFootprintSource from './roof-footprint-source.js';
+import useRoofPlacementMode from './roof-placement-mode.js';
+import useRoofRidgeMode, { ridgeQuarterTurn } from './roof-ridge-mode.js';
+import { collectRoofAlignmentAnchors, commitRoofFootprint, commitRoofPlacement, resolveRoofDraftPoint, } from './tool.js';
+/**
+ * The roof tool in 2D-only view. The 3D `RoofTool` lives in the canvas, which never renders while
+ * its pane is hidden, so in 2D-only view this commits instead, from the plan's own grid events: it
+ * snaps the corners, writes them into the plan's draft rectangle (or hovers the room, or for a cone
+ * the curved wall) and writes the roof. Split and 3D views keep the 3D tool as the one owner.
+ */
+export default function RoofFloorplanTool({ activeLevelId, sceneApi, selectNode, }) {
+    const planOwnsInput = useEditor((state) => visibleScene(state) === '2d');
+    const levelId = planOwnsInput ? activeLevelId : null;
+    const roofType = useEditor((state) => {
+        const parsed = RoofTypeSchema.safeParse(state.toolDefaults.roof?.roofType);
+        return parsed.success ? parsed.data : 'gable';
+    });
+    // A new source or roof type starts over, as the 3D tool does: a first corner kept across it
+    // would end the next rectangle with no draft on the plan to show it.
+    const source = useRoofFootprintSource((state) => parseRoofFootprintSource(state.source, roofType));
+    useEffect(() => {
+        if (!levelId)
+            return;
+        let corner1 = null;
+        const draft = useFloorplanDraftPreview.getState;
+        // A rectangle the 3D tool opened before the view changed has no first corner here: drop it, or
+        // the plan's draft and this tool's corner fall out of step (each click starts one, ends the other).
+        const clearDraft = () => {
+            draft().setRoofDraftStart(null);
+            draft().setRoofDraftEnd(null);
+            draft().setRoofDraftQuarterTurn(false);
+        };
+        clearDraft();
+        // Snapped as the 3D tool snaps in split view (onto the walls below too), so the same clicks
+        // make the same roof in either view.
+        let alignmentCandidates = collectRoofAlignmentAnchors(sceneApi.nodes(), levelId, roofType);
+        const planPoint = (event) => resolveRoofDraftPoint(event, levelId, sceneApi.nodes(), roofType, alignmentCandidates);
+        let previewedId = null;
+        const preview = (target) => {
+            if ((target?.id ?? null) === previewedId)
+                return;
+            previewedId = target?.id ?? null;
+            useViewer.getState().setPreviewSelectedIds(target?.ids ?? []);
+        };
+        const conicalWall = (event) => pickConicalRoofWall(levelId, sceneApi.nodes(), [
+            event.localPosition[0],
+            event.localPosition[2],
+        ]);
+        const onMove = (event) => {
+            if (source === 'walls') {
+                const wall = conicalWall(event);
+                preview(wall && { id: wall.id, ids: [wall.id] });
+                return;
+            }
+            if (source === 'room') {
+                const room = pickRoofRoom(levelId, sceneApi.nodes(), planPoint(event));
+                useRoofFootprintSource.getState().setRoomPick(room.pick);
+                preview(room.target && { id: room.target.id, ids: roofFootprintPreviewIds(room.target) });
+                return;
+            }
+            const [x, z] = planPoint(event);
+            if (!corner1)
+                return;
+            draft().setRoofDraftEnd([x, z]);
+            draft().setRoofDraftQuarterTurn(ridgeQuarterTurn(Math.abs(x - corner1[0]), Math.abs(z - corner1[2]), useRoofRidgeMode.getState().mode));
+        };
+        const onClick = (event) => {
+            if (source === 'walls') {
+                const wall = conicalWall(event);
+                if (!wall)
+                    return;
+                preview(null);
+                const segmentId = createConicalRoofSectorAboveWall(wall, sceneApi.nodes(), sceneApi, levelId);
+                if (segmentId)
+                    selectNode(segmentId);
+                return;
+            }
+            if (source === 'room') {
+                const { target, pick } = pickRoofRoom(levelId, sceneApi.nodes(), planPoint(event));
+                useRoofFootprintSource.getState().setRoomPick(pick);
+                if (!target)
+                    return;
+                const roofId = commitRoofFootprint(sceneApi, levelId, target, useRoofRidgeMode.getState().mode);
+                if (roofId)
+                    selectNode(roofId);
+                return;
+            }
+            const [x, z] = planPoint(event);
+            const corner = [x, event.localPosition[1], z];
+            if (!corner1) {
+                corner1 = corner;
+                draft().setRoofDraftStart([x, z]);
+                draft().setRoofDraftEnd([x, z]);
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            const roofId = commitRoofPlacement(sceneApi, levelId, corner1, corner, useViewer.getState().selection.selectedIds, useRoofRidgeMode.getState().mode, useRoofPlacementMode.getState().mode);
+            corner1 = null;
+            clearDraft();
+            alignmentCandidates = collectRoofAlignmentAnchors(sceneApi.nodes(), levelId, roofType);
+            clearSurfacePlanSnapFeedback();
+            if (roofId)
+                selectNode(roofId);
+        };
+        const onCancel = () => {
+            if (!corner1)
+                return;
+            markToolCancelConsumed();
+            corner1 = null;
+            clearDraft();
+        };
+        const onKeyDown = (event) => {
+            const target = event.target;
+            if (target instanceof HTMLInputElement ||
+                target instanceof HTMLTextAreaElement ||
+                (target instanceof HTMLElement && target.isContentEditable))
+                return;
+            if (event.repeat || event.metaKey || event.ctrlKey || event.altKey)
+                return;
+            const key = event.key.toLowerCase();
+            // As in 3D: P cycles a cone's placement surface, R turns a drawn roof's ridge.
+            if (source === 'walls') {
+                if (key !== 'p')
+                    return;
+                event.preventDefault();
+                useRoofPlacementMode.getState().cycleMode();
+                triggerSFX('sfx:grid-snap');
+                return;
+            }
+            if (key !== 'r')
+                return;
+            event.preventDefault();
+            useRoofRidgeMode.getState().toggle();
+            triggerSFX('sfx:item-rotate');
+        };
+        // The HUD chip flips the ridge too; the draft's ridge line follows either way.
+        const unsubscribeRidgeMode = useRoofRidgeMode.subscribe(() => {
+            const start = draft().roofDraftStart;
+            const end = draft().roofDraftEnd;
+            if (!(corner1 && start && end))
+                return;
+            draft().setRoofDraftQuarterTurn(ridgeQuarterTurn(Math.abs(end[0] - start[0]), Math.abs(end[1] - start[1]), useRoofRidgeMode.getState().mode));
+        });
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown);
+            unsubscribeRidgeMode();
+            useRoofFootprintSource.getState().setRoomPick(null);
+            preview(null);
+            clearDraft();
+            clearSurfacePlanSnapFeedback();
+        };
+    }, [levelId, roofType, sceneApi, selectNode, source]);
+    return null;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA8LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0MjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAyCzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AAqPD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmPjG"}