@revenexx/studio-integrations 0.6.0 → 0.7.0

package/dist/runtime/pages/integrations/workflows/index.vue

@@ -3,11 +3,16 @@ import { AddCircle as Plus } from "#solar-icons";
 import { Button } from "@revenexx/studio";
 import WorkflowsTable from "../../../components/Integrations/WorkflowsTable.vue";
 import WorkflowCreateDialog from "../../../components/Integrations/WorkflowCreateDialog.vue";
-useHead({ title: "Workflows \xB7 Revenexx Cockpit" });
+const t = useIntegrationsT();
+useHead({ title: () => t("integration.workflows.list.head.title") });
 const { workflows, loading, error, load } = useIntegrationsWorkflows();
 onMounted(() => {
   void load();
 });
+const { buildTick } = useIntegrationsRealtime();
+watch(buildTick, () => {
+  void load(true);
+});
 const loadFailed = computed(() => !!error && !!error.value && !workflows.value.length);
 const createOpen = ref(false);
 </script>
@@ -15,12 +20,12 @@ const createOpen = ref(false);
 <template>
   <IntegrationsLayout>
     <PageHeader
-      title="Workflows"
+      :title="t('integration.workflows.list.header.title')"
     >
       <template #actions>
         <Button class="h-7 text-sm" @click="createOpen = true">
           <Plus :size="14" />
-          New workflow
+          {{ t("integration.workflows.list.action.new") }}
         </Button>
       </template>
     </PageHeader>
@@ -29,12 +34,12 @@ const createOpen = ref(false);
       <StateCard
         v-if="loadFailed"
         variant="error"
-        title="Could not load workflows"
+        :title="t('integration.workflows.list.error.title')"
         :description="error ?? void 0"
       >
         <template #actions>
           <Button variant="outline" class="h-8 text-sm" @click="load(true)">
-            Try again
+            {{ t("integration.common.action.retry") }}
           </Button>
         </template>
       </StateCard>

package/dist/runtime/plugins/locale.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Apply the language a host configured statically (`studioIntegrations.locale`,
+ * or `NUXT_PUBLIC_STUDIO_INTEGRATIONS_LOCALE`) before anything renders.
+ *
+ * It runs ahead of the host's own plugins — module plugins are registered
+ * first — so a host that switches the language at runtime is applying its
+ * choice after this one, never being overwritten by it.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/locale.js

@@ -0,0 +1,6 @@
+import { setStudioLocale } from "../utils/localize.js";
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+export default defineNuxtPlugin(() => {
+  const configured = useRuntimeConfig().public.studioIntegrations?.locale;
+  if (configured) setStudioLocale(configured);
+});

package/dist/runtime/plugins/realtime.client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Starts realtime once per tab, client-only.
+ *
+ * TWO THINGS HAPPEN HERE AND NEITHER HAPPENS ANYWHERE ELSE.
+ *
+ * `usePlatformTalkback()` is what BUILDS the Talkback client: it imports the
+ * package, mints a connection token and opens the socket on its first call, then
+ * registers the client in studio-shared's registry. The channel composables only
+ * READ that registry — so without this call `useTalkbackTopic()` would find no
+ * client, subscribe to nothing and report a null channel, with no error anywhere.
+ * A plugin rather than a call inside the composable because building the client has
+ * side effects (a dynamic import, a WebSocket, a token mint) and a composable a
+ * component may reach during render is the wrong place for those.
+ *
+ * `useIntegrationsRealtime()` then takes the subscriptions. Warming it here rather
+ * than leaving it to the first surface that asks means an event arriving before the
+ * runs page is opened still moves the signals, and it puts the detached scope's
+ * creation at a defined point in the app's life instead of inside whichever
+ * component rendered first.
+ *
+ * BOTH ARE IDEMPOTENT AND BOTH ARE FREE WHEN REALTIME IS OFF. An empty
+ * `talkbackHost` makes `usePlatformTalkback()` return without building anything —
+ * neither `@revenexx/talkback-js` nor `centrifuge` is imported — and this plugin
+ * costs two function calls.
+ *
+ * The bare names resolve per application, so a host that overrides
+ * `usePlatformTalkback` (the standalone `studio-ui` does, because its API dev token
+ * is not one the Talkback facade will accept) gets its own client here, and a host
+ * that does not gets studio-shared's default.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/realtime.client.js

