@revenexx/studio-integrations 1.1.0 → 1.2.0

package/dist/runtime/pages/integrations/workflows/[id].vue

@@ -1,6 +1,6 @@
 <script setup>
 import { computed, nextTick, onMounted, onUnmounted, ref, watch } from "vue";
-import { AltArrowLeft as ArrowLeft, AltArrowRight as Chevron, Copy as CopyIcon, RefreshCircle as Loader2, Play, Refresh as RetryIcon, Diskette as Save, SidebarMinimalistic as RailIcon } from "#solar-icons";
+import { AltArrowLeft as ArrowLeft, AltArrowRight as Chevron, RefreshCircle as Loader2, MenuDots as MoreHorizontal, Play, Refresh as RetryIcon, Diskette as Save, SidebarMinimalistic as RailIcon } from "#solar-icons";
 import {
   AlertDialog,
   AlertDialogCancel,
@@ -16,6 +16,12 @@ import {
   DialogDescription,
   DialogHeader,
   DialogTitle,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
   Select,
   SelectContent,
   SelectItem,
@@ -24,16 +30,20 @@ import {
   Switch,
   Textarea
 } from "@revenexx/studio";
+import { deepClone } from "../../../utils/deepClone";
 import WorkflowEditor from "../../../components/Integrations/WorkflowEditor.vue";
 import WorkflowHistoryPanel from "../../../components/Integrations/WorkflowHistoryPanel.vue";
 import WorkflowRunReplayPanel from "../../../components/Integrations/WorkflowRunReplayPanel.vue";
 import WorkflowSettingsDialog from "../../../components/Integrations/WorkflowSettingsDialog.vue";
+import WorkflowDeleteDialog from "../../../components/Integrations/WorkflowDeleteDialog.vue";
 import WorkflowDuplicateDialog from "../../../components/Integrations/WorkflowDuplicateDialog.vue";
 import RunsTable from "../../../components/Integrations/RunsTable.vue";
 import RunDetailPanel from "../../../components/Integrations/RunDetailPanel.vue";
 import { toast } from "vue-sonner";
-import { IntegrationsApiError, apiValidationIssues } from "../../../utils/apiError";
+import { IntegrationsApiError, apiValidationIssues, errorReason } from "../../../utils/apiError";
 import { createPollBudget, SAFETY_POLL_MS } from "../../../utils/pollBudget";
+import { splitRunOutputs } from "../../../utils/runOutputs";
+import { isTerminalRun, unwrapRun } from "../../../utils/runEnvelope";
 import { findingsSummary, groupFindingsByNode, nodeDisplayLabel } from "../../../utils/validationFindings";
 import { payloadFieldsFromBlob } from "../../../data/payloadForm";
 import WorkflowIconView from "../../../components/Integrations/WorkflowIconView.vue";
@@ -62,11 +72,11 @@ function draftFrom() {
     executionMode: w.execution_mode ?? "async_only",
     tags: [...w.blob.tags ?? []],
     icon: w.blob.icon ?? null,
-    blob: JSON.parse(JSON.stringify(w.blob))
+    blob: deepClone(w.blob)
   };
 }
 function payloadBlob(d) {
-  const blob = JSON.parse(JSON.stringify(d.blob));
+  const blob = deepClone(d.blob);
   blob.name = d.name;
   if (d.description) blob.description = d.description;
   else delete blob.description;
@@ -138,6 +148,19 @@ async function waitForBuildReady() {
     waitingForBuild.value = false;
   }
 }
+let buildWatch = 0;
+async function settleBuildStatus() {
+  const mine = ++buildWatch;
+  const started = Date.now();
+  while (Date.now() - started < BUILD_WAIT_TIMEOUT_MS) {
+    if (mine !== buildWatch || !workflow.value) return;
+    const status = workflow.value.buildStatus;
+    if (status !== "pending" && status !== "building") return;
+    await new Promise((resolve) => setTimeout(resolve, BUILD_WAIT_POLL_MS));
+    if (mine !== buildWatch || !workflow.value) return;
+    await get(workflow.value.id);
+  }
+}
 const buildNotice = computed(() => {
   switch (workflow.value?.buildStatus) {
     case "building":
@@ -159,6 +182,7 @@ watch(id, async () => {
   draft.value = null;
   warningsExpanded.value = false;
   if (tab.value === "runs") void loadRuns(1);
+  void settleBuildStatus();
 }, { immediate: true });
 function onChange(blob) {
   const d = draftFrom();
@@ -212,12 +236,25 @@ async function onDuplicated(copy) {
   toast.success(t("integration.editor.toast.duplicated", { name: copy.name }));
   await leaveTo(`/integrations/workflows/${copy.id}`);
 }
+const deleteOpen = ref(false);
+const deleteTarget = ref(null);
+function askDelete() {
+  if (!workflow.value) return;
+  deleteTarget.value = { id: workflow.value.id, name: workflow.value.name };
+  deleteOpen.value = true;
+}
+async function onDeleted(wf) {
+  draft.value = null;
+  toast.success(t("integration.editor.toast.deleted", { name: wf.name }));
+  await leaveTo("/integrations/workflows");
+}
 async function onRevisionRestored() {
   if (!workflow.value) return;
   await get(workflow.value.id);
   draft.value = null;
+  void settleBuildStatus();
 }
-const { trigger: triggerRun, loadForWorkflow, fetchRun, retryRun } = useIntegrationsRuns();
+const { trigger: triggerRun, loadForWorkflow, fetchRun, getRun, retryRun } = useIntegrationsRuns();
 const running = ref(false);
 const waitingMode = ref(null);
 const payloadText = ref("{}");
@@ -227,6 +264,8 @@ const syncOpen = ref(false);
 const syncLoading = ref(false);
 const syncResponse = ref(null);
 const syncError = ref(null);
+const runObject = ref(null);
+const followingRun = ref(false);
 const runModalMode = ref("sync");
 const runModalRunId = ref(null);
 function extractRunId(res) {
@@ -236,6 +275,13 @@ function extractRunId(res) {
   }
   return null;
 }
+function asRunObject(res) {
+  if (!res || typeof res !== "object" || Array.isArray(res)) return null;
+  const o = res;
+  return "id" in o && "status" in o ? o : null;
+}
+const runOutputs = computed(() => splitRunOutputs(runObject.value?.result, shownBlob.value?.nodes ?? []));
+const runResult = computed(() => runObject.value ? runObject.value.result : syncResponse.value);
 function viewRunFromModal(id2) {
   syncOpen.value = false;
   void router.push({ query: { ...route.query, run: id2 } });
@@ -244,9 +290,8 @@ function syncErrorMessage(e) {
   if (e instanceof IntegrationsApiError) {
     if (e.status === 504) return t("integration.editor.run.error.syncTimeout");
     if (e.status === 422 && e.body?.status === "failed") return t("integration.editor.run.error.syncFailed");
-    return e.message || t("integration.editor.run.error.syncFailed");
   }
-  return e?.message || t("integration.editor.run.error.syncFailed");
+  return errorReason(e, t("integration.editor.run.error.syncFailed"));
 }
 function refusedForSettings(e) {
   const issues = apiValidationIssues(e);
@@ -289,6 +334,8 @@ async function run(mode) {
   }
   runModalMode.value = mode;
   runModalRunId.value = null;
+  stopFollowingRun();
+  runObject.value = null;
   syncOpen.value = true;
   syncLoading.value = true;
   syncResponse.value = null;
@@ -297,6 +344,7 @@ async function run(mode) {
     try {
       syncResponse.value = await triggerRun(workflow.value.id, payload, "sync");
       runModalRunId.value = extractRunId(syncResponse.value);
+      runObject.value = asRunObject(syncResponse.value);
     } catch (e) {
       await reportRunFailure(e, syncErrorMessage);
       if (e instanceof IntegrationsApiError) {
@@ -312,8 +360,10 @@ async function run(mode) {
   try {
     const res = await triggerRun(workflow.value.id, payload, "async");
     runModalRunId.value = extractRunId(res);
+    runObject.value = asRunObject(res);
+    startFollowingRun();
   } catch (e) {
-    await reportRunFailure(e, (err) => err?.message || t("integration.editor.run.error.couldNotStart"));
+    await reportRunFailure(e, (err) => errorReason(err, t("integration.editor.run.error.couldNotStart")));
   } finally {
     running.value = false;
     syncLoading.value = false;
@@ -397,6 +447,9 @@ const runsError = ref(null);
 const runsPage = ref(1);
 const runsTotal = ref(0);
 const runsLastPage = ref(1);
+const runsWanted = ref(1);
+let runsSeq = 0;
+let runsLoadingSeq = 0;
 const RUNS_POLL_MS = 3e3;
 const { delivering: realtimeDelivering, runTick, lastRunEvent, buildTick, lastBuildEvent } = useIntegrationsRealtime();
 const runsBudget = createPollBudget({ intervalMs: RUNS_POLL_MS, liveIntervalMs: SAFETY_POLL_MS });
@@ -410,12 +463,69 @@ function stopRunsPoll() {
 function startRunsPoll() {
   stopRunsPoll();
   runsPoll = setInterval(() => {
-    if (runsPage.value === 1 && runsBudget.due(realtimeDelivering.value)) void loadRuns(1, { silent: true });
+    if (!runsLoading.value && runsWanted.value === 1 && runsBudget.due(realtimeDelivering.value)) {
+      void loadRuns(1, { silent: true });
+    }
   }, RUNS_POLL_MS);
 }
 onUnmounted(stopRunsPoll);
+const FOLLOW_POLL_MS = 3e3;
+const followBudget = createPollBudget({ intervalMs: FOLLOW_POLL_MS, liveIntervalMs: SAFETY_POLL_MS });
+const FOLLOW_MAX_MISSES = 3;
+let followTimer = null;
+let followMisses = 0;
+let followSeq = 0;
+function stopFollowingRun() {
+  if (followTimer) {
+    clearInterval(followTimer);
+    followTimer = null;
+  }
+  followSeq++;
+  followingRun.value = false;
+}
+function countFollowMiss() {
+  if (++followMisses >= FOLLOW_MAX_MISSES) stopFollowingRun();
+}
+async function readFollowedRun() {
+  const id2 = runModalRunId.value;
+  if (!workflow.value || !id2) return stopFollowingRun();
+  const seq = ++followSeq;
+  try {
+    const raw = await getRun(workflow.value.id, id2);
+    followBudget.spend();
+    if (seq !== followSeq) return;
+    const run2 = asRunObject(unwrapRun(raw));
+    if (!run2) return countFollowMiss();
+    followMisses = 0;
+    runObject.value = run2;
+    if (isTerminalRun(run2)) stopFollowingRun();
+  } catch {
+    if (seq !== followSeq) return;
+    countFollowMiss();
+  }
+}
+function startFollowingRun() {
+  stopFollowingRun();
+  if (!runModalRunId.value || isTerminalRun(runObject.value)) return;
+  followMisses = 0;
+  followingRun.value = true;
+  void readFollowedRun();
+  followTimer = setInterval(() => {
+    if (followBudget.due(realtimeDelivering.value)) void readFollowedRun();
+  }, FOLLOW_POLL_MS);
+}
 watch(runTick, () => {
-  if (tab.value !== "runs" || runsPage.value !== 1) return;
+  if (!followingRun.value) return;
+  const eventRun = lastRunEvent.value?.topicId;
+  if (eventRun && eventRun !== String(runModalRunId.value ?? "")) return;
+  void readFollowedRun();
+});
+watch(syncOpen, (open) => {
+  if (!open) stopFollowingRun();
+});
+onUnmounted(stopFollowingRun);
+watch(runTick, () => {
+  if (tab.value !== "runs" || runsWanted.value !== 1 || runsLoading.value) return;
   const eventWorkflow = workflowIdOf(lastRunEvent.value);
   if (eventWorkflow && eventWorkflow !== String(workflow.value?.id ?? "")) return;
   void loadRuns(1, { silent: true });
@@ -426,10 +536,15 @@ watch(buildTick, () => {
   if (eventWorkflow && eventWorkflow !== String(workflow.value.id)) return;
   void get(workflow.value.id);
 });
-async function loadRuns(page = runsPage.value, opts = {}) {
+async function loadRuns(page = runsWanted.value, opts = {}) {
   if (!workflow.value) return;
+  runsWanted.value = page;
+  const seq = ++runsSeq;
   runsBudget.spend();
-  if (!opts.silent) runsLoading.value = true;
+  if (!opts.silent) {
+    runsLoading.value = true;
+    runsLoadingSeq = seq;
+  }
   runsError.value = null;
   try {
     const res = await loadForWorkflow(workflow.value.id, workflow.value.name, {
@@ -437,19 +552,23 @@ async function loadRuns(page = runsPage.value, opts = {}) {
       page,
       perPage: RUNS_PER_PAGE
     });
+    if (seq !== runsSeq) return;
     wfRuns.value = res.runs;
     runsTotal.value = res.total;
     runsLastPage.value = res.lastPage;
     runsPage.value = res.page;
+    runsWanted.value = res.page;
   } catch (e) {
-    runsError.value = e.message || t("integration.editor.runs.error.load");
+    if (seq !== runsSeq) return;
+    runsError.value = errorReason(e, t("integration.editor.runs.error.load"));
+    runsWanted.value = runsPage.value;
   } finally {
-    if (!opts.silent) runsLoading.value = false;
+    if (!opts.silent && seq === runsLoadingSeq) runsLoading.value = false;
   }
 }
 function goRunsPage(p) {
   const next = Math.min(Math.max(1, p), runsLastPage.value);
-  if (next !== runsPage.value) void loadRuns(next);
+  if (next !== runsWanted.value) void loadRuns(next);
 }
 watch(tab, (t2) => {
   if (t2 === "runs") {
@@ -496,7 +615,7 @@ async function loadOpenRun() {
   try {
     openRun.value = await fetchRun(workflow.value.id, openRunId.value, workflow.value.name);
   } catch (e) {
-    openRunError.value = e?.message ?? t("integration.editor.run.error.loadOpenRun");
+    openRunError.value = errorReason(e, t("integration.editor.run.error.loadOpenRun"));
   }
 }
 watch(openRunId, () => {
@@ -522,7 +641,7 @@ async function retryOpenRun() {
     toast.success(newId && newId !== openRun.value.id ? t("integration.editor.retry.toast.started", { id: newId }) : t("integration.editor.retry.toast.requested"));
     void loadRuns(1, { silent: true });
   } catch (e) {
-    toast.error(e?.message ?? t("integration.editor.retry.error.generic"));
+    toast.error(errorReason(e, t("integration.editor.retry.error.generic")));
   } finally {
     retryBusy.value = false;
   }
@@ -575,7 +694,7 @@ async function onToggleActive() {
       toast.error(t("integration.editor.activate.error.validationIssues", issues.length));
       return;
     }
-    toast.error(e.message || t("integration.editor.activate.error.generic"));
+    toast.error(errorReason(e, t("integration.editor.activate.error.generic")));
   }
 }
 async function save() {
@@ -592,6 +711,7 @@ async function save() {
       executionMode: d.executionMode
     });
     draft.value = null;
+    void settleBuildStatus();
   } catch (e) {
     const issues = apiValidationIssues(e);
     if (issues.length && workflow.value.active) {
@@ -603,7 +723,7 @@ async function save() {
       });
       deactivationOpen.value = true;
     } else {
-      saveError.value = e.message || t("integration.editor.save.error.generic");
+      saveError.value = errorReason(e, t("integration.editor.save.error.generic"));
     }
   } finally {
     saving.value = false;
@@ -628,9 +748,10 @@ async function confirmDeactivate() {
     draft.value = null;
     deactivationOpen.value = false;
     toast.success(t("integration.editor.deactivate.toast.savedPaused"));
+    void settleBuildStatus();
   } catch (e) {
     deactivationOpen.value = false;
-    saveError.value = e.message || t("integration.editor.save.error.generic");
+    saveError.value = errorReason(e, t("integration.editor.save.error.generic"));
   } finally {
     saving.value = false;
   }
@@ -733,10 +854,33 @@ function formatDateTime(iso) {
               {{ workflow.buildStatus === "building" ? t("integration.editor.build.chip.building") : t("integration.editor.build.chip.queued") }}
             </span>
             <span v-if="isDirty" class="text-sm text-amber-600">{{ t("integration.editor.status.unsavedChanges") }}</span>
-            <Button variant="outline" class="h-7 text-sm" :disabled="saving" :title="t('integration.editor.action.duplicate.title')" @click="duplicateOpen = true">
-              <CopyIcon :size="12" />
-              {{ t("integration.editor.action.duplicate.label") }}
-            </Button>
+            <!-- What is done to the WORKFLOW, as opposed to the draft in front
+                 of it: the buttons beside this menu discard and save an
+                 afternoon's work, and these two make and unmake the thing that
+                 work belongs to. Two reasons they are a menu rather than two more
+                 buttons in a row of five. Deleting cannot be undone and has no
+                 business a mis-click away from Save; and a lone Delete under a
+                 Duplicate that stayed a button reads as an oversight rather than
+                 as a grouping — the menu only holds together while it holds both.
+                 Icon-only, so it carries a name of its own. -->
+            <DropdownMenu>
+              <DropdownMenuTrigger as-child>
+                <Button variant="outline" size="icon" class="size-7" :disabled="saving" :aria-label="t('integration.editor.action.more.aria')">
+                  <MoreHorizontal :size="12" />
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="end">
+                <DropdownMenuLabel>{{ t("integration.editor.action.more.label") }}</DropdownMenuLabel>
+                <DropdownMenuSeparator />
+                <DropdownMenuItem @select="duplicateOpen = true">
+                  {{ t("integration.editor.action.duplicate.label") }}
+                </DropdownMenuItem>
+                <DropdownMenuSeparator />
+                <DropdownMenuItem class="text-destructive focus:text-destructive" @select="askDelete">
+                  {{ t("integration.common.action.delete") }}
+                </DropdownMenuItem>
+              </DropdownMenuContent>
+            </DropdownMenu>
             <Button variant="outline" class="h-7 text-sm" :disabled="!isDirty || saving" :title="t('integration.editor.action.discard.title')" @click="discardChanges">
               {{ t("integration.editor.action.discard.label") }}
             </Button>
@@ -884,7 +1028,7 @@ function formatDateTime(iso) {
           :draft="draft?.blob ?? null"
           :run-busy="running || syncLoading || waitingForBuild"
           :run-waiting="waitingForBuild"
-          :overlay-open="settingsOpen || duplicateOpen || syncOpen || runPayloadOpen || deactivationOpen || leaveOpen"
+          :overlay-open="settingsOpen || duplicateOpen || deleteOpen || syncOpen || runPayloadOpen || deactivationOpen || leaveOpen"
           @change="onChange"
           @run="runFromEditor"
           @toggle-active="onToggleActive"
@@ -912,10 +1056,10 @@ function formatDateTime(iso) {
         <div v-if="runsLastPage > 1 || runsTotal > wfRuns.length" class="flex items-center justify-between text-sm text-muted-foreground">
           <span class="tabular-nums">{{ t("integration.editor.runs.pagination.page", { page: runsPage, lastPage: runsLastPage }) }} · {{ t("integration.editor.runs.pagination.count", runsTotal) }}</span>
           <div class="flex gap-2">
-            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsPage <= 1 || runsLoading" @click="goRunsPage(runsPage - 1)">
+            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsWanted <= 1 || runsLoading" @click="goRunsPage(runsWanted - 1)">
               {{ t("integration.editor.runs.pagination.newer") }}
             </Button>
-            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsPage >= runsLastPage || runsLoading" @click="goRunsPage(runsPage + 1)">
+            <Button variant="outline" size="sm" class="h-7 text-sm" :disabled="runsWanted >= runsLastPage || runsLoading" @click="goRunsPage(runsWanted + 1)">
               {{ t("integration.editor.runs.pagination.older") }}
             </Button>
           </div>
@@ -1018,7 +1162,10 @@ function formatDateTime(iso) {
       :open="syncOpen"
       :loading="syncLoading"
       :mode="runModalMode"
-      :response="syncResponse"
+      :run="runObject"
+      :outputs="runOutputs"
+      :result="runResult"
+      :following="followingRun"
       :error="syncError"
       :run-id="runModalRunId"
       @update:open="(v) => syncOpen = v"
@@ -1035,6 +1182,8 @@ function formatDateTime(iso) {
       @apply="applySettings"
     />
 
+    <WorkflowDeleteDialog v-model:open="deleteOpen" :workflow="deleteTarget" @deleted="onDeleted" />
+
     <WorkflowDuplicateDialog v-model:open="duplicateOpen" :workflow="duplicateTarget" @duplicated="onDuplicated" />
 
     <!-- Leaving the workflow with unsaved work.

package/dist/runtime/types/integrations.d.ts

@@ -261,6 +261,11 @@ export interface ConfigField {
     default?: unknown;
     placeholder?: LocalizedString;
     expressionAllowed?: boolean;
+    /** The setting takes several lines — a mail body, a list of instructions one
+     *  per line — so it is drawn with room for them. Read for `string` and
+     *  `expression` fields; every other type ignores it (a dropdown has no
+     *  multi-line meaning, and the JSON fallback is already a text area). */
+    multiline?: boolean;
     options?: ConfigFieldOption[];
     /** When true, this field's `options` are resolved at author-time via
      *  config:resolve with target === this field's `key` (see useNodeConfigResolve). */

package/dist/runtime/utils/apiError.d.ts

@@ -60,5 +60,25 @@ export declare function apiFieldErrors(err: unknown): Record<string, string>;
  * one — and it counts things no form draws. A surface that shows every field-keyed
  * message at its field does not need the number at all; what it needs is the reason
  * (PO-275, reported from use).
+ *
+ * **It answers for a load as well as a refusal, and that is why it is not called
+ * `refusalReason` any more.** Six composables carried a byte-identical private
+ * `captureError` for the load case, and forty-odd call sites spelled the cast inline —
+ * one contract, three implementations, and only this one knew about the suffix. The
+ * strip is a no-op on a load failure, because nothing but a `422` carries a count; what
+ * the load case gains is the two lines above it, which it never had: a whitespace-only
+ * message now falls back instead of drawing blank.
+ *
+ * The `instanceof IntegrationsApiError` branch every `captureError` opened with is gone
+ * rather than moved. It read `if (e instanceof IntegrationsApiError) return e.message`
+ * above a line that reaches `e.message` anyway — the class extends `Error`, and `??`
+ * does not fire on a non-empty string — so it never changed an answer for any input.
+ *
+ * Three other sites kept that shape with this function in the `else`, and there it stopped
+ * being harmless the moment the two branches differed: `integrationsApi` wraps **every**
+ * failure in `IntegrationsApiError`, so the guard always won and the count was never
+ * stripped on a node-config resolve, a schedules load or a run's detail panel. They are
+ * gone too. The shape is worth recognising: an `instanceof` guard in front of this
+ * function reintroduces exactly the split it exists to remove.
  */
-export declare function refusalReason(err: unknown, fallback: string): string;
+export declare function errorReason(err: unknown, fallback: string): string;

package/dist/runtime/utils/apiError.js

@@ -33,7 +33,7 @@ export function apiFieldErrors(err) {
   }
   return out;
 }
-export function refusalReason(err, fallback) {
+export function errorReason(err, fallback) {
   const raw = err?.message?.trim();
   if (!raw) return fallback;
   return raw.replace(/\s*\(and \d+ more errors?\)\s*$/, "").trim() || fallback;

package/dist/runtime/utils/clipboard.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Put something on the clipboard, and tell the operator what actually happened.
+ *
+ * **The waiting is the point.** `writeText` returns a promise, and a browser can refuse
+ * it after the fact — a page that is not focused, a context that is not secure, a
+ * permission the operator declined. A caller that fires its "Copied" message beside the
+ * call rather than after it announces a success it has not been told about, and the
+ * operator pastes whatever was on the clipboard before. That shipped on the audit log,
+ * where the promise was neither awaited nor caught: the toast had already gone up by the
+ * time the rejection arrived, and the rejection went nowhere.
+ *
+ * **A missing `navigator.clipboard` is a failure, not a reason to do nothing.** The audit
+ * log guarded on it and skipped the whole block, so on a browser without the API the
+ * button did nothing at all — no copy, no message — which reads as broken rather than as
+ * refused. Reading through it and letting the `TypeError` land in the same `catch` is
+ * what makes "it did not work" one path instead of two.
+ *
+ * `vue-sonner` directly, not `notify.ts`: that wrapper exists so a *save* is never lost
+ * to a notification that cannot be drawn, and says in its own docblock that everywhere
+ * else imports the library. A copy has no such underlying action — the message IS the
+ * outcome — so routing six more surfaces through it would spend the indirection on the
+ * case it was explicitly not written for.
+ *
+ * The two messages stay with the caller because they are the only part that differs:
+ * copying a node's config, a webhook URL and an audit entry are three different things to
+ * have failed, and one message covering all of them would name none of them.
+ *
+ * Returns whether it worked, for a caller that has more to do than say so.
+ */
+export declare function copyToClipboard(text: string, said: {
+    copied: string;
+    failed: string;
+}): Promise<boolean>;

package/dist/runtime/utils/clipboard.js

@@ -0,0 +1,11 @@
+import { toast } from "vue-sonner";
+export async function copyToClipboard(text, said) {
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch {
+    toast.error(said.failed);
+    return false;
+  }
+  toast.success(said.copied);
+  return true;
+}

package/dist/runtime/utils/deepClone.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A deep copy of a value the studio is about to let someone edit.
+ *
+ * Every surface that edits a workflow takes one first, so that an unsaved change can
+ * be thrown away by dropping the copy rather than by undoing it: the editor's canvas,
+ * the node inspector's draft, the variables dialog's working set, a duplicate on its
+ * way to a new name, and the payload form's expert extras.
+ *
+ * **It is a JSON round trip, and that is a claim about the input rather than a
+ * shortcut.** A workflow blob is JSON — it is what the API stores and what the wire
+ * carries — so serialising and parsing it loses nothing. That is the whole guarantee,
+ * and it was the guarantee that made eight hand-written copies of this expression safe.
+ * What it cost is that the guarantee was never written down, so nothing said which
+ * inputs it holds for.
+ *
+ * **What it does not survive**, for whoever reaches for this with something that is not
+ * a blob: `undefined` becomes a missing key rather than a present one, a `Date` comes
+ * back as a string, a `Map`, a `Set` and a function are lost entirely, and a cycle
+ * throws. None of those can appear in a blob. All of them can appear in editor state
+ * that has not been through the API yet — a resolved sample, a cached schema — so a
+ * new caller is the moment to check the claim rather than to assume it.
+ *
+ * **The signature cannot enforce any of that, and says so here rather than pretending.**
+ * `<T>(value: T): T` claims the type it was handed comes back, which is false for exactly
+ * the five: `deepClone({ at: new Date() }).at` is typed `Date` and is a string, so
+ * `.getTime()` type-checks and throws. Constraining the parameter to a JSON-shaped type
+ * was tried and does not work here — `WorkflowBlob`, `WorkflowNode` and `WorkflowTrigger`
+ * are interfaces, which have no implicit index signature and so satisfy no recursive JSON
+ * type; it turned 13 type errors into 73, and collapsed the inference that gives callers
+ * their concrete type back. So the guarantee above is advisory, and the tests beside this
+ * file are where it is actually held.
+ *
+ * **Not `structuredClone`, deliberately.** It is available everywhere the module runs
+ * and it preserves all five of the things above, which sounds strictly better and is
+ * not: it would *change* what the callers get. A field that is dropped today because
+ * JSON cannot carry it would start surviving the copy, and something downstream may be
+ * relying on that loss without saying so. Swapping the mechanism is a behaviour change
+ * that wants its own proof; this module exists so that it becomes one edit when
+ * somebody makes it — which is PO-395's other half, and is not done here.
+ */
+export declare function deepClone<T>(value: T): T;

package/dist/runtime/utils/deepClone.js

@@ -0,0 +1,3 @@
+export function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}

package/dist/runtime/utils/formatDuration.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How long something took, in the shortest unit that still reads.
+ *
+ * One function for every surface that prints a duration: the runs table, the run
+ * record's step list, the result of a run started by hand, the replay panel's step
+ * and run figures, and the dashboard's latest executions. Private copies are how two
+ * surfaces come to spell the same milliseconds differently, which is what PO-383
+ * closed — three implementations across those five, two of them disagreeing. The
+ * dashboard's was not in the ticket's enumeration: it divided by a thousand inside
+ * the template, so it was invisible to a search for a formatter.
+ *
+ * The form is `900ms`, `1.5s`, `1m 3s`, and it was chosen rather than inherited.
+ * Three candidates stood in PO-383: this one, the two-decimal `1.50s`/`1.1m` these
+ * surfaces used to print, and the same shape as this one with a space before the
+ * unit. The unit sits against the number because that is how the product already
+ * writes a duration everywhere it is copy rather than a computed figure — `{n}s
+ * ago`, `{n}m ago`, `{n}h ago` in the message catalogue, read out beside these very
+ * values in the runs list. A space would also have had to stop applying above a
+ * minute, where `1 m 3 s` is unreadable, so it was one form under two rules.
+ *
+ * One decimal under a minute, and minutes-and-seconds above: a duration is read to
+ * answer "was that quick", so `1m 3s` beats `1.1m` for a step that took a minute,
+ * and the second decimal of `1.50s` is precision nobody acts on.
+ *
+ * **A trailing zero is dropped, because it is not always a measurement.** Two kinds of
+ * value arrive here. A *step's* duration is measured in milliseconds and a tenth of a
+ * second is a real reading — `3.4s`. A *run's* is the difference between two
+ * timestamps the platform stores to the second (`timestamp(0)`) and serialises without
+ * a fraction, so it is always a whole number of seconds: there is no run-level
+ * millisecond value anywhere in the API to be had. Printing `4.0s` there claimed a
+ * precision that cannot exist. Nothing has to be told which kind it is — a value that
+ * measured nothing below the unit has nothing after the point, so `4s` and `1m` fall
+ * out of the arithmetic while `3.4s` and `1m 3s` keep what they measured.
+ *
+ * Nothing promises the form. `specs/run-row.md` AC-3 promises that a row says how
+ * long a run has been going and deliberately not in what shape, and that stays the
+ * right altitude: a criterion pinning the spelling would freeze a decision the
+ * product may want to revisit — the next one being a locale, which this function
+ * does not take (German wants `1,5 s`).
+ *
+ * `null` is not zero: a run that has not started has no duration, and an em dash
+ * says so where `0ms` would claim it finished instantly.
+ */
+export declare function formatDuration(ms: number | null | undefined): string;

package/dist/runtime/utils/formatDuration.js

@@ -0,0 +1,13 @@
+export function formatDuration(ms) {
+  if (ms == null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  const tenths = Math.round(ms / 100);
+  if (tenths < 600) {
+    const seconds2 = tenths / 10;
+    return tenths % 10 === 0 ? `${seconds2}s` : `${seconds2.toFixed(1)}s`;
+  }
+  const seconds = Math.round(ms / 1e3);
+  const rest = seconds % 60;
+  const minutes = Math.floor(seconds / 60);
+  return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+}

package/dist/runtime/utils/nodeDisplayName.d.ts

@@ -0,0 +1,22 @@
+/** What a node display name can be derived from — the blob's own fields. */
+export interface NameableNode {
+    name?: unknown;
+    nodeSlug: string;
+    nodeVersion?: string;
+}
+/**
+ * What a node is called, wherever it is named.
+ *
+ * The three sources in order: the name the author typed, the manifest's name for
+ * that kind of node, and — where the catalogue does not know the slug — the slug
+ * itself. Never the node's id, which is a key the studio generated and nobody
+ * chose.
+ *
+ * The two resolvers are not interchangeable and the difference has already cost
+ * once (PO-204): the author's own name is passed through untouched, while a
+ * manifest string is trimmed and may carry its languages as an object. That is
+ * why this is one function rather than the rule restated wherever a node is
+ * named — the canvas card and the result of a run started by hand have to agree
+ * on what a node is called, or the dialog names something the graph does not.
+ */
+export declare function nodeDisplayName(node: NameableNode): string;