@revenexx/studio-integrations 0.5.0 → 0.6.0

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/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;

package/dist/runtime/utils/loadGate.js

@@ -0,0 +1,22 @@
+import { whenIdle } from "./whenIdle.js";
+export function createLoadGate(state) {
+  const { loading, loaded, started, finished } = state;
+  return {
+    async claim(force = false) {
+      const askedAt = started.value;
+      while (loading.value) {
+        await whenIdle(loading);
+        if (!force) return false;
+        if (finished.value > askedAt) return false;
+      }
+      if (loaded?.value && !force) return false;
+      started.value++;
+      loading.value = true;
+      return true;
+    },
+    release() {
+      loading.value = false;
+      finished.value++;
+    }
+  };
+}

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

@@ -7,5 +7,34 @@
  * 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.
+ *
+ * **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`,
+ * `locText`, `localLabel`, `title`, `descriptionText`), all agreeing with this
+ * function by coincidence. A language switcher wired into this one place would
+ * have translated a fraction of the surface with nothing going red — so PO-229
+ * collapsed them here before building one. Anything that renders a name, a
+ * label, a description or a placeholder from the API calls this; nothing
+ * re-derives the rule.
+ *
+ * Two of the seventeen were named for their call site rather than for the rule
+ * (`WorkflowTriggerView`'s `title`, `WorkflowVariablesDialog`'s
+ * `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;
+/**
+ * The same resolution, for a value that may be **text a person wrote** — a
+ * node's own name, a group frame's label.
+ *
+ * `resolveLocalized` normalises: it trims, and it reads a leading `{` as JSON.
+ * That is right for a manifest string and wrong for a user's own, and it has
+ * already cost once (PO-204): run through the trimming resolver, the node-name
+ * field ate the space the user had just typed, so "Fetch open orders" came back
+ * as "Fetchopenorders". A name like `{"a":"b"}` would render as `b`.
+ *
+ * So a string is passed through untouched and only the localised-object form is
+ * 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;

package/dist/runtime/utils/localize.js

@@ -18,3 +18,7 @@ export function resolveLocalized(value) {
     return trimmed;
   }
 }
+export function resolveDisplayName(value) {
+  if (typeof value === "string") return value;
+  return resolveLocalized(value);
+}

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

@@ -0,0 +1,59 @@
+/**
+ * A proxy rather than a hand-written object, so the whole library stays reachable:
+ * `toast.dismiss`, `toast.promise`, `toast.custom` and whatever it gains next are
+ * forwarded and guarded on access. Listing the methods by hand would have turned the
+ * first call to an unlisted one into "undefined is not a function" — a second defect
+ * of the same shape as the one this file exists for.
+ */
+export declare const toast: ((message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number) & {
+    success: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    info: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    warning: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    error: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    custom: (component: import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    message: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
+        action?: (import("vue-sonner").Action | import("vue").Component) | undefined;
+        icon?: import("vue").Component | undefined;
+        class?: string | undefined;
+        id?: number | string | undefined;
+        position?: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
+        cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
+        toasterId?: string | undefined;
+        component?: import("vue").Component | undefined;
+        componentProps?: any;
+        richColors?: boolean | undefined;
+        invert?: boolean | undefined;
+        closeButton?: boolean | undefined;
+        dismissible?: boolean | undefined;
+        duration?: number | undefined;
+        important?: boolean | undefined;
+        onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
+        onAutoClose?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
+        cancelButtonStyle?: import("vue").CSSProperties | undefined;
+        actionButtonStyle?: import("vue").CSSProperties | undefined;
+        style?: import("vue").CSSProperties | undefined;
+        unstyled?: boolean | undefined;
+        classes?: import("vue-sonner").ToastClasses | undefined;
+        descriptionClass?: string | undefined;
+        closeButtonPosition?: ("top-left" | "top-right" | "bottom-left" | "bottom-right") | undefined;
+        testId?: string | undefined;
+    } & {
+        loading?: string | import("vue").Component;
+        success?: (string | import("vue").Component | ((data: ToastData) => import("vue").Component | string | Promise<import("vue").Component | string>)) | (import("vue-sonner").PromiseIExtendedResult | ((data: ToastData) => import("vue-sonner").PromiseIExtendedResult | Promise<import("vue-sonner").PromiseIExtendedResult>)) | undefined;
+        error?: (string | import("vue").Component | ((data: any) => import("vue").Component | string | Promise<import("vue").Component | string>)) | (import("vue-sonner").PromiseIExtendedResult | ((data: any) => import("vue-sonner").PromiseIExtendedResult | Promise<import("vue-sonner").PromiseIExtendedResult>));
+        description?: string | import("vue").Component | ((data: any) => import("vue").Component | string | Promise<import("vue").Component | string>);
+        finally?: () => void | Promise<void>;
+    }) | undefined) => (string & {
+        unwrap: () => Promise<ToastData>;
+    }) | (number & {
+        unwrap: () => Promise<ToastData>;
+    }) | {
+        unwrap: () => Promise<ToastData>;
+    } | undefined;
+    dismiss: (id?: number | string) => string | number | undefined;
+    loading: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+} & {
+    getHistory: () => (import("vue-sonner").ToastT<import("vue").Component> | import("vue-sonner").ToastToDismiss)[];
+    getToasts: () => (import("vue-sonner").ToastT<import("vue").Component> | import("vue-sonner").ToastToDismiss)[];
+};

