@revenexx/studio-integrations 0.5.1 → 0.6.0

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -1,12 +1,14 @@
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
+import { useLoadGate } from "./useLoadGate.js";
 export function useIntegrationsTriggers() {
   const all = useState("integrations.triggers.all", () => []);
   const loading = useState("integrations.triggers.loading", () => false);
   const error = useState("integrations.triggers.error", () => null);
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
-  const { workflows, load: loadWorkflows } = useIntegrationsWorkflows();
+  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
+  const gate = useLoadGate("integrations.triggers", { loading, loaded });
   function unwrapList(res) {
     if (Array.isArray(res)) return res;
     return res?.data ?? [];
@@ -15,9 +17,7 @@ export function useIntegrationsTriggers() {
     return unwrapList(await api.get(`/workflows/${workflowId}/triggers`));
   }
   async function loadAll(force = false) {
-    if (loading.value) return all.value;
-    if (loaded.value && !force) return all.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return all.value;
     error.value = null;
     try {
       await loadWorkflows();
@@ -25,11 +25,11 @@ export function useIntegrationsTriggers() {
         workflows.value.map(async (wf) => (await list(wf.id)).map((t) => ({ ...t, workflowName: wf.name })))
       );
       all.value = settled.flatMap((p) => p.status === "fulfilled" ? p.value : []);
-      loaded.value = true;
+      loaded.value = workflowsLoaded.value && settled.every((p) => p.status === "fulfilled");
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load triggers.";
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return all.value;
   }

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -1,6 +1,7 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
+import { useLoadGate } from "./useLoadGate.js";
 const BLOB_VERSION = "v0-draft";
 function toCockpit(api) {
   const apiBlob = api.blob ?? {};
@@ -35,6 +36,10 @@ function toCockpit(api) {
     execution_mode: api.execution_mode,
     buildStatus: api.build_status ?? null,
     buildError: api.build_error ?? null,
+    // Carried through as-is: `undefined` (e.g. the list response, which omits
+    // it) means "unknown", NOT "valid" — callers must fail open and only gate
+    // activation on a non-empty array.
+    warnings: api.warnings,
     created_at: api.created_at ?? "",
     updated_at: api.updated_at ?? ""
   };
@@ -76,6 +81,7 @@ export function useIntegrationsWorkflows() {
   const loading = useState("integrations.workflows.loading", () => false);
   const error = useState("integrations.workflows.error", () => null);
   const loaded = useState("integrations.workflows.loaded", () => false);
+  const gate = useLoadGate("integrations.workflows", { loading, loaded });
   const api = useIntegrationsApi();
   function unwrap(res) {
     return res?.data ?? res;
@@ -89,9 +95,7 @@ export function useIntegrationsWorkflows() {
     workflows.value = idx < 0 ? [...workflows.value, wf] : workflows.value.map((w) => w.id === wf.id ? wf : w);
   }
   async function load(force = false) {
-    if (loading.value) return workflows.value;
-    if (loaded.value && !force) return workflows.value;
-    loading.value = true;
+    if (!await gate.claim(force)) return workflows.value;
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/workflows")) ?? [];
@@ -100,7 +104,7 @@ export function useIntegrationsWorkflows() {
     } catch (e) {
       error.value = captureError(e, "Could not load workflows.");
     } finally {
-      loading.value = false;
+      gate.release();
     }
     return workflows.value;
   }

package/dist/runtime/composables/useLoadGate.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type { LoadGate } from '../utils/loadGate.js';
+/**
+ * A composable's load gate, keyed by the namespace its own state already uses:
+ * `useLoadGate('integrations.triggers', { loading, loaded })`.
+ *
+ * The rule lives in `utils/loadGate.ts`; this is the wiring, and the wiring is the
+ * reason it is a composable. The counters have to share the flag's fate — one per
+ * Nuxt app on the client, one per request on the server — so they are `useState`
+ * like the flag itself. A module-level counter would be shared between two
+ * concurrent server-rendered requests, and then one tenant's finished load would
+ * answer another tenant's forced caller.
+ */
+export declare function useLoadGate(key: string, flags: {
+    loading: Ref<boolean>;
+    loaded?: Ref<boolean>;
+}): LoadGate;

package/dist/runtime/composables/useLoadGate.js

@@ -0,0 +1,8 @@
+import { createLoadGate } from "../utils/loadGate.js";
+export function useLoadGate(key, flags) {
+  return createLoadGate({
+    ...flags,
+    started: useState(`${key}.started`, () => 0),
+    finished: useState(`${key}.finished`, () => 0)
+  });
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Pure core of the tidy-up branch reorder (see WorkflowEditor's
+ * `reorderBranchesByHandle`): given laid-out node positions and the outgoing
+ * edges tagged with their output-port index, compute the x moves that put
+ * each source's branch subtrees into handle order.
+ *
+ * dagre places nodes as points and is blind to which output HANDLE an edge
+ * leaves from, so a node's branches can land in the opposite left-to-right
+ * order to their handles and cross right under the node. Only self-contained,
+ * pairwise-disjoint subtrees are moved — a reconverging branch (diamond,
+ * shared descendant, outside parent) leaves the whole node untouched rather
+ * than corrupted. Idempotent: an already-ordered node yields no moves.
+ *
+ * The crossing is owned by the direct CHILD NODE's own x, not the subtree's
+ * extent: dagre centres a node over its (possibly wide) subtree, so a spine —
+ * a long main chain where each step also hangs off a short error/leaf branch —
+ * puts the leaf to the LEFT while the continuation node sits at its subtree's
+ * centre to the right, crossing out/error even though the two subtrees never
+ * share a node. So we reorder by the child nodes' positions: the children keep
+ * exactly the set of x slots they already occupy, re-slotted into handle order.
+ * That's a pure permutation — the rank's footprint (and the source's centre
+ * over it) is preserved and no branch is flung wide, whatever its subtree size.
+ *
+ * Kept free of vue-flow/component state so it can be unit-tested against
+ * hand-built graphs.
+ */
+export interface ReorderNode {
+    x: number;
+}
+export interface ReorderEdge {
+    source: string;
+    target: string;
+    /** Left-to-right index of the source's output handle this edge leaves from. */
+    portIndex: number;
+}
+/** Node id → new x, for exactly the nodes that need to move. */
+export declare function reorderBranchSubtrees(nodes: Map<string, ReorderNode>, edges: ReorderEdge[]): Map<string, number>;

package/dist/runtime/data/branchReorder.js

@@ -0,0 +1,71 @@
+export function reorderBranchSubtrees(nodes, edges) {
+  const inGraph = (e) => nodes.has(e.source) && nodes.has(e.target);
+  const children = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!inGraph(e)) continue;
+    (children.get(e.source) ?? (children.set(e.source, []), children.get(e.source))).push(e.target);
+    (parents.get(e.target) ?? (parents.set(e.target, []), parents.get(e.target))).push(e.source);
+  }
+  const subtreeOf = (root) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length) {
+      const v = stack.pop();
+      if (seen.has(v)) continue;
+      seen.add(v);
+      for (const c of children.get(v) ?? []) if (!seen.has(c)) stack.push(c);
+    }
+    return seen;
+  };
+  const branchesBySource = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!inGraph(e)) continue;
+    const byTarget = branchesBySource.get(e.source) ?? (branchesBySource.set(e.source, /* @__PURE__ */ new Map()), branchesBySource.get(e.source));
+    byTarget.set(e.target, Math.min(byTarget.get(e.target) ?? Infinity, e.portIndex));
+  }
+  const moved = /* @__PURE__ */ new Map();
+  const xOf = (id) => moved.get(id) ?? nodes.get(id).x;
+  for (const [source, byTarget] of branchesBySource) {
+    const targets = [...byTarget].map(([target, idx]) => ({ target, idx }));
+    if (targets.length < 2) continue;
+    const subtrees = new Map(targets.map((t) => [t.target, subtreeOf(t.target)]));
+    let safe = true;
+    const union = /* @__PURE__ */ new Set();
+    outer: for (const t of targets) {
+      const st = subtrees.get(t.target);
+      if (st.has(source)) {
+        safe = false;
+        break;
+      }
+      for (const m of st) {
+        if (union.has(m)) {
+          safe = false;
+          break outer;
+        }
+        union.add(m);
+        for (const p of parents.get(m) ?? []) {
+          if (p !== source && !st.has(p)) {
+            safe = false;
+            break outer;
+          }
+        }
+      }
+    }
+    if (!safe) continue;
+    const desired = [...targets].sort((a, b) => a.idx - b.idx || a.target.localeCompare(b.target));
+    const current = [...targets].sort((a, b) => xOf(a.target) - xOf(b.target) || a.target.localeCompare(b.target));
+    if (current.every((t, i) => t.target === desired[i].target)) continue;
+    const slots = current.map((t) => xOf(t.target));
+    for (let i = 0; i < desired.length; i++) {
+      const target = desired[i].target;
+      const dx = slots[i] - xOf(target);
+      if (dx !== 0) {
+        for (const m of subtrees.get(target)) {
+          moved.set(m, xOf(m) + dx);
+        }
+      }
+    }
+  }
+  return moved;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Reading the logical port name out of a canvas handle id.
+ *
+ * Each node on the canvas renders four connection points per port, one per
+ * side, so that an edge can leave and arrive without crossing a card body. The
+ * side rides along in the handle id as a `__<side>` suffix; the workflow blob
+ * stores only the port name. Everything that persists an edge, or reasons about
+ * which port an edge left from, has to read the name back out — and an id whose
+ * name is missing has to be told apart from one whose name is unusual.
+ *
+ * An output dot is `<port>__<side>`. A node's single input dot is `__in__<side>`
+ * and a group frame's is `__in__top`: the separator sits at the very front, so
+ * there is no port name in front of it. Those answer `null` — **not** the empty
+ * string, which is what a `slice(0, 0)` would hand back. Every caller writes
+ * `portFromHandleId(id) ?? 'default'`, and `??` does not fire on `''`, so an
+ * empty name would travel on past the fallback that exists to catch it.
+ *
+ * It lives here rather than in the editor because it is the one place that knows
+ * how to read an id, and because that is what makes it testable: the editor is
+ * an SFC, out of reach of the unit suite, and the defect above shipped once
+ * already without anything going red.
+ */
+export declare function portFromHandleId(handleId: string | null | undefined): string | null;

package/dist/runtime/data/handleId.js

@@ -0,0 +1,6 @@
+const SIDE_SUFFIX = /__(?:top|right|bottom|left)$/;
+export function portFromHandleId(handleId) {
+  if (!handleId) return null;
+  const name = handleId.replace(SIDE_SUFFIX, "");
+  return name.startsWith("__") || !name ? null : name;
+}

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

@@ -3,9 +3,48 @@ import type { WorkflowTemplate } from '../types/integrations.js';
  * Category lens config for the Templates catalogue. The templates themselves
  * come live from the Integrations registry (`GET /templates`) — there is no
  * mock catalogue; an empty registry is an empty catalogue.
+ *
+ * The two categories that templates actually ship with today are `commerce` and
+ * `sales`: the eight templates in `@revenexx/integrations-nodes-core` are all
+ * `commerce`, the two in the Business Central package `sales`. Neither was named
+ * here, so both were shown by the fallback rather than by a label — the studio's
+ * one list of categories described none of the catalogue it had. The other six
+ * are named on spec and nothing publishes them yet.
  */
 export declare const TEMPLATE_CATEGORIES: Array<{
     key: WorkflowTemplate['category'];
     label: string;
     color: string;
 }>;
+/**
+ * What a template's category is called, wherever the studio shows one.
+ *
+ * Four surfaces draw a category chip — the gallery, a template's own page, the
+ * dashboard's template panel and the start-from-a-template list in the dialog that
+ * creates a workflow — and each worked the name out for itself: a lookup with a
+ * capitalisation fallback, the raw registry key, and two separate capitalisations.
+ * They agreed only by coincidence, because every label in `TEMPLATE_CATEGORIES`
+ * above happens to be its key capitalised.
+ *
+ * That coincidence ends with the first category whose name is not a capitalisation
+ * — `crm`, `b2b`, `erp` — and categories arrive with node packages rather than with
+ * a release of the studio, so it is a matter of when. Every chip goes through here
+ * instead.
+ *
+ * The fallback is the catalogue's own promise (`specs/templates.md` AC-2): a
+ * category the studio has never been taught still gets a chip, named as well as it
+ * can be rather than dropped. That guarantee held on the gallery alone before; it
+ * now holds on all four.
+ */
+export declare function templateCategoryLabel(key: string): string;
+/**
+ * The integration a template ships with, as a card badges it — and as the
+ * gallery's search matches it. The core toolbox stays unbadged: every template
+ * would carry it, so it would say nothing.
+ *
+ * It lives here for the same reason `templateCategoryLabel` does. The gallery
+ * both shows this label and searches by it, so a copy inside the card component
+ * would be a second implementation of a name — the exact duplication PO-243
+ * removes.
+ */
+export declare function templatePackageLabel(tpl: Pick<WorkflowTemplate, 'package'>): string | null;

package/dist/runtime/data/integrationTemplates.js

@@ -1,5 +1,7 @@
 export const TEMPLATE_CATEGORIES = [
   // Uniform muted pill — the label carries the meaning, no rainbow needed.
+  { key: "commerce", label: "Commerce", color: "bg-slate-100 text-slate-700" },
+  { key: "sales", label: "Sales", color: "bg-slate-100 text-slate-700" },
   { key: "sync", label: "Sync", color: "bg-slate-100 text-slate-700" },
   { key: "notification", label: "Notification", color: "bg-slate-100 text-slate-700" },
   { key: "fulfilment", label: "Fulfilment", color: "bg-slate-100 text-slate-700" },
@@ -7,3 +9,16 @@ export const TEMPLATE_CATEGORIES = [
   { key: "finance", label: "Finance", color: "bg-slate-100 text-slate-700" },
   { key: "reporting", label: "Reporting", color: "bg-slate-100 text-slate-700" }
 ];
+export function templateCategoryLabel(key) {
+  if (!key) return "";
+  const known = TEMPLATE_CATEGORIES.find((c) => c.key === key);
+  if (known) return known.label;
+  return key.charAt(0).toUpperCase() + key.slice(1);
+}
+export function templatePackageLabel(tpl) {
+  const pkg = tpl.package;
+  if (!pkg) return null;
+  const tail = (pkg.name.split("/").pop() ?? pkg.name).replace(/^integrations-nodes-/, "");
+  if (tail === "core") return null;
+  return pkg.label ?? tail.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ");
+}

package/dist/runtime/data/integrationWorkflowSamples.js

@@ -137,7 +137,7 @@ export const SAMPLE_WORKFLOWS = [
         }
       ],
       variables: {
-        source: { type: "string", default: "primary", required: false }
+        source: { type: "string", default: "primary" }
       },
       nodes: [
         {

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

@@ -0,0 +1,2 @@
+/** Resolve a manifest icon name to a Lucide component (Box as last resort). */
+export declare function nodeIcon(name?: string | null): unknown;

package/dist/runtime/data/nodeIcons.js

@@ -0,0 +1,73 @@
+import * as Lucide from "lucide-vue-next";
+const MDI_TO_LUCIDE = {
+  "account-group-outline": "Users",
+  "account-outline": "User",
+  "account-plus-outline": "UserPlus",
+  "alert-octagon": "OctagonAlert",
+  "api": "Webhook",
+  "book-open-outline": "BookOpen",
+  "bullseye-arrow": "Target",
+  "calendar-check-outline": "CalendarCheck",
+  "card-account-details-outline": "IdCard",
+  "cart-outline": "ShoppingCart",
+  "cart-plus": "ShoppingBasket",
+  "circle-outline": "Circle",
+  "clock-outline": "Clock",
+  "cloud-download": "CloudDownload",
+  "cloud-upload": "CloudUpload",
+  "cloud-upload-outline": "CloudUpload",
+  "code-brackets": "Brackets",
+  "code-json": "Braces",
+  "code-tags": "Code",
+  "compare-horizontal": "ArrowLeftRight",
+  "currency-eur": "Euro",
+  "database-cog-outline": "Database",
+  "database-export-outline": "HardDriveUpload",
+  "database-import-outline": "HardDriveDownload",
+  "domain": "Building2",
+  "email-send": "Send",
+  "file-edit-outline": "FilePen",
+  "file-export-outline": "FileOutput",
+  "file-import-outline": "FileInput",
+  "file-move-outline": "FileSymlink",
+  "file-plus": "FilePlus",
+  "file-question-outline": "FileQuestion",
+  "file-remove-outline": "FileX",
+  "filter": "Filter",
+  "find-replace": "Replace",
+  "folder-download-outline": "FolderDown",
+  "folder-plus-outline": "FolderPlus",
+  "folder-search-outline": "FolderSearch",
+  "folder-upload-outline": "FolderUp",
+  "folder-zip-outline": "FolderArchive",
+  "format-list-bulleted-type": "List",
+  "handshake": "Handshake",
+  "handshake-outline": "Handshake",
+  "link-lock": "Link2",
+  "magnify": "Search",
+  "office-building-outline": "Building",
+  "pencil-box-outline": "SquarePen",
+  "pipe": "Workflow",
+  "receipt-outline": "Receipt",
+  "receipt-text-outline": "ReceiptText",
+  "regex": "Regex",
+  "repeat": "Repeat",
+  "ruler": "Ruler",
+  "source-branch": "GitBranch",
+  "tag-multiple-outline": "Tags",
+  "transfer": "ArrowRightLeft",
+  "translate": "Languages",
+  "truck-outline": "Truck",
+  "web": "Globe",
+  "xml": "CodeXml"
+};
+export function nodeIcon(name) {
+  if (!name) return Lucide.Box;
+  const bare = name.includes(":") ? name.split(":").pop() : name;
+  const mapped = MDI_TO_LUCIDE[bare];
+  if (mapped && Lucide[mapped]) {
+    return Lucide[mapped];
+  }
+  const pascal = bare.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  return Lucide[pascal] || Lucide.Box;
+}

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

@@ -27,11 +27,23 @@ export interface PortEntry {
     /** Declared payload fields of this port (schema; may be empty). */
     fields: FieldEntry[];
 }
+/**
+ * A manifest declaring zero output ports describes a TERMINAL node (PO-201):
+ * the run ends there, so it gets no output handle and no edge may leave it.
+ *
+ * The distinction that matters is **declared empty vs. not known**. An absent
+ * manifest — a node that is not installed — is not terminal; we simply cannot
+ * work out its ports, and it has to stay wirable. Same for a `sourceFromConfig`
+ * or `resolveOutputs` set that expands to nothing: unresolved, not terminal.
+ * Only an explicit `[]` is the node making a statement about itself.
+ */
+export declare function isTerminalManifest(manifest: NodeManifest | null | undefined): boolean;
 /**
  * The output ports one upstream node exposes, mirroring the canvas port
- * derivation: named ports map straight over, `sourceFromConfig` ports expand
- * from the node's config values (plus the optional fallback), and a node
- * without any resolvable port still gets its `default`. Server-resolved
- * dynamic outputs, when present, replace the manifest's static list.
+ * derivation in `WorkflowNodeView.vue`. Named ports map straight over,
+ * `sourceFromConfig` ports expand from the node's config values (plus the
+ * optional fallback), and a node whose ports could not be worked out still
+ * gets its `default`. Server-resolved dynamic outputs, when present, replace
+ * the manifest's static list.
  */
 export declare function portsForNode(node: WorkflowNode, manifest: NodeManifest | null, resolvedOutputs?: NodeManifestOutput[]): PortEntry[];

package/dist/runtime/data/nodeInputData.js

@@ -44,7 +44,11 @@ function fieldEntries(raw) {
   }
   return [];
 }
+export function isTerminalManifest(manifest) {
+  return !!manifest && Array.isArray(manifest.outputs) && !manifest.outputs.length;
+}
 export function portsForNode(node, manifest, resolvedOutputs) {
+  if (isTerminalManifest(manifest)) return [];
   const list = resolvedOutputs?.length ? resolvedOutputs : manifest?.outputs ?? [];
   const ports = [];
   for (const o of list) {

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

@@ -16,8 +16,15 @@ export interface PayloadField {
     path: string;
     label: string;
 }
-/** Scan the blob's node configs and derive the payload form fields. */
-export declare function payloadFieldsFromBlob(blob: Pick<WorkflowBlob, 'nodes'>): PayloadField[];
+/**
+ * Payload form fields: fields DECLARED on a manual trigger come first (the
+ * author's explicit contract, e.g. a file field for a manual import), then
+ * every `${{ trigger.payload.* }}` reference found in node configs that the
+ * declarations don't already cover.
+ */
+export declare function payloadFieldsFromBlob(blob: Pick<WorkflowBlob, 'nodes'> & {
+    triggers?: WorkflowBlob['triggers'];
+}): PayloadField[];
 export declare function setPath(target: Record<string, unknown>, path: string, value: unknown): void;
 export declare function getPath(source: Record<string, unknown>, path: string): unknown;
 export interface AttachedFile {

package/dist/runtime/data/payloadForm.js

@@ -14,9 +14,23 @@ function labelFor(path) {
   return last.replace(/[_-]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
 }
 export function payloadFieldsFromBlob(blob) {
+  const declared = [];
+  for (const t of blob.triggers ?? []) {
+    if (t.type !== "manual") continue;
+    for (const d of t.config?.payloadFields ?? []) {
+      const path = d.path?.trim();
+      if (!path && d.kind !== "file") continue;
+      declared.push({
+        kind: d.kind === "file" ? "file" : "text",
+        path: path ?? "",
+        label: d.label?.trim() || labelFor(path || "file")
+      });
+    }
+  }
   const refs = /* @__PURE__ */ new Set();
   for (const node of blob.nodes ?? []) collectRefs(node.config, refs);
-  if (refs.size === 0) return [];
+  if (refs.size === 0 && declared.length === 0) return [];
+  const declaredPaths = new Set(declared.map((f) => f.path));
   const byPrefix = /* @__PURE__ */ new Map();
   for (const ref of refs) {
     const idx = ref.lastIndexOf(".");
@@ -26,9 +40,15 @@ export function payloadFieldsFromBlob(blob) {
     byPrefix.get(prefix).add(leaf);
   }
   const fields = [];
-  const consumed = /* @__PURE__ */ new Set();
+  const consumed = new Set(declaredPaths);
   for (const [prefix, leaves] of byPrefix) {
     if (leaves.has("data")) {
+      if (declaredPaths.has(prefix)) {
+        for (const leaf of leaves) {
+          if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
+        }
+        continue;
+      }
       fields.push({ kind: "file", path: prefix, label: prefix === "" ? "File" : labelFor(prefix) });
       for (const leaf of leaves) {
         if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
@@ -37,9 +57,13 @@ export function payloadFieldsFromBlob(blob) {
   }
   for (const ref of [...refs].sort()) {
     if (consumed.has(ref)) continue;
+    if (declared.some((d) => d.kind === "file" && (d.path === "" ? FILE_KEYS.has(ref) : ref.startsWith(d.path + ".")))) continue;
     fields.push({ kind: "text", path: ref, label: labelFor(ref) });
   }
-  return fields.sort((a, b) => a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === "file" ? -1 : 1);
+  return [
+    ...declared,
+    ...fields.sort((a, b) => a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === "file" ? -1 : 1)
+  ];
 }
 export function setPath(target, path, value) {
   if (path === "") {

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

@@ -0,0 +1,17 @@
+import type { OutputKind } from '../types/integrations.js';
+/**
+ * The colour of the dot in front of a port name, wherever a port is listed
+ * rather than drawn on the canvas: the Input panel's upstream trees and the
+ * node's own output schema.
+ *
+ * The legend mirrors `portTone` on the canvas node (PO-197): green = a real,
+ * active output — the normal continuation, including switch cases, iterator
+ * `item` and If/Filter `true`; soft rose = the error output that only runs on
+ * failure; neutral slate for `false` and fallbacks. There is no separate branch
+ * colour — the labels already say "one of several".
+ *
+ * It lives here rather than in a component because two lists render it and they
+ * must never disagree. They did once: the schema list kept a private copy and
+ * silently held the pre-PO-197 palette while the Input panel moved on.
+ */
+export declare function portDotClass(kind: OutputKind, name: string): string;

package/dist/runtime/data/portTone.js

@@ -0,0 +1,7 @@
+export function portDotClass(kind, name) {
+  if (name === "true") return "bg-emerald-500";
+  if (name === "false") return "bg-slate-500";
+  if (name === "error" || kind === "error") return "bg-rose-300";
+  if (name === "done") return "bg-emerald-500";
+  return "bg-emerald-500";
+}

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

@@ -0,0 +1,18 @@
+import type { WorkflowTrigger } from '../types/integrations.js';
+/**
+ * Mapping between the webhook Protection select and the ingress verification
+ * profiles stored on the trigger (`authProfile`/`authConfig`). Bearer is the
+ * token profile with a fixed Authorization + "Bearer " prefix.
+ *
+ * An ABSENT authProfile reads as 'token': that is what the exposure defaults
+ * to server-side (and what every endpoint provisioned before this feature
+ * got), so the select shows the effective behavior. The UI persists the
+ * choice explicitly the moment the public toggle is enabled, so anything
+ * exposed from here on carries what it shows.
+ */
+export type WebhookAuthChoice = 'none' | 'token' | 'bearer' | 'basic';
+type TriggerConfig = WorkflowTrigger['config'];
+export declare function authChoiceFromConfig(config: TriggerConfig | undefined): WebhookAuthChoice;
+/** The config patch that makes a Protection choice stored state. */
+export declare function configPatchForAuthChoice(choice: WebhookAuthChoice): Partial<TriggerConfig>;
+export {};

package/dist/runtime/data/webhookAuth.js

@@ -0,0 +1,19 @@
+export function authChoiceFromConfig(config) {
+  if (config?.authProfile === "none") return "none";
+  if (config?.authProfile === "basic") return "basic";
+  if (config?.authProfile === "token" && config?.authConfig?.prefix === "Bearer ") return "bearer";
+  return "token";
+}
+export function configPatchForAuthChoice(choice) {
+  switch (choice) {
+    case "none":
+      return { authProfile: "none", authConfig: void 0 };
+    case "bearer":
+      return { authProfile: "token", authConfig: { header: "Authorization", prefix: "Bearer " } };
+    case "basic":
+      return { authProfile: "basic", authConfig: void 0 };
+    case "token":
+    default:
+      return { authProfile: "token", authConfig: void 0 };
+  }
+}

package/dist/runtime/data/workflowIconCatalog.js

@@ -37,6 +37,7 @@ import {
   WalletMoney
 } from "#solar-icons";
 import { INTEGRATION_NODE_CATALOG } from "./integrationNodeCatalog.js";
+import { resolveLocalized } from "../utils/localize.js";
 export const WORKFLOW_SOLAR_ICONS = {
   Programming,
   Bolt,
@@ -78,10 +79,6 @@ export const WORKFLOW_SOLAR_ICONS = {
 export function solarIconFor(name) {
   return (name ? WORKFLOW_SOLAR_ICONS[name] : void 0) ?? Programming;
 }
-function loc(v) {
-  if (!v) return "";
-  return typeof v === "string" ? v : v.en ?? Object.values(v)[0] ?? "";
-}
 const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const IMAGE_URL_ID_RE = new RegExp(`node-packages/images/(${UUID})`, "i");
 const BARE_UUID_RE = new RegExp(`^${UUID}$`, "i");
@@ -109,7 +106,7 @@ export function nodeLogoOptions() {
     if (!logo?.src) continue;
     const id = imageIdFromSrc(logo.src) ?? logo.src;
     if (byId.has(id)) continue;
-    const label = m.__package?.label || (m.groups?.length ? loc(m.groups[0]) : "") || loc(m.name);
+    const label = m.__package?.label || (m.groups?.length ? resolveLocalized(m.groups[0]) : "") || resolveLocalized(m.name);
     byId.set(id, { label: label || "Integration", src: logo.src });
   }
   return [...byId.entries()].map(([id, v]) => ({ id, src: v.src, label: v.label })).sort((a, b) => a.label.localeCompare(b.label));