@revenexx/studio-integrations 1.0.0 → 1.1.1

package/dist/runtime/i18n/messages/en.json

@@ -71,6 +71,8 @@
   "integration.canvas.node.action.duplicateAria": "Duplicate node",
   "integration.canvas.node.badge.invalidConfig": "Config incomplete — {n} setting still needs fixing: {fields} | Config incomplete — {n} settings still need fixing: {fields}",
   "integration.canvas.node.badge.noBuiltCode": "Version {version} is not ready to use — this step cannot be tested",
+  "integration.canvas.node.badge.repeats": "Repeats — runs once per element of {iterators} | Repeats — runs once per element of each of the {n} loops it sits inside: {iterators}",
+  "integration.canvas.node.badge.loopBody": "Loop — nothing is wired to Item yet, so nothing repeats | Loop — repeats the one step wired to Item, once per element | Loop — repeats the {n} steps wired to Item, once per element",
   "integration.canvas.node.handle.input": "Input",
   "integration.canvas.node.meta.versionTitle": "Version {version}",
   "integration.canvas.node.note.heading": "Note",
@@ -298,12 +300,17 @@
   "integration.deadLetters.panel.title": "Missed runs",
   "integration.deadLetters.reason.fallback": "No reason recorded.",
   "integration.deadLetters.state.empty": "No missed runs. Every trigger firing made it into a run.",
+  "integration.deadLetters.status.discarded": "discarded",
+  "integration.deadLetters.status.pending": "waiting",
+  "integration.deadLetters.status.replayed": "replayed",
+  "integration.deadLetters.status.unknown": "unknown ({status})",
   "integration.deadLetters.tabs.missed.label": "Missed runs",
   "integration.deadLetters.toast.discard.done": "Discarded",
   "integration.deadLetters.toast.discard.error": "Could not discard.",
   "integration.deadLetters.toast.replay.done": "Replayed",
   "integration.deadLetters.toast.replay.error": "Could not replay.",
   "integration.deadLetters.toast.replay.started": "Replayed — started run #{id}",
+  "integration.deadLetters.workflow.fallback": "Workflow #{id}",
   "integration.editor.action.activate.title": "Activate this workflow",
   "integration.editor.action.activate.title.invalid": "Fix {n} node setting before activating | Fix {n} node settings before activating",
   "integration.editor.action.backToWorkflow": "Back to Workflow",
@@ -513,6 +520,7 @@
   "integration.nodeConfig.dynamicSchema.resolving": "Resolving fields…",
   "integration.nodeConfig.expression.badge.title": "Accepts ${{ … }} expressions",
   "integration.nodeConfig.expression.insertTitle": "Insert expression",
+  "integration.nodeConfig.expression.insertAria": "Insert expression — available data for this setting",
   "integration.nodeConfig.expression.picker.aria": "Available data for this setting",
   "integration.nodeConfig.expression.picker.empty": "Nothing matches “{query}”.",
   "integration.nodeConfig.expression.picker.filterAria": "Filter available data",
@@ -622,6 +630,10 @@
   "integration.nodeInspector.notice.versionNotReady.none": "Version {version} of this node is no longer usable, and no version of it is. This step cannot be tested, and the choice lists in its settings stay empty.",
   "integration.nodeInspector.notice.versionNotReady.upgrade": "Version {version} of this node is no longer usable. To keep using this step, it has to be upgraded to version {ready}.",
   "integration.nodeInspector.output.description": "What downstream nodes receive from this one. Declared by the node type; filled with real values once the step has run.",
+  "integration.nodeInspector.output.loopBody.heading": "The loop body",
+  "integration.nodeInspector.output.loopBody.size": "Nothing is wired to Item yet, so this loop repeats nothing. | One step is wired to Item and runs once per element. | {n} steps are wired to Item and each runs once per element.",
+  "integration.nodeInspector.output.loopBody.names": "These repeat: {names}",
+  "integration.nodeInspector.output.loopBody.joined": "One of them is wired after the loop as well, on the Done side — so it repeats with the body rather than running once: {names} | {n} of them are wired after the loop as well, on the Done side — so they repeat with the body rather than running once: {names}",
   "integration.nodeInspector.output.pin.editAction": "Edit pinned sample",
   "integration.nodeInspector.output.pin.editorAria": "Pinned sample output",
   "integration.nodeInspector.output.pin.hint": "A pinned sample stands in for run data while you map downstream fields.",
