@revenexx/studio-integrations 0.7.0 → 1.1.0

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -3,6 +3,7 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+const EMPTY_SUMMARY = { total: 0, in_flight: 0, by_status: {} };
 function mapStatus(status) {
   switch (status) {
     case "completed":
@@ -31,22 +32,30 @@ export function useIntegrationsRuns() {
   const error = useState("integrations.runs.error", () => null);
   const loaded = useState("integrations.runs.loaded", () => false);
   const reconciling = useState("integrations.runs.reconciling", () => false);
+  const summary = useState("integrations.runs.summary", () => ({ ...EMPTY_SUMMARY }));
+  const hasMore = useState("integrations.runs.hasMore", () => false);
+  const query = useState("integrations.runs.query", () => ({
+    page: 1,
+    perPage: 100
+  }));
   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) {
+  function mapRun(r, workflowName = "") {
     const startedMs = r.started_at ? new Date(r.started_at).getTime() : null;
     const finishedMs = r.completed_at ? new Date(r.completed_at).getTime() : null;
     return {
       id: String(r.id),
       workflowId: r.workflow_id,
-      workflowName,
+      workflowName: r.workflow_name ?? workflowName,
       status: mapStatus(r.status),
       temporalRunId: r.temporal_run_id ?? null,
-      triggerId: "",
-      triggerType: "manual",
+      triggerId: r.trigger_handle ?? "",
+      // The platform reports what started the run. This was hardcoded to
+      // `manual` because the payload carried nothing, which left the trigger
+      // column and its filter with one populated value in production.
+      triggerType: r.trigger_type ?? "manual",
       startedAt: r.started_at ?? "",
       finishedAt: r.completed_at ?? null,
       // The list carries the reason a run failed; dropping it here was why every
@@ -63,25 +72,14 @@ export function useIntegrationsRuns() {
     if (!await gate.claim(force)) return runs.value;
     error.value = null;
     try {
-      await loadWorkflows();
-      const MAX_PAGES = 100;
-      const perWorkflow = await Promise.allSettled(
-        workflows.value.map(async (wf) => {
-          const out = [];
-          let page = 1;
-          while (page <= MAX_PAGES) {
-            const res = await api.get(
-              `/workflows/${wf.id}/runs?page=${page}&per_page=100`
-            );
-            out.push(...(res?.data ?? []).map((r) => mapRun(r, wf.name)));
-            const last = res?.meta?.last_page ?? 1;
-            if (page >= last) break;
-            page++;
-          }
-          return out;
-        })
-      );
-      runs.value = perWorkflow.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+      const { page: pageNumber, perPage } = query.value;
+      const [page, counts] = await Promise.all([
+        api.get(`/runs?page=${pageNumber}&per_page=${perPage}`),
+        api.get("/runs/summary")
+      ]);
+      runs.value = (page?.data ?? []).map((r) => mapRun(r));
+      hasMore.value = page?.meta?.has_more ?? false;
+      summary.value = counts?.data ?? { ...EMPTY_SUMMARY };
       if (!reconciling.value) {
         reconciling.value = true;
         try {
@@ -99,9 +97,10 @@ export function useIntegrationsRuns() {
           reconciling.value = false;
         }
       }
-      loaded.value = workflowsLoaded.value && perWorkflow.every((p) => p.status === "fulfilled");
+      loaded.value = true;
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+      loaded.value = false;
     } finally {
       gate.release();
     }
@@ -137,7 +136,40 @@ export function useIntegrationsRuns() {
     let result = [...runs.value];
     if (filter?.workflowId !== void 0) result = result.filter((r) => r.workflowId === filter.workflowId);
     if (filter?.status) result = result.filter((r) => r.status === filter.status);
-    return result.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    return result;
+  }
+  async function loadSummary() {
+    try {
+      const res = await api.get("/runs/summary");
+      summary.value = res?.data ?? { ...EMPTY_SUMMARY };
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+    }
+    return summary.value;
+  }
+  const latestPerWorkflow = useState("integrations.runs.latest", () => []);
+  const latestLoaded = useState("integrations.runs.latest.loaded", () => false);
+  const latestLoading = useState("integrations.runs.latest.loading", () => false);
+  const latestGate = useLoadGate("integrations.runs.latest", {
+    loading: latestLoading,
+    loaded: latestLoaded
+  });
+  async function loadLatestPerWorkflow(force = false) {
+    if (!await latestGate.claim(force)) return latestPerWorkflow.value;
+    try {
+      const res = await api.get("/runs/latest-per-workflow");
+      latestPerWorkflow.value = (res?.data ?? []).map((r) => mapRun(r));
+      latestLoaded.value = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.error.loadFailed");
+      latestLoaded.value = false;
+    } finally {
+      latestGate.release();
+    }
+    return latestPerWorkflow.value;
+  }
+  function lastRunFor(workflowId) {
+    return latestPerWorkflow.value.find((r) => r.workflowId === workflowId) ?? null;
   }
   function get(id) {
     return runs.value.find((r) => r.id === id) ?? null;
@@ -175,9 +207,9 @@ export function useIntegrationsRuns() {
     return api.get(`/workflows/${workflowId}/runs/${runId}/history${suffix}`);
   };
   const getStackTrace = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}/stack-trace`).then((r) => r.stack_trace);
-  const total = computed(() => runs.value.length);
-  const failedCount = computed(() => runs.value.filter((r) => r.status === "failed").length);
-  const runningCount = computed(() => runs.value.filter((r) => r.status === "running").length);
+  const total = computed(() => summary.value.total);
+  const failedCount = computed(() => Object.entries(summary.value.by_status).filter(([status]) => mapStatus(status) === "failed").reduce((sum, [, count]) => sum + count, 0));
+  const runningCount = computed(() => summary.value.in_flight);
   return {
     runs,
     loading,
@@ -186,11 +218,20 @@ export function useIntegrationsRuns() {
     total,
     failedCount,
     runningCount,
+    summary,
+    hasMore,
+    query,
     load,
+    loadSummary,
     loadForWorkflow,
     list,
     get,
     fetchRun,
+    latestPerWorkflow,
+    latestLoaded,
+    latestLoading,
+    loadLatestPerWorkflow,
+    lastRunFor,
     trigger,
     cancelRun,
     terminateRun,

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

@@ -1,18 +1,11 @@
 import type { ScheduleEntry } from '../types/integrations.js';
-/**
- * Derived view — every trigger of type `schedule` across all workflows,
- * sourced from the real triggers sub-resource (useIntegrationsTriggers).
- * Next/last-run timestamps are mocked deterministically (no telemetry
- * endpoint yet).
- *
- * Unordered on purpose: the page's table sorts, by its own default and by
- * whichever column the operator clicks, so an order established here would be
- * replaced before anyone saw it.
- */
 export declare function useIntegrationsSchedules(): {
-    entries: import("vue").ComputedRef<ScheduleEntry[]>;
-    total: import("vue").ComputedRef<number>;
-    activeCount: import("vue").ComputedRef<number>;
+    entries: any;
+    total: import("vue").ComputedRef<any>;
+    activeCount: import("vue").ComputedRef<any>;
+    timezonesInUse: import("vue").ComputedRef<any>;
     loading: any;
-    load: any;
+    loaded: any;
+    error: any;
+    load: (force?: boolean) => Promise<ScheduleEntry[]>;
 };

package/dist/runtime/composables/useIntegrationsSchedules.js

@@ -1,39 +1,84 @@
 import { computed } from "vue";
+import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
+import { useLoadGate } from "./useLoadGate.js";
+import { IntegrationsApiError } from "../utils/apiError.js";
 import { scheduleTimezone } from "../utils/schedule.js";
 export function useIntegrationsSchedules() {
-  const { all, loading, loadAll } = useIntegrationsTriggers();
-  const entries = computed(
-    () => all.value.filter((t) => t.type === "schedule").map((t) => {
-      const cfg = t.config ?? {};
-      const triggerId = String(t.id);
-      return {
-        id: `${t.workflow_id}:${t.id}`,
-        workflowId: t.workflow_id,
-        workflowName: t.workflowName,
-        triggerId,
-        // Never invented: a trigger without an expression says so on the page.
-        // Standing in `* * * * *` for it would read as "every minute", and with
-        // the expression no longer on screen that guess would be invisible.
-        cron: typeof cfg.cron === "string" && cfg.cron.trim() !== "" ? cfg.cron : null,
-        // The schedule's own zone, or the platform's default where it has none —
-        // from the same helper the trigger settings read, so one schedule cannot
-        // be shown in two zones on two screens.
-        timezone: scheduleTimezone(cfg.timezone),
-        active: t.active,
-        nextRunAt: t.active ? mockNextRun(t.workflow_id, triggerId) : null,
-        lastRunAt: t.active ? mockLastRun(t.workflow_id, triggerId) : null
-      };
-    })
-  );
-  const total = computed(() => entries.value.length);
-  const activeCount = computed(() => entries.value.filter((e) => e.active).length);
-  return { entries, total, activeCount, loading, load: loadAll };
-}
-function mockNextRun(workflowId, triggerId) {
-  const offsetMinutes = (workflowId * 7 + triggerId.length * 3) % 720 + 5;
-  return new Date(Date.now() + offsetMinutes * 6e4).toISOString();
-}
-function mockLastRun(workflowId, triggerId) {
-  const offsetMinutes = (workflowId * 13 + triggerId.length * 11) % 720 + 30;
-  return new Date(Date.now() - offsetMinutes * 6e4).toISOString();
+  const api = useIntegrationsApi();
+  const t = useIntegrationsT();
+  const entries = useState("integrations.schedules", () => []);
+  const loading = useState("integrations.schedules.loading", () => false);
+  const loaded = useState("integrations.schedules.loaded", () => false);
+  const error = useState("integrations.schedules.error", () => null);
+  const meta = useState("integrations.schedules.meta", () => ({
+    total: 0,
+    live_count: 0,
+    timezones: []
+  }));
+  const gate = useLoadGate("integrations.schedules", { loading, loaded });
+  function mapEntry(row) {
+    const block = row.schedule;
+    const firstFiring = block?.next_fire_times?.[0] ?? null;
+    return {
+      id: `${row.workflow_id}:${row.id}`,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name ?? "",
+      triggerId: String(row.id),
+      // Never invented: a trigger without an expression says so on the page.
+      // Standing in `* * * * *` for it would read as "every minute", and with the
+      // expression no longer on screen that guess would be invisible.
+      cron: block?.cron ?? null,
+      // The zone the platform resolved, rather than one guessed here — but the
+      // platform's default put back where it reports none. `timezone` is null on
+      // the wire whenever the expression could not be read AND the schedule
+      // carries no zone of its own (`ScheduleTelemetry::present` falls through to
+      // `configuredTimezone()`), which is exactly the row AC-9 promises exists.
+      //
+      // A blank there is not merely ugly, it is unreachable: `meta.timezones`
+      // contributes the platform default for a schedule carrying none, and the
+      // service's `scopeToTimezone()` matches those rows when the reader narrows
+      // to that default — so a row with no zone at all would show a bare globe
+      // and then vanish from every timezone the filter offers. The same helper
+      // the trigger settings use, so one schedule cannot read two zones
+      // (`utils/schedule.ts`, and the note in `NodeInspector.vue`).
+      timezone: scheduleTimezone(block?.timezone),
+      active: row.active,
+      workflowActive: row.workflow_active,
+      nextRunAt: block?.next_fire_at ?? null,
+      nextRunLocal: firstFiring?.local ?? null,
+      // When the run STARTED, which is nullable on the platform
+      // (`workflow_runs.started_at`): a run the scheduler has created and the
+      // worker has not picked up yet carries a status and no start. So this
+      // being null does not mean "never ran" — `lastRunStatus` is what separates
+      // the two, and the page states the queued run rather than showing the
+      // dash a schedule that has never fired gets (`specs/schedules.md` AC-12).
+      lastRunAt: block?.last_run?.started_at ?? null,
+      /** Non-null exactly when the platform holds a last run at all. */
+      lastRunStatus: block?.last_run?.status ?? null,
+      lastDispatchAt: block?.last_dispatch_at ?? null,
+      holdsFirings: block?.holds_firings ?? false,
+      notFiringReason: block?.not_firing_reason ?? null
+    };
+  }
+  async function load(force = false) {
+    if (!await gate.claim(force)) return entries.value;
+    error.value = null;
+    try {
+      const res = await api.get("/schedules");
+      entries.value = (res?.data ?? []).map(mapEntry);
+      meta.value = res?.meta ?? { total: 0, live_count: 0, timezones: [] };
+      loaded.value = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.schedules.error.loadFailed");
+      loaded.value = false;
+    } finally {
+      gate.release();
+    }
+    return entries.value;
+  }
+  const total = computed(() => meta.value.total);
+  const activeCount = computed(() => meta.value.live_count);
+  const timezonesInUse = computed(() => meta.value.timezones);
+  return { entries, total, activeCount, timezonesInUse, loading, loaded, error, load };
 }

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

@@ -1,9 +1,21 @@
 import type { TriggerType } from '../types/integrations.js';
+import type { ApiTriggerLite } from './useIntegrationsWorkflows.js';
 /**
  * Workflow triggers — a per-workflow sub-resource in the Integrations service
- * (`/workflows/{id}/triggers`), NOT part of the workflow blob. The global
- * Schedules / Webhooks views fan `loadAll()` out across the tenant's workflows
- * and filter by `type`.
+ * (`/workflows/{id}/triggers`), NOT part of the workflow blob. `list()`, `create()`,
+ * `update()` and `remove()` address that sub-resource, one workflow at a time, which
+ * is how the editor's trigger settings work.
+ *
+ * `loadAll()` does NOT: the workflow list carries each workflow's triggers in full,
+ * so a tenant-wide view is derived from that response rather than fetched per
+ * workflow (PO-236). What it still costs is the workflow list, once.
+ *
+ * Nothing in this module reads `loadAll()` any more. The Schedules page was its
+ * one caller and now reads `GET /schedules`, which is the only source that can
+ * report when a schedule fires next (PO-231). It is kept because these
+ * composables are the module's public, auto-imported surface — a host app may
+ * hold the tenant's triggers this way, and the Webhooks view this was also
+ * written for has never been built.
  */
 export interface ApiTrigger {
     id: number;
@@ -26,6 +38,21 @@ export interface TriggerInput {
     config?: Record<string, unknown> | null;
     active?: boolean;
 }
+/**
+ * The tenant's triggers, read off the workflow list rather than fetched per workflow
+ * (PO-236). Pure, and exported for that reason: it is the whole of what the tenant-wide
+ * view now does, and the composable around it needs a Nuxt app that the unit setup has
+ * no environment for.
+ *
+ * `byWorkflow` holds the triggers as the API sent them (`useIntegrationsWorkflows`
+ * keeps them beside the cockpit model, whose `id` is the handle). Two fields are not
+ * in there and are filled from the workflow the triggers arrived with: `workflow_id`,
+ * which every row id and route is built from, and `workflowName`, which the views show.
+ */
+export declare function tenantTriggers(workflows: {
+    id: number;
+    name: string;
+}[], byWorkflow: Record<number, ApiTriggerLite[]>): TriggerWithWorkflow[];
 export declare function useIntegrationsTriggers(): {
     all: any;
     loading: any;

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -2,6 +2,19 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+export function tenantTriggers(workflows, byWorkflow) {
+  return workflows.flatMap((wf) => (byWorkflow[wf.id] ?? []).flatMap((t) => {
+    if (typeof t.id !== "number") return [];
+    return [{
+      ...t,
+      id: t.id,
+      workflow_id: wf.id,
+      workflowName: wf.name,
+      handle: t.handle ?? "",
+      active: t.active ?? true
+    }];
+  }));
+}
 export function useIntegrationsTriggers() {
   const all = useState("integrations.triggers.all", () => []);
   const loading = useState("integrations.triggers.loading", () => false);
@@ -9,7 +22,7 @@ export function useIntegrationsTriggers() {
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
-  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
+  const { workflows, apiTriggers, load: loadWorkflows, loaded: workflowsLoaded, error: workflowsError } = useIntegrationsWorkflows();
   const gate = useLoadGate("integrations.triggers", { loading, loaded });
   function unwrapList(res) {
     if (Array.isArray(res)) return res;
@@ -22,12 +35,10 @@ export function useIntegrationsTriggers() {
     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((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");
+      await loadWorkflows(force);
+      all.value = tenantTriggers(workflows.value, apiTriggers.value);
+      error.value = workflowsError.value;
+      loaded.value = workflowsLoaded.value && !workflowsError.value;
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.triggers.error.loadFailed");
     } finally {

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

@@ -1,9 +1,18 @@
-import type { Workflow, WorkflowBlob, WorkflowExecutionMode } from '../types/integrations.js';
+import type { TriggerType, Workflow, WorkflowBlob, WorkflowExecutionMode } from '../types/integrations.js';
+export interface ApiTriggerLite {
+    id?: number;
+    handle?: string;
+    type: TriggerType;
+    name?: string | Record<string, string> | null;
+    config?: Record<string, unknown> | null;
+    active?: boolean;
+}
 export declare function useIntegrationsWorkflows(): {
     workflows: any;
     loading: any;
     error: any;
     loaded: any;
+    apiTriggers: any;
     total: import("vue").ComputedRef<any>;
     activeCount: import("vue").ComputedRef<any>;
     load: (force?: boolean) => Promise<Workflow[]>;

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -82,6 +82,7 @@ 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();
@@ -92,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);
@@ -101,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, t("integration.workflows.error.loadFailed"));
+      loaded.value = false;
     } finally {
       gate.release();
     }
@@ -116,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 {
@@ -124,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,
@@ -175,7 +195,7 @@ export function useIntegrationsWorkflows() {
     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,
@@ -201,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) {
@@ -54,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

@@ -59,6 +59,28 @@ export declare const TRIGGER_TYPE_WORDS: readonly ["manual", "schedule", "webhoo
  * 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 {
@@ -75,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

@@ -26,6 +26,14 @@ export function triggerTypeLabel(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;
@@ -42,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: {}
   },
   {
@@ -53,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" }
   },
   {
@@ -64,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" }
   },
   {
@@ -75,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: "" }
   }
 ];