@pascal-app/nodes 1.0.7 → 1.1.0

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAoMvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAmFlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG9B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAQvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AA2M5C,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CA6B9E,CAAA"}

package/dist/skylight/definition.edit.js

@@ -0,0 +1,218 @@
+import { buildSkylightFloorplan } from './floorplan.js';
+import { closeSkylightOpenState, isOperableSkylightNode, toggleSkylightOpenState, } from './interaction.js';
+import { skylightParametrics } from './parametrics.js';
+// In-world handle constants. Offsets are measured from the skylight's
+// edge to the arrow's CENTER, so they need to clear half the chevron's
+// own length (~13 cm at default scale) plus the frame's outward depth
+// before there's any visible gap. 0.35 m leaves ~15 cm of clear space
+// between the chevron's tail and the skylight frame for a typical
+// flat / opening skylight; rotate gizmo gets a matching cushion.
+const SIDE_HANDLE_OFFSET = 0.35;
+const ROTATE_CORNER_OFFSET = 0.35;
+// Small +X bump so the rotate gizmo reads as sitting *beside* the corner
+// instead of perched on its edge — visually separates it from the
+// width chevron that shares the +X side.
+const ROTATE_CORNER_X_OFFSET = 0.2;
+// Lift the rotate gizmo a little off the surface so it floats above the
+// frame instead of sinking into the curb / shingles around the corner.
+const ROTATE_CORNER_Y_OFFSET = 0.18;
+const ROTATE_RING_OFFSET = 0.06;
+// Curb arrow sits a small distance above the current curb top so it stays
+// grabbable when the curb collapses to zero (flat / walk-on look) and
+// doesn't sink into the frame for tall lantern curbs.
+const CURB_HANDLE_OFFSET = 0.18;
+const MIN_SKYLIGHT_DIM = 0.2;
+const MIN_FRAME_THICKNESS = 0.005;
+// Width arrows live on ±X (left / right edges of the skylight footprint).
+// Asymmetric resize: each arrow only moves its own edge, the opposite
+// edge stays put — same pattern as the door and the roof-segment width
+// handles. `position` is in segment-surface-tangent coords, so after
+// changing width we recenter `position` by half the delta along the
+// skylight's own +X axis (rotated by `node.rotation` since the inner
+// rotation-y group puts skylight-local X at an angle relative to
+// segment-local X).
+function skylightWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_SKYLIGHT_DIM,
+        currentValue: (n) => n.width,
+        apply: (initial, newWidth) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: newWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        // Grandparent so handles render inside the roof (visible) instead of
+        // the segment mesh, which lives inside the roof renderer's
+        // `<group visible={false}>` segments wrapper. See skylight/renderer
+        // for the matching composed-transform group that backs this.
+        portal: 'grandparent',
+    };
+}
+// Height arrows on ±Z. Skylight `height` is the dimension along the
+// roof's slope direction (X is across-slope). Same asymmetric pattern as
+// width — anchored edge stays world-fixed, position recenters by half
+// delta along the skylight's own +Z axis (rotated by `node.rotation`).
+function skylightHeightHandle(side) {
+    const sign = side === 'top' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: side === 'top' ? 'min' : 'max',
+        min: MIN_SKYLIGHT_DIM,
+        currentValue: (n) => n.height,
+        apply: (initial, newHeight) => {
+            const rotY = initial.rotation ?? 0;
+            // Skylight-local +Z projects onto segment-surface +X / +Z as
+            // (sin r, cos r) — orthogonal to the (cos r, -sin r) basis used
+            // for the +X axis above.
+            const armX = Math.sin(rotY);
+            const armZ = Math.cos(rotY);
+            const anchorX = initial.position[0] - sign * (initial.height / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.height / 2) * armZ;
+            const newCenterX = anchorX + sign * (newHeight / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newHeight / 2) * armZ;
+            return {
+                height: newHeight,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [0, 0, sign * (n.height / 2 + SIDE_HANDLE_OFFSET)],
+            // The +Z chevron points along +Z by default (axis 'z' auto-rotates
+            // -π/2 in LinearArrow). For the -Z handle, add +π so it flips.
+            rotationY: () => (side === 'top' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+// Rotate gizmo at the +X+Z corner of the footprint, with a ring guide
+// traced around the corner-diagonal radius — same idiom as the roof-
+// segment / column / elevator rotate gizmos. Negate the cursor delta to
+// match three.js Y-rotation handedness.
+function skylightRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => {
+                const halfX = n.width / 2;
+                const halfZ = n.height / 2;
+                return [
+                    halfX + ROTATE_CORNER_X_OFFSET,
+                    ROTATE_CORNER_Y_OFFSET,
+                    halfZ + ROTATE_CORNER_OFFSET,
+                ];
+            },
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2, n.height / 2) + ROTATE_RING_OFFSET,
+            y: () => 0,
+        },
+        portal: 'grandparent',
+    };
+}
+// Curb-height arrow — vertical chevron above the skylight, dragged up
+// to raise the curb. Auto-enables `curb: true` when the user grows from
+// zero so the geometry actually has a curb to show; preserves `curb`
+// flag once it's been set. Placement floats just above the curb top so
+// it tracks the value as the user drags and stays above the frame for
+// tall lantern curbs.
+function skylightCurbHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: 0,
+        currentValue: (n) => n.curbHeight ?? 0,
+        apply: (initial, newValue) => ({
+            curbHeight: newValue,
+            // Without this, dragging the arrow on a walk-on (curb: false)
+            // skylight would change `curbHeight` invisibly because the
+            // geometry path ignores it when `curb` is false.
+            curb: initial.curb || newValue > 0,
+        }),
+        placement: {
+            position: (n) => [0, (n.curbHeight ?? 0) + CURB_HANDLE_OFFSET, 0],
+        },
+        portal: 'grandparent',
+    };
+}
+// Frame-thickness arrow — diagonal chevron at the -X+Z (top-left) corner,
+// pointing outward along the corner bisector. Lives on the opposite
+// corner from the rotate gizmo so they don't compete. axis='z' (instead
+// of 'x') so dragging outward toward +Z grows the value 1:1; LinearArrow
+// auto-rotates a 'z'-axis chevron by -π/2 (so it points +Z), and the
+// extra -π/4 here swings the chevron to -X+Z. The X+Z offsets match
+// SIDE_HANDLE_OFFSET on each axis, so the arrow sits the same visual
+// distance from the corner that the side chevrons sit from their edges.
+function skylightFrameThicknessHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'min',
+        min: MIN_FRAME_THICKNESS,
+        currentValue: (n) => n.frameThickness ?? 0.05,
+        apply: (_n, newValue) => ({ frameThickness: newValue }),
+        placement: {
+            position: (n) => [-(n.width / 2) - SIDE_HANDLE_OFFSET, 0, n.height / 2 + SIDE_HANDLE_OFFSET],
+            rotationY: () => -Math.PI / 4,
+        },
+        portal: 'grandparent',
+    };
+}
+const skylightHandles = [
+    skylightWidthHandle('right'),
+    skylightWidthHandle('left'),
+    skylightHeightHandle('top'),
+    skylightHeightHandle('bottom'),
+    skylightCurbHeightHandle(),
+    skylightFrameThicknessHandle(),
+    skylightRotateHandle(),
+];
+export const skylightEditContribution = {
+    snapProfile: 'item',
+    parametrics: skylightParametrics,
+    handles: skylightHandles,
+    floorplan: buildSkylightFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place skylight on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    // R toggles open ↔ closed on operable types (opening / sliding); T
+    // forces close. The animation runs through `useInteractive` and the
+    // skylight system; see `./interaction.ts`.
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'skylight' && isOperableSkylightNode(node),
+            run: (node) => toggleSkylightOpenState(node.id),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'skylight' && isOperableSkylightNode(node),
+            run: (node) => closeSkylightOpenState(node.id),
+        },
+    },
+};

