@pascal-app/nodes 0.1.1

package/dist/ridge-vent/move-tool.d.ts

@@ -0,0 +1,12 @@
+import { type RidgeVentNode } from '@pascal-app/core';
+/**
+ * Ridge-vent move tool. Mirrors the box-vent move flow — ghost follows
+ * the cursor over any roof segment, click commits the new position +
+ * parent segment in one undoable step. The ridge sits along the ridge
+ * line, so we don't tilt the preview by the segment slope (the renderer
+ * places the vent on the peak); we just yaw it with the roof + segment.
+ */
+export default function MoveRidgeVentTool({ node }: {
+    node: RidgeVentNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/ridge-vent/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AA4BzB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,sCAyN1E"}

package/dist/ridge-vent/move-tool.js

@@ -0,0 +1,210 @@
+'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 { useCallback, useEffect, useState } from 'react';
+import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag';
+import { resolveRidgeSnap } from '../shared/ridge-snap';
+import { getRoofTopSurfaceY } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, } from '../shared/roof-surface-placement-guides';
+import RidgeVentPreview from './preview';
+/**
+ * Ridge-vent move tool. Mirrors the box-vent move flow — ghost follows
+ * the cursor over any roof segment, click commits the new position +
+ * parent segment in one undoable step. The ridge sits along the ridge
+ * line, so we don't tilt the preview by the segment slope (the renderer
+ * places the vent on the peak); we just yaw it with the roof + segment.
+ */
+export default function MoveRidgeVentTool({ node }) {
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        const ventObj = sceneRegistry.nodes.get(node.id);
+        if (ventObj)
+            ventObj.visible = false;
+        let lastSnap = null;
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag(original);
+        const clearTarget = () => {
+            lastTarget = null;
+            lastSnap = null;
+            setPreviewPos(null);
+            clearRoofSurfacePlacementGuides();
+        };
+        const resolveTarget = (event) => {
+            const rawTarget = roofDrag.resolve(event);
+            if (!rawTarget)
+                return null;
+            const target = snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true);
+            const snap = resolveRidgeSnap(target.segment, target.localX, target.localZ);
+            if (!snap)
+                return null;
+            const yOffset = original.position[1] ?? 0;
+            return {
+                segment: target.segment,
+                localX: snap.localX,
+                localY: getRoofTopSurfaceY(snap.localX, snap.localZ, target.segment) + yOffset,
+                localZ: snap.localZ,
+                rotation: snap.rotation,
+            };
+        };
+        const updatePreview = (event) => {
+            const target = resolveTarget(event);
+            if (!target) {
+                clearTarget();
+                return;
+            }
+            lastTarget = target;
+            const sx = Math.round(target.localX * 20) / 20;
+            const sz = Math.round(target.localZ * 20) / 20;
+            if (event.nativeEvent?.shiftKey !== true &&
+                (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnap = [sx, sz];
+            }
+            setPreviewYaw((event.node.rotation ?? 0) + (target.segment.rotation ?? 0) + target.rotation);
+            setPreviewPos(roofSegmentLocalToBuildingLocal(target.segment.id, [
+                target.localX,
+                target.localY,
+                target.localZ,
+            ]));
+            publishRoofSurfaceNodePlacementGuides({
+                roof: event.node,
+                segment: target.segment,
+                center: [target.localX, target.localY, target.localZ],
+                node,
+                mode: 'linear-edge',
+            });
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (committed)
+                return;
+            const target = lastTarget ?? resolveTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const targetSegmentId = target.segment.id;
+            const st = useScene.getState();
+            const prevSegmentId = original.roofSegmentId;
+            if (prevSegmentId && prevSegmentId !== targetSegmentId) {
+                const oldSeg = st.nodes[prevSegmentId];
+                if (oldSeg) {
+                    st.updateNode(prevSegmentId, {
+                        children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                    });
+                }
+                const newSeg = st.nodes[targetSegmentId];
+                if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                    st.updateNode(targetSegmentId, {
+                        children: [...(newSeg.children ?? []), node.id],
+                    });
+                }
+                st.dirtyNodes.add(prevSegmentId);
+            }
+            useScene.temporal.getState().resume();
+            st.updateNode(node.id, {
+                roofSegmentId: targetSegmentId,
+                parentId: targetSegmentId,
+                position: [target.localX, original.position[1] ?? 0, target.localZ],
+                rotation: target.rotation,
+                visible: true,
+                metadata: {},
+            });
+            useScene.temporal.getState().pause();
+            st.dirtyNodes.add(targetSegmentId);
+            st.dirtyNodes.add(node.id);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                const parentId = original.roofSegmentId;
+                if (parentId) {
+                    const parent = useScene.getState().nodes[parentId];
+                    if (parent) {
+                        useScene.getState().updateNode(parentId, {
+                            children: (parent.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                }
+                useScene.getState().deleteNode(node.id);
+                useScene.temporal.getState().resume();
+                markToolCancelConsumed();
+                clearRoofSurfacePlacementGuides();
+                exitMoveMode();
+                return;
+            }
+            useScene.getState().updateNode(node.id, {
+                position: original.position,
+                rotation: original.rotation,
+                roofSegmentId: original.roofSegmentId,
+                parentId: original.parentId,
+                metadata: original.metadata,
+            });
+            if (original.roofSegmentId) {
+                useScene.getState().dirtyNodes.add(original.roofSegmentId);
+            }
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onRoofClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('roof:leave', clearTarget);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [exitMoveMode, node]);
+    if (!previewPos)
+        return null;
+    return (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx(RidgeVentPreview, { node: node }) }) }));
+}

