@revenexx/studio-integrations 1.2.0 → 1.3.0

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -70,6 +70,11 @@ function applyDetail(base, api) {
     edges: def.edges ?? [],
     triggerPositions: def.triggerPositions ?? {},
     variables: def.variables,
+    // Enumerated key by key like every block above it, so one missing here is
+    // one lost in this direction. Harmless today — a template becomes a workflow
+    // server-side, so this blob only feeds the preview — but the preview is
+    // where an author would look to see what a template remembers.
+    state: def.state,
     triggers
   };
   const md = resolveLocalized(api.description ?? "") || base.descriptionMd;

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -20,6 +20,7 @@ function toCockpit(api) {
     nodes: apiBlob.nodes ?? [],
     edges: apiBlob.edges ?? [],
     variables: apiBlob.variables ?? void 0,
+    state: apiBlob.state ?? void 0,
     triggerPositions: apiBlob.triggerPositions ?? {},
     stickies: apiBlob.stickies ?? [],
     groups: apiBlob.groups ?? [],
@@ -64,6 +65,11 @@ function toPayload(meta) {
       ...b.groups?.length ? { groups: b.groups } : {},
       // variables were silently dropped before — the schema always allowed them.
       ...b.variables && Object.keys(b.variables).length ? { variables: b.variables } : {},
+      // Same shape, and the same trap: both mappers enumerate blob keys, so a
+      // block missing from either one is lost in that direction. `state` is the
+      // declaration that makes the run grant reachable at all (PO-374) — losing
+      // it on save would take the workflow's memory away without a message.
+      ...b.state?.length ? { state: b.state } : {},
       ...b.tags?.length ? { tags: b.tags } : {},
       ...b.icon ? { icon: b.icon } : {}
     },

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

@@ -81,6 +81,31 @@ export declare function isVersionExecutable(slug: string, version: string): bool
  * only what is wrong.
  */
 export declare function newestExecutableVersion(slug: string): string | null;
+/**
+ * Every version of this node the platform can execute, newest first — the
+ * choice offered when a step is moved onto another version (PO-339).
+ *
+ * Order is the catalogue's own: the registry returns each slug's versions
+ * semver-descending, which is the assumption `newestExecutableVersion` above and
+ * the palette's own list already rest on. So "newer than the pinned one" is
+ * "earlier in this array", and nothing here has to parse a semver.
+ *
+ * A version whose code was never built is left out, for the reason the palette
+ * leaves it out: it is not a choice, it is a dead end with a version number
+ * (PO-338). The version a step is pinned to is therefore not guaranteed to be in
+ * here — which is exactly the state the move exists to get out of.
+ */
+export declare function executableVersionsOf(slug: string): NodeManifest[];
+/**
+ * The versions of this node that are newer than the one pinned, and runnable.
+ *
+ * Empty when the step is already on the newest — which is the common case, and
+ * the reason the inspector can stay silent rather than telling most authors that
+ * their node is fine. A pinned version the catalogue does not carry counts as
+ * "nothing newer": there is no position to be newer *than*, and inventing one
+ * would put an upgrade notice on a node whose real problem is different.
+ */
+export declare function newerExecutableVersions(slug: string, version: string): NodeManifest[];
 export declare function findManifest(slug: string, version?: string): NodeManifest | null;
 export declare const TRIGGER_OUTPUT_PORT = "default";
 export interface TriggerTemplate {

package/dist/runtime/data/integrationNodeCatalog.js

@@ -34,6 +34,14 @@ export function newestExecutableVersion(slug) {
   const hit = INTEGRATION_NODE_CATALOG.find((m) => m.slug === slug && m.__hasBundle !== false);
   return hit?.version ?? null;
 }
+export function executableVersionsOf(slug) {
+  return INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug && m.__hasBundle !== false);
+}
+export function newerExecutableVersions(slug, version) {
+  const versions = executableVersionsOf(slug);
+  const at = versions.findIndex((m) => m.version === version);
+  return at < 0 ? [] : versions.slice(0, at);
+}
 export function findManifest(slug, version) {
   const matches = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug);
   if (!matches.length) return null;

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

@@ -0,0 +1,72 @@
+import type { ConfigField, NodeManifest } from '../types/integrations.js';
+/**
+ * What moving a step onto another version of its node costs (PO-339).
+ *
+ * A version is chosen when a node is inserted and, until this, never again — so
+ * the only route onto another one was to delete the step and build it back,
+ * losing its settings, its name, its note and its edges. Moving instead is
+ * cheap in the blob (one field changes) and expensive in trust: the two
+ * versions may not declare the same settings, and an author who is not told
+ * beforehand finds out by a value having quietly gone.
+ *
+ * This module answers "what would the move cost" and nothing else. It builds no
+ * words: labels are localised strings on the manifest, so the caller resolves
+ * them and this stays testable without an i18n context.
+ *
+ * **A value that is not there is not a loss.** Only settings the node actually
+ * holds are weighed. A field the author never filled has nothing to carry, drop
+ * or check, and listing it would bury the two or three that matter.
+ *
+ * **The comparison is over the config's own top-level keys**, which is what
+ * `nextConfig` can act on: the blob stores settings as one flat object, and
+ * removing `attachments` is removing one key from it. A version that changed
+ * something *inside* an object or an array element is caught as far as it can
+ * be — such a field lands in `review` rather than being silently carried — but
+ * the stale value inside it is not pruned. `specs/node-configuration.md`
+ * records that limit rather than this pretending to close it.
+ */
+/** A setting the move has something to say about, with the field it was read from. */
+export interface MoveEntry {
+    key: string;
+    /**
+     * The declaration to name it by. For a carried or reviewed setting that is the
+     * TARGET's field, because that is what the author will be looking at after the
+     * move; for a dropped one it is the SOURCE's, which is the only version that
+     * still has a word for it. `null` where neither declares it — a key left behind
+     * by an earlier move, which has no label anywhere and shows as its own name.
+     */
+    field: ConfigField | null;
+    /** Why it needs looking at. Only set on `review`. */
+    reason?: 'changed' | 'nowRequired';
+}
+export interface VersionMovePlan {
+    /** Settings that travel untouched: the target declares the same key, the same way. */
+    carried: MoveEntry[];
+    /** Settings the target does not declare. Their values are gone from `nextConfig`. */
+    dropped: MoveEntry[];
+    /** Settings that arrive but need the author's eye — see `reason`. Values are kept. */
+    review: MoveEntry[];
+    /** The config to save with the new version: the current one minus what was dropped. */
+    nextConfig: Record<string, unknown>;
+    /** Nothing is dropped and nothing needs checking — the move is a version change and no more. */
+    lossless: boolean;
+    /**
+     * Whether the version being left is still in the catalogue, so the two
+     * declarations could actually be held against each other. `false` for a
+     * withdrawn version: the move still works and nothing here is wrong, but
+     * `carried` then means "kept" rather than "checked and unchanged", and the
+     * dialog owes the author that sentence.
+     */
+    comparable: boolean;
+}
+/**
+ * What it would cost to move a step from `from` to `to`, given the settings it
+ * holds today.
+ *
+ * Either manifest may be `null` — a version the catalogue does not carry, which
+ * happens to a workflow pinned to something later withdrawn. A missing SOURCE
+ * only costs labels; a missing TARGET would drop every setting, so the caller
+ * must not offer a move onto a version it cannot find, and `planVersionMove`
+ * does not defend against being asked anyway.
+ */
+export declare function planVersionMove(from: NodeManifest | null, to: NodeManifest | null, config: Record<string, unknown> | null | undefined): VersionMovePlan;

package/dist/runtime/data/nodeVersionMove.js

@@ -0,0 +1,65 @@
+function hasValue(config, key) {
+  if (!(key in config)) return false;
+  const v = config[key];
+  return v !== void 0 && v !== null && v !== "";
+}
+function byKey(manifest) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of manifest?.config ?? []) {
+    if (f && typeof f.key === "string" && f.key) map.set(f.key, f);
+  }
+  return map;
+}
+function shapeOf(field) {
+  if (!field) return "";
+  return JSON.stringify([
+    field.type,
+    (field.options ?? []).map((o) => o.value),
+    (field.properties ?? []).map((p) => [p.key, p.type]),
+    field.items ? [field.items.key, field.items.type, (field.items.properties ?? []).map((p) => [p.key, p.type])] : null
+  ]);
+}
+export function planVersionMove(from, to, config) {
+  const current = config ?? {};
+  const sourceFields = byKey(from);
+  const targetFields = byKey(to);
+  const targetHasDynamicSchema = (to?.config ?? []).some((f) => f?.type === "dynamic-schema");
+  const carried = [];
+  const dropped = [];
+  const review = [];
+  const nextConfig = {};
+  for (const key of Object.keys(current)) {
+    if (!hasValue(current, key)) {
+      nextConfig[key] = current[key];
+      continue;
+    }
+    const target = targetFields.get(key);
+    if (!target) {
+      if (targetHasDynamicSchema) {
+        nextConfig[key] = current[key];
+        continue;
+      }
+      dropped.push({ key, field: sourceFields.get(key) ?? null });
+      continue;
+    }
+    nextConfig[key] = current[key];
+    const source = sourceFields.get(key);
+    if (!source || shapeOf(source) === shapeOf(target)) carried.push({ key, field: target });
+    else review.push({ key, field: target, reason: "changed" });
+  }
+  for (const [key, field] of targetFields) {
+    if (field.default !== void 0 && !(key in current)) nextConfig[key] = field.default;
+    if (field.required !== true) continue;
+    if (field.default !== void 0) continue;
+    if (hasValue(current, key)) continue;
+    review.push({ key, field, reason: "nowRequired" });
+  }
+  return {
+    carried,
+    dropped,
+    review,
+    nextConfig,
+    lossless: dropped.length === 0 && review.length === 0,
+    comparable: from !== null && from !== void 0
+  };
+}

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