package/dist/skylight/definition.js

@@ -1,271 +1,4 @@
-import { SkylightNode as SkylightNodeSchema, } from '@pascal-app/core';
-import { buildSkylightFloorplan } from './floorplan.js';
-import { closeSkylightOpenState, isOperableSkylightNode, toggleSkylightOpenState, } from './interaction.js';
-import { skylightParametrics } from './parametrics.js';
-import { buildSkylightRoofCut } from './roof-cut.js';
-import { SkylightNode } from './schema.js';
-// In-world handle constants. Offsets are measured from the skylight's
-// edge to the arrow's CENTER, so they need to clear half the chevron's
-// own length (~13 cm at default scale) plus the frame's outward depth
-// before there's any visible gap. 0.35 m leaves ~15 cm of clear space
-// between the chevron's tail and the skylight frame for a typical
-// flat / opening skylight; rotate gizmo gets a matching cushion.
-const SIDE_HANDLE_OFFSET = 0.35;
-const ROTATE_CORNER_OFFSET = 0.35;
-// Small +X bump so the rotate gizmo reads as sitting *beside* the corner
-// instead of perched on its edge — visually separates it from the
-// width chevron that shares the +X side.
-const ROTATE_CORNER_X_OFFSET = 0.2;
-// Lift the rotate gizmo a little off the surface so it floats above the
-// frame instead of sinking into the curb / shingles around the corner.
-const ROTATE_CORNER_Y_OFFSET = 0.18;
-const ROTATE_RING_OFFSET = 0.06;
-// Curb arrow sits a small distance above the current curb top so it stays
-// grabbable when the curb collapses to zero (flat / walk-on look) and
-// doesn't sink into the frame for tall lantern curbs.
-const CURB_HANDLE_OFFSET = 0.18;
-const MIN_SKYLIGHT_DIM = 0.2;
-const MIN_FRAME_THICKNESS = 0.005;
-// Width arrows live on ±X (left / right edges of the skylight footprint).
-// Asymmetric resize: each arrow only moves its own edge, the opposite
-// edge stays put — same pattern as the door and the roof-segment width
-// handles. `position` is in segment-surface-tangent coords, so after
-// changing width we recenter `position` by half the delta along the
-// skylight's own +X axis (rotated by `node.rotation` since the inner
-// rotation-y group puts skylight-local X at an angle relative to
-// segment-local X).
-function skylightWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_SKYLIGHT_DIM,
-        currentValue: (n) => n.width,
-        apply: (initial, newWidth) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
-            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
-            return {
-                width: newWidth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-        // Grandparent so handles render inside the roof (visible) instead of
-        // the segment mesh, which lives inside the roof renderer's
-        // `<group visible={false}>` segments wrapper. See skylight/renderer
-        // for the matching composed-transform group that backs this.
-        portal: 'grandparent',
-    };
-}
-// Height arrows on ±Z. Skylight `height` is the dimension along the
-// roof's slope direction (X is across-slope). Same asymmetric pattern as
-// width — anchored edge stays world-fixed, position recenters by half
-// delta along the skylight's own +Z axis (rotated by `node.rotation`).
-function skylightHeightHandle(side) {
-    const sign = side === 'top' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: side === 'top' ? 'min' : 'max',
-        min: MIN_SKYLIGHT_DIM,
-        currentValue: (n) => n.height,
-        apply: (initial, newHeight) => {
-            const rotY = initial.rotation ?? 0;
-            // Skylight-local +Z projects onto segment-surface +X / +Z as
-            // (sin r, cos r) — orthogonal to the (cos r, -sin r) basis used
-            // for the +X axis above.
-            const armX = Math.sin(rotY);
-            const armZ = Math.cos(rotY);
-            const anchorX = initial.position[0] - sign * (initial.height / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.height / 2) * armZ;
-            const newCenterX = anchorX + sign * (newHeight / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newHeight / 2) * armZ;
-            return {
-                height: newHeight,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [0, 0, sign * (n.height / 2 + SIDE_HANDLE_OFFSET)],
-            // The +Z chevron points along +Z by default (axis 'z' auto-rotates
-            // -π/2 in LinearArrow). For the -Z handle, add +π so it flips.
-            rotationY: () => (side === 'top' ? 0 : Math.PI),
-        },
-        portal: 'grandparent',
-    };
-}
-// Rotate gizmo at the +X+Z corner of the footprint, with a ring guide
-// traced around the corner-diagonal radius — same idiom as the roof-
-// segment / column / elevator rotate gizmos. Negate the cursor delta to
-// match three.js Y-rotation handedness.
-function skylightRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n) => {
-                const halfX = n.width / 2;
-                const halfZ = n.height / 2;
-                return [
-                    halfX + ROTATE_CORNER_X_OFFSET,
-                    ROTATE_CORNER_Y_OFFSET,
-                    halfZ + ROTATE_CORNER_OFFSET,
-                ];
-            },
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => Math.hypot(n.width / 2, n.height / 2) + ROTATE_RING_OFFSET,
-            y: () => 0,
-        },
-        portal: 'grandparent',
-    };
-}
-// Curb-height arrow — vertical chevron above the skylight, dragged up
-// to raise the curb. Auto-enables `curb: true` when the user grows from
-// zero so the geometry actually has a curb to show; preserves `curb`
-// flag once it's been set. Placement floats just above the curb top so
-// it tracks the value as the user drags and stays above the frame for
-// tall lantern curbs.
-function skylightCurbHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: 0,
-        currentValue: (n) => n.curbHeight ?? 0,
-        apply: (initial, newValue) => ({
-            curbHeight: newValue,
-            // Without this, dragging the arrow on a walk-on (curb: false)
-            // skylight would change `curbHeight` invisibly because the
-            // geometry path ignores it when `curb` is false.
-            curb: initial.curb || newValue > 0,
-        }),
-        placement: {
-            position: (n) => [0, (n.curbHeight ?? 0) + CURB_HANDLE_OFFSET, 0],
-        },
-        portal: 'grandparent',
-    };
-}
-// Frame-thickness arrow — diagonal chevron at the -X+Z (top-left) corner,
-// pointing outward along the corner bisector. Lives on the opposite
-// corner from the rotate gizmo so they don't compete. axis='z' (instead
-// of 'x') so dragging outward toward +Z grows the value 1:1; LinearArrow
-// auto-rotates a 'z'-axis chevron by -π/2 (so it points +Z), and the
-// extra -π/4 here swings the chevron to -X+Z. The X+Z offsets match
-// SIDE_HANDLE_OFFSET on each axis, so the arrow sits the same visual
-// distance from the corner that the side chevrons sit from their edges.
-function skylightFrameThicknessHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: 'min',
-        min: MIN_FRAME_THICKNESS,
-        currentValue: (n) => n.frameThickness ?? 0.05,
-        apply: (_n, newValue) => ({ frameThickness: newValue }),
-        placement: {
-            position: (n) => [-(n.width / 2) - SIDE_HANDLE_OFFSET, 0, n.height / 2 + SIDE_HANDLE_OFFSET],
-            rotationY: () => -Math.PI / 4,
-        },
-        portal: 'grandparent',
-    };
-}
-const skylightHandles = [
-    skylightWidthHandle('right'),
-    skylightWidthHandle('left'),
-    skylightHeightHandle('top'),
-    skylightHeightHandle('bottom'),
-    skylightCurbHeightHandle(),
-    skylightFrameThicknessHandle(),
-    skylightRotateHandle(),
-];
-/**
- * Skylight — a framed glass opening hosted on a roof segment. All five
- * type variants (flat / walk-on / lantern / opening / sliding) render
- * with the archive's full geometry; the animation system advances
- * `operationState` via `useInteractive.skylightAnimations`.
- */
-export const skylightDefinition = {
-    kind: 'skylight',
-    schemaVersion: 1,
-    schema: SkylightNode,
-    category: 'structure',
-    surfaceRole: 'glazing',
-    defaults: () => {
-        const stub = SkylightNodeSchema.parse({
-            id: 'skylight_default',
-            type: 'skylight',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
-        // cascade to the host segment's parent roof so its merged shell
-        // re-CSGs with the new cut. `buildCut` returns the segment-local
-        // box that's subtracted from shin / deck / wall.
-        roofAccessory: {
-            buildCut: (node, hostSegment) => buildSkylightRoofCut(node, hostSegment),
-        },
-    },
-    parametrics: skylightParametrics,
-    handles: skylightHandles,
-    floorplan: buildSkylightFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    system: {
-        module: () => import('./system.js'),
-        priority: 3,
-    },
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place skylight on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Skylight',
-        description: 'Framed glass opening on a roof segment.',
-        icon: { kind: 'url', src: '/icons/skylight.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 124,
-    },
-    mcp: {
-        description: 'A skylight on a roof segment. Five type variants (flat / walk-on / lantern / opening / sliding) — geometry beyond box stub coming later.',
-    },
-    // R toggles open ↔ closed on operable types (opening / sliding); T
-    // forces close. The animation runs through `useInteractive` and the
-    // skylight system; see `./interaction.ts`.
-    keyboardActions: {
-        r: {
-            appliesTo: (node) => node.type === 'skylight' && isOperableSkylightNode(node),
-            run: (node) => toggleSkylightOpenState(node.id),
-        },
-        t: {
-            appliesTo: (node) => node.type === 'skylight' && isOperableSkylightNode(node),
-            run: (node) => closeSkylightOpenState(node.id),
-        },
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { skylightEditContribution } from './definition.edit.js';
+import { skylightRenderDefinition } from './definition.render.js';
+export const skylightDefinition = composeNodeDefinition(skylightRenderDefinition, skylightEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAAC,GAAG;IACjF,IAAI,EAAE,UAAU,CAAA;CAiDjB,CAAA"}

package/dist/skylight/definition.render.js

@@ -0,0 +1,50 @@
+import { SkylightNode as SkylightNodeSchema, } from '@pascal-app/core';
+import { buildSkylightRoofCut } from './roof-cut.js';
+import { SkylightNode } from './schema.js';
+export const skylightRenderDefinition = {
+    kind: 'skylight',
+    schemaVersion: 1,
+    schema: SkylightNode,
+    category: 'structure',
+    surfaceRole: 'glazing',
+    defaults: () => {
+        const stub = SkylightNodeSchema.parse({
+            id: 'skylight_default',
+            type: 'skylight',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
+        // cascade to the host segment's parent roof so its merged shell
+        // re-CSGs with the new cut. `buildCut` returns the segment-local
+        // box that's subtracted from shin / deck / wall.
+        roofAccessory: {
+            buildCut: (node, hostSegment) => buildSkylightRoofCut(node, hostSegment),
+        },
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Skylight',
+        description: 'Framed glass opening on a roof segment.',
+        icon: { kind: 'url', src: '/icons/skylight.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 124,
+    },
+    mcp: {
+        description: 'A skylight on a roof segment. Five type variants (flat / walk-on / lantern / opening / sliding) — geometry beyond box stub coming later.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/skylight/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAA;AAuBzB,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,sCAiQxE"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/skylight/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAA;AA0BzB,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,sCAqQxE"}

package/dist/skylight/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, useRef, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -58,9 +58,9 @@ export default function MoveSkylightTool({ 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,
             });
         };
         // Resolve which segment the cursor is over, then derive the same
@@ -97,7 +97,9 @@ export default function MoveSkylightTool({ node }) {
         const onRoofMove = (event) => {
             const sx = Math.round(event.position[0] * 20) / 20;
             const sz = Math.round(event.position[2] * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true && (sx !== lastSnapX || sz !== lastSnapZ)) {
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
+                (sx !== lastSnapX || sz !== lastSnapZ)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnapX = sx;
                 lastSnapZ = sz;
@@ -133,7 +135,7 @@ export default function MoveSkylightTool({ node }) {
                 position: [target.localX, target.localY, target.localZ],
                 rotation: finalRotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             if (original.roofSegmentId && original.roofSegmentId !== targetSegmentId) {
                 const oldSeg = st.nodes[original.roofSegmentId];