@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/elevator/tool.js

@@ -0,0 +1,250 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { collectAlignmentAnchors, ElevatorNode, emitter, resolveAlignment, useScene, } from '@pascal-app/core';
+import { CursorSphere, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, resolveCurrentBuildingId, resolveElevatorSupportY, triggerSFX, useAlignmentGuides, useEditor, usePlacementPreview, useRegistryToolContext, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+const defaults = ElevatorNode.parse({});
+const DEFAULT_ELEVATOR_WIDTH = defaults.width;
+const DEFAULT_ELEVATOR_DEPTH = defaults.depth;
+const DEFAULT_ELEVATOR_CAB_HEIGHT = defaults.cabHeight;
+const DEFAULT_ELEVATOR_DOOR_WIDTH = defaults.doorWidth;
+const DEFAULT_ELEVATOR_DOOR_HEIGHT = defaults.doorHeight;
+const DEFAULT_ELEVATOR_SPEED = defaults.speed;
+const DEFAULT_ELEVATOR_DOOR_DURATION_MS = defaults.doorDurationMs;
+const DEFAULT_ELEVATOR_DWELL_MS = defaults.dwellMs;
+const isTypingTarget = (target) => target instanceof HTMLElement &&
+    !!target.closest('input, textarea, select, [contenteditable="true"]');
+const GRID_OFFSET = 0.02;
+/** Figma-style alignment-snap threshold (meters), matching the move tools. */
+const ALIGNMENT_THRESHOLD_M = 0.08;
+function resolveDefaultServiceRange(buildingId, selectedLevelId) {
+    const nodes = useScene.getState().nodes;
+    const building = nodes[buildingId];
+    if (building?.type !== 'building') {
+        return { defaultLevelId: null, fromLevelId: null, toLevelId: null };
+    }
+    const levels = building.children
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'level')
+        .sort((left, right) => left.level - right.level);
+    const selectedLevelIndex = levels.findIndex((level) => level.id === selectedLevelId);
+    const fromIndex = Math.max(selectedLevelIndex, 0);
+    const fromLevel = levels[fromIndex];
+    const toLevel = levels[Math.min(fromIndex + 1, levels.length - 1)] ?? fromLevel;
+    return {
+        defaultLevelId: fromLevel?.id ?? null,
+        fromLevelId: fromLevel?.id ?? null,
+        toLevelId: toLevel?.id ?? fromLevel?.id ?? null,
+    };
+}
+function createElevatorPreviewGeometry() {
+    return new THREE.BoxGeometry(DEFAULT_ELEVATOR_WIDTH, DEFAULT_ELEVATOR_CAB_HEIGHT, DEFAULT_ELEVATOR_DEPTH);
+}
+function createElevatorPreviewEdgeGeometry() {
+    const box = createElevatorPreviewGeometry();
+    const edges = new THREE.EdgesGeometry(box);
+    box.dispose();
+    return edges;
+}
+function commitElevatorPlacement(buildingId, selectedLevelId, x, z, rotation, onPlaced) {
+    const { createNode, nodes } = useScene.getState();
+    const elevatorCount = Object.values(nodes).filter((node) => node.type === 'elevator').length;
+    const serviceRange = resolveDefaultServiceRange(buildingId, selectedLevelId);
+    const supportY = resolveElevatorSupportY({
+        buildingId,
+        preferredLevelId: serviceRange.fromLevelId ?? serviceRange.defaultLevelId,
+        x,
+        z,
+    });
+    const elevator = ElevatorNode.parse({
+        name: `Elevator ${elevatorCount + 1}`,
+        parentId: buildingId,
+        position: [x, supportY, z],
+        rotation,
+        width: DEFAULT_ELEVATOR_WIDTH,
+        depth: DEFAULT_ELEVATOR_DEPTH,
+        cabHeight: DEFAULT_ELEVATOR_CAB_HEIGHT,
+        doorWidth: DEFAULT_ELEVATOR_DOOR_WIDTH,
+        doorHeight: DEFAULT_ELEVATOR_DOOR_HEIGHT,
+        ...serviceRange,
+        speed: DEFAULT_ELEVATOR_SPEED,
+        doorDurationMs: DEFAULT_ELEVATOR_DOOR_DURATION_MS,
+        dwellMs: DEFAULT_ELEVATOR_DWELL_MS,
+    });
+    createNode(elevator, buildingId);
+    onPlaced?.(elevator.id, buildingId);
+    triggerSFX('sfx:structure-build');
+}
+export default function ElevatorTool() {
+    const { activeLevelId: levelId, selectNode } = useRegistryToolContext();
+    const buildingId = useViewer((state) => state.selection.buildingId);
+    const onPlaced = useMemo(() => (id) => selectNode(id), [selectNode]);
+    const cursorRef = useRef(null);
+    const previewRef = useRef(null);
+    const rotationRef = useRef(0);
+    const previousGridPosRef = useRef(null);
+    const previewGeometry = useMemo(() => createElevatorPreviewGeometry(), []);
+    const previewEdgeGeometry = useMemo(() => createElevatorPreviewEdgeGeometry(), []);
+    // Default-shaped elevator for the 2D floor-plan placement ghost. The 3D
+    // preview meshes below are hidden in 2D (canvas `display:none`), so this
+    // feeds `usePlacementPreview` → `FloorplanPlacementPreviewLayer`, which
+    // renders the elevator's footprint following the cursor.
+    const floorplanPreviewNode = useMemo(() => ElevatorNode.parse({
+        name: 'Elevator',
+        position: [0, 0, 0],
+        rotation: 0,
+        width: DEFAULT_ELEVATOR_WIDTH,
+        depth: DEFAULT_ELEVATOR_DEPTH,
+        cabHeight: DEFAULT_ELEVATOR_CAB_HEIGHT,
+        doorWidth: DEFAULT_ELEVATOR_DOOR_WIDTH,
+        doorHeight: DEFAULT_ELEVATOR_DOOR_HEIGHT,
+    }), []);
+    useEffect(() => {
+        const currentBuildingId = resolveCurrentBuildingId({
+            buildingId,
+            levelId,
+            nodes: useScene.getState().nodes,
+        });
+        if (!currentBuildingId)
+            return;
+        rotationRef.current = 0;
+        if (previewRef.current)
+            previewRef.current.rotation.y = 0;
+        // Alignment candidates — anchors of every alignable object; refreshed
+        // after each placement. The elevator aligns by its ORIGIN point.
+        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', levelId);
+        // Snap the elevator origin onto another object's nearest real anchor and
+        // publish the guide. The probe is the RAW cursor, NOT the 0.5m-grid-snapped
+        // point: resolving against the grid point would only ever catch anchors
+        // that happen to sit on a grid line, so off-grid items (furniture, angled
+        // walls) would never surface a guide. The matched axis locks exactly to the
+        // candidate's coordinate; the other axis keeps its grid snap. Guides are
+        // published in every snapping mode (including Off); the magnetic pull toward
+        // them (applySnap) applies only in 'lines' mode.
+        const alignPoint = (gridX, gridZ, rawX, rawZ, bypass, applySnap) => {
+            if (bypass || alignmentCandidates.length === 0) {
+                useAlignmentGuides.getState().clear();
+                return [gridX, gridZ];
+            }
+            const ar = resolveAlignment({
+                moving: [{ nodeId: '__elevator-draft__', kind: 'corner', x: rawX, z: rawZ }],
+                candidates: alignmentCandidates,
+                threshold: ALIGNMENT_THRESHOLD_M,
+            });
+            if (ar.guides.length === 0) {
+                useAlignmentGuides.getState().clear();
+                return [gridX, gridZ];
+            }
+            useAlignmentGuides.getState().set(ar.guides);
+            if (!applySnap)
+                return [gridX, gridZ];
+            let x = gridX;
+            let z = gridZ;
+            for (const guide of ar.guides) {
+                if (guide.axis === 'x')
+                    x = guide.coord;
+                else
+                    z = guide.coord;
+            }
+            return [x, z];
+        };
+        const onGridMove = (event) => {
+            // Grid snap follows the global mode (live step so the HUD chip is
+            // honest); Off keeps the raw cursor. Shift cycles the mode centrally.
+            const step = useEditor.getState().gridSnapStep;
+            const [gridX, gridZ] = alignPoint(isGridSnapActive()
+                ? Math.round(event.localPosition[0] / step) * step
+                : event.localPosition[0], isGridSnapActive()
+                ? Math.round(event.localPosition[2] / step) * step
+                : event.localPosition[2], event.localPosition[0], event.localPosition[2], !isAlignmentGuideActive(), isMagneticSnapActive());
+            const supportY = resolveElevatorSupportY({
+                buildingId: currentBuildingId,
+                preferredLevelId: levelId,
+                x: gridX,
+                z: gridZ,
+            });
+            cursorRef.current?.position.set(gridX, supportY + GRID_OFFSET, gridZ);
+            previewRef.current?.position.set(gridX, supportY + DEFAULT_ELEVATOR_CAB_HEIGHT / 2, gridZ);
+            // Publish the 2D floor-plan ghost at the snapped/aligned cursor.
+            usePlacementPreview.getState().set({
+                ...floorplanPreviewNode,
+                position: [gridX, supportY, gridZ],
+                rotation: rotationRef.current,
+            });
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                previousGridPosRef.current &&
+                (gridX !== previousGridPosRef.current[0] || gridZ !== previousGridPosRef.current[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousGridPosRef.current = [gridX, gridZ];
+        };
+        const onGridClick = (event) => {
+            const latestBuildingId = resolveCurrentBuildingId({
+                buildingId,
+                levelId,
+                nodes: useScene.getState().nodes,
+            });
+            if (!latestBuildingId)
+                return;
+            const step = useEditor.getState().gridSnapStep;
+            const [gridX, gridZ] = alignPoint(isGridSnapActive()
+                ? Math.round(event.localPosition[0] / step) * step
+                : event.localPosition[0], isGridSnapActive()
+                ? Math.round(event.localPosition[2] / step) * step
+                : event.localPosition[2], event.localPosition[0], event.localPosition[2], !isAlignmentGuideActive(), isMagneticSnapActive());
+            commitElevatorPlacement(latestBuildingId, levelId, gridX, gridZ, rotationRef.current, onPlaced);
+            alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', levelId);
+            useAlignmentGuides.getState().clear();
+            // The placed elevator's footprint now renders for real; drop the ghost
+            // (the next grid:move re-publishes it for the following placement).
+            usePlacementPreview.getState().clear();
+        };
+        const onKeyDown = (event) => {
+            if (isTypingTarget(event.target))
+                return;
+            const ROTATION_STEP = Math.PI / 4;
+            let rotationDelta = 0;
+            if (event.key === 'r' || event.key === 'R')
+                rotationDelta = ROTATION_STEP;
+            else if (event.key === 't' || event.key === 'T')
+                rotationDelta = -ROTATION_STEP;
+            if (rotationDelta !== 0) {
+                event.preventDefault();
+                triggerSFX('sfx:item-rotate');
+                rotationRef.current += rotationDelta;
+                if (previewRef.current)
+                    previewRef.current.rotation.y = rotationRef.current;
+                // Reflect the rotation in the 2D ghost immediately (no pointer move
+                // needed) by republishing at the last snapped cursor position.
+                const last = previousGridPosRef.current;
+                if (last) {
+                    usePlacementPreview.getState().set({
+                        ...floorplanPreviewNode,
+                        position: [last[0], 0, last[1]],
+                        rotation: rotationRef.current,
+                    });
+                }
+            }
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            window.removeEventListener('keydown', onKeyDown);
+            useAlignmentGuides.getState().clear();
+            usePlacementPreview.getState().clear();
+        };
+    }, [buildingId, levelId, onPlaced, floorplanPreviewNode]);
+    return (_jsxs("group", { children: [_jsx(CursorSphere, { ref: cursorRef }), _jsxs("group", { ref: previewRef, children: [_jsx("mesh", { geometry: previewGeometry, children: _jsx("meshStandardMaterial", { color: "#38bdf8", depthWrite: false, opacity: 0.12, transparent: true }) }), _jsx("lineSegments", { geometry: previewEdgeGeometry, children: _jsx("lineBasicMaterial", { color: "#38bdf8", opacity: 0.9, transparent: true }) }), _jsxs("mesh", { position: [0, -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + 0.015, 0], rotation: [-Math.PI / 2, 0, 0], children: [_jsx("planeGeometry", { args: [DEFAULT_ELEVATOR_WIDTH, DEFAULT_ELEVATOR_DEPTH] }), _jsx("meshBasicMaterial", { color: "#38bdf8", opacity: 0.16, transparent: true })] }), _jsxs("mesh", { position: [0, 0, -DEFAULT_ELEVATOR_DEPTH / 2 - 0.01], children: [_jsx("planeGeometry", { args: [DEFAULT_ELEVATOR_WIDTH, DEFAULT_ELEVATOR_CAB_HEIGHT] }), _jsx("meshBasicMaterial", { color: "#e0f2fe", opacity: 0.18, transparent: true })] }), _jsxs("mesh", { position: [
+                            0,
+                            -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + DEFAULT_ELEVATOR_DOOR_HEIGHT / 2,
+                            -DEFAULT_ELEVATOR_DEPTH / 2 - 0.03,
+                        ], children: [_jsx("boxGeometry", { args: [DEFAULT_ELEVATOR_DOOR_WIDTH, DEFAULT_ELEVATOR_DOOR_HEIGHT, 0.035] }), _jsx("meshStandardMaterial", { color: "#e5e7eb", depthWrite: false, opacity: 0.45, transparent: true })] }), _jsxs("mesh", { position: [
+                            0,
+                            -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + DEFAULT_ELEVATOR_DOOR_HEIGHT / 2,
+                            -DEFAULT_ELEVATOR_DEPTH / 2 - 0.049,
+                        ], children: [_jsx("boxGeometry", { args: [DEFAULT_ELEVATOR_DOOR_WIDTH + 0.14, DEFAULT_ELEVATOR_DOOR_HEIGHT + 0.14, 0.01] }), _jsx("meshBasicMaterial", { color: "#38bdf8", opacity: 0.5, transparent: true })] })] })] }));
+}

package/dist/eyebrow-vent/definition.d.ts

@@ -1,12 +1,98 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { EyebrowVentNode } from './schema.js';
-/**
- * Eyebrow vent — a low, curved lens-shaped hood with a louvered front that
- * sweeps out of a roof slope. 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 / cupola (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 eyebrowVentDefinition: NodeDefinition<typeof EyebrowVentNode>;
+export declare const eyebrowVentDefinition: 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<`eyebrow-vent_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"eyebrow-vent">>;
+    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>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "half-round": "half-round";
+        scoop: "scoop";
+        "slant-box": "slant-box";
+    }>>;
+    louverCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    backRatio: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/eyebrow-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA6DxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

package/dist/eyebrow-vent/definition.edit.d.ts

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

package/dist/eyebrow-vent/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoG/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAgBpF,CAAA"}

package/dist/eyebrow-vent/definition.edit.js

@@ -0,0 +1,104 @@
+import { eyebrowVentPaint } from './paint.js';
+import { eyebrowVentParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.3;
+const HEIGHT_HANDLE_OFFSET = 0.2;
+// Snug to the vent corner so the rotate icon stays close to the item.
+const ROTATE_CORNER_OFFSET = 0.12;
+const MIN_WIDTH = 0.4;
+const MIN_DEPTH = 0.2;
+const MIN_HEIGHT = 0.08;
+// Mid-Y of the arch (its tallest point is `height`), used to seat the side /
+// rotate chevrons against the body and centre the rotate ring.
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Width (span) and depth grow symmetrically from the centre — eyebrow vents
+// are placed by their centre — so a single centred chevron per axis.
+function eyebrowWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_WIDTH,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: Math.max(MIN_WIDTH, newValue) }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+function eyebrowDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_DEPTH,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: Math.max(MIN_DEPTH, newValue) }),
+        placement: {
+            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+function eyebrowHeightHandle() {
+    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 eyebrowRotateHandle() {
+    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 vent, sized to pass through the corner icon so
+        // the icon rides the ring — matches cupola / solar-panel.
+        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 vent
+// rides the roof→segment→node frame chain, so the handle rig must too, or the
+// handles (and rotate arc) render offset from the vent.
+const eyebrowVentHandles = [
+    eyebrowWidthHandle(),
+    eyebrowDepthHandle(),
+    eyebrowHeightHandle(),
+    eyebrowRotateHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+export const eyebrowVentEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: eyebrowVentPaint,
+    },
+    parametrics: eyebrowVentParametrics,
+    handles: eyebrowVentHandles,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place eyebrow vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/eyebrow-vent/definition.js

@@ -1,152 +1,4 @@
-import { EyebrowVentNode as EyebrowVentNodeSchema, eyebrowVentSlots, } from '@pascal-app/core';
-import { buildEyebrowVentFloorplan } from './floorplan.js';
-import { eyebrowVentPaint } from './paint.js';
-import { eyebrowVentParametrics } from './parametrics.js';
-import { EyebrowVentNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.3;
-const HEIGHT_HANDLE_OFFSET = 0.2;
-// Snug to the vent corner so the rotate icon stays close to the item.
-const ROTATE_CORNER_OFFSET = 0.12;
-const MIN_WIDTH = 0.4;
-const MIN_DEPTH = 0.2;
-const MIN_HEIGHT = 0.08;
-// Mid-Y of the arch (its tallest point is `height`), used to seat the side /
-// rotate chevrons against the body and centre the rotate ring.
-function getBodyMidY(n) {
-    return Math.max(0.001, n.height) / 2;
-}
-// Width (span) and depth grow symmetrically from the centre — eyebrow vents
-// are placed by their centre — so a single centred chevron per axis.
-function eyebrowWidthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_WIDTH,
-        currentValue: (n) => n.width,
-        apply: (_n, newValue) => ({ width: Math.max(MIN_WIDTH, newValue) }),
-        placement: {
-            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
-        },
-    };
-}
-function eyebrowDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: 'center',
-        min: MIN_DEPTH,
-        currentValue: (n) => n.depth,
-        apply: (_n, newValue) => ({ depth: Math.max(MIN_DEPTH, newValue) }),
-        placement: {
-            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
-        },
-    };
-}
-function eyebrowHeightHandle() {
-    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 eyebrowRotateHandle() {
-    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 vent, sized to pass through the corner icon so
-        // the icon rides the ring — matches cupola / solar-panel.
-        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 vent
-// rides the roof→segment→node frame chain, so the handle rig must too, or the
-// handles (and rotate arc) render offset from the vent.
-const eyebrowVentHandles = [
-    eyebrowWidthHandle(),
-    eyebrowDepthHandle(),
-    eyebrowHeightHandle(),
-    eyebrowRotateHandle(),
-].map((h) => ({ ...h, portal: 'grandparent' }));
-/**
- * Eyebrow vent — a low, curved lens-shaped hood with a louvered front that
- * sweeps out of a roof slope. 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 / cupola (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 eyebrowVentDefinition = {
-    kind: 'eyebrow-vent',
-    schemaVersion: 3,
-    schema: EyebrowVentNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        const stub = EyebrowVentNodeSchema.parse({
-            id: 'eyebrow-vent_default',
-            type: 'eyebrow-vent',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: eyebrowVentSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: eyebrowVentPaint,
-        // 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 vent moves / resizes.
-        roofAccessory: {},
-    },
-    parametrics: eyebrowVentParametrics,
-    handles: eyebrowVentHandles,
-    floorplan: buildEyebrowVentFloorplan,
-    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 eyebrow vent on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Eyebrow Vent',
-        description: 'Low curved lens-shaped roof vent with a louvered front.',
-        icon: { kind: 'url', src: '/icons/eyebrow-vent.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 123,
-    },
-    mcp: {
-        description: 'A low curved eyebrow vent on a roof segment — a lens-shaped hood with an optional louvered front. Parametric width (span) / depth / height.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { eyebrowVentEditContribution } from './definition.edit.js';
+import { eyebrowVentRenderDefinition } from './definition.render.js';
+export const eyebrowVentDefinition = composeNodeDefinition(eyebrowVentRenderDefinition, eyebrowVentEditContribution);

package/dist/eyebrow-vent/definition.render.d.ts

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

package/dist/eyebrow-vent/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CA2CrB,CAAA"}