@@ -71,9 +71,9 @@
   "integration.canvas.node.action.duplicate": "Duplizieren",
   "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.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.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",
@@ -455,6 +455,8 @@
   "integration.editor.tool.select": "Auswählen",
   "integration.editor.tool.settings.label": "Einstellungen",
   "integration.editor.tool.settings.tooltip": "Workflow-Einstellungen",
+  "integration.editor.tool.state.label": "Zustand",
+  "integration.editor.tool.state.tooltip": "Was sich dieser Workflow zwischen Läufen merkt",
   "integration.editor.tool.tidyUp": "Aufräumen",
   "integration.editor.tool.variables.label": "Variablen",
   "integration.editor.tool.variables.tooltip": "Workflow-Variablen",
@@ -529,8 +531,8 @@
   "integration.nodeConfig.dynamicSchema.reloading": "Felder werden neu geladen…",
   "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.insertTitle": "Ausdruck einfügen",
   "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",
@@ -596,6 +598,11 @@
   "integration.nodeConfig.resolve.error.generic": "Auflösung fehlgeschlagen",
   "integration.nodeConfig.secretRef.placeholder": "Secret auswählen",
   "integration.nodeConfig.select.placeholder": "Auswählen",
+  "integration.nodeConfig.state.action.new": "Neuen Namespace deklarieren…",
+  "integration.nodeConfig.state.create.description": "Er wird den Deklarationen dieses Workflows als {role}-Namespace hinzugefügt und hier ausgewählt.",
+  "integration.nodeConfig.state.create.title": "Zustands-Namespace deklarieren",
+  "integration.nodeConfig.state.empty": "Dieser Workflow deklariert davon noch keinen.",
+  "integration.nodeConfig.state.placeholder": "Namespace wählen…",
   "integration.nodeConfig.validation.max": "Muss ≤ {max} sein",
   "integration.nodeConfig.validation.maxLength": "Darf höchstens {max} Zeichen lang sein",
   "integration.nodeConfig.validation.min": "Muss ≥ {min} sein",
