@revenexx/studio-integrations 1.0.0 → 1.1.0

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[]>;
 };

package/dist/runtime/composables/useIntegrationsSchedules.js

@@ -1,39 +1,84 @@
 import { computed } from "vue";
+import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
+import { useLoadGate } from "./useLoadGate.js";
+import { IntegrationsApiError } from "../utils/apiError.js";
 import { scheduleTimezone } from "../utils/schedule.js";
 export function useIntegrationsSchedules() {
-  const { all, loading, loadAll } = useIntegrationsTriggers();
-  const entries = computed(
-    () => all.value.filter((t) => t.type === "schedule").map((t) => {
-      const cfg = t.config ?? {};
-      const triggerId = String(t.id);
-      return {
-        id: `${t.workflow_id}:${t.id}`,
-        workflowId: t.workflow_id,
-        workflowName: t.workflowName,
-        triggerId,
-        // Never invented: a trigger without an expression says so on the page.
-        // Standing in `* * * * *` for it would read as "every minute", and with
-        // the expression no longer on screen that guess would be invisible.
-        cron: typeof cfg.cron === "string" && cfg.cron.trim() !== "" ? cfg.cron : null,
-        // The schedule's own zone, or the platform's default where it has none —
-        // from the same helper the trigger settings read, so one schedule cannot
-        // be shown in two zones on two screens.
-        timezone: scheduleTimezone(cfg.timezone),
-        active: t.active,
-        nextRunAt: t.active ? mockNextRun(t.workflow_id, triggerId) : null,
-        lastRunAt: t.active ? mockLastRun(t.workflow_id, triggerId) : null
-      };
-    })
-  );
-  const total = computed(() => entries.value.length);
-  const activeCount = computed(() => entries.value.filter((e) => e.active).length);
-  return { entries, total, activeCount, loading, load: loadAll };
-}
-function mockNextRun(workflowId, triggerId) {
-  const offsetMinutes = (workflowId * 7 + triggerId.length * 3) % 720 + 5;
-  return new Date(Date.now() + offsetMinutes * 6e4).toISOString();
-}
-function mockLastRun(workflowId, triggerId) {
-  const offsetMinutes = (workflowId * 13 + triggerId.length * 11) % 720 + 30;
-  return new Date(Date.now() - offsetMinutes * 6e4).toISOString();
+  const api = useIntegrationsApi();
+  const t = useIntegrationsT();
+  const entries = useState("integrations.schedules", () => []);
+  const loading = useState("integrations.schedules.loading", () => false);
+  const loaded = useState("integrations.schedules.loaded", () => false);
+  const error = useState("integrations.schedules.error", () => null);
+  const meta = useState("integrations.schedules.meta", () => ({
+    total: 0,
+    live_count: 0,
+    timezones: []
+  }));
+  const gate = useLoadGate("integrations.schedules", { loading, loaded });
+  function mapEntry(row) {
+    const block = row.schedule;
+    const firstFiring = block?.next_fire_times?.[0] ?? null;
+    return {
+      id: `${row.workflow_id}:${row.id}`,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name ?? "",
+      triggerId: String(row.id),
+      // Never invented: a trigger without an expression says so on the page.
+      // Standing in `* * * * *` for it would read as "every minute", and with the
+      // expression no longer on screen that guess would be invisible.
+      cron: block?.cron ?? null,
+      // The zone the platform resolved, rather than one guessed here — but the
+      // platform's default put back where it reports none. `timezone` is null on
+      // the wire whenever the expression could not be read AND the schedule
+      // carries no zone of its own (`ScheduleTelemetry::present` falls through to
+      // `configuredTimezone()`), which is exactly the row AC-9 promises exists.
+      //
+      // A blank there is not merely ugly, it is unreachable: `meta.timezones`
+      // contributes the platform default for a schedule carrying none, and the
+      // service's `scopeToTimezone()` matches those rows when the reader narrows
+      // to that default — so a row with no zone at all would show a bare globe
+      // and then vanish from every timezone the filter offers. The same helper
+      // the trigger settings use, so one schedule cannot read two zones
+      // (`utils/schedule.ts`, and the note in `NodeInspector.vue`).
+      timezone: scheduleTimezone(block?.timezone),
+      active: row.active,
+      workflowActive: row.workflow_active,
+      nextRunAt: block?.next_fire_at ?? null,
+      nextRunLocal: firstFiring?.local ?? null,
+      // When the run STARTED, which is nullable on the platform
+      // (`workflow_runs.started_at`): a run the scheduler has created and the
+      // worker has not picked up yet carries a status and no start. So this
+      // being null does not mean "never ran" — `lastRunStatus` is what separates
+      // the two, and the page states the queued run rather than showing the
+      // dash a schedule that has never fired gets (`specs/schedules.md` AC-12).
+      lastRunAt: block?.last_run?.started_at ?? null,
+      /** Non-null exactly when the platform holds a last run at all. */
+      lastRunStatus: block?.last_run?.status ?? null,
+      lastDispatchAt: block?.last_dispatch_at ?? null,
+      holdsFirings: block?.holds_firings ?? false,
+      notFiringReason: block?.not_firing_reason ?? null
+    };
+  }
+  async function load(force = false) {
+    if (!await gate.claim(force)) return entries.value;
+    error.value = null;
+    try {
+      const res = await api.get("/schedules");
+      entries.value = (res?.data ?? []).map(mapEntry);
+      meta.value = res?.meta ?? { total: 0, live_count: 0, timezones: [] };
+      loaded.value = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.schedules.error.loadFailed");
+      loaded.value = false;
+    } finally {
+      gate.release();
+    }
+    return entries.value;
+  }
+  const total = computed(() => meta.value.total);
+  const activeCount = computed(() => meta.value.live_count);
+  const timezonesInUse = computed(() => meta.value.timezones);
+  return { entries, total, activeCount, timezonesInUse, loading, loaded, error, load };
 }

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

@@ -7,8 +7,15 @@ import type { ApiTriggerLite } from './useIntegrationsWorkflows.js';
  * is how the editor's trigger settings work.
  *
  * `loadAll()` does NOT: the workflow list carries each workflow's triggers in full,
- * so the tenant-wide view is derived from that response rather than fetched per
+ * so a tenant-wide view is derived from that response rather than fetched per
  * workflow (PO-236). What it still costs is the workflow list, once.
+ *
+ * Nothing in this module reads `loadAll()` any more. The Schedules page was its
+ * one caller and now reads `GET /schedules`, which is the only source that can
+ * report when a schedule fires next (PO-231). It is kept because these
+ * composables are the module's public, auto-imported surface — a host app may
+ * hold the tenant's triggers this way, and the Webhooks view this was also
+ * written for has never been built.
  */
 export interface ApiTrigger {
     id: number;