@ucdjs/pipelines-ui 0.0.1-beta.1

package/dist/hooks/use-event-view.d.mts

@@ -0,0 +1,19 @@
+//#region src/hooks/use-event-view.d.ts
+interface EventViewState {
+  isJsonMode: boolean;
+  selectedEventId: string | null;
+  isDetailPanelOpen: boolean;
+  expandedInlineIds: Set<string>;
+}
+interface EventViewActions {
+  toggleJsonMode: () => void;
+  setJsonMode: (value: boolean) => void;
+  selectEvent: (eventId: string | null) => void;
+  openDetailPanel: (eventId: string) => void;
+  closeDetailPanel: () => void;
+  toggleInlineExpansion: (eventId: string) => void;
+  isInlineExpanded: (eventId: string) => boolean;
+}
+declare function useEventView(): EventViewState & EventViewActions;
+//#endregion
+export { EventViewActions, EventViewState, useEventView };

package/dist/hooks/use-event-view.mjs

@@ -0,0 +1,112 @@
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+
+//#region src/hooks/use-event-view.ts
+function useEventView() {
+	const $ = c(14);
+	const [isJsonMode, setIsJsonMode] = useState(_temp);
+	const [selectedEventId, setSelectedEventId] = useState(null);
+	const [isDetailPanelOpen, setIsDetailPanelOpen] = useState(false);
+	const [expandedInlineIds, setExpandedInlineIds] = useState(_temp2);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = () => {
+			setIsJsonMode(_temp3);
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const toggleJsonMode = t0;
+	let t1;
+	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = (value) => {
+			setIsJsonMode(value);
+			localStorage.setItem("pipeline-events-json-mode", String(value));
+		};
+		$[1] = t1;
+	} else t1 = $[1];
+	const setJsonMode = t1;
+	let t2;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = (eventId) => {
+			setSelectedEventId(eventId);
+		};
+		$[2] = t2;
+	} else t2 = $[2];
+	const selectEvent = t2;
+	let t3;
+	if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = (eventId_0) => {
+			setSelectedEventId(eventId_0);
+			setIsDetailPanelOpen(true);
+		};
+		$[3] = t3;
+	} else t3 = $[3];
+	const openDetailPanel = t3;
+	let t4;
+	if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = () => {
+			setIsDetailPanelOpen(false);
+			setSelectedEventId(null);
+		};
+		$[4] = t4;
+	} else t4 = $[4];
+	const closeDetailPanel = t4;
+	let t5;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = (eventId_1) => {
+			setExpandedInlineIds((prev_0) => {
+				const next_0 = new Set(prev_0);
+				if (next_0.has(eventId_1)) next_0.delete(eventId_1);
+				else next_0.add(eventId_1);
+				return next_0;
+			});
+		};
+		$[5] = t5;
+	} else t5 = $[5];
+	const toggleInlineExpansion = t5;
+	let t6;
+	if ($[6] !== expandedInlineIds) {
+		t6 = (eventId_2) => expandedInlineIds.has(eventId_2);
+		$[6] = expandedInlineIds;
+		$[7] = t6;
+	} else t6 = $[7];
+	const isInlineExpanded = t6;
+	let t7;
+	if ($[8] !== expandedInlineIds || $[9] !== isDetailPanelOpen || $[10] !== isInlineExpanded || $[11] !== isJsonMode || $[12] !== selectedEventId) {
+		t7 = {
+			isJsonMode,
+			selectedEventId,
+			isDetailPanelOpen,
+			expandedInlineIds,
+			toggleJsonMode,
+			setJsonMode,
+			selectEvent,
+			openDetailPanel,
+			closeDetailPanel,
+			toggleInlineExpansion,
+			isInlineExpanded
+		};
+		$[8] = expandedInlineIds;
+		$[9] = isDetailPanelOpen;
+		$[10] = isInlineExpanded;
+		$[11] = isJsonMode;
+		$[12] = selectedEventId;
+		$[13] = t7;
+	} else t7 = $[13];
+	return t7;
+}
+function _temp3(prev) {
+	const next = !prev;
+	localStorage.setItem("pipeline-events-json-mode", String(next));
+	return next;
+}
+function _temp2() {
+	return /* @__PURE__ */ new Set();
+}
+function _temp() {
+	if (typeof window !== "undefined") return localStorage.getItem("pipeline-events-json-mode") === "true";
+	return false;
+}
+
+//#endregion
+export { useEventView };

