@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/cupola/definition.d.ts

@@ -1,11 +1,96 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { CupolaNode } from './schema.js';
-/**
- * Cupola — a louvered roof lantern. Parented to a `roof-segment`; position
- * is segment-local; rotation rotates it around the segment's vertical axis
- * after the slope tilt is applied. Same composition as the box vent (custom
- * renderer, pure geometry builder, no system) — see box-vent's definition
- * for the rationale on why roof accessories need a custom renderer.
- */
-export declare const cupolaDefinition: NodeDefinition<typeof CupolaNode>;
+export declare const cupolaDefinition: 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<`cupola_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"cupola">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    materialPreset: import("zod").ZodDefault<import("zod").ZodString>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    roofStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        dome: "dome";
+        pyramid: "pyramid";
+    }>>;
+    finial: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA6D9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG5B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAgG1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAiB1E,CAAA"}

package/dist/cupola/definition.edit.js

@@ -0,0 +1,103 @@
+import { buildCupolaFloorplan } from './floorplan.js';
+import { cupolaPaint } from './paint.js';
+import { cupolaParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.3;
+const HEIGHT_HANDLE_OFFSET = 0.25;
+// Snug to the cupola corner so the rotate icon stays close to the item.
+const ROTATE_CORNER_OFFSET = 0.12;
+const MIN_DIM = 0.3;
+const MIN_HEIGHT = 0.4;
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Width / depth grow symmetrically from the centre (cupolas are placed by
+// their centre on the ridge), so a single centred chevron per axis.
+function cupolaWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+function cupolaDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+function cupolaHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+function cupolaRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => [
+                n.width / 2 + ROTATE_CORNER_OFFSET,
+                getBodyMidY(n),
+                n.depth / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        // Guide ring centred on the cupola, sized to pass through the corner
+        // icon so the icon rides the ring — matches solar-panel / skylight.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2 + ROTATE_CORNER_OFFSET, n.depth / 2 + ROTATE_CORNER_OFFSET),
+            y: (n) => getBodyMidY(n),
+        },
+    };
+}
+// `portal: 'grandparent'` on every handle — see box-vent's note. The cupola
+// rides the roof→segment→node frame chain, so the handle rig must too, or
+// the handles (and rotate arc) render offset from the cupola.
+const cupolaHandles = [
+    cupolaWidthHandle(),
+    cupolaDepthHandle(),
+    cupolaHeightHandle(),
+    cupolaRotateHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+export const cupolaEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: cupolaPaint,
+    },
+    parametrics: cupolaParametrics,
+    handles: cupolaHandles,
+    floorplan: buildCupolaFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place cupola on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/cupola/definition.js

@@ -1,148 +1,4 @@
-import { CUPOLA_LOUVERS_DEFAULT, CupolaNode as CupolaNodeSchema, cupolaSlots, } from '@pascal-app/core';
-import { buildCupolaFloorplan } from './floorplan.js';
-import { cupolaPaint } from './paint.js';
-import { cupolaParametrics } from './parametrics.js';
-import { CupolaNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.3;
-const HEIGHT_HANDLE_OFFSET = 0.25;
-// Snug to the cupola corner so the rotate icon stays close to the item.
-const ROTATE_CORNER_OFFSET = 0.12;
-const MIN_DIM = 0.3;
-const MIN_HEIGHT = 0.4;
-function getBodyMidY(n) {
-    return Math.max(0.001, n.height) / 2;
-}
-// Width / depth grow symmetrically from the centre (cupolas are placed by
-// their centre on the ridge), so a single centred chevron per axis.
-function cupolaWidthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_DIM,
-        currentValue: (n) => n.width,
-        apply: (_n, newValue) => ({ width: Math.max(MIN_DIM, newValue) }),
-        placement: {
-            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
-        },
-    };
-}
-function cupolaDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: 'center',
-        min: MIN_DIM,
-        currentValue: (n) => n.depth,
-        apply: (_n, newValue) => ({ depth: Math.max(MIN_DIM, newValue) }),
-        placement: {
-            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
-        },
-    };
-}
-function cupolaHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_HEIGHT,
-        currentValue: (n) => n.height,
-        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
-        placement: {
-            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-function cupolaRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n) => [
-                n.width / 2 + ROTATE_CORNER_OFFSET,
-                getBodyMidY(n),
-                n.depth / 2 + ROTATE_CORNER_OFFSET,
-            ],
-            rotationY: () => -Math.PI / 4,
-        },
-        // Guide ring centred on the cupola, sized to pass through the corner
-        // icon so the icon rides the ring — matches solar-panel / skylight.
-        decoration: {
-            kind: 'ring',
-            radius: (n) => Math.hypot(n.width / 2 + ROTATE_CORNER_OFFSET, n.depth / 2 + ROTATE_CORNER_OFFSET),
-            y: (n) => getBodyMidY(n),
-        },
-    };
-}
-// `portal: 'grandparent'` on every handle — see box-vent's note. The cupola
-// rides the roof→segment→node frame chain, so the handle rig must too, or
-// the handles (and rotate arc) render offset from the cupola.
-const cupolaHandles = [
-    cupolaWidthHandle(),
-    cupolaDepthHandle(),
-    cupolaHeightHandle(),
-    cupolaRotateHandle(),
-].map((h) => ({ ...h, portal: 'grandparent' }));
-/**
- * Cupola — a louvered roof lantern. Parented to a `roof-segment`; position
- * is segment-local; rotation rotates it around the segment's vertical axis
- * after the slope tilt is applied. Same composition as the box vent (custom
- * renderer, pure geometry builder, no system) — see box-vent's definition
- * for the rationale on why roof accessories need a custom renderer.
- */
-export const cupolaDefinition = {
-    kind: 'cupola',
-    schemaVersion: 4,
-    schema: CupolaNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        const stub = CupolaNodeSchema.parse({ id: 'cupola_default', type: 'cupola' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return {
-            ...rest,
-            slots: { ...(rest.slots ?? {}), louvers: CUPOLA_LOUVERS_DEFAULT },
-        };
-    },
-    capabilities: {
-        exterior: true,
-        slots: cupolaSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: cupolaPaint,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // slope — no `buildCut`, just the dirty cascade so the parent roof's
-        // merged shell rebuilds when the cupola moves / resizes.
-        roofAccessory: {},
-    },
-    parametrics: cupolaParametrics,
-    handles: cupolaHandles,
-    floorplan: buildCupolaFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place cupola on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Cupola',
-        description: 'Louvered roof lantern with a dome or pyramid cap and optional finial.',
-        icon: { kind: 'url', src: '/icons/cupola.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 122,
-    },
-    mcp: {
-        description: 'A louvered cupola (roof lantern) on a roof segment. Roof style: dome / pyramid, optional finial. Parametric width/depth/height.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { cupolaEditContribution } from './definition.edit.js';
+import { cupolaRenderDefinition } from './definition.render.js';
+export const cupolaDefinition = composeNodeDefinition(cupolaRenderDefinition, cupolaEditContribution);

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

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

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

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

package/dist/cupola/definition.render.js

@@ -0,0 +1,43 @@
+import { CUPOLA_LOUVERS_DEFAULT, CupolaNode as CupolaNodeSchema, cupolaSlots, } from '@pascal-app/core';
+import { CupolaNode } from './schema.js';
+export const cupolaRenderDefinition = {
+    kind: 'cupola',
+    schemaVersion: 4,
+    schema: CupolaNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = CupolaNodeSchema.parse({ id: 'cupola_default', type: 'cupola' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return {
+            ...rest,
+            slots: { ...(rest.slots ?? {}), louvers: CUPOLA_LOUVERS_DEFAULT },
+        };
+    },
+    capabilities: {
+        exterior: true,
+        slots: cupolaSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // slope — no `buildCut`, just the dirty cascade so the parent roof's
+        // merged shell rebuilds when the cupola moves / resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Cupola',
+        description: 'Louvered roof lantern with a dome or pyramid cap and optional finial.',
+        icon: { kind: 'url', src: '/icons/cupola.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A louvered cupola (roof lantern) on a roof segment. Roof style: dome / pyramid, optional finial. Parametric width/depth/height.',
+    },
+};

package/dist/cupola/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/cupola/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAwNpE"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/cupola/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAyNpE"}

package/dist/cupola/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -54,9 +54,9 @@ export default function MoveCupolaTool({ node }) {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const updatePreview = (event) => {
@@ -68,7 +68,8 @@ export default function MoveCupolaTool({ node }) {
             lastTarget = target;
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true &&
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
                 (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnap = [sx, sz];
@@ -121,7 +122,7 @@ export default function MoveCupolaTool({ node }) {
                 position: [target.localX, target.localY, target.localZ],
                 rotation: original.rotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             useScene.temporal.getState().pause();
             st.dirtyNodes.add(targetSegmentId);

package/dist/cupola/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCA4OlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAuPlC"}

package/dist/cupola/panel.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getActiveRoofHeight, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
@@ -11,6 +11,7 @@ import { useCallback } from 'react';
  * flow the placement tool uses. Mirrors the box-vent panel.
  */
 export default function CupolaPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
@@ -78,11 +79,17 @@ export default function CupolaPanel() {
     }, [selectedId, node, deleteNode, setSelection]);
     if (!(node && node.type === 'cupola' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Cupola', width: 300, children: [_jsxs(PanelSection, { title: "Style", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ roofStyle: v }), options: [
-                            { label: 'Dome', value: 'dome' },
-                            { label: 'Pyramid', value: 'pyramid' },
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || i18n._({ id: 'node.cupola.panel.cupola', message: 'Cupola' }), width: 300, children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.style', message: 'Style' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ roofStyle: v }), options: [
+                            { label: i18n._({ id: 'node.cupola.panel.dome', message: 'Dome' }), value: 'dome' },
+                            {
+                                label: i18n._({ id: 'node.cupola.panel.pyramid', message: 'Pyramid' }),
+                                value: 'pyramid',
+                            },
                         ], value: node.roofStyle ?? 'dome' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ finial: v === 'on' }), options: [
-                            { label: 'Finial', value: 'on' },
-                            { label: 'No Finial', value: 'off' },
-                        ], value: (node.finial ?? true) ? 'on' : 'off' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: "Depth", max: 1000, min: 0.3, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.depth }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.4, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[0] ?? 0 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[1] ?? 0 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[2] ?? 0 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                            { label: i18n._({ id: 'node.cupola.panel.finial', message: 'Finial' }), value: 'on' },
+                            {
+                                label: i18n._({ id: 'node.cupola.panel.noFinial', message: 'No Finial' }),
+                                value: 'off',
+                            },
+                        ], value: (node.finial ?? true) ? 'on' : 'off' })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.dimensions', message: 'Dimensions' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.width', message: 'Width' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.depth', message: 'Depth' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.depth }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.height', message: 'Height' }), max: 1000, min: 0.4, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[0] ?? 0 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[1] ?? 0 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[2] ?? 0 }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.rotation', message: 'Rotation' }), max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.cupola.panel.actions', message: 'Actions' }), children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.cupola.panel.move', message: 'Move' }), onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.cupola.panel.duplicate', message: 'Duplicate' }), onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: i18n._({ id: 'node.cupola.panel.delete', message: 'Delete' }), onClick: handleDelete })] }) })] }));
 }

package/dist/definition-contributions.d.ts

@@ -0,0 +1,14 @@
+import type { AnyNodeDefinition, NodeDefinition } from '@pascal-app/core';
+type NodeSchema = AnyNodeDefinition['schema'];
+type EditField = 'extensions' | 'facingIndicator' | 'drafting' | 'connectedMove' | 'parametrics' | 'placementNotice' | 'quickActions' | 'quickActionNodeScope' | 'tool' | 'affordanceTools' | 'affordances' | 'toolHints' | 'affordanceHints' | 'toolOptions' | 'snapProfile' | 'snapDraftDirectional' | 'preview' | 'keyboardActions' | 'handles' | 'computeFloorplanLevelData' | 'floorplan' | 'floorplanDependencies' | 'floorplanScope' | 'floorplanDependsOnSiblings' | 'floorplanAffectedIds' | 'floorplanSiblingOverrides' | 'floorplanAffordances' | 'floorplanMoveTarget';
+type Capabilities<S extends NodeSchema> = NonNullable<NodeDefinition<S>['capabilities']>;
+export type NodeRenderDefinition<S extends NodeSchema> = Omit<NodeDefinition<S>, EditField | 'capabilities'> & {
+    capabilities: Omit<Capabilities<S>, 'paint'>;
+};
+export type NodeEditContribution<S extends NodeSchema> = Partial<Pick<NodeDefinition<S>, EditField | 'renderer'>> & {
+    capabilities?: Pick<Capabilities<S>, 'paint' | 'ceilingCut'>;
+};
+/** Top-level replacement; capabilities merge once. Arrays and functions are replaced. */
+export declare function composeNodeDefinition<S extends NodeSchema>(render: NodeRenderDefinition<S>, edit: NodeEditContribution<S>): NodeDefinition<S>;
+export {};
+//# sourceMappingURL=definition-contributions.d.ts.map

package/dist/definition-contributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-contributions.d.ts","sourceRoot":"","sources":["../src/definition-contributions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEzE,KAAK,UAAU,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AAE7C,KAAK,SAAS,GACV,YAAY,GACZ,iBAAiB,GACjB,UAAU,GACV,eAAe,GACf,aAAa,GACb,iBAAiB,GACjB,cAAc,GACd,sBAAsB,GACtB,MAAM,GACN,iBAAiB,GACjB,aAAa,GACb,WAAW,GACX,iBAAiB,GACjB,aAAa,GACb,aAAa,GACb,sBAAsB,GACtB,SAAS,GACT,iBAAiB,GACjB,SAAS,GACT,2BAA2B,GAC3B,WAAW,GACX,uBAAuB,GACvB,gBAAgB,GAChB,4BAA4B,GAC5B,sBAAsB,GACtB,2BAA2B,GAC3B,sBAAsB,GACtB,qBAAqB,CAAA;AAEzB,KAAK,YAAY,CAAC,CAAC,SAAS,UAAU,IAAI,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAA;AAExF,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAC3D,cAAc,CAAC,CAAC,CAAC,EACjB,SAAS,GAAG,cAAc,CAC3B,GAAG;IAAE,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;CAAE,CAAA;AAGpD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAC9D,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC,CAChD,GAAG;IAAE,YAAY,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC,CAAA;CAAE,CAAA;AAEpE,yFAAyF;AACzF,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,UAAU,EACxD,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAC/B,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC5B,cAAc,CAAC,CAAC,CAAC,CAMnB"}

package/dist/definition-contributions.js

@@ -0,0 +1,8 @@
+/** Top-level replacement; capabilities merge once. Arrays and functions are replaced. */
+export function composeNodeDefinition(render, edit) {
+    return {
+        ...render,
+        ...edit,
+        capabilities: { ...render.capabilities, ...edit.capabilities },
+    };
+}

package/dist/door/actions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The door's action-menu contributions, in 2D and 3D: swap the hinge side and swap the swing
+ * side without opening the panel's Swing section. One undo step each; a closed door opens so
+ * the new swing shows.
+ */
+export default function DoorActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=actions.d.ts.map

package/dist/door/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/door/actions.tsx"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAiClC"}

package/dist/door/actions.js

@@ -0,0 +1,32 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { ActionMenuButton } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { ArrowLeftRight, ArrowUpDown } from 'lucide-react';
+import { applyOpeningSwap } from '../shared/opening-swap.js';
+import { doorMechanism } from './mechanism.js';
+import { canSwapDoorHinge, canSwapDoorSwing, swapDoorHingePatch, swapDoorSwingPatch } from './swing.js';
+/**
+ * The door's action-menu contributions, in 2D and 3D: swap the hinge side and swap the swing
+ * side without opening the panel's Swing section. One undo step each; a closed door opens so
+ * the new swing shows.
+ */
+export default function DoorActions() {
+    const i18n = usePascalI18n();
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const door = useScene((s) => {
+        const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
+        return node?.type === 'door' ? node : undefined;
+    });
+    const readOnly = useScene((s) => s.readOnly);
+    if (!door || readOnly || !canSwapDoorSwing(door))
+        return null;
+    return (_jsxs(_Fragment, { children: [canSwapDoorHinge(door) ? (_jsx(ActionMenuButton, { label: i18n._({ id: 'node.door.actions.swapHingeSide', message: 'Swap hinge side' }), onClick: (event) => {
+                    event.stopPropagation();
+                    applyOpeningSwap(door, swapDoorHingePatch(door), doorMechanism);
+                }, children: _jsx(ArrowLeftRight, { className: "h-4 w-4" }) })) : null, _jsx(ActionMenuButton, { label: i18n._({ id: 'node.door.actions.swapSwingSide', message: 'Swap swing side' }), onClick: (event) => {
+                    event.stopPropagation();
+                    applyOpeningSwap(door, swapDoorSwingPatch(door), doorMechanism);
+                }, children: _jsx(ArrowUpDown, { className: "h-4 w-4" }) })] }));
+}

package/dist/door/contextual-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/door/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGpF,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAK1B"}
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/door/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIpF,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAkB1B"}

package/dist/door/contextual-dimensions.js

@@ -1,6 +1,16 @@
+import { getDoorOpeningSize, openingHostFacing } from '@pascal-app/core';
 import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions.js';
 export function buildDoorContextualDimensions(node, ctx) {
-    return buildWallHostedOpeningContextualDimensions(node, ctx, {
+    const size = getDoorOpeningSize(node);
+    return buildWallHostedOpeningContextualDimensions({
+        ...node,
+        width: size.width,
+        position: [
+            node.position[0] - size.leafOffsetX * openingHostFacing(node),
+            node.position[1],
+            node.position[2],
+        ],
+    }, ctx, {
         showClearancesWhileMoving: false,
         useExteriorNormal: false,
     });