@revenexx/studio-integrations 2.3.0 → 2.5.0

package/dist/runtime/components/Integrations/NodeVersionsPanel.vue

@@ -0,0 +1,134 @@
+<script setup>
+import { computed, onMounted, ref, watch } from "vue";
+import { RefreshCircle as Loader2 } from "#solar-icons";
+import { Badge, Button, Card, CardContent, CardHeader, CardTitle } from "@revenexx/studio";
+import { useIntegrationsT } from "../../composables/useIntegrationsT";
+import { useNodeRetirement } from "../../composables/useNodeRetirement";
+import { errorReason } from "../../utils/apiError";
+import NodeRetireDialog, {} from "./NodeRetireDialog.vue";
+const props = defineProps({
+  packageName: { type: [String, null], required: true }
+});
+const t = useIntegrationsT();
+const { versionsOfPackage, restore } = useNodeRetirement();
+const versions = ref([]);
+const loading = ref(false);
+const error = ref(null);
+const restoring = ref(null);
+const retireTarget = ref(null);
+const retireOpen = ref(false);
+const nodes = computed(() => {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const v of versions.value) {
+    const entry = bySlug.get(v.slug) ?? { slug: v.slug, name: v.name, versions: [] };
+    entry.versions.push(v);
+    bySlug.set(v.slug, entry);
+  }
+  return [...bySlug.values()];
+});
+async function load() {
+  if (!props.packageName) {
+    versions.value = [];
+    return;
+  }
+  loading.value = true;
+  error.value = null;
+  try {
+    versions.value = await versionsOfPackage(props.packageName);
+  } catch (e) {
+    error.value = errorReason(e, t("integration.nodeVersions.error.load"));
+  } finally {
+    loading.value = false;
+  }
+}
+function askRetire(v) {
+  retireTarget.value = { slug: v.slug, version: v.version, name: v.name };
+  retireOpen.value = true;
+}
+async function doRestore(v) {
+  const key = `${v.slug}@${v.version}`;
+  restoring.value = key;
+  error.value = null;
+  try {
+    await restore(v.slug, v.version);
+    await load();
+  } catch (e) {
+    error.value = errorReason(e, t("integration.nodeVersions.restore.error.generic"));
+  } finally {
+    restoring.value = null;
+  }
+}
+watch(() => props.packageName, () => void load());
+onMounted(() => void load());
+</script>
+
+<template>
+  <div class="space-y-4" data-testid="node-versions-panel">
+    <p v-if="!packageName" class="text-sm text-muted-foreground">
+      {{ t("integration.nodeVersions.empty.noPackage") }}
+    </p>
+    <p v-else-if="error" class="text-sm text-rose-600">{{ error }}</p>
+    <div v-if="loading" class="flex items-center gap-2 text-sm text-muted-foreground">
+      <Loader2 :size="14" class="animate-spin" />
+      {{ t("integration.nodeVersions.loading") }}
+    </div>
+    <p v-else-if="packageName && !error && !nodes.length" class="text-sm text-muted-foreground">
+      {{ t("integration.nodeVersions.empty.noNodes") }}
+    </p>
+
+    <Card v-for="node in nodes" :key="node.slug" :data-testid="`node-versions-${node.slug}`">
+      <CardHeader class="pb-2">
+        <CardTitle class="flex flex-wrap items-baseline gap-2 text-base">
+          <span>{{ node.name }}</span>
+          <span class="font-mono text-xs font-normal text-muted-foreground">{{ node.slug }}</span>
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        <table class="w-full text-sm">
+          <thead class="text-left text-muted-foreground">
+            <tr>
+              <th class="py-1 pr-3 font-medium">{{ t("integration.nodeVersions.column.version") }}</th>
+              <th class="py-1 pr-3 font-medium">{{ t("integration.nodeVersions.column.state") }}</th>
+              <th class="py-1" />
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="v in node.versions" :key="v.version" class="border-t border-border" :data-testid="`node-version-${v.version}`">
+              <td class="py-2 pr-3 font-mono">v{{ v.version }}</td>
+              <td class="py-2 pr-3">
+                <Badge v-if="v.retired" variant="outline" class="text-xs font-medium border-amber-500/30 text-amber-700">
+                  {{ t("integration.nodeVersions.badge.retired") }}
+                </Badge>
+                <!-- Not retired is not the same as offered: a version whose code was
+                     never built is left out of the palette too (PO-338). -->
+                <Badge v-else-if="v.has_bundle === false" variant="outline" class="text-xs font-medium border-slate-400/40 text-slate-600">
+                  {{ t("integration.nodeVersions.badge.notBuilt") }}
+                </Badge>
+                <Badge v-else variant="outline" class="text-xs font-medium border-emerald-500/30 text-emerald-700">
+                  {{ t("integration.nodeVersions.badge.offered") }}
+                </Badge>
+                <span v-if="v.retired && v.retirement_reason" class="ml-2 text-muted-foreground">{{ v.retirement_reason }}</span>
+              </td>
+              <td class="py-2 text-right">
+                <Button
+                  v-if="v.retired"
+                  variant="outline"
+                  size="sm"
+                  :disabled="restoring === `${v.slug}@${v.version}`"
+                  @click="doRestore(v)"
+                >
+                  {{ t("integration.nodeVersions.action.restore") }}
+                </Button>
+                <Button v-else variant="outline" size="sm" class="text-destructive" @click="askRetire(v)">
+                  {{ t("integration.nodeVersions.action.retire") }}
+                </Button>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </CardContent>
+    </Card>
+
+    <NodeRetireDialog v-model:open="retireOpen" :target="retireTarget" @retired="load" />
+  </div>
+</template>