package/dist/hooks/use-execute.d.mts

@@ -0,0 +1,20 @@
+import { ExecuteResult } from "../types.mjs";
+
+//#region src/hooks/use-execute.d.ts
+interface UseExecuteOptions {
+  /**
+   * Base URL for the API (default: "")
+   */
+  baseUrl?: string;
+}
+interface UseExecuteReturn {
+  execute: (fileId: string, pipelineId: string, versions: string[]) => Promise<ExecuteResult>;
+  executing: boolean;
+  result: ExecuteResult | null;
+  error: string | null;
+  executionId: string | null;
+  reset: () => void;
+}
+declare function useExecute(options?: UseExecuteOptions): UseExecuteReturn;
+//#endregion
+export { UseExecuteOptions, UseExecuteReturn, useExecute };

package/dist/hooks/use-execute.mjs

@@ -0,0 +1,68 @@
+import { useCallback, useState } from "react";
+
+//#region src/hooks/use-execute.ts
+function useExecute(options = {}) {
+	const { baseUrl = "" } = options;
+	const [executing, setExecuting] = useState(false);
+	const [result, setResult] = useState(null);
+	const [error, setError] = useState(null);
+	const [executionId, setExecutionId] = useState(null);
+	return {
+		execute: useCallback(async (fileId, pipelineId, versions) => {
+			setExecuting(true);
+			setError(null);
+			setResult(null);
+			setExecutionId(null);
+			try {
+				const data = await (await fetch(`${baseUrl}/api/pipelines/${fileId}/${pipelineId}/execute`, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ versions })
+				})).json();
+				if (data.success && data.executionId) {
+					setExecutionId(data.executionId);
+					const successResult = {
+						success: true,
+						pipelineId,
+						executionId: data.executionId
+					};
+					setResult(successResult);
+					return successResult;
+				} else {
+					const errorResult_0 = {
+						success: false,
+						pipelineId,
+						executionId: data.executionId,
+						error: data.error ?? "Execution failed"
+					};
+					setResult(errorResult_0);
+					setError(errorResult_0.error ?? "Execution failed");
+					return errorResult_0;
+				}
+			} catch (err) {
+				const errorResult = {
+					success: false,
+					pipelineId,
+					error: err instanceof Error ? err.message : String(err)
+				};
+				setResult(errorResult);
+				setError(errorResult.error ?? "Execution failed");
+				return errorResult;
+			} finally {
+				setExecuting(false);
+			}
+		}, [baseUrl]),
+		executing,
+		result,
+		error,
+		executionId,
+		reset: useCallback(() => {
+			setResult(null);
+			setError(null);
+			setExecutionId(null);
+		}, [])
+	};
+}
+
+//#endregion
+export { useExecute };

package/dist/hooks/use-pipeline-file.d.mts

@@ -0,0 +1,20 @@
+import { PipelineFileInfo } from "../types.mjs";
+
+//#region src/hooks/use-pipeline-file.d.ts
+interface PipelineFileResponse {
+  file?: PipelineFileInfo;
+  error?: string;
+}
+interface UsePipelineFileOptions {
+  baseUrl?: string;
+  fetchOnMount?: boolean;
+}
+interface UsePipelineFileReturn {
+  file: PipelineFileInfo | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => void;
+}
+declare function usePipelineFile(fileId: string, options?: UsePipelineFileOptions): UsePipelineFileReturn;
+//#endregion
+export { PipelineFileResponse, UsePipelineFileOptions, UsePipelineFileReturn, usePipelineFile };

package/dist/hooks/use-pipeline-file.mjs

