@revenexx/studio-integrations 0.5.1 → 0.6.0

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

@@ -0,0 +1,141 @@
+/**
+ * A schedule, in both directions: the structured rhythm the studio lets a user
+ * pick, the five-field cron expression the platform runs on, and the sentence
+ * that says it in words.
+ *
+ * The studio no longer asks anyone to write cron. It asks for a rhythm — every
+ * few minutes, daily at a time, on these weekdays — and `toCron` turns that into
+ * the expression the API stores. `parseCron` is the way back, so a schedule that
+ * arrives from anywhere (a template, the MCP tools, a hand-written expression from
+ * before this existed) opens in the same controls if it can, and stays an
+ * expression if it cannot.
+ *
+ * **The sentence is total over what the picker can build.** `describeRecurrence`
+ * always answers; the refusal to guess lives in `parseCron`, which returns `null`
+ * for everything outside the shapes below — several stepped fields, minute and
+ * hour lists, `L`/`#` syntax, month restrictions, seconds precision. That is what
+ * lets the studio show the sentence instead of the expression: for anything it
+ * authored there is always a sentence, and where there is none the expression is
+ * shown, because nothing else would be true.
+ *
+ * **Nothing here converts a time.** The platform evaluates the expression in the
+ * trigger's own timezone (`CronExpression->isDue($now->setTimezone($tz))`), so the
+ * numbers in it are wall-clock time in that zone. The zone is therefore half of
+ * the schedule and the caller's to show — it is not a formatting detail.
+ */
+/** A rhythm the picker can build, and `describeRecurrence` can always say. */
+export type Recurrence = 
+/** `interval` minutes apart, all day, every day. `1` means every minute. */
+{
+    kind: 'minutes';
+    interval: number;
+}
+/** Once an hour, at `minute` past. */
+ | {
+    kind: 'hourly';
+    minute: number;
+}
+/** Every `interval` hours (2 or more), at `minute` past. */
+ | {
+    kind: 'hours';
+    interval: number;
+    minute: number;
+}
+/** Once a day, at a fixed time. */
+ | {
+    kind: 'daily';
+    hour: number;
+    minute: number;
+}
+/**
+ * Several times a day, at the same minute past each of `hours` — two or more —
+ * and on `days`, or every day when that is `null`.
+ *
+ * A list of hours and a run of them are the same rhythm written two ways
+ * (`9,10,11` fires exactly when `9-11` does), so both read back into this one
+ * form and `toCron` picks the canonical spelling. Times with *different*
+ * minutes are not one rhythm and cron cannot express them in one expression:
+ * 07:30 and 09:15 is two schedules.
+ */
+ | {
+    kind: 'times';
+    minute: number;
+    hours: number[];
+    days: number[] | null;
+}
+/** On the given weekdays (0 = Sunday), at a fixed time. Never empty. */
+ | {
+    kind: 'weekly';
+    days: number[];
+    hour: number;
+    minute: number;
+}
+/** On one day of the month, at a fixed time. */
+ | {
+    kind: 'monthly';
+    day: number;
+    hour: number;
+    minute: number;
+};
+/**
+ * The zone a schedule without one of its own runs in: the platform's default,
+ * which is UTC (`config('app.timezone')`, which nothing overrides).
+ *
+ * Not the zone the studio *writes*. A schedule set up here carries
+ * `Europe/Berlin` from the trigger's own default config, and this is only what a
+ * schedule that arrived without a zone actually runs in.
+ */
+export declare const PLATFORM_TIMEZONE = "UTC";
+/**
+ * The zone a schedule's numbers are read in — its own where it has one, the
+ * platform's default where it does not.
+ *
+ * One function because two surfaces show it: the trigger settings under the
+ * controls, and the Schedules page in its own column. A surface that answered this
+ * for itself is how one schedule ends up with two zones, and a zone is half of
+ * what a time means.
+ */
+export declare function scheduleTimezone(timezone: unknown): string;
+/**
+ * The rhythm an expression describes, or `null` when it is not one of them.
+ *
+ * @param cron A five-field expression: minute hour day-of-month month day-of-week.
+ */
+export declare function parseCron(cron: string | null | undefined): Recurrence | null;
+/**
+ * The five-field expression for a rhythm. Always valid, always five fields, and
+ * **never both a day of the month and a weekday** — cron reads that pair as
+ * "either", so a picker that produced it would mean something other than what it
+ * showed.
+ *
+ * Three rhythms are written in their canonical form rather than literally, so one
+ * rhythm has one expression: an hourly interval of 1 is `hourly`, a weekly
+ * schedule on all seven days is `daily`, and every day of the week under `times`
+ * is written as an open field. Reading any of them back therefore gives the
+ * canonical form, not the one passed in.
+ */
+export declare function toCron(r: Recurrence): string;
+/**
+ * A sentence for a rhythm. Total: every `Recurrence` has one, which is what lets
+ * a surface show the sentence in place of the expression.
+ */
+export declare function describeRecurrence(r: Recurrence): string;
+/**
+ * A sentence for the expression, or `null` when it cannot be said plainly.
+ *
+ * Nothing at all is the point where it happens. A wrong aid is worse than none,
+ * because a schedule that reads "Daily at 03:00" and fires hourly is a fault
+ * nobody goes looking for — so the shapes this cannot read produce no sentence,
+ * and the surface shows the expression instead.
+ *
+ * Times are read as written: the expression's own numbers, in the schedule's own
+ * timezone. Nothing here converts anything, which is why the timezone is the
+ * caller's to show.
+ */
+export declare function describeCron(cron: string | null | undefined): string | null;
+/**
+ * How long a rhythm waits between firings, in minutes — the order a "when does
+ * this run" column sorts in. An expression that cannot be read sorts last, since
+ * the alternative is ordering rows by a string the reader cannot see.
+ */
+export declare function cadenceRank(cron: string | null | undefined): number;

