@revenexx/studio-integrations 1.0.0 → 1.1.0

package/dist/runtime/data/loopBody.d.ts

@@ -0,0 +1,129 @@
+import type { NodeManifest, WorkflowEdge, WorkflowNode } from '../types/integrations.js';
+/**
+ * Which nodes repeat, and which edges are walked once per element (PO-277).
+ *
+ * The iterator draws its two outputs like any other pair of ports, so nothing
+ * on the canvas said that everything hanging off `item` runs once per element
+ * while everything off `done` runs once, afterwards. This module computes the
+ * repeating part; the canvases mark it (`specs/editor-loop-body.md`).
+ *
+ * **The set is the engine's, not a tidier one.** `getLoopBodyNodes`
+ * (`worker/src/dagUtils.ts`) walks forward from the `item` port and follows
+ * EVERY outgoing edge it meets — an error route, a nested iterator's `done`,
+ * an edge the author meant as "and afterwards, do this". There is no stop
+ * condition, because the loop body has no end anywhere in the workflow. The
+ * walk below is that walk, deliberately: a UI that computed the body the
+ * author *meant* would draw nothing on the node that surprises them, which is
+ * the one case this is for.
+ *
+ * **Nesting needs no special case.** The engine narrows an inner iterator's
+ * body to its outer one (`getLoopBodyNodes(inner, edges, loopBodyIds)`), but a
+ * body is closed under reachability and the inner iterator is in the outer
+ * body — so everything reachable from the inner `item` is already in the outer
+ * one, and the narrowing never removes anything. A node inside two loops is
+ * therefore simply a member of both bodies, which is what `depth` counts.
+ */
+/** The iterator's repeating output — the port the body hangs off. */
+export declare const ITEM_PORT = "item";
+/** The iterator's post-loop output — everything off it runs once, at the end. */
+export declare const DONE_PORT = "done";
+/**
+ * Nodes known to iterate while no manifest says so.
+ *
+ * The worker learns which nodes iterate at bundle-build time by duck-typing the
+ * implementation (`builder/src/generateEntry.ts` → `MANIFEST.iterationNodeIds`),
+ * and nothing of that reaches the studio: `GET /nodes` publishes the manifest,
+ * and no field in it says "this node repeats what is wired to it". Until one
+ * does — {@link NodeManifest.iteration}, read first by {@link manifestIterates}
+ * — the editor has to know the published iterator by name. One slug, in one
+ * place, rather than the same string spelled out at every call site.
+ */
+export declare const ITERATOR_SLUGS: readonly string[];
+/**
+ * Whether a manifest describes a node that runs its `item` side per element.
+ *
+ * A manifest that carries the field at all is believed either way — `false`
+ * defeats the slug fallback. Otherwise the day the service starts publishing it,
+ * a published `iteration: false` on the very slug below would be overruled by
+ * this file, which is the one answer the field exists to give.
+ */
+export declare function manifestIterates(manifest: NodeManifest | null | undefined): boolean;
+/** The blob's iterator nodes, in blob order. */
+export declare function iteratorNodeIds(nodes: readonly WorkflowNode[]): string[];
+/** One iterator's body: what repeats, and where it overlaps the `done` side. */
+export interface LoopBody {
+    /** The iterator whose `item` port this body hangs off. */
+    iteratorId: string;
+    /** Every node the engine would run once per element. */
+    nodeIds: Set<string>;
+    /**
+     * Body nodes that are ALSO reachable from `done` — the author wired the body
+     * into the part meant to run after the loop, and the engine repeats it.
+     *
+     * Only the join case is provable. Where `done` is wired nowhere, a node
+     * appended to the body is indistinguishable from a node meant to be in it, so
+     * nothing here reports it (`specs/editor-loop-body.md` § Gaps). The mark on
+     * the card is what covers that case: it says "this repeats" wherever it is
+     * true, whether or not anything can tell it was a mistake.
+     */
+    joinedWithDone: Set<string>;
+}
+/**
+ * One body per iterator id, in the order given.
+ *
+ * Pure on purpose — the catalogue lookup that decides what an iterator IS lives
+ * in {@link iteratorNodeIds}, so the walk can be tested against a graph alone.
+ */
+export declare function computeLoopBodies(iteratorIds: readonly string[], edges: readonly WorkflowEdge[]): LoopBody[];
+/** What one node card has to say about repeating. */
+export interface LoopBodyMark {
+    /**
+     * How many bodies this node is in — 1 for a plain loop, 2 inside a nested
+     * one. The card shows the number from 2 up: "repeats" is the news at depth 1,
+     * "repeats per element of both" is the news above it.
+     */
+    depth: number;
+    /** The iterators, outermost first (a larger body encloses a smaller one). */
+    iteratorIds: string[];
+}
+/**
+ * Marks for a whole canvas: which nodes repeat, and the bodies behind them.
+ *
+ * **Nodes only, deliberately — the connections carry nothing.** Tinting the
+ * body's edges was the obvious other half, and it is the one thing this could
+ * not do: `specs/editor-output-paths.md` AC-2 promises that the lines carry no
+ * meaning and stay neutral, and colour and dashing on an edge are both reserved
+ * for a run that actually happened (`docs/editor-path-colors.md`). A body drawn
+ * in a colour of its own would take that promise back for every workflow with a
+ * loop in it.
+ */
+export interface LoopBodyMarks {
+    byNode: Map<string, LoopBodyMark>;
+    bodies: LoopBody[];
+}
+/**
+ * The whole computation for one blob, ready to hand to a canvas.
+ *
+ * Called by all three canvases (editor, run replay, history preview) on every
+ * sync: the marks depend on the edges, so anything less would let a rewired
+ * body keep an old mark. The cost is one pass over the edges to build the
+ * adjacency map, then two breadth-first walks per iterator over it — and a
+ * workflow with no iterator in it costs one filter over the nodes.
+ */
+export declare function loopBodyMarks(nodes: readonly WorkflowNode[], edges: readonly WorkflowEdge[]): LoopBodyMarks;
+/** What one canvas hands a node card about repetition. */
+export interface NodeLoopData {
+    /** 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;
+}
+/**
+ * One call per canvas sync: node id → what its card says about repeating.
+ *
+ * Names rather than ids, because the card shows the sentence — and the same
+ * three steps a banner uses to name a node ({@link nodeDisplayLabel}), so a
+ * loop the user renamed is named that everywhere. Absent from the map means
+ * nothing to say, which is the common case and costs the card nothing.
+ */
+export declare function nodeLoopData(nodes: readonly WorkflowNode[], edges: readonly WorkflowEdge[]): Map<string, NodeLoopData>;

package/dist/runtime/data/loopBody.js

@@ -0,0 +1,76 @@
+import { nodeDisplayLabel } from "../utils/validationFindings.js";
+import { findManifest } from "./integrationNodeCatalog.js";
+export const ITEM_PORT = "item";
+export const DONE_PORT = "done";
+export const ITERATOR_SLUGS = ["revenexx:iterator"];
+export function manifestIterates(manifest) {
+  if (!manifest) return false;
+  if (manifest.iteration !== void 0) return manifest.iteration;
+  return ITERATOR_SLUGS.includes(manifest.slug);
+}
+export function iteratorNodeIds(nodes) {
+  return nodes.filter((n) => manifestIterates(findManifest(n.nodeSlug, n.nodeVersion))).map((n) => n.id);
+}
+function successors(edges) {
+  const out = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const list = out.get(edge.from.nodeId);
+    if (list) list.push(edge.to.nodeId);
+    else out.set(edge.from.nodeId, [edge.to.nodeId]);
+  }
+  return out;
+}
+function reachableFromPort(fromNodeId, output, edges, next = successors(edges)) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const edge of edges) {
+    if (edge.from.nodeId === fromNodeId && edge.from.output === output) queue.push(edge.to.nodeId);
+  }
+  for (let head = 0; head < queue.length; head++) {
+    const nodeId = queue[head];
+    if (visited.has(nodeId)) continue;
+    visited.add(nodeId);
+    for (const target of next.get(nodeId) ?? []) {
+      if (!visited.has(target)) queue.push(target);
+    }
+  }
+  return visited;
+}
+export function computeLoopBodies(iteratorIds, edges) {
+  const next = successors(edges);
+  return iteratorIds.map((iteratorId) => {
+    const nodeIds = reachableFromPort(iteratorId, ITEM_PORT, edges, next);
+    const afterLoop = reachableFromPort(iteratorId, DONE_PORT, edges, next);
+    const joinedWithDone = new Set([...nodeIds].filter((id) => afterLoop.has(id)));
+    return { iteratorId, nodeIds, joinedWithDone };
+  });
+}
+export function loopBodyMarks(nodes, edges) {
+  const bodies = computeLoopBodies(iteratorNodeIds(nodes), edges);
+  const byNode = /* @__PURE__ */ new Map();
+  const outermostFirst = [...bodies].sort((a, b) => b.nodeIds.size - a.nodeIds.size);
+  for (const body of outermostFirst) {
+    for (const nodeId of body.nodeIds) {
+      const mark = byNode.get(nodeId) ?? { depth: 0, iteratorIds: [] };
+      mark.depth += 1;
+      mark.iteratorIds.push(body.iteratorId);
+      byNode.set(nodeId, mark);
+    }
+  }
+  return { byNode, bodies };
+}
+export function nodeLoopData(nodes, edges) {
+  const marks = loopBodyMarks(nodes, edges);
+  if (!marks.bodies.length) return /* @__PURE__ */ new Map();
+  const labelOf = new Map(nodes.map((n) => [n.id, nodeDisplayLabel(n)]));
+  const out = /* @__PURE__ */ new Map();
+  for (const [nodeId, mark] of marks.byNode) {
+    out.set(nodeId, { inside: mark.iteratorIds.map((id) => labelOf.get(id) ?? id) });
+  }
+  for (const body of marks.bodies) {
+    const entry = out.get(body.iteratorId) ?? {};
+    entry.bodySize = body.nodeIds.size;
+    out.set(body.iteratorId, entry);
+  }
+  return out;
+}

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

@@ -71,6 +71,8 @@
   "integration.canvas.node.action.duplicateAria": "Node duplizieren",
   "integration.canvas.node.badge.invalidConfig": "Konfiguration unvollständig — {n} Einstellung muss noch behoben werden: {fields} | Konfiguration unvollständig — {n} Einstellungen müssen noch behoben werden: {fields}",
   "integration.canvas.node.badge.noBuiltCode": "Version {version} ist nicht einsatzbereit — dieser Schritt lässt sich nicht testen",
+  "integration.canvas.node.badge.repeats": "Wiederholt sich — läuft einmal pro Element von {iterators} | Wiederholt sich — läuft einmal pro Element jeder der {n} Schleifen, in denen er liegt: {iterators}",
+  "integration.canvas.node.badge.loopBody": "Schleife — am Ausgang „Element“ hängt noch nichts, es wiederholt sich also nichts | Schleife — wiederholt den einen Schritt am Ausgang „Element“, einmal pro Element | Schleife — wiederholt die {n} Schritte am Ausgang „Element“, einmal pro Element",
   "integration.canvas.node.handle.input": "Eingang",
   "integration.canvas.node.meta.versionTitle": "Version {version}",
   "integration.canvas.node.note.heading": "Notiz",
@@ -259,7 +261,7 @@
   "integration.dashboard.action.newWorkflow": "Workflow anlegen",
   "integration.dashboard.attention.failed": "Fehlgeschlagen.",
   "integration.dashboard.attention.healthy": "Alle Workflows in Ordnung.",
-  "integration.dashboard.attention.missedRuns": "{n} verpasste Ausführung | {n} verpasste Ausführungen",
+  "integration.dashboard.attention.missedRuns": "{n} verpasster Run | {n} verpasste Runs",
   "integration.dashboard.attention.missedRuns.hint": "Trigger haben ausgelöst, während ihr Workflow nicht laufen konnte — prüfen und erneut ausführen.",
   "integration.dashboard.attention.title": "Erfordert Aufmerksamkeit",
   "integration.dashboard.head.title": "Dashboard · Integration Studio",
@@ -268,14 +270,14 @@
   "integration.dashboard.kpi.activeWorkflows.label": "Aktive Workflows",
   "integration.dashboard.kpi.activeWorkflows.sub": "{n} pausiert oder Entwurf | {n} pausiert oder Entwürfe",
   "integration.dashboard.kpi.aria.group": "Kennzahlen",
-  "integration.dashboard.kpi.missedRuns.label": "Verpasste Ausführungen",
-  "integration.dashboard.kpi.missedRuns.sub": "Trigger-Auslösungen ohne Ausführung",
+  "integration.dashboard.kpi.missedRuns.label": "Verpasste Runs",
+  "integration.dashboard.kpi.missedRuns.sub": "Trigger-Auslösungen ohne Run",
   "integration.dashboard.kpi.runningNow.label": "Läuft gerade",
-  "integration.dashboard.kpi.runningNow.sub": "laufende Ausführungen",
+  "integration.dashboard.kpi.runningNow.sub": "laufende Runs",
   "integration.dashboard.kpi.scheduled.label": "Geplant",
   "integration.dashboard.kpi.scheduled.sub": "aktive Zeitplan-Trigger",
-  "integration.dashboard.runs.empty": "Noch keine Ausführungen.",
-  "integration.dashboard.runs.title": "Letzte Ausführungen",
+  "integration.dashboard.runs.empty": "Noch keine Runs.",
+  "integration.dashboard.runs.title": "Letzte Runs",
   "integration.dashboard.surface.events.hint": "Live-Events der Plattform, die Workflows abonnieren.",
   "integration.dashboard.surface.events.label": "Event-Stream",
   "integration.dashboard.surface.io.hint": "Profile, die Katalog- und Entitätsdaten hinein- und hinausbewegen.",
@@ -298,12 +300,17 @@
   "integration.deadLetters.panel.title": "Verpasste Runs",
   "integration.deadLetters.reason.fallback": "Kein Grund erfasst.",
   "integration.deadLetters.state.empty": "Keine verpassten Runs. Jeder Trigger hat einen Run ausgelöst.",
+  "integration.deadLetters.status.discarded": "verworfen",
+  "integration.deadLetters.status.pending": "wartet",
+  "integration.deadLetters.status.replayed": "wiederholt",
+  "integration.deadLetters.status.unknown": "unbekannt ({status})",
   "integration.deadLetters.tabs.missed.label": "Verpasste Runs",
   "integration.deadLetters.toast.discard.done": "Verworfen",
   "integration.deadLetters.toast.discard.error": "Verwerfen fehlgeschlagen.",
   "integration.deadLetters.toast.replay.done": "Wiederholt",
   "integration.deadLetters.toast.replay.error": "Wiederholen fehlgeschlagen.",
   "integration.deadLetters.toast.replay.started": "Wiederholt — Run #{id} gestartet",
+  "integration.deadLetters.workflow.fallback": "Workflow #{id}",
   "integration.editor.action.activate.title": "Workflow aktivieren",
   "integration.editor.action.activate.title.invalid": "{n} Node-Einstellung vor der Aktivierung beheben | {n} Node-Einstellungen vor der Aktivierung beheben",
   "integration.editor.action.backToWorkflow": "Zurück zum Workflow",
@@ -326,12 +333,12 @@
   "integration.editor.breadcrumb.workflows": "Workflows",
   "integration.editor.build.chip.building": "Build wird erstellt…",
   "integration.editor.build.chip.queued": "Build in Warteschlange…",
-  "integration.editor.build.notice.building": "Der Workflow-Build läuft noch — Ausführungen sind erst möglich, wenn er fertig ist.",
+  "integration.editor.build.notice.building": "Der Workflow-Build läuft noch — Runs sind erst möglich, wenn er fertig ist.",
   "integration.editor.build.notice.failed": "Der Workflow-Build ist fehlgeschlagen. Speichern Sie den Workflow erneut, um den Build neu zu starten.",
   "integration.editor.build.notice.failedWithError": "Der Workflow-Build ist fehlgeschlagen: {error} Speichern Sie den Workflow erneut, um den Build neu zu starten.",
-  "integration.editor.build.notice.pending": "Der Build des Workflows ist in der Warteschlange — Ausführungen sind erst möglich, wenn er fertig ist.",
-  "integration.editor.build.toast.failed": "Der Workflow-Build ist fehlgeschlagen — die Ausführung wurde nicht gestartet.",
-  "integration.editor.build.toast.timeout": "Der Build dauert ungewöhnlich lange — versuchen Sie die Ausführung erneut, sobald er bereit ist.",
+  "integration.editor.build.notice.pending": "Der Build des Workflows ist in der Warteschlange — Runs sind erst möglich, wenn er fertig ist.",
+  "integration.editor.build.toast.failed": "Der Workflow-Build ist fehlgeschlagen — der Run wurde nicht gestartet.",
+  "integration.editor.build.toast.timeout": "Der Build dauert ungewöhnlich lange — versuchen Sie den Run erneut, sobald er bereit ist.",
   "integration.editor.build.tooltip.failed": "Der Workflow-Build ist fehlgeschlagen.",
   "integration.editor.clipboard.error.empty": "Die Zwischenablage enthält keine Nodes.",
   "integration.editor.clipboard.error.read": "Zwischenablage konnte nicht gelesen werden.",
@@ -348,13 +355,13 @@
   "integration.editor.emptyState.hint": "Ziehen Sie einen Trigger und eine Aktion aus dem Panel links.",
   "integration.editor.emptyState.title": "Leere Arbeitsfläche",
   "integration.editor.event.toast.noneReceived": "Noch kein {topic}-Event empfangen.",
-  "integration.editor.executionMode.async.hint": "Ausführungen werden immer in die Warteschlange gestellt; der Trigger antwortet sofort.",
+  "integration.editor.executionMode.async.hint": "Runs werden immer in die Warteschlange gestellt; der Trigger antwortet sofort.",
   "integration.editor.executionMode.async.label": "Nur asynchron",
   "integration.editor.executionMode.async.short": "Asynchron",
-  "integration.editor.executionMode.callerDecides.hint": "Der Aufrufer entscheidet pro Ausführung zwischen synchron und asynchron.",
+  "integration.editor.executionMode.callerDecides.hint": "Der Aufrufer entscheidet pro Run zwischen synchron und asynchron.",
   "integration.editor.executionMode.callerDecides.label": "Aufrufer entscheidet",
   "integration.editor.executionMode.error.generic": "Der Ausführungsmodus konnte nicht aktualisiert werden.",
-  "integration.editor.executionMode.sync.hint": "Ausführungen blockieren, bis sie abgeschlossen sind, und liefern das Ergebnis direkt zurück.",
+  "integration.editor.executionMode.sync.hint": "Runs blockieren, bis sie abgeschlossen sind, und liefern das Ergebnis direkt zurück.",
   "integration.editor.executionMode.sync.label": "Nur synchron",
   "integration.editor.executionMode.sync.short": "Synchron",
   "integration.editor.group.defaultLabel": "Gruppe {n}",
@@ -387,15 +394,15 @@
   "integration.editor.quickConnect.toast": "Node auswählen — er wird dort platziert und ist bereits verbunden.",
   "integration.editor.reauth.action.fix": "in den Zugangsdaten beheben",
   "integration.editor.reauth.banner": "{n} hier verwendeter Zugangsdaten-Eintrag muss neu verbunden werden | {n} hier verwendete Zugangsdaten-Einträge müssen neu verbunden werden",
-  "integration.editor.retry.error.generic": "Die Ausführung konnte nicht wiederholt werden.",
+  "integration.editor.retry.error.generic": "Der Run konnte nicht wiederholt werden.",
   "integration.editor.retry.toast.requested": "Wiederholung angefordert",
   "integration.editor.retry.toast.started": "Run #{id} gestartet",
   "integration.editor.run.button": "Run",
-  "integration.editor.run.error.couldNotStart": "Die Ausführung konnte nicht gestartet werden.",
-  "integration.editor.run.error.loadOpenRun": "Die Ausführung konnte nicht geladen werden.",
+  "integration.editor.run.error.couldNotStart": "Der Run konnte nicht gestartet werden.",
+  "integration.editor.run.error.loadOpenRun": "Der Run konnte nicht geladen werden.",
   "integration.editor.run.error.refusedForSettings": "Kann nicht ausgeführt werden — {summary}{where}",
-  "integration.editor.run.error.syncFailed": "Synchrone Ausführung fehlgeschlagen",
-  "integration.editor.run.error.syncTimeout": "Synchrone Ausführung: Zeitüberschreitung",
+  "integration.editor.run.error.syncFailed": "Synchroner Run fehlgeschlagen",
+  "integration.editor.run.error.syncTimeout": "Synchroner Run: Zeitüberschreitung",
   "integration.editor.run.loading": "Run wird geladen…",
   "integration.editor.run.waitingForBuild": "Warten auf Build…",
   "integration.editor.runPayload.action.latestEvent": "Letztes reales Event",
@@ -404,25 +411,25 @@
   "integration.editor.runPayload.action.sampleEvent": "Beispiel-Event",
   "integration.editor.runPayload.action.sampleEvent.titleAvailable": "Beispiel-Payload aus dem Katalog einfügen",
   "integration.editor.runPayload.action.sampleEvent.titleUnavailable": "Der Event-Katalog enthält kein Beispiel für dieses Topic.",
-  "integration.editor.runPayload.dialog.description": "Startet eine manuelle Ausführung mit diesem Trigger-Payload. Das Ergebnis erscheint im Tab Runs.",
+  "integration.editor.runPayload.dialog.description": "Startet einen manuellen Run mit diesem Trigger-Payload. Das Ergebnis erscheint im Tab Runs.",
   "integration.editor.runPayload.dialog.title": "Mit Payload ausführen",
   "integration.editor.runPayload.prefill.label": "Vorbelegen mit",
   "integration.editor.runView.details": "Details",
   "integration.editor.runView.replay": "Replay",
   "integration.editor.runView.timeline": "Zeitleiste",
-  "integration.editor.runs.empty": "Noch keine Ausführungen — im Editor auf Run klicken.",
-  "integration.editor.runs.error.load": "Ausführungen konnten nicht geladen werden.",
-  "integration.editor.runs.pagination.count": "{n} Ausführung | {n} Ausführungen",
+  "integration.editor.runs.empty": "Noch keine Runs — im Editor auf Run klicken.",
+  "integration.editor.runs.error.load": "Runs konnten nicht geladen werden.",
+  "integration.editor.runs.pagination.count": "{n} Run | {n} Runs",
   "integration.editor.runs.pagination.newer": "← Neuer",
   "integration.editor.runs.pagination.older": "Älter →",
   "integration.editor.runs.pagination.page": "Seite {page} / {lastPage}",
   "integration.editor.save.error.generic": "Speichern fehlgeschlagen.",
-  "integration.editor.splice.error.terminal": "{name} beendet die Ausführung und kann nicht in eine Verbindung eingefügt werden.",
+  "integration.editor.splice.error.terminal": "{name} beendet den Run und kann nicht in eine Verbindung eingefügt werden.",
   "integration.editor.splice.toast": "Node aus der Palette auswählen — er wird in die Verbindung eingefügt.",
   "integration.editor.state.loading": "Wird geladen…",
   "integration.editor.status.unsavedChanges": "Nicht gespeicherte Änderungen",
   "integration.editor.sticky.starterContent": "## Ich bin eine Notiz\n**Doppelklicken**, um mich zu bearbeiten. **Fett**, *kursiv*, `Code`, [Links](https://revenexx.com) und\n- Listen funktionieren",
-  "integration.editor.tab.deadLetters": "Verpasste Ausführungen",
+  "integration.editor.tab.deadLetters": "Verpasste Runs",
   "integration.editor.tab.editor": "Editor",
   "integration.editor.tab.history": "Verlauf",
   "integration.editor.tab.runs": "Runs",
@@ -435,7 +442,7 @@
   "integration.editor.tool.fitView.tooltip": "Ansicht einpassen",
   "integration.editor.tool.hand": "Hand (Verschieben)",
   "integration.editor.tool.run.tooltip": "Workflow ausführen",
-  "integration.editor.tool.run.tooltipWaiting": "Der Build läuft noch — die Ausführung startet, sobald er bereit ist",
+  "integration.editor.tool.run.tooltipWaiting": "Der Build läuft noch — der Run startet, sobald er bereit ist",
   "integration.editor.tool.select": "Auswählen",
   "integration.editor.tool.settings.label": "Einstellungen",
   "integration.editor.tool.settings.tooltip": "Workflow-Einstellungen",
@@ -622,6 +629,10 @@
   "integration.nodeInspector.notice.versionNotReady.none": "Version {version} dieses Nodes ist nicht mehr einsatzbereit, und es liegt keine einsatzbereite Version vor. Dieser Schritt lässt sich nicht testen, und Auswahllisten in seinen Einstellungen bleiben leer.",
   "integration.nodeInspector.notice.versionNotReady.upgrade": "Version {version} dieses Nodes ist nicht mehr einsatzbereit. Um den Node weiter zu verwenden, ist ein Upgrade auf Version {ready} notwendig.",
   "integration.nodeInspector.output.description": "Was nachgelagerte Nodes von diesem erhalten. Deklariert vom Node-Typ; wird mit echten Werten gefüllt, sobald der Schritt gelaufen ist.",
+  "integration.nodeInspector.output.loopBody.heading": "Der Schleifenkörper",
+  "integration.nodeInspector.output.loopBody.size": "Am Ausgang „Element“ hängt noch nichts, diese Schleife wiederholt also nichts. | Ein Schritt hängt am Ausgang „Element“ und läuft einmal pro Element. | {n} Schritte hängen am Ausgang „Element“ und laufen jeder einmal pro Element.",
+  "integration.nodeInspector.output.loopBody.names": "Diese wiederholen sich: {names}",
+  "integration.nodeInspector.output.loopBody.joined": "Einer davon hängt zugleich hinter der Schleife, am Ausgang „Fertig“ — er wiederholt sich also mit dem Schleifenkörper, statt einmal zu laufen: {names} | {n} davon hängen zugleich hinter der Schleife, am Ausgang „Fertig“ — sie wiederholen sich also mit dem Schleifenkörper, statt einmal zu laufen: {names}",
   "integration.nodeInspector.output.pin.editAction": "Angeheftetes Beispiel bearbeiten",
   "integration.nodeInspector.output.pin.editorAria": "Angeheftete Beispielausgabe",
   "integration.nodeInspector.output.pin.hint": "Ein angeheftetes Beispiel steht anstelle von Run-Daten, während Sie nachgelagerte Felder zuordnen.",
@@ -801,8 +812,8 @@
   "integration.replay.debug.stepCounter": "Schritt {current} / {total}",
   "integration.replay.debug.titleFallback": "Debug",
   "integration.replay.error.loadStepsFailed": "Die Run-Schritte konnten nicht geladen werden.",
-  "integration.replay.runsList.description": "Klicken Sie sich durch die Ausführungen, um sie auf dem Canvas abzuspielen.",
-  "integration.replay.runsList.empty": "Noch keine Runs — lösen Sie einen über die Schaltfläche „Ausführen“ im Editor aus.",
+  "integration.replay.runsList.description": "Klicken Sie sich durch die Runs, um sie auf dem Canvas abzuspielen.",
+  "integration.replay.runsList.empty": "Noch keine Runs — im Editor auf Run klicken.",
   "integration.replay.runsList.heading": "Runs",
   "integration.replay.runsList.loadMore": "Ältere Runs laden",
   "integration.replay.state.noSteps": "Für diesen Run wurden keine Schritte aufgezeichnet.",
@@ -948,6 +959,7 @@
   "integration.schedules.cron.weekday.tuesday": "Dienstags",
   "integration.schedules.cron.weekday.wednesday": "Mittwochs",
   "integration.schedules.cron.weeklyAt": "{days} um {time}",
+  "integration.schedules.error.loadFailed": "Zeitpläne konnten nicht geladen werden.",
   "integration.schedules.head.title": "Zeitpläne · Integration Studio",
   "integration.schedules.header.description": "Jeder Zeitplan-Trigger aus allen Ihren Workflows. Klicken Sie auf eine Zeile, um den Workflow zu öffnen.",
   "integration.schedules.header.title": "Zeitpläne",
@@ -956,8 +968,8 @@
   "integration.schedules.state.empty": "Noch keine Zeitpläne. Fügen Sie einem Workflow einen Zeitplan-Trigger hinzu.",
   "integration.schedules.status.live": "aktiv",
   "integration.schedules.status.paused": "pausiert",
-  "integration.schedules.table.column.lastRun": "Letzte Ausführung",
-  "integration.schedules.table.column.nextRun": "Nächste Ausführung",
+  "integration.schedules.table.column.lastRun": "Letzter Run",
+  "integration.schedules.table.column.nextRun": "Nächster Run",
   "integration.schedules.table.column.status": "Status",
   "integration.schedules.table.column.timezone": "Zeitzone",
   "integration.schedules.table.column.when": "Wann",
@@ -972,7 +984,7 @@
   "integration.secrets.cell.updated.aria": "Aktualisiert für {key}: {date}",
   "integration.secrets.dialog.create.description": "Der Wert wird nach dem Speichern mit AES-256-GCM verschlüsselt und nie wieder ausgegeben. Sie können ihn später überschreiben, aber um ihn zu lesen, müssen Sie ihn bereits kennen.",
   "integration.secrets.dialog.create.title": "Secret anlegen",
-  "integration.secrets.dialog.delete.body": "wird endgültig entfernt. Workflows, die darauf verweisen, funktionieren beim nächsten Lauf nicht mehr.",
+  "integration.secrets.dialog.delete.body": "wird endgültig entfernt. Workflows, die darauf verweisen, funktionieren beim nächsten Run nicht mehr.",
   "integration.secrets.dialog.delete.title": "Secret löschen?",
   "integration.secrets.error.invalidKey": "Der Schlüssel muss dem Muster ^[A-Z0-9_]+$ entsprechen.",
   "integration.secrets.error.loadFailed": "Secrets konnten nicht geladen werden.",

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",
@@ -622,6 +629,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 +959,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,37 @@ 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 { runStatusClass, runStatusLabel } from "../../utils/statusStyle";
 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) {
@@ -180,7 +179,7 @@ function surfaceCards() {
               :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"
             >
-              <Badge variant="outline" :class="['border text-xs font-medium uppercase', statusClass(r.status)]">
+              <Badge variant="outline" :class="['border text-xs font-medium uppercase', runStatusClass(r.status)]">
                 {{ runStatusLabel(r.status) }}
               </Badge>
               <div class="truncate">

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">