@revenexx/studio-integrations 0.5.1 → 0.7.0

package/dist/runtime/composables/useIntegrationsSecrets.js

@@ -1,40 +1,45 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
+import { useLoadGate } from "./useLoadGate.js";
 const KEY_PATTERN = /^[A-Z0-9_]+$/;
 export function useIntegrationsSecrets() {
   const secrets = useState("integrations.secrets", () => []);
   const loading = useState("integrations.secrets.loading", () => false);
   const error = useState("integrations.secrets.error", () => null);
   const loaded = useState("integrations.secrets.loaded", () => false);
+  const gate = useLoadGate("integrations.secrets", { loading, loaded });
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   function isValidKey(key) {
     return KEY_PATTERN.test(key);
   }
   function normalize(res) {
     const obj = res;
+    if (Array.isArray(obj?.data)) return obj.data.map(toRecord);
+    if (Array.isArray(obj?.secrets)) return obj.secrets.map(toRecord);
     if (Array.isArray(obj?.keys)) return obj.keys.map((key) => ({ key, created_at: "", updated_at: "" }));
-    if (Array.isArray(obj?.data)) return obj.data;
-    if (Array.isArray(obj?.secrets)) return obj.secrets;
-    if (Array.isArray(res)) return res;
+    if (Array.isArray(res)) return res.map(toRecord);
     return [];
   }
+  function toRecord(r) {
+    return { key: r.key ?? "", created_at: r.created_at ?? "", updated_at: r.updated_at ?? "" };
+  }
   function captureError(e, fallback) {
     if (e instanceof IntegrationsApiError) return e.message;
     return e?.message ?? fallback;
   }
   async function load(force = false) {
-    if (loading.value) return secrets.value;
-    if (loaded.value && !force) return secrets.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return secrets.value;
     error.value = null;
     try {
       secrets.value = normalize(await api.get("/secrets"));
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load secrets.");
+      error.value = captureError(e, t("integration.secrets.error.loadFailed"));
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return secrets.value;
   }
@@ -44,7 +49,7 @@ export function useIntegrationsSecrets() {
   }
   async function upsert(key, value) {
     if (!isValidKey(key)) {
-      throw new Error("Key must match ^[A-Z0-9_]+$");
+      throw new Error(t("integration.secrets.error.invalidKey"));
     }
     const created = !secrets.value.some((s) => s.key === key);
     await api.post("/secrets", { key, value });

package/dist/runtime/composables/useIntegrationsT.d.ts

@@ -0,0 +1,35 @@
+import type { ComputedRef } from 'vue';
+import type { Translate } from '../i18n/translate.js';
+/**
+ * `useIntegrationsT()` — the studio's own interface strings.
+ *
+ *   const t = useIntegrationsT()
+ *   t('integration.dashboard.runs.title')
+ *   t('integration.dashboard.attention.missedRuns', missed.length)
+ *   t('integration.credentials.toast.deleted', { name: credential.name })
+ *
+ * Returns `t` directly rather than `{ t }`, matching `useT()` in
+ * `@revenexx/studio-shared`. It is **not** that function: `useT()` asks the
+ * host's catalogue, which has no `integration.*` keys in it, so this module
+ * reads its own (`runtime/i18n/messages/*.json`) instead. The names differ on
+ * purpose — studio-shared registers a global auto-import called `useT`, and two
+ * modules claiming one name is a silent, one-wins collision.
+ *
+ * Not a composable in the reactive-state sense: no component instance is
+ * needed, so it may be called from a plain helper or outside `setup()`.
+ *
+ * **Reactivity is on the caller.** `t()` reads the language at call time, so
+ * anything evaluated once — a `const TABS = [...]` at module or setup scope —
+ * keeps whatever language was current when the file loaded. Put it in a
+ * `computed()`. That is the one way to ship this looking finished and have it
+ * not switch.
+ */
+export declare function useIntegrationsT(): Translate;
+/**
+ * The language the studio's chrome is rendering in, as a `ComputedRef`.
+ *
+ * For the rare case that needs the tag itself — an `Intl` format, a `lang`
+ * attribute — rather than a translated string. To *set* it, that is
+ * `useIntegrationsLocale()`, which is the host's seam.
+ */
+export declare function useIntegrationsUiLocale(): ComputedRef<string>;

package/dist/runtime/composables/useIntegrationsT.js

@@ -0,0 +1,9 @@
+import { computed } from "vue";
+import { studioLocale } from "../utils/localize.js";
+import { translate } from "../i18n/translate.js";
+export function useIntegrationsT() {
+  return translate;
+}
+export function useIntegrationsUiLocale() {
+  return computed(() => studioLocale());
+}

package/dist/runtime/composables/useIntegrationsTemplates.d.ts

@@ -1,11 +1,11 @@
 import type { TemplateRequirements, WorkflowTemplate } from '../types/integrations.js';
 export declare function useIntegrationsTemplates(): {
-    templates: any;
+    templates: import("vue").ComputedRef<WorkflowTemplate[]>;
     loaded: any;
     loading: any;
     error: any;
-    total: import("vue").ComputedRef<any>;
-    popular: import("vue").ComputedRef<any[]>;
+    total: import("vue").ComputedRef<number>;
+    startingPoints: import("vue").ComputedRef<WorkflowTemplate[]>;
     load: (force?: boolean) => Promise<WorkflowTemplate[]>;
     list: () => WorkflowTemplate[];
     get: (slug: string) => WorkflowTemplate | null;

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -2,6 +2,7 @@ import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { resolveLocalized } from "../utils/localize.js";
+import { useLoadGate } from "./useLoadGate.js";
 const BLOB_VERSION = "v0-draft";
 const INDUSTRY_VALUES = ["mechanical-engineering", "chemicals", "wholesale", "manufacturing", "retail", "any"];
 function plainExcerpt(md) {
@@ -34,14 +35,18 @@ function mapListItem(api) {
     triggerTypes: api.triggerTypes ?? [],
     images: api.images ?? [],
     package: api.package ? { name: api.package.name, label: api.package.label ?? null } : null,
-    category: api.category ?? "sync",
+    // The registry documents this field as free-form and returns it as nullable,
+    // so "no category" is a state and not an error. It used to become `sync` —
+    // a category nothing publishes, so the studio was badging a template with a
+    // name no publisher had chosen. Empty travels instead, and every surface that
+    // draws a chip leaves it out rather than filling it in (PO-243).
+    category: api.category || "",
     industries: mapIndustries(api.industries),
     vendors: api.vendors ?? [],
     requiredSecrets: [],
     level: api.level ?? "beginner",
     outline: [],
     nodeCount: 0,
-    installs: 0,
     publisher: publisherFor(api.slug, api.vendors ?? []),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     blob: emptyBlob(resolveLocalized(api.name)),
@@ -79,10 +84,18 @@ function applyDetail(base, api) {
   };
 }
 export function useIntegrationsTemplates() {
-  const templates = useState("integrations.templates", () => []);
+  const t = useIntegrationsT();
+  const rawList = useState("integrations.templates.raw", () => []);
+  const rawDetails = useState("integrations.templates.rawDetails", () => ({}));
+  const templates = computed(() => rawList.value.map((item) => {
+    const base = mapListItem(item);
+    const detail = rawDetails.value[item.slug];
+    return detail ? applyDetail(base, detail) : base;
+  }));
   const loaded = useState("integrations.templates.loaded", () => false);
   const loading = useState("integrations.templates.loading", () => false);
   const error = useState("integrations.templates.error", () => null);
+  const gate = useLoadGate("integrations.templates", { loading, loaded });
   const api = useIntegrationsApi();
   function unwrap(res) {
     return res?.data ?? res;
@@ -91,20 +104,20 @@ export function useIntegrationsTemplates() {
     return e instanceof IntegrationsApiError ? e.message : e?.message ?? fallback;
   }
   async function load(force = false) {
-    if (loading.value) return templates.value;
-    if (loaded.value && !force) return templates.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return templates.value;
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/templates")) ?? [];
-      templates.value = list2.map(mapListItem);
+      rawList.value = list2;
+      rawDetails.value = {};
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load templates.");
-      templates.value = [];
+      error.value = captureError(e, t("integration.templates.state.error.fallback"));
+      rawList.value = [];
+      rawDetails.value = {};
       loaded.value = true;
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return templates.value;
   }
@@ -112,16 +125,15 @@ export function useIntegrationsTemplates() {
     return templates.value;
   }
   function get(slug) {
-    return templates.value.find((t) => t.slug === slug) ?? null;
+    return templates.value.find((t2) => t2.slug === slug) ?? null;
   }
   async function fetchDetail(slug) {
     const base = get(slug);
     if (!base?.fromApi) return base;
     try {
       const detail = unwrap(await api.get(`/templates/${slug}`));
-      const merged = applyDetail(base, detail);
-      templates.value = templates.value.map((t) => t.slug === slug ? merged : t);
-      return merged;
+      rawDetails.value = { ...rawDetails.value, [slug]: detail };
+      return get(slug);
     } catch {
       return base;
     }
@@ -165,6 +177,6 @@ export function useIntegrationsTemplates() {
     return instantiate(slug);
   }
   const total = computed(() => templates.value.length);
-  const popular = computed(() => [...templates.value].sort((a, b) => b.installs - a.installs).slice(0, 4));
-  return { templates, loaded, loading, error, total, popular, load, list, get, fetchDetail, ensureDetails, requirements, instantiate, install };
+  const startingPoints = computed(() => templates.value.slice(0, 4));
+  return { templates, loaded, loading, error, total, startingPoints, load, list, get, fetchDetail, ensureDetails, requirements, instantiate, install };
 }

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -1,12 +1,16 @@
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
+import { useLoadGate } from "./useLoadGate.js";
 export function useIntegrationsTriggers() {
   const all = useState("integrations.triggers.all", () => []);
   const loading = useState("integrations.triggers.loading", () => false);
   const error = useState("integrations.triggers.error", () => null);
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
-  const { workflows, load: loadWorkflows } = useIntegrationsWorkflows();
+  const t = useIntegrationsT();
+  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
+  const gate = useLoadGate("integrations.triggers", { loading, loaded });
   function unwrapList(res) {
     if (Array.isArray(res)) return res;
     return res?.data ?? [];
@@ -15,21 +19,19 @@ export function useIntegrationsTriggers() {
     return unwrapList(await api.get(`/workflows/${workflowId}/triggers`));
   }
   async function loadAll(force = false) {
-    if (loading.value) return all.value;
-    if (loaded.value && !force) return all.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return all.value;
     error.value = null;
     try {
       await loadWorkflows();
       const settled = await Promise.allSettled(
-        workflows.value.map(async (wf) => (await list(wf.id)).map((t) => ({ ...t, workflowName: wf.name })))
+        workflows.value.map(async (wf) => (await list(wf.id)).map((t2) => ({ ...t2, workflowName: wf.name })))
       );
       all.value = settled.flatMap((p) => p.status === "fulfilled" ? p.value : []);
-      loaded.value = true;
+      loaded.value = workflowsLoaded.value && settled.every((p) => p.status === "fulfilled");
     } catch (e) {
-      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load triggers.";
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.triggers.error.loadFailed");
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return all.value;
   }

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -1,6 +1,8 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
+import { useLoadGate } from "./useLoadGate.js";
 const BLOB_VERSION = "v0-draft";
 function toCockpit(api) {
   const apiBlob = api.blob ?? {};
@@ -35,6 +37,10 @@ function toCockpit(api) {
     execution_mode: api.execution_mode,
     buildStatus: api.build_status ?? null,
     buildError: api.build_error ?? null,
+    // Carried through as-is: `undefined` (e.g. the list response, which omits
+    // it) means "unknown", NOT "valid" — callers must fail open and only gate
+    // activation on a non-empty array.
+    warnings: api.warnings,
     created_at: api.created_at ?? "",
     updated_at: api.updated_at ?? ""
   };
@@ -76,7 +82,9 @@ export function useIntegrationsWorkflows() {
   const loading = useState("integrations.workflows.loading", () => false);
   const error = useState("integrations.workflows.error", () => null);
   const loaded = useState("integrations.workflows.loaded", () => false);
+  const gate = useLoadGate("integrations.workflows", { loading, loaded });
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   function unwrap(res) {
     return res?.data ?? res;
   }
@@ -89,18 +97,16 @@ export function useIntegrationsWorkflows() {
     workflows.value = idx < 0 ? [...workflows.value, wf] : workflows.value.map((w) => w.id === wf.id ? wf : w);
   }
   async function load(force = false) {
-    if (loading.value) return workflows.value;
-    if (loaded.value && !force) return workflows.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return workflows.value;
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/workflows")) ?? [];
       workflows.value = list2.map(toCockpit);
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load workflows.");
+      error.value = captureError(e, t("integration.workflows.error.loadFailed"));
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return workflows.value;
   }
@@ -130,7 +136,7 @@ export function useIntegrationsWorkflows() {
   }
   async function duplicate(id, name) {
     const source = await get(id);
-    if (!source) throw new Error("Workflow not found.");
+    if (!source) throw new Error(t("integration.workflows.error.notFound"));
     const blob = JSON.parse(JSON.stringify(source.blob));
     const handleMap = /* @__PURE__ */ new Map();
     for (const trigger of blob.triggers ?? []) {
@@ -166,7 +172,7 @@ export function useIntegrationsWorkflows() {
         lastError = err;
       }
     }
-    throw lastError instanceof Error ? lastError : new Error("Could not duplicate the workflow.");
+    throw lastError instanceof Error ? lastError : new Error(t("integration.workflows.error.duplicateFailed"));
   }
   async function update(id, patch) {
     const wf = toCockpit(unwrap(await api.put(`/workflows/${id}`, toPayload({

package/dist/runtime/composables/useLoadGate.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type { LoadGate } from '../utils/loadGate.js';
+/**
+ * A composable's load gate, keyed by the namespace its own state already uses:
+ * `useLoadGate('integrations.triggers', { loading, loaded })`.
+ *
+ * The rule lives in `utils/loadGate.ts`; this is the wiring, and the wiring is the
+ * reason it is a composable. The counters have to share the flag's fate — one per
+ * Nuxt app on the client, one per request on the server — so they are `useState`
+ * like the flag itself. A module-level counter would be shared between two
+ * concurrent server-rendered requests, and then one tenant's finished load would
+ * answer another tenant's forced caller.
+ */
+export declare function useLoadGate(key: string, flags: {
+    loading: Ref<boolean>;
+    loaded?: Ref<boolean>;
+}): LoadGate;

package/dist/runtime/composables/useLoadGate.js

@@ -0,0 +1,8 @@
+import { createLoadGate } from "../utils/loadGate.js";
+export function useLoadGate(key, flags) {
+  return createLoadGate({
+    ...flags,
+    started: useState(`${key}.started`, () => 0),
+    finished: useState(`${key}.finished`, () => 0)
+  });
+}

package/dist/runtime/composables/useNodeConfigResolve.js

@@ -15,7 +15,8 @@ export function isResolvableValue(v) {
 }
 function classifyError(err) {
   const status = err instanceof IntegrationsApiError ? err.status : void 0;
-  const message = err instanceof IntegrationsApiError ? err.message : err?.message ?? "Resolve failed";
+  const t = useIntegrationsT();
+  const message = err instanceof IntegrationsApiError ? err.message : err?.message ?? t("integration.nodeConfig.resolve.error.generic");
   let kind;
   switch (status) {
     case 409:

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

@@ -0,0 +1,37 @@
+/**
+ * Pure core of the tidy-up branch reorder (see WorkflowEditor's
+ * `reorderBranchesByHandle`): given laid-out node positions and the outgoing
+ * edges tagged with their output-port index, compute the x moves that put
+ * each source's branch subtrees into handle order.
+ *
+ * dagre places nodes as points and is blind to which output HANDLE an edge
+ * leaves from, so a node's branches can land in the opposite left-to-right
+ * order to their handles and cross right under the node. Only self-contained,
+ * pairwise-disjoint subtrees are moved — a reconverging branch (diamond,
+ * shared descendant, outside parent) leaves the whole node untouched rather
+ * than corrupted. Idempotent: an already-ordered node yields no moves.
+ *
+ * The crossing is owned by the direct CHILD NODE's own x, not the subtree's
+ * extent: dagre centres a node over its (possibly wide) subtree, so a spine —
+ * a long main chain where each step also hangs off a short error/leaf branch —
+ * puts the leaf to the LEFT while the continuation node sits at its subtree's
+ * centre to the right, crossing out/error even though the two subtrees never
+ * share a node. So we reorder by the child nodes' positions: the children keep
+ * exactly the set of x slots they already occupy, re-slotted into handle order.
+ * That's a pure permutation — the rank's footprint (and the source's centre
+ * over it) is preserved and no branch is flung wide, whatever its subtree size.
+ *
+ * Kept free of vue-flow/component state so it can be unit-tested against
+ * hand-built graphs.
+ */
+export interface ReorderNode {
+    x: number;
+}
+export interface ReorderEdge {
+    source: string;
+    target: string;
+    /** Left-to-right index of the source's output handle this edge leaves from. */
+    portIndex: number;
+}
+/** Node id → new x, for exactly the nodes that need to move. */
+export declare function reorderBranchSubtrees(nodes: Map<string, ReorderNode>, edges: ReorderEdge[]): Map<string, number>;

package/dist/runtime/data/branchReorder.js

@@ -0,0 +1,71 @@
+export function reorderBranchSubtrees(nodes, edges) {
+  const inGraph = (e) => nodes.has(e.source) && nodes.has(e.target);
+  const children = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!inGraph(e)) continue;
+    (children.get(e.source) ?? (children.set(e.source, []), children.get(e.source))).push(e.target);
+    (parents.get(e.target) ?? (parents.set(e.target, []), parents.get(e.target))).push(e.source);
+  }
+  const subtreeOf = (root) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length) {
+      const v = stack.pop();
+      if (seen.has(v)) continue;
+      seen.add(v);
+      for (const c of children.get(v) ?? []) if (!seen.has(c)) stack.push(c);
+    }
+    return seen;
+  };
+  const branchesBySource = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!inGraph(e)) continue;
+    const byTarget = branchesBySource.get(e.source) ?? (branchesBySource.set(e.source, /* @__PURE__ */ new Map()), branchesBySource.get(e.source));
+    byTarget.set(e.target, Math.min(byTarget.get(e.target) ?? Infinity, e.portIndex));
+  }
+  const moved = /* @__PURE__ */ new Map();
+  const xOf = (id) => moved.get(id) ?? nodes.get(id).x;
+  for (const [source, byTarget] of branchesBySource) {
+    const targets = [...byTarget].map(([target, idx]) => ({ target, idx }));
+    if (targets.length < 2) continue;
+    const subtrees = new Map(targets.map((t) => [t.target, subtreeOf(t.target)]));
+    let safe = true;
+    const union = /* @__PURE__ */ new Set();
+    outer: for (const t of targets) {
+      const st = subtrees.get(t.target);
+      if (st.has(source)) {
+        safe = false;
+        break;
+      }
+      for (const m of st) {
+        if (union.has(m)) {
+          safe = false;
+          break outer;
+        }
+        union.add(m);
+        for (const p of parents.get(m) ?? []) {
+          if (p !== source && !st.has(p)) {
+            safe = false;
+            break outer;
+          }
+        }
+      }
+    }
+    if (!safe) continue;
+    const desired = [...targets].sort((a, b) => a.idx - b.idx || a.target.localeCompare(b.target));
+    const current = [...targets].sort((a, b) => xOf(a.target) - xOf(b.target) || a.target.localeCompare(b.target));
+    if (current.every((t, i) => t.target === desired[i].target)) continue;
+    const slots = current.map((t) => xOf(t.target));
+    for (let i = 0; i < desired.length; i++) {
+      const target = desired[i].target;
+      const dx = slots[i] - xOf(target);
+      if (dx !== 0) {
+        for (const m of subtrees.get(target)) {
+          moved.set(m, xOf(m) + dx);
+        }
+      }
+    }
+  }
+  return moved;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Reading the logical port name out of a canvas handle id.
+ *
+ * Each node on the canvas renders four connection points per port, one per
+ * side, so that an edge can leave and arrive without crossing a card body. The
+ * side rides along in the handle id as a `__<side>` suffix; the workflow blob
+ * stores only the port name. Everything that persists an edge, or reasons about
+ * which port an edge left from, has to read the name back out — and an id whose
+ * name is missing has to be told apart from one whose name is unusual.
+ *
+ * An output dot is `<port>__<side>`. A node's single input dot is `__in__<side>`
+ * and a group frame's is `__in__top`: the separator sits at the very front, so
+ * there is no port name in front of it. Those answer `null` — **not** the empty
+ * string, which is what a `slice(0, 0)` would hand back. Every caller writes
+ * `portFromHandleId(id) ?? 'default'`, and `??` does not fire on `''`, so an
+ * empty name would travel on past the fallback that exists to catch it.
+ *
+ * It lives here rather than in the editor because it is the one place that knows
+ * how to read an id, and because that is what makes it testable: the editor is
+ * an SFC, out of reach of the unit suite, and the defect above shipped once
+ * already without anything going red.
+ */
+export declare function portFromHandleId(handleId: string | null | undefined): string | null;

package/dist/runtime/data/handleId.js

@@ -0,0 +1,6 @@
+const SIDE_SUFFIX = /__(?:top|right|bottom|left)$/;
+export function portFromHandleId(handleId) {
+  if (!handleId) return null;
+  const name = handleId.replace(SIDE_SUFFIX, "");
+  return name.startsWith("__") || !name ? null : name;
+}

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

@@ -13,11 +13,52 @@ export declare function applyNodeCatalog(manifests: NodeManifest[]): void;
  * Categories rendered in the picker. Colors map to the L.I.D.F.
  * domain palette we use across the cockpit.
  */
+/**
+ * The catalogue's five top-level groups.
+ *
+ * `label` is the group's **stable English identity**, not display text: the
+ * palette matches a stack path back to a category by comparing against it, so
+ * translating it in place would break navigation the moment the language
+ * changed. Anything that puts a group name on screen calls
+ * {@link nodeCategoryLabel} instead.
+ */
 export declare const NODE_CATEGORIES: Array<{
     key: NodeManifest['category'];
     label: string;
     color: string;
 }>;
+/**
+ * A category's name for the reader, read at call time so it follows a language
+ * switch. Falls back to the English identity for a category the catalogue has
+ * no wording for — visible and usable, rather than a raw key.
+ */
+export declare function nodeCategoryLabel(key: NodeManifest['category'] | string | null | undefined): string;
+/** The trigger kinds the catalogue carries a word for, as a runtime value —
+ * `TriggerType` is a type and cannot be asked at runtime what it contains. */
+/**
+ * The trigger kinds the studio has a word for, in the order a reader is offered
+ * them. Exported for the same reason `RUN_STATUS_WORDS` is: the runs list narrows
+ * by trigger kind and needs the vocabulary it labels, not a second copy of it.
+ */
+export declare const TRIGGER_TYPE_WORDS: readonly ["manual", "schedule", "webhook", "event"];
+/**
+ * What a trigger's kind is called for the reader — `manual` as "Manual", and in
+ * German as "Manuell".
+ *
+ * Here rather than in a component because two surfaces say it: the trigger card
+ * on the canvas and the Trigger column of the runs list, which used to print the
+ * raw field and so read English under a German heading. One function is the same
+ * lesson `resolveLocalized` was built on — a word said in two places gets
+ * translated in one of them.
+ *
+ * The keys are `integration.common.triggerType.*`: they belong to neither
+ * surface, and the catalogue puts a word shared across surfaces under `common`.
+ *
+ * A kind the catalogue has no word for is returned as it came, the way
+ * `runStatusLabel` returns an unknown status: asking for the key would put the
+ * key itself on screen, because a missing message resolves to its own name.
+ */
+export declare function triggerTypeLabel(type: TriggerType | string | null | undefined): string;
 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

@@ -1,4 +1,5 @@
 import { reactive } from "vue";
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 export const INTEGRATION_NODE_CATALOG = reactive([]);
 export function applyNodeCatalog(manifests) {
   INTEGRATION_NODE_CATALOG.splice(0, INTEGRATION_NODE_CATALOG.length, ...manifests);
@@ -12,6 +13,19 @@ export const NODE_CATEGORIES = [
   { key: "transform", label: "Transforms", color: "bg-slate-100 text-amber-700/80" },
   { key: "control", label: "Control flow", color: "bg-slate-100 text-rose-600/80" }
 ];
+export function nodeCategoryLabel(key) {
+  const category = NODE_CATEGORIES.find((c) => c.key === key);
+  if (!category) return "";
+  return useIntegrationsT()(`integration.nodes.category.${category.key}`) || category.label;
+}
+export const TRIGGER_TYPE_WORDS = ["manual", "schedule", "webhook", "event"];
+const TRIGGER_TYPE_WORD_SET = new Set(TRIGGER_TYPE_WORDS);
+export function triggerTypeLabel(type) {
+  if (!type) return "";
+  const kind = String(type);
+  if (!TRIGGER_TYPE_WORD_SET.has(kind)) return kind;
+  return useIntegrationsT()(`integration.common.triggerType.${kind}`);
+}
 export function findManifest(slug, version) {
   const matches = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug);
   if (!matches.length) return null;