@pascal-app/nodes 1.0.7 → 1.1.1

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;AAsBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAwM1D,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;AAevE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqFxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAwGtE,CAAA"}

package/dist/roof/definition.edit.js

@@ -0,0 +1,181 @@
+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 { 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,
+    floorplanSiblingOverrides: roofFloorplanSiblingOverrides,
+    floorplanAffectedIds: roofFloorplanAffectedIds,
+};

package/dist/roof/definition.js

@@ -1,284 +1,4 @@
-import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
-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';
-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',
-        },
-        [FLOORPLAN_NODE_EXTENSION_KEY]: {
-            tool: () => import('./floorplan-tool.js'),
-        },
-    },
-    defaults: () => {
-        const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        paint: roofPaint,
-        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: '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,
-    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":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,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;CAqGxF,CAAA"}

package/dist/roof/definition.render.js

@@ -0,0 +1,112 @@
+import { RoofNode as RoofNodeSchema, roofFaceShapes, } from '@pascal-app/core';
+import { buildRoofFloorplan } from './floorplan.js';
+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 and its faces' outlines — 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 face of roofFaceShapes(roof, nodes)) {
+                for (const [wx, wz] of face.outline) {
+                    minX = Math.min(minX, wx);
+                    maxX = Math.max(maxX, wx);
+                    minZ = Math.min(minZ, wz);
+                    maxZ = Math.max(maxZ, wz);
+                    any = true;
+                }
+            }
+            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,
+    },
+    floorplan: buildRoofFloorplan,
+    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.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,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"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;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"}

package/dist/roof/floorplan.js

@@ -1,5 +1,4 @@
-import { getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, getSegmentSlopeFrame, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
-import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { floorplanGeometryMetadata, getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, getSegmentSlopeFrame, readFloorplanContext, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
 import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan.js';
 import { getRoofSurfaceCreases } from './roof-plan-creases.js';
 /**

package/dist/roof/geometry-notice.d.ts

@@ -0,0 +1,5 @@
+import { type AnyNodeId } from '@pascal-app/core';
+export declare function RoofGeometryNotice({ ids }: {
+    ids: readonly AnyNodeId[];
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=geometry-notice.d.ts.map

package/dist/roof/geometry-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-notice.d.ts","sourceRoot":"","sources":["../../src/roof/geometry-notice.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA2B,MAAM,kBAAkB,CAAA;AAI1E,wBAAgB,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,sCA+BxE"}

package/dist/roof/geometry-notice.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { ActionButton } from '@pascal-app/editor';
+import { useGeometryStatus } from '@pascal-app/viewer';
+export function RoofGeometryNotice({ ids }) {
+    const i18n = usePascalI18n();
+    const failures = useGeometryStatus((state) => state.failures);
+    const failedId = ids.find((id) => failures.has(id));
+    if (!failedId)
+        return null;
+    return (_jsxs("div", { role: "alert", className: "mx-3 my-2 rounded-md border border-amber-500/40 p-3 text-xs", children: [_jsx("p", { children: failures.get(failedId) === 'invalid-geometry'
+                    ? i18n._({
+                        id: 'node.roof.geometryNotice.roofGeometryIsInvalidThePrevious',
+                        message: 'Roof geometry is invalid. The previous shape is still shown. Adjust the dimensions or intersections and retry.',
+                    })
+                    : i18n._({
+                        id: 'node.roof.geometryNotice.roofGeometryCouldNotBeRebuilt',
+                        message: 'Roof geometry could not be rebuilt. The previous shape is still shown. Adjust the dimensions or intersections and retry.',
+                    }) }), _jsx(ActionButton, { label: i18n._({
+                    id: 'node.roof.geometryNotice.retryRoofGeometry',
+                    message: 'Retry roof geometry',
+                }), onClick: () => {
+                    for (const id of ids)
+                        if (failures.has(id))
+                            useScene.getState().markDirty(id);
+                } })] }));
+}