@@ -641,9 +648,9 @@
   "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.loopBody.names": "Diese wiederholen sich: {names}",
+  "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.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.",
@@ -800,6 +807,20 @@
   "integration.nodeInspector.trigger.webhook.username.hint": "Optional — legt den Basic-Auth-Benutzernamen fest. Das Passwort ist das Endpoint-Secret.",
   "integration.nodeInspector.trigger.webhook.username.label": "Benutzername",
   "integration.nodeInspector.trigger.webhook.username.placeholder": "Beliebiger Benutzername",
+  "integration.nodeInspector.version.available": "Version {version} ist verfügbar.",
+  "integration.nodeInspector.version.change": "Version wechseln",
+  "integration.nodeInspector.version.move.confirm": "Version wechseln",
+  "integration.nodeInspector.version.move.description": "Der Schritt behält seine Verbindungen, seinen Namen und seine Notiz. Es ändert sich die Version — und jede Einstellung, die es in der gewählten Version nicht gibt.",
+  "integration.nodeInspector.version.move.dropped": "Wird entfernt",
+  "integration.nodeInspector.version.move.lossless": "Alle Einstellungen kommen unverändert mit.",
+  "integration.nodeInspector.version.move.notComparable": "Version {version} liegt nicht mehr im Katalog, deshalb lässt sich nicht vergleichen, was sich zwischen beiden unterscheidet. Unten steht, was ankommt — nicht, was geprüft wurde.",
+  "integration.nodeInspector.version.move.reason.changed": "hat sich zwischen den Versionen geändert",
+  "integration.nodeInspector.version.move.reason.nowRequired": "erforderlich und noch nicht ausgefüllt",
+  "integration.nodeInspector.version.move.review": "Danach prüfen",
+  "integration.nodeInspector.version.move.same": "Auf dieser Version steht der Schritt bereits.",
+  "integration.nodeInspector.version.move.targetAria": "Version, auf die dieser Schritt wechselt",
+  "integration.nodeInspector.version.move.title": "Version dieses Schritts wechseln",
+  "integration.nodeInspector.version.moveTo": "Auf Version {version} wechseln",
   "integration.nodes.category.action": "Aktionen",
   "integration.nodes.category.control": "Ablaufsteuerung",
   "integration.nodes.category.io": "I/O",