@@ -948,6 +960,7 @@
   "integration.schedules.cron.weekday.tuesday": "Tuesdays",
   "integration.schedules.cron.weekday.wednesday": "Wednesdays",
   "integration.schedules.cron.weeklyAt": "{days} at {time}",
+  "integration.schedules.error.loadFailed": "Schedules could not be loaded.",
   "integration.schedules.head.title": "Schedules · Integration Studio",
   "integration.schedules.header.description": "Every scheduled trigger across your workflows. Click a row to open the workflow.",
   "integration.schedules.header.title": "Schedules",

package/dist/runtime/pages/integrations/index.vue

@@ -6,38 +6,38 @@ import WorkflowCreateDialog from "../../components/Integrations/WorkflowCreateDi
 import { Pulse as Activity, DangerTriangle as AlertTriangle, ArrowRight, Box as Boxes, ClockCircle as Clock, Database, Layers, AddCircle as Plus, Radio, MagicStick as Sparkles, LinkRound as Webhook, Programming as Workflow } from "#solar-icons";
 import { Badge, Button } from "@revenexx/studio";
 import { servedPaths } from "../../utils/servedPaths";
-import { runStatusLabel, statusClass } from "../../utils/statusStyle";
+import { RUN_STATUS_COLUMN_WIDTH, runStatusClass, runStatusLabel } from "../../utils/statusStyle";
+const LATEST_RUN_COLUMNS = `${RUN_STATUS_COLUMN_WIDTH} minmax(0,1fr) 100px 70px`;
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.dashboard.head.title") });
 const { workflows, activeCount: activeWorkflows, loading: workflowsLoading, load: loadWorkflows } = useIntegrationsWorkflows();
-const { runs, runningCount, failedCount, loading: runsLoading, load: loadRuns } = useIntegrationsRuns();
+const {
+  latestPerWorkflow: latestRunPerWorkflow,
+  runningCount,
+  latestLoading: runsLoading,
+  loadSummary: loadRunSummary,
+  loadLatestPerWorkflow
+} = useIntegrationsRuns();
 const { startingPoints, loading: templatesLoading, load: loadTemplates, ensureDetails } = useIntegrationsTemplates();
 watch(() => startingPoints.value.map((t2) => t2.slug).join(","), () => {
   if (startingPoints.value.length) void ensureDetails(startingPoints.value.map((t2) => t2.slug));
 }, { immediate: true });
 const { activeCount: schedulesActive, load: loadSchedules } = useIntegrationsSchedules();
 const { pendingCount: missedRuns, globalLoading: missedLoading, loadGlobal: loadMissedRuns } = useIntegrationsDeadLetters();
-const kpisLoading = computed(() => workflowsLoading.value && !workflows.value.length || runsLoading.value && !runs.value.length);
-const latestLoading = computed(() => runsLoading.value && !runs.value.length);
+const kpisLoading = computed(() => workflowsLoading.value && !workflows.value.length || runsLoading.value && !latestRunPerWorkflow.value.length);
+const latestLoading = computed(() => runsLoading.value && !latestRunPerWorkflow.value.length);
 const createOpen = ref(false);
 const NuxtLinkComp = resolveComponent("NuxtLink");
 onMounted(() => {
   void loadWorkflows();
-  void loadRuns();
+  void loadRunSummary();
+  void loadLatestPerWorkflow();
   void loadTemplates();
   void loadSchedules();
-  void loadMissedRuns();
-});
-const latestByWorkflow = computed(() => {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const r of runs.value) {
-    if (seen.has(r.workflowId)) continue;
-    seen.add(r.workflowId);
-    out.push(r);
-  }
-  return out;
+  void loadMissedRuns().catch(() => {
+  });
 });
