@revenexx/studio-integrations 1.0.0 → 1.1.1

package/dist/runtime/components/Integrations/WorkflowNodeView.d.vue.ts

@@ -9,6 +9,19 @@ interface NodeData extends WorkflowNode {
      *  injected by the editor the same non-persisting way. Read-only canvases
      *  (run replay, history preview) never pass them, so nothing is marked there. */
     __invalidFields?: string[];
+    /**
+     * Where this node stands with respect to an iterator's loop body (PO-277),
+     * computed per sync from the blob's edges (`data/loopBody.ts`) and injected
+     * like the two above. Unlike them it reaches ALL THREE canvases: what repeats
+     * is a property of the workflow rather than of editing it, and a run replay is
+     * where the repetition is most real.
+     */
+    __loop?: {
+        /** The iterators whose body this node is in, outermost first, by label. */
+        inside?: string[];
+        /** Set on an iterator itself: how many nodes hang off its `item` port. */
+        bodySize?: number;
+    };
 }
 type __VLS_Props = {
     id: string;

package/dist/runtime/components/Integrations/WorkflowNodeView.vue

@@ -3,7 +3,7 @@ import { computed, inject, nextTick, ref, watch } from "vue";
 import { Handle, Position, useVueFlow } from "@vue-flow/core";
 import { NodeToolbar } from "@vue-flow/node-toolbar";
 import * as Lucide from "lucide-vue-next";
-import { Copy, DangerTriangle as AlertTriangle, RefreshCircle as Loader2, TrashBinMinimalistic as TrashBin } from "#solar-icons";
+import { Copy, DangerTriangle as AlertTriangle, RefreshCircle as Loader2, Repeat, TrashBinMinimalistic as TrashBin } from "#solar-icons";
 import { NODE_CATEGORIES, findManifest, isVersionExecutable } from "../../data/integrationNodeCatalog";
 import { isTerminalManifest } from "../../data/nodeInputData";
 import { resolveDisplayName, resolveLocalized } from "../../utils/localize";
@@ -22,6 +22,12 @@ const title = computed(
 );
 const invalidFields = computed(() => props.data.__invalidFields ?? []);
 const invalidLabel = computed(() => t("integration.canvas.node.badge.invalidConfig", invalidFields.value.length, { fields: invalidFields.value.join(", ") }));
+const insideLoops = computed(() => props.data.__loop?.inside ?? []);
+const repeatsLabel = computed(() => t("integration.canvas.node.badge.repeats", insideLoops.value.length, { iterators: insideLoops.value.join(", ") }));
+const bodySize = computed(() => props.data.__loop?.bodySize);
+const bodySizeLabel = computed(() => t("integration.canvas.node.badge.loopBody", bodySize.value ?? 0));
+const loopHighlight = inject("workflow-loop-highlight", null);
+const inSelectedLoop = computed(() => !!loopHighlight?.value.has(props.id));
 const notes = computed(() => (props.data.notes ?? "").trim());
 const noteOpen = ref(false);
 const noteReady = ref(false);
@@ -264,7 +270,7 @@ function remove() {
     @mouseenter="onHoverEnter"
     @mouseleave="onHoverLeave"
     :class="[
-  selected ? 'border-emerald-500/50 shadow-[0_0_0_2px_rgba(16,185,129,0.18)]' : invalidFields.length ? 'border-amber-500/70 shadow-[0_0_0_2px_rgba(245,158,11,0.22)] hover:shadow-md' : 'border-black/[0.08] shadow-sm hover:shadow-md hover:border-black/[0.16]',
+  selected ? 'border-emerald-500/50 shadow-[0_0_0_2px_rgba(16,185,129,0.18)]' : invalidFields.length ? 'border-amber-500/70 shadow-[0_0_0_2px_rgba(245,158,11,0.22)] hover:shadow-md' : inSelectedLoop ? 'border-slate-400/80 shadow-[0_0_0_2px_rgba(100,116,139,0.20)]' : 'border-black/[0.08] shadow-sm hover:shadow-md hover:border-black/[0.16]',
   showPortLabels ? 'pb-3.5' : ''
 ]"
   >
@@ -275,7 +281,7 @@ function remove() {
          a bare count at a corner is a riddle, so each carries its own title;
          `nodrag` keeps that hover from starting a card drag. -->
     <span
-      v-if="invalidFields.length || unbuildableVersion"
+      v-if="invalidFields.length || unbuildableVersion || insideLoops.length || bodySize !== void 0"
       class="nodrag absolute -left-2 -top-2 z-10 flex items-center gap-1"
     >
       <span
@@ -305,6 +311,35 @@ function remove() {
       >
         <AlertTriangle :size="9" weight="Bold" />
       </span>
+      <!-- Repetition (PO-277). Slate, not amber or rose: a loop is how the
+           workflow is built, not something wrong with it. The glyph is the
+           mark; the count next to it is the depth, printed from 2 up because
+           "repeats" is the news at one loop and "repeats twice over" is the
+           news above it. Both marks carry their sentence as their accessible
+           name — a bare arrow at a corner is a riddle. -->
+      <span
+        v-if="insideLoops.length"
+        role="img"
+        :aria-label="repeatsLabel"
+        :title="repeatsLabel"
+        class="flex cursor-help items-center gap-0.5 rounded-full bg-slate-600 px-1.5 py-0.5 text-[9px] font-bold leading-none text-white shadow-sm"
+      >
+        <Repeat :size="9" weight="Bold" />
+        <template v-if="insideLoops.length > 1">{{ insideLoops.length }}</template>
+      </span>
+      <!-- The loop itself, and how much of the canvas it repeats. Outlined
+           rather than filled: it names the same fact from the other end, and two
+           solid slate pills side by side on a nested iterator would read as one. -->
+      <span
+        v-if="bodySize !== void 0"
+        role="img"
+        :aria-label="bodySizeLabel"
+        :title="bodySizeLabel"
+        class="flex cursor-help items-center gap-0.5 rounded-full border border-slate-300 bg-white px-1.5 py-0.5 text-[9px] font-bold leading-none text-slate-600 shadow-sm"
+      >
+        <Repeat :size="9" weight="Bold" />
+        {{ bodySize }}
+      </span>
     </span>
     <!-- Always-visible edit affordance: single click opens the config lightbox.
          (Double-click on the whole card works too.) Hidden in read-only hosts

package/dist/runtime/components/Integrations/WorkflowNodeView.vue.d.ts

@@ -9,6 +9,19 @@ interface NodeData extends WorkflowNode {
      *  injected by the editor the same non-persisting way. Read-only canvases
      *  (run replay, history preview) never pass them, so nothing is marked there. */
     __invalidFields?: string[];
+    /**
+     * Where this node stands with respect to an iterator's loop body (PO-277),
+     * computed per sync from the blob's edges (`data/loopBody.ts`) and injected
+     * like the two above. Unlike them it reaches ALL THREE canvases: what repeats
+     * is a property of the workflow rather than of editing it, and a run replay is
+     * where the repetition is most real.
+     */
+    __loop?: {
+        /** The iterators whose body this node is in, outermost first, by label. */
+        inside?: string[];
+        /** Set on an iterator itself: how many nodes hang off its `item` port. */
+        bodySize?: number;
+    };
 }
 type __VLS_Props = {
     id: string;

package/dist/runtime/components/Integrations/WorkflowRunReplayPanel.vue

@@ -24,9 +24,10 @@ import StickyNoteView from "./StickyNoteView.vue";
 import GroupFrameView from "./GroupFrameView.vue";
 import WorkflowEdgeView from "./WorkflowEdgeView.vue";
 import { findManifest } from "../../data/integrationNodeCatalog";
+import { nodeLoopData } from "../../data/loopBody";
 import { triggerGlyph } from "../../data/triggerGlyphs";
 import { SAFETY_POLL_MS } from "../../utils/pollBudget";
-import { runStatusLabel, statusClass } from "../../utils/statusStyle";
+import { runStatusClass, runStatusLabel } from "../../utils/statusStyle";
 const props = defineProps({
   workflow: { type: Object, required: true },
   initialRunId: { type: [String, null], required: false },
@@ -236,6 +237,7 @@ function replayNodeClass(id, type) {
   const active = activeStep.value?.node_id === id ? " replay-node-active" : "";
   return `${tone}${reached ? "" : " replay-unreached"}${active}`;
 }
+const loops = computed(() => nodeLoopData(props.workflow.blob.nodes, props.workflow.blob.edges));
 const vfNodes = computed(() => {
   const blob = props.workflow.blob;
   const triggerPos = (id, i) => blob.triggerPositions?.[id] ?? { x: -40, y: 60 + i * 140 };
@@ -274,7 +276,7 @@ const vfNodes = computed(() => {
       position: n.position ?? { x: 240, y: 80 },
       draggable: false,
       class: replayNodeClass(n.id, "workflow"),
-      data: { ...n, __resolvedOutputs: dynamicOutputs.value[n.id] }
+      data: { ...n, __resolvedOutputs: dynamicOutputs.value[n.id], __loop: loops.value.get(n.id) }
     }))
   ];
 });
@@ -471,7 +473,7 @@ watch(() => props.initialRunId, (id) => {
         <div class="absolute top-3 left-3 z-10 flex items-center gap-2 rounded-lg border border-black/[0.08] bg-white/95 px-2.5 py-1.5 text-sm shadow-sm backdrop-blur-sm">
           <Play :size="13" class="text-muted-foreground" />
           <span class="font-medium">{{ selectedRunId ? t("integration.replay.canvas.runLabel", { id: selectedRunId }) : t("integration.replay.canvas.pickRun") }}</span>
-          <Badge v-if="runStatus" variant="outline" class="border text-xs font-medium uppercase" :class="statusClass(runStatus)">
+          <Badge v-if="runStatus" variant="outline" class="border text-xs font-medium uppercase" :class="runStatusClass(runStatus)">
             {{ runStatusLabel(runStatus) }}
           </Badge>
           <Badge v-if="stepsSource" variant="outline" class="border text-xs font-medium uppercase text-muted-foreground">
@@ -535,7 +537,7 @@ watch(() => props.initialRunId, (id) => {
             <template v-else>{{ t("integration.replay.debug.noStepSelected") }}</template>
           </div>
         </div>
-        <Badge v-if="activeStep" variant="outline" class="shrink-0 border text-xs font-medium uppercase" :class="statusClass(activeStep.status)">
+        <Badge v-if="activeStep" variant="outline" class="shrink-0 border text-xs font-medium uppercase" :class="runStatusClass(activeStep.status)">
           {{ runStatusLabel(activeStep.status) }}
         </Badge>
       </div>
@@ -613,8 +615,8 @@ watch(() => props.initialRunId, (id) => {
               <component :is="triggerIcon(r.triggerType)" :size="12" class="shrink-0 text-muted-foreground" />
               <span class="truncate">#{{ r.id }}</span>
             </span>
-            <Badge variant="outline" class="shrink-0 border text-xs font-medium uppercase" :class="statusClass(r.status)">
-              {{ r.status }}
+            <Badge variant="outline" class="shrink-0 border text-xs font-medium uppercase" :class="runStatusClass(r.status)">
+              {{ runStatusLabel(r.status) }}
             </Badge>
           </div>
           <div class="mt-0.5 flex items-center justify-between gap-2 text-sm text-muted-foreground">

package/dist/runtime/components/Integrations/WorkflowsTable.vue

@@ -50,13 +50,18 @@ watch(groupByTags, (on) => {
   } catch {
   }
 });
-const { runs, loaded: runsLoaded, load: loadRuns, list: listRuns } = useIntegrationsRuns();
+const {
+  latestPerWorkflow,
+  latestLoaded: runsLoaded,
+  loadLatestPerWorkflow,
+  lastRunFor: latestRunFor
+} = useIntegrationsRuns();
 onMounted(() => {
-  void loadRuns();
+  void loadLatestPerWorkflow();
 });
 function lastRunFor(id) {
-  void runs.value.length;
-  return listRuns({ workflowId: id })[0] ?? null;
+  void latestPerWorkflow.value.length;
+  return latestRunFor(id);
 }
 function runBadge(status) {
   switch (status) {

package/dist/runtime/composables/useIntegrationsDeadLetters.d.ts

@@ -1,7 +1,11 @@
 import type { DeadLetterRow } from '../types/integrations.js';
-/** A dead letter enriched with its workflow's name (global "Missed runs" view). */
+/**
+ * A dead letter as the tenant-wide list serves it: the platform now reports the
+ * workflow's name on the row, where the fan-out had to inject it from the loop
+ * variable.
+ */
 export interface GlobalDeadLetterRow extends DeadLetterRow {
-    workflowName: string;
+    workflow_name?: string | null;
 }
 export declare function useIntegrationsDeadLetters(): {
     list: (workflowId: number | string, opts?: {
@@ -18,5 +22,8 @@ export declare function useIntegrationsDeadLetters(): {
     loadGlobal: (force?: boolean) => Promise<GlobalDeadLetterRow[]>;
     globalItems: any;
     globalLoading: any;
+    globalLoaded: any;
+    globalHasMore: any;
+    summary: any;
     pendingCount: import("vue").ComputedRef<any>;
 };

package/dist/runtime/composables/useIntegrationsDeadLetters.js

@@ -1,6 +1,7 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { useLoadGate } from "./useLoadGate.js";
+const EMPTY_SUMMARY = { total: 0, by_status: {} };
 export function useIntegrationsDeadLetters() {
   const api = useIntegrationsApi();
   async function list(workflowId, opts = {}) {
@@ -18,34 +19,42 @@ export function useIntegrationsDeadLetters() {
   }
   const replay = (id) => api.post(`/dead-letters/${id}/replay`, {});
   const discard = (id) => api.post(`/dead-letters/${id}/discard`, {});
-  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
   const globalItems = useState("integrations.deadletters.global", () => []);
   const globalLoading = useState("integrations.deadletters.global.loading", () => false);
   const globalLoaded = useState("integrations.deadletters.global.loaded", () => false);
   const gate = useLoadGate("integrations.deadletters.global", { loading: globalLoading, loaded: globalLoaded });
-  const pendingCount = computed(() => globalItems.value.filter((i) => i.status === "pending").length);
+  const summary = useState("integrations.deadletters.summary", () => ({ ...EMPTY_SUMMARY }));
+  const globalHasMore = useState("integrations.deadletters.global.hasMore", () => false);
+  const pendingCount = computed(() => summary.value.by_status.pending ?? 0);
   async function loadGlobal(force = false) {
     if (!await gate.claim(force)) return globalItems.value;
     try {
-      await loadWorkflows();
-      const MAX_PAGES = 20;
-      const per = await Promise.allSettled(workflows.value.map(async (wf) => {
-        const out = [];
-        let page = 1;
-        while (page <= MAX_PAGES) {
-          const res = await list(wf.id, { page, perPage: 100 });
-          out.push(...res.items.map((i) => ({ ...i, workflowName: wf.name })));
-          if (page >= res.lastPage) break;
-          page++;
-        }
-        return out;
-      }));
-      globalItems.value = per.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.created_at ?? 0).getTime() - new Date(a.created_at ?? 0).getTime());
-      globalLoaded.value = workflowsLoaded.value && per.every((p) => p.status === "fulfilled");
+      const [page, counts] = await Promise.all([
+        api.get("/dead-letters?page=1&per_page=100"),
+        api.get("/dead-letters/summary")
+      ]);
+      globalItems.value = page?.data ?? [];
+      globalHasMore.value = page?.meta?.has_more ?? false;
+      summary.value = counts?.data ?? { ...EMPTY_SUMMARY };
+      globalLoaded.value = true;
+    } catch (e) {
+      globalLoaded.value = false;
+      throw e;
     } finally {
       gate.release();
     }
     return globalItems.value;
   }
-  return { list, replay, discard, loadGlobal, globalItems, globalLoading, pendingCount };
+  return {
+    list,
+    replay,
+    discard,
+    loadGlobal,
+    globalItems,
+    globalLoading,
+    globalLoaded,
+    globalHasMore,
+    summary,
+    pendingCount
+  };
 }

package/dist/runtime/composables/useIntegrationsRuns.d.ts

@@ -1,13 +1,36 @@
 import type { RunStatus, RunStepRow, WorkflowRun } from '../types/integrations.js';
+interface RunSummary {
+    total: number;
+    in_flight: number;
+    by_status: Record<string, number>;
+}
+/**
+ * Which page of the tenant's list to read.
+ *
+ * Only the page: `/runs` also narrows by status, trigger kind, workflow, window
+ * and text, and none of that is driven from here yet. The shared DataTable
+ * narrows and searches what it holds, and it cannot report a filter selection
+ * back to the page under `serverMode` — so a narrowing sent to the platform
+ * would have nothing to set it. That is the remaining half of PO-231, and the
+ * parameters are waiting on the endpoint for it.
+ */
+export interface RunFeedQuery {
+    page: number;
+    perPage: number;
+}
 export declare function useIntegrationsRuns(): {
     runs: any;
     loading: any;
     error: any;
     loaded: any;
     total: import("vue").ComputedRef<any>;
-    failedCount: import("vue").ComputedRef<any>;
+    failedCount: import("vue").ComputedRef<number>;
     runningCount: import("vue").ComputedRef<any>;
+    summary: any;
+    hasMore: any;
+    query: any;
     load: (force?: boolean) => Promise<WorkflowRun[]>;
+    loadSummary: () => Promise<RunSummary>;
     loadForWorkflow: (workflowId: number, workflowName: string, opts?: {
         reconcile?: boolean;
         page?: number;
@@ -24,6 +47,11 @@ export declare function useIntegrationsRuns(): {
     }) => WorkflowRun[];
     get: (id: string) => WorkflowRun | null;
     fetchRun: (workflowId: number | string, runId: number | string, workflowName: string) => Promise<WorkflowRun>;
+    latestPerWorkflow: any;
+    latestLoaded: any;
+    latestLoading: any;
+    loadLatestPerWorkflow: (force?: boolean) => Promise<WorkflowRun[]>;
+    lastRunFor: (workflowId: number) => WorkflowRun | null;
     trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "async" | "sync") => Promise<unknown>;
     cancelRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     terminateRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
@@ -49,3 +77,4 @@ export declare function useIntegrationsRuns(): {
     }>;
     getStackTrace: (workflowId: number | string, runId: number | string) => Promise<string>;
 };
+export {};

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -3,6 +3,7 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+const EMPTY_SUMMARY = { total: 0, in_flight: 0, by_status: {} };
 function mapStatus(status) {
   switch (status) {
     case "completed":
@@ -31,22 +32,30 @@ export function useIntegrationsRuns() {
   const error = useState("integrations.runs.error", () => null);
   const loaded = useState("integrations.runs.loaded", () => false);
   const reconciling = useState("integrations.runs.reconciling", () => false);
+  const summary = useState("integrations.runs.summary", () => ({ ...EMPTY_SUMMARY }));
+  const hasMore = useState("integrations.runs.hasMore", () => false);
+  const query = useState("integrations.runs.query", () => ({
+    page: 1,
+    perPage: 100
+  }));
   const gate = useLoadGate("integrations.runs", { loading, loaded });
   const SYNC_LIMIT = 5;
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
-  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
-  function mapRun(r, workflowName) {
+  function mapRun(r, workflowName = "") {
     const startedMs = r.started_at ? new Date(r.started_at).getTime() : null;
     const finishedMs = r.completed_at ? new Date(r.completed_at).getTime() : null;
     return {
       id: String(r.id),
       workflowId: r.workflow_id,
-      workflowName,
+      workflowName: r.workflow_name ?? workflowName,
       status: mapStatus(r.status),
       temporalRunId: r.temporal_run_id ?? null,
-      triggerId: "",
-      triggerType: "manual",
+      triggerId: r.trigger_handle ?? "",
+      // The platform reports what started the run. This was hardcoded to
+      // `manual` because the payload carried nothing, which left the trigger
+      // column and its filter with one populated value in production.
+      triggerType: r.trigger_type ?? "manual",
       startedAt: r.started_at ?? "",
       finishedAt: r.completed_at ?? null,
       // The list carries the reason a run failed; dropping it here was why every
@@ -63,25 +72,14 @@ export function useIntegrationsRuns() {
     if (!await gate.claim(force)) return runs.value;
     error.value = null;
     try {
-      await loadWorkflows();
-      const MAX_PAGES = 100;
-      const perWorkflow = await Promise.allSettled(
-        workflows.value.map(async (wf) => {
-          const out = [];
-          let page = 1;
-          while (page <= MAX_PAGES) {
-            const res = await api.get(
-              `/workflows/${wf.id}/runs?page=${page}&per_page=100`
-            );
-            out.push(...(res?.data ?? []).map((r) => mapRun(r, wf.name)));
-            const last = res?.meta?.last_page ?? 1;
-            if (page >= last) break;
-            page++;
-          }
-          return out;
-        })
-      );
-      runs.value = perWorkflow.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+      const { page: pageNumber, perPage } = query.value;
+      const [page, counts] = await Promise.all([
+        api.get(`/runs?page=${pageNumber}&per_page=${perPage}`),
+        api.get("/runs/summary")
+      ]);
+      runs.value = (page?.data ?? []).map((r) => mapRun(r));
+      hasMore.value = page?.meta?.has_more ?? false;
+      summary.value = counts?.data ?? { ...EMPTY_SUMMARY };
       if (!reconciling.value) {
         reconciling.value = true;
         try {
@@ -99,9 +97,10 @@ export function useIntegrationsRuns() {
           reconciling.value = false;
         }
       }
-      loaded.value = workflowsLoaded.value && perWorkflow.every((p) => p.status === "fulfilled");
+      loaded.value = true;
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+      loaded.value = false;
     } finally {
       gate.release();
     }
@@ -137,7 +136,40 @@ export function useIntegrationsRuns() {
     let result = [...runs.value];
     if (filter?.workflowId !== void 0) result = result.filter((r) => r.workflowId === filter.workflowId);
     if (filter?.status) result = result.filter((r) => r.status === filter.status);
-    return result.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    return result;
+  }
+  async function loadSummary() {
+    try {
+      const res = await api.get("/runs/summary");
+      summary.value = res?.data ?? { ...EMPTY_SUMMARY };
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+    }
+    return summary.value;
+  }
+  const latestPerWorkflow = useState("integrations.runs.latest", () => []);
+  const latestLoaded = useState("integrations.runs.latest.loaded", () => false);
+  const latestLoading = useState("integrations.runs.latest.loading", () => false);
+  const latestGate = useLoadGate("integrations.runs.latest", {
+    loading: latestLoading,
+    loaded: latestLoaded
+  });
+  async function loadLatestPerWorkflow(force = false) {
+    if (!await latestGate.claim(force)) return latestPerWorkflow.value;
+    try {
+      const res = await api.get("/runs/latest-per-workflow");
+      latestPerWorkflow.value = (res?.data ?? []).map((r) => mapRun(r));
+      latestLoaded.value = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+      latestLoaded.value = false;
+    } finally {
+      latestGate.release();
+    }
+    return latestPerWorkflow.value;
+  }
+  function lastRunFor(workflowId) {
+    return latestPerWorkflow.value.find((r) => r.workflowId === workflowId) ?? null;
   }
   function get(id) {
     return runs.value.find((r) => r.id === id) ?? null;
@@ -175,9 +207,9 @@ export function useIntegrationsRuns() {
     return api.get(`/workflows/${workflowId}/runs/${runId}/history${suffix}`);
   };
   const getStackTrace = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}/stack-trace`).then((r) => r.stack_trace);
-  const total = computed(() => runs.value.length);
-  const failedCount = computed(() => runs.value.filter((r) => r.status === "failed").length);
-  const runningCount = computed(() => runs.value.filter((r) => r.status === "running").length);
+  const total = computed(() => summary.value.total);
+  const failedCount = computed(() => Object.entries(summary.value.by_status).filter(([status]) => mapStatus(status) === "failed").reduce((sum, [, count]) => sum + count, 0));
+  const runningCount = computed(() => summary.value.in_flight);
   return {
     runs,
     loading,
@@ -186,11 +218,20 @@ export function useIntegrationsRuns() {
     total,
     failedCount,
     runningCount,
+    summary,
+    hasMore,
+    query,
     load,
+    loadSummary,
     loadForWorkflow,
     list,
     get,
     fetchRun,
+    latestPerWorkflow,
+    latestLoaded,
+    latestLoading,
+    loadLatestPerWorkflow,
+    lastRunFor,
     trigger,
     cancelRun,
     terminateRun,

package/dist/runtime/composables/useIntegrationsSchedules.d.ts

@@ -1,19 +1,11 @@
 import type { ScheduleEntry } from '../types/integrations.js';
-/**
- * Derived view — every trigger of type `schedule` across all workflows, as
- * `useIntegrationsTriggers` holds them: read out of the workflow list, which carries
- * each workflow's triggers, rather than fetched per workflow (PO-236).
- * Next/last-run timestamps are mocked deterministically (no telemetry
- * endpoint yet).
- *
- * Unordered on purpose: the page's table sorts, by its own default and by
- * whichever column the operator clicks, so an order established here would be
- * replaced before anyone saw it.
- */
 export declare function useIntegrationsSchedules(): {
-    entries: import("vue").ComputedRef<ScheduleEntry[]>;
-    total: import("vue").ComputedRef<number>;
-    activeCount: import("vue").ComputedRef<number>;
+    entries: any;
+    total: import("vue").ComputedRef<any>;
+    activeCount: import("vue").ComputedRef<any>;
+    timezonesInUse: import("vue").ComputedRef<any>;
     loading: any;
-    load: any;
+    loaded: any;
+    error: any;
+    load: (force?: boolean) => Promise<ScheduleEntry[]>;
 };