@@ -1188,6 +1209,34 @@
   "integration.workflows.settings.section.appearance": "Aussehen",
   "integration.workflows.settings.section.execution": "Ausführung",
   "integration.workflows.settings.section.metadata": "Metadaten",
+  "integration.workflows.state.action.add": "Deklarieren",
+  "integration.workflows.state.action.done": "Fertig",
+  "integration.workflows.state.action.remove": "Deklaration entfernen",
+  "integration.workflows.state.action.remove.hint": "Das Entfernen nimmt diesem Workflow den Zugriff. Die gespeicherten Einträge bleiben bestehen.",
+  "integration.workflows.state.dialog.description": "Was sich dieser Workflow zwischen Läufen merken darf. Er erreicht ausschließlich die hier deklarierten Namespaces — alles andere wird beim Lauf abgewiesen.",
+  "integration.workflows.state.dialog.title": "Zustands-Namespaces",
+  "integration.workflows.state.error.invalidName": "Kleinbuchstaben, Ziffern und . - _, beginnend mit einem Buchstaben — zum Beispiel article oder crm.customers.",
+  "integration.workflows.state.error.nameExists": "Dieser Workflow deklariert diesen Namespace bereits.",
+  "integration.workflows.state.field.newName.label": "Namespace deklarieren",
+  "integration.workflows.state.field.newName.placeholder": "article",
+  "integration.workflows.state.field.newRole.label": "Rolle",
+  "integration.workflows.state.field.newVisibility.label": "Sichtbar für",
+  "integration.workflows.state.field.visibility.label": "Sichtbar für",
+  "integration.workflows.state.role.cursor.hint": "Merkt sich, wie weit ein inkrementeller Import gelesen hat. Es rückt nur vor, wenn der Lauf sauber endet.",
+  "integration.workflows.state.role.cursor.label": "Lesezeichen",
+  "integration.workflows.state.role.dedupe.hint": "Markiert Verarbeitetes, damit eine wiederholte Zustellung nicht doppelt gebucht wird.",
+  "integration.workflows.state.role.dedupe.label": "Dublettenschutz",
+  "integration.workflows.state.role.digest.hint": "Merkt sich den zuletzt geschriebenen Stand, damit unveränderte Datensätze übersprungen werden.",
+  "integration.workflows.state.role.digest.label": "Prüfsumme",
+  "integration.workflows.state.role.fixed": "Die Rolle steht mit der Deklaration fest: Einträge, die mit einer Bedeutung geschrieben wurden, lassen sich nicht mit einer anderen lesen.",
+  "integration.workflows.state.role.mapping.hint": "Verknüpft je eine ID auf beiden Seiten, damit ein späterer Lauf weiß, ob er anlegen oder aktualisieren muss.",
+  "integration.workflows.state.role.mapping.label": "Zuordnung",
+  "integration.workflows.state.row.aria": "Zustands-Namespace {namespace}",
+  "integration.workflows.state.empty": "Dieser Workflow merkt sich noch nichts zwischen Läufen.",
+  "integration.workflows.state.visibility.private.hint": "Nur dieser Workflow liest und schreibt ihn, und er wird mit dem Workflow gelöscht.",
+  "integration.workflows.state.visibility.private.label": "Diesen Workflow",
+  "integration.workflows.state.visibility.shared.hint": "Jeder Workflow dieses Mandanten liest und schreibt diese Einträge, und der Namespace bleibt bestehen, wenn dieser Workflow gelöscht wird.",
+  "integration.workflows.state.visibility.shared.label": "Alle Workflows",
   "integration.workflows.table.action.groupByTags": "Nach Tags gruppieren",
   "integration.workflows.table.column.build": "Build",
   "integration.workflows.table.column.lastRun": "Letzter Run",

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

