@revenexx/studio-integrations 2.8.1 → 2.9.0

package/dist/runtime/data/graphShapes.js

@@ -0,0 +1,359 @@
+const PRECEDENCE = ["splitter-bypassed", "merger-across-splitters", "undecomposable-shape"];
+const ROOT = "\0root";
+function compare(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  const left = Array.from(a);
+  const right = Array.from(b);
+  for (let i = 0; i < left.length && i < right.length; i++) {
+    const difference = left[i].codePointAt(0) - right[i].codePointAt(0);
+    if (difference !== 0) {
+      return difference < 0 ? -1 : 1;
+    }
+  }
+  return left.length < right.length ? -1 : 1;
+}
+function compareLists(a, b) {
+  for (let i = 0; i < a.length && i < b.length; i++) {
+    const difference = compare(a[i], b[i]);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return a.length - b.length;
+}
+function comparePorts(a, b) {
+  return compare(a.nodeId, b.nodeId) || compare(a.port, b.port);
+}
+function compareOptionalPorts(a, b) {
+  return a && b ? comparePorts(a, b) : a ? -1 : b ? 1 : 0;
+}
+function sorted(values) {
+  return [...values].sort(compare);
+}
+const inputKey = (nodeId, input) => `${nodeId}\0${input}`;
+const crossingKey = (c) => c ? [c.from, c.port, c.to, c.input].join("\0") : "";
+export function analyzeGraphShapes(blob, opts) {
+  const nodeIds = new Set(blob.nodes.map((n) => n.id));
+  const iterators = new Set(opts.iterators.filter((id) => nodeIds.has(id)));
+  const terminals = new Set(opts.terminals ?? []);
+  const connections = [];
+  blob.edges.forEach((edge, index) => {
+    if (nodeIds.has(edge.to.nodeId)) {
+      connections.push({
+        index,
+        from: edge.from.nodeId,
+        port: edge.from.output,
+        to: edge.to.nodeId,
+        input: edge.to.input ?? "in"
+      });
+    }
+  });
+  const handles = sorted(new Set(connections.filter((c) => !nodeIds.has(c.from)).map((c) => c.from)));
+  const fed = new Set(connections.map((c) => c.to));
+  const origins = [...handles, ...sorted([...nodeIds].filter((id) => !fed.has(id)))];
+  for (const origin of origins) {
+    connections.push({ index: -1, from: ROOT, port: origin, to: origin, input: "in" });
+  }
+  const vertices = [ROOT, ...handles, ...sorted(nodeIds)];
+  const outgoing = new Map(vertices.map((v) => [v, []]));
+  const incoming = new Map(vertices.map((v) => [v, []]));
+  for (const c of connections) {
+    outgoing.get(c.from).push(c);
+    incoming.get(c.to).push(c);
+  }
+  const descendants = /* @__PURE__ */ new Map();
+  for (const v of vertices) {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = outgoing.get(v).map((c) => c.to);
+    while (queue.length > 0) {
+      const next = queue.shift();
+      if (!seen.has(next)) {
+        seen.add(next);
+        queue.push(...outgoing.get(next).map((c) => c.to));
+      }
+    }
+    descendants.set(v, seen);
+  }
+  const reaches = (c, v) => c.to === v || descendants.get(c.to).has(v);
+  const onCycle = sorted([...nodeIds].filter((id) => descendants.get(id).has(id)));
+  if (onCycle.length > 0) {
+    return withHelpers(
+      {
+        splitters: [],
+        mergers: [],
+        converging: [],
+        virtualMergers: [],
+        loopBodies: {},
+        violations: onCycle.map((nodeId) => ({ rule: "cycle", nodeId }))
+      },
+      () => null,
+      () => false
+    );
+  }
+  const order = [];
+  const inDegree = new Map(vertices.map((v) => [v, incoming.get(v).length]));
+  const ready = vertices.filter((v) => inDegree.get(v) === 0);
+  while (ready.length > 0) {
+    const v = ready.shift();
+    order.push(v);
+    for (const c of outgoing.get(v)) {
+      inDegree.set(c.to, inDegree.get(c.to) - 1);
+      if (inDegree.get(c.to) === 0) {
+        ready.push(c.to);
+      }
+    }
+  }
+  const dominators = /* @__PURE__ */ new Map();
+  for (const v of order) {
+    const [first, ...rest] = incoming.get(v).map((c) => dominators.get(c.from));
+    const common = [...first ?? []].filter((d) => rest.every((ofPred) => ofPred.has(d)));
+    dominators.set(v, /* @__PURE__ */ new Set([...common, v]));
+  }
+  const violations = [];
+  const splitters = [];
+  for (const v of vertices.slice(1)) {
+    const perPort = /* @__PURE__ */ new Map();
+    for (const c of outgoing.get(v)) {
+      perPort.set(c.port, (perPort.get(c.port) ?? 0) + 1);
+    }
+    for (const [port, count] of perPort) {
+      if (count > 1) {
+        splitters.push({ nodeId: v, port });
+      }
+    }
+  }
+  splitters.sort(comparePorts);
+  const bodies = /* @__PURE__ */ new Map();
+  for (const it of sorted(iterators)) {
+    const body = /* @__PURE__ */ new Set();
+    for (const c of outgoing.get(it)) {
+      if (c.port === "item") {
+        body.add(c.to);
+        descendants.get(c.to).forEach((d) => body.add(d));
+      }
+    }
+    bodies.set(it, body);
+  }
+  const crossed = /* @__PURE__ */ new Set();
+  const loopBodies = {};
+  for (const [it, body] of bodies) {
+    for (const c of connections) {
+      if (body.has(c.to) && !body.has(c.from) && !(c.from === it && c.port === "item")) {
+        violations.push({ rule: "loop-boundary", nodeId: c.to, edgeIndex: c.index });
+        crossed.add(inputKey(c.to, c.input));
+      }
+    }
+    const nested = /* @__PURE__ */ new Set();
+    for (const inner of body) {
+      bodies.get(inner)?.forEach((n) => nested.add(n));
+    }
+    const ownLevel = [...body].filter((n) => !nested.has(n) && !terminals.has(n));
+    const ends = sorted(
+      ownLevel.filter(
+        (n) => !outgoing.get(n).some((c) => ownLevel.includes(c.to) && !(iterators.has(n) && c.port === "item"))
+      )
+    );
+    if (body.size > 0 && ends.length !== 1) {
+      violations.push({ rule: "loop-end-not-unique", nodeId: it });
+    }
+    loopBodies[it] = ends.length === 1 ? { members: sorted(body), endNode: ends[0] } : { members: sorted(body) };
+  }
+  const nearestCommonDominator = (sources) => {
+    let common = [...dominators.get(sources[0])];
+    for (const s of sources.slice(1)) {
+      const ofSource = dominators.get(s);
+      common = common.filter((d) => ofSource.has(d));
+    }
+    return common.reduce((best, d) => dominators.get(d).size > dominators.get(best).size ? d : best);
+  };
+  const bypass = (branches) => {
+    const candidates = splitters.filter(({ nodeId, port }) => {
+      const onPort = outgoing.get(nodeId).filter((c) => c.port === port);
+      return branches.every((b) => onPort.some((c) => c === b || reaches(c, b.from)));
+    }).sort((a, b) => dominators.get(b.nodeId).size - dominators.get(a.nodeId).size || comparePorts(a, b));
+    for (const splitter of candidates) {
+      const around = sorted(branches.filter((b) => !dominators.get(b.from).has(splitter.nodeId)).map((b) => b.from));
+      if (around.length > 0) {
+        return { rule: "splitter-bypassed", splitter, branch: around[0] };
+      }
+    }
+    return { rule: "splitter-bypassed" };
+  };
+  const crossing = (n, port, target) => {
+    const reached = outgoing.get(n).filter((c) => c.port === port).map((c) => /* @__PURE__ */ new Set([c.to, ...descendants.get(c.to)]));
+    return connections.filter(
+      (c) => c.index >= 0 && c.to !== target && descendants.get(c.to).has(target) && reached.some((from, i) => from.has(c.from) && reached.some((into, j) => j !== i && into.has(c.to) && !into.has(c.from)))
+    ).sort((a, b) => compare(a.from, b.from) || compare(a.port, b.port) || compare(a.to, b.to) || compare(a.input, b.input))[0];
+  };
+  const decompose = (branches) => {
+    if (branches.length === 1) {
+      return { level: { kind: "leaf", connection: branches[0] } };
+    }
+    const n = nearestCommonDominator(branches.map((b) => b.from));
+    const via = branches.map((b) => outgoing.get(n).filter((c) => c === b || reaches(c, b.from)));
+    const portsOf = (members) => new Set(members.flatMap((i) => via[i].map((c) => c.port)));
+    const parent = branches.map((_, i) => i);
+    const find = (i) => parent[i] === i ? i : parent[i] = find(parent[i]);
+    for (let i = 0; i < branches.length; i++) {
+      for (let j = i + 1; j < branches.length; j++) {
+        if (via[i].some((c) => via[j].includes(c))) {
+          parent[find(j)] = find(i);
+        }
+      }
+    }
+    const groups = /* @__PURE__ */ new Map();
+    branches.forEach((_, i) => {
+      const root = find(i);
+      groups.set(root, [...groups.get(root) ?? [], i]);
+    });
+    if (groups.size === 1) {
+      const ports = portsOf(branches.map((_, i) => i));
+      if (ports.size > 1) {
+        return { problems: [bypass(branches)] };
+      }
+      const [port] = [...ports];
+      const crossed2 = crossing(n, port, branches[0].to);
+      return { problems: [{ rule: "merger-across-splitters", ...crossed2 ? { crossing: crossed2 } : {} }] };
+    }
+    const problems = [];
+    const byPort = /* @__PURE__ */ new Map();
+    for (const members of groups.values()) {
+      const ports = portsOf(members);
+      if (ports.size > 1) {
+        problems.push({ rule: "undecomposable-shape" });
+      }
+      const part = decompose(members.map((i) => branches[i]));
+      if ("problems" in part) {
+        problems.push(...part.problems);
+      } else if (ports.size === 1) {
+        const [port] = ports;
+        byPort.set(port, [...byPort.get(port) ?? [], part.level]);
+      }
+    }
+    if (problems.length > 0) {
+      return { problems };
+    }
+    if (byPort.size === 1) {
+      const [[port, parts2]] = byPort;
+      return { level: { kind: "and", splitter: { nodeId: n, port }, parts: parts2 } };
+    }
+    const parts = sorted(byPort.keys()).map((port) => {
+      const onPort = byPort.get(port);
+      return onPort.length === 1 ? onPort[0] : { kind: "and", splitter: { nodeId: n, port }, parts: onPort };
+    });
+    return { level: { kind: "or", parts } };
+  };
+  const leaves = (level) => level.kind === "leaf" ? [level.connection.from] : level.parts.flatMap(leaves);
+  const mergers = [];
+  const mergerByInput = /* @__PURE__ */ new Map();
+  const converging = /* @__PURE__ */ new Set();
+  const virtualMergers = [];
+  const inputsOf = (nodeId) => sorted(new Set((incoming.get(nodeId) ?? []).filter((c) => c.index >= 0).map((c) => c.input)));
+  for (const nodeId of sorted(nodeIds)) {
+    const inputs = inputsOf(nodeId);
+    const named = (input) => inputs.length > 1 ? { inputName: input } : {};
+    for (const input of inputs) {
+      const branches = incoming.get(nodeId).filter((c) => c.index >= 0 && c.input === input);
+      if (branches.length < 2 || crossed.has(inputKey(nodeId, input))) {
+        continue;
+      }
+      const top = decompose(branches);
+      if ("problems" in top) {
+        const [chosen] = [...top.problems].sort(
+          (a, b) => PRECEDENCE.indexOf(a.rule) - PRECEDENCE.indexOf(b.rule) || compareOptionalPorts(a.splitter, b.splitter) || compare(a.branch ?? "", b.branch ?? "") || compare(crossingKey(a.crossing), crossingKey(b.crossing))
+        );
+        violations.push({
+          rule: chosen.rule,
+          nodeId,
+          ...named(input),
+          ...chosen.splitter ? { splitter: chosen.splitter } : {},
+          ...chosen.branch !== void 0 ? { branch: chosen.branch } : {},
+          ...chosen.crossing ? { edgeIndex: chosen.crossing.index } : {}
+        });
+        continue;
+      }
+      const level = top.level;
+      if (level.kind === "leaf") {
+        continue;
+      }
+      const mergerBranches2 = [];
+      const walk = (part, depth, splitter) => {
+        if (part.kind === "leaf") {
+          if (splitter !== null) {
+            mergerBranches2.push({ splitter, lastNodeId: part.connection.from });
+          }
+          return;
+        }
+        if (depth > 0) {
+          virtualMergers.push({
+            input: nodeId,
+            ...named(input),
+            level: depth,
+            kind: part.kind === "and" ? "merger" : "converging",
+            ...part.kind === "and" ? { splitter: part.splitter } : {},
+            members: sorted(leaves(part))
+          });
+        }
+        const inner = part.kind === "and" ? part.splitter : splitter;
+        part.parts.forEach((p) => walk(p, depth + 1, inner));
+      };
+      walk(level, 0, null);
+      if (level.kind === "and") {
+        mergerBranches2.sort((a, b) => compare(a.lastNodeId, b.lastNodeId) || comparePorts(a.splitter, b.splitter));
+        mergers.push({ nodeId, ...named(input), branches: mergerBranches2 });
+        mergerByInput.set(inputKey(nodeId, input), mergerBranches2);
+      } else {
+        converging.add(nodeId);
+      }
+    }
+  }
+  virtualMergers.sort(
+    (a, b) => compare(a.input, b.input) || compare(a.inputName ?? "", b.inputName ?? "") || a.level - b.level || compareLists(a.members, b.members)
+  );
+  const isSiblingReference = (fromNodeId, targetNodeId) => {
+    if (!nodeIds.has(fromNodeId) || !nodeIds.has(targetNodeId) || fromNodeId === targetNodeId) {
+      return false;
+    }
+    if (descendants.get(targetNodeId).has(fromNodeId) || descendants.get(fromNodeId).has(targetNodeId)) {
+      return false;
+    }
+    return splitters.some(({ nodeId, port }) => {
+      const onPort = outgoing.get(nodeId).filter((c) => c.port === port);
+      return onPort.some((c1) => reaches(c1, fromNodeId) && onPort.some((c2) => c2 !== c1 && reaches(c2, targetNodeId)));
+    });
+  };
+  for (const ref of opts.references ?? []) {
+    if (ref.root === "nodes" && isSiblingReference(ref.fromNodeId, ref.target)) {
+      violations.push({ rule: "sibling-reference", nodeId: ref.fromNodeId, target: ref.target });
+    }
+    if (ref.root === "in" && nodeIds.has(ref.fromNodeId)) {
+      const inputs = inputsOf(ref.fromNodeId);
+      const branches = inputs.length === 1 ? mergerByInput.get(inputKey(ref.fromNodeId, inputs[0])) : void 0;
+      if (branches && !branches.some((b) => b.lastNodeId === ref.target)) {
+        violations.push({ rule: "merger-in-reference", nodeId: ref.fromNodeId, target: ref.target });
+      }
+    }
+  }
+  violations.sort(
+    (a, b) => compare(a.rule, b.rule) || compare(a.nodeId, b.nodeId) || compare(a.inputName ?? "", b.inputName ?? "") || (a.edgeIndex ?? -1) - (b.edgeIndex ?? -1) || compare(a.target ?? "", b.target ?? "") || compare(a.branch ?? "", b.branch ?? "")
+  );
+  const mergerBranches = (nodeId, inputName) => {
+    const input = inputName ?? inputsOf(nodeId).find((name) => mergerByInput.has(inputKey(nodeId, name)));
+    return input === void 0 ? null : mergerByInput.get(inputKey(nodeId, input)) ?? null;
+  };
+  return withHelpers(
+    { splitters, mergers, converging: sorted(converging), virtualMergers, loopBodies, violations },
+    mergerBranches,
+    isSiblingReference
+  );
+}
+function withHelpers(shapes, mergerBranches, isSiblingReference) {
+  return {
+    ...shapes,
+    mergerBranches,
+    loopEndNode: (iteratorId) => shapes.loopBodies[iteratorId]?.endNode ?? null,
+    isSiblingReference
+  };
+}

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

@@ -81,3 +81,15 @@ export declare function outputHandleId(port: string, side: Side): string;
  * name to carry. A group frame's input is this on the top side.
  */
 export declare function inputHandleId(side: Side): string;
+/**
+ * The id of a virtual merger's dot: one level of a merge drawn in front of a node's
+ * input (PO-750). `n` counts the virtual mergers in front of that one input, from 1;
+ * two can stand on the same level, so the level alone would not tell them apart.
+ *
+ * It arrives at the same node as the input dot does, so it carries no port name
+ * either, and the separator stays at the front: `portFromHandleId` reads
+ * `__merge1__in__top` as "no port", exactly like `__in__top`. Nothing stores this
+ * id — the blob names only the node an edge arrives at — so the canvas may route a
+ * connection through it without the workflow ever knowing it exists.
+ */
+export declare function virtualMergerHandleId(n: number, side: Side): string;

package/dist/runtime/data/handleId.js

@@ -11,3 +11,6 @@ export function outputHandleId(port, side) {
 export function inputHandleId(side) {
   return `__in__${side}`;
 }
+export function virtualMergerHandleId(n, side) {
+  return `__merge${n}${inputHandleId(side)}`;
+}

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

@@ -0,0 +1,32 @@
+import type { Refusal } from './connectionRules.js';
+import type { ShapeRefusal } from './canvasShapes.js';
+/**
+ * What a toast says when the editor refuses a connection (PO-750).
+ *
+ * A toast is a small record, not a sentence — the design system's shape: a title
+ * saying what happened, and a description with the detail (`@revenexx/studio`,
+ * its Sonner examples). The detail names the steps involved, so the author does not
+ * have to work out which of the dots they were near was the one refused. No action:
+ * there is no next step the editor could take for them — the connection is either
+ * drawn elsewhere or not at all.
+ *
+ * Pure, and it returns message keys rather than text, so the choice of words is
+ * testable without the translator and the translator stays the editor's.
+ */
+export interface ToastText {
+    title: string;
+    description: string;
+    params: Record<string, string | number>;
+}
+/** The record for one refused connection; `label` names a step or a trigger by id. */
+export declare function refusalText(refusal: Refusal, label: (id: string) => string): ToastText;
+/** The record for copies that came without some of their connections. */
+export declare function copiedRefusalText(count: number): ToastText;
+/**
+ * The record for an input the save will refuse because of how branches arrive at
+ * it (decided 19 Oct 2026) — said as it is drawn, not refused: the shape may still
+ * be finished into a valid one, so the connection stays. Where the branches of a
+ * split cross, it names that connection, which is the one to change; `step` is the
+ * step the save will refuse, as its card names it.
+ */
+export declare function joinRefusalText(refusal: ShapeRefusal, step: string): ToastText;

package/dist/runtime/data/refusalMessage.js

@@ -0,0 +1,42 @@
+const TITLE = "integration.editor.connection.refused.title";
+export function refusalText(refusal, label) {
+  if (refusal.reason === "cycle") {
+    return refusal.from && refusal.to ? { title: TITLE, description: "integration.editor.connection.refused.cycle", params: { source: label(refusal.from), target: label(refusal.to) } } : { title: TITLE, description: "integration.editor.connection.refused.cycleUnnamed", params: {} };
+  }
+  if (refusal.direction === "item") {
+    return {
+      title: TITLE,
+      description: "integration.editor.connection.refused.loopBoundaryItem",
+      params: { outside: label(refusal.outside), loop: label(refusal.iterator) }
+    };
+  }
+  return refusal.direction === "out" ? {
+    title: TITLE,
+    description: "integration.editor.connection.refused.loopBoundaryOut",
+    params: { inside: label(refusal.inside), outside: label(refusal.outside), loop: label(refusal.iterator) }
+  } : {
+    title: TITLE,
+    description: "integration.editor.connection.refused.loopBoundary",
+    params: { inside: label(refusal.inside), loop: label(refusal.iterator) }
+  };
+}
+export function copiedRefusalText(count) {
+  return {
+    title: "integration.editor.connection.refused.copiedTitle",
+    description: "integration.editor.connection.refused.copied",
+    params: { n: count }
+  };
+}
+const JOIN_DESCRIPTION = {
+  "merger-across-splitters": "integration.editor.connection.joinRule.mergerAcrossSplitters",
+  "splitter-bypassed": "integration.editor.connection.joinRule.splitterBypassed",
+  "undecomposable-shape": "integration.editor.connection.joinRule.undecomposable"
+};
+export function joinRefusalText(refusal, step) {
+  const title = "integration.editor.connection.joinRule.title";
+  if (refusal.crossing) {
+    const { from, output, to } = refusal.crossing;
+    return { title, description: "integration.editor.connection.joinRule.crossing", params: { from, output, to, step } };
+  }
+  return { title, description: JOIN_DESCRIPTION[refusal.rule], params: { step } };
+}

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

@@ -0,0 +1,31 @@
+import type { WorkflowEdge, WorkflowNode, WorkflowTrigger } from '../types/integrations.js';
+/**
+ * What the save dialog says when the service refuses a workflow for its shape
+ * (PO-746).
+ *
+ * The service checks the shape of the graph on every save, active or paused, and
+ * reports it at the node or the connection itself — `blob.nodes.5`, `blob.edges.3`
+ * — where a node setting is reported under `blob.nodes.5.config.…`. Pausing the
+ * workflow does not get such a save through, so the dialog must not offer it.
+ *
+ * The service says it in English and by step id. The canvas runs the same
+ * analysis, so a refusal it recognises is said in the words the canvas warns
+ * with — the studio's language, the name each card carries, which connection or
+ * node, and what to do. Only a refusal the canvas does not know is passed on as
+ * the service wrote it.
+ */
+export interface SaveIssue {
+    path: string;
+    message: string;
+}
+/** One line of the dialog: a message key with its params, or the service's own text. */
+export type SaveRefusalLine = {
+    key: string;
+    params: Record<string, string | number>;
+} | {
+    where: string | null;
+    message: string;
+};
+/** Whether the service refused the graph itself, which no `active` flag changes. */
+export declare function isShapeIssue(path: string): boolean;
+export declare function saveRefusalLines(issues: readonly SaveIssue[], nodes: readonly WorkflowNode[], edges: readonly WorkflowEdge[], triggers?: readonly WorkflowTrigger[]): SaveRefusalLine[];

package/dist/runtime/data/saveRefusal.js

@@ -0,0 +1,25 @@
+import { nodeDisplayLabel } from "../utils/validationFindings.js";
+import { canvasShapes } from "./canvasShapes.js";
+import { joinRefusalText } from "./refusalMessage.js";
+export function isShapeIssue(path) {
+  return /^blob\.(nodes|edges)(\.\d+)?$/.test(path);
+}
+export function saveRefusalLines(issues, nodes, edges, triggers = []) {
+  const refusals = canvasShapes(nodes, edges, triggers).refusals;
+  const lines = [];
+  const said = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    const index = /^blob\.nodes\.(\d+)\b/.exec(issue.path);
+    const node = index ? nodes[Number(index[1])] : void 0;
+    const refusal = node && isShapeIssue(issue.path) ? refusals.find((r) => r.nodeId === node.id) : void 0;
+    if (refusal) {
+      if (said.has(refusal.nodeId)) continue;
+      said.add(refusal.nodeId);
+      const text = joinRefusalText(refusal, nodeDisplayLabel(node));
+      lines.push({ key: text.description, params: text.params });
+      continue;
+    }
+    lines.push({ where: node ? nodeDisplayLabel(node) : null, message: issue.message });
+  }
+  return lines;
+}

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

@@ -77,7 +77,13 @@
   "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.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.handle.converging": "Zusammenführung: Der Zweig, der ankommt, wird als Eingabe übergeben",
+  "integration.canvas.node.handle.convergingKeyed": "Die Zweige eines Splitters kommen zusammen an, jeder unter dem Schritt, in dem er endet",
   "integration.canvas.node.handle.input": "Eingang",
+  "integration.canvas.node.handle.merger": "Merger: wartet auf alle Zweige; jeder wird unter dem Schritt übergeben, in dem er endet",
+  "integration.canvas.node.handle.splitter": "Splitter: alle Zweige laufen",
+  "integration.canvas.node.handle.virtualConverging": "Zusammenführung, nur gezeichnet: der Zweig, der ankommt",
+  "integration.canvas.node.handle.virtualMerger": "Merger, nur gezeichnet: wartet auf alle Zweige",
   "integration.canvas.node.meta.versionTitle": "Version {version}",
   "integration.canvas.node.note.heading": "Notiz",
   "integration.canvas.node.port.outputFallback": "Ausgang",
@@ -385,6 +391,14 @@
   "integration.editor.clipboard.error.read": "Zwischenablage konnte nicht gelesen werden.",
   "integration.editor.clipboard.error.write": "In die Zwischenablage konnte nicht geschrieben werden.",
   "integration.editor.clipboard.toast.copied": "Node kopiert | {n} Nodes kopiert",
+  "integration.editor.connection.refused.copied": "{n} Verbindung zwischen den Kopien wurde weggelassen, weil sie die Grenze einer Schleife überqueren würde. | {n} Verbindungen zwischen den Kopien wurden weggelassen, weil sie die Grenze einer Schleife überqueren würden.",
+  "integration.editor.connection.refused.copiedTitle": "Ohne einige Verbindungen kopiert",
+  "integration.editor.connection.refused.cycle": "{source} läuft bereits nach {target} — diese Verbindung würde einen Kreis schließen.",
+  "integration.editor.connection.refused.cycleUnnamed": "Damit entstünde ein Kreis: Ein Schritt liefe nach sich selbst.",
+  "integration.editor.connection.refused.loopBoundary": "{inside} liegt in der Schleife {loop}; nur deren Ausgang „Element“ darf in ihre Schritte führen.",
+  "integration.editor.connection.refused.loopBoundaryItem": "{outside} wird auch von außerhalb der Schleife {loop} erreicht, deshalb darf deren Ausgang „Element“ nicht dorthin führen.",
+  "integration.editor.connection.refused.loopBoundaryOut": "{inside} liegt in der Schleife {loop}, und {outside} wird auch von außerhalb erreicht; nur deren Ausgang „Fertig“ darf aus der Schleife herausführen.",
+  "integration.editor.connection.refused.title": "Verbindung nicht möglich",
   "integration.editor.deactivate.dialog.cancel": "Abbrechen",
   "integration.editor.deactivate.dialog.confirm": "Als pausiert speichern",
   "integration.editor.deactivate.dialog.description.paused": "pausiert",
@@ -581,14 +595,23 @@
   "integration.nodeConfig.expression.picker.filterPlaceholder": "Filtern…",
   "integration.nodeConfig.expression.pill.inputPath": "Input · {rest}",
   "integration.nodeConfig.expression.pill.inputPayload": "Eingabe-Payload",
+  "integration.nodeConfig.expression.pill.runId": "Run-ID",
+  "integration.nodeConfig.expression.pill.runUrl": "Run-Link",
   "integration.nodeConfig.expression.pill.triggerPath": "Trigger · {rest}",
   "integration.nodeConfig.expression.pill.triggerPayload": "Trigger-Payload",
   "integration.nodeConfig.expression.pill.variable": "Variable · {path}",
+  "integration.nodeConfig.expression.pill.workflowId": "Workflow-ID",
+  "integration.nodeConfig.expression.pill.workflowName": "Workflow-Name",
   "integration.nodeConfig.expression.preview.missTitle": "Teile dieses Ausdrucks haben noch keine Beispieldaten",
   "integration.nodeConfig.expression.suggestion.heading.input": "EINGABE",
   "integration.nodeConfig.expression.suggestion.heading.nodeOutputs": "NODE-AUSGABEN",
+  "integration.nodeConfig.expression.suggestion.heading.run": "RUN",
   "integration.nodeConfig.expression.suggestion.heading.variables": "VARIABLEN",
   "integration.nodeConfig.expression.suggestion.inputPayload": "Eingabe-Payload",
+  "integration.nodeConfig.expression.suggestion.runId": "Run-ID",
+  "integration.nodeConfig.expression.suggestion.runUrl": "Run-Link",
+  "integration.nodeConfig.expression.suggestion.workflowId": "Workflow-ID",
+  "integration.nodeConfig.expression.suggestion.workflowName": "Workflow-Name",
   "integration.nodeConfig.expression.toggle.off": "Zurück zum normalen Feld (löscht den Ausdruck)",
   "integration.nodeConfig.expression.toggle.on": "Diesen Wert stattdessen aus einem vorherigen Schritt zuordnen",
   "integration.nodeConfig.expression.useFit": "Übernehmen:",
@@ -990,10 +1013,14 @@
   "integration.runs.response.title.starting": "Run wird gestartet",
   "integration.runs.response.title.sync": "Run-Antwort",
   "integration.runs.response.title.unconfirmed": "Start nicht bestätigt",
+  "integration.runs.skip.deadEnd": "Übersprungen: Dead End",
+  "integration.runs.skip.deadEndBranch": "Übersprungen: Dead End in Zweig {branch}",
+  "integration.runs.skip.plain": "Übersprungen",
   "integration.runs.status.cancelled": "abgebrochen",
   "integration.runs.status.failed": "fehlgeschlagen",
   "integration.runs.status.queued": "wartet",
   "integration.runs.status.running": "läuft",
+  "integration.runs.status.skipped": "übersprungen",
   "integration.runs.status.succeeded": "erfolgreich",
   "integration.runs.table.column.duration": "Dauer",
   "integration.runs.table.column.id": "ID",
@@ -1393,5 +1420,13 @@
   "integration.nodeVersions.badge.offered": "Angeboten",
   "integration.nodeVersions.badge.notBuilt": "Nicht gebaut",
   "integration.nodeVersions.action.retire": "Ausmustern",
-  "integration.nodeVersions.action.restore": "Wiederherstellen"
+  "integration.nodeVersions.action.restore": "Wiederherstellen",
+  "integration.editor.connection.joinRule.title": "So nicht speicherbar",
+  "integration.editor.connection.joinRule.crossing": "Die Verbindung vom Node „{from}“ (Ausgang {output}) zum Node „{to}“ verbindet zwei Wege, die getrennt laufen müssen. Löschen Sie diese Verbindung oder führen Sie sie zu einem Node im selben Weg.",
+  "integration.editor.connection.joinRule.mergerAcrossSplitters": "Im Node „{step}“ kommen Wege zusammen, die sich an verschiedenen Stellen geteilt haben. Führen Sie zuerst die Wege jeder Teilung in einem eigenen Node zusammen.",
+  "integration.editor.connection.joinRule.splitterBypassed": "Zum Node „{step}“ führen Wege, die sich vorher geteilt haben – und eine Verbindung führt zusätzlich an dieser Teilung vorbei. Löschen Sie diese zusätzliche Verbindung.",
+  "integration.editor.connection.joinRule.undecomposable": "Im Node „{step}“ kommen Wege zusammen, die immer laufen, und Wege, die nur bei einer bestimmten Bedingung laufen. Führen Sie diese Wege in getrennten Nodes zusammen.",
+  "integration.editor.unsavable.dialog.back": "Zurück zum Editor",
+  "integration.editor.unsavable.dialog.description": "Dieser Workflow ist aktuell ungültig. Er kann so nicht gespeichert werden. Bitte beheben Sie zuerst diese Fehler:",
+  "integration.editor.unsavable.dialog.title": "Workflow kann nicht gespeichert werden"
 }