@@ -0,0 +1,4 @@
+export default defineNuxtPlugin(() => {
+  usePlatformTalkback();
+  useIntegrationsRealtime();
+});

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

@@ -22,7 +22,30 @@ export interface CredentialStateInfo {
     at?: string | null;
 }
 type TestableCredential = Pick<Credential, 'status' | 'last_test_ok' | 'last_test_at' | 'last_test_message'>;
+/** Every state a credential can be in, in the order a reader is offered them. */
+export declare const CREDENTIAL_STATES: readonly ["connected", "failed", "needs_reauth", "untested"];
+/**
+ * What a state is called for the reader, keyed rather than derived from a
+ * credential.
+ *
+ * `credentialState()` below answers "what state is this credential in, and what
+ * is it called"; this answers the second half on its own, for the list's filter,
+ * which offers all four states whether or not a credential is in them. They read
+ * the same map, so the badge on a row and the option that finds it cannot come to
+ * disagree — they did, briefly, as two copies of the same four `t()` calls.
+ */
+export declare function credentialStateLabel(key: CredentialConnState): string;
+/**
+ * The `label` is read at call time rather than held in a map beside `TONE`: a
+ * map built once would keep the language it was built in, and this function is
+ * called from inside the table's `computed()` on every render anyway.
+ */
 export declare function credentialState(c: TestableCredential): CredentialStateInfo;
-/** "just now" / "3m ago" / "2h ago" / "5d ago" / a date. Empty for no timestamp. */
+/**
+ * "just now" / "3m ago" / "2h ago" / "5d ago" / a date. Empty for no timestamp.
+ *
+ * Reuses the studio's common time words (`integration.common.time.*`) rather
+ * than minting its own — the same rule as the dashboard's `formatRelative`.
+ */
 export declare function relativeTime(iso?: string | null): string;
 export {};

package/dist/runtime/utils/credentialState.js