@@ -71,9 +71,9 @@
   "integration.canvas.node.action.duplicate": "Duplicate",
   "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.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.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",
@@ -455,6 +455,8 @@
   "integration.editor.tool.select": "Select",
   "integration.editor.tool.settings.label": "Settings",
   "integration.editor.tool.settings.tooltip": "Workflow settings",
+  "integration.editor.tool.state.label": "State",
+  "integration.editor.tool.state.tooltip": "What this workflow remembers between runs",
   "integration.editor.tool.tidyUp": "Tidy up",
   "integration.editor.tool.variables.label": "Variables",
   "integration.editor.tool.variables.tooltip": "Workflow variables",
@@ -529,8 +531,8 @@
   "integration.nodeConfig.dynamicSchema.reloading": "reloading fields…",
   "integration.nodeConfig.dynamicSchema.resolving": "Resolving fields…",
   "integration.nodeConfig.expression.badge.title": "Accepts ${{ … }} expressions",
-  "integration.nodeConfig.expression.insertTitle": "Insert expression",
   "integration.nodeConfig.expression.insertAria": "Insert expression — available data for this setting",
+  "integration.nodeConfig.expression.insertTitle": "Insert expression",
   "integration.nodeConfig.expression.picker.aria": "Available data for this setting",
   "integration.nodeConfig.expression.picker.empty": "Nothing matches “{query}”.",
   "integration.nodeConfig.expression.picker.filterAria": "Filter available data",
@@ -596,6 +598,11 @@
   "integration.nodeConfig.resolve.error.generic": "Resolve failed",
   "integration.nodeConfig.secretRef.placeholder": "Pick a secret",
   "integration.nodeConfig.select.placeholder": "Pick one",
+  "integration.nodeConfig.state.action.new": "Declare a new namespace…",
+  "integration.nodeConfig.state.create.description": "It is added to this workflow's declarations as a {role} namespace and selected here.",
+  "integration.nodeConfig.state.create.title": "Declare a state namespace",
+  "integration.nodeConfig.state.empty": "This workflow declares none of this kind yet.",
+  "integration.nodeConfig.state.placeholder": "Choose a namespace…",
   "integration.nodeConfig.validation.max": "Must be ≤ {max}",
   "integration.nodeConfig.validation.maxLength": "Must be at most {max} characters",
   "integration.nodeConfig.validation.min": "Must be ≥ {min}",
@@ -641,9 +648,9 @@
   "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.loopBody.names": "These repeat: {names}",
+  "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.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.",
@@ -800,6 +807,20 @@
   "integration.nodeInspector.trigger.webhook.username.hint": "Optional — pins the Basic-auth username. The password is the endpoint secret.",
   "integration.nodeInspector.trigger.webhook.username.label": "Username",
   "integration.nodeInspector.trigger.webhook.username.placeholder": "Any username",
+  "integration.nodeInspector.version.available": "Version {version} is available.",
+  "integration.nodeInspector.version.change": "Change version",
+  "integration.nodeInspector.version.move.confirm": "Change version",
+  "integration.nodeInspector.version.move.description": "The step keeps its connections, its name and its note. What changes is the version — and any setting the chosen version does not have.",
+  "integration.nodeInspector.version.move.dropped": "Will be removed",
+  "integration.nodeInspector.version.move.lossless": "Every setting travels unchanged.",
+  "integration.nodeInspector.version.move.notComparable": "Version {version} is no longer in the catalogue, so what differs between the two cannot be compared. The list below is what arrives, not what was checked.",
+  "integration.nodeInspector.version.move.reason.changed": "changed between the versions",
+  "integration.nodeInspector.version.move.reason.nowRequired": "required, and not answered yet",
+  "integration.nodeInspector.version.move.review": "Worth checking afterwards",
+  "integration.nodeInspector.version.move.same": "This is the version the step is already on.",
+  "integration.nodeInspector.version.move.targetAria": "Version to change this step to",
+  "integration.nodeInspector.version.move.title": "Change this step's version",
+  "integration.nodeInspector.version.moveTo": "Change to version {version}",
   "integration.nodes.category.action": "Actions",
   "integration.nodes.category.control": "Control flow",
   "integration.nodes.category.io": "I/O",
@@ -1188,6 +1209,34 @@
   "integration.workflows.settings.section.appearance": "Appearance",
   "integration.workflows.settings.section.execution": "Execution",
   "integration.workflows.settings.section.metadata": "Metadata",
+  "integration.workflows.state.action.add": "Declare",
+  "integration.workflows.state.action.done": "Done",
+  "integration.workflows.state.action.remove": "Remove declaration",
+  "integration.workflows.state.action.remove.hint": "Removing the declaration takes this workflow's access away. The stored entries stay where they are.",
+  "integration.workflows.state.dialog.description": "What this workflow may remember between runs. It can only reach the namespaces declared here — anything else is refused when the workflow runs.",
+  "integration.workflows.state.dialog.title": "State namespaces",
+  "integration.workflows.state.error.invalidName": "Use lowercase letters, digits and . - _, starting with a letter — for example article or crm.customers.",
+  "integration.workflows.state.error.nameExists": "This workflow already declares that namespace.",
+  "integration.workflows.state.field.newName.label": "Declare a namespace",
+  "integration.workflows.state.field.newName.placeholder": "article",
+  "integration.workflows.state.field.newRole.label": "Role",
+  "integration.workflows.state.field.newVisibility.label": "Visible to",
+  "integration.workflows.state.field.visibility.label": "Visible to",
+  "integration.workflows.state.role.cursor.hint": "Remembers how far an incremental import read. It only moves on when the run finishes cleanly.",
+  "integration.workflows.state.role.cursor.label": "Cursor",
+  "integration.workflows.state.role.dedupe.hint": "Marks something as already processed, so a repeated delivery is not booked twice.",
+  "integration.workflows.state.role.dedupe.label": "Dedupe",
+  "integration.workflows.state.role.digest.hint": "Remembers what was last written, so unchanged records can be skipped.",
+  "integration.workflows.state.role.digest.label": "Digest",
+  "integration.workflows.state.role.fixed": "The role is fixed once the namespace is declared: entries written with one meaning cannot be read back with another.",
+  "integration.workflows.state.role.mapping.hint": "Correlates an id on each side, so a later run knows whether to create or update.",
+  "integration.workflows.state.role.mapping.label": "Mapping",
+  "integration.workflows.state.row.aria": "State namespace {namespace}",
+  "integration.workflows.state.empty": "This workflow remembers nothing between runs yet.",
+  "integration.workflows.state.visibility.private.hint": "Only this workflow reads and writes it, and it is deleted along with the workflow.",
+  "integration.workflows.state.visibility.private.label": "This workflow",
+  "integration.workflows.state.visibility.shared.hint": "Every workflow in this tenant reads and writes these entries, and the namespace stays when this workflow is deleted.",
+  "integration.workflows.state.visibility.shared.label": "Every workflow",
   "integration.workflows.table.action.groupByTags": "Group by tags",
   "integration.workflows.table.column.build": "Build",
   "integration.workflows.table.column.lastRun": "Last run",

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