package/dist/runtime/components/Integrations/NodeVersionsPanel.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    packageName: string | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/Integrations/TemplateFlowPreview.vue

@@ -106,6 +106,7 @@ const EDGE_STROKE = {
   trigger: "#94a3b8",
   error: "#cbd5e1"
 };
+const triggerChipClass = NODE_CATEGORIES.find((c) => c.key === "trigger")?.color;
 const bounds = computed(() => {
   if (!boxes.value.length) return { x: 0, y: 0, w: 1, h: 1 };
   const minX = Math.min(...boxes.value.map((b) => b.x)) - props.padding;
@@ -165,8 +166,8 @@ const bounds = computed(() => {
           class="flex h-full w-full flex-col rounded-lg border-2 border-emerald-400/40 bg-gradient-to-br from-emerald-50 to-white shadow-sm"
         >
           <div class="flex flex-1 items-center gap-2.5 px-3 py-2">
-            <span class="flex size-8 shrink-0 items-center justify-center rounded-md bg-emerald-500 text-white shadow-sm">
-              <component :is="b.icon" :size="15" />
+            <span class="flex size-8 shrink-0 items-center justify-center rounded-md" :class="triggerChipClass">
+              <component :is="b.icon" :size="18" />
             </span>
             <div class="min-w-0 flex-1">
               <div class="truncate text-sm font-semibold leading-tight text-foreground">{{ b.label }}</div>

package/dist/runtime/components/Integrations/WorkflowContextMenu.d.vue.ts

@@ -11,6 +11,8 @@ type __VLS_Props = {
     targetIsTrigger?: boolean;
     /** Busy flag for the Run item. */
     runBusy?: boolean;
+    /** The workflow has unsaved work, so the Run item saves it first — and says so. */
+    runSaves?: boolean;
 };
 declare var __VLS_14: {};
 type __VLS_Slots = {} & {

package/dist/runtime/components/Integrations/WorkflowContextMenu.vue

@@ -16,7 +16,8 @@ const props = defineProps({
   selectionCount: { type: Number, required: true },
   totalNodes: { type: Number, required: true },
   targetIsTrigger: { type: Boolean, required: false },
-  runBusy: { type: Boolean, required: false }
+  runBusy: { type: Boolean, required: false },
+  runSaves: { type: Boolean, required: false }
 });
 const emit = defineEmits(["action", "update:open"]);
 const t = useIntegrationsT();
@@ -33,7 +34,7 @@ const sections = computed(() => {
         { id: "duplicate", label: t("integration.canvas.contextMenu.item.duplicate"), shortcut: primaryShortcut("duplicate"), disabled: props.targetIsTrigger }
       ],
       [
-        { id: "run", label: t("integration.canvas.contextMenu.item.runWorkflow"), shortcut: primaryShortcut("run"), disabled: props.runBusy },
+        { id: "run", label: t(props.runSaves ? "integration.canvas.contextMenu.item.saveAndRunWorkflow" : "integration.canvas.contextMenu.item.runWorkflow"), shortcut: primaryShortcut("run"), disabled: props.runBusy },
         { id: "tidy-up", label: t("integration.canvas.contextMenu.item.tidyUp"), shortcut: primaryShortcut("tidyUp") }
       ],
       [

package/dist/runtime/components/Integrations/WorkflowContextMenu.vue.d.ts

@@ -11,6 +11,8 @@ type __VLS_Props = {
     targetIsTrigger?: boolean;
     /** Busy flag for the Run item. */
     runBusy?: boolean;
+    /** The workflow has unsaved work, so the Run item saves it first — and says so. */
+    runSaves?: boolean;
 };
 declare var __VLS_14: {};
 type __VLS_Slots = {} & {

package/dist/runtime/components/Integrations/WorkflowCreateDialog.vue

@@ -18,7 +18,7 @@ import {
   SelectValue,
   Textarea
 } from "@revenexx/studio";
-import { TRIGGER_TEMPLATES } from "../../data/integrationNodeCatalog";
+import { NODE_CATEGORIES, TRIGGER_TEMPLATES } from "../../data/integrationNodeCatalog";
 import LoadingAnnouncement from "./LoadingAnnouncement.vue";
 import TemplateCard from "./TemplateCard.vue";
 import TemplateInstallStep from "./TemplateInstallStep.vue";
@@ -61,6 +61,7 @@ const executionModes = computed(() => [
   { key: "caller_decides", label: t("integration.workflows.create.executionMode.callerDecides.label"), hint: t("integration.workflows.create.executionMode.callerDecides.hint"), icon: "SlidersHorizontal" }
 ]);
 const selectedTrigger = computed(() => TRIGGER_TEMPLATES.find((tt) => tt.type === triggerType.value) ?? null);
+const triggerChipClass = NODE_CATEGORIES.find((c) => c.key === "trigger")?.color;
 const selectedMode = computed(() => executionModes.value.find((m) => m.key === executionMode.value) ?? executionModes.value[0]);
 watch(open, (v) => {
   if (!v) return;
@@ -196,7 +197,7 @@ async function installed(id) {
             <SelectTrigger id="wf-trigger" class="w-full bg-white">
               <SelectValue>
                 <span class="flex min-w-0 items-center gap-2">
-                  <span class="flex size-6 shrink-0 items-center justify-center rounded-md bg-emerald-100 text-emerald-600">
+                  <span class="flex size-6 shrink-0 items-center justify-center rounded-md" :class="triggerChipClass">
                     <component :is="triggerGlyph(selectedTrigger?.type)" :size="13" />
                   </span>
                   <span class="shrink-0 text-sm font-medium">{{ resolveLocalized(selectedTrigger?.name) }}</span>
@@ -207,7 +208,7 @@ async function installed(id) {
             <SelectContent>
               <SelectItem v-for="tpl in TRIGGER_TEMPLATES" :key="tpl.id" :value="tpl.type">
                 <span class="flex items-center gap-2.5 py-0.5">
-                  <span class="flex size-7 shrink-0 items-center justify-center rounded-md bg-emerald-100 text-emerald-600">
+                  <span class="flex size-7 shrink-0 items-center justify-center rounded-md" :class="triggerChipClass">
                     <component :is="triggerGlyph(tpl.type)" :size="14" />
                   </span>
                   <span class="min-w-0">

package/dist/runtime/components/Integrations/WorkflowEditor.d.vue.ts

@@ -20,10 +20,13 @@ type __VLS_Props = {
      * keystrokes.
      */
     draft?: WorkflowBlob | null;
-    /** Busy flag for the control-pane Play button (a run is being triggered). */
+    /** A run is being triggered — the context menu's Run item and the shortcut stand down. */
     runBusy?: boolean;
-    /** The run is queued behind a bundle build — busy, but worth saying why. */
-    runWaiting?: boolean;
+    /**
+     * The workflow has unsaved work, so Run saves it first. Only the context menu
+     * reads it, to say so: Run itself stands in the page header, beside Save.
+     */
+    runSaves?: boolean;
     /**
      * One of the page's own lightboxes is open above the editor (settings,
      * duplicate, run payload, the sync response, the deactivation prompt). The

package/dist/runtime/components/Integrations/WorkflowEditor.vue

@@ -13,10 +13,8 @@ import { MiniMap } from "@vue-flow/minimap";
 import {
   Widget as LayoutGrid,
   MagicStick as Sparkles,
-  Play,
   MinusCircle as ZoomOut,
-  AddCircle as ZoomIn,
-  RefreshCircle as Loader2
+  AddCircle as ZoomIn
 } from "#solar-icons";
 import {
   Dialog,
@@ -60,12 +58,13 @@ import { deepClone } from "../../utils/deepClone";
 import { copyToClipboard } from "../../utils/clipboard";
 import { groupFindingsByNode, findingsByNodeField } from "../../utils/validationFindings";
 import { reorderBranchSubtrees } from "../../data/branchReorder";
-import { resolveDisplayName, resolveLocalized } from "../../utils/localize";
+import { resolveLocalized } from "../../utils/localize";
+import { nodeDisplayName } from "../../utils/nodeDisplayName";
 const props = defineProps({
   workflow: { type: Object, required: true },
   draft: { type: [Object, null], required: false },
   runBusy: { type: Boolean, required: false },
-  runWaiting: { type: Boolean, required: false },
+  runSaves: { type: Boolean, required: false },
   overlayOpen: { type: Boolean, required: false }
 });
 const emit = defineEmits(["change", "run", "toggleActive", "openSettings"]);
@@ -875,9 +874,8 @@ const selectedUpstreamOutputs = computed(() => {
     const port = portsForNode(source, findManifest(source.nodeSlug, source.nodeVersion), dynamicOutputs.value[source.id]).find((p) => p.name === e.from.output);
     return [{
       nodeId: source.id,
-      // A node's own name is text the user typed — never trimmed, never read
-      // as JSON. The manifest strings below it get the normalising resolver.
-      nodeName: resolveDisplayName(source.name) || source.nodeSlug,
+      // Called what its card calls it, not by its slug (PO-601).
+      nodeName: nodeDisplayName(source),
       output: e.from.output,
       fields: port?.fields.map((f) => f.name)
     }];
@@ -1420,6 +1418,7 @@ const edgeTypes = {
         :total-nodes="vfNodes.length"
         :target-is-trigger="!!menu.targetId && blob.triggers.some((t2) => t2.id === menu.targetId)"
         :run-busy="runBusy"
+        :run-saves="runSaves"
         @action="onMenuAction"
       >
         <!-- `pan-activation-key-code` is null rather than left at its default, which
@@ -1695,25 +1694,6 @@ const edgeTypes = {
         <TooltipProvider :delay-duration="250">
           <div class="rounded-lg border border-gray-400/10 outline-1 outline-white/30 backdrop-blur-sm">
             <div class="flex items-center gap-0.5 whitespace-nowrap border border-white bg-white rounded-lg bg-gradient-to-br from-white via-violet-50/40 to-white px-2 py-1">
-              <!-- Smart Run: the page decides what "run" means — a workflow that
-               consumes trigger.payload, or leaves the mode to the caller, opens
-               the run dialog; one that asks neither fires immediately. One
-               button either way. -->
-              <IntegrationsEditorTip :label="runWaiting ? t('integration.editor.tool.run.tooltipWaiting') : t('integration.editor.tool.run.tooltip')" :shortcut="primaryShortcut('run')">
-                <button
-                  type="button"
-                  class="relative flex h-8 items-center gap-1.5 rounded-lg bg-gradient-to-b from-emerald-500 to-emerald-600 px-3.5 text-sm font-medium text-white transition after:pointer-events-none after:absolute after:inset-0 after:rounded-[inherit] after:shadow-[inset_0_1px_0_rgba(255,255,255,0.3),inset_0_-2px_0_rgba(0,0,0,0.25)] hover:from-emerald-600 hover:to-emerald-600 active:translate-y-px disabled:opacity-60"
-                  :disabled="runBusy"
-                  @click="emit('run')"
-                >
-                  <Loader2 v-if="runBusy" :size="14" class="animate-spin" />
-                  <Play v-else :size="14" />
-                  {{ runWaiting ? t("integration.editor.run.waitingForBuild") : t("integration.editor.run.button") }}
-                </button>
-              </IntegrationsEditorTip>
-
-              <div class="mx-1 h-5 w-px bg-black/10" />
-
               <div class="flex items-center gap-0.5 rounded-lg bg-black/[0.05] p-0.5 shadow-[inset_0_1px_2px_rgba(15,23,42,0.12)]">
                 <!-- Icon-only, and the tooltip is not an accessible name: each one
                says what it does itself, and whether it is the active mode. -->

package/dist/runtime/components/Integrations/WorkflowEditor.vue.d.ts

@@ -20,10 +20,13 @@ type __VLS_Props = {
      * keystrokes.
      */
     draft?: WorkflowBlob | null;
-    /** Busy flag for the control-pane Play button (a run is being triggered). */
+    /** A run is being triggered — the context menu's Run item and the shortcut stand down. */
     runBusy?: boolean;
-    /** The run is queued behind a bundle build — busy, but worth saying why. */
-    runWaiting?: boolean;
+    /**
+     * The workflow has unsaved work, so Run saves it first. Only the context menu
+     * reads it, to say so: Run itself stands in the page header, beside Save.
+     */
+    runSaves?: boolean;
     /**
      * One of the page's own lightboxes is open above the editor (settings,
      * duplicate, run payload, the sync response, the deactivation prompt). The

package/dist/runtime/components/Integrations/WorkflowTriggerView.vue

@@ -7,7 +7,7 @@ import { SIDE_POSITION } from "./canvasSides";
 import { outputHandleId } from "../../data/handleId";
 import { triggerGlyph as glyphForTrigger } from "../../data/triggerGlyphs";
 import { resolveDisplayName } from "../../utils/localize";
-import { triggerTypeLabel } from "../../data/integrationNodeCatalog";
+import { NODE_CATEGORIES, triggerTypeLabel } from "../../data/integrationNodeCatalog";
 import { describeCron } from "../../utils/schedule";
 const props = defineProps({
   id: { type: String, required: true },
@@ -18,6 +18,7 @@ defineOptions({ inheritAttrs: false });
 defineEmits(["updateNodeInternals"]);
 const t = useIntegrationsT();
 const icon = computed(() => glyphForTrigger(props.data.type));
+const chipClass = NODE_CATEGORIES.find((c) => c.key === "trigger")?.color;
 const subtitle = computed(() => {
   const c = props.data.config;
   if (props.data.type === "schedule") return describeCron(c.cron) ?? c.cron ?? t("integration.canvas.trigger.subtitle.noSchedule");
@@ -72,10 +73,10 @@ const OUT_SIDES = ["bottom"];
     @mouseleave="onHoverLeave"
   >
     <!-- Same type scale as WorkflowNodeView so trigger and node cards read
-         identically (icon chip size-8/15, subtitle plain text-sm, mt-0.5). -->
+         identically (icon chip size-8 with an 18px glyph, subtitle plain text-sm, mt-0.5). -->
     <div class="flex items-center gap-2.5 px-3 py-2.5">
-      <span class="flex size-8 shrink-0 items-center justify-center rounded-md bg-emerald-500 text-white shadow-sm">
-        <component :is="icon" :size="15" />
+      <span class="flex size-8 shrink-0 items-center justify-center rounded-md" :class="chipClass">
+        <component :is="icon" :size="18" />
       </span>
       <div class="min-w-0 flex-1">
         <div class="text-sm font-semibold text-foreground leading-tight truncate">

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

@@ -27,6 +27,11 @@ export interface CredentialTestResult {
     ok: boolean;
     message?: string;
     error?: string;
+    /**
+     * Whether the platform kept this answer as the credential's state. `false` for a
+     * test of an edit that tried values other than the stored ones (PO-535).
+     */
+    recorded?: boolean;
 }
 export declare function useIntegrationsCredentials(): {
     credentials: any;
@@ -49,6 +54,6 @@ export declare function useIntegrationsCredentials(): {
     }) => Promise<Credential>;
     remove: (id: string) => Promise<void>;
     testInline: (credentialTypeSlug: string, config: Record<string, unknown>) => Promise<CredentialTestResult>;
-    test: (id: string) => Promise<CredentialTestResult>;
+    test: (id: string, config?: Record<string, unknown>) => Promise<CredentialTestResult>;
     oauthAuthorizeUrl: (id: string) => Promise<string>;
 };

package/dist/runtime/composables/useIntegrationsCredentials.js

@@ -53,10 +53,13 @@ export function useIntegrationsCredentials() {
       return { ok: false, error: errorReason(e, t("integration.credentials.error.testFailed")) };
     }
   }
-  async function test(id) {
+  async function test(id, config) {
     try {
-      const res = await api.post(`/credentials/${encodeURIComponent(id)}/test`);
-      return res?.ok === false ? res : { ok: true, message: res?.message };
+      const res = await api.post(
+        `/credentials/${encodeURIComponent(id)}/test`,
+        config ? { config } : void 0
+      );
+      return res?.ok === false ? res : { ok: true, message: res?.message, recorded: res?.recorded };
     } catch (e) {
       return { ok: false, error: errorReason(e, t("integration.credentials.error.testFailed")) };
     }

package/dist/runtime/composables/useIntegrationsNodes.js

@@ -31,6 +31,9 @@ export function useIntegrationsNodes() {
         // was never built can be drawn but not executed, so the palette must
         // be able to leave it out (PO-338). Missing field = assume built.
         __hasBundle: n.has_bundle !== false,
+        // Retired by its publisher: still drawn for the workflows already on
+        // it, offered nowhere new (PO-549). Missing field = not retired.
+        __retired: n.retired === true,
         // The package's own order, which the palette falls back to inside a
         // folder (PO-537). Null and absent both mean "not recorded".
         __packagePosition: typeof n.package_position === "number" ? n.package_position : void 0

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

@@ -0,0 +1,48 @@
+/**
+ * A publisher withdrawing a version of its own node from new use, and taking
+ * that back (PO-549; behaviour in specs/node-versions.md).
+ *
+ * Retiring is not deleting. The workflows already built on the version — in any
+ * tenant, since a public package's nodes sit in workflows its publisher cannot
+ * see — keep drawing, saving and running; what a retired version loses is the
+ * offer, and the platform refuses any save that would newly use it. The platform
+ * decides who may do this (the organisation the slug is namespaced under) and
+ * insists on the version being named in `confirm`, whatever this screen does.
+ */
+/** One registered version of a node, as the catalogue lists it. */
+export interface PublishedNodeVersion {
+    slug: string;
+    version: string;
+    name: string;
+    package: {
+        name: string;
+        version: string;
+        label?: string | null;
+    } | null;
+    has_bundle?: boolean;
+    retired?: boolean;
+    retired_at?: string | null;
+    retirement_reason?: string | null;
+}
+/** How widely one version is used, across every tenant — counts only. */
+export interface NodeVersionUsage {
+    workflows: number;
+    active_workflows: number;
+    tenants: number;
+    templates: number;
+}
+interface RetirementAnswer {
+    slug: string;
+    version: string;
+    retired: boolean;
+    retired_at: string | null;
+    retirement_reason: string | null;
+    usage: NodeVersionUsage;
+}
+export declare function useNodeRetirement(): {
+    versionsOfPackage: (packageName: string) => Promise<PublishedNodeVersion[]>;
+    usage: (slug: string, version: string) => Promise<NodeVersionUsage>;
+    retire: (slug: string, version: string, reason: string | null) => Promise<RetirementAnswer>;
+    restore: (slug: string, version: string) => Promise<RetirementAnswer>;
+};
+export {};

package/dist/runtime/composables/useNodeRetirement.js

@@ -0,0 +1,31 @@
+import { IntegrationsApiError } from "../utils/apiError.js";
+import { unwrapList, unwrapRecord } from "../utils/apiEnvelope.js";
+import { useIntegrationsApi } from "./integrationsApi.js";
+function versionPath(slug, version) {
+  return `/nodes/${encodeURIComponent(slug)}/${encodeURIComponent(version)}`;
+}
+export function useNodeRetirement() {
+  const api = useIntegrationsApi();
+  async function versionsOfPackage(packageName) {
+    const all = unwrapList(await api.get("/nodes"));
+    return all.filter((n) => n.package?.name === packageName);
+  }
+  async function usage(slug, version) {
+    const answer = unwrapRecord(await api.get(`${versionPath(slug, version)}/usage`), ["usage"]);
+    const counts = answer?.usage;
+    if (!counts || typeof counts.workflows !== "number") {
+      throw new IntegrationsApiError(200, answer, "");
+    }
+    return counts;
+  }
+  async function retire(slug, version, reason) {
+    return unwrapRecord(await api.post(`${versionPath(slug, version)}/retire`, {
+      confirm: `${slug}@${version}`,
+      ...reason ? { reason } : {}
+    }), ["usage"]);
+  }
+  async function restore(slug, version) {
+    return unwrapRecord(await api.del(`${versionPath(slug, version)}/retire`), ["usage"]);
+  }
+  return { versionsOfPackage, usage, retire, restore };
+}

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

@@ -72,6 +72,14 @@ export declare function triggerTypeLabel(type: TriggerType | string | null | und
  * executable, because the alternative is a studio that hides working nodes.
  */
 export declare function isVersionExecutable(slug: string, version: string): boolean;
+/**
+ * Whether this version is one to offer: its code was built, and its publisher
+ * has not retired it (PO-338, PO-549). What the palette inserts and what a
+ * move points at. Narrower than {@link isVersionExecutable} on purpose — a
+ * retired version still runs for the workflows already on it, it is only no
+ * longer a choice.
+ */
+export declare function isOffered(m: NodeManifest): boolean;
 /**
  * The newest version of this node that can be executed, or `null` when none can.
  *
@@ -92,7 +100,8 @@ export declare function newestExecutableVersion(slug: string): string | null;
  *
  * A version whose code was never built is left out, for the reason the palette
  * leaves it out: it is not a choice, it is a dead end with a version number
- * (PO-338). The version a step is pinned to is therefore not guaranteed to be in
+ * (PO-338). So is one its publisher retired, which the platform would refuse
+ * to newly pin (PO-549). The version a step is pinned to is therefore not guaranteed to be in
  * here — which is exactly the state the move exists to get out of.
  */
 export declare function executableVersionsOf(slug: string): NodeManifest[];

package/dist/runtime/data/integrationNodeCatalog.js

@@ -30,17 +30,20 @@ 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 isOffered(m) {
+  return m.__hasBundle !== false && m.__retired !== true;
+}
 export function newestExecutableVersion(slug) {
-  const hit = INTEGRATION_NODE_CATALOG.find((m) => m.slug === slug && m.__hasBundle !== false);
+  const hit = INTEGRATION_NODE_CATALOG.find((m) => m.slug === slug && isOffered(m));
   return hit?.version ?? null;
 }
 export function executableVersionsOf(slug) {
-  return INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug && m.__hasBundle !== false);
+  return INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug && isOffered(m));
 }
 export function newerExecutableVersions(slug, version) {
-  const versions = executableVersionsOf(slug);
-  const at = versions.findIndex((m) => m.version === version);
-  return at < 0 ? [] : versions.slice(0, at);
+  const built = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug && m.__hasBundle !== false);
+  const at = built.findIndex((m) => m.version === version);
+  return at < 0 ? [] : built.slice(0, at).filter(isOffered);
 }
 export function findManifest(slug, version) {
   const matches = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug);

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

@@ -22,6 +22,11 @@ import type { TriggerType } from '../types/integrations.js';
  * ('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`.
+ *
+ * `manual` is a person, not the play triangle. The play glyph is the Run button's,
+ * and on a trigger card — white on the filled chip — it read as a second Run button
+ * that did nothing when pressed (PO-606). A trigger's glyph names who or what fires
+ * it; it is a label, so it must not borrow an action's shape.
  */
 export declare const TRIGGER_GLYPHS: Record<TriggerType, Component>;
 /**
@@ -32,9 +37,9 @@ export declare const TRIGGER_GLYPHS: Record<TriggerType, Component>;
  * 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
+ * Such a kind falls back to the **bolt**, not to the manual trigger's glyph, which
+ * is what the templates surfaces did before this map existed. That glyph asserts
+ * "a person starts this", 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

package/dist/runtime/data/triggerGlyphs.js

@@ -1,6 +1,6 @@
-import { Bolt, ClockCircle, LinkRound, Play } from "#solar-icons";
+import { Bolt, ClockCircle, LinkRound, User } from "#solar-icons";
 export const TRIGGER_GLYPHS = {
-  manual: Play,
+  manual: User,
   schedule: ClockCircle,
   webhook: LinkRound,
   event: Bolt