@revenexx/studio-integrations 2.6.0 → 2.8.0

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -4,6 +4,7 @@ import { errorReason } from "../utils/apiError.js";
 import { unwrapList, unwrapRecord } from "../utils/apiEnvelope.js";
 import { resolveLocalized } from "../utils/localize.js";
 import { useLoadGate } from "./useLoadGate.js";
+import { createDetailLoader, keyedBatch } from "../utils/detailLoader.js";
 const BLOB_VERSION = "v0-draft";
 const INDUSTRY_VALUES = ["mechanical-engineering", "chemicals", "wholesale", "manufacturing", "retail", "any"];
 function plainExcerpt(md) {
@@ -89,6 +90,7 @@ function applyDetail(base, api) {
     outline: nodes.map((n) => n.nodeSlug ?? n.id).filter(Boolean)
   };
 }
+let sharedLoader = null;
 export function useIntegrationsTemplates() {
   const t = useIntegrationsT();
   const rawList = useState("integrations.templates.raw", () => []);
@@ -127,26 +129,33 @@ export function useIntegrationsTemplates() {
   function get(slug) {
     return templates.value.find((t2) => t2.slug === slug) ?? null;
   }
+  const loader = sharedLoader ??= createDetailLoader({
+    fetchOne: async (slug) => unwrapRecord(await api.get(`/templates/${slug}`)),
+    // A host that predates `include=definition` ignores it and sends the plain
+    // gallery list, whose items carry no `definition`: that reads as "no batch".
+    fetchMany: async (slugs) => keyedBatch(unwrapList(await api.get(
+      `/templates?include=definition&slugs=${slugs.map(encodeURIComponent).join(",")}`
+    )), "definition")
+  }, {
+    // The most slugs the service accepts in one `slugs` filter; more is a 422.
+    batchSize: 100
+  });
+  function remember(details) {
+    const found = [...details].filter((entry) => entry[1] !== null);
+    if (!found.length) return;
+    rawDetails.value = { ...rawDetails.value, ...Object.fromEntries(found) };
+  }
   async function fetchDetail(slug) {
     const base = get(slug);
     if (!base?.fromApi) return base;
-    try {
-      const detail = unwrapRecord(await api.get(`/templates/${slug}`));
-      rawDetails.value = { ...rawDetails.value, [slug]: detail };
-      return get(slug);
-    } catch {
-      return base;
-    }
+    const detail = await loader.one(slug);
+    if (detail) remember(/* @__PURE__ */ new Map([[slug, detail]]));
+    return get(slug);
   }
-  async function ensureDetails(slugs, concurrency = 4) {
-    const queue = slugs.filter((slug) => get(slug)?.fromApi && !get(slug)?.detailLoaded);
-    const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
-      while (queue.length) {
-        const slug = queue.shift();
-        if (slug) await fetchDetail(slug);
-      }
-    });
-    await Promise.all(workers);
+  async function ensureDetails(slugs, _concurrency = 4) {
+    const wanted = slugs.filter((slug) => get(slug)?.fromApi && !get(slug)?.detailLoaded);
+    if (!wanted.length) return;
+    remember(await loader.many(wanted));
   }
   async function requirements(slug) {
     try {

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -5,6 +5,7 @@ import { assignTriggerHandles, pausedTriggers } from "../utils/workflowFile.js";
 import { errorReason } from "../utils/apiError.js";
 import { unwrapList, unwrapRecord } from "../utils/apiEnvelope.js";
 import { useLoadGate } from "./useLoadGate.js";
+import { eventConfigForPlatform } from "../data/eventTrigger.js";
 const BLOB_VERSION = "v0-draft";
 function toCockpit(api) {
   const apiBlob = api.blob ?? {};
@@ -44,6 +45,8 @@ function toCockpit(api) {
     // it) means "unknown", NOT "valid" — callers must fail open and only gate
     // activation on a non-empty array.
     warnings: api.warnings,
+    savedBy: api.saved_by_sub || api.saved_by_name || api.saved_by_email ? { sub: api.saved_by_sub ?? null, name: api.saved_by_name ?? null, email: api.saved_by_email ?? null } : null,
+    savedAt: api.saved_at ?? null,
     created_at: api.created_at ?? "",
     updated_at: api.updated_at ?? ""
   };
@@ -80,7 +83,7 @@ function toPayload(meta) {
       handle: t.id,
       type: t.type,
       name: (typeof t.name === "string" ? t.name : null) ?? null,
-      config: t.type === "webhook" ? { method: "POST", ...t.config ?? {} } : t.config ?? null,
+      config: t.type === "webhook" ? { method: "POST", ...t.config ?? {} } : t.type === "event" && t.config ? eventConfigForPlatform(t.config) : t.config ?? null,
       active: t.active ?? true
     }))
   };

package/dist/runtime/data/eventTrigger.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowTrigger } from '../types/integrations.js';
+/**
+ * The event an event trigger listens for, as the platform names it (PO-641).
+ *
+ * The platform reads `config.subject` — its save validates it, and its event
+ * consumer matches published topics against it. The studio used to write
+ * `config.event_type` instead, which the platform never read: every save of an
+ * event trigger was refused as having no event, chosen or not.
+ *
+ * `event_type` is still read, so a trigger written under the old name shows its
+ * event rather than an empty field. None should exist, since the platform refused
+ * every save that carried one; reading it costs one line.
+ */
+type TriggerConfig = WorkflowTrigger['config'];
+export declare function eventSubject(config: TriggerConfig | null | undefined): string | undefined;
+/** The event as a topic to look up — trimmed, or null while none is named. */
+export declare function eventTopicOf(config: TriggerConfig | null | undefined): string | null;
+/** The config with the chosen event stored under the platform's name, and the old name gone. */
+export declare function withEventSubject(config: TriggerConfig, subject: string): TriggerConfig;
+/** An event trigger's config as the platform takes it: `subject`, never `event_type`. */
+export declare function eventConfigForPlatform(config: TriggerConfig): TriggerConfig;
+export {};

