@revenexx/studio-integrations 0.1.3 → 0.2.0

package/dist/runtime/data/integrationNodeCatalog.js

@@ -25,8 +25,8 @@ export const TRIGGER_TEMPLATES = [
     type: "manual",
     name: { en: "Manual", de: "Manuell" },
     description: {
-      en: "Run on demand from the editor or API.",
-      de: "Auf Knopfdruck aus dem Editor oder via API."
+      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: {}
@@ -36,8 +36,8 @@ export const TRIGGER_TEMPLATES = [
     type: "schedule",
     name: { en: "Schedule", de: "Zeitplan" },
     description: {
-      en: "Cron-based recurring execution.",
-      de: "Wiederkehrende Ausf\xFChrung per Cron."
+      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" }
@@ -47,8 +47,8 @@ export const TRIGGER_TEMPLATES = [
     type: "webhook",
     name: { en: "Webhook", de: "Webhook" },
     description: {
-      en: "Trigger from an inbound HTTP request.",
-      de: "Ausl\xF6sen durch eingehenden HTTP-Aufruf."
+      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" }
@@ -58,8 +58,8 @@ export const TRIGGER_TEMPLATES = [
     type: "event",
     name: { en: "Event", de: "Event" },
     description: {
-      en: "Run when a platform event fires (e.g. customer.created).",
-      de: "Ausl\xF6sen bei einem Plattform-Event (z. B. customer.created)."
+      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/nodeInputData.d.ts

@@ -0,0 +1,37 @@
+import type { 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. */
+export declare function triggerPayloadExpr(path?: string): string;
+/** `${{ vars.<name> }}` */
+export declare function variableExpr(name: string): string;
+export interface UpstreamNodeRef {
+    node: WorkflowNode;
+    /** True when an edge feeds the selected node directly from this one. */
+    direct: boolean;
+}
+/**
+ * All nodes the selected node can reference, found by walking the edges
+ * backwards from it (breadth-first, nearest first, deduped, cycle-safe).
+ * Trigger sources are skipped — only workflow nodes are listed.
+ */
+export declare function collectUpstreamNodes(selectedId: string, nodes: WorkflowNode[], edges: WorkflowEdge[]): UpstreamNodeRef[];
+export interface FieldEntry {
+    name: string;
+    /** Declared data type (`string`, `number`, `boolean`, …) when the manifest carries one. */
+    dataType: string | null;
+}
+export interface PortEntry {
+    name: string;
+    kind: OutputKind;
+    /** Declared payload fields of this port (schema; may be empty). */
+    fields: FieldEntry[];
+}
+/**
+ * The output ports one upstream node exposes, mirroring the canvas port
+ * derivation: named ports map straight over, `sourceFromConfig` ports expand
+ * from the node's config values (plus the optional fallback), and a node
+ * without any resolvable port still gets its `default`. Server-resolved
+ * dynamic outputs, when present, replace the manifest's static list.
+ */
+export declare function portsForNode(node: WorkflowNode, manifest: NodeManifest | null, resolvedOutputs?: NodeManifestOutput[]): PortEntry[];

package/dist/runtime/data/nodeInputData.js

@@ -0,0 +1,62 @@
+const OPEN = "${{ ";
+const CLOSE = " }}";
+function wrap(inner) {
+  return OPEN + inner + CLOSE;
+}
+export function nodeOutputExpr(nodeId, port, field) {
+  return wrap("nodes." + nodeId + ".outputs." + port + (field ? "." + field : ""));
+}
+export function triggerPayloadExpr(path) {
+  return wrap("trigger.payload" + (path ? "." + path : ""));
+}
+export function variableExpr(name) {
+  return wrap("vars." + name);
+}
+export function collectUpstreamNodes(selectedId, nodes, edges) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const seen = /* @__PURE__ */ new Set([selectedId]);
+  const out = [];
+  let frontier = [selectedId];
+  let direct = true;
+  while (frontier.length > 0) {
+    const next = [];
+    for (const id of frontier) {
+      for (const e of edges) {
+        if (e.to.nodeId !== id || seen.has(e.from.nodeId)) continue;
+        seen.add(e.from.nodeId);
+        next.push(e.from.nodeId);
+        const node = byId.get(e.from.nodeId);
+        if (node && node.id !== selectedId) out.push({ node, direct });
+      }
+    }
+    frontier = next;
+    direct = false;
+  }
+  return out;
+}
+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 [];
+}
+export function portsForNode(node, manifest, resolvedOutputs) {
+  const list = resolvedOutputs?.length ? resolvedOutputs : manifest?.outputs ?? [];
+  const ports = [];
+  for (const o of list) {
+    if (o.name) {
+      ports.push({ name: o.name, kind: o.kind, fields: fieldEntries(o.fields) });
+    } else if (o.sourceFromConfig) {
+      const raw = node.config?.[o.sourceFromConfig];
+      const values = Array.isArray(raw) ? raw : [];
+      for (const v of values) ports.push({ name: String(v), kind: o.kind, fields: fieldEntries(o.fields) });
+      if (o.fallback) ports.push({ name: o.fallback.name, kind: o.kind, fields: fieldEntries(o.fields) });
+    }
+  }
+  if (!ports.length) ports.push({ name: "default", kind: "default", fields: [] });
+  return ports;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Pure helpers behind the workbench's sample-data layer: turning run-step
+ * outputs into per-port value maps, walking value paths, and resolving
+ * `${{ … }}` expressions against sampled data for the inline previews.
+ * Sample data is author-time sugar only — the engine never sees any of it.
+ */
+/**
+ * A run step's `output` payload is the node activity result — usually
+ * `{ outputs: { <port>: value }, branch? }`. Older/odd payloads may be the
+ * bare value; those count as the `default` port.
+ */
+export declare function portValuesFromStepOutput(output: unknown): Record<string, unknown>;
+/**
+ * Walk `root` along dot-path segments; `undefined` on any miss. Mirrors the
+ * ENGINE's resolver semantics exactly: an array auto-maps the remaining path
+ * over its elements (`items.sku` → array of skus) and numeric segments are
+ * NOT indices — the preview must predict what a run would produce.
+ */
+export declare function valueAtPath(root: unknown, path: string[]): unknown;
+/** Compact single-line preview of a sampled value, capped for chip display. */
+export declare function previewValue(v: unknown, max?: number): string;
+/** Map a sampled value onto the manifest dataType vocabulary (for glyphs). */
+export declare function dataTypeOf(v: unknown): string | null;
+export interface SampleContext {
+    /** nodeId → port → sampled payload (pinned sample or last-run output). */
+    nodeOutputs: Record<string, Record<string, unknown>>;
+    triggerPayload?: unknown;
+    variables?: Record<string, unknown>;
+}
+export interface ResolvedPreview {
+    /** The text with every resolvable token replaced by its sampled value. */
+    resolved: string;
+    /** Tokens that resolved against the sample context. */
+    hits: number;
+    /** Tokens the context has no data for (left in place). */
+    misses: number;
+}
+/**
+ * Resolve the `${{ … }}` tokens inside `text` against sampled data. Returns
+ * null when the text contains no tokens (nothing to preview). Unresolvable
+ * tokens stay verbatim and are counted as misses — the preview renders either
+ * way so the operator sees which part is still unknown.
+ */
+export declare function resolveExpressionText(text: string, ctx: SampleContext): ResolvedPreview | null;
+export interface ExpressionToken {
+    /** The full `${{ … }}` token as it appears in the text. */
+    token: string;
+    /** The trimmed inner expression. */
+    expr: string;
+    start: number;
+    end: number;
+}
+/** Every expression token inside `text`, with positions for splicing. */
+export declare function listExpressionTokens(text: string): ExpressionToken[];
+/** Resolve one bare expression (no braces) against the sample context. */
+export declare function resolveExpression(expr: string, ctx: SampleContext): unknown;

package/dist/runtime/data/nodeRunData.js

@@ -0,0 +1,91 @@
+const TOKEN_RE = new RegExp("\\$\\{\\{\\s*([^}]+?)\\s*\\}\\}", "g");
+export function portValuesFromStepOutput(output) {
+  if (output && typeof output === "object" && !Array.isArray(output)) {
+    const outputs = output.outputs;
+    if (outputs && typeof outputs === "object" && !Array.isArray(outputs)) {
+      return outputs;
+    }
+  }
+  if (output === void 0 || output === null) return {};
+  return { default: output };
+}
+export function valueAtPath(root, path) {
+  let cur = root;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (seg === "") return void 0;
+    if (Array.isArray(cur)) {
+      const rest = path.slice(i);
+      return cur.map((el) => valueAtPath(el, rest));
+    }
+    if (!cur || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+export function previewValue(v, max = 42) {
+  let s;
+  if (typeof v === "string") s = v;
+  else {
+    try {
+      s = JSON.stringify(v) ?? String(v);
+    } catch {
+      s = String(v);
+    }
+  }
+  s = s.replace(/\s+/g, " ");
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+export function dataTypeOf(v) {
+  if (v === null || v === void 0) return null;
+  if (Array.isArray(v)) return "array";
+  const t = typeof v;
+  if (t === "object") return "object";
+  if (t === "string" || t === "number" || t === "boolean") return t;
+  return null;
+}
+export function resolveExpressionText(text, ctx) {
+  let hits = 0;
+  let misses = 0;
+  let sawToken = false;
+  const resolved = text.replace(TOKEN_RE, (token, inner) => {
+    sawToken = true;
+    const value = resolveExpression(inner, ctx);
+    if (value === void 0) {
+      misses++;
+      return token;
+    }
+    hits++;
+    return typeof value === "string" ? value : previewValue(value, 200);
+  });
+  if (!sawToken) return null;
+  return { resolved, hits, misses };
+}
+export function listExpressionTokens(text) {
+  const re = new RegExp(TOKEN_RE.source, "g");
+  const out = [];
+  for (let m = re.exec(text); m !== null; m = re.exec(text)) {
+    out.push({ token: m[0], expr: (m[1] ?? "").trim(), start: m.index, end: m.index + m[0].length });
+  }
+  return out;
+}
+export function resolveExpression(expr, ctx) {
+  const path = expr.trim().split(".");
+  if (path[0] === "nodes" && path.length >= 4 && path[2] === "outputs") {
+    const ports = ctx.nodeOutputs[path[1]];
+    if (!ports) return void 0;
+    const port = path[3];
+    if (!(port in ports)) return void 0;
+    return valueAtPath(ports[port], path.slice(4));
+  }
+  if (path[0] === "trigger" && path[1] === "payload") {
+    if (ctx.triggerPayload === void 0) return void 0;
+    return valueAtPath(ctx.triggerPayload, path.slice(2));
+  }
+  if (path[0] === "vars" && path.length >= 2) {
+    const vars = ctx.variables ?? {};
+    if (!(path[1] in vars)) return void 0;
+    return valueAtPath(vars[path[1]], path.slice(2));
+  }
+  return void 0;
+}

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

@@ -0,0 +1,44 @@
+import type { WorkflowBlob } from '../types/integrations.js';
+/**
+ * Derives an input form for a manual run from the workflow blob itself: every
+ * `${{ trigger.payload.<path> }}` reference a node config carries becomes one
+ * form field — the workflow declares implicitly what it consumes, so no extra
+ * schema is needed and every existing template gets a form for free.
+ *
+ * File convention: a path group whose members include `data` (optionally
+ * `filename` / `contentType` / `size`) is rendered as ONE file field — picking
+ * a file fills the whole group (base64 + metadata), matching the workflow
+ * file-object shape the io/storage nodes consume.
+ */
+export interface PayloadField {
+    kind: 'text' | 'file';
+    /** Dot-path below `trigger.payload` ('' = the payload root, file groups only). */
+    path: string;
+    label: string;
+}
+/** Scan the blob's node configs and derive the payload form fields. */
+export declare function payloadFieldsFromBlob(blob: Pick<WorkflowBlob, 'nodes'>): PayloadField[];
+export declare function setPath(target: Record<string, unknown>, path: string, value: unknown): void;
+export declare function getPath(source: Record<string, unknown>, path: string): unknown;
+export interface AttachedFile {
+    data: string;
+    filename: string;
+    contentType: string;
+    size: number;
+}
+/**
+ * Build the run payload: expert-only extras first (preserved), then the form
+ * values on top. Text values that parse as JSON scalars/objects are passed
+ * typed (numbers stay numbers, `{"a":1}` becomes an object); everything else
+ * stays a string.
+ */
+export declare function buildPayload(fields: PayloadField[], textValues: Record<string, string>, files: Record<string, AttachedFile | null>, extras: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Split a payload object into form values + expert extras: known field paths
+ * feed the form, everything else is preserved verbatim for the expert view.
+ */
+export declare function splitPayload(fields: PayloadField[], payload: Record<string, unknown>): {
+    textValues: Record<string, string>;
+    files: Record<string, AttachedFile | null>;
+    extras: Record<string, unknown>;
+};

package/dist/runtime/data/payloadForm.js

@@ -0,0 +1,126 @@
+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) {
+  if (typeof value === "string") {
+    for (const m of value.matchAll(PAYLOAD_REF_RE)) out.add(m[1]);
+  } else if (Array.isArray(value)) {
+    for (const v of value) collectRefs(v, out);
+  } else if (value !== null && typeof value === "object") {
+    for (const v of Object.values(value)) collectRefs(v, out);
+  }
+}
+function labelFor(path) {
+  const last = path.split(".").pop() ?? path;
+  return last.replace(/[_-]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+export function payloadFieldsFromBlob(blob) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const node of blob.nodes ?? []) collectRefs(node.config, refs);
+  if (refs.size === 0) return [];
+  const byPrefix = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const idx = ref.lastIndexOf(".");
+    const prefix = idx === -1 ? "" : ref.slice(0, idx);
+    const leaf = idx === -1 ? ref : ref.slice(idx + 1);
+    if (!byPrefix.has(prefix)) byPrefix.set(prefix, /* @__PURE__ */ new Set());
+    byPrefix.get(prefix).add(leaf);
+  }
+  const fields = [];
+  const consumed = /* @__PURE__ */ new Set();
+  for (const [prefix, leaves] of byPrefix) {
+    if (leaves.has("data")) {
+      fields.push({ kind: "file", path: prefix, label: prefix === "" ? "File" : labelFor(prefix) });
+      for (const leaf of leaves) {
+        if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
+      }
+    }
+  }
+  for (const ref of [...refs].sort()) {
+    if (consumed.has(ref)) continue;
+    fields.push({ kind: "text", path: ref, label: labelFor(ref) });
+  }
+  return fields.sort((a, b) => a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === "file" ? -1 : 1);
+}
+export function setPath(target, path, value) {
+  if (path === "") {
+    if (value !== null && typeof value === "object") Object.assign(target, value);
+    return;
+  }
+  const parts = path.split(".");
+  let cursor = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    const next = cursor[key];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) cursor[key] = {};
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+export function getPath(source, path) {
+  if (path === "") return source;
+  let cursor = source;
+  for (const part of path.split(".")) {
+    if (cursor === null || typeof cursor !== "object") return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+export function buildPayload(fields, textValues, files, extras) {
+  const payload = JSON.parse(JSON.stringify(extras ?? {}));
+  for (const field of fields) {
+    if (field.kind === "file") {
+      const file = files[field.path];
+      if (file) setPath(payload, field.path, { ...file });
+      continue;
+    }
+    const raw = textValues[field.path];
+    if (raw === void 0 || raw === "") continue;
+    let value = raw;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "string") value = parsed;
+    } catch {
+    }
+    setPath(payload, field.path, value);
+  }
+  return payload;
+}
+export function splitPayload(fields, payload) {
+  const extras = JSON.parse(JSON.stringify(payload ?? {}));
+  const textValues = {};
+  const files = {};
+  const deleteAt = (path) => {
+    if (path === "") return;
+    const parts = path.split(".");
+    let cursor = extras;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (cursor === null || typeof cursor !== "object") return;
+      cursor = cursor[parts[i]];
+    }
+    if (cursor !== null && typeof cursor === "object") delete cursor[parts[parts.length - 1]];
+  };
+  for (const field of fields) {
+    const value = getPath(payload, field.path);
+    if (field.kind === "file") {
+      const data = value !== null && typeof value === "object" ? value.data : void 0;
+      if (typeof data === "string" && data !== "") {
+        const v = value;
+        files[field.path] = {
+          data,
+          filename: typeof v.filename === "string" ? v.filename : "file",
+          contentType: typeof v.contentType === "string" ? v.contentType : "application/octet-stream",
+          size: typeof v.size === "number" ? v.size : Math.floor(data.length * 3 / 4)
+        };
+      } else {
+        files[field.path] = null;
+      }
+      for (const key of FILE_KEYS) deleteAt(field.path === "" ? key : `${field.path}.${key}`);
+      continue;
+    }
+    if (value !== void 0) {
+      textValues[field.path] = typeof value === "string" ? value : JSON.stringify(value);
+      deleteAt(field.path);
+    }
+  }
+  return { textValues, files, extras };
+}

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

@@ -0,0 +1,34 @@
+import type { Component } from 'vue';
+/**
+ * Curated icon set a workflow can carry (`blob.icon`, kind `solar`). Only
+ * names from this map are stored — the picker offers them, `solarIconFor`
+ * resolves them, unknown/legacy names fall back to the workflow glyph.
+ * Every name here MUST already be a valid `#solar-icons` export.
+ */
+export declare const WORKFLOW_SOLAR_ICONS: Record<string, Component>;
+/** Resolve a stored solar icon name; unknown names fall back to the workflow glyph. */
+export declare function solarIconFor(name: string | undefined): Component;
+/**
+ * Stable identity of a node-package image: the image UUID. Accepts both the
+ * bare UUID (what new blobs store) and a full signed image URL (what the
+ * registry serves and what legacy blobs stored — those URLs expire, which is
+ * exactly why only the UUID is persisted).
+ */
+export declare function imageIdFromSrc(src: string | undefined | null): string | null;
+/**
+ * Resolve a stored image reference (UUID or legacy signed URL) to a FRESH
+ * signed URL from the live node catalog — manifests are re-signed on every
+ * fetch, so this never serves an expired signature. Reactive via the catalog.
+ */
+export declare function freshImageSrc(stored: string | undefined | null): string | null;
+/**
+ * Unique node-package logos usable as workflow images (`blob.icon`, kind
+ * `image`) — so a Business Central workflow can wear the Business Central
+ * logo. Deduped by stable image id; `id` is what gets persisted (stable),
+ * `src` is the current fresh signed URL for previewing.
+ */
+export declare function nodeLogoOptions(): Array<{
+    label: string;
+    id: string;
+    src: string;
+}>;

package/dist/runtime/data/workflowIconCatalog.js

@@ -0,0 +1,116 @@
+import {
+  Bag,
+  Bell,
+  Bolt,
+  Box,
+  Buildings,
+  CalendarMinimalistic,
+  Card,
+  Cart,
+  ChartSquare,
+  ClockCircle,
+  Database,
+  Download,
+  Earth,
+  FileText,
+  Folder,
+  Global,
+  GraphDown,
+  GraphUp,
+  Key,
+  Layers,
+  Letter,
+  LinkRound,
+  MagicStick,
+  Programming,
+  Pulse,
+  Radio,
+  Server,
+  ShieldCheck,
+  Shop,
+  Star,
+  TagPrice,
+  TestTube,
+  Upload,
+  User,
+  UsersGroupRounded,
+  WalletMoney
+} from "#solar-icons";
+import { INTEGRATION_NODE_CATALOG } from "./integrationNodeCatalog.js";
+export const WORKFLOW_SOLAR_ICONS = {
+  Programming,
+  Bolt,
+  ClockCircle,
+  LinkRound,
+  Radio,
+  Database,
+  Server,
+  Box,
+  Layers,
+  Folder,
+  FileText,
+  Letter,
+  Upload,
+  Download,
+  Pulse,
+  GraphUp,
+  GraphDown,
+  ChartSquare,
+  MagicStick,
+  ShieldCheck,
+  Key,
+  Cart,
+  Bag,
+  Shop,
+  Card,
+  WalletMoney,
+  TagPrice,
+  Buildings,
+  Global,
+  Earth,
+  User,
+  UsersGroupRounded,
+  Bell,
+  CalendarMinimalistic,
+  Star,
+  TestTube
+};
+export function solarIconFor(name) {
+  return (name ? WORKFLOW_SOLAR_ICONS[name] : void 0) ?? Programming;
+}
+function loc(v) {
+  if (!v) return "";
+  return typeof v === "string" ? v : v.en ?? Object.values(v)[0] ?? "";
+}
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const IMAGE_URL_ID_RE = new RegExp(`node-packages/images/(${UUID})`, "i");
+const BARE_UUID_RE = new RegExp(`^${UUID}$`, "i");
+export function imageIdFromSrc(src) {
+  if (!src) return null;
+  if (BARE_UUID_RE.test(src)) return src.toLowerCase();
+  const m = IMAGE_URL_ID_RE.exec(src);
+  return m?.[1]?.toLowerCase() ?? null;
+}
+export function freshImageSrc(stored) {
+  const id = imageIdFromSrc(stored);
+  if (!id) return null;
+  for (const m of INTEGRATION_NODE_CATALOG) {
+    for (const img of m.images ?? []) {
+      if (img.src && img.src.toLowerCase().includes(`/images/${id}`)) return img.src;
+    }
+  }
+  return null;
+}
+export function nodeLogoOptions() {
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of INTEGRATION_NODE_CATALOG) {
+    const imgs = m.images ?? [];
+    const logo = imgs.find((i) => i.category === "logo") ?? imgs[0];
+    if (!logo?.src) continue;
+    const id = imageIdFromSrc(logo.src) ?? logo.src;
+    if (byId.has(id)) continue;
+    const label = m.__package?.label || (m.groups?.length ? loc(m.groups[0]) : "") || loc(m.name);
+    byId.set(id, { label: label || "Integration", src: logo.src });
+  }
+  return [...byId.entries()].map(([id, v]) => ({ id, src: v.src, label: v.label })).sort((a, b) => a.label.localeCompare(b.label));
+}