@@ -0,0 +1,39 @@
+import { useCallback, useEffect, useState } from "react";
+
+//#region src/hooks/use-pipeline-file.ts
+function usePipelineFile(fileId, options = {}) {
+	const { baseUrl = "", fetchOnMount = true } = options;
+	const [file, setFile] = useState(null);
+	const [loading, setLoading] = useState(fetchOnMount);
+	const [error, setError] = useState(null);
+	const fetchFile = useCallback(async () => {
+		setLoading(true);
+		setError(null);
+		try {
+			const res = await fetch(`${baseUrl}/api/pipelines/${fileId}`);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			const json = await res.json();
+			if (json.error) {
+				setError(json.error);
+				setFile(null);
+			} else setFile(json.file ?? null);
+		} catch (err) {
+			setError(err instanceof Error ? err.message : "Failed to load pipeline file");
+			setFile(null);
+		} finally {
+			setLoading(false);
+		}
+	}, [baseUrl, fileId]);
+	useEffect(() => {
+		if (fetchOnMount) fetchFile();
+	}, [fetchOnMount, fetchFile]);
+	return {
+		file,
+		loading,
+		error,
+		refetch: fetchFile
+	};
+}
+
+//#endregion
+export { usePipelineFile };

package/dist/hooks/use-pipeline-versions.d.mts

@@ -0,0 +1,10 @@
+//#region src/hooks/use-pipeline-versions.d.ts
+interface UsePipelineVersionsReturn {
+  selectedVersions: Set<string>;
+  toggleVersion: (version: string) => void;
+  selectAll: (versions: string[]) => void;
+  deselectAll: () => void;
+}
+declare function usePipelineVersions(pipelineId: string, allVersions: string[], storageKeyOverride?: string): UsePipelineVersionsReturn;
+//#endregion
+export { UsePipelineVersionsReturn, usePipelineVersions };

package/dist/hooks/use-pipeline-versions.mjs

@@ -0,0 +1,137 @@
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+
+//#region src/hooks/use-pipeline-versions.ts
+const STORAGE_KEY_PREFIX = "ucd-versions-";
+function getStorageKey(storageKey) {
+	return `${STORAGE_KEY_PREFIX}${storageKey}`;
+}
+function loadVersionsFromStorage(storageKey, allVersions) {
+	if (typeof window === "undefined") return new Set(allVersions);
+	try {
+		const stored = localStorage.getItem(getStorageKey(storageKey));
+		if (stored) {
+			const validVersions = JSON.parse(stored).filter((v) => allVersions.includes(v));
+			if (validVersions.length > 0) return new Set(validVersions);
+		}
+	} catch {}
+	return new Set(allVersions);
+}
+function saveVersionsToStorage(storageKey, versions) {
+	if (typeof window === "undefined") return;
+	try {
+		localStorage.setItem(getStorageKey(storageKey), JSON.stringify(Array.from(versions)));
+	} catch {}
+}
+function sanitizeVersions(versions, allVersions) {
+	const valid = Array.from(versions).filter((v) => allVersions.includes(v));
+	return new Set(valid.length > 0 ? valid : allVersions);
+}
+function usePipelineVersions(pipelineId, allVersions, storageKeyOverride) {
+	const $ = c(28);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = {};
+		$[0] = t0;
+	} else t0 = $[0];
+	const [overridesByPipeline, setOverridesByPipeline] = useState(t0);
+	const storageKey = storageKeyOverride ?? pipelineId;
+	let t1;
+	if ($[1] !== allVersions || $[2] !== storageKey) {
+		t1 = loadVersionsFromStorage(storageKey, allVersions);
+		$[1] = allVersions;
+		$[2] = storageKey;
+		$[3] = t1;
+	} else t1 = $[3];
+	const baseSelection = t1;
+	const override = overridesByPipeline[pipelineId];
+	let t2;
+	if ($[4] !== baseSelection || $[5] !== override) {
+		t2 = override ? new Set(override) : baseSelection;
+		$[4] = baseSelection;
+		$[5] = override;
+		$[6] = t2;
+	} else t2 = $[6];
+	const source = t2;
+	let t3;
+	if ($[7] !== allVersions || $[8] !== source) {
+		t3 = sanitizeVersions(source, allVersions);
+		$[7] = allVersions;
+		$[8] = source;
+		$[9] = t3;
+	} else t3 = $[9];
+	const selectedVersions = t3;
+	let t4;
+	if ($[10] !== allVersions || $[11] !== pipelineId || $[12] !== selectedVersions || $[13] !== storageKey) {
+		t4 = (version) => {
+			setOverridesByPipeline((prev) => {
+				const current = prev[pipelineId] ? new Set(prev[pipelineId]) : selectedVersions;
+				const next = new Set(current);
+				if (next.has(version)) next.delete(version);
+				else next.add(version);
+				const sanitized = sanitizeVersions(next, allVersions);
+				saveVersionsToStorage(storageKey, sanitized);
+				return {
+					...prev,
+					[pipelineId]: Array.from(sanitized)
+				};
+			});
+		};
+		$[10] = allVersions;
+		$[11] = pipelineId;
+		$[12] = selectedVersions;
+		$[13] = storageKey;
+		$[14] = t4;
+	} else t4 = $[14];
+	const toggleVersion = t4;
+	let t5;
+	if ($[15] !== allVersions || $[16] !== pipelineId || $[17] !== storageKey) {
+		t5 = (versions) => {
+			const sanitized_0 = sanitizeVersions(versions, allVersions);
+			saveVersionsToStorage(storageKey, sanitized_0);
+			setOverridesByPipeline((prev_0) => ({
+				...prev_0,
+				[pipelineId]: Array.from(sanitized_0)
+			}));
+		};
+		$[15] = allVersions;
+		$[16] = pipelineId;
+		$[17] = storageKey;
+		$[18] = t5;
+	} else t5 = $[18];
+	const selectAll = t5;
+	let t6;
+	if ($[19] !== allVersions || $[20] !== pipelineId || $[21] !== storageKey) {
+		t6 = () => {
+			const sanitized_1 = sanitizeVersions([], allVersions);
+			saveVersionsToStorage(storageKey, sanitized_1);
+			setOverridesByPipeline((prev_1) => ({
+				...prev_1,
+				[pipelineId]: Array.from(sanitized_1)
+			}));
+		};
+		$[19] = allVersions;
+		$[20] = pipelineId;
+		$[21] = storageKey;
+		$[22] = t6;
+	} else t6 = $[22];
+	const deselectAll = t6;
+	let t7;
+	if ($[23] !== deselectAll || $[24] !== selectAll || $[25] !== selectedVersions || $[26] !== toggleVersion) {
+		t7 = {
+			selectedVersions,
+			toggleVersion,
+			selectAll,
+			deselectAll
+		};
+		$[23] = deselectAll;
+		$[24] = selectAll;
+		$[25] = selectedVersions;
+		$[26] = toggleVersion;
+		$[27] = t7;
+	} else t7 = $[27];
+	return t7;
+}
+
+//#endregion
+export { usePipelineVersions };

