@revenexx/studio-integrations 0.6.0 → 0.7.0

package/dist/runtime/composables/useIntegrationsRealtime.js

@@ -0,0 +1,80 @@
+import { computed, effectScope, ref, shallowRef } from "vue";
+export const RUN_TOPIC = "revenexx.integrations.run";
+export const WORKFLOW_TOPIC = "revenexx.integrations.workflow";
+export const BUILD_TOPIC = "revenexx.integrations.build";
+export const RUN_ACTIONS = ["created", "started", "finished", "failed", "cancelled"];
+export const WORKFLOW_ACTIONS = ["created", "updated", "deleted"];
+export const BUILD_ACTIONS = ["started", "succeeded", "failed"];
+export function toRealtimeEvent(envelope) {
+  const topic = typeof envelope.topic === "string" ? envelope.topic : "";
+  const topicId = envelope.topic_id;
+  const data = envelope.data;
+  return {
+    id: typeof envelope.id === "string" ? envelope.id : "",
+    action: topic.split(".")[3] ?? "",
+    topicId: topicId === null || topicId === void 0 ? null : String(topicId),
+    data: data !== null && typeof data === "object" ? data : {}
+  };
+}
+export function workflowIdOf(event) {
+  const id = event?.data.workflow_id;
+  return typeof id === "string" && id ? id : null;
+}
+const runTick = ref(0);
+const workflowTick = ref(0);
+const buildTick = ref(0);
+const lastRunEvent = shallowRef(null);
+const lastWorkflowEvent = shallowRef(null);
+const lastBuildEvent = shallowRef(null);
+const deliveries = computed(() => runTick.value + workflowTick.value + buildTick.value);
+let scope = null;
+let openChannels = null;
+function onRun(envelope) {
+  lastRunEvent.value = toRealtimeEvent(envelope);
+  runTick.value++;
+}
+function onWorkflow(envelope) {
+  lastWorkflowEvent.value = toRealtimeEvent(envelope);
+  workflowTick.value++;
+}
+function onBuild(envelope) {
+  lastBuildEvent.value = toRealtimeEvent(envelope);
+  buildTick.value++;
+}
+function onRunGap() {
+  lastRunEvent.value = null;
+  runTick.value++;
+}
+function onWorkflowGap() {
+  lastWorkflowEvent.value = null;
+  workflowTick.value++;
+}
+function onBuildGap() {
+  lastBuildEvent.value = null;
+  buildTick.value++;
+}
+export function useIntegrationsRealtime() {
+  const { talkback, enabled } = usePlatformTalkback();
+  if (enabled && import.meta.client && !scope) {
+    scope = effectScope(true);
+    scope.run(() => {
+      const subs = [
+        ...RUN_ACTIONS.map((action) => useTalkbackTopic(`${RUN_TOPIC}.${action}`, { handler: onRun, onResync: onRunGap })),
+        ...WORKFLOW_ACTIONS.map((action) => useTalkbackTopic(`${WORKFLOW_TOPIC}.${action}`, { handler: onWorkflow, onResync: onWorkflowGap })),
+        ...BUILD_ACTIONS.map((action) => useTalkbackTopic(`${BUILD_TOPIC}.${action}`, { handler: onBuild, onResync: onBuildGap }))
+      ];
+      openChannels = computed(() => subs.map((s) => s.channel.value).filter((c) => !!c));
+    });
+  }
+  const channels = computed(() => openChannels?.value ?? []);
+  return {
+    delivering: computed(() => deliveries.value > 0 && enabled && !!talkback.value && channels.value.length > 0),
+    runTick,
+    workflowTick,
+    buildTick,
+    lastRunEvent,
+    lastWorkflowEvent,
+    lastBuildEvent,
+    channels
+  };
+}

package/dist/runtime/composables/useIntegrationsRevisions.js

