@revenexx/studio-integrations 0.5.1 → 0.7.0

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

@@ -3,29 +3,47 @@ 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 { workflows, loading, load } = useIntegrationsWorkflows();
+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>
 
 <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>
 
     <div class="p-4">
-      <WorkflowsTable :workflows="workflows" :loading="loading" />
+      <StateCard
+        v-if="loadFailed"
+        variant="error"
+        :title="t('integration.workflows.list.error.title')"
+        :description="error ?? void 0"
+      >
+        <template #actions>
+          <Button variant="outline" class="h-8 text-sm" @click="load(true)">
+            {{ t("integration.common.action.retry") }}
+          </Button>
+        </template>
+      </StateCard>
+      <WorkflowsTable v-else :workflows="workflows" :loading="loading" />
     </div>
 
     <WorkflowCreateDialog v-model:open="createOpen" />

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/types/integrations.d.ts

@@ -11,8 +11,19 @@ export type LocalizedString = string | Record<string, string>;
 export type WorkflowVariableType = 'string' | 'number' | 'boolean' | 'object' | 'array';
 export interface WorkflowVariable {
     type: WorkflowVariableType;
+    /** The value the workflow runs with — the studio labels it "Value". */
     default?: unknown;
     description?: LocalizedString;
+    /**
+     * @deprecated No effect anywhere: the engine resolves `default` regardless,
+     * and nothing validates it. Not editable in the studio any more, but kept in
+     * the type because existing blobs still carry the field and must round-trip.
+     *
+     * That round-trip does not rest on the dialog being careful: the save path
+     * spreads the stored `variables` object verbatim (`useIntegrationsWorkflows.ts`,
+     * no per-field mapping), so nothing in the studio is in a position to drop the
+     * field. Change that spread and this guarantee is what you are changing.
+     */
     required?: boolean;
 }
 export type TriggerType = 'manual' | 'schedule' | 'webhook' | 'event';
@@ -27,10 +38,35 @@ export interface WorkflowTrigger {
         timezone?: string;
         path?: string;
         method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+        /** @deprecated superseded by authProfile/authConfig — was never enforced */
         secretRef?: string;
+        /** Ingress verification profile for the public endpoint. */
+        authProfile?: 'none' | 'token' | 'basic' | 'hmac-generic' | 'stripe' | 'standard-webhooks';
+        authConfig?: {
+            header?: string;
+            prefix?: string;
+            username?: string;
+            algorithm?: string;
+            encoding?: string;
+            mode?: string;
+        };
+        public?: boolean;
+        /** Server-owned: the provisioned ingress endpoint. */
+        inbound?: {
+            endpoint_id?: string;
+            url?: string;
+        };
         event_type?: string;
+        payloadFields?: DeclaredPayloadField[];
     };
 }