package/dist/hooks/use-pipeline.d.mts

@@ -0,0 +1,21 @@
+import { PipelineDetails } from "../types.mjs";
+
+//#region src/hooks/use-pipeline.d.ts
+interface UsePipelineOptions {
+  /** Base URL for the API (default: "") */
+  baseUrl?: string;
+  /** Whether to fetch on mount (default: true) */
+  fetchOnMount?: boolean;
+}
+interface UsePipelineReturn {
+  pipeline: PipelineDetails | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => void;
+}
+/**
+ * Hook to fetch and manage a single pipeline by ID
+ */
+declare function usePipeline(fileId: string, pipelineId: string, options?: UsePipelineOptions): UsePipelineReturn;
+//#endregion
+export { UsePipelineOptions, UsePipelineReturn, usePipeline };

package/dist/hooks/use-pipeline.mjs

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useState } from "react";
+
+//#region src/hooks/use-pipeline.ts
+/**
+* Hook to fetch and manage a single pipeline by ID
+*/
+function usePipeline(fileId, pipelineId, options = {}) {
+	const { baseUrl = "", fetchOnMount = true } = options;
+	const [pipeline, setPipeline] = useState(null);
+	const [loading, setLoading] = useState(fetchOnMount);
+	const [error, setError] = useState(null);
+	const fetchPipeline = useCallback(async () => {
+		setLoading(true);
+		setError(null);
+		try {
+			const res = await fetch(`${baseUrl}/api/pipelines/${fileId}/${pipelineId}`);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			const json = await res.json();
+			if (json.error) {
+				setError(json.error);
+				setPipeline(null);
+			} else setPipeline(json.pipeline ?? null);
+		} catch (err) {
+			setError(err instanceof Error ? err.message : "Failed to load pipeline");
+			setPipeline(null);
+		} finally {
+			setLoading(false);
+		}
+	}, [
+		baseUrl,
+		fileId,
+		pipelineId
+	]);
+	useEffect(() => {
+		if (fetchOnMount) fetchPipeline();
+	}, [fetchOnMount, fetchPipeline]);
+	return {
+		pipeline,
+		loading,
+		error,
+		refetch: fetchPipeline
+	};
+}
+
+//#endregion
+export { usePipeline };

