@revenexx/studio-integrations 0.6.0 → 1.0.0

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";
@@ -81,8 +82,10 @@ 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 apiTriggers = useState("integrations.workflows.apiTriggers", () => ({}));
   const gate = useLoadGate("integrations.workflows", { loading, loaded });
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   function unwrap(res) {
     return res?.data ?? res;
   }
@@ -90,6 +93,24 @@ export function useIntegrationsWorkflows() {
     if (e instanceof IntegrationsApiError) return e.message;
     return e?.message ?? fallback;
   }
+  function remember(api2, into) {
+    if (api2.triggers !== void 0) into[Number(api2.id)] = api2.triggers;
+  }
+  function ingest(api2) {
+    const next = { ...apiTriggers.value };
+    remember(api2, next);
+    apiTriggers.value = next;
+    return toCockpit(api2);
+  }
+  function ingestList(list2) {
+    const next = { ...apiTriggers.value };
+    const out = list2.map((api2) => {
+      remember(api2, next);
+      return toCockpit(api2);
+    });
+    apiTriggers.value = next;
+    return out;
+  }
   function upsertCache(wf) {
     const idx = workflows.value.findIndex((w) => w.id === wf.id);
     workflows.value = idx < 0 ? [...workflows.value, wf] : workflows.value.map((w) => w.id === wf.id ? wf : w);
@@ -99,10 +120,11 @@ export function useIntegrationsWorkflows() {
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/workflows")) ?? [];
-      workflows.value = list2.map(toCockpit);
+      workflows.value = ingestList(list2);
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load workflows.");
+      error.value = captureError(e, t("integration.workflows.error.loadFailed"));
+      loaded.value = false;
     } finally {
       gate.release();
     }
@@ -114,7 +136,7 @@ export function useIntegrationsWorkflows() {
   }
   async function get(id) {
     try {
-      const wf = toCockpit(unwrap(await api.get(`/workflows/${id}`)));
+      const wf = ingest(unwrap(await api.get(`/workflows/${id}`)));
       upsertCache(wf);
       return wf;
     } catch {
@@ -122,7 +144,7 @@ export function useIntegrationsWorkflows() {
     }
   }
   async function create(input) {
-    const wf = toCockpit(unwrap(await api.post("/workflows", toPayload({
+    const wf = ingest(unwrap(await api.post("/workflows", toPayload({
       name: input.name,
       description: input.description,
       blob: input.blob,
@@ -134,7 +156,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,10 +192,10 @@ 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({
+    const wf = ingest(unwrap(await api.put(`/workflows/${id}`, toPayload({
       name: patch.name,
       description: patch.description,
       blob: patch.blob,
@@ -199,6 +221,7 @@ export function useIntegrationsWorkflows() {
     loading,
     error,
     loaded,
+    apiTriggers,
     total,
     activeCount,
     load,

package/dist/runtime/composables/useNodeConfigResolve.js

@@ -1,4 +1,5 @@
 import { computed, onScopeDispose, ref, toValue, watch } from "vue";
+import { isVersionExecutable } from "../data/integrationNodeCatalog.js";
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 export function isResolvableValue(v) {
@@ -15,7 +16,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:
@@ -53,7 +55,7 @@ export function useNodeConfigResolve(opts) {
   });
   const gated = computed(() => unsatisfied.value.length > 0);
   const isEnabled = computed(
-    () => (toValue(opts.enabled) ?? true) && !gated.value && !!toValue(opts.slug) && !!toValue(opts.version)
+    () => (toValue(opts.enabled) ?? true) && isVersionExecutable(toValue(opts.slug), toValue(opts.version)) && !gated.value && !!toValue(opts.slug) && !!toValue(opts.version)
   );
   const subsetKey = computed(() => {
     const cfg = toValue(opts.config);

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

@@ -13,11 +13,74 @@ 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;
+/**
+ * Whether this exact node version can be executed — its code was built, so
+ * `execute:test` and `config:resolve` will not be refused (PO-338).
+ *
+ * Deliberately NOT `findManifest(...)?.__hasBundle !== false`: that helper falls
+ * back to the newest registered version when the pinned one is absent, so a node
+ * pinned to a withdrawn version would inherit a stranger's build state and every
+ * surface would then say something about a version the catalogue does not have.
+ * Only an exact match may answer, and anything else — unknown version, catalogue
+ * not loaded yet, a host whose API does not report the field — reads as
+ * executable, because the alternative is a studio that hides working nodes.
+ */
+export declare function isVersionExecutable(slug: string, version: string): boolean;
+/**
+ * The newest version of this node that can be executed, or `null` when none can.
+ *
+ * What a surface tells the operator to move to. The catalogue is semver-descending
+ * within a slug, so the first executable entry is the newest one. `null` where the
+ * whole node is unusable — then there is nothing to point at and the surface says
+ * only what is wrong.
+ */
+export declare function newestExecutableVersion(slug: string): string | null;
 export declare function findManifest(slug: string, version?: string): NodeManifest | null;
 export declare const TRIGGER_OUTPUT_PORT = "default";
 export interface TriggerTemplate {
@@ -34,7 +97,6 @@ export interface TriggerTemplate {
         en: string;
         de: string;
     };
-    icon: string;
     /** Default config the canvas seeds when the user drops the tile. */
     defaultConfig: Record<string, unknown>;
 }

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,27 @@ 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 isVersionExecutable(slug, version) {
+  const exact = INTEGRATION_NODE_CATALOG.find((m) => m.slug === slug && m.version === version);
+  return exact ? exact.__hasBundle !== false : true;
+}
+export function newestExecutableVersion(slug) {
+  const hit = INTEGRATION_NODE_CATALOG.find((m) => m.slug === slug && m.__hasBundle !== false);
+  return hit?.version ?? null;
+}
 export function findManifest(slug, version) {
   const matches = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug);
   if (!matches.length) return null;
@@ -28,7 +50,6 @@ export const TRIGGER_TEMPLATES = [
       en: "Start the workflow yourself with the Run button or an API call.",
       de: "Starte den Workflow selbst \xFCber den Run-Button oder einen API-Aufruf."
     },
-    icon: "Play",
     defaultConfig: {}
   },
   {
@@ -39,7 +60,6 @@ export const TRIGGER_TEMPLATES = [
       en: "Runs automatically on a schedule you define, for example every night.",
       de: "L\xE4uft automatisch nach deinem Zeitplan, zum Beispiel jede Nacht."
     },
-    icon: "Clock",
     defaultConfig: { cron: "0 * * * *", timezone: "Europe/Berlin" }
   },
   {
@@ -50,7 +70,6 @@ export const TRIGGER_TEMPLATES = [
       en: "Starts when an external system calls this workflow's URL.",
       de: "Startet, wenn ein externes System die URL dieses Workflows aufruft."
     },
-    icon: "Webhook",
     defaultConfig: { path: "/incoming", method: "POST" }
   },
   {
@@ -61,7 +80,6 @@ export const TRIGGER_TEMPLATES = [
       en: "Starts when something happens on the platform, for example a new customer.",
       de: "Startet, wenn auf der Plattform etwas passiert, zum Beispiel ein neuer Kunde."
     },
-    icon: "Zap",
     defaultConfig: { event_type: "" }
   }
 ];

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/nodeInputData.d.ts

@@ -1,4 +1,4 @@
-import type { NodeManifest, NodeManifestOutput, OutputKind, WorkflowEdge, WorkflowNode } from '../types/integrations.js';
+import type { LocalizedString, NodeManifest, NodeManifestOutput, OutputKind, WorkflowEdge, WorkflowNode } from '../types/integrations.js';
 /** `${{ nodes.<id>.outputs.<port> }}`, optionally narrowed to one field. */
 export declare function nodeOutputExpr(nodeId: string, port: string, field?: string): string;
 /** `${{ trigger.payload }}`, optionally narrowed to a path inside it. */
@@ -20,13 +20,70 @@ export interface FieldEntry {
     name: string;
     /** Declared data type (`string`, `number`, `boolean`, …) when the manifest carries one. */
     dataType: string | null;
+    /**
+     * What the publisher says this field holds, unresolved. Kept in the shape the
+     * manifest sent it so the language is chosen where it is drawn — see the note
+     * on {@link PortEntry.description}.
+     */
+    description?: LocalizedString;
 }
 export interface PortEntry {
     name: string;
     kind: OutputKind;
     /** Declared payload fields of this port (schema; may be empty). */
     fields: FieldEntry[];
+    /**
+     * What the publisher says flows through this port, **unresolved** — the
+     * localised map as the manifest sent it, not a string.
+     *
+     * Resolving here would pick the language at the moment the ports are derived,
+     * and these helpers are pure by design: their tests would then depend on the
+     * studio's locale, and a language switched afterwards would not reach a port
+     * list already computed. So the raw value travels and whoever draws it calls
+     * the resolver, which is how every other manifest string in the studio is
+     * read. Absent rather than null when the publisher wrote none: most do not,
+     * and an optional key keeps the derivation's shape honest about that.
+     */
+    description?: LocalizedString;
 }
+export interface InputPortEntry {
+    name: string;
+    /** Declared data type of what the node accepts here. */
+    dataType: string | null;
+    /**
+     * Whether an upstream connection is mandatory.
+     *
+     * Most manifests leave the key out, so the default decides what nearly every
+     * node claims. It is **the service's**, not ours: the node-manifest schema
+     * documents `required` as *"Whether an upstream connection is mandatory.
+     * Defaults to true."*, so an absent key is read as required and the chip says
+     * so. Reading it the other way would have the studio call a mandatory input
+     * optional on the strength of a key nobody wrote.
+     *
+     * It is a statement about what the type **declares**, not a rule anything
+     * enforces — nothing in the studio blocks a save over it, and the service's own
+     * blob validation checks that a named port exists rather than that it is fed.
+     */
+    required: boolean;
+    /** What the publisher says the node expects, unresolved — see {@link PortEntry.description}. */
+    description?: LocalizedString;
+}
+/**
+ * What a node accepts, read from the manifest's `inputs` map.
+ *
+ * **Two wire shapes, one of them a trap.** A node with named ports arrives as an
+ * object; a node that accepts nothing arrives as `[]`, because the service
+ * encodes an empty PHP array as a JSON array rather than an object. So the empty
+ * case has a different JSON *type* from the populated one, and reading it with
+ * `Object.entries` alone would work by luck rather than by intent. Both land here
+ * as an empty list.
+ *
+ * The studio read this under a singular `input` key until PO-216 — a shape the
+ * service has never sent and its schema forbids, so every input a node declared
+ * was invisible: the sentence, the data type, and whether a connection was
+ * mandatory at all.
+ */
+export declare function inputPortsForManifest(manifest: NodeManifest | null | undefined): InputPortEntry[];
 /**
  * A manifest declaring zero output ports describes a TERMINAL node (PO-201):
  * the run ends there, so it gets no output handle and no edge may leave it.

package/dist/runtime/data/nodeInputData.js

@@ -37,13 +37,38 @@ export function collectUpstreamNodes(selectedId, nodes, edges) {
 function fieldEntries(raw) {
   if (Array.isArray(raw)) return raw.map((v) => ({ name: String(v), dataType: null }));
   if (raw && typeof raw === "object") {
-    return Object.entries(raw).map(([name, spec]) => ({
-      name,
-      dataType: spec && typeof spec === "object" && typeof spec.dataType === "string" ? spec.dataType : null
-    }));
+    return Object.entries(raw).map(([name, spec]) => {
+      const s = spec && typeof spec === "object" ? spec : null;
+      return {
+        name,
+        dataType: typeof s?.dataType === "string" ? s.dataType : null,
+        ...describedBy(s?.description)
+      };
+    });
   }
   return [];
 }
+function describedBy(raw) {
+  if (typeof raw === "string") return raw.trim() ? { description: raw.trim() } : {};
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const entries = Object.entries(raw).filter((e) => typeof e[1] === "string" && e[1].trim() !== "").map(([k, v]) => [k, v.trim()]);
+    return entries.length ? { description: Object.fromEntries(entries) } : {};
+  }
+  return {};
+}
+export function inputPortsForManifest(manifest) {
+  const raw = manifest?.inputs;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
+  return Object.entries(raw).map(([name, spec]) => {
+    const s = spec && typeof spec === "object" ? spec : null;
+    return {
+      name,
+      dataType: typeof s?.dataType === "string" ? s.dataType : null,
+      required: s?.required !== false,
+      ...describedBy(s?.description)
+    };
+  });
+}
 export function isTerminalManifest(manifest) {
   return !!manifest && Array.isArray(manifest.outputs) && !manifest.outputs.length;
 }
@@ -53,7 +78,7 @@ export function portsForNode(node, manifest, resolvedOutputs) {
   const ports = [];
   for (const o of list) {
     if (o.name) {
-      ports.push({ name: o.name, kind: o.kind, fields: fieldEntries(o.fields) });
+      ports.push({ name: o.name, kind: o.kind, fields: fieldEntries(o.fields), ...describedBy(o.description) });
     } else if (o.sourceFromConfig) {
       const raw = node.config?.[o.sourceFromConfig];
       const values = Array.isArray(raw) ? raw : [];

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/triggerGlyphs.d.ts

@@ -0,0 +1,47 @@
+import type { Component } from 'vue';
+import type { TriggerType } from '../types/integrations.js';
+/**
+ * Trigger type → glyph, for every surface that draws one.
+ *
+ * Eight files drew a trigger's glyph, and they did it two ways. Five spelled the
+ * mapping out — the canvas card and the run replay panel as ternaries, the node
+ * inspector's header, the template card and the template detail page as records —
+ * and three did not carry a mapping at all: they resolved a glyph from Lucide by
+ * *name*, so no import mentioned one, in the node palette's trigger tiles (through
+ * `nodeIcon`), the create dialog's trigger select and the template flow preview
+ * (each through a local `iconFor`).
+ *
+ * They did not agree: a webhook was a globe on the templates page, a link on the
+ * canvas and Lucide's pretzel in the palette, so the same trigger changed shape
+ * three times on the way from picking it to seeing it. The replay panel's ternary
+ * had no `event` branch at all, so an event-triggered run drew the manual play
+ * button — wrong information, not a mismatch (PO-329).
+ *
+ * One map instead, and the reason it can be Solar's: `TRIGGER_TEMPLATES` is
+ * this repository's own catalogue, not a node manifest, so its `icon` strings
+ * ('Play', 'Clock', 'Webhook', 'Zap') were Lucide names by habit rather than by
+ * contract. The node-type icon map (`nodeIcons.ts`) is a different thing and
+ * stays Lucide deliberately — see `docs/icons.md`.
+ */
+export declare const TRIGGER_GLYPHS: Record<TriggerType, Component>;
+/**
+ * The glyph for a trigger type.
+ *
+ * The parameter is deliberately wider than `TriggerType`: some callers read the
+ * type out of a template blob or a run record, where the service may name a kind
+ * the studio has no word for yet — `templates/[slug].vue` is built for exactly
+ * that case and says so.
+ *
+ * Such a kind falls back to the **bolt**, not to the manual play button, which is
+ * what the templates surfaces did before this map existed. A play button asserts
+ * "you start this yourself", and for an unknown kind that is a claim rather than a
+ * gap; the bolt says only that something fires it.
+ *
+ * `Object.hasOwn`, not `?? Bolt` on its own: a plain object inherits
+ * `Object.prototype`, so a service that named a trigger kind `constructor` or
+ * `toString` would resolve to a function, the `??` would never fire, and the card
+ * would try to render `<component :is="Object">`. The `Lucide[name]` lookups this
+ * map replaced could not do that — a module namespace object has a null prototype
+ * — so the guard is what keeps the docstring above true rather than nearly true.
+ */
+export declare function triggerGlyph(type?: string | null): Component;

package/dist/runtime/data/triggerGlyphs.js

@@ -0,0 +1,11 @@
+import { Bolt, ClockCircle, LinkRound, Play } from "#solar-icons";
+export const TRIGGER_GLYPHS = {
+  manual: Play,
+  schedule: ClockCircle,
+  webhook: LinkRound,
+  event: Bolt
+};
+export function triggerGlyph(type) {
+  const key = String(type);
+  return Object.hasOwn(TRIGGER_GLYPHS, key) ? TRIGGER_GLYPHS[key] : Bolt;
+}

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));
 }