package/dist/runtime/utils/notify.js

@@ -0,0 +1,21 @@
+import { toast as sonner } from "vue-sonner";
+function guarded(kind, fn) {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (e) {
+      console.warn(`[studio-integrations] notification dropped (${kind}): ${String(args[0])}`, e);
+      return void 0;
+    }
+  };
+}
+export const toast = new Proxy(sonner, {
+  apply(target, thisArg, args) {
+    return guarded("message", (...a) => Reflect.apply(target, thisArg, a))(...args);
+  },
+  get(target, prop) {
+    const value = Reflect.get(target, prop);
+    if (typeof value !== "function") return value;
+    return guarded(String(prop), (...args) => value.apply(target, args));
+  }
+});

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

@@ -0,0 +1,26 @@
+/**
+ * Which credential types offer the "Use revenexx …" source alternative, and
+ * under which kind.
+ *
+ * This lives apart from the component that renders it because its *parents* need
+ * it too: the detail dialog mounts that component only for the types it actually
+ * serves, since for every other type it renders nothing anyway.
+ *
+ * It was once load-bearing for a different reason — the component resolved
+ * cockpit-only composables at setup time, so mounting it outside the cockpit
+ * threw and took the surrounding form down. That is fixed (PO-222): the component
+ * asks whether those sources exist. So this guard is now tidiness rather than
+ * protection, which is also why the create dialog never having one stopped
+ * mattering.
+ */
+export type RevenexxSourceKind = 'sftp' | 'smtp' | 'api';
+export declare const REVENEXX_SOURCE_KIND_BY_SLUG: Record<string, RevenexxSourceKind>;
+/**
+ * Whether this credential type has a managed revenexx counterpart to copy from.
+ *
+ * Own properties only: `in` would answer yes for everything on the prototype
+ * chain, so a type slugged `toString` or `constructor` would pass the guard and
+ * then resolve to a function instead of a kind — and this guard is what decides
+ * whether the cockpit-coupled component mounts at all.
+ */
+export declare function hasRevenexxSource(slug: string | null | undefined): boolean;

package/dist/runtime/utils/revenexxCredentialSource.js

@@ -0,0 +1,8 @@
+export const REVENEXX_SOURCE_KIND_BY_SLUG = {
+  "revenexx:sftp": "sftp",
+  "revenexx:smtp": "smtp",
+  "revenexx:api": "api"
+};
+export function hasRevenexxSource(slug) {
+  return !!slug && Object.hasOwn(REVENEXX_SOURCE_KIND_BY_SLUG, slug);
+}