@nvent-addon/app 0.4.5 → 0.5.1

package/dist/runtime/app/components/flow/AwaitNode.vue

@@ -0,0 +1,91 @@
+<template>
+  <div
+    class="px-3 py-2 rounded-lg border-2 min-w-[180px] bg-white dark:bg-gray-900 transition-all duration-300"
+    :class="borderClass"
+  >
+    <div class="flex items-center justify-between gap-2 text-xs mb-2">
+      <div class="flex items-center gap-2">
+        <UIcon
+          :name="getAwaitIcon(data.awaitType)"
+          class="w-3.5 h-3.5"
+        />
+        <span class="font-medium text-gray-700 dark:text-gray-300">
+          {{ data.label }}
+        </span>
+      </div>
+      <UBadge
+        :label="statusLabel"
+        size="xs"
+        :color="statusColor"
+      />
+    </div>
+    <div
+      v-if="data.awaitConfig"
+      class="text-[10px] text-gray-500 dark:text-gray-400"
+    >
+      <div v-if="data.awaitType === 'time'">
+        Delay: {{ formatDelay(data.awaitConfig.delay) }}
+      </div>
+      <div v-else-if="data.awaitType === 'event'">
+        Event: {{ data.awaitConfig.event }}
+      </div>
+      <div v-else-if="data.awaitType === 'webhook'">
+        Webhook: {{ data.awaitConfig.method || "POST" }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { computed } from "#imports";
+import { UIcon, UBadge } from "#components";
+const props = defineProps({
+  data: { type: Object, required: true }
+});
+const statusLabel = computed(() => {
+  return (props.data.status || "idle").toUpperCase();
+});
+const statusColor = computed(() => {
+  switch (props.data.status) {
+    case "waiting":
+      return "warning";
+    case "resolved":
+      return "success";
+    case "timeout":
+      return "error";
+    default:
+      return "neutral";
+  }
+});
+const borderClass = computed(() => {
+  switch (props.data.status) {
+    case "waiting":
+      return "border-amber-400 dark:border-amber-500 bg-amber-50 dark:bg-amber-950/20";
+    case "resolved":
+      return "border-emerald-400 dark:border-emerald-500 bg-emerald-50 dark:bg-emerald-950/20";
+    case "timeout":
+      return "border-red-400 dark:border-red-500 bg-red-50 dark:bg-red-950/20";
+    default:
+      return "border-gray-300 dark:border-gray-700";
+  }
+});
+function getAwaitIcon(type) {
+  switch (type) {
+    case "time":
+      return "i-lucide-clock";
+    case "event":
+      return "i-lucide-zap";
+    case "webhook":
+      return "i-lucide-webhook";
+    default:
+      return "i-lucide-clock";
+  }
+}
+function formatDelay(ms) {
+  if (!ms) return "0ms";
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 36e5) return `${(ms / 6e4).toFixed(1)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+</script>

package/dist/runtime/app/components/flow/AwaitNode.vue.d.ts

@@ -0,0 +1,18 @@
+interface AwaitConfig {
+    type?: 'time' | 'event' | 'webhook';
+    delay?: number;
+    event?: string;
+    method?: string;
+    timeout?: number;
+}
+type __VLS_Props = {
+    data: {
+        label: string;
+        awaitType?: 'time' | 'event' | 'webhook';
+        awaitConfig?: AwaitConfig;
+        status?: 'idle' | 'waiting' | 'resolved' | 'timeout';
+    };
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/{FlowDiagram.d.vue.ts → flow/Diagram.d.vue.ts}

@@ -1,3 +1,11 @@
+interface AwaitConfig {
+    type: 'time' | 'event' | 'webhook';
+    delay?: number;
+    event?: string;
+    method?: string;
+    timeout?: number;
+    timeoutAction?: 'fail' | 'continue';
+}
 interface FlowEntry {
     step: string;
     queue: string;
@@ -5,6 +13,7 @@ interface FlowEntry {
     runtime?: 'nodejs' | 'python';
     runtype?: 'inprocess' | 'task';
     emits?: string[];
+    awaitAfter?: AwaitConfig;
 }
 interface FlowStep {
     queue: string;
@@ -13,6 +22,8 @@ interface FlowStep {
     runtime?: 'nodejs' | 'python';
     runtype?: 'inprocess' | 'task';
     emits?: string[];
+    awaitBefore?: AwaitConfig;
+    awaitAfter?: AwaitConfig;
 }
 interface AnalyzedStep extends FlowStep {
     name: string;
@@ -42,7 +53,7 @@ type __VLS_Props = {
     showMiniMap?: boolean;
     showBackground?: boolean;
     stepStates?: Record<string, StepStatus>;
-    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled';
+    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled' | 'stalled';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     nodeSelected: (payload: {

package/dist/runtime/app/components/{FlowDiagram.vue → flow/Diagram.vue}

@@ -52,6 +52,20 @@
             />
           </template>
 
+          <template #node-flow-await="{ data }">
+            <FlowAwaitNode
+              :data="data"
+            />
+            <Handle
+              type="target"
+              :position="Position.Top"
+            />
+            <Handle
+              type="source"
+              :position="Position.Bottom"
+            />
+          </template>
+
           <Background
             v-if="showBackground"
             pattern-color="#888"
@@ -68,7 +82,8 @@
 <script setup>
 import { computed, ref, watch, nextTick } from "#imports";
 import { Handle, Position } from "@vue-flow/core";
-import FlowNodeCard from "../components/FlowNodeCard.vue";
+import FlowNodeCard from "./NodeCard.vue";
+import FlowAwaitNode from "./AwaitNode.vue";
 const props = defineProps({
   flow: { type: [Object, null], required: false },
   heightClass: { type: String, required: false },
@@ -190,7 +205,50 @@ const nodes = computed(() => {
       });
     });
   }
-  return out;
+  const awaitNodes = [];
+  const awaitGap = 70;
+  if (f.entry?.awaitAfter && f.entry) {
+    const entryNode = out.find((n) => n.id === `entry:${f.entry.step}`);
+    if (entryNode) {
+      const awaitKey = `${f.entry.step}:await-after`;
+      const awaitState = states[awaitKey];
+      const awaitStatus = awaitState?.status === "waiting" ? "waiting" : awaitState?.status === "completed" ? "resolved" : awaitState?.status === "timeout" ? "timeout" : "idle";
+      awaitNodes.push({
+        id: `await:entry-after:${f.entry.step}`,
+        position: { x: -90, y: entryNode.position.y + rowHeight + awaitGap },
+        data: {
+          label: `Await (${f.entry.awaitAfter.type})`,
+          awaitType: f.entry.awaitAfter.type,
+          awaitConfig: f.entry.awaitAfter,
+          status: awaitStatus
+        },
+        type: "flow-await",
+        style: { minWidth: "180px" }
+      });
+    }
+  }
+  Object.entries(steps).forEach(([stepName, step]) => {
+    if (step.awaitBefore) {
+      const stepNode = out.find((n) => n.id === `step:${stepName}`);
+      if (stepNode) {
+        const awaitState = states[`${stepName}:await-before`];
+        const awaitStatus = awaitState?.status === "waiting" ? "waiting" : awaitState?.status === "completed" ? "resolved" : awaitState?.status === "timeout" ? "timeout" : "idle";
+        awaitNodes.push({
+          id: `await:step-before:${stepName}`,
+          position: { x: stepNode.position.x + 20, y: stepNode.position.y - awaitGap - 50 },
+          data: {
+            label: `Await (${step.awaitBefore.type})`,
+            awaitType: step.awaitBefore.type,
+            awaitConfig: step.awaitBefore,
+            status: awaitStatus
+          },
+          type: "flow-await",
+          style: { minWidth: "180px" }
+        });
+      }
+    }
+  });
+  return [...out, ...awaitNodes];
 });
 function mapStatusToNodeStatus(status) {
   switch (status) {
@@ -213,6 +271,7 @@ const edges = computed(() => {
   const f = props.flow;
   if (!f) return [];
   const states = props.stepStates || {};
+  const steps = f.steps || {};
   const added = /* @__PURE__ */ new Set();
   const out = [];
   function addEdge(source, target, label) {
@@ -229,14 +288,32 @@ const edges = computed(() => {
   if (f.analyzed?.steps) {
     const analyzedSteps = f.analyzed.steps;
     for (const [stepName, stepInfo] of Object.entries(analyzedSteps)) {
+      const targetStep = steps[stepName];
       const target = `step:${stepName}`;
       if (stepInfo.dependsOn.length > 0) {
         for (const depName of stepInfo.dependsOn) {
           const source = depName === f.entry?.step ? `entry:${depName}` : `step:${depName}`;
-          addEdge(source, target);
+          if (targetStep?.awaitBefore) {
+            const awaitNodeId = `await:step-before:${stepName}`;
+            addEdge(source, awaitNodeId);
+            addEdge(awaitNodeId, target);
+          } else {
+            addEdge(source, target);
+          }
         }
       } else if (f.entry) {
-        addEdge(`entry:${f.entry.step}`, target);
+        const entryId = `entry:${f.entry.step}`;
+        if (f.entry.awaitAfter) {
+          const awaitNodeId = `await:entry-after:${f.entry.step}`;
+          addEdge(entryId, awaitNodeId);
+          addEdge(awaitNodeId, target);
+        } else if (targetStep?.awaitBefore) {
+          const awaitNodeId = `await:step-before:${stepName}`;
+          addEdge(entryId, awaitNodeId);
+          addEdge(awaitNodeId, target);
+        } else {
+          addEdge(entryId, target);
+        }
       }
     }
   } else {
@@ -289,15 +366,19 @@ watch(() => props.flow, (f) => {
     }
   }, 100);
 }, { immediate: true, deep: false });
-watch(() => props.stepStates, () => {
+watch([() => props.stepStates, () => props.flowStatus], () => {
   if (!props.flow) return;
-  const builtNodes = nodes.value.map((n) => ({ id: n.id, position: { ...n.position }, data: { ...n.data }, type: n.type, style: n.style }));
+  const latestNodes = nodes.value;
   const positionMap = new Map(internalNodes.value.map((n) => [n.id, n.position]));
-  builtNodes.forEach((n) => {
-    const existing = positionMap.get(n.id);
-    if (existing) n.position = existing;
-  });
-  internalNodes.value = builtNodes;
+  const updatedNodes = latestNodes.map((n) => ({
+    id: n.id,
+    position: positionMap.get(n.id) || { ...n.position },
+    data: { ...n.data },
+    // Create new data object reference
+    type: n.type,
+    style: n.style
+  }));
+  internalNodes.value = updatedNodes;
   const builtEdges = edges.value.map((e) => ({ id: e.id, source: e.source, target: e.target, label: e.label, animated: e.animated }));
   internalEdges.value = builtEdges;
 }, { deep: true });

package/dist/runtime/app/components/{FlowDiagram.vue.d.ts → flow/Diagram.vue.d.ts}

@@ -1,3 +1,11 @@
+interface AwaitConfig {
+    type: 'time' | 'event' | 'webhook';
+    delay?: number;
+    event?: string;
+    method?: string;
+    timeout?: number;
+    timeoutAction?: 'fail' | 'continue';
+}
 interface FlowEntry {
     step: string;
     queue: string;
@@ -5,6 +13,7 @@ interface FlowEntry {
     runtime?: 'nodejs' | 'python';
     runtype?: 'inprocess' | 'task';
     emits?: string[];
+    awaitAfter?: AwaitConfig;
 }
 interface FlowStep {
     queue: string;
@@ -13,6 +22,8 @@ interface FlowStep {
     runtime?: 'nodejs' | 'python';
     runtype?: 'inprocess' | 'task';
     emits?: string[];
+    awaitBefore?: AwaitConfig;
+    awaitAfter?: AwaitConfig;
 }
 interface AnalyzedStep extends FlowStep {
     name: string;
@@ -42,7 +53,7 @@ type __VLS_Props = {
     showMiniMap?: boolean;
     showBackground?: boolean;
     stepStates?: Record<string, StepStatus>;
-    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled';
+    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled' | 'stalled';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     nodeSelected: (payload: {

package/dist/runtime/app/components/{FlowRunOverview.d.vue.ts → flow/RunOverview.d.vue.ts}

@@ -5,6 +5,9 @@ type __VLS_Props = {
     steps: any[];
     flowName?: string;
     runId?: string;
+    triggerName?: string;
+    triggerType?: 'manual' | 'event' | 'webhook' | 'schedule';
+    flowDef?: any;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "select-step": (stepKey: string | null) => any;

package/dist/runtime/app/components/{FlowRunOverview.vue → flow/RunOverview.vue}

@@ -18,6 +18,23 @@
           <!-- Divider -->
           <div class="w-px h-3 bg-gray-300 dark:bg-gray-700" />
 
+          <!-- Entry Trigger -->
+          <div
+            v-if="triggerName"
+            class="flex items-center gap-1.5"
+          >
+            <UIcon
+              :name="getTriggerIcon(triggerType)"
+              class="w-3 h-3 text-gray-500"
+            />
+            <span class="text-gray-700 dark:text-gray-300">
+              {{ triggerName }}
+            </span>
+          </div>
+
+          <!-- Divider -->
+          <div class="w-px h-3 bg-gray-300 dark:bg-gray-700" />
+
           <!-- Total Steps -->
           <div class="flex items-center gap-1.5">
             <UIcon
@@ -96,14 +113,17 @@
 <script setup>
 import { ref, computed, watch } from "#imports";
 import { UIcon, UButton } from "#components";
-import FlowStepSelector from "./FlowStepSelector.vue";
+import FlowStepSelector from "./StepSelector.vue";
 const props = defineProps({
   runStatus: { type: String, required: false },
   startedAt: { type: [String, Number], required: false },
   completedAt: { type: [String, Number], required: false },
   steps: { type: Array, required: true },
   flowName: { type: String, required: false },
-  runId: { type: String, required: false }
+  runId: { type: String, required: false },
+  triggerName: { type: String, required: false },
+  triggerType: { type: String, required: false },
+  flowDef: { type: null, required: false }
 });
 const emit = defineEmits(["select-step", "cancel-flow"]);
 const handleCancelFlow = () => {
@@ -119,6 +139,23 @@ watch(firstStepKey, (newKey, oldKey) => {
 watch(selectedStep, (newStep) => {
   emit("select-step", newStep === "all-steps" ? null : newStep);
 });
+const isValidAwaitStep = (stepKey) => {
+  if (!stepKey.includes(":await-")) return true;
+  if (!props.flowDef) return false;
+  const parts = stepKey.split(":await-");
+  const stepName = parts[0];
+  const position = parts[1];
+  if (props.flowDef.entry?.step === stepName) {
+    if (position === "after" && props.flowDef.entry?.awaitAfter) return true;
+    if (position === "before" && props.flowDef.entry?.awaitBefore) return true;
+  }
+  const step = stepName ? props.flowDef.steps?.[stepName] : void 0;
+  if (step) {
+    if (position === "after" && step.awaitAfter) return true;
+    if (position === "before" && step.awaitBefore) return true;
+  }
+  return false;
+};
 const radioItems = computed(() => {
   const allItem = {
     value: "all-steps",
@@ -127,13 +164,48 @@ const radioItems = computed(() => {
       key: "All Steps",
       status: null,
       showAllIndicator: true
-    }
+    },
+    clickable: true
   };
-  const stepItems = props.steps.map((step) => ({
-    value: step.key,
-    label: step.key,
-    step
-  }));
+  const filteredSteps = props.steps.filter((step) => isValidAwaitStep(step.key));
+  const stepItems = filteredSteps.map((step) => {
+    const isAwait = step.key.includes(":await-");
+    let awaitConfig = void 0;
+    let webhookUrl = void 0;
+    if (isAwait && props.flowDef) {
+      const parts = step.key.split(":await-");
+      const stepName = parts[0];
+      const position = parts[1];
+      if (props.flowDef.entry?.step === stepName) {
+        awaitConfig = position === "after" ? props.flowDef.entry?.awaitAfter : props.flowDef.entry?.awaitBefore;
+      } else {
+        const stepDef = stepName ? props.flowDef.steps?.[stepName] : void 0;
+        if (stepDef) {
+          awaitConfig = position === "after" ? stepDef.awaitAfter : stepDef.awaitBefore;
+        }
+      }
+      if (awaitConfig?.type === "webhook" && props.flowName && props.runId) {
+        const baseUrl = typeof window !== "undefined" ? `${window.location.protocol}//${window.location.host}` : "";
+        webhookUrl = `${baseUrl}/api/_webhook/await/${props.flowName}/${props.runId}/${stepName}`;
+      }
+    }
+    const finalStep = {
+      ...step,
+      awaitConfig,
+      // Add await config from flow definition
+      // Extract awaitType from config if available
+      awaitType: awaitConfig?.type || step.awaitType,
+      webhookUrl
+      // Add constructed webhook URL
+    };
+    return {
+      value: step.key,
+      label: step.key,
+      step: finalStep,
+      clickable: !isAwait
+      // Await steps are not clickable
+    };
+  });
   return [allItem, ...stepItems];
 });
 const formatTime = (timestamp) => {
@@ -185,4 +257,18 @@ const getStatusColor = (status) => {
       return "bg-gray-300";
   }
 };