+/** A payload field the workflow author declares on a manual trigger. */
+export interface DeclaredPayloadField {
+    /** Dot-path below `trigger.payload` (e.g. `orderId`, `import.file`). */
+    path: string;
+    label?: string;
+    kind?: 'text' | 'file';
+}
 export type RetryStrategy = 'linear' | 'exponential';
 export interface WorkflowNodeRetry {
     maxAttempts: number;
@@ -151,6 +187,17 @@ export type WorkflowExecutionMode = 'async_only' | 'sync_only' | 'caller_decides
  * bundle is `ready`; the API rejects runs with 409 in any other state.
  */
 export type WorkflowBuildStatus = 'pending' | 'building' | 'ready' | 'failed';
+/**
+ * A non-blocking manifest cross-validation finding returned on the create /
+ * update / show responses (never on the *list* response — that path skips the
+ * per-node DB resolution). `path` is keyed into the blob (`blob.nodes.N.config.KEY`),
+ * matching the `errors` keys of the 422 an active save is rejected with. See
+ * `docs/workflow-validation.md` (PO-186 port; behavior: specs/workflow-validation.md).
+ */
+export interface WorkflowWarning {
+    path: string;
+    message: string;
+}
 export interface Workflow {
     id: number;
     name: string;
@@ -164,6 +211,13 @@ export interface Workflow {
     buildStatus: WorkflowBuildStatus | null;
     /** Human-readable build failure reason, present when `buildStatus === 'failed'`. */
     buildError: string | null;
+    /**
+     * Non-blocking manifest validation findings for the persisted blob. Present on
+     * show/create/update, **absent (undefined) on the list response** — so `undefined`
+     * means "unknown", not "valid". Callers must fail open: only gate activation when
+     * this is a non-empty array. See [[WorkflowWarning]].
+     */
+    warnings?: WorkflowWarning[];
     created_at: string;
     updated_at: string;
 }
@@ -219,8 +273,7 @@ export interface ConfigField {
      *  (e.g. 'revenexx:business-central'). An array lets a node accept more than
      *  one credential type; the picker merges the tenant's credentials across all. */
     credentialType?: string | string[];
-    /** keys of other config fields this field's options/schema depend on. The
-     *  driving `select` fields also form the node's canvas subtitle. */
+    /** keys of other config fields this field's options/schema depend on. */
     dependsOn?: string[];
     validation?: {
         pattern?: string;
@@ -266,6 +319,8 @@ export interface NodeManifest {
         category?: string;
     }>;
     input: NodeManifestInput;
+    /** Empty marks a terminal node (PO-201): the run ends there, so the canvas
+     *  draws no output handle and no edge may leave it. */
     outputs: NodeManifestOutput[];
     config?: ConfigField[];
     /** Source package (editor-side enrichment from GET /nodes; not manifest data). */
@@ -379,7 +434,8 @@ export interface ScheduleEntry {
     workflowId: number;
     workflowName: string;
     triggerId: string;
-    cron: string;
+    /** `null` when the trigger carries no expression at all — never invented. */
+    cron: string | null;
     timezone: string;
     active: boolean;
     nextRunAt: string | null;
@@ -409,7 +465,12 @@ export interface WorkflowTemplate {
         name: string;
         label: string | null;
     } | null;
-    category: TemplateCategory;
+    /**
+     * `''` when the registry published none. The studio does not pick a category
+     * on a publisher's behalf: a chip reading "Sync" over a template nobody filed
+     * under `sync` is a name invented by the reader's side of the wire.
+     */
+    category: TemplateCategory | '';
     industries: Array<'mechanical-engineering' | 'chemicals' | 'wholesale' | 'manufacturing' | 'retail' | 'any'>;
     /** Vendor slugs this template wires together (used to compute prerequisites). */
     vendors: string[];
@@ -421,8 +482,6 @@ export interface WorkflowTemplate {
     outline: string[];
     /** Number of node instances in the canonical blob. */
     nodeCount: number;
-    /** Number of installs across the platform (used for "popular" ranking). */
-    installs: number;
     /** Author identity. */
     publisher: {
         name: string;

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

@@ -15,3 +15,50 @@ export declare class IntegrationsApiError extends Error {
     body: unknown;
     constructor(status: number, body: unknown, message: string);
 }
+/**
+ * Manifest validation issues parsed out of a 422 rejection body.
+ *
+ * Saving a workflow with `active: true` re-runs the DB-aware manifest
+ * cross-validation as a hard block: on any issue the backend responds `422`
+ * with Laravel-style `errors` keyed by the blob path
+ * (`{ "blob.nodes.0.config.credentials": ["Required config field ..."] }`).
+ * This flattens that map into `{ path, message }[]` — the same shape as the
+ * non-blocking `warnings` on a show/update response.
+ *
+ * Keys are filtered to the blob keyspace only: `blob` itself and any
+ * `blob.*` child, but **not** the sibling `blob_definition_version` (a
+ * `startsWith('blob')` would wrongly swallow it). A non-blob-keyed 422 (e.g.
+ * a duplicate-name validation error) yields `[]`, so callers can tell an
+ * activation-blocked 422 apart from an unrelated one.
+ */
+export declare function apiValidationIssues(err: unknown): {
+    path: string;
+    message: string;
+}[];
+/**
+ * Field-keyed validation messages from a rejection, as `{ field: message }`.
+ *
+ * The counterpart to `apiValidationIssues` above, for the ordinary case that has
+ * nothing to do with the workflow blob: a form field the service refused, named the
+ * way the form names it. Laravel answers a `422` with `errors` keyed by field and a
+ * list of messages per key; the first message is the one a person reads, so that is
+ * the one kept.
+ *
+ * A form uses this to put the refusal where the operator is looking — "The name has
+ * already been taken." under the Name field, rather than as a sentence somewhere
+ * else about a field they then have to find (PO-275). Keys that address the blob are
+ * left out: those belong to `apiValidationIssues`, which resolves them to nodes.
+ */
+export declare function apiFieldErrors(err: unknown): Record<string, string>;
+/**
+ * The reason a rejection gives, without the count of everything else it found.
+ *
+ * The service leads with one message and appends how many more there were — "The name
+ * has already been taken. (and 2 more errors)". That count is honest arithmetic and
+ * misleading copy: it counts by validation rule, so a missing field the service checks
+ * twice (`config`, then `config.authKey`) is two of them, while the operator can see
+ * 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).
+ */
+export declare function refusalReason(err: unknown, fallback: string): string;

package/dist/runtime/utils/apiError.js

@@ -6,3 +6,35 @@ export class IntegrationsApiError extends Error {
     this.name = "IntegrationsApiError";
   }
 }
+export function apiValidationIssues(err) {
+  if (!(err instanceof IntegrationsApiError) || err.status !== 422) return [];
+  const errors = err.body?.errors;
+  if (!errors || typeof errors !== "object") return [];
+  const issues = [];
+  for (const [key, val] of Object.entries(errors)) {
+    if (key !== "blob" && !key.startsWith("blob.")) continue;
+    const messages = Array.isArray(val) ? val : [val];
+    for (const m of messages) issues.push({ path: key, message: String(m) });
+  }
+  return issues;
+}
+export function apiFieldErrors(err) {
+  if (!(err instanceof IntegrationsApiError) || err.status !== 422) return {};
+  const errors = err.body?.errors;
+  if (!errors || typeof errors !== "object") return {};
+  const out = {};
+  for (const [key, val] of Object.entries(errors)) {
+    if (key === "blob" || key.startsWith("blob.")) continue;
+    const first = Array.isArray(val) ? val[0] : val;
+    if (first !== void 0 && first !== null) out[key] = String(first);
+  }
+  for (const key of Object.keys(out)) {
+    if (Object.keys(out).some((other) => other.startsWith(`${key}.`))) delete out[key];
+  }
+  return out;
+}
+export function refusalReason(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/cockpitSources.d.ts

@@ -0,0 +1,153 @@
+/**
+ * What the module expects a **cockpit** host to provide, and how it asks.
+ *
+ * The three managed credential types (`revenexx:sftp`, `revenexx:smtp`,
+ * `revenexx:api`) offer a "Use revenexx …" alternative to typing access data by
+ * hand: the operator picks an SFTP account, a mail credential or a fresh API key
+ * that already exists elsewhere in the cockpit, and the studio copies its access
+ * data into the credential. That is cockpit-coupled by design.
+ *
+ * The coupling is five composables the cockpit auto-imports. They are not part of
+ * this module and there is no import to write for them — in the cockpit they are
+ * simply in scope, and in any other host they are not there at all. Referencing
+ * one where it does not exist throws a `ReferenceError`, and thrown from a setup
+ * it takes the whole surrounding form down: before PO-222 that left both credential
+ * dialogs with no fields at all for those three types, so a credential of one could
+ * neither be created nor edited outside the cockpit — including in this
+ * repository's own documented dev loop, which serves exactly those three.
+ *
+ * **`typeof` on a bare identifier is the only safe way to ask.** It is the one
+ * expression that does not throw on a name that was never declared. It is
+ * deliberately not `globalThis.useConsoleTenants`: an auto-import is injected at
+ * build time as a module binding, not hung off the global object, so a
+ * `globalThis` lookup answers "absent" **in the cockpit too** — which would
+ * silently switch the feature off in the one host it exists for. That is the
+ * failure this file is most at risk of, so it is written down rather than left to
+ * be rediscovered.
+ *
+ * **The ambient declarations below must stay `declare const`, never `declare
+ * function`.** They are the same failure arriving by a second door: unimport
+ * decides what to inject by scanning the source for identifiers that are not
+ * already declared in it, and one of its exclusion patterns is
+ * `/\bfunction\s*([\w$]+)\s*\(/` — so a `declare function useConsoleSftp()` reads
+ * as "this file already provides it" and the injection is skipped. In the cockpit
+ * the name is then genuinely absent, `typeof` answers `'undefined'`, and the panel
+ * disables itself in the one host it works in. `declare const useConsoleSftp:
+ * (() => …) | undefined` is not excluded, because the pattern for a variable
+ * captures up to `=`, `;` or the line end and the captured text (`useConsoleSftp:
+ * (() => …) | undefined`) is not the bare identifier.
+ *
+ * That is measured, not read off the regex: unimport's own `injectImports`, run
+ * over this file, injects all five — and over the same file with the declarations
+ * rewritten as `declare function`, injects nothing. Repeat it that way if the
+ * spelling ever has to change. Nothing stands guard over it automatically, because
+ * a test would mean this repository taking a dependency on a build tool it does
+ * not otherwise use, to assert that tool's behaviour rather than its own.
+ */
+/**
+ * The shapes this module uses.
+ *
+ * Narrowed to the members it reads — but narrowed against the cockpit's own
+ * source (`app/composables/*.ts`, `app/types/consoleSftp.ts`), not guessed. A
+ * declaration that omits a member the code below reads is not a typing nit: it is
+ * this file claiming a contract the caller then violates, and nothing in CI
+ * typechecks these files today, so the claim has to be right by construction.
+ *
+ * Two members exist here only because the code reads them off values the cockpit
+ * may hand back as `null`: `getCredential` and `createCredential` both resolve to
+ * `MailCredential | null`, and the callers have to say what they do about it.
+ */
+export interface CockpitSources {
+    tenants: {
+        /** `ConsoleTenant[]` — the picker renders `name` and keys by `slug`. */
+        tenants: {
+            value: {
+                slug: string;
+                name: string;
+            }[];
+        };
+        onlyTenantSlug: {
+            value: string | null;
+        };
+        load: () => Promise<unknown>;
+    };
+    market: {
+        markets: {
+            value: {
+                code: string;
+                name: string;
+            }[];
+        };
+        activeCode: {
+            value: string;
+        };
+        GLOBAL_MARKET_CODE: string;
+        fetchMarkets: () => Promise<unknown>;
+    };
+    sftp: {
+        /**
+         * `ConsoleSftpAccount[]`. Provisioning is asynchronous, so a row carries both
+         * the flag and the state machine — `create()` hands back a `pending` row and
+         * the caller polls `refresh()` until one of them says active.
+         */
+        accounts: {
+            value: CockpitSftpAccount[];
+        };
+        load: (tenant: string | null) => Promise<unknown>;
+        /** `null` while the account is still provisioning (the Console answers 404). */
+        revealPassword: (tenant: string, id: number) => Promise<{
+            username: string;
+            password: string;
+            server?: string;
+        } | null>;
+        create: (tenant: string, name?: string) => Promise<CockpitSftpAccount>;
+        refresh: (tenant: string, id: number) => Promise<CockpitSftpAccount>;
+    };
+    mail: {
+        listCredentials: () => Promise<CockpitMailCredential[]>;
+        getCredential: (uuid: string) => Promise<CockpitMailCredential | null>;
+        createCredential: (input: {
+            name: string;
+            type: 'SMTP' | 'API';
+        }) => Promise<CockpitMailCredential | null>;
+    };
+    keys: {
+        create: (name: string, scopes: string[]) => Promise<{
+            secret: string;
+        }>;
+    };
+}
+/** The members of the cockpit's `ConsoleSftpAccount` this module reads. */
+export interface CockpitSftpAccount {
+    id: number;
+    /** The gateway login. `null` until the account finished provisioning. */
+    login_username: string | null;
+    status: string;
+    is_active: boolean;
+    error_message: string | null;
+}
+/**
+ * The members of the cockpit's `MailCredential` this module reads.
+ *
+ * The SMTP pair is optional on the wire: the mail engine returns it on `show` and
+ * on create, but the type does not promise it, which is why every read of it here
+ * falls back to an empty string rather than assuming.
+ */
+export interface CockpitMailCredential {
+    uuid: string;
+    name: string;
+    type?: string;
+    smtp_username?: string;
+    smtp_password?: string;
+}
+/**
+ * The cockpit's sources, or `null` in a host that does not have them.
+ *
+ * All five or none: a host with three of them is not a cockpit, and half a picker
+ * is worse than none — the operator would meet a control that lists nothing and
+ * says nothing about why. `null` is what the caller turns into "the managed
+ * sources are unavailable here", with the manual fields left in place.
+ *
+ * Must be called from a component's setup, like the composables it calls.
+ */
+export declare function cockpitSources(): CockpitSources | null;

package/dist/runtime/utils/cockpitSources.js

@@ -0,0 +1,14 @@
+export function cockpitSources() {
+  if (typeof useConsoleTenants !== "function") return null;
+  if (typeof useActiveMarket !== "function") return null;
+  if (typeof useConsoleSftp !== "function") return null;
+  if (typeof useMailAdmin !== "function") return null;
+  if (typeof useConsoleApiKeys !== "function") return null;
+  return {
+    tenants: useConsoleTenants(),
+    market: useActiveMarket(),
+    sftp: useConsoleSftp(),
+    mail: useMailAdmin(),
+    keys: useConsoleApiKeys()
+  };
+}

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/loadGate.d.ts

@@ -0,0 +1,61 @@
+import type { Ref } from 'vue';
+/**
+ * The load guard of every composable in the studio, in one place: who waits, who
+ * sends a request of its own, and the rule that keeps **one** load in flight.
+ *
+ * `whenIdle` next door only answers "has the load finished". What a caller does
+ * *after* waiting is the part every hand-written guard got wrong the same way, in
+ * both directions:
+ *
+ * - Returning the state **as it stands** handed a cold caller an empty list, which
+ *   it then fanned out over and cached as an answer (PO-219, PO-230).
+ * - Waiting and then always sending its own request lost the other half: two forced
+ *   callers woken by the same load each sent one, so `loading` went down with a
+ *   request still out. The flag stopped meaning "a load is out" — and `runs.vue`'s
+ *   poll reads exactly that flag to decide whether to shed a tick (found in review
+ *   on PO-230, reproduced with three discards in quick succession).
+ *
+ * So the gate counts loads rather than trusting a boolean. A caller that waited is
+ * satisfied by the load it waited for **unless** it asked for a fresh read, and a
+ * forced caller is satisfied only by a load that *began after it asked* — which is
+ * what "Try again", a replay and a discard all mean. Everything else waits again,
+ * so at most one request is ever out and at most one extra one is ever sent, no
+ * matter how many callers arrive during the same load.
+ *
+ * Two properties worth relying on:
+ *
+ * - **`loading` is true exactly while a load is out.** The gate is its only writer;
+ *   a caller that sets it itself breaks the same invariant again.
+ * - **A forced caller waits for at most two loads** — the one in flight, then the
+ *   one that answers it — rather than chaining behind every later arrival.
+ *
+ * The one thing it cannot do is decide what a waiting caller *returns*: that is the
+ * composable's own state, and its shape differs (a list, nothing, a page appended).
+ * `claim()` says whether to load; the caller says what to answer with.
+ */
+export interface LoadGateState {
+    /** True exactly while a load is out. Written by the gate alone. */
+    loading: Ref<boolean>;
+    /**
+     * Set by the composable once a load has actually read something. Left out where
+     * nothing is cached — the audit feed is paged by cursor, so every caller either
+     * opens it or asks for the next page.
+     */
+    loaded?: Ref<boolean>;
+    /** Loads begun. */
+    started: Ref<number>;
+    /** Loads finished. Together with `started` this is what tells a forced caller
+     * whether the answer it waited for was read after it asked. */
+    finished: Ref<number>;
+}
+export interface LoadGate {
+    /**
+     * Resolves to `true` when the caller must run the load itself — in which case
+     * `loading` is already up and `release()` is owed in a `finally`. `false` means
+     * the state now holds an answer the caller can return.
+     */
+    claim: (force?: boolean) => Promise<boolean>;
+    /** The load is done: the flag goes down and the load is counted. */
+    release: () => void;
+}
+export declare function createLoadGate(state: LoadGateState): LoadGate;