+const latestByWorkflow = computed(() => latestRunPerWorkflow.value);
 const latestPerWorkflow = computed(() => latestByWorkflow.value.slice(0, 10));
 const failedRecent = computed(() => latestByWorkflow.value.filter((r) => r.status === "failed").slice(0, 3));
 function formatRelative(iso) {
@@ -178,9 +178,18 @@ function surfaceCards() {
               v-for="r in latestPerWorkflow"
               :key="r.id"
               :to="{ path: `/integrations/workflows/${r.workflowId}`, query: { run: r.id } }"
-              class="grid grid-cols-[90px_minmax(0,1fr)_100px_70px] items-center gap-2 border-b border-black/[0.04] px-3 py-2 text-sm last:border-b-0 hover:bg-muted/30"
+              class="grid items-center gap-2 border-b border-black/[0.04] px-3 py-2 text-sm last:border-b-0 hover:bg-muted/30"
+              :style="{ gridTemplateColumns: LATEST_RUN_COLUMNS }"
             >
-              <Badge variant="outline" :class="['border text-xs font-medium uppercase', statusClass(r.status)]">
+              <!-- The runs list's own track, not a second guess: this panel was the
+                   narrower of the two at 90px, so three German words ran out of it,
+                   "erfolgreich" included (PO-362). `max-w-full` is the net behind it,
+                   and it clips rather than ellipsing — see the runs list. -->
+              <Badge
+                variant="outline"
+                :title="runStatusLabel(r.status)"
+                :class="['border text-xs font-medium uppercase max-w-full', runStatusClass(r.status)]"
+              >
                 {{ runStatusLabel(r.status) }}
               </Badge>
               <div class="truncate">
@@ -198,7 +207,8 @@ function surfaceCards() {
               <div
                 v-for="n in 6"
                 :key="`sk-run-${n}`"
-                class="grid grid-cols-[90px_minmax(0,1fr)_100px_70px] items-center gap-2 border-b border-black/[0.04] px-3 py-2.5 last:border-b-0"
+                class="grid items-center gap-2 border-b border-black/[0.04] px-3 py-2.5 last:border-b-0"
+                :style="{ gridTemplateColumns: LATEST_RUN_COLUMNS }"
               >
                 <div class="h-5 w-16 rounded bg-black/[0.07] animate-pulse" />
                 <div class="space-y-1.5">

package/dist/runtime/pages/integrations/runs.vue

@@ -4,7 +4,7 @@ import { Badge, Button } from "@revenexx/studio";
 import { toast } from "vue-sonner";
 import RunsTable from "../../components/Integrations/RunsTable.vue";
 import { createPollBudget, SAFETY_POLL_MS } from "../../utils/pollBudget";
-import { statusClass } from "../../utils/statusStyle";
+import { deadLetterStatusClass, deadLetterStatusLabel } from "../../utils/statusStyle";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.runs.list.head.title") });
 const route = useRoute();
@@ -37,7 +37,7 @@ watch([runTick, workflowTick], () => {
 let pollTimer = null;
 onMounted(() => {
   void load(true);
-  void loadGlobal(true);
+  void reloadMissedRuns();
   pollTimer = setInterval(() => {
     if (hasActiveRuns.value && !loading.value && budget.due(delivering.value)) void load(true);
   }, POLL_MS);
@@ -49,31 +49,43 @@ onUnmounted(() => {
   }
 });
 const busyId = ref(null);
+async function reloadMissedRuns() {
+  try {
+    await loadGlobal(true);
+  } catch {
+  }
+}
 async function onReplay(dl) {
   busyId.value = dl.id;
   try {
     const res = await replay(dl.id);
     const newId = res && typeof res === "object" && "id" in res ? String(res.id) : null;
     toast.success(newId ? t("integration.deadLetters.toast.replay.started", { id: newId }) : t("integration.deadLetters.toast.replay.done"));
-    await loadGlobal(true);
-    reload();
   } catch (e) {
     toast.error(e?.message ?? t("integration.deadLetters.toast.replay.error"));
-  } finally {
     busyId.value = null;
+    return;
   }
+  await reloadMissedRuns();
+  reload();
+  busyId.value = null;
 }
 async function onDiscard(dl) {
   busyId.value = dl.id;
   try {
     await discard(dl.id);
     toast.success(t("integration.deadLetters.toast.discard.done"));
-    await loadGlobal(true);
   } catch (e) {
     toast.error(e?.message ?? t("integration.deadLetters.toast.discard.error"));
-  } finally {
     busyId.value = null;
+    return;
   }
+  await reloadMissedRuns();
+  busyId.value = null;
+}
+function workflowNameOf(dl) {
+  const name = dl.workflow_name;
+  return typeof name === "string" && name.trim() !== "" ? name : t("integration.deadLetters.workflow.fallback", { id: dl.workflow_id });
 }
 function fmt(iso) {
   if (!iso) return "\u2014";
@@ -104,7 +116,7 @@ function fmt(iso) {
           <p class="text-sm text-muted-foreground">
             {{ t("integration.deadLetters.list.description") }}
           </p>
-          <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="missedLoading" @click="() => loadGlobal(true)">
+          <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="missedLoading" @click="() => reloadMissedRuns()">
             <Loader2 v-if="missedLoading" :size="12" class="animate-spin" />
             {{ t("integration.common.action.refresh") }}
           </Button>
@@ -130,10 +142,10 @@ function fmt(iso) {
             :key="dl.id"
             class="flex items-start gap-3 px-3 py-2.5"
           >
-            <Badge variant="outline" :class="['border text-xs font-medium uppercase shrink-0 mt-0.5', statusClass(dl.status)]">{{ dl.status }}</Badge>
+            <Badge variant="outline" :class="['border text-xs font-medium uppercase shrink-0 mt-0.5', deadLetterStatusClass(dl.status)]">{{ deadLetterStatusLabel(dl.status) }}</Badge>
             <div class="min-w-0 flex-1">
               <NuxtLink :to="`/integrations/workflows/${dl.workflow_id}`" class="text-sm font-medium truncate transition-colors hover:text-primary">
-                {{ dl.workflowName }}
+                {{ workflowNameOf(dl) }}
               </NuxtLink>
               <div class="text-sm break-words">{{ dl.reason || t("integration.deadLetters.reason.fallback") }}</div>
               <div class="mt-0.5 flex flex-wrap items-center gap-x-3 gap-y-0.5 text-xs text-muted-foreground font-mono">

package/dist/runtime/pages/integrations/schedules.vue

@@ -2,14 +2,23 @@
 import { ClockCircle as Clock, Globus as Globe } from "#solar-icons";
 import { Badge } from "@revenexx/studio";
 import { cadenceRank, describeCron } from "../../utils/schedule";
+import { runStatusLabel } from "../../utils/statusStyle";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.schedules.head.title") });
 const router = useRouter();
-const { entries, activeCount, loading, load } = useIntegrationsSchedules();
+const { entries, activeCount, timezonesInUse, loading, error, load } = useIntegrationsSchedules();
 onMounted(() => {
   void load(true);
 });
-function formatRelative(iso) {
+function inScheduleZone(iso, timezone) {
+  const parts = { month: "short", day: "2-digit", hour: "2-digit", minute: "2-digit" };
+  try {
+    return new Date(iso).toLocaleString(void 0, { ...parts, timeZone: timezone });
+  } catch {
+    return new Date(iso).toLocaleString(void 0, parts);
+  }
+}
+function formatRelative(iso, timezone) {
   if (!iso) return "\u2014";
   const ms = new Date(iso).getTime() - Date.now();
   if (Math.abs(ms) < 6e4) return ms > 0 ? t("integration.schedules.time.inLessThanMinute") : t("integration.common.time.justNow");
@@ -21,7 +30,11 @@ function formatRelative(iso) {
     const hrs = Math.round(Math.abs(ms) / 36e5);
     return ms > 0 ? t("integration.schedules.time.inHours", hrs) : t("integration.common.time.hoursAgo", hrs);
   }
-  return new Date(iso).toLocaleString(void 0, { month: "short", day: "2-digit", hour: "2-digit", minute: "2-digit" });
+  return inScheduleZone(iso, timezone);
+}
+function lastRunText(e) {
+  if (e.lastRunAt) return formatRelative(e.lastRunAt, e.timezone);
+  return e.lastRunStatus ? runStatusLabel(e.lastRunStatus) : "\u2014";
 }
 const filterTabs = computed(() => [
   {
@@ -40,7 +53,10 @@ const filterTabs = computed(() => [
     key: "timezone",
     label: t("integration.schedules.table.column.timezone"),
     getter: (e) => e.timezone,
-    options: [...new Set(entries.value.map((e) => e.timezone))].sort().map((tz) => ({ value: tz, label: tz }))
+    // The zones the platform reports as in use across the tenant, not the ones
+    // visible in the rows: with the list narrowed, deriving them from the rows
+    // would shrink the menu to what the previous choice left standing.
+    options: timezonesInUse.value.map((tz) => ({ value: tz, label: tz }))
   }
 ]);
 const columns = computed(() => [
@@ -76,7 +92,25 @@ const columns = computed(() => [
       </template>
     </PageHeader>
 
+    <!--
+      A refused read says so. Without this the page fell through to the table's
+      own empty text, so a 503 and a tenant with no schedules were one screen —
+      and the message it needed was already written and translated
+      (`specs/schedules.md` AC-13). An alert rather than a bare div, so it is
+      announced and not only visible.
+    -->
+    <div v-if="error" role="alert" class="m-4 rounded-md border border-rose-500/20 bg-rose-500/5 px-3 py-2 text-sm text-rose-700">
+      {{ error }}
+    </div>
+
     <div class="p-4">
+      <!--
+        The empty text answers the error too, so the table cannot go on saying
+        "No schedules yet" underneath a banner explaining that there was no
+        answer to count. Two renderings of one fact rather than two facts: the
+        banner carries the platform's own words, which may be specific, and this
+        is why the list is blank.
+      -->
       <DataTable
         :loading="loading"
         :data="entries"
@@ -85,7 +119,7 @@ const columns = computed(() => [
         :default-sort="{ column: 'nextRun', direction: 'asc' }"
         :search="{ placeholder: t('integration.schedules.search.placeholder') }"
         :filter-tabs="filterTabs"
-        :empty-text="t('integration.schedules.state.empty')"
+        :empty-text="error ? t('integration.schedules.error.loadFailed') : t('integration.schedules.state.empty')"
         @row-click="(e2) => router.push(`/integrations/workflows/${e2.workflowId}`)"
       >
         <template #cell-workflow="{ row: e }">
@@ -143,12 +177,35 @@ const columns = computed(() => [
           semantics in the shared table (PO-233, and a gap in
           `specs/accessibility.md`).
         -->
+        <!--
+          The instant the platform holds, shown as a distance from now, with the
+          moment in the schedule's own zone as its title: "in 6d" answers when,
+          and "2026-08-24T08:30:00+02:00" answers which side of a clock change it
+          falls on. Neither is worked out here — a browser doing summer-time
+          arithmetic that a wrong answer makes worse than no answer is exactly
+          what this replaced.
+        -->
         <template #cell-nextRun="{ row: e }">
-          <span :aria-label="t('integration.schedules.table.column.nextRun')" class="text-sm tabular-nums">{{ formatRelative(e.nextRunAt) }}</span>
+          <span
+            :aria-label="t('integration.schedules.table.column.nextRun')"
+            :title="e.nextRunLocal ?? void 0"
+            class="text-sm tabular-nums"
+          >{{ formatRelative(e.nextRunAt, e.timezone) }}</span>
         </template>
 
+        <!--
+          The last run carries a title too, and it is the instant rather than a
+          zone reading: the platform reports no local form for a run the way it
+          does for a firing, and inventing one here is what this page stopped
+          doing. Without it a run further back than a day was readable to the
+          minute and to no greater precision than the cell's own text.
+        -->
         <template #cell-lastRun="{ row: e }">
-          <span :aria-label="t('integration.schedules.table.column.lastRun')" class="text-sm tabular-nums text-muted-foreground">{{ formatRelative(e.lastRunAt) }}</span>
+          <span
+            :aria-label="t('integration.schedules.table.column.lastRun')"
+            :title="e.lastRunAt ?? void 0"
+            class="text-sm tabular-nums text-muted-foreground"
+          >{{ lastRunText(e) }}</span>
         </template>
 
         <template #cell-status="{ row: e }">

package/dist/runtime/pages/integrations/workflows/[id].vue

@@ -397,6 +397,9 @@ const runsError = ref(null);
 const runsPage = ref(1);
 const runsTotal = ref(0);
 const runsLastPage = ref(1);
+const runsWanted = ref(1);
+let runsSeq = 0;
+let runsLoadingSeq = 0;
 const RUNS_POLL_MS = 3e3;
 const { delivering: realtimeDelivering, runTick, lastRunEvent, buildTick, lastBuildEvent } = useIntegrationsRealtime();
 const runsBudget = createPollBudget({ intervalMs: RUNS_POLL_MS, liveIntervalMs: SAFETY_POLL_MS });
@@ -410,12 +413,14 @@ function stopRunsPoll() {
 function startRunsPoll() {
   stopRunsPoll();
   runsPoll = setInterval(() => {
-    if (runsPage.value === 1 && runsBudget.due(realtimeDelivering.value)) void loadRuns(1, { silent: true });
+    if (!runsLoading.value && runsWanted.value === 1 && runsBudget.due(realtimeDelivering.value)) {
+      void loadRuns(1, { silent: true });
+    }
   }, RUNS_POLL_MS);
 }
 onUnmounted(stopRunsPoll);
 watch(runTick, () => {
-  if (tab.value !== "runs" || runsPage.value !== 1) return;
+  if (tab.value !== "runs" || runsWanted.value !== 1 || runsLoading.value) return;
   const eventWorkflow = workflowIdOf(lastRunEvent.value);
   if (eventWorkflow && eventWorkflow !== String(workflow.value?.id ?? "")) return;
   void loadRuns(1, { silent: true });
@@ -426,10 +431,15 @@ watch(buildTick, () => {
   if (eventWorkflow && eventWorkflow !== String(workflow.value.id)) return;
   void get(workflow.value.id);
 });
-async function loadRuns(page = runsPage.value, opts = {}) {
+async function loadRuns(page = runsWanted.value, opts = {}) {
   if (!workflow.value) return;
+  runsWanted.value = page;
+  const seq = ++runsSeq;
   runsBudget.spend();
-  if (!opts.silent) runsLoading.value = true;
+  if (!opts.silent) {
+    runsLoading.value = true;
+    runsLoadingSeq = seq;
+  }
   runsError.value = null;
   try {
     const res = await loadForWorkflow(workflow.value.id, workflow.value.name, {
@@ -437,19 +447,23 @@ async function loadRuns(page = runsPage.value, opts = {}) {
       page,
       perPage: RUNS_PER_PAGE
     });
+    if (seq !== runsSeq) return;
     wfRuns.value = res.runs;
     runsTotal.value = res.total;
     runsLastPage.value = res.lastPage;
     runsPage.value = res.page;
+    runsWanted.value = res.page;
   } catch (e) {
+    if (seq !== runsSeq) return;
     runsError.value = e.message || t("integration.editor.runs.error.load");
+    runsWanted.value = runsPage.value;
   } finally {
-    if (!opts.silent) runsLoading.value = false;
+    if (!opts.silent && seq === runsLoadingSeq) runsLoading.value = false;
   }
 }
 function goRunsPage(p) {
   const next = Math.min(Math.max(1, p), runsLastPage.value);
-  if (next !== runsPage.value) void loadRuns(next);
+  if (next !== runsWanted.value) void loadRuns(next);
 }
 watch(tab, (t2) => {
   if (t2 === "runs") {
@@ -912,10 +926,10 @@ function formatDateTime(iso) {
         <div v-if="runsLastPage > 1 || runsTotal > wfRuns.length" class="flex items-center justify-between text-sm text-muted-foreground">
           <span class="tabular-nums">{{ t("integration.editor.runs.pagination.page", { page: runsPage, lastPage: runsLastPage }) }} · {{ t("integration.editor.runs.pagination.count", runsTotal) }}</span>
           <div class="flex gap-2">
-            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsPage <= 1 || runsLoading" @click="goRunsPage(runsPage - 1)">
+            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsWanted <= 1 || runsLoading" @click="goRunsPage(runsWanted - 1)">
               {{ t("integration.editor.runs.pagination.newer") }}
             </Button>
-            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsPage >= runsLastPage || runsLoading" @click="goRunsPage(runsPage + 1)">
+            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsWanted >= runsLastPage || runsLoading" @click="goRunsPage(runsWanted + 1)">
               {{ t("integration.editor.runs.pagination.older") }}
             </Button>
           </div>

package/dist/runtime/types/integrations.d.ts

@@ -339,6 +339,18 @@ export interface NodeManifest {
     /** Empty marks a terminal node (PO-201): the run ends there, so the canvas
      *  draws no output handle and no edge may leave it. */
     outputs: NodeManifestOutput[];
+    /**
+     * When true, the node runs whatever is wired to its `item` output once per
+     * element, and its `done` output once afterwards — so the canvas marks that
+     * part as repeating (PO-277, `specs/editor-loop-body.md`).
+     *
+     * **Nothing publishes it yet** (later phase; harmless now, like
+     * `resolveOutputs` above). The worker derives the same fact at bundle-build
+     * time by duck-typing the implementation, and no field of `GET /nodes` carries
+     * it, so until one does the editor falls back to the published iterator's slug
+     * — `ITERATOR_SLUGS` in `data/loopBody.ts`, which this field is here to retire.
+     */
+    iteration?: boolean;
     config?: ConfigField[];
     /** Source package (editor-side enrichment from GET /nodes; not manifest data). */
     __package?: {
@@ -453,6 +465,12 @@ export interface WebhookEntry {
     lastFiredAt: string | null;
     callCount24h: number;
 }
+/**
+ * Why a schedule holds no next firing. Mirrors the conditions under which the
+ * platform's scheduler would never select it, so a paused schedule and one whose
+ * expression nobody can read stop reading the same way.
+ */
+export type ScheduleNotFiringReason = 'trigger_paused' | 'workflow_inactive' | 'workflow_not_ready' | 'no_cron' | 'invalid_cron' | 'unknown_timezone' | 'unsatisfiable';
 export interface ScheduleEntry {
     id: string;
     workflowId: number;
@@ -462,8 +480,29 @@ export interface ScheduleEntry {
     cron: string | null;
     timezone: string;
     active: boolean;
+    /** Whether the workflow the schedule belongs to is active. */
+    workflowActive: boolean;
+    /**
+     * The next firing the platform holds, as an instant, or `null` when it holds
+     * none. Not computed here: a browser working it out from the expression has to
+     * do summer-time arithmetic that a wrong answer makes worse than no answer.
+     */
     nextRunAt: string | null;
+    /** The same moment in the schedule's own zone, offset included. */
+    nextRunLocal: string | null;
+    /** When the schedule last actually ran — `null` when it never has. */
     lastRunAt: string | null;
+    /** How that run ended. */
+    lastRunStatus: string | null;
+    /**
+     * When the scheduler last DECIDED to fire this schedule. Stamped before the
+     * run exists, so it can differ from `lastRunAt` — a firing that was dispatched
+     * and then lost.
+     */
+    lastDispatchAt: string | null;
+    /** False whenever the platform would not fire this schedule. */
+    holdsFirings: boolean;
+    notFiringReason: ScheduleNotFiringReason | null;
 }
 export type TemplateCategory = 'sync' | 'notification' | 'enrichment' | 'fulfilment' | 'reporting' | 'finance' | 'commerce' | 'sales';
 export interface WorkflowTemplate {

package/dist/runtime/utils/statusStyle.d.ts

@@ -23,6 +23,30 @@ export declare function toneClass(tone: StatusTone): string;
  * order. It used to keep its own copy of the list, so a sixth word added here
  * would have been labelled everywhere and silently missing from that menu. */
 export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed", "cancelled", "queued"];
+/**
+ * How wide a list draws its Status column, as a grid track.
+ *
+ * A fixed width, and it has to be one: the shared table gives the header row, every
+ * body row and every skeleton row a grid of their own, so a content-sized track
+ * (`max-content`, `auto`, `fit-content`) is resolved per row and a row holding a
+ * longer word would step out of line with the header and with the rows around it.
+ * The `id` column below says the same thing, and this constant was `minmax(136px,
+ * max-content)` for one commit because that warning was read too late.
+ *
+ * So the number is the promise, and it is a floor rather than a measurement. The
+ * column stood at 100px, which fitted every English word with room to spare and let
+ * the German "fehlgeschlagen" — 126px as a rendered badge on the machine this was
+ * measured on — run out of its cell and under the workflow name beside it (PO-362).
+ * 160px is that word plus a quarter, because the rendered width is not ours to know:
+ * a font that failed to load, a browser zoom or a reader's own minimum font size all
+ * move it, and one of those is why a first attempt at 136 was still reported cut.
+ *
+ * What happens when it is still not enough, and why that is survivable: the badge
+ * carries `max-w-full`, so it is clipped inside its own cell rather than drawn over
+ * the column beside it, and the whole word stays readable in its `title`. Raising
+ * this number is the fix at that point — not making the track elastic.
+ */
+export declare const RUN_STATUS_COLUMN_WIDTH = "160px";
 /**
  * Raw API/Temporal run vocabulary → the cockpit's run-status labels, so a run
  * never reads "completed" in one surface and "succeeded" in another. This IS
@@ -42,4 +66,56 @@ export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed
  * never disagree about which status they mean.
  */
 export declare function normalisedRunStatus(status: string | null | undefined): string;
+/**
+ * The classes a run's status badge is drawn with — the colour half of
+ * {@link runStatusLabel}, and it reads the same word.
+ *
+ * `statusClass` on its own is handed whatever the platform wrote, and the map it
+ * looks in knows the studio's vocabulary rather than Temporal's: `terminated` and
+ * `timed_out` are in no branch of it, so a run the operator terminated was drawn
+ * neutral — the colour a *cancelled* run wears — while its badge said "failed".
+ * Two runs reading the same, in two colours, because the word went through
+ * {@link normalisedRunStatus} and the colour did not.
+ *
+ * So this normalises first. Every surface drawing a run's state calls it rather
+ * than `statusClass`, which stays what it is: one map from a status *word* to a
+ * tone, for the many vocabularies across the cockpit that already speak it.
+ */
+export declare function runStatusClass(status: string | null | undefined): string;
 export declare function runStatusLabel(status: string | null | undefined): string;
+/**
+ * A missed run's state, as a word written for the operator.
+ *
+ * The counterpart to {@link runStatusLabel} for the entry a trigger firing leaves
+ * when its workflow could not run. A state the catalogue does not know is named as
+ * unknown and carries the platform's own value inside that frame, so an operator
+ * can still quote what arrived without the studio claiming the word as one of its
+ * own. Nothing in, nothing out — the same answer `runStatusLabel` gives, for a
+ * column that is never actually empty.
+ *
+ * **The match is exact, unlike `runStatusLabel`'s**, and that is the point rather
+ * than an omission. Everything else that reads this field compares it strictly —
+ * whether an entry offers replay and discard, and whether it counts towards the
+ * firings still waiting — so a value differing by case or a stray space is one the
+ * studio does not act on. Saying "waiting" for it would promise an action that is
+ * not offered; saying it is unknown is what the rest of the studio already
+ * believes.
+ *
+ * The frame carries the value with its surrounding whitespace off and nothing else
+ * touched. Not verbatim, twice over, and neither is worth chasing: the badge is
+ * HTML, which collapses whitespace, and it draws its text uppercased — so an
+ * operator reads the letters that arrived rather than the casing, exactly as they
+ * do for the three states the studio does have words for.
+ */
+export declare function deadLetterStatusLabel(status: string | null | undefined): string;
+/**
+ * The classes a missed run's state badge is drawn with, on every surface that lists
+ * one.
+ *
+ * The colour half of {@link deadLetterStatusLabel}, reading the same map by the same
+ * exact match, so the two cannot disagree about which states the studio knows: a
+ * state named as unknown is drawn as unknown. Tones come from the shared palette,
+ * so this is one more vocabulary mapped into the studio's colours rather than a
+ * second set of colours.
+ */
+export declare function deadLetterStatusClass(status: string | null | undefined): string;

package/dist/runtime/utils/statusStyle.js

@@ -77,6 +77,7 @@ export function toneClass(tone) {
   return TONE_CLASS[tone];
 }
 export const RUN_STATUS_WORDS = ["running", "succeeded", "failed", "cancelled", "queued"];
+export const RUN_STATUS_COLUMN_WIDTH = "160px";
 const RUN_STATUS_WORD_SET = new Set(RUN_STATUS_WORDS);
 export function normalisedRunStatus(status) {
   if (!status) return "";
@@ -89,13 +90,39 @@ export function normalisedRunStatus(status) {
     case "terminated":
     case "timed_out":
       return "failed";
+    // Temporal spells a cancellation the American way and the studio does not, so
+    // without this the *word* half of the promise fails on the surfaces that read
+    // the platform's answer directly: the row said `cancelled`, the record
+    // `canceled`, and in German the record said it in English.
+    case "canceled":
+      return "cancelled";
     default:
       return s;
   }
 }
+export function runStatusClass(status) {
+  return statusClass(normalisedRunStatus(status));
+}
 export function runStatusLabel(status) {
   const normalized = normalisedRunStatus(status);
   if (!normalized) return "";
   if (!RUN_STATUS_WORD_SET.has(normalized)) return normalized;
   return useIntegrationsT()(`integration.runs.status.${normalized}`);
 }
+const MISSED_RUN_STATUS_TONE = /* @__PURE__ */ new Map([
+  ["pending", "warning"],
+  ["replayed", "success"],
+  ["discarded", "neutral"]
+]);
+export function deadLetterStatusLabel(status) {
+  if (!status) return "";
+  const raw = String(status);
+  if (!MISSED_RUN_STATUS_TONE.has(raw)) {
+    return useIntegrationsT()("integration.deadLetters.status.unknown", { status: raw.trim() || raw });
+  }
+  return useIntegrationsT()(`integration.deadLetters.status.${raw}`);
+}
+export function deadLetterStatusClass(status) {
+  const tone = status ? MISSED_RUN_STATUS_TONE.get(String(status)) : void 0;
+  return toneClass(tone ?? "neutral");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {