@revenexx/studio-integrations 1.0.0 → 1.1.1

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;

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",
@@ -513,6 +520,7 @@
   "integration.nodeConfig.dynamicSchema.resolving": "Felder werden geladen…",
   "integration.nodeConfig.expression.badge.title": "Akzeptiert ${{ … }}-Ausdrücke",
   "integration.nodeConfig.expression.insertTitle": "Ausdruck einfügen",
+  "integration.nodeConfig.expression.insertAria": "Ausdruck einfügen — verfügbare Daten für diese Einstellung",
   "integration.nodeConfig.expression.picker.aria": "Verfügbare Daten für diese Einstellung",
   "integration.nodeConfig.expression.picker.empty": "Nichts entspricht „{query}“.",
   "integration.nodeConfig.expression.picker.filterAria": "Verfügbare Daten filtern",
@@ -622,6 +630,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 +813,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.",
@@ -818,7 +830,7 @@
   "integration.runs.action.back": "Zurück",
   "integration.runs.action.cancel": "Run stoppen",
   "integration.runs.action.resume": "Fortsetzen",
-  "integration.runs.action.retry": "Retry",
+  "integration.runs.action.retry": "Erneut ausführen",
   "integration.runs.action.terminate": "Terminieren",
   "integration.runs.confirm.cancel": "Diesen Run stoppen?",
   "integration.runs.confirm.resume": "Diesen Run fortsetzen?",
@@ -878,9 +890,9 @@
   "integration.runs.list.header.title": "Runs",
   "integration.runs.menu.aria.actions": "Aktionen für Run #{id}",
   "integration.runs.menu.cancel": "Run stoppen",
-  "integration.runs.menu.replay": "Wiederholen",
+  "integration.runs.menu.replay": "Wiedergabe",
   "integration.runs.menu.resume": "Fortsetzen",
-  "integration.runs.menu.retry": "Retry",
+  "integration.runs.menu.retry": "Erneut ausführen",
   "integration.runs.menu.terminate": "Terminieren",
   "integration.runs.menu.viewDetails": "Details anzeigen",
   "integration.runs.notice.requested": "{action} angefordert.",
@@ -948,6 +960,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 +969,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 +985,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.",