@@ -42,6 +42,7 @@ import RunDetailPanel from "../../../components/Integrations/RunDetailPanel.vue"
 import { toast } from "vue-sonner";
 import { IntegrationsApiError, apiValidationIssues, errorReason } from "../../../utils/apiError";
 import { createPollBudget, SAFETY_POLL_MS } from "../../../utils/pollBudget";
+import { BUILD_SETTLE_POLL_MS, BUILD_SETTLE_TIMEOUT_MS, createBuildSettle, isBuildUnsettled } from "../../../utils/buildSettle";
 import { splitRunOutputs } from "../../../utils/runOutputs";
 import { isTerminalRun, unwrapRun } from "../../../utils/runEnvelope";
 import { findingsSummary, groupFindingsByNode, nodeDisplayLabel } from "../../../utils/validationFindings";
@@ -124,8 +125,8 @@ const reauthCredentials = computed(() => {
 const buildWorking = computed(() => workflow.value?.buildStatus === "building" || workflow.value?.buildStatus === "pending");
 const buildFailed = computed(() => workflow.value?.buildStatus === "failed");
 const waitingForBuild = ref(false);
-const BUILD_WAIT_POLL_MS = 2500;
-const BUILD_WAIT_TIMEOUT_MS = 5 * 6e4;
+const BUILD_WAIT_POLL_MS = BUILD_SETTLE_POLL_MS;
+const BUILD_WAIT_TIMEOUT_MS = BUILD_SETTLE_TIMEOUT_MS;
 async function waitForBuildReady() {
   waitingForBuild.value = true;
   try {
@@ -148,19 +149,14 @@ async function waitForBuildReady() {
     waitingForBuild.value = false;
   }
 }
-let buildWatch = 0;
-async function settleBuildStatus() {
-  const mine = ++buildWatch;
-  const started = Date.now();
-  while (Date.now() - started < BUILD_WAIT_TIMEOUT_MS) {
-    if (mine !== buildWatch || !workflow.value) return;
-    const status = workflow.value.buildStatus;
-    if (status !== "pending" && status !== "building") return;
-    await new Promise((resolve) => setTimeout(resolve, BUILD_WAIT_POLL_MS));
-    if (mine !== buildWatch || !workflow.value) return;
-    await get(workflow.value.id);
-  }
+const buildSettle = createBuildSettle();
+function settleBuildStatus() {
+  void buildSettle.settle({
+    unsettled: () => !!workflow.value && isBuildUnsettled(workflow.value.buildStatus),
+    read: () => get(workflow.value.id)
+  });
 }
+onUnmounted(() => buildSettle.stop());
 const buildNotice = computed(() => {
   switch (workflow.value?.buildStatus) {
     case "building":
@@ -182,7 +178,7 @@ watch(id, async () => {
   draft.value = null;
   warningsExpanded.value = false;
   if (tab.value === "runs") void loadRuns(1);
-  void settleBuildStatus();
+  settleBuildStatus();
 }, { immediate: true });
 function onChange(blob) {
   const d = draftFrom();
@@ -252,7 +248,7 @@ async function onRevisionRestored() {
   if (!workflow.value) return;
   await get(workflow.value.id);
   draft.value = null;
-  void settleBuildStatus();
+  settleBuildStatus();
 }
 const { trigger: triggerRun, loadForWorkflow, fetchRun, getRun, retryRun } = useIntegrationsRuns();
 const running = ref(false);
@@ -711,7 +707,7 @@ async function save() {
       executionMode: d.executionMode
     });
     draft.value = null;
-    void settleBuildStatus();
+    settleBuildStatus();
   } catch (e) {
     const issues = apiValidationIssues(e);
     if (issues.length && workflow.value.active) {
@@ -748,7 +744,7 @@ async function confirmDeactivate() {
     draft.value = null;
     deactivationOpen.value = false;
     toast.success(t("integration.editor.deactivate.toast.savedPaused"));
-    void settleBuildStatus();
+    settleBuildStatus();
   } catch (e) {
     deactivationOpen.value = false;
     saveError.value = errorReason(e, t("integration.editor.save.error.generic"));
@@ -1195,7 +1191,18 @@ function formatDateTime(iso) {
          afternoon this dialog exists to protect.
          `as-child` so the studio's own Button is that element rather than a second one
          beside it. Escape means the same thing, through `update:open`; a click beside
-         the dialog does nothing at all, which an alert dialog is entitled to. -->
+         the dialog does nothing at all, which an alert dialog is entitled to.
+
+         The class list on that Button is the price of `as-child`: `AlertDialogCancel`
+         applies the outline variant to whatever it renders, and every dialog in this
+         module draws the answer on the right as a filled one. So the two variants meet
+         on one element and `tailwind-merge` decides between them per group — which it
+         cannot do where the outline variant names a group the default one does not, and
+         those are the five that have to be said here. Left to itself the merge produced
+         a background from the outline variant and a text colour from the default, which
+         resolve to the same colour in this theme: the label was invisible until hovered
+         (PO-415). Nothing marks this answer as the one holding the keyboard otherwise —
+         `focus-visible` does not match after the click that opened the dialog. -->
     <AlertDialog :open="leaveOpen" @update:open="(v) => {
   if (!v) answerLeave(false);
 }">
@@ -1211,7 +1218,10 @@ function formatDateTime(iso) {
             {{ t("integration.editor.leave.dialog.discard") }}
           </Button>
           <AlertDialogCancel as-child>
-            <Button @click="answerLeave(false)">
+            <Button
+              class="border-transparent bg-primary text-primary-foreground hover:bg-primary/90 hover:text-primary-foreground dark:border-transparent dark:bg-primary dark:hover:bg-primary/90"
+              @click="answerLeave(false)"
+            >
               {{ t("integration.editor.leave.dialog.stay") }}
             </Button>
           </AlertDialogCancel>

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

@@ -3,15 +3,30 @@ import { AddCircle as Plus } from "#solar-icons";
 import { Button } from "@revenexx/studio";
 import WorkflowsTable from "../../../components/Integrations/WorkflowsTable.vue";
 import WorkflowCreateDialog from "../../../components/Integrations/WorkflowCreateDialog.vue";
+import { createBuildSettle, isBuildUnsettled } from "../../../utils/buildSettle";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.workflows.list.head.title") });
 const { workflows, loading, error, load } = useIntegrationsWorkflows();
-onMounted(() => {
-  void load();
+onMounted(async () => {
+  await load();
+  settleBuildStates();
+});
+let onScreen = true;
+const buildSettle = createBuildSettle();
+function settleBuildStates() {
+  if (!onScreen) return;
+  void buildSettle.settle({
+    unsettled: () => workflows.value.some((wf) => isBuildUnsettled(wf.buildStatus)),
+    read: () => load(true)
+  });
+}
+onUnmounted(() => {
+  onScreen = false;
+  buildSettle.stop();
 });
 const { buildTick } = useIntegrationsRealtime();
 watch(buildTick, () => {
-  void load(true);
+  void load(true).then(() => settleBuildStates());
 });
 const loadFailed = computed(() => !!error && !!error.value && !workflows.value.length);
 const createOpen = ref(false);
@@ -43,7 +58,11 @@ const createOpen = ref(false);
           </Button>
         </template>
       </StateCard>
-      <WorkflowsTable v-else :workflows="workflows" :loading="loading" />
+      <!-- `loading` is the composable's app-wide flag and goes up for every read, the
+           build watch's included — so passing it straight through would flip the table
+           between its skeleton and its empty text every few seconds while a build
+           runs. What the table's skeleton means is "nothing to show yet". -->
+      <WorkflowsTable v-else :workflows="workflows" :loading="loading && !workflows.length" />
     </div>
 
     <WorkflowCreateDialog v-model:open="createOpen" />