@nvent-addon/app 0.5.4 → 0.5.6

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

@@ -102,39 +102,90 @@ const nodes = computed(() => {
   const f = props.flow;
   if (!f) return out;
   const states = props.stepStates || {};
-  const colWidth = 250;
-  const rowHeight = 140;
-  const horizontalGap = 50;
-  const verticalGap = 80;
-  const entryToStepsGap = 140;
-  const nodeWidth = 220;
+  const colWidth = 320;
+  const rowHeight = 180;
+  const horizontalGap = 60;
+  const verticalGap = 90;
+  const awaitRowHeight = 140;
+  const nodeWidth = 300;
   let y = 0;
   if (f.entry) {
     const entryState = states[f.entry.step];
     const status = mapStatusToNodeStatus(entryState?.status);
+    const entryStepTimeout = f.analyzed?.steps?.[f.entry.step]?.stepTimeout;
     out.push({
       id: `entry:${f.entry.step}`,
       position: { x: -nodeWidth / 2, y },
       data: {
         label: f.entry.step,
         queue: f.entry.queue,
+        workerId: f.entry.workerId,
         status,
         attempt: entryState?.attempt,
         error: entryState?.error,
         runtime: f.entry.runtime,
         runtype: f.entry.runtype,
-        emits: f.entry.emits
+        emits: f.entry.emits,
+        awaitBefore: f.entry.awaitBefore,
+        awaitAfter: f.entry.awaitAfter,
+        stepTimeout: entryStepTimeout
       },
       type: "flow-entry",
       style: { minWidth: `${nodeWidth}px` }
     });
-    y += rowHeight + entryToStepsGap;
+    y += rowHeight + verticalGap;
+    if (f.entry.awaitAfter) {
+      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";
+      out.push({
+        id: `await:entry-after:${f.entry.step}`,
+        position: { x: -120, y },
+        data: {
+          label: `Await (${f.entry.awaitAfter.type})`,
+          awaitType: f.entry.awaitAfter.type,
+          awaitConfig: f.entry.awaitAfter,
+          awaitData: awaitState?.awaitData,
+          status: awaitStatus,
+          scheduledTriggerAt: awaitState?.scheduledTriggerAt
+        },
+        type: "flow-await",
+        style: { minWidth: "180px" }
+      });
+      y += awaitRowHeight + verticalGap;
+    }
   }
   const steps = f.steps || {};
   if (f.analyzed?.levels && f.analyzed.levels.length > 0) {
-    const levels = f.analyzed.levels.filter((level) => level.length > 0);
+    const levels = f.analyzed.levels.slice(1).filter((level) => level.length > 0);
     levels.forEach((levelSteps) => {
       if (levelSteps.length === 0) return;
+      const awaitNodesCreated = [];
+      levelSteps.forEach((stepName) => {
+        const step = steps[stepName];
+        if (!step?.awaitBefore) return;
+        const awaitState = states[`${stepName}:await-before`];
+        const awaitStatus = awaitState?.status === "waiting" ? "waiting" : awaitState?.status === "completed" ? "resolved" : awaitState?.status === "timeout" ? "timeout" : "idle";
+        out.push({
+          id: `await:step-before:${stepName}`,
+          position: { x: 0, y },
+          // Temporary position
+          data: {
+            label: `Await (${step.awaitBefore.type})`,
+            awaitType: step.awaitBefore.type,
+            awaitConfig: step.awaitBefore,
+            awaitData: awaitState?.awaitData,
+            status: awaitStatus,
+            scheduledTriggerAt: awaitState?.scheduledTriggerAt
+          },
+          type: "flow-await",
+          style: { minWidth: "180px" }
+        });
+        awaitNodesCreated.push(stepName);
+      });
+      if (awaitNodesCreated.length > 0) {
+        y += awaitRowHeight + verticalGap;
+      }
       const cols = Math.min(4, levelSteps.length);
       const rows = Math.ceil(levelSteps.length / cols);
       levelSteps.forEach((stepName, idx) => {
@@ -150,6 +201,8 @@ const nodes = computed(() => {
         const rowStartX = -rowWidth / 2;
         const x = rowStartX + col * (colWidth + horizontalGap);
         const yPos = y + row * (rowHeight + verticalGap);
+        const analyzedStep = f.analyzed?.steps?.[stepName];
+        const stepStepTimeout = analyzedStep?.stepTimeout;
         out.push({
           id: `step:${stepName}`,
           position: { x, y: yPos },
@@ -162,13 +215,46 @@ const nodes = computed(() => {
             error: stepState?.error,
             runtime: step?.runtime,
             runtype: step?.runtype,
-            emits: step?.emits
+            subscribes: step?.subscribes,
+            emits: step?.emits,
+            awaitBefore: step?.awaitBefore,
+            awaitAfter: step?.awaitAfter,
+            stepTimeout: stepStepTimeout
           },
           type: "flow-step",
           style: { minWidth: `${nodeWidth}px` }
         });
+        if (step.awaitBefore) {
+          const awaitNode = out.find((n) => n.id === `await:step-before:${stepName}`);
+          if (awaitNode) {
+            awaitNode.position.x = x - 20;
+          }
+        }
+        if (step.awaitAfter && row === rows - 1 && idx === levelSteps.length - 1) {
+          const awaitKey = `${stepName}:await-after`;
+          const awaitState = states[awaitKey];
+          const awaitStatus = awaitState?.status === "waiting" ? "waiting" : awaitState?.status === "completed" ? "resolved" : awaitState?.status === "timeout" ? "timeout" : "idle";
+          out.push({
+            id: `await:step-after:${stepName}`,
+            position: { x: x - 20, y: yPos + rowHeight + verticalGap },
+            data: {
+              label: `Await (${step.awaitAfter.type})`,
+              awaitType: step.awaitAfter.type,
+              awaitConfig: step.awaitAfter,
+              awaitData: awaitState?.awaitData,
+              status: awaitStatus,
+              scheduledTriggerAt: awaitState?.scheduledTriggerAt
+            },
+            type: "flow-await",
+            style: { minWidth: "180px" }
+          });
+        }
       });
       y += rows * (rowHeight + verticalGap);
+      const lastStepName = levelSteps[levelSteps.length - 1];
+      if (lastStepName && steps[lastStepName]?.awaitAfter) {
+        y += awaitRowHeight + verticalGap;
+      }
     });
   } else {
     const names = Object.keys(steps);
@@ -186,6 +272,8 @@ const nodes = computed(() => {
       const rowStartX = -rowWidth / 2;
       const x = rowStartX + col * (colWidth + horizontalGap);
       const yPos = y + row * (rowHeight + verticalGap);
+      const analyzedStep = f.analyzed?.steps?.[name];
+      const stepStepTimeout = analyzedStep?.stepTimeout;
       out.push({
         id: `step:${name}`,
         position: { x, y: yPos },
@@ -198,57 +286,15 @@ const nodes = computed(() => {
           error: stepState?.error,
           runtime: step?.runtime,
           runtype: step?.runtype,
-          emits: step?.emits
+          emits: step?.emits,
+          stepTimeout: stepStepTimeout
         },
         type: "flow-step",
         style: { minWidth: `${nodeWidth}px` }
       });
     });
   }
-  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];
+  return out;
 });
 function mapStatusToNodeStatus(status) {
   switch (status) {
@@ -277,22 +323,53 @@ const edges = computed(() => {
   function addEdge(source, target, label) {
     const id = `${source}->${target}${label ? `:${label}` : ""}`;
     if (added.has(id)) return;
-    const sourceStep = source.split(":")[1];
-    const targetStep = target.split(":")[1];
-    const sourceState = sourceStep ? states[sourceStep] : void 0;
-    const targetState = targetStep ? states[targetStep] : void 0;
-    const shouldAnimate = props.flowStatus === "running" && sourceState?.status === "completed" && (targetState?.status === "running" || targetState?.status === "pending" || !targetState);
+    const getNodeState = (nodeId) => {
+      if (nodeId.startsWith("await:entry-after:")) {
+        const stepName = nodeId.replace("await:entry-after:", "");
+        return states[`${stepName}:await-after`];
+      }
+      if (nodeId.startsWith("await:step-before:")) {
+        const stepName = nodeId.replace("await:step-before:", "");
+        return states[`${stepName}:await-before`];
+      }
+      if (nodeId.startsWith("await:step-after:")) {
+        const stepName = nodeId.replace("await:step-after:", "");
+        return states[`${stepName}:await-after`];
+      }
+      const parts = nodeId.split(":");
+      return parts[1] ? states[parts[1]] : void 0;
+    };
+    const sourceState = getNodeState(source);
+    const targetState = getNodeState(target);
+    const shouldAnimate = (props.flowStatus === "running" || props.flowStatus === "awaiting") && (sourceState?.status === "completed" || sourceState?.status === "resolved") && (targetState?.status === "running" || targetState?.status === "pending" || targetState?.status === "waiting" || !targetState);
     added.add(id);
     out.push({ id, source, target, label, animated: shouldAnimate });
   }
   if (f.analyzed?.steps) {
     const analyzedSteps = f.analyzed.steps;
+    if (f.entry?.awaitAfter) {
+      const entryId = `entry:${f.entry.step}`;
+      const entryAwaitId = `await:entry-after:${f.entry.step}`;
+      addEdge(entryId, entryAwaitId);
+    }
     for (const [stepName, stepInfo] of Object.entries(analyzedSteps)) {
+      if (stepName === f.entry?.step) continue;
       const targetStep = steps[stepName];
       const target = `step:${stepName}`;
+      if (targetStep?.awaitAfter) {
+        const stepId = `step:${stepName}`;
+        const awaitAfterId = `await:step-after:${stepName}`;
+        addEdge(stepId, awaitAfterId);
+      }
       if (stepInfo.dependsOn.length > 0) {
         for (const depName of stepInfo.dependsOn) {
-          const source = depName === f.entry?.step ? `entry:${depName}` : `step:${depName}`;
+          let source;
+          if (depName === f.entry?.step) {
+            source = f.entry.awaitAfter ? `await:entry-after:${depName}` : `entry:${depName}`;
+          } else {
+            const depStep = steps[depName];
+            source = depStep?.awaitAfter ? `await:step-after:${depName}` : `step:${depName}`;
+          }
           if (targetStep?.awaitBefore) {
             const awaitNodeId = `await:step-before:${stepName}`;
             addEdge(source, awaitNodeId);
@@ -301,19 +378,6 @@ const edges = computed(() => {
             addEdge(source, target);
           }
         }
-      } else if (f.entry) {
-        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 {

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

@@ -45,6 +45,7 @@ interface StepStatus {
     status: 'pending' | 'running' | 'completed' | 'failed' | 'retrying' | 'waiting' | 'timeout' | 'canceled';
     attempt?: number;
     error?: string;
+    scheduledTriggerAt?: string;
 }
 type __VLS_Props = {
     flow?: FlowMeta | null;
@@ -53,7 +54,7 @@ type __VLS_Props = {
     showMiniMap?: boolean;
     showBackground?: boolean;
     stepStates?: Record<string, StepStatus>;
-    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled' | 'stalled';
+    flowStatus?: 'running' | 'completed' | 'failed' | 'canceled' | 'stalled' | 'awaiting';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     nodeSelected: (payload: {

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

@@ -1,4 +1,13 @@
 type Status = 'idle' | 'running' | 'error' | 'done' | 'canceled' | string | undefined;
+interface AwaitConfig {
+    type: 'time' | 'event' | 'webhook' | 'schedule';
+    delay?: number;
+    event?: string;
+    method?: string;
+    timeout?: number;
+    timeoutAction?: 'fail' | 'continue';
+    cron?: string;
+}
 type __VLS_Props = {
     id: string;
     data: {
@@ -10,20 +19,14 @@ type __VLS_Props = {
         error?: string;
         runtime?: 'nodejs' | 'python';
         runtype?: 'inprocess' | 'task';
+        subscribes?: string[];
         emits?: string[];
+        awaitBefore?: AwaitConfig;
+        awaitAfter?: AwaitConfig;
+        stepTimeout?: number;
     };
     kind?: 'entry' | 'step';
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    action: (payload: {
-        id: string;
-        action: "run" | "logs" | "details";
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onAction?: ((payload: {
-        id: string;
-        action: "run" | "logs" | "details";
-    }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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/flow/NodeCard.vue

@@ -1,10 +1,9 @@
 <template>
   <UCard
-    class="min-w-[220px] max-w-[300px]"
+    class="min-w-[260px] max-w-[340px]"
     :ui="{
   body: 'p-0',
-  header: headerClass,
-  footer: footerClass
+  header: headerClass
 }"
   >
     <template #header>
@@ -23,24 +22,49 @@
             {{ data?.label }}
           </p>
         </div>
-        <UBadge
-          :label="(data?.status || 'idle').toUpperCase()"
-          size="xs"
-          :color="statusColor(data?.status)"
-        />
+        <div class="flex items-center gap-2">
+          <span
+            v-if="data?.stepTimeout !== void 0 && data.stepTimeout > 0"
+            class="flex items-center gap-1 text-xs opacity-80"
+            :title="`Step Execution Timeout: ${formatStepTimeout(data.stepTimeout)}`"
+          >
+            <UIcon
+              name="i-heroicons-clock-20-solid"
+              class="size-3"
+            />
+            <span>{{ formatStepTimeout(data.stepTimeout) }}</span>
+          </span>
+          <UBadge
+            :label="(data?.status || 'idle').toUpperCase()"
+            size="xs"
+            :color="statusColor(data?.status)"
+          />
+        </div>
       </div>
     </template>
 
     <div class="px-3 py-2 text-xs space-y-1">
       <div class="flex items-center justify-between">
-        <span class="text-gray-500 dark:text-gray-400">Queue</span>
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-queue-list-20-solid"
+            class="size-3"
+          />
+          Queue
+        </span>
         <span
           class="truncate ml-2 font-mono"
           :title="data?.queue"
         >{{ data?.queue || "-" }}</span>
       </div>
       <div class="flex items-center justify-between">
-        <span class="text-gray-500 dark:text-gray-400">Worker</span>
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-cpu-chip-20-solid"
+            class="size-3"
+          />
+          Worker
+        </span>
         <span
           class="truncate ml-2 font-mono"
           :title="data?.workerId"
@@ -58,11 +82,39 @@
           variant="soft"
         />
       </div>
+      <div
+        v-if="data?.subscribes && data.subscribes.length > 0"
+        class="flex items-start justify-between gap-2"
+      >
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-arrow-down-on-square-stack-20-solid"
+            class="size-3"
+          />
+          Subscribes
+        </span>
+        <div class="flex flex-wrap gap-1 justify-end">
+          <UBadge
+            v-for="event in data.subscribes"
+            :key="event"
+            :label="event"
+            size="xs"
+            color="blue"
+            variant="soft"
+          />
+        </div>
+      </div>
       <div
         v-if="data?.emits && data.emits.length > 0"
         class="flex items-start justify-between gap-2"
       >
-        <span class="text-gray-500 dark:text-gray-400">Emits</span>
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-arrow-up-on-square-stack-20-solid"
+            class="size-3"
+          />
+          Emits
+        </span>
         <div class="flex flex-wrap gap-1 justify-end">
           <UBadge
             v-for="event in data.emits"
@@ -74,6 +126,42 @@
           />
         </div>
       </div>
+      <div
+        v-if="data?.awaitBefore"
+        class="flex items-center justify-between"
+      >
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-clock-20-solid"
+            class="size-3"
+          />
+          Await Before
+        </span>
+        <UBadge
+          :label="data.awaitBefore.type"
+          size="xs"
+          color="violet"
+          variant="soft"
+        />
+      </div>
+      <div
+        v-if="data?.awaitAfter"
+        class="flex items-center justify-between"
+      >
+        <span class="text-gray-500 dark:text-gray-400 flex items-center gap-1">
+          <UIcon
+            name="i-heroicons-clock-20-solid"
+            class="size-3"
+          />
+          Await After
+        </span>
+        <UBadge
+          :label="data.awaitAfter.type"
+          size="xs"
+          color="violet"
+          variant="soft"
+        />
+      </div>
       <div
         v-if="data?.attempt && data.attempt > 1"
         class="flex items-center justify-between"
@@ -95,25 +183,6 @@
         </span>
       </div>
     </div>
-
-    <template #footer>
-      <div class="flex items-center justify-center gap-2 w-full">
-        <UButton
-          size="xs"
-          color="neutral"
-          label="Logs"
-          icon="i-heroicons-document-text-20-solid"
-          @click="handleAction('logs')"
-        />
-        <UButton
-          size="xs"
-          color="neutral"
-          label="Details"
-          icon="i-heroicons-information-circle-20-solid"
-          @click="handleAction('details')"
-        />
-      </div>
-    </template>
   </UCard>
 </template>
 
@@ -124,12 +193,7 @@ const props = defineProps({
   data: { type: Object, required: true },
   kind: { type: String, required: false }
 });
-const emit = defineEmits(["action"]);
-function handleAction(action) {
-  emit("action", { id: props.id, action });
-}
 const headerClass = computed(() => props.kind === "entry" ? "px-3 py-2 bg-gradient-to-br from-emerald-800 to-emerald-700 text-emerald-50 rounded-t" : "px-3 py-2 bg-gradient-to-br from-gray-800 to-gray-700 text-gray-100 rounded-t");
-const footerClass = computed(() => props.kind === "entry" ? "px-3 pb-2 pt-1" : "px-3 pb-2 pt-1");
 const runnerIcon = computed(() => {
   const runtime = props.data?.runtime;
   if (runtime === "python") {
@@ -154,4 +218,24 @@ function statusColor(status) {
       return "neutral";
   }
 }
+function formatStepTimeout(ms) {
+  if (!ms || ms === 0) return "None";
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+  }
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+  }
+  if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  return `${seconds}s`;
+}
 </script>

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

@@ -1,4 +1,13 @@
 type Status = 'idle' | 'running' | 'error' | 'done' | 'canceled' | string | undefined;
+interface AwaitConfig {
+    type: 'time' | 'event' | 'webhook' | 'schedule';
+    delay?: number;
+    event?: string;
+    method?: string;
+    timeout?: number;
+    timeoutAction?: 'fail' | 'continue';
+    cron?: string;
+}
 type __VLS_Props = {
     id: string;
     data: {
@@ -10,20 +19,14 @@ type __VLS_Props = {
         error?: string;
         runtime?: 'nodejs' | 'python';
         runtype?: 'inprocess' | 'task';
+        subscribes?: string[];
         emits?: string[];
+        awaitBefore?: AwaitConfig;
+        awaitAfter?: AwaitConfig;
+        stepTimeout?: number;
     };
     kind?: 'entry' | 'step';
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    action: (payload: {
-        id: string;
-        action: "run" | "logs" | "details";
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onAction?: ((payload: {
-        id: string;
-        action: "run" | "logs" | "details";
-    }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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/flow/RunOverview.d.vue.ts

@@ -8,6 +8,7 @@ type __VLS_Props = {
     triggerName?: string;
     triggerType?: 'manual' | 'event' | 'webhook' | 'schedule';
     flowDef?: any;
+    stallTimeout?: number;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "select-step": (stepKey: string | null) => any;