@revenexx/studio-integrations 0.5.1 → 0.7.0

package/dist/runtime/utils/schedule.js

@@ -0,0 +1,219 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+import { studioLocale } from "./localize.js";
+const WEEKDAY_KEYS = [
+  "integration.schedules.cron.weekday.sunday",
+  "integration.schedules.cron.weekday.monday",
+  "integration.schedules.cron.weekday.tuesday",
+  "integration.schedules.cron.weekday.wednesday",
+  "integration.schedules.cron.weekday.thursday",
+  "integration.schedules.cron.weekday.friday",
+  "integration.schedules.cron.weekday.saturday"
+];
+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 ordinal(n) {
+  if (studioLocale().split("-")[0] === "de") return `${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, t) {
+  if (words.length <= 1) return words[0] ?? "";
+  return `${words.slice(0, -1).join(", ")} ${t("integration.common.list.and")} ${words[words.length - 1]}`;
+}
+function isEveryDay(days) {
+  if (!days) return true;
+  const set = new Set(days.map((d) => d === 7 ? 0 : d));
+  return set.size === 0 || set.size === 7;
+}
+function dayPhrase(days, t) {
+  if (isEveryDay(days)) return t("integration.schedules.cron.day.daily");
+  const set = [...new Set((days ?? []).map((d) => d === 7 ? 0 : d))].sort((a, b) => a - b);
+  if (sameDays(set, WEEKDAYS)) return t("integration.schedules.cron.day.weekdays");
+  if (sameDays(set, WEEKEND)) return t("integration.schedules.cron.day.weekends");
+  return listWords(set.map((d) => t(WEEKDAY_KEYS[d])), t);
+}
+export function describeRecurrence(r) {
+  const t = useIntegrationsT();
+  switch (r.kind) {
+    case "minutes":
+      return r.interval <= 1 ? t("integration.schedules.cron.everyMinute") : t("integration.schedules.cron.everyNMinutes", { n: r.interval });
+    case "hourly":
+      return r.minute === 0 ? t("integration.schedules.cron.hourlyOnTheHour") : t("integration.schedules.cron.hourlyAt", { minute: String(r.minute).padStart(2, "0") });
+    case "hours":
+      if (r.interval <= 1) return describeRecurrence({ kind: "hourly", minute: r.minute });
+      return r.minute === 0 ? t("integration.schedules.cron.everyNHoursOnTheHour", { n: r.interval }) : t("integration.schedules.cron.everyNHoursAt", { n: r.interval, minute: String(r.minute).padStart(2, "0") });
+    case "daily":
+      return t("integration.schedules.cron.dailyAt", { time: 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 });
+      if (saysAsSpan(hours)) {
+        const from = at(hours[0], r.minute);
+        const to = at(hours[hours.length - 1], r.minute);
+        return isEveryDay(r.days) ? t("integration.schedules.cron.spanAllDay", { from, to }) : t("integration.schedules.cron.spanWithDays", { days: dayPhrase(r.days, t), from, to });
+      }
+      return t("integration.schedules.cron.namedTimes", { days: dayPhrase(r.days, t), times: listWords(hours.map((h) => at(h, r.minute)), t) });
+    }
+    case "weekly":
+      return t("integration.schedules.cron.weeklyAt", { days: dayPhrase(r.days, t), time: at(r.hour, r.minute) });
+    case "monthly":
+      return t("integration.schedules.cron.monthlyAt", { ordinal: ordinal(r.day), time: 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/statusStyle.d.ts

@@ -13,9 +13,33 @@ export declare function statusTone(status: string | null | undefined): StatusTon
 export declare function statusClass(status: string | null | undefined): string;
 /** Tone classes directly (when you already have a tone). */
 export declare function toneClass(tone: StatusTone): string;
+/** The run-status words the studio itself displays (as opposed to whatever
+ * vocabulary Temporal or the raw API used to get there) — the only ones
+ * `runStatusLabel` translates. Anything else passes through unlabelled: a
+ * status this catalogue doesn't know is a raw field, not the studio's chrome.
+ *
+ * An array rather than a set, and exported, because the runs list offers these
+ * five as the choices it can be narrowed to and has to offer them in a fixed
+ * order. It used to keep its own copy of the list, so a sixth word added here
+ * would have been labelled everywhere and silently missing from that menu. */
+export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed", "cancelled", "queued"];
 /**
  * Raw API/Temporal run vocabulary → the cockpit's run-status labels, so a run
- * never reads "completed" in one surface and "succeeded" in another. Unknown
- * statuses pass through lowercased.
+ * never reads "completed" in one surface and "succeeded" in another. This IS
+ * the studio's own chrome (Temporal's "completed" becomes our "succeeded"), so
+ * unlike a raw `run.status` read elsewhere, it is translated. Unknown statuses
+ * still pass through lowercased, untranslated — this function only relabels
+ * the fixed run-status vocabulary, not arbitrary strings.
+ */
+/**
+ * The platform's run vocabulary reduced to the studio's own five words — Temporal's
+ * `completed` is our `succeeded`, `pending` is `queued`, and two ways of dying are
+ * both `failed`. A status this catalogue does not know comes back as itself.
+ *
+ * Exported because a run's status is used as an *identity* as well as a word: the runs
+ * list narrows by it, and what a filter stores has to be something that does not move
+ * when the reader's language does. Both sides read this, so a filter and a row can
+ * never disagree about which status they mean.
  */
+export declare function normalisedRunStatus(status: string | null | undefined): string;
 export declare function runStatusLabel(status: string | null | undefined): string;

package/dist/runtime/utils/statusStyle.js

@@ -76,7 +76,9 @@ export function statusClass(status) {
 export function toneClass(tone) {
   return TONE_CLASS[tone];
 }
-export function runStatusLabel(status) {
+export const RUN_STATUS_WORDS = ["running", "succeeded", "failed", "cancelled", "queued"];
+const RUN_STATUS_WORD_SET = new Set(RUN_STATUS_WORDS);
+export function normalisedRunStatus(status) {
   if (!status) return "";
   const s = String(status).toLowerCase().replace(/[\s-]+/g, "_");
   switch (s) {
@@ -91,3 +93,9 @@ export function runStatusLabel(status) {
       return s;
   }
 }
+export function runStatusLabel(status) {
+  const normalized = normalisedRunStatus(status);
+  if (!normalized) return "";
+  if (!RUN_STATUS_WORD_SET.has(normalized)) return normalized;
+  return useIntegrationsT()(`integration.runs.status.${normalized}`);
+}

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-configuration.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-configuration.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,54 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+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 t = useIntegrationsT();
+  const nodesClause = nodeCount ? ` ${t("integration.workflows.validation.summary.nodesClause", nodeCount)}` : "";
+  return t("integration.workflows.validation.summary", findingCount, { nodesClause });
+}

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/dist/types.d.mts

@@ -1,9 +1,5 @@
-import type { NuxtModule } from '@nuxt/schema'
-
-import type { default as Module } from './module.mjs'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
 export { default } from './module.mjs'
 
+export { type ModuleOptions } from './module.mjs'
+
 export * from '../dist/runtime/types/integrations.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "0.5.1",
+  "version": "0.7.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": {
@@ -25,7 +26,7 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.0.0",
-    "@revenexx/studio-shared": "^0.2.0",
+    "@revenexx/studio-shared": "^0.3.0",
     "@solar-icons/nuxt": "^1.2.0",
     "marked": "^18.0.5"
   },
@@ -50,9 +51,11 @@
     "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",
+    "@revenexx/talkback-js": "^0.3.0",
     "@nuxt/schema": "^4.0.0",
     "nuxt": "^4.2.2",
     "vitest": "^3.2.0",
@@ -63,6 +66,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"
   }
 }