package/dist/hooks/use-pipelines.d.mts

@@ -0,0 +1,26 @@
+import { PipelinesResponse } from "../types.mjs";
+
+//#region src/hooks/use-pipelines.d.ts
+interface UsePipelinesOptions {
+  /**
+   * Base URL for the API (default: "")
+   */
+  baseUrl?: string;
+  /**
+   * Optional search query
+   */
+  search?: string;
+  /**
+   * Whether to fetch on mount (default: true)
+   */
+  fetchOnMount?: boolean;
+}
+interface UsePipelinesReturn {
+  data: PipelinesResponse | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => void;
+}
+declare function usePipelines(options?: UsePipelinesOptions): UsePipelinesReturn;
+//#endregion
+export { UsePipelinesOptions, UsePipelinesReturn, usePipelines };

package/dist/hooks/use-pipelines.mjs

@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useState } from "react";
+
+//#region src/hooks/use-pipelines.ts
+function usePipelines(options = {}) {
+	const { baseUrl = "", search, fetchOnMount = true } = options;
+	const [data, setData] = useState(null);
+	const [loading, setLoading] = useState(fetchOnMount);
+	const [error, setError] = useState(null);
+	const fetchPipelines = useCallback(async () => {
+		setLoading(true);
+		setError(null);
+		try {
+			const params = new URLSearchParams();
+			if (search && search.trim()) params.set("search", search.trim());
+			const queryString = params.toString();
+			const url = queryString ? `${baseUrl}/api/pipelines?${queryString}` : `${baseUrl}/api/pipelines`;
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			setData(await res.json());
+		} catch (err) {
+			setError(err instanceof Error ? err.message : "Failed to load pipelines");
+		} finally {
+			setLoading(false);
+		}
+	}, [baseUrl, search]);
+	useEffect(() => {
+		if (fetchOnMount) fetchPipelines();
+	}, [fetchOnMount, fetchPipelines]);
+	return {
+		data,
+		loading,
+		error,
+		refetch: fetchPipelines
+	};
+}
+
+//#endregion
+export { usePipelines };

package/dist/index.d.mts