package/dist/runtime/data/eventTrigger.js

@@ -0,0 +1,18 @@
+export function eventSubject(config) {
+  const subject = typeof config?.subject === "string" ? config.subject : void 0;
+  const legacy = typeof config?.event_type === "string" ? config.event_type : void 0;
+  return subject || legacy || subject;
+}
+export function eventTopicOf(config) {
+  return eventSubject(config)?.trim() || null;
+}
+export function withEventSubject(config, subject) {
+  const { event_type: _legacy, ...rest } = config;
+  return { ...rest, subject };
+}
+export function eventConfigForPlatform(config) {
+  if (!("event_type" in config)) return config;
+  const { event_type: _legacy, ...rest } = config;
+  const subject = eventSubject(config);
+  return subject === void 0 ? rest : { ...rest, subject };
+}

package/dist/runtime/data/integrationNodeCatalog.js

@@ -91,6 +91,6 @@ export const TRIGGER_TEMPLATES = [
       en: "Starts when something happens on the platform, for example a new customer.",
       de: "Startet, wenn auf der Plattform etwas passiert, zum Beispiel ein neuer Kunde."
     },
-    defaultConfig: { event_type: "" }
+    defaultConfig: { subject: "" }
   }
 ];

package/dist/runtime/i18n/messages/de.json

@@ -8,6 +8,8 @@
   "integration.audit.action.runStarted": "Run gestartet",
   "integration.audit.action.update": "aktualisiert",
   "integration.audit.actor.system": "System",
+  "integration.audit.detail.actorEmail": "E-Mail",
+  "integration.audit.detail.actorId": "Akteur-ID",
   "integration.audit.detail.detailsHeading": "Details",
   "integration.audit.detail.id": "ID",
   "integration.audit.detail.tenant": "Mandant",
@@ -513,6 +515,7 @@
   "integration.history.heading.description": "Jedes Speichern archiviert die vorherige Revision; die neueste ist die, die läuft, solange der Workflow aktiv ist.",
   "integration.history.heading.title": "Versionsverlauf",
   "integration.history.list.revisionLabel": "Revision {revision}",