package/dist/runtime/utils/schedule.js

@@ -0,0 +1,207 @@
+const DAY_NAMES = ["Sundays", "Mondays", "Tuesdays", "Wednesdays", "Thursdays", "Fridays", "Saturdays"];
+export const PLATFORM_TIMEZONE = "UTC";
+export function scheduleTimezone(timezone) {
+  return typeof timezone === "string" && timezone.trim() !== "" ? timezone.trim() : PLATFORM_TIMEZONE;
+}
+const WEEKDAYS = [1, 2, 3, 4, 5];
+const WEEKEND = [0, 6];
+function isEvery(field) {
+  return field === "*";
+}
+function fixed(field, min, max) {
+  if (!/^\d{1,2}$/.test(field)) return null;
+  const n = Number(field);
+  return n >= min && n <= max ? n : null;
+}
+function step(field, max, range) {
+  const m = /^\*\/(\d{1,2})$/.exec(field);
+  if (!m) return null;
+  const n = Number(m[1]);
+  return n >= 2 && n <= max && range % n === 0 ? n : null;
+}
+function numberSet(field, min, max) {
+  if (isEvery(field)) return null;
+  const out = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const run = /^(\d{1,2})-(\d{1,2})$/.exec(part);
+    if (run) {
+      const from = Number(run[1]);
+      const to = Number(run[2]);
+      if (from < min || to > max || from >= to) return null;
+      for (let n = from; n <= to; n++) out.add(n);
+      continue;
+    }
+    const one = fixed(part, min, max);
+    if (one == null) return null;
+    out.add(one);
+  }
+  return out.size ? [...out].sort((a, b) => a - b) : null;
+}
+function daySet(field) {
+  const raw = numberSet(field, 0, 7);
+  if (!raw) return null;
+  return [...new Set(raw.map((d) => d === 7 ? 0 : d))].sort((a, b) => a - b);
+}
+function isRun(values) {
+  return values.length > 0 && values[values.length - 1] - values[0] === values.length - 1;
+}
+function readsAsSpan(hours) {
+  return hours.length >= 3 && isRun(hours);
+}
+function saysAsSpan(hours) {
+  return hours.length >= 4 && isRun(hours);
+}
+function writeSet(values) {
+  return readsAsSpan(values) ? `${values[0]}-${values[values.length - 1]}` : values.join(",");
+}
+export function parseCron(cron) {
+  if (!cron) return null;
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) return null;
+  const [minute, hour, dom, month, dow] = fields;
+  if (!isEvery(month)) return null;
+  const everyDay = isEvery(dom) && isEvery(dow);
+  if (isEvery(hour) && everyDay) {
+    if (isEvery(minute)) return { kind: "minutes", interval: 1 };
+    const perMinute = step(minute, 59, 60);
+    if (perMinute) return { kind: "minutes", interval: perMinute };
+  }
+  const min = fixed(minute, 0, 59);
+  if (min == null) return null;
+  if (everyDay) {
+    if (isEvery(hour)) return { kind: "hourly", minute: min };
+    const perHour = step(hour, 23, 24);
+    if (perHour) return { kind: "hours", interval: perHour, minute: min };
+  }
+  const hr = fixed(hour, 0, 23);
+  if (hr == null && isEvery(dom)) {
+    const hours = numberSet(hour, 0, 23);
+    if (hours && hours.length >= 2) {
+      const days = isEvery(dow) ? null : daySet(dow);
+      if (!isEvery(dow) && !days) return null;
+      return { kind: "times", minute: min, hours, days };
+    }
+  }
+  if (hr == null) return null;
+  if (everyDay) return { kind: "daily", hour: hr, minute: min };
+  if (isEvery(dom)) {
+    const days = daySet(dow);
+    return days ? { kind: "weekly", days, hour: hr, minute: min } : null;
+  }
+  if (isEvery(dow)) {
+    const day = fixed(dom, 1, 31);
+    if (day) return { kind: "monthly", day, hour: hr, minute: min };
+  }
+  return null;
+}
+export function toCron(r) {
+  switch (r.kind) {
+    case "minutes":
+      return r.interval <= 1 ? "* * * * *" : `*/${r.interval} * * * *`;
+    case "hourly":
+      return `${r.minute} * * * *`;
+    case "hours":
+      return r.interval <= 1 ? `${r.minute} * * * *` : `${r.minute} */${r.interval} * * *`;
+    case "daily":
+      return `${r.minute} ${r.hour} * * *`;
+    case "times": {
+      const hours = [...new Set(r.hours)].sort((a, b) => a - b);
+      if (hours.length < 2) {
+        const hour = hours[0] ?? 0;
+        return r.days ? toCron({ kind: "weekly", days: r.days, hour, minute: r.minute }) : toCron({ kind: "daily", hour, minute: r.minute });
+      }
+      const days = r.days ? [...new Set(r.days.map((d) => d === 7 ? 0 : d))].sort((a, b) => a - b) : [];
+      const dow = !days.length || days.length === 7 ? "*" : writeSet(days);
+      return `${r.minute} ${writeSet(hours)} * * ${dow}`;
+    }
+    case "weekly": {
+      const days = [...new Set(r.days.map((d) => d === 7 ? 0 : d))].sort((a, b) => a - b);
+      if (!days.length || days.length === 7) return `${r.minute} ${r.hour} * * *`;
+      return `${r.minute} ${r.hour} * * ${days.join(",")}`;
+    }
+    case "monthly":
+      return `${r.minute} ${r.hour} ${r.day} * *`;
+  }
+}
+function at(hour, minute) {
+  return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+function plural(n, unit) {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+function ordinal(n) {
+  const suffix = n % 100 >= 11 && n % 100 <= 13 ? "th" : ["th", "st", "nd", "rd"][n % 10] ?? "th";
+  return `${n}${suffix}`;
+}
+function sameDays(days, other) {
+  return days.length === other.length && days.every((d) => other.includes(d));
+}
+function listWords(words) {
+  if (words.length <= 1) return words[0] ?? "";
+  return `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+}
+function dayPhrase(days) {
+  if (!days) return "Daily";
+  const set = [...new Set(days.map((d) => d === 7 ? 0 : d))].sort((a, b) => a - b);
+  if (!set.length || set.length === 7) return "Daily";
+  if (sameDays(set, WEEKDAYS)) return "Weekdays";
+  if (sameDays(set, WEEKEND)) return "Weekends";
+  return listWords(set.map((d) => DAY_NAMES[d] ?? "").filter(Boolean));
+}
+export function describeRecurrence(r) {
+  switch (r.kind) {
+    case "minutes":
+      return r.interval <= 1 ? "Every minute" : `Every ${plural(r.interval, "minute")}`;
+    case "hourly":
+      return r.minute === 0 ? "Hourly, on the hour" : `Hourly at :${String(r.minute).padStart(2, "0")}`;
+    case "hours":
+      if (r.interval <= 1) return describeRecurrence({ kind: "hourly", minute: r.minute });
+      return r.minute === 0 ? `Every ${plural(r.interval, "hour")}, on the hour` : `Every ${plural(r.interval, "hour")} at :${String(r.minute).padStart(2, "0")}`;
+    case "daily":
+      return `Daily at ${at(r.hour, r.minute)}`;
+    case "times": {
+      const hours = [...new Set(r.hours)].sort((a, b) => a - b);
+      if (hours.length < 2) return describeRecurrence({ kind: "weekly", days: r.days ?? [0, 1, 2, 3, 4, 5, 6], hour: hours[0] ?? 0, minute: r.minute });
+      const phrase = dayPhrase(r.days);
+      if (saysAsSpan(hours)) {
+        const span = `hourly from ${at(hours[0], r.minute)} to ${at(hours[hours.length - 1], r.minute)}`;
+        return phrase === "Daily" ? `Hourly from ${at(hours[0], r.minute)} to ${at(hours[hours.length - 1], r.minute)}` : `${phrase}, ${span}`;
+      }
+      return `${phrase} at ${listWords(hours.map((h) => at(h, r.minute)))}`;
+    }
+    case "weekly": {
+      return `${dayPhrase(r.days)} at ${at(r.hour, r.minute)}`;
+    }
+    case "monthly":
+      return `Monthly on the ${ordinal(r.day)}, at ${at(r.hour, r.minute)}`;
+  }
+}
+export function describeCron(cron) {
+  const r = parseCron(cron);
+  return r ? describeRecurrence(r) : null;
+}
+export function cadenceRank(cron) {
+  const r = parseCron(cron);
+  if (!r) return Number.MAX_SAFE_INTEGER;
+  switch (r.kind) {
+    case "minutes":
+      return Math.max(1, r.interval);
+    case "hourly":
+      return 60;
+    case "hours":
+      return Math.max(1, r.interval) * 60;
+    case "daily":
+      return 1440;
+    // Several times a day, thinned out by the days it skips.
+    case "times":
+      return Math.round(
+        1440 / Math.max(1, r.hours.length) * (7 / Math.min(7, Math.max(1, r.days?.length ?? 7)))
+      );
+    // A schedule on five weekdays fires roughly every 1.4 days, which belongs
+    // between daily and weekly rather than lumped in with a Monday-only one.
+    case "weekly":
+      return Math.round(10080 / Math.min(7, Math.max(1, r.days.length)));
+    case "monthly":
+      return 43200;
+  }
+}

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

@@ -0,0 +1,101 @@
+import type { WorkflowNode } from '../types/integrations.js';
+/**
+ * Reading the backend's validation findings — for the editor's validation
+ * banner (behavior specs/workflow-validation.md, how docs/workflow-validation.md)
+ * and for the node configuration dialog (specs/node-inspector.md AC-8).
+ *
+ * The backend reports one finding per incomplete setting, each keyed by its
+ * blob path (`blob.nodes.4.config.companyId`). The two readers want different
+ * cuts of that list:
+ *
+ * - `groupFindingsByNode` — for the banner. Rendered one-per-line that repeats
+ *   the same node name three times over for a node missing three fields, so the
+ *   banner groups them by node and names the fields instead of the messages.
+ *   The full messages ride along for the hover title.
+ * - `findingsByNodeField` — for the dialog. Above the canvas the message alone
+ *   is enough; inside a node's configuration it is not, because the dialog has
+ *   to know WHICH FIELD the sentence belongs to or the user is left comparing a
+ *   message against a form.
+ *
+ * Both live here rather than in their components because the parsing is the
+ * part worth pinning in a unit test: a finding whose path names no node must
+ * still reach the user (nothing may be silently dropped on the way to the
+ * banner), and a path shape that changes must not quietly mark the wrong field.
+ */
+export interface ValidationFinding {
+    path: string;
+    message: string;
+}
+/**
+ * Either a node with its incomplete settings, or a single finding that belongs
+ * to no node. `nodeId` discriminates the two, and `label` / `fields` are only
+ * populated in the first case — an unattributed finding has no node to name and
+ * no config key to point at, so it is rendered from `messages` alone.
+ */
+export interface FindingNodeGroup {
+    /** Blob node id, or `null` when the path names no node in the blob. */
+    nodeId: string | null;
+    /** The node's human label; `null` when `nodeId` is. */
+    label: string | null;
+    /**
+     * One compact entry per finding, in order and de-duplicated: the config key
+     * the path ends in, falling back to the message when the path carries none.
+     * **Empty when `nodeId` is `null`** — read `messages` instead.
+     */
+    fields: string[];
+    /** The full messages behind this group, in order. Never empty. */
+    messages: string[];
+}
+/**
+ * How a node is named wherever it is talked ABOUT rather than rendered: the
+ * instance name the user typed, else the manifest's name, else the raw slug.
+ * The same three steps the node card itself uses — a banner that stops after
+ * two of them prints `revenexx:business-central-create-customer` at the user.
+ */
+export declare function nodeDisplayLabel(node: WorkflowNode): string;
+/**
+ * The setting a finding is about: the config key its path ends in.
+ *
+ * Only the FIRST segment after `config.` — `config.mapping[0].source` reads as
+ * `mapping`, so two findings on different sub-paths of one field collapse to a
+ * single `fields` entry while both still count towards the banner's total. That
+ * is deliberate: the line names the setting to open, not every leaf inside it,
+ * and the full messages survive in `messages` for the hover. It does mean a node
+ * can show two field names under a header that counted three findings.
+ */
+export declare function findingFieldKey(path: string): string | null;
+/**
+ * Group findings by the node they belong to, preserving first-appearance order.
+ *
+ * A finding whose path resolves to no node becomes a group of its own (with a
+ * `null` nodeId), rendered after the node groups — it has no node to hide
+ * behind, and dropping it would lose an issue the user has to fix.
+ */
+export declare function groupFindingsByNode(findings: readonly ValidationFinding[], nodes: readonly WorkflowNode[], labelOf?: (node: WorkflowNode) => string): FindingNodeGroup[];
+/**
+ * Node id → config key → the message to show AT that setting
+ * (specs/node-inspector.md AC-8).
+ *
+ * First finding wins: the backend reports the most specific reason first, and
+ * two sentences stacked under one input would be noise.
+ *
+ * Findings whose path names no node, or no config key, are absent here on
+ * purpose — they have no field to sit next to. They still reach the user in the
+ * warnings above the canvas via `groupFindingsByNode`, so nothing is dropped.
+ */
+export declare function findingsByNodeField(findings: readonly ValidationFinding[], nodes: readonly WorkflowNode[]): Record<string, Record<string, string>>;
+/**
+ * "6 settings in 4 nodes still need fixing" — the count of findings and the count
+ * of nodes, but only naming nodes while there IS a node to attribute them to.
+ *
+ * Extracted because two surfaces have to give the same reason: the banner above
+ * the canvas, and the refusal a run comes back with (specs/workflow-validation.md
+ * AC-1 and AC-11). AC-11 exists precisely because those two disagreed — the gate
+ * named the settings and the run reported a generic failure — so the phrase they
+ * share is the wrong thing to write twice.
+ *
+ * NOT the wording of the activation toast, which is deliberately shorter ("N
+ * settings still need fixing", no node count) and pinned by AC-4. Three surfaces,
+ * two phrases; this is the one used where the node names are shown alongside.
+ */
+export declare function findingsSummary(findingCount: number, nodeCount: number): string;

package/dist/runtime/utils/validationFindings.js

@@ -0,0 +1,53 @@
+import { findManifest } from "../data/integrationNodeCatalog.js";
+import { resolveLocalized } from "./localize.js";
+export function nodeDisplayLabel(node) {
+  const manifest = findManifest(node.nodeSlug, node.nodeVersion);
+  return resolveLocalized(node.name) || resolveLocalized(manifest?.name) || node.nodeSlug;
+}
+export function findingFieldKey(path) {
+  const m = /^blob\.nodes\.\d+\.config\.([^.[]+)/.exec(path);
+  return m ? m[1] : null;
+}
+function findingNode(path, nodes) {
+  const m = /^blob\.nodes\.(\d+)\b/.exec(path);
+  return m ? nodes[Number(m[1])] : void 0;
+}
+export function groupFindingsByNode(findings, nodes, labelOf = nodeDisplayLabel) {
+  const nodeGroups = [];
+  const orphans = [];
+  const byNodeId = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const node = findingNode(finding.path, nodes);
+    if (!node) {
+      orphans.push({ nodeId: null, label: null, fields: [], messages: [finding.message] });
+      continue;
+    }
+    let group = byNodeId.get(node.id);
+    if (!group) {
+      group = { nodeId: node.id, label: labelOf(node), fields: [], messages: [] };
+      byNodeId.set(node.id, group);
+      nodeGroups.push(group);
+    }
+    const field = findingFieldKey(finding.path) ?? finding.message;
+    if (!group.fields.includes(field)) group.fields.push(field);
+    group.messages.push(finding.message);
+  }
+  return [...nodeGroups, ...orphans];
+}
+export function findingsByNodeField(findings, nodes) {
+  const out = {};
+  for (const finding of findings) {
+    const node = findingNode(finding.path, nodes);
+    if (!node) continue;
+    const field = findingFieldKey(finding.path);
+    if (!field) continue;
+    const forNode = out[node.id] ??= {};
+    forNode[field] ??= finding.message;
+  }
+  return out;
+}
+export function findingsSummary(findingCount, nodeCount) {
+  const settings = `${findingCount} setting${findingCount === 1 ? "" : "s"}`;
+  const inNodes = nodeCount ? ` in ${nodeCount} node${nodeCount === 1 ? "" : "s"}` : "";
+  return `${settings}${inNodes} still need${findingCount === 1 ? "s" : ""} fixing`;
+}

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

@@ -0,0 +1,42 @@
+import type { Ref } from 'vue';
+/**
+ * Resolves once the load a `loading` flag stands for has finished.
+ *
+ * Every composable in the studio guards its `load()` against a second caller
+ * arriving while one is in flight. Nine of them did it by handing that caller the
+ * state **as it stands** — empty, on a cold visit — so whatever it fed then fanned
+ * out over nothing and cached the nothing as an answer. On the Runs page the
+ * missed-runs tab showed neither a count nor an entry on a first visit, and the
+ * dead-letter endpoint was never called at all; the dashboard was empty for the
+ * same reason. Waiting is the honest answer, and it is what this does.
+ *
+ * The watcher lives in a **detached** scope on purpose. The caller waiting here is
+ * usually a page, and the operator can leave it while the request is still out; a
+ * watcher owned by that page would be disposed with it, this promise would never
+ * settle, and the caller's own loading flag would stay up for the rest of the
+ * session — the same tab empty again, and this time permanently. That was found by
+ * PO-219 and is the single most important line in this file.
+ *
+ * Three things it cannot do, so nobody has to find them out:
+ *
+ * - **It must not be reached during server-side setup.** `watch(source, cb)`
+ *   without `immediate` is a no-op there, so the promise would never settle and the
+ *   render would hang. Every call site is `onMounted` or an event handler today; a
+ *   `useAsyncData` / `callOnce` / `onServerPrefetch` caller has to await the load
+ *   outside setup instead.
+ * - **A hung request parks every waiting caller.** `$fetch` carries no timeout
+ *   here, so a socket that never answers keeps them waiting rather than letting
+ *   them proceed with an empty list. Deliberate — the empty list was the bug — but
+ *   it is the one input that turns this into a permanent stall.
+ * - **It does not decide what happens next.** Whether a caller that waited then
+ *   sends its own request is the difference between a forced re-read and an
+ *   ordinary one, and every guard that answered it by hand got it wrong the same
+ *   way — two forced callers each sent a request, so the flag went down with one
+ *   still out. That rule now lives in `loadGate.ts`, which is what the composables
+ *   use; call this directly only where there is nothing to decide.
+ *
+ * An already-idle flag resolves immediately rather than waiting for a load that
+ * will never start — so this is safe to call without checking first, which is what
+ * stops it becoming a hang the next time somebody reuses it.
+ */
+export declare function whenIdle(loading: Ref<boolean>): Promise<void>;

package/dist/runtime/utils/whenIdle.js

@@ -0,0 +1,12 @@
+import { effectScope, watch } from "vue";
+export function whenIdle(loading) {
+  if (!loading.value) return Promise.resolve();
+  const scope = effectScope(true);
+  return new Promise((resolve) => {
+    scope.run(() => watch(loading, (busy) => {
+      if (busy) return;
+      scope.stop();
+      resolve();
+    }));
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {
@@ -17,6 +17,7 @@
   },
   "files": [
     "dist",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "publishConfig": {
@@ -50,6 +51,7 @@
     "vue-sonner": "^2.0.0"
   },
   "devDependencies": {
+    "@changesets/cli": "^2.31.0",
     "@nuxt/module-builder": "^1.0.2",
     "@playwright/test": "^1.57.0",
     "@nuxt/kit": "^4.0.0",
@@ -63,6 +65,10 @@
   "scripts": {
     "build": "nuxt-module-build build",
     "test": "vitest run",
-    "test:e2e": "playwright test"
+    "test:e2e": "playwright test",
+    "typecheck": "node scripts/typecheck.mjs",
+    "spec:check": "node scripts/spec-check.mjs",
+    "changeset": "changeset",
+    "version-packages": "changeset version"
   }
 }