@@ -0,0 +1,31 @@
+import { PipelineSidebar } from "./components/pipeline-sidebar.mjs";
+import { StatusBadge } from "./components/status-badge.mjs";
+import { StatusIcon } from "./components/status-icon.mjs";
+import { EventViewActions, EventViewState, useEventView } from "./hooks/use-event-view.mjs";
+import { ExecuteResult, ExecutionEventItem, ExecutionEventsResponse, ExecutionLogItem, ExecutionLogPayload, ExecutionLogStream, ExecutionLogsResponse, LoadError, PipelineDetails, PipelineFileInfo, PipelineInfo, PipelineResponse, PipelinesResponse } from "./types.mjs";
+import { UseExecuteOptions, UseExecuteReturn, useExecute } from "./hooks/use-execute.mjs";
+import { UsePipelineOptions, UsePipelineReturn, usePipeline } from "./hooks/use-pipeline.mjs";
+import { PipelineFileResponse, UsePipelineFileOptions, UsePipelineFileReturn, usePipelineFile } from "./hooks/use-pipeline-file.mjs";
+import { UsePipelineVersionsReturn, usePipelineVersions } from "./hooks/use-pipeline-versions.mjs";
+import { UsePipelinesOptions, UsePipelinesReturn, usePipelines } from "./hooks/use-pipelines.mjs";
+import "./hooks/index.mjs";
+import { ExecutionErrors, ExecutionErrorsProps, ExecutionResult, ExecutionResultProps, ExecutionSummary, ExecutionSummaryProps } from "./components/detail/execution-result.mjs";
+import { VersionSelector, VersionSelectorProps } from "./components/detail/version-selector.mjs";
+import { PipelineGraphDetails, PipelineGraphDetailsProps } from "./components/graph/details.mjs";
+import { PipelineGraphFilters, PipelineGraphFiltersProps } from "./components/graph/filters.mjs";
+import { nodeTypes } from "./components/graph/node-types.mjs";
+import { ArtifactNode, FileNode, OutputNode, PipelineNodeData, RouteNode, SourceNode } from "./components/graph/nodes.mjs";
+import { PipelineGraph, PipelineGraphProps } from "./components/graph/pipeline-graph.mjs";
+import { ExecutionLogPayloadPanel, ExecutionLogPayloadPanelProps } from "./components/logs/execution-log-payload.mjs";
+import { ExecutionLogTable, ExecutionLogTableProps } from "./components/logs/execution-log-table.mjs";
+import { buildExecutionSpans, formatBytes, formatDuration, formatTimeLabel, formatTimestamp } from "./lib/execution-logs.mjs";
+import { ExecutionSpanDrawer, ExecutionSpanDrawerProps } from "./components/logs/execution-span-drawer.mjs";
+import { ExecutionWaterfall, ExecutionWaterfallProps } from "./components/logs/execution-waterfall.mjs";
+import { PipelineFlowEdge, PipelineFlowNode, filterNodesByType, pipelineGraphToFlow } from "./lib/adapter.mjs";
+import { getNodeColor, nodeTypeColors } from "./lib/colors.mjs";
+import { formatHighPrecisionTime } from "./lib/format-time.mjs";
+import { NODE_HEIGHT, NODE_WIDTH, applyLayout } from "./lib/layout.mjs";
+import { toPipelineDetails, toPipelineInfo, toRouteDetails } from "./lib/pipeline-utils.mjs";
+import { cn } from "./lib/utils.mjs";
+import { ExecutionStatus } from "@ucdjs/pipelines-executor";
+export { ArtifactNode, EventViewActions, EventViewState, type ExecuteResult, ExecutionErrors, type ExecutionErrorsProps, type ExecutionEventItem, type ExecutionEventsResponse, type ExecutionLogItem, type ExecutionLogPayload, ExecutionLogPayloadPanel, type ExecutionLogPayloadPanelProps, type ExecutionLogStream, ExecutionLogTable, type ExecutionLogTableProps, type ExecutionLogsResponse, ExecutionResult, type ExecutionResultProps, ExecutionSpanDrawer, type ExecutionSpanDrawerProps, type ExecutionStatus, ExecutionSummary, type ExecutionSummaryProps, ExecutionWaterfall, type ExecutionWaterfallProps, FileNode, type LoadError, NODE_HEIGHT, NODE_WIDTH, OutputNode, type PipelineDetails, type PipelineFileInfo, PipelineFileResponse, type PipelineFlowEdge, type PipelineFlowNode, PipelineGraph, PipelineGraphDetails, type PipelineGraphDetailsProps, PipelineGraphFilters, type PipelineGraphFiltersProps, type PipelineGraphProps, type PipelineInfo, type PipelineNodeData, type PipelineResponse, PipelineSidebar, type PipelinesResponse, RouteNode, SourceNode, StatusBadge, StatusIcon, UseExecuteOptions, UseExecuteReturn, UsePipelineFileOptions, UsePipelineFileReturn, UsePipelineOptions, UsePipelineReturn, UsePipelineVersionsReturn, UsePipelinesOptions, UsePipelinesReturn, VersionSelector, type VersionSelectorProps, applyLayout, buildExecutionSpans, cn, filterNodesByType, formatBytes, formatDuration, formatHighPrecisionTime, formatTimeLabel, formatTimestamp, getNodeColor, nodeTypeColors, nodeTypes, pipelineGraphToFlow, toPipelineDetails, toPipelineInfo, toRouteDetails, useEventView, useExecute, usePipeline, usePipelineFile, usePipelineVersions, usePipelines };

package/dist/index.mjs