+const getTriggerIcon = (type) => {
+  switch (type) {
+    case "manual":
+      return "i-lucide-hand";
+    case "event":
+      return "i-lucide-zap";
+    case "webhook":
+      return "i-lucide-webhook";
+    case "schedule":
+      return "i-lucide-calendar-clock";
+    default:
+      return "i-lucide-play-circle";
+  }
+};
 </script>

package/dist/runtime/app/components/{FlowRunOverview.vue.d.ts → flow/RunOverview.vue.d.ts}

@@ -5,6 +5,9 @@ type __VLS_Props = {
     steps: any[];
     flowName?: string;
     runId?: string;
+    triggerName?: string;
+    triggerType?: 'manual' | 'event' | 'webhook' | 'schedule';
+    flowDef?: any;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "select-step": (stepKey: string | null) => any;

package/dist/runtime/app/components/{FlowRunStatusBadge.d.vue.ts → flow/RunStatusBadge.d.vue.ts}

@@ -4,15 +4,9 @@ interface Props {
     isFailed?: boolean;
     isCanceled?: boolean;
     isStalled?: boolean;
+    isAwaiting?: boolean;
     isReconnecting?: boolean;
 }
-declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
-    isRunning: boolean;
-    isCompleted: boolean;
-    isFailed: boolean;
-    isCanceled: boolean;
-    isStalled: boolean;
-    isReconnecting: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/app/components/{FlowRunStatusBadge.vue → flow/RunStatusBadge.vue}

@@ -5,6 +5,7 @@
   'bg-emerald-50 dark:bg-emerald-950/30 border-emerald-200 dark:border-emerald-800': isCompleted,
   'bg-red-50 dark:bg-red-950/30 border-red-200 dark:border-red-800': isFailed,
   'bg-blue-50 dark:bg-blue-950/30 border-blue-200 dark:border-blue-800': isRunning,
+  'bg-purple-50 dark:bg-purple-950/30 border-purple-200 dark:border-purple-800': isAwaiting,
   'bg-orange-50 dark:bg-orange-950/30 border-orange-200 dark:border-orange-800': isCanceled,
   'bg-amber-50 dark:bg-amber-950/30 border-amber-200 dark:border-amber-800': isStalled,
   'bg-gray-50 dark:bg-gray-900/30 border-gray-200 dark:border-gray-800': isIdle
@@ -16,6 +17,7 @@
   'bg-emerald-500': isCompleted,
   'bg-red-500': isFailed,
   'bg-blue-500 animate-pulse': isRunning && !isReconnecting,
+  'bg-purple-500 animate-pulse': isAwaiting,
   'bg-amber-500 animate-pulse': isReconnecting,
   'bg-orange-500': isCanceled,
   'bg-amber-600': isStalled,
@@ -28,6 +30,7 @@
   'text-emerald-700 dark:text-emerald-400': isCompleted,
   'text-red-700 dark:text-red-400': isFailed,
   'text-blue-700 dark:text-blue-400': isRunning,
+  'text-purple-700 dark:text-purple-400': isAwaiting,
   'text-orange-700 dark:text-orange-400': isCanceled,
   'text-amber-700 dark:text-amber-400': isStalled,
   'text-gray-600 dark:text-gray-400': isIdle
@@ -39,6 +42,9 @@
       <template v-else-if="isRunning">
         Running
       </template>
+      <template v-else-if="isAwaiting">
+        Awaiting
+      </template>
       <template v-else-if="isCompleted">
         Done
       </template>
@@ -66,9 +72,10 @@ const props = defineProps({
   isFailed: { type: Boolean, required: false, default: false },
   isCanceled: { type: Boolean, required: false, default: false },
   isStalled: { type: Boolean, required: false, default: false },
+  isAwaiting: { type: Boolean, required: false, default: false },
   isReconnecting: { type: Boolean, required: false, default: false }
 });
 const isIdle = computed(() => {
-  return !props.isRunning && !props.isCompleted && !props.isFailed && !props.isCanceled && !props.isStalled;
+  return !props.isRunning && !props.isCompleted && !props.isFailed && !props.isCanceled && !props.isStalled && !props.isAwaiting;
 });
 </script>

package/dist/runtime/app/components/{FlowRunStatusBadge.vue.d.ts → flow/RunStatusBadge.vue.d.ts}

@@ -4,15 +4,9 @@ interface Props {
     isFailed?: boolean;
     isCanceled?: boolean;
     isStalled?: boolean;
+    isAwaiting?: boolean;
     isReconnecting?: boolean;
 }
-declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
-    isRunning: boolean;
-    isCompleted: boolean;
-    isFailed: boolean;
-    isCanceled: boolean;
-    isStalled: boolean;
-    isReconnecting: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/app/components/{FlowRunTimeline.vue → flow/RunTimeline.vue}

@@ -58,7 +58,7 @@
 
 <script setup>
 import { ref, computed } from "#imports";
-import TimelineList from "./TimelineList.vue";
+import TimelineList from "../TimelineList.vue";
 import { UButton, UIcon, URadioGroup } from "#components";
 const props = defineProps({
   events: { type: Array, required: true },

package/dist/runtime/app/components/{FlowStepSelector.d.vue.ts → flow/StepSelector.d.vue.ts}

@@ -5,6 +5,7 @@ type __VLS_Props = {
         value: string;
         label: string;
         step: any;
+        clickable?: boolean;
     }>;
     ui?: {
         root?: ClassValue;