@@ -1,3 +1,16 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+export const CREDENTIAL_STATES = ["connected", "failed", "needs_reauth", "untested"];
+const MESSAGE_KEY = {
+  connected: "integration.credentials.state.connected",
+  failed: "integration.credentials.state.failed",
+  // Not derivable from the key: the state is called `needs_reauth` on the wire and
+  // "Needs reconnect" to a reader, which is the reason this map exists at all.
+  needs_reauth: "integration.credentials.state.needsReconnect",
+  untested: "integration.credentials.state.untested"
+};
+export function credentialStateLabel(key) {
+  return useIntegrationsT()(MESSAGE_KEY[key]);
+}
 const TONE = {
   connected: "bg-emerald-500/10 border-emerald-500/20 text-emerald-700",
   failed: "bg-rose-500/10 border-rose-500/20 text-rose-700",
@@ -5,25 +18,27 @@ const TONE = {
   untested: "bg-slate-500/10 border-slate-500/20 text-slate-600"
 };
 export function credentialState(c) {
+  const t = useIntegrationsT();
   if (c.status === "needs_reauth") {
-    return { key: "needs_reauth", label: "Needs reconnect", toneClass: TONE.needs_reauth, at: c.last_test_at };
+    return { key: "needs_reauth", label: t(MESSAGE_KEY.needs_reauth), toneClass: TONE.needs_reauth, at: c.last_test_at };
   }
   if (c.last_test_ok === true) {
-    return { key: "connected", label: "Connected", toneClass: TONE.connected, at: c.last_test_at };
+    return { key: "connected", label: t(MESSAGE_KEY.connected), toneClass: TONE.connected, at: c.last_test_at };
   }
   if (c.last_test_ok === false) {
-    return { key: "failed", label: "Failed", toneClass: TONE.failed, message: c.last_test_message, at: c.last_test_at };
+    return { key: "failed", label: t(MESSAGE_KEY.failed), toneClass: TONE.failed, message: c.last_test_message, at: c.last_test_at };
   }
-  return { key: "untested", label: "Not Connected", toneClass: TONE.untested };
+  return { key: "untested", label: t(MESSAGE_KEY.untested), toneClass: TONE.untested };
 }
 export function relativeTime(iso) {
   if (!iso) return "";
-  const t = new Date(iso).getTime();
-  if (Number.isNaN(t)) return "";
-  const ms = Date.now() - t;
-  if (ms < 6e4) return "just now";
-  if (ms < 36e5) return `${Math.floor(ms / 6e4)}m ago`;
-  if (ms < 864e5) return `${Math.floor(ms / 36e5)}h ago`;
-  if (ms < 30 * 864e5) return `${Math.floor(ms / 864e5)}d ago`;
+  const at = new Date(iso).getTime();
+  if (Number.isNaN(at)) return "";
+  const t = useIntegrationsT();
+  const ms = Date.now() - at;
+  if (ms < 6e4) return t("integration.common.time.justNow");
+  if (ms < 36e5) return t("integration.common.time.minutesAgo", Math.floor(ms / 6e4));
+  if (ms < 864e5) return t("integration.common.time.hoursAgo", Math.floor(ms / 36e5));
+  if (ms < 30 * 864e5) return t("integration.common.time.daysAgo", Math.floor(ms / 864e5));
   return new Date(iso).toLocaleDateString();
 }

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

@@ -1,12 +1,25 @@
+/**
+ * Tell the studio which language to render in. **This is the host's job**, and
+ * it is the whole contract: the module is published, so it must not go looking
+ * for the cockpit's storage keys or import the cockpit's i18n. A host with a
+ * language switcher calls this whenever the choice changes; a host with a fixed
+ * language sets `studioIntegrations.locale` in its Nuxt config instead and
+ * never calls this at all.
+ *
+ * A BCP-47 tag (`de`, `en`, `de-CH`). Empty or absent means English.
+ */
+export declare function setStudioLocale(locale: string | null | undefined): void;
+/** The language the studio is currently rendering in. Reactive when read in an effect. */
+export declare function studioLocale(): string;
 /**
  * Resolve a multilingual value from the Integrations API. The API returns
  * names and descriptions either as a plain string or as an already-parsed
  * object `{de:"…", en:"…"}` (the HTTP client does JSON decoding automatically).
  * JSON-encoded strings like `'{"de":"…","en":"…"}'` are also handled.
  *
- * Priority: 1) "en", 2) first key found. English is the cockpit default —
- * there is no working language switcher yet; browser-locale preference
- * returns together with the switcher.
+ * The language is the studio's ({@link setStudioLocale}) unless the caller
+ * names one. English is the fallback, and the map's own first entry the
+ * fallback after that.
  *
  * **This is the studio's only resolver, and that is the point.** The same three
  * lines used to sit in seventeen components under six names (`labelText`, `loc`,
@@ -22,7 +35,7 @@
  * `descriptionText`), so no grep for the rule's shape found them. Both resolve
  * text a person typed and went to `resolveDisplayName` below, not here.
  */
-export declare function resolveLocalized(value: unknown): string;
+export declare function resolveLocalized(value: unknown, locale?: string): string;
 /**
  * The same resolution, for a value that may be **text a person wrote** — a
  * node's own name, a group frame's label.
@@ -37,4 +50,4 @@ export declare function resolveLocalized(value: unknown): string;
  * resolved. Use this wherever the value can be something a person typed; use
  * `resolveLocalized` for anything that can only have come from a manifest.
  */
-export declare function resolveDisplayName(value: string | Record<string, string> | undefined | null): string;
+export declare function resolveDisplayName(value: string | Record<string, string> | undefined | null, locale?: string): string;

package/dist/runtime/utils/localize.js

@@ -1,11 +1,34 @@
-export function resolveLocalized(value) {
+import { shallowRef } from "vue";
+const uiLocale = shallowRef("en");
+export function setStudioLocale(locale) {
+  const next = typeof locale === "string" ? locale.trim() : "";
+  uiLocale.value = next || "en";
+}
+export function studioLocale() {
+  return uiLocale.value;
+}
+function pickLanguage(map, locale) {
+  const keys = Object.keys(map);
+  if (!keys.length) return "";
+  const wanted = locale.toLowerCase();
+  const base = wanted.split("-")[0];
+  const candidates = [
+    keys.find((k) => k.toLowerCase() === wanted),
+    keys.find((k) => k.toLowerCase().split("-")[0] === base),
+    keys.find((k) => k.toLowerCase().split("-")[0] === "en"),
+    keys[0]
+  ];
+  for (const key of candidates) {
+    if (key === void 0) continue;
+    const picked = map[key];
+    if (typeof picked === "string") return picked;
+  }
+  return "";
+}
+export function resolveLocalized(value, locale = uiLocale.value) {
   if (value === null || value === void 0) return "";
   if (typeof value === "object" && !Array.isArray(value)) {
-    const map = value;
-    const keys = Object.keys(map);
-    if (!keys.length) return "";
-    const picked = map["en"] ?? map[keys[0]];
-    return typeof picked === "string" ? picked : "";
+    return pickLanguage(value, locale);
   }
   if (typeof value !== "string") return String(value);
   const trimmed = value.trim();
@@ -13,12 +36,12 @@ export function resolveLocalized(value) {
   try {
     const parsed = JSON.parse(trimmed);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return trimmed;
-    return resolveLocalized(parsed);
+    return resolveLocalized(parsed, locale);
   } catch {
     return trimmed;
   }
 }
-export function resolveDisplayName(value) {
+export function resolveDisplayName(value, locale = uiLocale.value) {
   if (typeof value === "string") return value;
-  return resolveLocalized(value);
+  return resolveLocalized(value, locale);
 }

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

@@ -0,0 +1,72 @@
+/**
+ * How often a poll is still allowed to fetch once realtime is carrying the same
+ * updates.
+ *
+ * Every run surface polls: the runs list every three seconds, the detail panel
+ * every three and its timeline every ten, the replay canvas every four. That is the
+ * only thing that made a `running → completed` transition appear at all, and it is
+ * expensive — `runs.vue`'s pass fans out one request per workflow and then
+ * reconciles up to five active runs, so the list can cost dozens of requests every
+ * three seconds while anything is in flight.
+ *
+ * Talkback replaces the *latency* argument for polling, not the safety argument. So
+ * the intervals stay exactly where they are and this decides, per tick, whether the
+ * tick may spend a request: at the ordinary cadence while nothing is being reported,
+ * and at a slow safety cadence once something is.
+ *
+ * COUNTING TICKS, NOT READING A CLOCK, and that is deliberate twice over. The tick
+ * is the only thing that has actually happened — a wall-clock reading would make
+ * this disagree with a `setInterval` the browser throttled in a background tab. And
+ * `specs/runs.md` AC-12's test installs Playwright's fake clock and fast-forwards
+ * it; a `Date.now()` in here would read the fake time, which is the kind of
+ * coupling that makes a test pass for the wrong reason.
+ *
+ * WHAT `delivering` HAS TO MEAN, and this is the argument the parameter's name is
+ * carrying. Being subscribed is no evidence: a channel resolves from the local
+ * subscription, so a tenant whose event catalogue never publishes these topics holds
+ * open channels that stay silent for the life of the tab — and thinning on that state
+ * would make such a tenant ten times slower than before any of this existed, with
+ * nothing anywhere saying so. `useIntegrationsRealtime` therefore counts deliveries,
+ * and this is only ever thinned once something has really arrived.
+ *
+ * WHY A SLOW POLL RATHER THAN NONE. What is still unavailable is whether delivery is
+ * CONTINUING: a socket that dies quietly after one event keeps reading as delivering,
+ * because the per-channel confirmation that would settle it is not passed through the
+ * packages between Centrifugo and here. A budget that stopped fetching entirely would
+ * then show a stale list for as long as the tab stayed open, with nothing anywhere
+ * saying so. Backing off from three seconds to thirty gives up latency we now get
+ * from events and keeps the property that mattered: the view converges without the
+ * operator doing anything.
+ *
+ * The caller keeps its own tick-shedding (`!loading.value`) in front of this, so a
+ * tick that finds a load still out neither fetches nor spends budget — see
+ * `loadGate.ts` for why that flag is trustworthy.
+ */
+export interface PollBudgetOptions {
+    /** The caller's own interval, i.e. how much time one `due()` call stands for. */
+    intervalMs: number;
+    /** The gap between fetches while reports are arriving. */
+    liveIntervalMs: number;
+}
+export interface PollBudget {
+    /**
+     * Whether this tick may fetch. Advances the budget, so call it once per tick and
+     * last in the condition — `hasActive && !loading && budget.due(delivering)`.
+     */
+    due: (delivering: boolean) => boolean;
+    /**
+     * Counts a fetch this budget did not authorise: a report's refetch, a manual
+     * refresh, a row action, an opening surface's first read. Without it the next due
+     * tick would send a second request for a state that was just read.
+     *
+     * CALL IT IN THE LOADER, not at each call site, wherever the surface has a loader
+     * of its own to put it in — `[id].vue`'s `loadRuns`, `RunDetailPanel`'s
+     * `loadSummary` and `loadTimelineEvents`, `runs.vue`'s `reload`. A contract that
+     * asks every future caller to remember is one that ends up wider than the wiring,
+     * which is how this note came to be written.
+     */
+    spend: () => void;
+}
+/** The safety cadence every run surface backs off to while reports are arriving. */
+export declare const SAFETY_POLL_MS = 30000;
+export declare function createPollBudget(options: PollBudgetOptions): PollBudget;

package/dist/runtime/utils/pollBudget.js

@@ -0,0 +1,17 @@
+export const SAFETY_POLL_MS = 3e4;
+export function createPollBudget(options) {
+  let elapsed = 0;
+  return {
+    due(delivering) {
+      elapsed += options.intervalMs;
+      if (!delivering || elapsed >= options.liveIntervalMs) {
+        elapsed = 0;
+        return true;
+      }
+      return false;
+    },
+    spend() {
+      elapsed = 0;
+    }
+  };
+}

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

@@ -1,28 +1,3 @@
-/**
- * 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. */

package/dist/runtime/utils/schedule.js

@@ -1,4 +1,14 @@
-const DAY_NAMES = ["Sundays", "Mondays", "Tuesdays", "Wednesdays", "Thursdays", "Fridays", "Saturdays"];
+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;
@@ -126,54 +136,56 @@ export function toCron(r) {
 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) {
+  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) {
+function listWords(words, t) {
   if (words.length <= 1) return words[0] ?? "";
-  return `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+  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) {
-  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));
+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 ? "Every minute" : `Every ${plural(r.interval, "minute")}`;
+      return r.interval <= 1 ? t("integration.schedules.cron.everyMinute") : t("integration.schedules.cron.everyNMinutes", { n: r.interval });
     case "hourly":
-      return r.minute === 0 ? "Hourly, on the hour" : `Hourly at :${String(r.minute).padStart(2, "0")}`;
+      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 ? `Every ${plural(r.interval, "hour")}, on the hour` : `Every ${plural(r.interval, "hour")} at :${String(r.minute).padStart(2, "0")}`;
+      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 `Daily at ${at(r.hour, r.minute)}`;
+      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 });
-      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}`;
+        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 `${phrase} at ${listWords(hours.map((h) => at(h, r.minute)))}`;
-    }
-    case "weekly": {
-      return `${dayPhrase(r.days)} at ${at(r.hour, r.minute)}`;
+      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 `Monthly on the ${ordinal(r.day)}, at ${at(r.hour, r.minute)}`;
+      return t("integration.schedules.cron.monthlyAt", { ordinal: ordinal(r.day), time: at(r.hour, r.minute) });
   }
 }
 export function describeCron(cron) {

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

@@ -2,7 +2,7 @@ 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).
+ * 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
@@ -74,7 +74,7 @@ export declare function findingFieldKey(path: string): string | null;
 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).
+ * (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.

package/dist/runtime/utils/validationFindings.js

@@ -1,3 +1,4 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 import { findManifest } from "../data/integrationNodeCatalog.js";
 import { resolveLocalized } from "./localize.js";
 export function nodeDisplayLabel(node) {
@@ -47,7 +48,7 @@ export function findingsByNodeField(findings, nodes) {
   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`;
+  const t = useIntegrationsT();
+  const nodesClause = nodeCount ? ` ${t("integration.workflows.validation.summary.nodesClause", nodeCount)}` : "";
+  return t("integration.workflows.validation.summary", findingCount, { nodesClause });
 }

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'