@@ -1,8 +1,10 @@
 import { ref } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 export function useIntegrationsRevisions() {
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   const loading = ref(false);
   const error = ref(null);
   function captureError(e, fallback) {
@@ -16,7 +18,7 @@ export function useIntegrationsRevisions() {
       const res = await api.get(`/workflows/${workflowId}/revisions?page=${page}&per_page=${perPage}`);
       return { revisions: res.data ?? [], meta: res.meta };
     } catch (e) {
-      error.value = captureError(e, "Could not load the revision history.");
+      error.value = captureError(e, t("integration.revisions.error.loadFailed"));
       throw e;
     } finally {
       loading.value = false;
@@ -25,12 +27,12 @@ export function useIntegrationsRevisions() {
   async function get(workflowId, revision) {
     const res = await api.get(`/workflows/${workflowId}/revisions/${revision}`);
     const apiBlob = res.blob ?? {};
-    const triggers = (res.triggers ?? []).map((t) => ({
-      id: t.handle ?? String(t.id ?? ""),
-      type: t.type,
-      name: typeof t.name === "string" ? t.name : t.name ?? void 0,
-      active: t.active,
-      config: t.config ?? {}
+    const triggers = (res.triggers ?? []).map((t2) => ({
+      id: t2.handle ?? String(t2.id ?? ""),
+      type: t2.type,
+      name: typeof t2.name === "string" ? t2.name : t2.name ?? void 0,
+      active: t2.active,
+      config: t2.config ?? {}
     }));
     return {
       ...res,

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

@@ -24,7 +24,7 @@ export declare function useIntegrationsRuns(): {
     }) => WorkflowRun[];
     get: (id: string) => WorkflowRun | null;
     fetchRun: (workflowId: number | string, runId: number | string, workflowName: string) => Promise<WorkflowRun>;
-    trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "sync" | "async") => Promise<unknown>;
+    trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "async" | "sync") => Promise<unknown>;
     cancelRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     terminateRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     retryRun: (workflowId: number | string, runId: number | string) => Promise<unknown>;

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -1,5 +1,6 @@
 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";
 function mapStatus(status) {
@@ -33,6 +34,7 @@ export function useIntegrationsRuns() {
   const gate = useLoadGate("integrations.runs", { loading, loaded });
   const SYNC_LIMIT = 5;
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
   function mapRun(r, workflowName) {
     const startedMs = r.started_at ? new Date(r.started_at).getTime() : null;
@@ -99,7 +101,7 @@ export function useIntegrationsRuns() {
       }
       loaded.value = workflowsLoaded.value && perWorkflow.every((p) => p.status === "fulfilled");
     } catch (e) {
-      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load runs.";
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
     } finally {
       gate.release();
     }

package/dist/runtime/composables/useIntegrationsSecrets.js

@@ -1,5 +1,6 @@
 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_]+$/;
@@ -10,6 +11,7 @@ export function useIntegrationsSecrets() {
   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);
   }
@@ -35,7 +37,7 @@ export function useIntegrationsSecrets() {
       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 {
       gate.release();
     }
@@ -47,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>;
-    startingPoints: 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

@@ -84,7 +84,14 @@ 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);
@@ -101,11 +108,13 @@ export function useIntegrationsTemplates() {
     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 {
       gate.release();
@@ -116,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;
     }

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -1,4 +1,5 @@
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
 export function useIntegrationsTriggers() {
@@ -7,6 +8,7 @@ export function useIntegrationsTriggers() {
   const error = useState("integrations.triggers.error", () => null);
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
   const gate = useLoadGate("integrations.triggers", { loading, loaded });
   function unwrapList(res) {
@@ -22,12 +24,12 @@ export function useIntegrationsTriggers() {
     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 = 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 {
       gate.release();
     }

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -1,5 +1,6 @@
 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";
@@ -83,6 +84,7 @@ export function useIntegrationsWorkflows() {
   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;
   }
@@ -102,7 +104,7 @@ export function useIntegrationsWorkflows() {
       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 {
       gate.release();
     }
@@ -134,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 ?? []) {
@@ -170,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/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/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;

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

@@ -35,6 +35,15 @@ export declare const TEMPLATE_CATEGORIES: Array<{
  * category the studio has never been taught still gets a chip, named as well as it
  * can be rather than dropped. That guarantee held on the gallery alone before; it
  * now holds on all four.
+ *
+ * `specs/templates.md` AC-8 splits this in two: the first half — a category the
+ * studio *does* have a name for — is the studio's own word, and can follow the
+ * reader's language; the second half — the registry's own key, capitalised — never
+ * can, because a bare key carries no text to read in any language. Only the first
+ * half goes through `useIntegrationsT()`. A message missing from the catalogue
+ * (this key not merged into `messages/*.json` yet) falls back to the same English
+ * word `TEMPLATE_CATEGORIES` always carried, so the label degrades to "correct but
+ * unlocalised" rather than to the raw key.
  */
 export declare function templateCategoryLabel(key: string): string;
 /**

package/dist/runtime/data/integrationTemplates.js

@@ -1,3 +1,4 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 export const TEMPLATE_CATEGORIES = [
   // Uniform muted pill — the label carries the meaning, no rainbow needed.
   { key: "commerce", label: "Commerce", color: "bg-slate-100 text-slate-700" },
@@ -12,7 +13,12 @@ export const TEMPLATE_CATEGORIES = [
 export function templateCategoryLabel(key) {
   if (!key) return "";
   const known = TEMPLATE_CATEGORIES.find((c) => c.key === key);
-  if (known) return known.label;
+  if (known) {
+    const t = useIntegrationsT();
+    const messageKey = `integration.templates.category.${known.key}`;
+    const translated = t(messageKey);
+    return translated === messageKey ? known.label : translated;
+  }
   return key.charAt(0).toUpperCase() + key.slice(1);
 }
 export function templatePackageLabel(tpl) {

package/dist/runtime/data/payloadForm.js

@@ -1,3 +1,4 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 const PAYLOAD_REF_RE = /\$\{\{\s*trigger\.payload\.([a-zA-Z0-9_.-]+)/g;
 const FILE_KEYS = /* @__PURE__ */ new Set(["data", "filename", "contentType", "size"]);
 function collectRefs(value, out) {
@@ -49,7 +50,7 @@ export function payloadFieldsFromBlob(blob) {
         }
         continue;
       }
-      fields.push({ kind: "file", path: prefix, label: prefix === "" ? "File" : labelFor(prefix) });
+      fields.push({ kind: "file", path: prefix, label: prefix === "" ? useIntegrationsT()("integration.common.label.file") : labelFor(prefix) });
       for (const leaf of leaves) {
         if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
       }

package/dist/runtime/data/workflowIconCatalog.js

@@ -99,6 +99,7 @@ export function freshImageSrc(stored) {
   return null;
 }
 export function nodeLogoOptions() {
+  const t = useIntegrationsT();
   const byId = /* @__PURE__ */ new Map();
   for (const m of INTEGRATION_NODE_CATALOG) {
     const imgs = m.images ?? [];
@@ -107,7 +108,7 @@ export function nodeLogoOptions() {
     const id = imageIdFromSrc(logo.src) ?? logo.src;
     if (byId.has(id)) continue;
     const label = m.__package?.label || (m.groups?.length ? resolveLocalized(m.groups[0]) : "") || resolveLocalized(m.name);
-    byId.set(id, { label: label || "Integration", src: logo.src });
+    byId.set(id, { label: label || t("integration.workflows.iconCatalog.label.fallback"), src: logo.src });
   }
   return [...byId.entries()].map(([id, v]) => ({ id, src: v.src, label: v.label })).sort((a, b) => a.label.localeCompare(b.label));
 }