+  "integration.history.list.savedBy": "Gespeichert von {name}",
   "integration.history.preview.title.current": "Aktuelle Version · Revision {revision}",
   "integration.history.preview.title.revision": "Revision {revision} (schreibgeschützt)",
   "integration.history.state.empty": "Noch keine archivierten Revisionen — speichern Sie eine Änderung, um die erste Momentaufnahme zu erstellen.",

package/dist/runtime/i18n/messages/en.json

@@ -8,6 +8,8 @@
   "integration.audit.action.runStarted": "run started",
   "integration.audit.action.update": "update",
   "integration.audit.actor.system": "system",
+  "integration.audit.detail.actorEmail": "E-mail",
+  "integration.audit.detail.actorId": "Actor ID",
   "integration.audit.detail.detailsHeading": "Details",
   "integration.audit.detail.id": "ID",
   "integration.audit.detail.tenant": "Tenant",
@@ -513,6 +515,7 @@
   "integration.history.heading.description": "Every save archives the previous revision; the newest one is what runs while the workflow is active.",
   "integration.history.heading.title": "Version history",
   "integration.history.list.revisionLabel": "Revision {revision}",
+  "integration.history.list.savedBy": "Saved by {name}",
   "integration.history.preview.title.current": "Current version · revision {revision}",
   "integration.history.preview.title.revision": "Revision {revision} (read-only)",
   "integration.history.state.empty": "No archived revisions yet — save a change to create the first snapshot.",

package/dist/runtime/pages/integrations/audit.vue

@@ -11,6 +11,7 @@ import {
 } from "#solar-icons";
 import { Badge, Button } from "@revenexx/studio";
 import { copyToClipboard } from "../../utils/clipboard";
+import { isBareIdentifier, personLabel } from "../../utils/personLabel";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.audit.head.title") });
 const { entries, loading, error, hasMore, load, loadMore } = useIntegrationsAudit();
