@revenexx/studio-integrations 0.7.0 → 1.1.0

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

@@ -1,11 +1,11 @@
 <script setup>
-import { ref, watch } from "vue";
-import { RefreshCircle as Loader2 } from "#solar-icons";
+import { computed, ref, watch } from "vue";
 import {
   Button,
   Dialog,
   DialogContent,
   DialogDescription,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
   Input,
@@ -23,24 +23,35 @@ const props = defineProps({
   open: { type: Boolean, required: true },
   workflow: { type: Object, required: true },
   modes: { type: Array, required: true },
-  modeDraft: { type: String, required: true },
-  savingMode: { type: Boolean, required: false },
-  savingMeta: { type: Boolean, required: false },
+  current: { type: Object, required: true },
   tagSuggestions: { type: Array, required: false }
 });
-const emit = defineEmits(["update:open", "change-mode", "save-meta"]);
+const emit = defineEmits(["update:open", "apply"]);
 const t = useIntegrationsT();
 const nameDraft = ref("");
 const descriptionDraft = ref("");
 const tagsDraft = ref([]);
 const iconDraft = ref(null);
+const modeDraft = ref("");
 watch(() => props.open, (v) => {
   if (!v) return;
-  nameDraft.value = props.workflow.name;
-  descriptionDraft.value = props.workflow.description ?? "";
-  tagsDraft.value = [...props.workflow.blob.tags ?? []];
-  iconDraft.value = props.workflow.blob.icon ?? null;
+  nameDraft.value = props.current.name;
+  descriptionDraft.value = props.current.description;
+  tagsDraft.value = [...props.current.tags];
+  iconDraft.value = props.current.icon;
+  modeDraft.value = props.current.executionMode;
 }, { immediate: true });
+const edited = computed(() => ({
+  name: nameDraft.value.trim(),
+  description: descriptionDraft.value.trim(),
+  tags: tagsDraft.value,
+  icon: iconDraft.value,
+  executionMode: modeDraft.value
+}));
+function applyAndClose() {
+  if (JSON.stringify(edited.value) !== JSON.stringify(props.current)) emit("apply", edited.value);
+  emit("update:open", false);
+}
 function formatDateTime(iso) {
   if (!iso) return "\u2014";
   try {
@@ -57,7 +68,10 @@ function formatDateTime(iso) {
       <DialogHeader>
         <DialogTitle>{{ t("integration.workflows.settings.dialog.title") }}</DialogTitle>
         <DialogDescription class="text-sm">
-          {{ t("integration.workflows.settings.dialog.description", { name: workflow.name }) }}
+          <!-- The name as it stands, drafted included: this dialog is where a rename is
+               typed, so naming the workflow by its stored name here contradicts the
+               field directly below. -->
+          {{ t("integration.workflows.settings.dialog.description", { name: current.name }) }}
         </DialogDescription>
       </DialogHeader>
 
@@ -66,9 +80,7 @@ function formatDateTime(iso) {
           <div class="text-mono text-muted-foreground">{{ t("integration.workflows.settings.section.execution") }}</div>
           <div class="flex items-center gap-2">
             <Select
-              :model-value="modeDraft"
-              :disabled="savingMode"
-              @update:model-value="(v) => emit('change-mode', v)"
+              v-model="modeDraft"
             >
               <!-- Named explicitly: the section caption above says "Execution",
                    which is not a name the control itself carries. -->
@@ -81,7 +93,6 @@ function formatDateTime(iso) {
                 </SelectItem>
               </SelectContent>
             </Select>
-            <Loader2 v-if="savingMode" :size="14" class="shrink-0 animate-spin text-muted-foreground" />
           </div>
           <p class="text-xs text-muted-foreground">
             {{ modes.find((m2) => m2.value === modeDraft)?.hint }}
@@ -109,17 +120,6 @@ function formatDateTime(iso) {
             <Label id="wf-set-icon-label" class="text-sm font-normal text-muted-foreground">{{ t("integration.workflows.settings.field.icon.label") }}</Label>
             <WorkflowIconPicker v-model="iconDraft" trigger-labelledby="wf-set-icon-label" />
           </div>
-          <div class="flex justify-end">
-            <Button
-              size="sm"
-              class="h-7 text-sm"
-              :disabled="savingMeta || !nameDraft.trim()"
-              @click="emit('save-meta', { name: nameDraft.trim(), description: descriptionDraft.trim(), tags: tagsDraft, icon: iconDraft })"
-            >
-              <Loader2 v-if="savingMeta" :size="12" class="animate-spin" />
-              {{ t("integration.workflows.settings.action.save") }}
-            </Button>
-          </div>
         </div>
 
         <div class="rounded-lg border border-black/[0.06] bg-white p-4 space-y-2">
@@ -138,6 +138,17 @@ function formatDateTime(iso) {
           </div>
         </div>
       </div>
+
+      <!-- Cancel / Done, the pair every dialog in the editor closes on. Done reaches
+           the workflow's unsaved state; the header's Save reaches the platform. -->
+      <DialogFooter>
+        <Button variant="outline" size="sm" class="h-8" @click="emit('update:open', false)">
+          {{ t("integration.common.action.cancel") }}
+        </Button>
+        <Button size="sm" class="h-8" :disabled="!nameDraft.trim()" @click="applyAndClose">
+          {{ t("integration.workflows.settings.action.done") }}
+        </Button>
+      </DialogFooter>
     </DialogContent>
   </Dialog>
 </template>

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

@@ -4,33 +4,32 @@ export interface ExecutionModeOption {
     label: string;
     hint: string;
 }
+/** What this dialog edits — the values as they stand, saved or not. */
+export interface WorkflowSettingsValues {
+    name: string;
+    description: string;
+    tags: string[];
+    icon: WorkflowIcon | null;
+    executionMode: string;
+}
 type __VLS_Props = {
     open: boolean;
     workflow: Workflow;
     modes: ExecutionModeOption[];
-    modeDraft: string;
-    savingMode?: boolean;
-    savingMeta?: boolean;
+    /**
+     * The values to edit: the editor's unsaved ones where it has any, the saved ones
+     * otherwise. Reopening the dialog therefore shows what the operator last entered
+     * rather than what the platform still holds.
+     */
+    current: WorkflowSettingsValues;
     /** Tag suggestions (tags already used across the tenant's workflows). */
     tagSuggestions?: string[];
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (args_0: boolean) => any;
-    "change-mode": (mode: string) => any;
-    "save-meta": (meta: {
-        name: string;
-        description: string;
-        tags: string[];
-        icon: WorkflowIcon | null;
-    }) => any;
+    apply: (values: WorkflowSettingsValues) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:open"?: ((args_0: boolean) => any) | undefined;
-    "onChange-mode"?: ((mode: string) => any) | undefined;
-    "onSave-meta"?: ((meta: {
-        name: string;
-        description: string;
-        tags: string[];
-        icon: WorkflowIcon | null;
-    }) => any) | undefined;
+    onApply?: ((values: WorkflowSettingsValues) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -2,7 +2,8 @@
 import { computed, ref } from "vue";
 import { Handle, Position, useVueFlow } from "@vue-flow/core";
 import { NodeToolbar } from "@vue-flow/node-toolbar";
-import { ClockCircle as Clock, Play, TrashBinMinimalistic as TrashBin, LinkRound as Webhook, Bolt } from "#solar-icons";
+import { TrashBinMinimalistic as TrashBin } from "#solar-icons";
+import { triggerGlyph as glyphForTrigger } from "../../data/triggerGlyphs";
 import { resolveDisplayName } from "../../utils/localize";
 import { triggerTypeLabel } from "../../data/integrationNodeCatalog";
 import { describeCron } from "../../utils/schedule";
@@ -14,9 +15,7 @@ const props = defineProps({
 defineOptions({ inheritAttrs: false });
 defineEmits(["updateNodeInternals"]);
 const t = useIntegrationsT();
-const icon = computed(() => {
-  return props.data.type === "schedule" ? Clock : props.data.type === "webhook" ? Webhook : props.data.type === "event" ? Bolt : Play;
-});
+const icon = computed(() => glyphForTrigger(props.data.type));
 const subtitle = computed(() => {
   const c = props.data.config;
   if (props.data.type === "schedule") return describeCron(c.cron) ?? c.cron ?? t("integration.canvas.trigger.subtitle.noSchedule");
@@ -77,7 +76,7 @@ function sideToPosition(s) {
          identically (icon chip size-8/15, subtitle plain text-sm, mt-0.5). -->
     <div class="flex items-center gap-2.5 px-3 py-2.5">
       <span class="flex size-8 shrink-0 items-center justify-center rounded-md bg-emerald-500 text-white shadow-sm">
-        <component :is="icon" :size="15" :stroke-width="2.5" />
+        <component :is="icon" :size="15" />
       </span>
       <div class="min-w-0 flex-1">
         <div class="text-sm font-semibold text-foreground leading-tight truncate">

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

@@ -6,6 +6,7 @@ import {
   Dialog,
   DialogContent,
   DialogDescription,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
   Input,
@@ -18,7 +19,7 @@ import {
   SelectValue
 } from "@revenexx/studio";
 import { toast } from "vue-sonner";
-import { resolveDisplayName } from "../../utils/localize";
+import { languageKeyRead, languageKeyToWrite, resolveDisplayName } from "../../utils/localize";
 const props = defineProps({
   open: { type: Boolean, required: true },
   variables: { type: Object, required: true }
@@ -27,32 +28,50 @@ const emit = defineEmits(["update:open", "update:variables"]);
 const t = useIntegrationsT();
 const KEY_PATTERN = /^[a-z_][a-z0-9_]*$/i;
 const TYPES = ["string", "number", "boolean", "object", "array"];
+const working = ref({});
 const jsonDrafts = reactive({});
 const jsonErrors = reactive({});
+const descDrafts = reactive({});
 watch(() => props.open, (o) => {
   if (!o) return;
+  working.value = JSON.parse(JSON.stringify(props.variables));
   for (const k of Object.keys(jsonDrafts)) delete jsonDrafts[k];
   for (const k of Object.keys(jsonErrors)) delete jsonErrors[k];
-  for (const [key, v] of Object.entries(props.variables)) {
+  for (const k of Object.keys(descDrafts)) delete descDrafts[k];
+  for (const [key, v] of Object.entries(working.value)) {
+    descDrafts[key] = descriptionText(v);
     if (v.type === "object" || v.type === "array") {
       jsonDrafts[key] = v.default === void 0 ? "" : JSON.stringify(v.default, null, 2);
       jsonErrors[key] = null;
     }
   }
 });
-const entries = computed(() => Object.entries(props.variables));
+const entries = computed(() => Object.entries(working.value));
+const changed = computed(() => JSON.stringify(working.value) !== JSON.stringify(props.variables));
+const hasJsonError = computed(() => Object.values(jsonErrors).some(Boolean));
 function commit(next) {
-  emit("update:variables", next);
+  working.value = next;
+}
+function applyAndClose() {
+  for (const [key, v] of Object.entries(working.value)) {
+    if ((v.type === "object" || v.type === "array") && jsonDrafts[key] !== void 0) {
+      applyJsonDraft(key, v.type);
+    }
+  }
+  if (hasJsonError.value) return;
+  if (changed.value) emit("update:variables", working.value);
+  emit("update:open", false);
 }
 function patchVar(key, patch) {
-  const cur = props.variables[key];
+  const cur = working.value[key];
   if (!cur) return;
-  commit({ ...props.variables, [key]: { ...cur, ...patch } });
+  commit({ ...working.value, [key]: { ...cur, ...patch } });
 }
 function removeVar(key) {
-  const next = { ...props.variables };
+  const next = { ...working.value };
   delete next[key];
   delete jsonDrafts[key];
+  delete descDrafts[key];
   delete jsonErrors[key];
   commit(next);
 }
@@ -65,6 +84,8 @@ function changeType(key, type) {
     array: void 0
   };
   patchVar(key, { type, default: blank[type] });
+  delete jsonDrafts[key];
+  delete jsonErrors[key];
   if (type === "object" || type === "array") {
     jsonDrafts[key] = "";
     jsonErrors[key] = null;
@@ -94,28 +115,34 @@ function descriptionText(v) {
   return resolveDisplayName(v.description);
 }
 function writeDescription(key, text) {
-  const cur = props.variables[key];
+  const cur = working.value[key];
   if (!cur) return;
+  descDrafts[key] = text;
+  const existing = typeof cur.description === "object" && cur.description !== null ? { ...cur.description } : {};
   if (!text.trim()) {
+    delete existing[languageKeyRead(cur.description)];
+    if (Object.keys(existing).length) {
+      patchVar(key, { description: existing });
+      return;
+    }
     const { description: _drop, ...rest } = cur;
-    commit({ ...props.variables, [key]: rest });
+    commit({ ...working.value, [key]: rest });
     return;
   }
-  const existing = typeof cur.description === "object" && cur.description !== null ? cur.description : {};
-  patchVar(key, { description: { ...existing, en: text } });
+  patchVar(key, { description: { ...existing, [languageKeyToWrite(cur.description)]: text } });
 }
 const newKey = ref("");
 const newKeyError = computed(() => {
   const k = newKey.value.trim();
   if (!k) return null;
   if (!KEY_PATTERN.test(k)) return t("integration.workflows.variables.error.invalidKey");
-  if (props.variables[k]) return t("integration.workflows.variables.error.keyExists");
+  if (working.value[k]) return t("integration.workflows.variables.error.keyExists");
   return null;
 });
 function addVariable() {
   const k = newKey.value.trim();
   if (!k || newKeyError.value) return;
-  commit({ ...props.variables, [k]: { type: "string", default: "" } });
+  commit({ ...working.value, [k]: { type: "string", default: "" } });
   newKey.value = "";
 }
 async function copyUsage(key) {
@@ -247,7 +274,7 @@ async function copyUsage(key) {
             <Label :for="`var-${key}-desc`" class="text-mono text-muted-foreground">{{ t("integration.workflows.variables.field.description.label") }}</Label>
             <Input
               :id="`var-${key}-desc`"
-              :model-value="descriptionText(v)"
+              :model-value="descDrafts[key] ?? descriptionText(v)"
               class="h-8 bg-white text-sm"
               :placeholder="t('integration.workflows.variables.field.description.placeholder')"
               @update:model-value="(val) => writeDescription(key, String(val))"
@@ -274,6 +301,18 @@ async function copyUsage(key) {
           <p v-if="newKeyError" class="mt-1 text-xs text-rose-600">{{ newKeyError }}</p>
         </div>
       </div>
+
+      <!-- Cancel / Done, the same pair every dialog in the editor closes on. Done
+           reaches the workflow's unsaved state; only the header's Save reaches the
+           platform. -->
+      <DialogFooter>
+        <Button variant="outline" size="sm" class="h-8" @click="emit('update:open', false)">
+          {{ t("integration.common.action.cancel") }}
+        </Button>
+        <Button size="sm" class="h-8" :disabled="hasJsonError" @click="applyAndClose">
+          {{ t("integration.workflows.variables.action.done") }}
+        </Button>
+      </DialogFooter>
     </DialogContent>
   </Dialog>
 </template>

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/useIntegrationsCredentials.d.ts

@@ -13,8 +13,19 @@ import type { Credential } from '../types/integrations.js';
  *   POST   /credentials/{id}/test        → test saved instance
  *   POST   /credentials/{id}/oauth/authorize-url → { authorize_url, state }
  */
+/**
+ * `message` is what the credential type said about the test, whichever way it went —
+ * which host answered, which environment, which plan, or why it was refused. The
+ * service sends it on every path, and it may be absent.
+ *
+ * `error` is not the service's: it is what THIS composable puts there when the call
+ * never arrived — a network failure, a refusal that is not an answer. Nothing on the
+ * wire ever carries it, so a surface that reads `error` alone and falls back to a
+ * fixed sentence throws away every reason the platform did send.
+ */
 export interface CredentialTestResult {
     ok: boolean;
+    message?: string;
     error?: string;
 }
 export declare function useIntegrationsCredentials(): {

package/dist/runtime/composables/useIntegrationsCredentials.js

@@ -60,7 +60,7 @@ export function useIntegrationsCredentials() {
   async function testInline(credentialTypeSlug, config) {
     try {
       const res = await api.post("/credentials/test", { credential_type_slug: credentialTypeSlug, config });
-      return res?.ok === false ? res : { ok: true };
+      return res?.ok === false ? res : { ok: true, message: res?.message };
     } catch (e) {
       return { ok: false, error: captureError(e, t("integration.credentials.error.testFailed")) };
     }
@@ -68,7 +68,7 @@ export function useIntegrationsCredentials() {
   async function test(id) {
     try {
       const res = await api.post(`/credentials/${encodeURIComponent(id)}/test`);
-      return res?.ok === false ? res : { ok: true };
+      return res?.ok === false ? res : { ok: true, message: res?.message };
     } catch (e) {
       return { ok: false, error: captureError(e, t("integration.credentials.error.testFailed")) };
     }

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/useIntegrationsNodes.js

@@ -4,14 +4,17 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+const RETRY_COOLDOWN_MS = 3e4;
 export function useIntegrationsNodes() {
   const loading = useState("integrations.nodes.loading", () => false);
   const error = useState("integrations.nodes.error", () => null);
   const loaded = useState("integrations.nodes.loaded", () => false);
+  const failedAt = useState("integrations.nodes.failedAt", () => 0);
   const gate = useLoadGate("integrations.nodes", { loading, loaded });
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
   async function load(force = false) {
+    if (!force && failedAt.value && Date.now() - failedAt.value < RETRY_COOLDOWN_MS) return;
     if (!await gate.claim(force)) return;
     error.value = null;
     try {
@@ -23,12 +26,19 @@ export function useIntegrationsNodes() {
         version: n.manifest.version ?? n.version,
         name: n.manifest.name ?? n.name,
         // Keep the source package — the palette groups app nodes by it.
-        __package: n.package ? { name: n.package.name, label: n.package.label ?? null } : void 0
+        __package: n.package ? { name: n.package.name, label: n.package.label ?? null } : void 0,
+        // Registered and built are two different things: a version whose code
+        // was never built can be drawn but not executed, so the palette must
+        // be able to leave it out (PO-338). Missing field = assume built.
+        __hasBundle: n.has_bundle !== false
       }));
       applyNodeCatalog(manifests);
       loaded.value = true;
+      failedAt.value = 0;
     } catch (e) {
       applyNodeCatalog([]);
+      loaded.value = false;
+      failedAt.value = Date.now();
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.nodes.error.loadFailed");
     } finally {
       gate.release();

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 {};