@@ -0,0 +1,29 @@
+import { cn } from "./lib/utils.mjs";
+import { ExecutionErrors, ExecutionResult, ExecutionSummary } from "./components/detail/execution-result.mjs";
+import { VersionSelector } from "./components/detail/version-selector.mjs";
+import { PipelineGraphDetails } from "./components/graph/details.mjs";
+import { PipelineGraphFilters } from "./components/graph/filters.mjs";
+import { ArtifactNode, FileNode, OutputNode, RouteNode, SourceNode } from "./components/graph/nodes.mjs";
+import { nodeTypes } from "./components/graph/node-types.mjs";
+import { filterNodesByType, pipelineGraphToFlow } from "./lib/adapter.mjs";
+import { getNodeColor, nodeTypeColors } from "./lib/colors.mjs";
+import { NODE_HEIGHT, NODE_WIDTH, applyLayout } from "./lib/layout.mjs";
+import { PipelineGraph } from "./components/graph/pipeline-graph.mjs";
+import { ExecutionLogPayloadPanel } from "./components/logs/execution-log-payload.mjs";
+import { buildExecutionSpans, formatBytes, formatDuration, formatTimeLabel, formatTimestamp } from "./lib/execution-logs.mjs";
+import { ExecutionLogTable } from "./components/logs/execution-log-table.mjs";
+import { ExecutionSpanDrawer } from "./components/logs/execution-span-drawer.mjs";
+import { ExecutionWaterfall } from "./components/logs/execution-waterfall.mjs";
+import { useEventView } from "./hooks/use-event-view.mjs";
+import { useExecute } from "./hooks/use-execute.mjs";
+import { usePipeline } from "./hooks/use-pipeline.mjs";
+import { usePipelineFile } from "./hooks/use-pipeline-file.mjs";
+import { usePipelineVersions } from "./hooks/use-pipeline-versions.mjs";
+import { usePipelines } from "./hooks/use-pipelines.mjs";
+import { PipelineSidebar } from "./components/pipeline-sidebar.mjs";
+import { StatusBadge } from "./components/status-badge.mjs";
+import { StatusIcon } from "./components/status-icon.mjs";
+import { formatHighPrecisionTime } from "./lib/format-time.mjs";
+import { toPipelineDetails, toPipelineInfo, toRouteDetails } from "./lib/pipeline-utils.mjs";
+
+export { ArtifactNode, ExecutionErrors, ExecutionLogPayloadPanel, ExecutionLogTable, ExecutionResult, ExecutionSpanDrawer, ExecutionSummary, ExecutionWaterfall, FileNode, NODE_HEIGHT, NODE_WIDTH, OutputNode, PipelineGraph, PipelineGraphDetails, PipelineGraphFilters, PipelineSidebar, RouteNode, SourceNode, StatusBadge, StatusIcon, VersionSelector, applyLayout, buildExecutionSpans, cn, filterNodesByType, formatBytes, formatDuration, formatHighPrecisionTime, formatTimeLabel, formatTimestamp, getNodeColor, nodeTypeColors, nodeTypes, pipelineGraphToFlow, toPipelineDetails, toPipelineInfo, toRouteDetails, useEventView, useExecute, usePipeline, usePipelineFile, usePipelineVersions, usePipelines };

package/dist/lib/adapter.d.mts

@@ -0,0 +1,26 @@
+import { Edge, Node } from "@xyflow/react";
+import { PipelineGraph, PipelineGraphEdge, PipelineGraphNode, PipelineGraphNodeType } from "@ucdjs/pipelines-core";
+
+//#region src/lib/adapter.d.ts
+interface PipelineFlowNode extends Node {
+  data: {
+    pipelineNode: PipelineGraphNode;
+    label: string;
+  };
+  type: PipelineGraphNodeType;
+}
+interface PipelineFlowEdge extends Edge {
+  data: {
+    pipelineEdge: PipelineGraphEdge;
+  };
+}
+declare function pipelineGraphToFlow(graph: PipelineGraph): {
+  nodes: PipelineFlowNode[];
+  edges: PipelineFlowEdge[];
+};
+declare function filterNodesByType(nodes: PipelineFlowNode[], edges: PipelineFlowEdge[], visibleTypes: Set<PipelineGraphNodeType>): {
+  nodes: PipelineFlowNode[];
+  edges: PipelineFlowEdge[];
+};
+//#endregion
+export { PipelineFlowEdge, PipelineFlowNode, filterNodesByType, pipelineGraphToFlow };