@revenexx/studio-integrations 1.1.1 → 1.3.0

package/dist/runtime/utils/buildSettle.js

@@ -0,0 +1,29 @@
+export const BUILD_SETTLE_POLL_MS = 2500;
+export const BUILD_SETTLE_TIMEOUT_MS = 5 * 6e4;
+export function isBuildUnsettled(status) {
+  return status === "pending" || status === "building";
+}
+export function createBuildSettle(options = {}) {
+  const pollMs = options.pollMs ?? BUILD_SETTLE_POLL_MS;
+  const timeoutMs = options.timeoutMs ?? BUILD_SETTLE_TIMEOUT_MS;
+  let generation = 0;
+  return {
+    async settle({ unsettled, read }) {
+      const mine = ++generation;
+      const started = Date.now();
+      while (Date.now() - started < timeoutMs) {
+        if (mine !== generation) return;
+        if (!unsettled()) return;
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        if (mine !== generation || !unsettled()) return;
+        try {
+          await read();
+        } catch {
+        }
+      }
+    },
+    stop() {
+      generation += 1;
+    }
+  };
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Put something on the clipboard, and tell the operator what actually happened.
+ *
+ * **The waiting is the point.** `writeText` returns a promise, and a browser can refuse
+ * it after the fact — a page that is not focused, a context that is not secure, a
+ * permission the operator declined. A caller that fires its "Copied" message beside the
+ * call rather than after it announces a success it has not been told about, and the
+ * operator pastes whatever was on the clipboard before. That shipped on the audit log,
+ * where the promise was neither awaited nor caught: the toast had already gone up by the
+ * time the rejection arrived, and the rejection went nowhere.
+ *
+ * **A missing `navigator.clipboard` is a failure, not a reason to do nothing.** The audit
+ * log guarded on it and skipped the whole block, so on a browser without the API the
+ * button did nothing at all — no copy, no message — which reads as broken rather than as
+ * refused. Reading through it and letting the `TypeError` land in the same `catch` is
+ * what makes "it did not work" one path instead of two.
+ *
+ * `vue-sonner` directly, not `notify.ts`: that wrapper exists so a *save* is never lost
+ * to a notification that cannot be drawn, and says in its own docblock that everywhere
+ * else imports the library. A copy has no such underlying action — the message IS the
+ * outcome — so routing six more surfaces through it would spend the indirection on the
+ * case it was explicitly not written for.
+ *
+ * The two messages stay with the caller because they are the only part that differs:
+ * copying a node's config, a webhook URL and an audit entry are three different things to
+ * have failed, and one message covering all of them would name none of them.
+ *
+ * Returns whether it worked, for a caller that has more to do than say so.
+ */
+export declare function copyToClipboard(text: string, said: {
+    copied: string;
+    failed: string;
+}): Promise<boolean>;

package/dist/runtime/utils/clipboard.js

@@ -0,0 +1,11 @@
+import { toast } from "vue-sonner";
+export async function copyToClipboard(text, said) {
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch {
+    toast.error(said.failed);
+    return false;
+  }
+  toast.success(said.copied);
+  return true;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * A deep copy of a value the studio is about to let someone edit.
+ *
+ * Every surface that edits a workflow takes one first, so that an unsaved change can
+ * be thrown away by dropping the copy rather than by undoing it: the editor's canvas,
+ * the node inspector's draft, the variables dialog's working set, a duplicate on its
+ * way to a new name, and the payload form's expert extras.
+ *
+ * **It is a JSON round trip, and that is a claim about the input rather than a
+ * shortcut.** A workflow blob is JSON — it is what the API stores and what the wire
+ * carries — so serialising and parsing it loses nothing. That is the whole guarantee,
+ * and it was the guarantee that made eight hand-written copies of this expression safe.
+ * What it cost is that the guarantee was never written down, so nothing said which
+ * inputs it holds for.
+ *
+ * **What it does not survive**, for whoever reaches for this with something that is not
+ * a blob: `undefined` becomes a missing key rather than a present one, a `Date` comes
+ * back as a string, a `Map`, a `Set` and a function are lost entirely, and a cycle
+ * throws. None of those can appear in a blob. All of them can appear in editor state
+ * that has not been through the API yet — a resolved sample, a cached schema — so a
+ * new caller is the moment to check the claim rather than to assume it.
+ *
+ * **The signature cannot enforce any of that, and says so here rather than pretending.**
+ * `<T>(value: T): T` claims the type it was handed comes back, which is false for exactly
+ * the five: `deepClone({ at: new Date() }).at` is typed `Date` and is a string, so
+ * `.getTime()` type-checks and throws. Constraining the parameter to a JSON-shaped type
+ * was tried and does not work here — `WorkflowBlob`, `WorkflowNode` and `WorkflowTrigger`
+ * are interfaces, which have no implicit index signature and so satisfy no recursive JSON
+ * type; it turned 13 type errors into 73, and collapsed the inference that gives callers
+ * their concrete type back. So the guarantee above is advisory, and the tests beside this
+ * file are where it is actually held.
+ *
+ * **Not `structuredClone`, deliberately.** It is available everywhere the module runs
+ * and it preserves all five of the things above, which sounds strictly better and is
+ * not: it would *change* what the callers get. A field that is dropped today because
+ * JSON cannot carry it would start surviving the copy, and something downstream may be
+ * relying on that loss without saying so. Swapping the mechanism is a behaviour change
+ * that wants its own proof; this module exists so that it becomes one edit when
+ * somebody makes it — which is PO-395's other half, and is not done here.
+ */
+export declare function deepClone<T>(value: T): T;

package/dist/runtime/utils/deepClone.js

@@ -0,0 +1,3 @@
+export function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}

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

@@ -0,0 +1,44 @@
+/**
+ * How long something took, in the shortest unit that still reads.
+ *
+ * One function for every surface that prints a duration: the runs table, the run
+ * record's step list, the result of a run started by hand, the replay panel's step
+ * and run figures, and the dashboard's latest executions. Private copies are how two
+ * surfaces come to spell the same milliseconds differently, which is what PO-383
+ * closed — three implementations across those five, two of them disagreeing. The
+ * dashboard's was not in the ticket's enumeration: it divided by a thousand inside
+ * the template, so it was invisible to a search for a formatter.
+ *
+ * The form is `900ms`, `1.5s`, `1m 3s`, and it was chosen rather than inherited.
+ * Three candidates stood in PO-383: this one, the two-decimal `1.50s`/`1.1m` these
+ * surfaces used to print, and the same shape as this one with a space before the
+ * unit. The unit sits against the number because that is how the product already
+ * writes a duration everywhere it is copy rather than a computed figure — `{n}s
+ * ago`, `{n}m ago`, `{n}h ago` in the message catalogue, read out beside these very
+ * values in the runs list. A space would also have had to stop applying above a
+ * minute, where `1 m 3 s` is unreadable, so it was one form under two rules.
+ *
+ * One decimal under a minute, and minutes-and-seconds above: a duration is read to
+ * answer "was that quick", so `1m 3s` beats `1.1m` for a step that took a minute,
+ * and the second decimal of `1.50s` is precision nobody acts on.
+ *
+ * **A trailing zero is dropped, because it is not always a measurement.** Two kinds of
+ * value arrive here. A *step's* duration is measured in milliseconds and a tenth of a
+ * second is a real reading — `3.4s`. A *run's* is the difference between two
+ * timestamps the platform stores to the second (`timestamp(0)`) and serialises without
+ * a fraction, so it is always a whole number of seconds: there is no run-level
+ * millisecond value anywhere in the API to be had. Printing `4.0s` there claimed a
+ * precision that cannot exist. Nothing has to be told which kind it is — a value that
+ * measured nothing below the unit has nothing after the point, so `4s` and `1m` fall
+ * out of the arithmetic while `3.4s` and `1m 3s` keep what they measured.
+ *
+ * Nothing promises the form. `specs/run-row.md` AC-3 promises that a row says how
+ * long a run has been going and deliberately not in what shape, and that stays the
+ * right altitude: a criterion pinning the spelling would freeze a decision the
+ * product may want to revisit — the next one being a locale, which this function
+ * does not take (German wants `1,5 s`).
+ *
+ * `null` is not zero: a run that has not started has no duration, and an em dash
+ * says so where `0ms` would claim it finished instantly.
+ */
+export declare function formatDuration(ms: number | null | undefined): string;

package/dist/runtime/utils/formatDuration.js

@@ -0,0 +1,13 @@
+export function formatDuration(ms) {
+  if (ms == null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  const tenths = Math.round(ms / 100);
+  if (tenths < 600) {
+    const seconds2 = tenths / 10;
+    return tenths % 10 === 0 ? `${seconds2}s` : `${seconds2.toFixed(1)}s`;
+  }
+  const seconds = Math.round(ms / 1e3);
+  const rest = seconds % 60;
+  const minutes = Math.floor(seconds / 60);
+  return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+}

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

@@ -0,0 +1,22 @@
+/** What a node display name can be derived from — the blob's own fields. */
+export interface NameableNode {
+    name?: unknown;
+    nodeSlug: string;
+    nodeVersion?: string;
+}
+/**
+ * What a node is called, wherever it is named.
+ *
+ * The three sources in order: the name the author typed, the manifest's name for
+ * that kind of node, and — where the catalogue does not know the slug — the slug
+ * itself. Never the node's id, which is a key the studio generated and nobody
+ * chose.
+ *
+ * The two resolvers are not interchangeable and the difference has already cost
+ * once (PO-204): the author's own name is passed through untouched, while a
+ * manifest string is trimmed and may carry its languages as an object. That is
+ * why this is one function rather than the rule restated wherever a node is
+ * named — the canvas card and the result of a run started by hand have to agree
+ * on what a node is called, or the dialog names something the graph does not.
+ */
+export declare function nodeDisplayName(node: NameableNode): string;

package/dist/runtime/utils/nodeDisplayName.js

@@ -0,0 +1,6 @@
+import { findManifest } from "../data/integrationNodeCatalog.js";
+import { resolveDisplayName, resolveLocalized } from "./localize.js";
+export function nodeDisplayName(node) {
+  const manifest = findManifest(node.nodeSlug, node.nodeVersion);
+  return resolveDisplayName(node.name) || resolveLocalized(manifest?.name) || node.nodeSlug;
+}

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

@@ -18,7 +18,6 @@ export declare const toast: ((message: string | (() => string | import("vue").Co
         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;
@@ -28,6 +27,7 @@ export declare const toast: ((message: string | (() => string | import("vue").Co
         dismissible?: boolean | undefined;
         duration?: number | undefined;
         important?: boolean | undefined;
+        cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
         onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
         onAutoClose?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
         cancelButtonStyle?: import("vue").CSSProperties | undefined;

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

@@ -0,0 +1,31 @@
+/** A run as the API sends it, before anything has been read out of it. */
+export type RunLike = Record<string, unknown>;
+/**
+ * The run out of a single-run response, enveloped or not.
+ *
+ * `GET /workflows/{id}/runs/{runId}` answers the run itself, and the studio's own
+ * mock and some callers wrap it in `{ data: … }`. So the envelope has to be
+ * optional — but unwrapping on the mere presence of a `data` key is wrong: a run
+ * that ever carried one would be unwrapped into it, and the caller would be
+ * handed a field instead of a run. Hence the two guards: a body that already
+ * looks like a run (`status`, `temporal_run_id`) is the run, whatever else it has
+ * on it.
+ *
+ * This is deliberately generous about the *rest* of the shape. It answers "where
+ * is the run in this body", not "is this a usable run" — the caller decides that,
+ * because a caller following a run has to be able to count an unusable answer as
+ * a failed read rather than sit on it.
+ */
+/**
+ * The raw platform statuses a run does not come back from.
+ *
+ * The platform's own words, not the studio's five — the single-run endpoint answers
+ * `completed` where a row would read "succeeded" (`utils/statusStyle.ts` maps one to
+ * the other), and anything reading this is reading the endpoint.
+ */
+export declare const RUN_TERMINAL: Set<string>;
+/** Whether this run has ended, as the platform reports it. */
+export declare function isTerminalRun(run: {
+    status?: unknown;
+} | null | undefined): boolean;
+export declare function unwrapRun(res: unknown): RunLike | null;

package/dist/runtime/utils/runEnvelope.js

@@ -0,0 +1,12 @@
+export const RUN_TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "canceled", "terminated", "timed_out"]);
+export function isTerminalRun(run) {
+  return RUN_TERMINAL.has(String(run?.status ?? "").toLowerCase());
+}
+export function unwrapRun(res) {
+  if (!res || typeof res !== "object") return null;
+  const o = res;
+  if ("data" in o && o.data && typeof o.data === "object" && !("status" in o) && !("temporal_run_id" in o)) {
+    return o.data;
+  }
+  return o;
+}

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

@@ -0,0 +1,135 @@
+import type { RunStatus, TriggerType } from '../types/integrations.js';
+/**
+ * The narrowing of the tenant Runs list, translated for the platform.
+ *
+ * The list narrows on the server now, so the words the studio puts on its filter
+ * have to reach an endpoint that speaks a different vocabulary. The studio draws
+ * five outcomes; the platform accepts six statuses, two of which the studio folds
+ * into one word. Everything here exists to keep that fold from making a filter
+ * contradict the column it sits under — or, as happened once, from asking for a
+ * word the platform refuses outright.
+ *
+ * Kept out of the composable so it can be read on its own — the collapse is the
+ * one piece of this feature that is wrong in a way nothing on screen would show.
+ */
+/**
+ * Every status the platform ACCEPTS in a `status` filter: the six cases of
+ * `RunStatus` in the integrations service (`app/Enums/RunStatus.php`), and
+ * nothing else.
+ *
+ * Copied from the enum, not from prose about it. It was written from a comment
+ * once and carried a seventh value, `timed_out`, which that enum does not have —
+ * so choosing "failed" sent `failed,terminated,timed_out` and the platform
+ * answered `422 The selected status.2 is invalid`. The filter did not narrow
+ * badly; it failed outright.
+ *
+ * This is deliberately NOT "every status a run can carry". `workflow_runs.status`
+ * is an uncast string column and the service's own summary endpoint accounts for
+ * values outside the enum, so a row may arrive carrying one — `mapRunStatus`
+ * therefore stays tolerant about what it READS. Only what is SENT is bounded by
+ * this list.
+ */
+export declare const API_RUN_STATUSES: readonly ["pending", "running", "completed", "failed", "cancelled", "terminated"];
+/**
+ * Platform status → the word the studio draws.
+ *
+ * Tolerant on purpose, and wider than {@link API_RUN_STATUSES}: the status column
+ * is an uncast string on the platform's side, so a row can arrive carrying a word
+ * the enum does not list. `terminated` and `timed_out` are failures to an
+ * operator and the column says so; anything else fails closed for the reason it
+ * does everywhere else — a run the platform cannot classify must never read as a
+ * stuck `running`.
+ */
+export declare function mapRunStatus(status: string): RunStatus;
+/**
+ * The platform statuses behind the studio's words.
+ *
+ * DERIVED from `mapRunStatus` rather than written out beside it. Restating the
+ * collapse would leave two lists to keep in step, and the failure is silent: the
+ * filter would come back short a few rows the column beside it still calls
+ * failed, which reads as runs having disappeared rather than as a narrowing that
+ * is narrower than it says.
+ */
+export declare function apiStatusesFor(words: readonly RunStatus[]): string[];
+/**
+ * The orders this studio can ask `GET /runs` for.
+ *
+ * Three of the four `RunSort` names the service accepts. Two absences are the
+ * platform's: ordering by the workflow's name would need a join on the paging
+ * path, and the trigger kind has four values, so it groups the list rather than
+ * ordering it — the filter beside it answers that question better.
+ *
+ * The third absence is the STUDIO'S, and it is the reason this list is not
+ * simply a mirror of the service's enum. `sort=status` orders by the word the
+ * platform stores — `cancelled`, `completed`, `failed`, `pending`, `running`,
+ * `terminated` — and those are not the words on the rows: the studio draws its
+ * own five, translated, and folds three of the platform's into one of them. A
+ * header reading "Status ↑" over rows ordered by a vocabulary the reader never
+ * sees is a control that cannot do what it says, and in German it would not even
+ * be alphabetical. Ordering by outcome from here needs the platform to order by
+ * something the studio can name, which it cannot: the translation lives in this
+ * repository and the ordering happens in the other one.
+ */
+export declare const RUN_SORTS: readonly ["created_at", "started_at", "duration"];
+export type RunSort = (typeof RUN_SORTS)[number];
+export type RunSortDirection = 'asc' | 'desc';
+/** The order the list opens in, and the one the platform falls back to. */
+export declare const DEFAULT_RUN_SORT: RunSort;
+export declare const DEFAULT_RUN_DIRECTION: RunSortDirection;
+/** What the Runs list is currently asking the platform for. */
+export interface RunFeedQuery {
+    /** 1-based, as the platform pages. */
+    page: number;
+    perPage: number;
+    /** The studio's own outcome words; empty narrows by no outcome. */
+    status: RunStatus[];
+    /** Empty narrows by no trigger kind. */
+    triggerType: TriggerType | '';
+    /** Matched against the workflow's name by the platform, not by the browser. */
+    search: string;
+    /** Which order the page is read in. Not a narrowing — see below. */
+    sort: RunSort;
+    direction: RunSortDirection;
+}
+/**
+ * The query string for `GET /runs` — and for `GET /runs/summary`, which narrows
+ * through the same rules and is where a numbered pager gets its total. Both are
+ * built from one place so the count can never describe a different set of rows
+ * from the page beside it.
+ *
+ * A filter nobody set is left out rather than sent empty: the platform reads an
+ * empty `status` as a value and answers 422.
+ */
+export declare function runFeedQueryString(query: RunFeedQuery): string;
+/**
+ * The narrowing alone, without the paging — what `GET /runs/summary` is read
+ * with so the pager's total describes the same rows as the page beside it.
+ *
+ * Empty when nothing narrows, and callers lean on that: the tenant-wide figures
+ * the dashboard shows come from the same summary state, so an unnarrowed load
+ * may refresh them and a narrowed one may not.
+ *
+ * The ORDER is deliberately absent. The summary counts what matches; a count has
+ * no order, and the endpoint ignores one — sending it would advertise an effect
+ * it does not have, and would make an ordered list look like it had asked for a
+ * differently counted total.
+ */
+export declare function runFeedNarrowingString(query: RunFeedQuery): string;
+/**
+ * Apply a change to the query, returning to the first page whenever the change
+ * is a narrowing rather than a page turn.
+ *
+ * The reset is the point. Page 4 of the old result set is very often past the
+ * end of the narrowed one, and the page that comes back is then empty — which
+ * an operator reads as "nothing matches" when the truth is "nothing matches
+ * this far in". The page size counts as a narrowing here even though it narrows
+ * nothing, because it changes what page 4 refers to.
+ */
+export declare function withRunFeedPatch(query: RunFeedQuery, patch: Partial<RunFeedQuery>): RunFeedQuery;
+/**
+ * How many pages a total spreads over, for the pager's "page 2 of 7".
+ *
+ * Never zero: an empty list is still page 1 of 1, and a pager reading "page 1 of
+ * 0" is a sentence about nothing.
+ */
+export declare function runFeedLastPage(total: number, perPage: number): number;

package/dist/runtime/utils/runFeedQuery.js

@@ -0,0 +1,66 @@
+export const API_RUN_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "terminated"
+];
+export function mapRunStatus(status) {
+  switch (status) {
+    case "completed":
+      return "succeeded";
+    case "pending":
+      return "queued";
+    case "terminated":
+      return "failed";
+    case "timed_out":
+      return "failed";
+    case "running":
+      return "running";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "failed";
+  }
+}
+export function apiStatusesFor(words) {
+  if (!words.length) return [];
+  return API_RUN_STATUSES.filter((status) => words.includes(mapRunStatus(status)));
+}
+export const RUN_SORTS = ["created_at", "started_at", "duration"];
+export const DEFAULT_RUN_SORT = "created_at";
+export const DEFAULT_RUN_DIRECTION = "desc";
+export function runFeedQueryString(query) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page));
+  params.set("per_page", String(query.perPage));
+  for (const [key, value] of narrowingParams(query)) params.set(key, value);
+  if (query.sort !== DEFAULT_RUN_SORT || query.direction !== DEFAULT_RUN_DIRECTION) {
+    params.set("sort", query.sort);
+    params.set("direction", query.direction);
+  }
+  return params.toString();
+}
+export function runFeedNarrowingString(query) {
+  return narrowingParams(query).toString();
+}
+function narrowingParams(query) {
+  const params = new URLSearchParams();
+  const statuses = apiStatusesFor(query.status);
+  if (statuses.length) params.set("status", statuses.join(","));
+  if (query.triggerType) params.set("trigger_type", query.triggerType);
+  const search = query.search.trim();
+  if (search) params.set("search", search);
+  return params;
+}
+export function withRunFeedPatch(query, patch) {
+  const narrowed = "status" in patch || "triggerType" in patch || "search" in patch || "perPage" in patch || "sort" in patch || "direction" in patch;
+  return { ...query, ...patch, ...narrowed ? { page: 1 } : {} };
+}
+export function runFeedLastPage(total, perPage) {
+  if (perPage <= 0) return 1;
+  return Math.max(1, Math.ceil(total / perPage));
+}

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

@@ -0,0 +1,33 @@
+import type { NameableNode } from './nodeDisplayName.js';
+/** One node's share of what a run returned. */
+export interface RunOutput {
+    /** The blob key the value stood under. Kept for addressing, never shown alone. */
+    nodeId: string;
+    /** What that node is called on the canvas. */
+    name: string;
+    value: unknown;
+}
+/** A node as the blob carries it — an id, and enough to name it by. */
+export type OutputNode = NameableNode & {
+    id: string;
+};
+/**
+ * What a run returned, split per node and named the way the canvas names it.
+ *
+ * A run's result is a map keyed by node id — `{"n-1787908672612": {…}}` — which
+ * is the worker's addressing and not a thing to show a person. Split against the
+ * workflow's own nodes it becomes what the author was actually looking at: one
+ * block per node, under the name on the card.
+ *
+ * `null` means "this is not that shape", and the caller shows the value whole
+ * instead of inventing structure for it. That covers three real cases: a result
+ * that is a bare value rather than a map, one keyed by something other than node
+ * ids, and a run of a workflow whose nodes have since changed — where guessing
+ * would put a value under the wrong name, which is worse than not naming it.
+ * An empty result is `null` too: there is nothing to split, and the caller has a
+ * better sentence for it than an empty list.
+ *
+ * Order follows the blob rather than the result's own keys, so two runs of one
+ * workflow read the same way down the page.
+ */
+export declare function splitRunOutputs(result: unknown, nodes: readonly OutputNode[]): RunOutput[] | null;

package/dist/runtime/utils/runOutputs.js

@@ -0,0 +1,10 @@
+import { nodeDisplayName } from "./nodeDisplayName.js";
+export function splitRunOutputs(result, nodes) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return null;
+  const keys = Object.keys(result);
+  if (!keys.length) return null;
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  if (!keys.every((k) => byId.has(k))) return null;
+  const values = result;
+  return nodes.filter((n) => Object.hasOwn(values, n.id)).map((n) => ({ nodeId: n.id, name: nodeDisplayName(n), value: values[n.id] }));
+}

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

@@ -0,0 +1,48 @@
+import type { ConfigField, SettingConditionOperator } from '../types/integrations.js';
+/**
+ * What an operator means. Mirrors the SDK's `evaluate` row for row, including
+ * the leniency of `equals` across the string/number line: a select carries `1`
+ * where a text box carries `'1'`, and an author means one thing by both.
+ */
+export declare function evaluateOperator(left: unknown, op: SettingConditionOperator, right: unknown): boolean;
+/**
+ * Whether one setting applies, given the values at its own level — inside a
+ * group, the siblings in that group, which is where the node wrote the
+ * condition and where the platform resolves it.
+ *
+ * A setting with no condition always applies, and so does one whose condition
+ * is malformed: whatever the node meant, an author is better off seeing a field
+ * than having it silently withheld.
+ */
+export declare function settingApplies(field: Pick<ConfigField, 'showIf'>, values: Record<string, unknown>): boolean;
+/**
+ * Whether a change to `changedKey` leaves this setting's value stale.
+ *
+ * Two reasons a setting can depend on another, and they do not go stale at the
+ * same moment. `dependsOn` names what a dynamic field resolves its options
+ * from, and any change to it invalidates what was chosen out of the old
+ * options. A condition names the setting that decides whether the field is
+ * drawn at all, and what was typed only becomes unreachable when the condition
+ * stops holding: while it still holds the field is on screen, and clearing it
+ * on every keystroke in the setting it reads would empty a field the author is
+ * looking at — `showIf: { key: 'url', op: 'isNotEmpty' }` stays true from the
+ * first character on.
+ */
+export declare function valueGoesStale(field: Pick<ConfigField, 'dependsOn' | 'showIf'>, changedKey: string, values: Record<string, unknown>): boolean;
+/**
+ * The settings of one level whose values are stale once `changedKey` has been
+ * set — the cascade, walked to a fixpoint over that level's own fields.
+ *
+ * `after` is the config as it stands *after* the write, because a condition is
+ * read against it: whether a setting still applies is the whole question for a
+ * `showIf` dependant. Each cleared key is taken out of that config as the walk
+ * goes, so a setting withdrawn by a clearing is found in the same pass.
+ *
+ * The setting being written is never cleared, which is also what guards a
+ * cyclic `dependsOn`.
+ */
+export declare function staleKeys(fields: Pick<ConfigField, 'key' | 'dependsOn' | 'showIf'>[], changedKey: string, after: Record<string, unknown>): Set<string>;
+/**
+ * The settings of a level that apply, in the order the node declared them.
+ */
+export declare function applyingFields(fields: ConfigField[], values: Record<string, unknown>): ConfigField[];

package/dist/runtime/utils/settingCondition.js

@@ -0,0 +1,84 @@
+const READS_PRESENCE = ["exists", "notExists", "isEmpty", "isNotEmpty"];
+const OPERATORS = [
+  "equals",
+  "notEquals",
+  "contains",
+  "notContains",
+  "startsWith",
+  "endsWith",
+  "greaterThan",
+  "greaterThanOrEqual",
+  "lessThan",
+  "lessThanOrEqual",
+  ...READS_PRESENCE
+];
+export function evaluateOperator(left, op, right) {
+  switch (op) {
+    case "exists":
+      return left !== void 0 && left !== null;
+    case "notExists":
+      return left === void 0 || left === null;
+    case "isEmpty":
+      return left === "" || left === null || left === void 0 || Array.isArray(left) && left.length === 0;
+    case "isNotEmpty":
+      return !evaluateOperator(left, "isEmpty", right);
+    case "equals":
+      return String(left) === String(right);
+    case "notEquals":
+      return String(left) !== String(right);
+    case "contains":
+      return typeof left === "string" && left.includes(String(right));
+    case "notContains":
+      return typeof left === "string" && !left.includes(String(right));
+    case "startsWith":
+      return typeof left === "string" && left.startsWith(String(right));
+    case "endsWith":
+      return typeof left === "string" && left.endsWith(String(right));
+    case "greaterThan":
+      return Number(left) > Number(right);
+    case "greaterThanOrEqual":
+      return Number(left) >= Number(right);
+    case "lessThan":
+      return Number(left) < Number(right);
+    case "lessThanOrEqual":
+      return Number(left) <= Number(right);
+    default: {
+      const unhandled = op;
+      void unhandled;
+      return false;
+    }
+  }
+}
+export function settingApplies(field, values) {
+  const condition = field.showIf;
+  if (!condition || typeof condition !== "object")
+    return true;
+  const { key, op } = condition;
+  if (typeof key !== "string" || !OPERATORS.includes(op))
+    return true;
+  return evaluateOperator(values[key], op, condition.value);
+}
+export function valueGoesStale(field, changedKey, values) {
+  if ((field.dependsOn ?? []).includes(changedKey))
+    return true;
+  return field.showIf?.key === changedKey && !settingApplies(field, values);
+}
+export function staleKeys(fields, changedKey, after) {
+  const remaining = { ...after };
+  const out = /* @__PURE__ */ new Set();
+  const queue = [changedKey];
+  while (queue.length > 0) {
+    const dep = queue.shift();
+    for (const f of fields) {
+      if (f.key === changedKey || out.has(f.key)) continue;
+      if (!valueGoesStale(f, dep, remaining)) continue;
+      out.add(f.key);
+      delete remaining[f.key];
+      queue.push(f.key);
+    }
+  }
+  return out;
+}
+export function applyingFields(fields, values) {
+  return fields.filter((field) => settingApplies(field, values));
+}