package/dist/ridge-vent/panel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Inspector panel for a placed ridge vent. Same structure as box-vent's
+ * panel — sliders for style / dimensions / position + Move / Duplicate /
+ * Delete actions that route through the kind-owned ghost-drag flow.
+ */
+export default function RidgeVentPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/ridge-vent/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/panel.tsx"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,uCAmQrC"}

package/dist/ridge-vent/panel.js

@@ -0,0 +1,118 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RidgeVentNode as RidgeVentSchema, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Copy, Move, Trash2 } from 'lucide-react';
+import { useCallback } from 'react';
+/**
+ * Inspector panel for a placed ridge vent. Same structure as box-vent's
+ * panel — sliders for style / dimensions / position + Move / Duplicate /
+ * Delete actions that route through the kind-owned ghost-drag flow.
+ */
+export default function RidgeVentPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const segment = useScene((s) => node?.roofSegmentId
+        ? s.nodes[node.roofSegmentId]
+        : undefined);
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+    }, [selectedId, updateNode]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleBack = useCallback(() => {
+        if (node?.roofSegmentId) {
+            setSelection({ selectedIds: [node.roofSegmentId] });
+        }
+    }, [node?.roofSegmentId, setSelection]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        // Type-union escape — see box-vent panel.
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDuplicate = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        const parentId = node.roofSegmentId;
+        if (!parentId)
+            return;
+        const state = useScene.getState();
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const cloneInput = {
+            ...node,
+            id: undefined,
+            metadata: { ...meta, isNew: true },
+        };
+        const cloned = RidgeVentSchema.parse(cloneInput);
+        state.createNode(cloned, parentId);
+        state.dirtyNodes.add(parentId);
+        setMovingNode(cloned);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        const segmentId = node.roofSegmentId;
+        if (segmentId) {
+            const state = useScene.getState();
+            const seg = state.nodes[segmentId];
+            if (seg) {
+                state.updateNode(segmentId, {
+                    children: (seg.children ?? []).filter((id) => id !== selectedId),
+                });
+            }
+        }
+        deleteNode(selectedId);
+        if (segmentId) {
+            useScene.getState().dirtyNodes.add(segmentId);
+            setSelection({ selectedIds: [segmentId] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [selectedId, node, deleteNode, setSelection]);
+    if (!(node && node.type === 'ridge-vent' && selectedId))
+        return null;
+    // Ridge runs along segment-X axis, so the length slider's max ties to
+    // segment.width and the across-ridge X-position to the same span. Z
+    // is the across-slope position — for ridge vents this should stay
+    // near zero (the ridge line), so clamp it to a narrow window around
+    // the segment's center.
+    const halfW = Math.round(((segment?.width ?? 10) / 2) * 100) / 100;
+    const halfD = Math.round(((segment?.depth ?? 10) / 2) * 100) / 100;
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Ridge Vent', width: 300, children: [_jsxs(PanelSection, { title: "Style", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ style: v }), options: [
+                            { label: 'Standard', value: 'standard' },
+                            { label: 'Shingled', value: 'shingled' },
+                            { label: 'Flanged', value: 'metal' },
+                        ], value: node.style ?? 'standard' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ endCaps: v === 'yes' }), options: [
+                            { label: 'End Caps', value: 'yes' },
+                            { label: 'Open', value: 'no' },
+                        ], value: (node.endCaps ?? true) ? 'yes' : 'no' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: 8, min: 0.5, onChange: (v) => handleUpdate({ length: v }), onCommit: (v) => handleUpdate({ length: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.length * 100) / 100 }), _jsx(SliderControl, { label: "Width", max: 0.6, min: 0.1, onChange: (v) => handleUpdate({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 0.2, min: 0.03, onChange: (v) => handleUpdate({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.height * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: halfW, min: -halfW, onChange: (v) => handleUpdate({
+                            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: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: 2, min: -2, onChange: (v) => handleUpdate({
+                            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: Math.round((node.position[1] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: halfD, min: -halfD, onChange: (v) => handleUpdate({
+                            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: Math.round((node.position[2] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => handleUpdate({ 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-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

package/dist/ridge-vent/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { RidgeVentNode } from './schema';
+export declare const ridgeVentParametrics: ParametricDescriptor<RidgeVentNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/ridge-vent/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,aAAa,CA2BpE,CAAA"}

package/dist/ridge-vent/parametrics.js

@@ -0,0 +1,28 @@
+export const ridgeVentParametrics = {
+    // Custom panel exposes Position sliders + Move/Duplicate actions
+    // alongside the style/dimensions controls. See box-vent's parametrics
+    // for the same pattern.
+    customPanel: () => import('./panel'),
+    groups: [
+        {
+            label: 'Style',
+            fields: [
+                {
+                    key: 'style',
+                    kind: 'enum',
+                    options: ['standard', 'shingled', 'metal'],
+                    display: 'segmented',
+                },
+                { key: 'endCaps', kind: 'boolean' },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'length', kind: 'number', unit: 'm', min: 0.5, max: 8, step: 0.05 },
+                { key: 'width', kind: 'number', unit: 'm', min: 0.1, max: 0.6, step: 0.01 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.03, max: 0.2, step: 0.005 },
+            ],
+        },
+    ],
+};

package/dist/ridge-vent/preview.d.ts

@@ -0,0 +1,7 @@
+import type { RidgeVentNode } from './schema';
+declare const RidgeVentPreview: ({ node, invalid }: {
+    node: RidgeVentNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default RidgeVentPreview;
+//# sourceMappingURL=preview.d.ts.map

package/dist/ridge-vent/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,QAAA,MAAM,gBAAgB,GAAI,mBAAmB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAgDtF,CAAA;AAED,eAAe,gBAAgB,CAAA"}

package/dist/ridge-vent/preview.js

@@ -0,0 +1,31 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildRidgeVentGeometry } from './geometry';
+const RidgeVentPreview = ({ node, invalid }) => {
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildRidgeVentGeometry(node), [node.length, node.width, node.height, node.style, node.endCaps]);
+    const material = useMemo(() => new THREE.MeshStandardMaterial({
+        color: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissive: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissiveIntensity: 0.12,
+        roughness: 0.85,
+        metalness: 0.05,
+        transparent: true,
+        opacity: invalid ? 0.4 : 0.55,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+    }), [invalid]);
+    const edgesGeometry = useMemo(() => new THREE.EdgesGeometry(geometry, 25), [geometry]);
+    useEffect(() => () => {
+        geometry.dispose();
+        edgesGeometry.dispose();
+        material.dispose();
+    }, [geometry, edgesGeometry, material]);
+    return (_jsxs("group", { "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { geometry: geometry, material: material, raycast: () => {
+                    /* see box-vent preview note */
+                } }), _jsx("lineSegments", { geometry: edgesGeometry, renderOrder: 1000, children: _jsx("lineBasicMaterial", { color: 0x6c_a3_ff, depthTest: false, opacity: 0.9, transparent: true }) })] }));
+};
+export default RidgeVentPreview;

package/dist/ridge-vent/renderer.d.ts

@@ -0,0 +1,20 @@
+import { type RidgeVentNode } from '@pascal-app/core';
+/**
+ * Ridge vent renderer. Sits along the ridge of a roof-segment — no
+ * slope tilt is needed (the ridge IS the high line of the segment), so
+ * the transform stack is simply
+ *
+ *   segment.position → segment.rotation (Y) → vent.position
+ *     → vent.rotation (Y) → mesh
+ *
+ * Mirrors the box-vent renderer otherwise (segment lookup via
+ * useScene, live-transform follow for parent drags). Style-specific
+ * default materials let unpainted ridge vents read as their material
+ * family (matte standard / shingled grey / brushed metal) before the
+ * user opens the paint tray.
+ */
+declare const RidgeVentRenderer: ({ node: storeNode }: {
+    node: RidgeVentNode;
+}) => import("react").JSX.Element | null;
+export default RidgeVentRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/ridge-vent/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAiMtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}