@@ -55,6 +56,18 @@ function resourceName(e) {
 function fmtDate(iso) {
   return iso ? new Date(iso).toLocaleString() : "\u2014";
 }
+function actor(e) {
+  return { sub: e.actor_sub, name: e.actor_name, email: e.actor_email };
+}
+function actorLabel(e) {
+  return personLabel(actor(e)) ?? t("integration.audit.actor.system");
+}
+function actorIsId(e) {
+  return isBareIdentifier(actor(e));
+}
+function actorIsPerson(e) {
+  return !!(e.actor_name || e.actor_email);
+}
 const filterTabs = computed(() => [
   {
     key: "resource",
@@ -72,7 +85,7 @@ const filterTabs = computed(() => [
 const columns = computed(() => [
   { key: "action", label: t("integration.audit.table.column.action"), width: "130px", sortable: true, sortGetter: (e) => e.action },
   { key: "resource", label: t("integration.audit.table.column.resource"), sortable: true, sortGetter: (e) => `${e.resource_type} ${resourceName(e)}`, searchGetter: (e) => `${e.resource_type} ${resourceName(e)} ${e.action} ${e.actor_sub ?? ""}` },
-  { key: "actor", label: t("integration.audit.table.column.actor"), width: "170px", sortable: true, sortGetter: (e) => e.actor_sub ?? "" },
+  { key: "actor", label: t("integration.audit.table.column.actor"), width: "170px", sortable: true, sortGetter: (e) => personLabel(actor(e)) ?? "", searchGetter: (e) => `${e.actor_name ?? ""} ${e.actor_email ?? ""} ${e.actor_sub ?? ""}` },
   { key: "when", label: t("integration.audit.table.column.when"), width: "180px", sortable: true, sortGetter: (e) => e.created_at }
 ]);
 const selected = ref(null);
@@ -170,7 +183,10 @@ onUnmounted(() => document.removeEventListener("keydown", onKeydown));
           </div>
         </template>
         <template #cell-actor="{ row }">
-          <span class="text-sm font-mono text-muted-foreground truncate">{{ row.actor_sub ?? t("integration.audit.actor.system") }}</span>
+          <div class="min-w-0">
+            <div class="text-sm truncate" :class="actorIsPerson(row) ? 'text-[#0B0522]' : 'text-muted-foreground'"><span :class="{ 'font-mono': actorIsId(row) }">{{ actorLabel(row) }}</span></div>
+            <div v-if="row.actor_name && row.actor_email" class="text-xs text-muted-foreground truncate">{{ row.actor_email }}</div>
+          </div>
         </template>
         <template #cell-when="{ row }">
           <span class="text-sm text-muted-foreground">{{ fmtDate(row.created_at) }}</span>
@@ -227,7 +243,11 @@ onUnmounted(() => document.removeEventListener("keydown", onKeydown));
             <div class="space-y-1.5">
               <div class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.table.column.resource") }}</span><span class="font-medium text-right">{{ resourceName(selected) }}</span></div>
               <div v-if="selected.resource_id" class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.detail.id") }}</span><code class="font-mono text-xs">{{ selected.resource_id }}</code></div>
-              <div class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.table.column.actor") }}</span><code class="font-mono text-xs">{{ selected.actor_sub ?? t("integration.audit.actor.system") }}</code></div>
+              <div class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.table.column.actor") }}</span><code v-if="actorIsId(selected)" class="font-mono text-xs">{{ selected.actor_sub }}</code><span v-else class="font-medium text-right">{{ actorLabel(selected) }}</span></div>
+              <div v-if="selected.actor_name && selected.actor_email" class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.detail.actorEmail") }}</span><span class="text-right">{{ selected.actor_email }}</span></div>
+              <!-- The identifier stays for tracing — it is what the platform's own
+                   logs and the identity provider know the person by. -->
+              <div v-if="selected.actor_sub && !actorIsId(selected)" class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.detail.actorId") }}</span><code class="font-mono text-xs">{{ selected.actor_sub }}</code></div>
               <div class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.table.column.when") }}</span><span>{{ fmtDate(selected.created_at) }}</span></div>
               <div v-if="selected.tenant_id" class="flex justify-between gap-2"><span class="text-muted-foreground">{{ t("integration.audit.detail.tenant") }}</span><span>{{ selected.tenant_id }}</span></div>
             </div>

package/dist/runtime/pages/integrations/credentials.vue

@@ -36,6 +36,7 @@ import { CREDENTIAL_STATES, credentialState, credentialStateLabel, providerStepW
 import { hasRevenexxSource } from "../../utils/revenexxCredentialSource";
 import { resolveLocalized } from "../../utils/localize";
 import { fromModelValue, toItemValue, toModelValue } from "../../utils/selectOptions";
+import { keepOpenBeside } from "../../utils/dialog";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.credentials.list.head.title") });
 const { credentials, loading, error, load, create, update, remove, testInline, test, oauthAuthorizeUrl } = useIntegrationsCredentials();
@@ -339,7 +340,7 @@ async function confirmDelete() {
 
     <!-- Create / edit dialog -->
     <Dialog v-model:open="dialogOpen">
-      <DialogContent class="sm:max-w-lg">
+      <DialogContent class="sm:max-w-lg" @interact-outside="keepOpenBeside">
         <DialogHeader>
           <DialogTitle>{{ isEdit ? t("integration.credentials.shared.dialog.title.edit") : t("integration.credentials.shared.dialog.title.create") }}</DialogTitle>
           <DialogDescription class="text-sm">

package/dist/runtime/pages/integrations/secrets.vue

@@ -25,6 +25,7 @@ import {
   Label
 } from "@revenexx/studio";
 import { errorReason } from "../../utils/apiError";
+import { keepOpenBeside } from "../../utils/dialog";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.secrets.head.title") });
 const { secrets, loading, error, isValidKey, upsert, remove, load } = useIntegrationsSecrets();
@@ -103,7 +104,7 @@ const columns = computed(() => [
               {{ t("integration.secrets.action.new") }}
             </Button>
           </DialogTrigger>
-          <DialogContent>
+          <DialogContent @interact-outside="keepOpenBeside">
             <DialogHeader>
               <DialogTitle>{{ t("integration.secrets.dialog.create.title") }}</DialogTitle>
               <DialogDescription class="text-sm">

package/dist/runtime/pages/integrations/templates/[slug].vue

@@ -18,6 +18,7 @@ import NodeMark from "../../../components/Integrations/NodeMark.vue";
 import { templateCategoryLabel, templatePackageLabel } from "../../../data/integrationTemplates";
 import { describeCron } from "../../../utils/schedule";
 import { renderTemplateDescription } from "../../../utils/templateDescription";
+import { keepOpenBeside } from "../../../utils/dialog";
 const t = useIntegrationsT();
 const route = useRoute();
 const router = useRouter();
@@ -31,7 +32,7 @@ useHead({ title: () => t("integration.templates.detail.head.title", { name: tpl.
 const reqs = ref(null);
 onMounted(async () => {
   await load();
-  await Promise.all([fetchDetail(slug.value), loadNodeCatalog(), loadCredentials(), loadSecrets()]);
+  await Promise.all([fetchDetail(slug.value), loadNodeCatalog(false, { summary: true }), loadCredentials(), loadSecrets()]);
   reqs.value = await requirements(slug.value);
 });
 const descriptionHtml = computed(() => renderTemplateDescription(tpl.value?.descriptionMd));
@@ -442,7 +443,7 @@ function levelDot(level) {
 
     <!-- Install: the shared step, in this page's dialog ------------------- -->
     <Dialog v-model:open="installOpen">
-      <DialogContent class="sm:max-w-lg">
+      <DialogContent class="sm:max-w-lg" @interact-outside="keepOpenBeside">
         <DialogHeader>
           <DialogTitle>{{ t("integration.templates.detail.action.useTemplate") }}</DialogTitle>
           <DialogDescription class="text-sm">

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

@@ -10,7 +10,7 @@ useHead({ title: () => t("integration.templates.gallery.head.title") });
 const { templates, loading, error, loaded, load, ensureDetails } = useIntegrationsTemplates();
 const { load: loadNodeCatalog } = useIntegrationsNodes();
 onMounted(async () => {
-  await Promise.all([load(true), loadNodeCatalog()]);
+  await Promise.all([load(true), loadNodeCatalog(false, { summary: true })]);
   void ensureDetails(templates.value.map((t2) => t2.slug));
 });
 const search = ref("");

package/dist/runtime/pages/integrations/workflows/[id].vue

@@ -44,8 +44,10 @@ import { splitRunOutputs } from "../../../utils/runOutputs";
 import { isTerminalRun, unwrapRun } from "../../../utils/runEnvelope";
 import { findingsSummary, groupFindingsByNode, nodeDisplayLabel } from "../../../utils/validationFindings";
 import { payloadFieldsFromBlob } from "../../../data/payloadForm";
+import { eventTopicOf } from "../../../data/eventTrigger";
 import WorkflowIconView from "../../../components/Integrations/WorkflowIconView.vue";
 import { DEFAULT_RUN_DIRECTION, DEFAULT_RUN_SORT } from "../../../utils/runFeedQuery";
+import { keepOpenBeside } from "../../../utils/dialog";
 const t = useIntegrationsT();
 const route = useRoute();
 const router = useRouter();
@@ -453,8 +455,7 @@ const eventLog = typeof useIntegrationsEvents === "function" ? useIntegrationsEv
 const prefillBusy = ref(null);
 const eventTriggerTopic = computed(() => {
   const trigger = (workflow.value?.blob.triggers ?? []).find((t2) => t2.type === "event");
-  const topic = trigger?.config?.event_type;
-  return typeof topic === "string" && topic.trim() !== "" ? topic.trim() : null;
+  return eventTopicOf(trigger?.config);
 });
 watch(runPayloadOpen, (open) => {
   if (open && eventTriggerTopic.value) void definedEvents.load();
@@ -1198,7 +1199,7 @@ async function confirmDeactivate() {
 
     <!-- The run dialog — opened by the editor's Run button. -->
     <Dialog v-model:open="runPayloadOpen">
-      <DialogContent class="sm:max-w-lg">
+      <DialogContent class="sm:max-w-lg" @interact-outside="keepOpenBeside">
         <DialogHeader>
           <DialogTitle>{{ t("integration.editor.runPayload.dialog.title") }}</DialogTitle>
           <DialogDescription class="text-sm">

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

@@ -1,7 +1,5 @@
 /**
- * Starts realtime once per tab, client-only.
- *
- * TWO THINGS HAPPEN HERE AND NEITHER HAPPENS ANYWHERE ELSE.
+ * Starts the realtime client once per tab, client-only — and takes no channel.
  *
  * `usePlatformTalkback()` is what BUILDS the Talkback client: it imports the
  * package, mints a connection token and opens the socket on its first call, then
@@ -12,18 +10,22 @@
  * 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.
+ * THE STUDIO'S SUBSCRIPTIONS ARE NOT TAKEN HERE ANY MORE (PE-990). Warming
+ * `useIntegrationsRealtime()` from this plugin subscribed eleven channels — run ×5,
+ * workflow ×3, build ×3, each its own subscription-token mint — on every boot of
+ * every host page, the cockpit's commerce and settings pages included, where nothing
+ * reads them. The first Integration Studio surface that calls
+ * `useIntegrationsRealtime()` takes them now (runs list, a workflow, a run panel,
+ * the workflows list); the composable's detached scope keeps them for the rest of
+ * the tab, so leaving that surface does not drop them. Every promise in
+ * `specs/realtime-updates.md` is about an OPEN surface, and an open surface is
+ * exactly what subscribes.
  *
- * 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.
+ * FREE WHEN REALTIME IS OFF. An empty `talkbackHost` makes `usePlatformTalkback()`
+ * return without building anything — neither `@revenexx/talkback-js` nor
+ * `centrifuge` is imported.
  *
- * The bare names resolve per application, so a host that overrides
+ * The bare name resolves 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.

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

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

package/dist/runtime/types/integrations.d.ts

@@ -56,6 +56,8 @@ export interface WorkflowTrigger {
             endpoint_id?: string;
             url?: string;
         };
+        subject?: string;
+        /** @deprecated the platform reads `subject`; still read by `eventSubject` (PO-641) */
         event_type?: string;
         payloadFields?: DeclaredPayloadField[];
     };
@@ -235,9 +237,23 @@ export interface Workflow {
      * this is a non-empty array. See [[WorkflowWarning]].
      */
     warnings?: WorkflowWarning[];
+    /**
+     * Who saved the current revision (PO-609), as their sign-in stated it then.
+     * Null when nobody is recorded: a platform write, or a revision from before
+     * authors were recorded.
+     */
+    savedBy?: RevisionAuthor | null;
+    /** When the current revision was saved; `updated_at` also moves on a rename. Null for a revision from before this was recorded. */
+    savedAt?: string | null;
     created_at: string;
     updated_at: string;
 }
+/** Whoever saved a workflow revision. Any part may be missing; named by `personLabel`. */
+export interface RevisionAuthor {
+    sub: string | null;
+    name: string | null;
+    email: string | null;
+}
 export type NodeCategory = 'trigger' | 'action' | 'transform' | 'control' | 'io';
 export type NodeDataType = 'any' | 'object' | 'array' | 'string' | 'number' | 'boolean';
 export type OutputKind = 'default' | 'branch' | 'error';

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

@@ -0,0 +1,52 @@
+/**
+ * Reads per-slug details — one request per slug, or one request for many — with
+ * three guarantees the template previews needed (PE-990):
+ *
+ * - **One request per slug in flight.** Two surfaces asking for the same template
+ *   at once (the dashboard panel and the create dialog, or a watcher firing twice)
+ *   share the one request instead of each sending their own. The baseline showed
+ *   the first four template details fetched twice on every dashboard visit.
+ * - **A batch when the host offers one.** `fetchMany` answers a whole set in one
+ *   request. It resolves to `null` when the host does not batch (an API that
+ *   predates the endpoint), and the loader then remembers that and asks one slug
+ *   at a time from then on — so a client released before its backend still works.
+ * - **A bounded fan-out.** Single reads go through a small queue, so a gallery of
+ *   twenty cards on an older host still sends at most `concurrency` at once.
+ *   Batches are cut at `batchSize` slugs, the most one request may name; a set
+ *   above it is several batches rather than one refused request and a fallback
+ *   to single reads.
+ *
+ * A failed read resolves to `null` rather than rejecting: a preview that cannot be
+ * drawn falls back to the card without it, and one missing template must not take
+ * its neighbours down with it.
+ */
+export interface DetailSource<D> {
+    fetchOne: (slug: string) => Promise<D>;
+    /**
+     * Details for every slug the host knows, keyed by slug — or `null` when the host
+     * has no batch read, which switches the loader to single reads for good.
+     */
+    fetchMany?: (slugs: string[]) => Promise<Map<string, D> | null>;
+}
+export interface DetailLoader<D> {
+    /** One slug, sharing a read already in flight for it. */
+    one: (slug: string) => Promise<D | null>;
+    /** Several slugs: one batch where the host offers it, single reads otherwise. */
+    many: (slugs: string[]) => Promise<Map<string, D | null>>;
+    /** Whether the host has been seen to batch: `undefined` until a batch was tried. */
+    readonly batchSupported: boolean | undefined;
+}
+export declare function createDetailLoader<D>(source: DetailSource<D>, opts?: {
+    concurrency?: number;
+    batchSize?: number;
+}): DetailLoader<D>;
+/**
+ * A batch answer keyed by slug, or `null` when it is not one. A host that does not
+ * know a batch parameter usually ignores it and answers with its plain list, whose
+ * items lack the key the batch adds — every item has to carry `requiredKey` for the
+ * answer to count, so that list is read as "no batch here" rather than as a set of
+ * empty details.
+ */
+export declare function keyedBatch<T extends {
+    slug: string;
+}>(list: T[], requiredKey: string): Map<string, T> | null;

package/dist/runtime/utils/detailLoader.js

@@ -0,0 +1,65 @@
+export function createDetailLoader(source, opts = {}) {
+  const concurrency = Math.max(1, opts.concurrency ?? 4);
+  const batchSize = Math.max(1, opts.batchSize ?? Number.POSITIVE_INFINITY);
+  const inFlight = /* @__PURE__ */ new Map();
+  let batchSupported = source.fetchMany ? void 0 : false;
+  let active = 0;
+  const waiting = [];
+  async function limited(task) {
+    if (active >= concurrency) await new Promise((resolve) => waiting.push(resolve));
+    active++;
+    try {
+      return await task();
+    } finally {
+      active--;
+      waiting.shift()?.();
+    }
+  }
+  function track(slug, read) {
+    const settled = read.catch(() => null).finally(() => {
+      if (inFlight.get(slug) === settled) inFlight.delete(slug);
+    });
+    inFlight.set(slug, settled);
+    return settled;
+  }
+  function single(slug) {
+    return limited(() => source.fetchOne(slug));
+  }
+  function one(slug) {
+    return inFlight.get(slug) ?? track(slug, single(slug));
+  }
+  async function many(slugs) {
+    const unique = [...new Set(slugs.filter(Boolean))];
+    const missing = unique.filter((slug) => !inFlight.has(slug));
+    if (missing.length > 1 && source.fetchMany && batchSupported !== false) {
+      for (let i = 0; i < missing.length; i += batchSize) {
+        const chunk = missing.slice(i, i + batchSize);
+        const batch = source.fetchMany(chunk).then(
+          (found) => {
+            batchSupported = found !== null;
+            return found;
+          },
+          () => null
+        );
+        for (const slug of chunk) {
+          track(slug, batch.then((found) => found ? found.get(slug) ?? null : single(slug)));
+        }
+      }
+    } else {
+      for (const slug of missing) track(slug, single(slug));
+    }
+    const entries = await Promise.all(unique.map(async (slug) => [slug, await (inFlight.get(slug) ?? one(slug))]));
+    return new Map(entries);
+  }
+  return {
+    one,
+    many,
+    get batchSupported() {
+      return batchSupported;
+    }
+  };
+}
+export function keyedBatch(list, requiredKey) {
+  if (list.some((item) => !item || typeof item !== "object" || !(requiredKey in item))) return null;
+  return new Map(list.map((item) => [item.slug, item]));
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Keep a dialog open when the pointer or the focus lands beside it.
+ *
+ * Bound as `@interact-outside="keepOpenBeside"` on the `DialogContent` of every dialog
+ * that holds something entered or chosen — behaviour specs/dialog-dismissal.md AC-1.
+ * Without it the dialog takes any pointer-down outside its content as Cancel, and that
+ * is not always a click the operator aimed at the dialog: a host draws its toasts under
+ * the dialog's overlay, so the click that dismissed the message a step test raises
+ * closed the step's dialog and threw its settings away (PO-648).
+ *
+ * Reka reports focus moving outside the content through the same event, so a dialog
+ * bound to this stays open then as well. That is intended: focus leaving a modal is
+ * not an answer to it either.
+ *
+ * One function rather than an inline `e.preventDefault()` per dialog, so the rule has a
+ * name to grep for when the next dialog is added. Display-only dialogs — the shortcut
+ * list, a run's response, a timeline span — do not bind it: there is nothing to lose
+ * there, and a click beside them is the quickest way out.
+ */
+export declare function keepOpenBeside(event: Event): void;

package/dist/runtime/utils/dialog.js

@@ -0,0 +1,3 @@
+export function keepOpenBeside(event) {
+  event.preventDefault();
+}

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

@@ -0,0 +1,18 @@
+/**
+ * How much of each node manifest the catalogue holds (PE-990).
+ *
+ * `summary` is what `GET /nodes?fields=summary` answers with: enough to name, draw
+ * and group a node, without the settings schemas that make the full catalogue
+ * megabytes. `full` is every manifest whole, which the editor needs. The full
+ * catalogue satisfies every caller; the summary only the ones that asked for it.
+ */
+export type CatalogLevel = 'summary' | 'full';
+/** Whether a caller wanting `wanted` has to load, given what the catalogue holds. */
+export declare function catalogNeedsLoad(held: CatalogLevel | null, wanted: CatalogLevel): boolean;
+/**
+ * What to ask the service for. Never less than the catalogue already holds: a
+ * forced summary reload over a full catalogue (a signed image link expiring on the
+ * dashboard while the editor's catalogue is in memory) reads the full one again
+ * rather than cutting the editor's manifests down under it.
+ */
+export declare function catalogRequest(held: CatalogLevel | null, wanted: CatalogLevel): CatalogLevel;

package/dist/runtime/utils/nodeCatalogLevel.js

@@ -0,0 +1,7 @@
+export function catalogNeedsLoad(held, wanted) {
+  if (held === null) return true;
+  return held === "summary" && wanted === "full";
+}
+export function catalogRequest(held, wanted) {
+  return held === "full" ? "full" : wanted;
+}

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

@@ -0,0 +1,18 @@
+/** Whoever did something, as the platform recorded them (PO-609). Any part may be missing. */
+export interface PersonRef {
+    sub?: string | null;
+    name?: string | null;
+    email?: string | null;
+}
+/**
+ * What a person is called, wherever the studio names one: the name, else the
+ * e-mail, else the identifier the platform knows them by. `null` when nothing
+ * is recorded — a platform write, or a record from before people were recorded
+ * by name — and the caller decides what that says ("system", or nothing).
+ *
+ * One function for the Audit Log and the History alike, so the order cannot
+ * drift between the two surfaces that name the same people.
+ */
+export declare function personLabel(person: PersonRef | null | undefined): string | null;
+/** Whether {@link personLabel} falls back to the bare identifier — the one case set apart as an id. */
+export declare function isBareIdentifier(person: PersonRef | null | undefined): boolean;

package/dist/runtime/utils/personLabel.js

@@ -0,0 +1,6 @@
+export function personLabel(person) {
+  return person?.name || person?.email || person?.sub || null;
+}
+export function isBareIdentifier(person) {
+  return !person?.name && !person?.email && !!person?.sub;
+}