@burdenoff/fluidgrids-fe-sdk 2026.1110.11 → 2026.1110.13

package/dist/{chunk-URM73DCA.js → chunk-GNIJYZNL.js}

@@ -1,8 +1,8 @@
 import { useBuilderReadOnly } from './chunk-SDZEAIIE.js';
-import { STICKY_NOTE_TYPE, useFlowStore, resolveStickyColor, STICKY_COLORS, stickySurfaceStyle, nodeAdaptersOf, resolveOperationName, synchronizeOperationUpdate, isNodeTrigger, resolveOutputHandles, resolveInputHandles, outputHandlesSpacerHeight, WAIT_FOR_SIGNAL_NODE_TYPE, CODE_WORKFLOW_NODE_TYPE, readSignalName, LogicNodeCard, NodeCard, NodeCardHeader, NodeCardBody, InputHandles, OutputHandles, hasNodeManifest, NodeTypeIcon, nodeAccent, readCodeWorkflowState, interfaceFields, interfaceHandlers, partitionStickyNotes, DEFAULT_STICKY_COLOR, alignPlainOutputEdges } from './chunk-JT6NAHAX.js';
+import { STICKY_NOTE_TYPE, useFlowStore, resolveStickyColor, STICKY_COLORS, stickySurfaceStyle, nodeAdaptersOf, resolveOperationName, synchronizeOperationUpdate, isNodeTrigger, resolveOutputHandles, resolveInputHandles, outputHandlesSpacerHeight, WAIT_FOR_SIGNAL_NODE_TYPE, CODE_WORKFLOW_NODE_TYPE, readSignalName, LogicNodeCard, NodeCard, NodeCardHeader, NodeCardBody, InputHandles, OutputHandles, hasNodeManifest, NodeTypeIcon, nodeAccent, readCodeWorkflowState, interfaceFields, interfaceHandlers, partitionStickyNotes, DEFAULT_STICKY_COLOR, alignPlainOutputEdges } from './chunk-ATTUQMTG.js';
 import { getGlobalStoreClient, createGlobalStoreClient, setGlobalStoreClient, resetGlobalStoreClient } from './chunk-TYI2XOSI.js';
 import { GetMyNodeInstallationsDocument } from './chunk-4FPY66GH.js';
-import { fetchAllNodeEndpointConfigs, NodeManifestDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowRunDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, WorkflowDefinitionDocument } from './chunk-AL5QPU3W.js';
+import { fetchAllNodeEndpointConfigs, NodeManifestDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowRunDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, WorkflowDefinitionDocument, EventRegistrationsDocument } from './chunk-AL5QPU3W.js';
 import { useTr, ENGLISH_FALLBACK_TRANSLATOR, FluidGridsTranslationProvider } from './chunk-UULVIT25.js';
 import { waitForFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, createFluidGridsClient, setFluidGridsClient, resetFluidGridsClient } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError, emitFluidGridsEvent, emitOperationErrorEvent, emitRunCompletedOnce } from './chunk-JKLZ6YZ3.js';
@@ -1967,14 +1967,14 @@ function normalizeOperations(raw) {
   }
   return [];
 }
-function resolveNodeOperation(data, fallbackOperations) {
+function resolveNodeOperation(data, fallbackOperations2) {
   const nodeData = isRecord4(data?.nodeData) ? data?.nodeData : void 0;
   let operations = normalizeOperations(nodeData?.operations);
   if (operations.length === 0) {
     operations = normalizeOperations(data?.operations);
   }
-  if (operations.length === 0 && fallbackOperations !== void 0) {
-    operations = normalizeOperations(fallbackOperations);
+  if (operations.length === 0 && fallbackOperations2 !== void 0) {
+    operations = normalizeOperations(fallbackOperations2);
   }
   const opName = typeof data?.operation_name === "string" ? data.operation_name : void 0;
   const selected = operations.find((op) => op.name === opName) ?? operations[0];
@@ -2066,8 +2066,8 @@ function formatParameterValue(value) {
   if (value === void 0 || value === null) return "";
   return typeof value === "string" ? value : JSON.stringify(value, null, 2);
 }
-function normalizeNodeParameters(data, fallbackOperations, mappedFields = /* @__PURE__ */ new Set()) {
-  const operation = resolveNodeOperation(data, fallbackOperations).selected;
+function normalizeNodeParameters(data, fallbackOperations2, mappedFields = /* @__PURE__ */ new Set()) {
+  const operation = resolveNodeOperation(data, fallbackOperations2).selected;
   const fields = record(operation?.input_fields);
   const args = record(data.args);
   const state = record(args?.state) ?? {};
@@ -2091,7 +2091,7 @@ function normalizeNodeParameters(data, fallbackOperations, mappedFields = /* @__
   }
   return { ...data, args: { ...args, state: Object.fromEntries(normalized) } };
 }
-function normalizeWorkflowParameters(nodes, edges, fallbackOperations) {
+function normalizeWorkflowParameters(nodes, edges, fallbackOperations2) {
   return nodes.map((node) => {
     if (node.data.disabled === true) return node;
     const mappedFields = new Set(
@@ -2108,7 +2108,7 @@ function normalizeWorkflowParameters(nodes, edges, fallbackOperations) {
         ...node,
         data: normalizeNodeParameters(
           node.data,
-          fallbackOperations(node.type),
+          fallbackOperations2(node.type),
           mappedFields
         )
       };
@@ -3941,11 +3941,1627 @@ function useGuardedNavigate() {
     [navigate]
   );
 }
-function useRunGuard(startRun) {
+
+// src/builder/lib/required-parameters.ts
+function isEmptyParameterValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function missingRequiredParameters(params, state, boundFields = /* @__PURE__ */ new Set()) {
+  const defaults = {};
+  for (const param of params) {
+    if (param.defaultValue !== void 0)
+      defaults[param.name] = param.defaultValue;
+  }
+  const missing = [];
+  for (const param of params) {
+    if (param.required !== true || boundFields.has(param.name)) continue;
+    if (!isParamVisible(param, state, defaults)) continue;
+    const value = state[param.name] === void 0 ? param.defaultValue : state[param.name];
+    if (!isEmptyParameterValue(value)) continue;
+    missing.push({
+      name: param.name,
+      label: typeof param.label === "string" && param.label.trim() !== "" ? param.label : param.name
+    });
+  }
+  return missing;
+}
+function asRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function nodeStateOf(node) {
+  return asRecord3(asRecord3(asRecord3(node.data)?.args)?.state) ?? {};
+}
+function isDisabledNode(node) {
+  return asRecord3(node.data)?.disabled === true;
+}
+function boundFieldsOf(nodeId, edges) {
+  const bound = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    if (edge.target !== nodeId) continue;
+    const definition = asRecord3(edge.mapping?.definition) ?? asRecord3(asRecord3(asRecord3(edge.data)?.mapping)?.definition);
+    for (const field of Object.keys(definition ?? {})) bound.add(field);
+  }
+  return bound;
+}
+function nodeParameterIssues(nodes, edges, paramsOf, labelOf) {
+  const issues = [];
+  for (const node of nodes) {
+    if (isDisabledNode(node)) continue;
+    const missing = missingRequiredParameters(
+      paramsOf(node),
+      nodeStateOf(node),
+      boundFieldsOf(node.id, edges)
+    );
+    if (missing.length > 0)
+      issues.push({ nodeId: node.id, nodeLabel: labelOf(node), missing });
+  }
+  return issues;
+}
+
+// src/builder/components/ndv/field-label.ts
+var UPPERCASE_WORDS = /* @__PURE__ */ new Set([
+  "api",
+  "csv",
+  "html",
+  "http",
+  "https",
+  "id",
+  "ip",
+  "json",
+  "jwt",
+  "sql",
+  "ssl",
+  "url",
+  "uri",
+  "utc",
+  "xml"
+]);
+var PLURAL_ACRONYMS = /* @__PURE__ */ new Map([
+  ["apis", "APIs"],
+  ["ids", "IDs"],
+  ["ips", "IPs"],
+  ["uris", "URIs"],
+  ["urls", "URLs"]
+]);
+function titleWord(word) {
+  const lower = word.toLowerCase();
+  const plural = PLURAL_ACRONYMS.get(lower);
+  if (plural) return plural;
+  if (UPPERCASE_WORDS.has(lower)) return lower.toUpperCase();
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+function humanizeFieldName(name) {
+  const words = name.split(".").pop().replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
+  return words.length > 0 ? words.map(titleWord).join(" ") : name;
+}
+function fieldLabel(name, spec) {
+  for (const key of ["label", "displayName", "title"]) {
+    const value = spec?.[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return humanizeFieldName(name);
+}
+
+// src/builder/lib/mapping-input.ts
+function latestNodeLog(logs, nodeId, runId) {
+  return nodeId && runId ? logs.filter((log) => log.nodeId === nodeId && log.runId === runId).at(-1) : void 0;
+}
+function resolveMappingInput({
+  source,
+  operation,
+  runId,
+  logs
+}) {
+  const sourceLog = latestNodeLog(logs, source?.id, runId);
+  const data = sourceLog?.output ?? void 0;
+  return {
+    data,
+    fields: data !== void 0 ? fieldsFromValue(data) : source ? declaredOutputFields(source.type, operation) : []
+  };
+}
+
+// src/builder/lib/mapping-values.ts
+function isMappingValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return true;
+  }
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isMappingValue);
+  return typeof value === "object" && Object.values(value).every(isMappingValue);
+}
+function parseMappingValue(text) {
+  try {
+    const value = JSON.parse(text);
+    if (isMappingValue(value)) return { valid: true, value };
+  } catch {
+    return {
+      valid: false,
+      error: "Enter valid JSON before applying the mapping."
+    };
+  }
+  return { valid: false, error: "JSON mapping numbers must be finite." };
+}
+function updateMappingDefinition(definition, field, value) {
+  if (value === void 0 || typeof value === "string" && !value.trim()) {
+    const next = { ...definition };
+    delete next[field];
+    return next;
+  }
+  return { ...definition, [field]: value };
+}
+var FIELD_PATH_MIME = "application/x-fg-field-path";
+var TYPE_ICON = {
+  string: "mdi:format-text",
+  number: "mdi:numeric",
+  integer: "mdi:numeric",
+  boolean: "mdi:toggle-switch-outline",
+  array: "mdi:code-brackets",
+  object: "mdi:code-braces",
+  any: "mdi:help-circle-outline"
+};
+var DEFAULT_EXPAND_DEPTH = 3;
+function FieldRow({ field, depth, draggable }) {
+  const [open, setOpen] = useState(depth < DEFAULT_EXPAND_DEPTH);
+  const hasChildren = !!field.children && field.children.length > 0;
+  const handleDragStart = (e) => {
+    e.dataTransfer.setData(FIELD_PATH_MIME, field.path);
+    e.dataTransfer.setData("text/plain", pathToExpression(field.path));
+    e.dataTransfer.effectAllowed = "copy";
+  };
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `group flex items-center gap-1.5 rounded-md py-1 pr-2 text-xs hover:bg-muted ${draggable ? "cursor-grab active:cursor-grabbing" : ""}`,
+        style: { paddingLeft: `${depth * 14 + 6}px` },
+        draggable,
+        onDragStart: draggable ? handleDragStart : void 0,
+        "data-field-path": field.path,
+        "data-schema-variant": field.schemaVariant,
+        title: field.description || field.path,
+        children: [
+          hasChildren ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => setOpen((v) => !v),
+              className: "flex size-4 items-center justify-center text-muted-foreground hover:text-foreground",
+              children: /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: open ? "mdi:chevron-down" : "mdi:chevron-right",
+                  className: "size-3.5"
+                }
+              )
+            }
+          ) : /* @__PURE__ */ jsx("span", { className: "inline-block size-4" }),
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: TYPE_ICON[field.type] ?? TYPE_ICON.any,
+              className: "size-3.5 shrink-0 text-primary/70"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "truncate font-medium text-foreground", children: field.key }),
+          /* @__PURE__ */ jsxs("span", { className: "ml-auto shrink-0 text-[10px] lowercase tracking-wide text-muted-foreground", children: [
+            field.type,
+            field.required ? " *" : ""
+          ] })
+        ]
+      }
+    ),
+    hasChildren && open && /* @__PURE__ */ jsx("div", { children: field.children.map((child) => /* @__PURE__ */ jsx(
+      FieldRow,
+      {
+        field: child,
+        depth: depth + 1,
+        draggable
+      },
+      child.schemaVariant ?? child.path
+    )) })
+  ] });
+}
+function FieldTree({
+  fields,
+  draggable = false,
+  emptyMessage = "No fields available."
+}) {
+  if (fields.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "px-2 py-4 text-xs text-card-foreground/50", children: emptyMessage });
+  }
+  return /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-0.5", children: fields.map((field) => /* @__PURE__ */ jsx(
+    FieldRow,
+    {
+      field,
+      depth: 0,
+      draggable
+    },
+    field.schemaVariant ?? field.path
+  )) });
+}
+function emptyGroup() {
+  return { type: "group", combinator: "AND", children: [] };
+}
+function emptyRule(field = "") {
+  return { type: "rule", field, operator: "==", value: "" };
+}
+var OPERATORS = {
+  string: [
+    { value: "==", label: "equals", needsValue: true },
+    { value: "!=", label: "not equals", needsValue: true },
+    { value: "contains", label: "contains", needsValue: true },
+    { value: "notContains", label: "does not contain", needsValue: true },
+    { value: "startsWith", label: "starts with", needsValue: true },
+    { value: "endsWith", label: "ends with", needsValue: true },
+    { value: "regex", label: "matches regex", needsValue: true },
+    { value: "isEmpty", label: "is empty", needsValue: false },
+    { value: "isNotEmpty", label: "is not empty", needsValue: false },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ],
+  number: [
+    { value: "==", label: "equals", needsValue: true },
+    { value: "!=", label: "not equals", needsValue: true },
+    { value: ">", label: "greater than", needsValue: true },
+    { value: ">=", label: "greater or equal", needsValue: true },
+    { value: "<", label: "less than", needsValue: true },
+    { value: "<=", label: "less or equal", needsValue: true },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ],
+  boolean: [
+    { value: "isTrue", label: "is true", needsValue: false },
+    { value: "isFalse", label: "is false", needsValue: false },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ],
+  array: [
+    { value: "contains", label: "contains", needsValue: true },
+    { value: "notContains", label: "does not contain", needsValue: true },
+    { value: "isEmpty", label: "is empty", needsValue: false },
+    { value: "isNotEmpty", label: "is not empty", needsValue: false },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ],
+  object: [
+    { value: "hasProperty", label: "has property", needsValue: true },
+    { value: "isEmpty", label: "is empty", needsValue: false },
+    { value: "isNotEmpty", label: "is not empty", needsValue: false },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ],
+  any: [
+    { value: "==", label: "equals", needsValue: true },
+    { value: "!=", label: "not equals", needsValue: true },
+    { value: ">", label: "greater than", needsValue: true },
+    { value: "<", label: "less than", needsValue: true },
+    { value: "contains", label: "contains", needsValue: true },
+    { value: "isEmpty", label: "is empty", needsValue: false },
+    { value: "isNotEmpty", label: "is not empty", needsValue: false },
+    { value: "isNull", label: "is null", needsValue: false },
+    { value: "isNotNull", label: "is not null", needsValue: false }
+  ]
+};
+function operatorsFor(type) {
+  return OPERATORS[type ?? "any"] ?? OPERATORS.any;
+}
+function flattenFields(nodes) {
+  const out = [];
+  const walk = (list) => {
+    for (const node of list) {
+      if (node.path) out.push({ path: node.path, type: node.type ?? "any" });
+      if (Array.isArray(node.children)) walk(node.children);
+    }
+  };
+  walk(nodes);
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+var rowInput = "rounded-md border border-border-default bg-bg-surface px-2 py-1 text-xs text-text-primary scheme-normal dark:scheme-dark outline-none focus:border-action-primary-border [&_option]:bg-bg-surface [&_option]:text-text-primary";
+function RuleRow({
+  rule,
+  fields,
+  onChange,
+  onRemove
+}) {
+  const tr = useTr();
+  const fieldType = fields.find((f) => f.path === rule.field)?.type ?? "any";
+  const ops = operatorsFor(fieldType);
+  const currentOp = ops.find((o) => o.value === rule.operator) ?? ops[0];
+  const knownField = fields.some((f) => f.path === rule.field);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex flex-wrap items-center gap-1.5",
+      "data-testid": "condition-rule",
+      children: [
+        fields.length > 0 && (knownField || rule.field === "") ? /* @__PURE__ */ jsxs(
+          "select",
+          {
+            value: rule.field,
+            onChange: (e) => {
+              const nextField = e.target.value;
+              const nextType = fields.find((f) => f.path === nextField)?.type ?? "any";
+              const nextOps = operatorsFor(nextType);
+              const operator = nextOps.some((o) => o.value === rule.operator) ? rule.operator : nextOps[0].value;
+              onChange({ ...rule, field: nextField, operator });
+            },
+            className: cn(rowInput, "max-w-[180px] flex-1"),
+            "data-testid": "condition-field",
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "", children: tr(
+                "fluidgrids.builder.conditionBuilder.selectField",
+                "Select field\u2026"
+              ) }),
+              fields.map((f) => /* @__PURE__ */ jsxs("option", { value: f.path, children: [
+                f.path,
+                " (",
+                f.type,
+                ")"
+              ] }, f.path)),
+              /* @__PURE__ */ jsx("option", { value: "__custom__", children: tr(
+                "fluidgrids.builder.conditionBuilder.customPath",
+                "Custom path\u2026"
+              ) })
+            ]
+          }
+        ) : /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            value: rule.field === "__custom__" ? "" : rule.field,
+            placeholder: "field.path",
+            onChange: (e) => onChange({ ...rule, field: e.target.value }),
+            className: cn(rowInput, "max-w-[180px] flex-1 font-mono"),
+            "data-testid": "condition-field"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "select",
+          {
+            value: currentOp.value,
+            onChange: (e) => onChange({ ...rule, operator: e.target.value }),
+            className: rowInput,
+            "data-testid": "condition-operator",
+            children: ops.map((o) => /* @__PURE__ */ jsx("option", { value: o.value, children: o.label }, o.value))
+          }
+        ),
+        currentOp.needsValue && /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: fieldType === "number" ? "number" : "text",
+            value: rule.value === null || rule.value === void 0 ? "" : String(rule.value),
+            placeholder: tr(
+              "fluidgrids.builder.conditionBuilder.valuePlaceholder",
+              "value"
+            ),
+            onChange: (e) => {
+              const raw = e.target.value;
+              const value = fieldType === "number" && raw.trim() !== "" && !Number.isNaN(Number(raw)) ? Number(raw) : raw;
+              onChange({ ...rule, value });
+            },
+            className: cn(rowInput, "min-w-[90px] flex-1"),
+            "data-testid": "condition-value"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onRemove,
+            title: tr(
+              "fluidgrids.builder.conditionBuilder.removeCondition",
+              "Remove condition"
+            ),
+            className: "rounded p-1 text-muted-foreground hover:text-[var(--color-status-error-text)]",
+            children: /* @__PURE__ */ jsx(Icon, { icon: "mynaui:trash", className: "size-3.5" })
+          }
+        )
+      ]
+    }
+  );
+}
+function GroupEditor({
+  group,
+  fields,
+  depth,
+  onChange,
+  onRemove
+}) {
+  const tr = useTr();
+  const setChild = (index, child) => {
+    const children = group.children.slice();
+    children[index] = child;
+    onChange({ ...group, children });
+  };
+  const removeChild = (index) => {
+    onChange({
+      ...group,
+      children: group.children.filter((_, i) => i !== index)
+    });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "flex flex-col gap-1.5 rounded-md",
+        depth > 0 && "border border-border/70 bg-muted/20 p-2"
+      ),
+      "data-testid": `condition-group-depth-${depth}`,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex overflow-hidden rounded-md border border-input text-[10px] font-semibold", children: ["AND", "OR"].map((c) => /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => onChange({ ...group, combinator: c }),
+              className: cn(
+                "px-2 py-0.5",
+                group.combinator === c ? "bg-primary text-primary-foreground" : "bg-background text-muted-foreground hover:text-foreground"
+              ),
+              "data-testid": `combinator-${c}`,
+              children: c
+            },
+            c
+          )) }),
+          /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground", children: group.combinator === "AND" ? tr(
+            "fluidgrids.builder.conditionBuilder.combinatorAndHint",
+            "all conditions must match"
+          ) : tr(
+            "fluidgrids.builder.conditionBuilder.combinatorOrHint",
+            "any condition may match"
+          ) }),
+          onRemove && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: onRemove,
+              title: tr(
+                "fluidgrids.builder.conditionBuilder.removeGroup",
+                "Remove group"
+              ),
+              className: "ml-auto rounded p-1 text-muted-foreground hover:text-[var(--color-status-error-text)]",
+              children: /* @__PURE__ */ jsx(Icon, { icon: "mynaui:trash", className: "size-3.5" })
+            }
+          )
+        ] }),
+        group.children.map(
+          (child, index) => child.type === "rule" ? /* @__PURE__ */ jsx(
+            RuleRow,
+            {
+              rule: child,
+              fields,
+              onChange: (next) => setChild(index, next),
+              onRemove: () => removeChild(index)
+            },
+            index
+          ) : /* @__PURE__ */ jsx(
+            GroupEditor,
+            {
+              group: child,
+              fields,
+              depth: depth + 1,
+              onChange: (next) => setChild(index, next),
+              onRemove: () => removeChild(index)
+            },
+            index
+          )
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => onChange({
+                ...group,
+                children: [...group.children, emptyRule(fields[0]?.path ?? "")]
+              }),
+              className: "flex items-center gap-1 text-[11px] font-medium text-primary hover:underline",
+              "data-testid": "add-condition",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "basil:add-solid", className: "size-3.5" }),
+                " ",
+                tr(
+                  "fluidgrids.builder.conditionBuilder.addCondition",
+                  "Add condition"
+                )
+              ]
+            }
+          ),
+          depth < 2 && /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => onChange({
+                ...group,
+                children: [...group.children, emptyGroup()]
+              }),
+              className: "flex items-center gap-1 text-[11px] font-medium text-muted-foreground hover:text-foreground",
+              "data-testid": "add-group",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "basil:add-solid", className: "size-3.5" }),
+                " ",
+                tr("fluidgrids.builder.conditionBuilder.addGroup", "Add group")
+              ]
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function ConditionTreeBuilder({
+  value,
+  fields,
+  onChange
+}) {
+  const tree = value && typeof value === "object" && value.type === "group" ? value : emptyGroup();
+  return /* @__PURE__ */ jsx("div", { "data-testid": "condition-tree-builder", children: /* @__PURE__ */ jsx(
+    GroupEditor,
+    {
+      group: tree,
+      fields,
+      depth: 0,
+      onChange: (next) => onChange(next.children.length === 0 ? void 0 : next)
+    }
+  ) });
+}
+function newRuleHandle(existing) {
+  let n = existing.length;
+  const taken = new Set(existing.map((r) => r.handle));
+  let handle = `rule-${n}`;
+  while (taken.has(handle)) handle = `rule-${++n}`;
+  return handle;
+}
+function casesFromRules(rules) {
+  const cases = {};
+  rules.forEach((rule, index) => {
+    cases[rule.name || `Rule ${index + 1}`] = rule.handle;
+  });
+  return cases;
+}
+function SwitchRulesEditor({
+  rules,
+  fallbackHandle,
+  fields,
+  onChange
+}) {
+  const tr = useTr();
+  const setRule = (index, rule) => {
+    const next = rules.slice();
+    next[index] = rule;
+    onChange({ rules: next, fallbackHandle });
+  };
+  const move = (index, dir) => {
+    const target = index + dir;
+    if (target < 0 || target >= rules.length) return;
+    const next = rules.slice();
+    const tmp = next[index];
+    next[index] = next[target];
+    next[target] = tmp;
+    onChange({ rules: next, fallbackHandle });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", "data-testid": "switch-rules-editor", children: [
+    rules.map((rule, index) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "rounded-md border border-border/70 bg-muted/10 p-2",
+        "data-testid": `switch-rule-${index}`,
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "mb-1.5 flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsxs("span", { className: "text-[10px] font-semibold text-muted-foreground", children: [
+              index + 1,
+              "."
+            ] }),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "text",
+                value: rule.name,
+                placeholder: `Rule ${index + 1}`,
+                onChange: (e) => setRule(index, { ...rule, name: e.target.value }),
+                className: cn(rowInput, "flex-1 font-medium"),
+                "data-testid": "switch-rule-name"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => move(index, -1),
+                disabled: index === 0,
+                title: tr(
+                  "fluidgrids.builder.switchRulesEditor.moveUp",
+                  "Move up"
+                ),
+                className: "rounded p-0.5 text-muted-foreground hover:text-foreground disabled:opacity-30",
+                children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:chevron-up", className: "size-4" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => move(index, 1),
+                disabled: index === rules.length - 1,
+                title: tr(
+                  "fluidgrids.builder.switchRulesEditor.moveDown",
+                  "Move down"
+                ),
+                className: "rounded p-0.5 text-muted-foreground hover:text-foreground disabled:opacity-30",
+                children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:chevron-down", className: "size-4" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => onChange({
+                  rules: rules.filter((_, i) => i !== index),
+                  fallbackHandle
+                }),
+                title: tr(
+                  "fluidgrids.builder.switchRulesEditor.removeRule",
+                  "Remove rule"
+                ),
+                className: "rounded p-0.5 text-muted-foreground hover:text-[var(--color-status-error-text)]",
+                children: /* @__PURE__ */ jsx(Icon, { icon: "mynaui:trash", className: "size-3.5" })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            ConditionTreeBuilder,
+            {
+              value: rule.conditionTree,
+              fields,
+              onChange: (tree) => setRule(index, { ...rule, conditionTree: tree ?? emptyGroup() })
+            }
+          )
+        ]
+      },
+      rule.handle
+    )),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => onChange({
+          rules: [
+            ...rules,
+            {
+              name: `Rule ${rules.length + 1}`,
+              handle: newRuleHandle(rules),
+              conditionTree: emptyGroup()
+            }
+          ],
+          fallbackHandle
+        }),
+        className: "flex w-fit items-center gap-1 text-[11px] font-medium text-primary hover:underline",
+        "data-testid": "add-switch-rule",
+        children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "basil:add-solid", className: "size-3.5" }),
+          " ",
+          tr("fluidgrids.builder.switchRulesEditor.addRule", "Add rule")
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "mt-1 flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-[11px] text-muted-foreground", children: tr(
+        "fluidgrids.builder.switchRulesEditor.fallbackLabel",
+        "Fallback output (no rule matches):"
+      ) }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          value: fallbackHandle,
+          placeholder: "default",
+          onChange: (e) => onChange({ rules, fallbackHandle: e.target.value }),
+          className: cn(rowInput, "w-28"),
+          "data-testid": "switch-fallback"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "text-[10px] leading-snug text-muted-foreground", children: tr(
+      "fluidgrids.builder.switchRulesEditor.rulesHint",
+      "Rules are checked top-down; the first matching rule routes the item to its output. Each rule renders as an output handle on the node."
+    ) })
+  ] });
+}
+function useWebhookRegistration(workflowKey, triggerNodeId, enabled = true) {
+  const key = enabled && workflowKey && triggerNodeId ? JSON.stringify([workflowKey, triggerNodeId]) : null;
+  const requestId = useRef(0);
+  const [state, setState] = useState({ key: null, registration: null, loading: false, error: null });
+  const fetchData = useCallback(async () => {
+    const currentRequest = ++requestId.current;
+    if (!key || !workflowKey || !triggerNodeId) return;
+    const client = getFluidGridsClientSafe();
+    if (!client) {
+      setState({
+        key,
+        registration: null,
+        loading: false,
+        error: new Error("Workflow client unavailable")
+      });
+      return;
+    }
+    setState({ key, registration: null, loading: true, error: null });
+    try {
+      const result = await client.query({
+        query: EventRegistrationsDocument,
+        variables: { workflowKey },
+        fetchPolicy: "network-only"
+      });
+      const match = result.data?.eventRegistrations?.find(
+        (r) => r.triggerNodeId === triggerNodeId
+      ) ?? null;
+      if (currentRequest === requestId.current)
+        setState({ key, registration: match, loading: false, error: null });
+    } catch (err) {
+      if (currentRequest === requestId.current)
+        setState({
+          key,
+          registration: null,
+          loading: false,
+          error: err instanceof Error ? err : new Error("Unable to load trigger URL")
+        });
+    }
+  }, [key, workflowKey, triggerNodeId]);
+  useEffect(() => {
+    fetchData();
+    return () => {
+      requestId.current += 1;
+    };
+  }, [fetchData]);
+  useEffect(() => {
+    if (!enabled || !workflowKey) return;
+    return subscribeWorkflowSaved(workflowKey, () => {
+      void fetchData();
+    });
+  }, [enabled, workflowKey, fetchData]);
+  const current = state.key === key && key !== null ? state : null;
+  const registration = current?.registration ?? null;
+  return {
+    registration,
+    webhookUrl: registration?.webhookUrl ?? null,
+    formUrl: registration?.formUrl ?? null,
+    loading: current?.loading ?? !!key,
+    error: current?.error ?? null,
+    refetch: fetchData
+  };
+}
+
+// src/builder/components/ndv/node-option-values.ts
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isParameterName(value) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) && !["__proto__", "prototype", "constructor"].includes(value);
+}
+function isStringOptionList(schema) {
+  if (structuredParameterType(schema) !== "array") return false;
+  const type = typeof schema === "string" ? schema : isRecord6(schema) ? schema.type : void 0;
+  const inlineItem = typeof type === "string" ? type.trim().toLowerCase().match(/^array<(.+)>$/)?.[1] : void 0;
+  const item = (isRecord6(schema) ? schema.items : void 0) ?? inlineItem;
+  if (item === void 0) return true;
+  const itemType = typeof item === "string" ? item : isRecord6(item) ? item.type : void 0;
+  return typeof itemType === "string" && itemType.trim().toLowerCase() === "string";
+}
+function readLoadOptionsSpec(value) {
+  if (!isRecord6(value) || typeof value.operation !== "string" || typeof value.labelField !== "string" || typeof value.valueField !== "string")
+    return void 0;
+  let parameterArgs;
+  if (value.parameterArgs !== void 0) {
+    if (!isRecord6(value.parameterArgs)) return void 0;
+    parameterArgs = {};
+    for (const [argument, parameter] of Object.entries(value.parameterArgs)) {
+      if (!isParameterName(argument) || typeof parameter !== "string" || !isParameterName(parameter))
+        return void 0;
+      parameterArgs[argument] = parameter;
+    }
+  }
+  return {
+    operation: value.operation,
+    labelField: value.labelField,
+    valueField: value.valueField,
+    resultPath: typeof value.resultPath === "string" ? value.resultPath : void 0,
+    staticArgs: isRecord6(value.staticArgs) ? value.staticArgs : void 0,
+    parameterArgs
+  };
+}
+function resolveLoadOptionsSpec(spec, values, defaults = {}, unavailableParameters = []) {
+  const args = { ...spec.staticArgs };
+  const missingParameters = /* @__PURE__ */ new Set();
+  for (const [argument, parameter] of Object.entries(
+    spec.parameterArgs ?? {}
+  )) {
+    if (!isParameterName(argument) || !isParameterName(parameter)) {
+      missingParameters.add(parameter);
+      continue;
+    }
+    const value = Object.hasOwn(values, parameter) && values[parameter] !== void 0 ? values[parameter] : Object.hasOwn(defaults, parameter) ? defaults[parameter] : void 0;
+    if (unavailableParameters.includes(parameter) || value === void 0 || value === null || containsExpression(value) || typeof value === "string" && !value.trim() || Array.isArray(value) && value.length === 0)
+      missingParameters.add(parameter);
+    else args[argument] = value;
+  }
+  return {
+    spec: missingParameters.size ? void 0 : { ...spec, staticArgs: args },
+    missingParameters: [...missingParameters]
+  };
+}
+function containsExpression(value) {
+  if (typeof value === "string") return /\{\{|\$\{|^\$\./.test(value);
+  if (Array.isArray(value)) return value.some(containsExpression);
+  return isRecord6(value) && Object.values(value).some(containsExpression);
+}
+function optionListValues(value) {
+  if (value === void 0 || value === null || value === "") return [];
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    if (trimmed.startsWith("{")) return void 0;
+    if (trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed) ? optionListValues(parsed) : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    return [
+      ...new Set(
+        trimmed.split(",").map((entry) => entry.trim()).filter(Boolean)
+      )
+    ];
+  }
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string"))
+    return void 0;
+  return [...new Set(value.filter((entry) => entry !== ""))];
+}
+function optionListText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? []);
+}
+
+// src/modules/ui-blocks/parse.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function humanizeFieldName2(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function synthesizeCardFromInputFields(inputFields) {
+  const names = Object.keys(inputFields);
+  if (names.length === 0) return null;
+  const body = [];
+  for (const name of names) {
+    const field = isRecord7(inputFields[name]) ? inputFields[name] : {};
+    const description = typeof field.description === "string" ? field.description : void 0;
+    const required = field.required === true;
+    const secret = field.secret === true;
+    const multiline = name === "body" || name === "htmlBody";
+    const label = humanizeFieldName2(name);
+    body.push({
+      type: "TextBlock",
+      text: required ? `${label} *` : label,
+      wrap: true
+    });
+    body.push({
+      type: "Input.Text",
+      id: `args.state.${name}`,
+      value: `\${${name}}`,
+      ...description ? { placeholder: description } : {},
+      // A secret field renders masked (and agent tools treat a password
+      // input as sensitive).
+      ...secret ? { style: "Password" } : {},
+      ...multiline && !secret ? { isMultiline: true } : {},
+      ...required ? { isRequired: true, errorMessage: `${label} is required` } : {}
+    });
+  }
+  body.push({
+    type: "ActionSet",
+    actions: [{ type: "Action.Submit", title: "Apply" }]
+  });
+  return { type: "AdaptiveCard", version: "1.5", body };
+}
+function secretFieldNames(inputFields) {
+  const names = /* @__PURE__ */ new Set();
+  if (!isRecord7(inputFields)) return names;
+  for (const [name, field] of Object.entries(inputFields)) {
+    if (isRecord7(field) && field.secret === true) names.add(name);
+  }
+  return names;
+}
+function fieldOfInputId(id) {
+  if (typeof id !== "string") return null;
+  const name = id.replace(/^(?:args\.)?state\./, "");
+  return name.length > 0 ? name : null;
+}
+function maskSecretInputs(card, secrets) {
+  if (secrets.size === 0) return card;
+  const visit = (value) => {
+    if (Array.isArray(value)) return value.map(visit);
+    if (!isRecord7(value)) return value;
+    const copy = {};
+    for (const [key, nested] of Object.entries(value))
+      copy[key] = visit(nested);
+    const field = copy.type === "Input.Text" ? fieldOfInputId(copy.id) : null;
+    if (field && secrets.has(field)) {
+      copy.style = "Password";
+      delete copy.isMultiline;
+    }
+    return copy;
+  };
+  return visit(card);
+}
+function validateUiSpec(raw) {
+  if (!isRecord7(raw)) return "ui is not an object";
+  if (raw.version !== 1)
+    return `unsupported ui.version: ${String(raw.version)}`;
+  if (!Array.isArray(raw.blocks) || raw.blocks.length === 0) {
+    return "ui.blocks must be a non-empty array";
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const blocks = [];
+  for (const [index, rawBlock] of raw.blocks.entries()) {
+    if (!isRecord7(rawBlock)) return `ui.blocks[${index}] is not an object`;
+    const id = rawBlock.id;
+    if (typeof id !== "string" || id.length === 0) {
+      return `ui.blocks[${index}] is missing a non-empty string id`;
+    }
+    if (seenIds.has(id)) return `ui.blocks has duplicate id "${id}"`;
+    seenIds.add(id);
+    if (rawBlock.type === "adaptive_card") {
+      if (!isRecord7(rawBlock.card)) {
+        return `ui.blocks[${index}] ("${id}") has no card object`;
+      }
+      blocks.push({ id, type: "adaptive_card", card: rawBlock.card });
+    } else if (rawBlock.type === "custom") {
+      if (typeof rawBlock.component !== "string" || !rawBlock.component) {
+        return `ui.blocks[${index}] ("${id}") has no component name`;
+      }
+      blocks.push({
+        id,
+        type: "custom",
+        component: rawBlock.component,
+        props: isRecord7(rawBlock.props) ? rawBlock.props : void 0
+      });
+    } else {
+      return `ui.blocks[${index}] ("${id}") has unknown type "${String(rawBlock.type)}"`;
+    }
+  }
+  return {
+    version: 1,
+    blocks,
+    ...typeof raw.applyLabel === "string" && raw.applyLabel.trim().length > 0 ? { applyLabel: raw.applyLabel } : {}
+  };
+}
+function resolveUiSpec(operation) {
+  if (!operation) return null;
+  const secrets = secretFieldNames(operation.input_fields);
+  if (operation.ui !== void 0) {
+    const result = validateUiSpec(operation.ui);
+    if (typeof result !== "string") {
+      const blocks = result.blocks.map(
+        (block) => block.type === "adaptive_card" ? { ...block, card: maskSecretInputs(block.card, secrets) } : block
+      );
+      return { spec: { ...result, blocks }, synthesized: false };
+    }
+    console.warn(
+      `ui-blocks: invalid ui declaration on operation "${operation.name ?? "?"}" (${result}); falling back to adaptive_card`
+    );
+  }
+  if (isRecord7(operation.adaptive_card)) {
+    return {
+      spec: {
+        version: 1,
+        blocks: [
+          {
+            id: "main",
+            type: "adaptive_card",
+            card: maskSecretInputs(operation.adaptive_card, secrets)
+          }
+        ]
+      },
+      synthesized: true
+    };
+  }
+  if (isRecord7(operation.input_fields)) {
+    const card = synthesizeCardFromInputFields(operation.input_fields);
+    if (card) {
+      return {
+        spec: {
+          version: 1,
+          blocks: [{ id: "main", type: "adaptive_card", card }]
+        },
+        synthesized: true
+      };
+    }
+  }
+  return null;
+}
+function isSubmitAction(action) {
+  return isRecord7(action) && action.type === "Action.Submit";
+}
+function stripFromActions(actions) {
+  return actions.filter((action) => !isSubmitAction(action)).map(
+    (action) => isRecord7(action) && isRecord7(action.card) ? { ...action, card: stripSubmitActions(action.card) } : action
+  );
+}
+function stripFromElements(elements) {
+  const result = [];
+  for (const element of elements) {
+    if (!isRecord7(element)) {
+      result.push(element);
+      continue;
+    }
+    const el = { ...element };
+    if (el.type === "ActionSet" && Array.isArray(el.actions)) {
+      const remaining = stripFromActions(el.actions);
+      if (remaining.length === 0) continue;
+      el.actions = remaining;
+    }
+    if (Array.isArray(el.items)) {
+      el.items = stripFromElements(el.items);
+    }
+    if (Array.isArray(el.columns)) {
+      el.columns = el.columns.map(
+        (column) => isRecord7(column) && Array.isArray(column.items) ? { ...column, items: stripFromElements(column.items) } : column
+      );
+    }
+    result.push(el);
+  }
+  return result;
+}
+function stripSubmitActions(card) {
+  const result = { ...card };
+  if (Array.isArray(result.actions)) {
+    result.actions = stripFromActions(result.actions);
+  }
+  if (Array.isArray(result.body)) {
+    result.body = stripFromElements(result.body);
+  }
+  return result;
+}
+
+// src/builder/lib/multiline-parameters.ts
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function multilineParameters(operation) {
+  const names = /* @__PURE__ */ new Set();
+  if (!isRecord8(operation)) return names;
+  const legacyCard = operation.adaptive_card ?? operation.adaptiveCard;
+  const resolved = resolveUiSpec({
+    name: typeof operation.name === "string" ? operation.name : void 0,
+    ui: operation.ui,
+    adaptive_card: isRecord8(legacyCard) ? legacyCard : void 0
+  });
+  const pending = resolved?.spec.blocks.flatMap(
+    (block) => block.type === "adaptive_card" ? [block.card] : []
+  ) ?? [];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const element = pending.pop();
+    if (typeof element !== "object" || element === null || visited.has(element))
+      continue;
+    visited.add(element);
+    if (Array.isArray(element)) {
+      pending.push(...element);
+      continue;
+    }
+    if (!isRecord8(element)) continue;
+    if (element.type === "Input.Text" && element.isMultiline === true && typeof element.id === "string") {
+      const name = element.id.replace(/^(?:args\.)?state\./, "");
+      if (name) names.add(name);
+    }
+    pending.push(
+      element.body,
+      element.items,
+      element.columns,
+      element.actions,
+      element.card
+    );
+  }
+  if (isRecord8(operation.input_fields)) {
+    for (const [name, field] of Object.entries(operation.input_fields)) {
+      if (!isRecord8(field)) continue;
+      if (field.isMultiline === true) names.add(name);
+      else if (field.isMultiline === false) names.delete(name);
+    }
+  }
+  return names;
+}
+
+// src/builder/components/ndv/use-node-config.ts
+function fixedParameterState(state, params, field, value) {
+  const parameter = params.find((candidate) => candidate.name === field);
+  const parsed = parseParameterValue(
+    parameter?.schema ?? parameter?.type,
+    value
+  );
+  const nextValue = parsed.valid ? parsed.value : value;
+  const optionDependency = params.some(
+    (candidate) => Object.values(candidate.loadOptions?.parameterArgs ?? {}).includes(field)
+  );
+  if (nextValue === void 0 || !optionDependency && (nextValue === null || nextValue === "")) {
+    const next = { ...state };
+    delete next[field];
+    return next;
+  }
+  return { ...state, [field]: nextValue };
+}
+function errorConfigOf(node) {
+  const config = asRecord4(node?.data)?.errorConfig;
+  return config;
+}
+function coerceNumber(type, raw) {
+  if (raw.trim() === "") return void 0;
+  const n = type === "integer" ? parseInt(raw, 10) : parseFloat(raw);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function asRecord4(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function fallbackOperations(type) {
+  if (!type) return void 0;
+  return NODE_CONFIGS.find((c) => c.type === type)?.operations;
+}
+function selectedOperationOf(data, type) {
+  const live = liveInternalOperations(type);
+  if (live) {
+    const selected = resolveNodeOperation(
+      { operation_name: data?.operation_name },
+      live
+    ).selected;
+    if (selected) return selected;
+  }
+  return resolveNodeOperation(data, fallbackOperations(type)).selected;
+}
+function readOptionLabels(map, options) {
+  const labels = /* @__PURE__ */ Object.create(null);
+  for (const [value, text] of Object.entries(asRecord4(map) ?? {})) {
+    if (typeof text === "string" && text.trim() !== "") labels[value] = text;
+  }
+  if (Array.isArray(options)) {
+    for (const option of options) {
+      const rec = asRecord4(option);
+      const value = rec?.value ?? rec?.name;
+      const text = [
+        rec?.title,
+        rec?.label,
+        rec?.value !== void 0 ? rec?.name : void 0
+      ].find(
+        (candidate) => typeof candidate === "string" && candidate.trim() !== ""
+      );
+      if (typeof value === "string" && typeof text === "string" && text !== value) {
+        if (!Object.hasOwn(labels, value)) labels[value] = text;
+      }
+    }
+  }
+  return Object.keys(labels).length > 0 ? labels : void 0;
+}
+function optionText(param, value) {
+  const labels = param.optionLabels;
+  return labels && Object.hasOwn(labels, value) ? labels[value] : value;
+}
+function paramsFromOperation(op) {
+  const io = asRecord4(op?.input_fields);
+  if (!io) return [];
+  const multiline = multilineParameters(op);
+  return Object.entries(io).map(([name, spec]) => {
+    const rec = asRecord4(spec);
+    const optsRaw = rec?.options ?? rec?.enum;
+    const options = Array.isArray(optsRaw) ? optsRaw.map(
+      (o) => typeof o === "string" ? o : asRecord4(o)?.value ?? asRecord4(o)?.name
+    ).filter((v) => typeof v === "string") : void 0;
+    const loadOptions = readLoadOptionsSpec(rec?.loadOptions);
+    const optionLabels = readOptionLabels(rec?.optionLabels, optsRaw);
+    const fields = asRecord4(rec?.fields);
+    return {
+      name,
+      label: fieldLabel(name, rec),
+      placeholder: typeof rec?.placeholder === "string" && rec.placeholder.trim() !== "" ? rec.placeholder : void 0,
+      ...optionLabels ? { optionLabels } : {},
+      type: typeof spec === "string" ? spec : typeof rec?.type === "string" ? rec.type : "any",
+      required: rec?.required === true,
+      description: typeof rec?.description === "string" ? rec.description : void 0,
+      options,
+      defaultValue: rec?.default,
+      isMultiline: multiline.has(name),
+      schema: spec,
+      loadOptions,
+      ...rec?.secret === true ? { secret: true } : {},
+      displayOptions: readDisplayOptions(rec),
+      fields
+    };
+  });
+}
+function nodeTitle(node) {
+  if (!node) return "Node";
+  const data = asRecord4(node.data);
+  const label = typeof data?.label === "string" ? data.label : "";
+  return label || getNodeDetail(node.type).title || node.id;
+}
+function nodeSubtitle(node) {
+  const data = asRecord4(node?.data);
+  return typeof data?.operation_name === "string" ? data.operation_name : void 0;
+}
+function leaveUnchanged() {
+}
+function readOnlyNodeConfig(api) {
+  return {
+    ...api,
+    writeFixed: leaveUnchanged,
+    writeMapping: leaveUnchanged,
+    handleConnectionsChange: leaveUnchanged,
+    toggleMode: leaveUnchanged,
+    // A field dropped on a read-only form is refused, not opened as a link.
+    handleDropOnParam: () => (e) => e.preventDefault(),
+    writeErrorConfig: leaveUnchanged,
+    writeNotes: leaveUnchanged,
+    writeExecutionSettings: leaveUnchanged,
+    writeNodeDataField: leaveUnchanged,
+    readOnly: true
+  };
+}
+function runOnOf(executionSettings) {
+  const runOn = asRecord4(executionSettings?.runOn);
+  return runOn?.kind === "runner" && typeof runOn.runnerId === "string" ? { kind: "runner", runnerId: runOn.runnerId } : null;
+}
+function useNodeConfig(target, options) {
+  const nodes = useFlowStore((s) => s.workflow.nodes);
+  const edges = useFlowStore((s) => s.workflow.edges);
+  const workflowKey = useFlowStore((s) => s.workflow.workflowKey);
+  const readOnly = useBuilderReadOnly();
+  const executionLogs = useFlowStore((s) => s.execution.logs);
+  const currentRunId = useFlowStore((s) => s.execution.currentRunId);
+  const nodeId = target?.nodeId;
+  const node = useMemo(
+    () => nodeId ? nodes.find((n) => n.id === nodeId) : void 0,
+    [nodeId, nodes]
+  );
+  const incoming = useMemo(
+    () => nodeId ? edges.filter((e) => e.target === nodeId) : [],
+    [edges, nodeId]
+  );
+  const sourceIds = useMemo(() => incoming.map((e) => e.source), [incoming]);
+  const sourceKey = sourceIds.join(",");
+  const [selectedSource, setSelectedSource] = useState();
+  const [dragField, setDragField] = useState(null);
+  const [modeByField, setModeByField] = useState({});
+  useEffect(() => {
+    setSelectedSource(
+      (prev) => prev && sourceIds.includes(prev) ? prev : sourceIds[0]
+    );
+  }, [nodeId, sourceKey, sourceIds]);
+  useEffect(() => {
+    setModeByField({});
+  }, [nodeId, selectedSource]);
+  const sourceNode = useMemo(
+    () => nodes.find((n) => n.id === selectedSource),
+    [nodes, selectedSource]
+  );
+  const currentEdge = useMemo(
+    () => incoming.find((e) => e.source === selectedSource),
+    [incoming, selectedSource]
+  );
+  const registryRevision = useNodeRegistryRevision();
+  const currentOp = useMemo(() => {
+    return selectedOperationOf(asRecord4(node?.data), node?.type);
+  }, [node, registryRevision]);
+  const sourceOp = useMemo(() => {
+    return selectedOperationOf(asRecord4(sourceNode?.data), sourceNode?.type);
+  }, [sourceNode, registryRevision]);
+  const { fields: inputFields, data: inputData } = useMemo(
+    () => resolveMappingInput({
+      source: sourceNode,
+      operation: sourceOp,
+      runId: currentRunId,
+      logs: executionLogs
+    }),
+    [sourceNode, sourceOp, currentRunId, executionLogs]
+  );
+  const outputFields = useMemo(
+    () => fieldsFromIO(currentOp?.output_fields),
+    [currentOp]
+  );
+  const params = useMemo(() => paramsFromOperation(currentOp), [currentOp]);
+  const isWebhookTrigger = useMemo(
+    () => !!asRecord4(currentOp?.output_fields)?.webhookUrl,
+    [currentOp]
+  );
+  const isFormTrigger = useMemo(
+    () => !!asRecord4(currentOp?.output_fields)?.formUrl,
+    [currentOp]
+  );
+  const {
+    webhookUrl,
+    formUrl,
+    error: triggerUrlError,
+    loading: webhookUrlLoading
+  } = useWebhookRegistration(
+    workflowKey || void 0,
+    node?.id,
+    (isWebhookTrigger || isFormTrigger) && (options?.webhookEnabled ?? true)
+  );
+  const pickerFields = useMemo(() => flattenFields(inputFields), [inputFields]);
+  const mapping = currentEdge?.mapping?.definition ?? {};
+  const argsState = useMemo(() => {
+    const data = asRecord4(node?.data);
+    const args = asRecord4(data?.args);
+    return asRecord4(args?.state) ?? {};
+  }, [node]);
+  const isWebhookWait = useMemo(() => {
+    const type = asRecord4(asRecord4(node?.data)?.args)?.context;
+    const nodeType = asRecord4(asRecord4(type)?.node)?.type;
+    return nodeType === "internal:wait" && argsState.mode === "webhook";
+  }, [node, argsState]);
+  const connectionAdapters = useMemo(() => {
+    const op = asRecord4(currentOp);
+    const manifest = asRecord4(asRecord4(node?.data)?.nodeData);
+    const raw = op?.connectionAdapters ?? op?.credentialAdapters ?? manifest?.connectionAdapters ?? manifest?.credentialAdapters;
+    if (!Array.isArray(raw)) return [];
+    return raw.map((a) => asRecord4(a)).filter((a) => !!a).map((a) => ({
+      name: String(a.name ?? ""),
+      provider: String(a.provider ?? ""),
+      ...a.required === false ? { required: false } : {}
+    })).filter((a) => a.name && a.provider);
+  }, [currentOp, node]);
+  const selectedConnections = useMemo(() => {
+    const args = asRecord4(asRecord4(node?.data)?.args);
+    const fromList = (list, idKey) => {
+      if (!Array.isArray(list)) return [];
+      return list.map((c) => asRecord4(c)).filter((c) => !!c).map((c) => ({
+        connectionId: String(c[idKey] ?? ""),
+        adapter: String(c.adapter ?? "")
+      })).filter((c) => c.connectionId);
+    };
+    const connections = fromList(args?.connections, "connectionId");
+    if (connections.length > 0) return connections;
+    return fromList(args?.credentials, "id");
+  }, [node]);
+  const handleConnectionsChange = (connections) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const next = store.workflow.nodes.map((n) => {
+      if (n.id !== nodeId) return n;
+      const data = { ...asRecord4(n.data) ?? {} };
+      const args = { ...asRecord4(data.args) ?? {} };
+      delete args.credentials;
+      args.connections = connections.map((c) => ({
+        connectionId: c.connectionId,
+        adapter: c.adapter
+      }));
+      data.args = args;
+      return { ...n, data };
+    });
+    store.actions.nodes.setNodes(next);
+  };
+  const writeMapping = (field, value) => {
+    if (!currentEdge) return;
+    const store = useFlowStore.getState();
+    const freshEdges = store.workflow.edges;
+    const next = freshEdges.map((e) => {
+      if (e.id !== currentEdge.id) return e;
+      const def = updateMappingDefinition(
+        e.mapping?.definition ?? {},
+        field,
+        value
+      );
+      return {
+        ...e,
+        mapping: {
+          definition: def,
+          comment: e.mapping?.comment ?? `Map ${selectedSource} \u2192 ${nodeId ?? ""}`
+        }
+      };
+    });
+    store.actions.edges.setEdges(next);
+  };
+  const clearMappingFromAllIncoming = (field) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const fresh = store.workflow.edges;
+    let changed = false;
+    const next = fresh.map((e) => {
+      if (e.target !== nodeId || !e.mapping?.definition) return e;
+      if (!(field in e.mapping.definition)) return e;
+      const def = { ...e.mapping.definition };
+      delete def[field];
+      changed = true;
+      return { ...e, mapping: { ...e.mapping, definition: def } };
+    });
+    if (changed) store.actions.edges.setEdges(next);
+  };
+  const writeFixed = (field, value) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const next = store.workflow.nodes.map((n) => {
+      if (n.id !== nodeId) return n;
+      const data = { ...asRecord4(n.data) ?? {} };
+      const args = { ...asRecord4(data.args) ?? {} };
+      args.state = fixedParameterState(
+        asRecord4(args.state) ?? {},
+        params,
+        field,
+        value
+      );
+      data.args = args;
+      return { ...n, data };
+    });
+    store.actions.nodes.setNodes(next);
+    clearMappingFromAllIncoming(field);
+  };
+  const writeErrorConfig = (patch) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const next = store.workflow.nodes.map((n) => {
+      if (n.id !== nodeId) return n;
+      const data = { ...asRecord4(n.data) ?? {} };
+      const prev = errorConfigOf(n) ?? {};
+      const merged = { ...prev, ...patch };
+      if (patch.retryConfig !== void 0) {
+        merged.retryConfig = patch.retryConfig ? { ...prev.retryConfig, ...patch.retryConfig } : void 0;
+      }
+      if (patch.timeout !== void 0) {
+        merged.timeout = patch.timeout ? { ...prev.timeout, ...patch.timeout } : void 0;
+      }
+      data.errorConfig = merged;
+      return { ...n, data };
+    });
+    store.actions.nodes.setNodes(next);
+  };
+  const writeNodeDataField = (field, value) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const next = store.workflow.nodes.map((n) => {
+      if (n.id !== nodeId) return n;
+      const data = { ...asRecord4(n.data) ?? {} };
+      if (value === void 0 || value === "" || value === false) {
+        delete data[field];
+      } else {
+        data[field] = value;
+      }
+      return { ...n, data };
+    });
+    store.actions.nodes.setNodes(next);
+  };
+  const writeNotes = (value) => writeNodeDataField("notes", value);
+  const writeExecutionSettings = (patch) => {
+    if (!nodeId) return;
+    const store = useFlowStore.getState();
+    const next = store.workflow.nodes.map((n) => {
+      if (n.id !== nodeId) return n;
+      const data = { ...asRecord4(n.data) ?? {} };
+      const merged = {
+        ...asRecord4(data.executionSettings) ?? {},
+        ...patch
+      };
+      if (merged.runOn === null) delete merged.runOn;
+      if (!merged.alwaysOutputData && !merged.executeOnce && !merged.runOn) {
+        delete data.executionSettings;
+      } else {
+        data.executionSettings = merged;
+      }
+      return { ...n, data };
+    });
+    store.actions.nodes.setNodes(next);
+  };
+  const toggleMode = (field, current) => {
+    if (current === "expression") {
+      clearMappingFromAllIncoming(field);
+    }
+    setModeByField((m) => ({
+      ...m,
+      [field]: current === "expression" ? "fixed" : "expression"
+    }));
+  };
+  const errorConfig = useMemo(() => errorConfigOf(node), [node]);
+  const notes = useMemo(() => {
+    const data = asRecord4(node?.data);
+    return typeof data?.notes === "string" ? data.notes : "";
+  }, [node]);
+  const executionSettings = useMemo(
+    () => asRecord4(asRecord4(node?.data)?.executionSettings),
+    [node]
+  );
+  const alwaysOutputData = executionSettings?.alwaysOutputData === true;
+  const executeOnce = executionSettings?.executeOnce === true;
+  const runOn = useMemo(() => runOnOf(executionSettings), [executionSettings]);
+  const handleDropOnParam = (field) => (e) => {
+    e.preventDefault();
+    setDragField(null);
+    const path = e.dataTransfer.getData(FIELD_PATH_MIME);
+    if (path) {
+      writeMapping(field, pathToExpression(path));
+      setModeByField((m) => ({ ...m, [field]: "expression" }));
+    }
+  };
+  const api = {
+    node,
+    nodes,
+    incoming,
+    sourceIds,
+    selectedSource,
+    setSelectedSource,
+    currentEdge,
+    currentOp,
+    params,
+    argsState,
+    mapping,
+    inputFields,
+    inputData,
+    outputFields,
+    pickerFields,
+    connectionAdapters,
+    selectedConnections,
+    isWebhookTrigger,
+    isFormTrigger,
+    formUrl,
+    triggerUrlError,
+    isWebhookWait,
+    webhookUrl,
+    webhookUrlLoading,
+    modeByField,
+    dragField,
+    setDragField,
+    writeFixed,
+    writeMapping,
+    handleConnectionsChange,
+    toggleMode,
+    handleDropOnParam,
+    errorConfig,
+    writeErrorConfig,
+    notes,
+    writeNotes,
+    alwaysOutputData,
+    executeOnce,
+    runOn,
+    writeExecutionSettings,
+    writeNodeDataField,
+    readOnly: false
+  };
+  return readOnly ? readOnlyNodeConfig(api) : api;
+}
+
+// src/builder/components/ndv/node-parameter-issues.ts
+function nodeParamsOf(node) {
+  return paramsFromOperation(
+    selectedOperationOf(asRecord4(node.data), node.type)
+  );
+}
+function nodeDisplayName(node) {
+  const data = asRecord4(node.data);
+  const label = data?.label;
+  if (typeof label === "string" && label.trim() !== "") return label;
+  const name = asRecord4(data?.nodeData)?.name;
+  if (typeof name === "string" && name.trim() !== "") return name;
+  return node.type || node.id;
+}
+function workflowParameterIssues(nodes, edges, nodeIds) {
+  const only = nodeIds ? new Set(nodeIds) : void 0;
+  const checked = only ? nodes.filter((node) => only.has(node.id)) : nodes;
+  return nodeParameterIssues(checked, edges, nodeParamsOf, nodeDisplayName);
+}
+function useRunGuard(startRun, options = {}) {
   const { saveToBackend } = useSaveWorkflow();
   const [confirmOpen, setConfirmOpen] = useState(false);
   const [preparing, setPreparing] = useState(false);
+  const [issues, setIssues] = useState([]);
+  const stepNodeId = options.nodeId;
   const requestRun = useCallback(async () => {
+    const { nodes, edges } = useFlowStore.getState().workflow;
+    const found = workflowParameterIssues(
+      nodes,
+      edges,
+      stepNodeId ? [stepNodeId] : void 0
+    );
+    if (found.length > 0) {
+      setIssues(found);
+      return;
+    }
     const preparation = runPreparation();
     if (preparation === "run") {
       startRun();
@@ -3965,23 +5581,62 @@ function useRunGuard(startRun) {
       }
     }
     setConfirmOpen(true);
-  }, [saveToBackend, startRun]);
-  const dialog = /* @__PURE__ */ jsx(
-    UnsavedRunDialog,
+  }, [saveToBackend, startRun, stepNodeId]);
+  const dialog = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      UnsavedRunDialog,
+      {
+        open: confirmOpen,
+        onOpenChange: setConfirmOpen,
+        onRunSaved: () => {
+          setConfirmOpen(false);
+          startRun();
+        },
+        onSavedAndRunnable: () => {
+          setConfirmOpen(false);
+          startRun();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(MissingParametersDialog, { issues, onClose: () => setIssues([]) })
+  ] });
+  return { requestRun, preparing, dialog };
+}
+function MissingParametersDialog({
+  issues,
+  onClose,
+  title
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsx(
+    AlertDialog,
     {
-      open: confirmOpen,
-      onOpenChange: setConfirmOpen,
-      onRunSaved: () => {
-        setConfirmOpen(false);
-        startRun();
+      open: issues.length > 0,
+      onOpenChange: (open) => {
+        if (!open) onClose();
       },
-      onSavedAndRunnable: () => {
-        setConfirmOpen(false);
-        startRun();
-      }
+      children: /* @__PURE__ */ jsxs(AlertDialogContent, { "data-testid": "missing-parameters-dialog", children: [
+        /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+          /* @__PURE__ */ jsx(AlertDialogTitle, { children: title ?? tr(
+            "fluidgrids.builder.requiredParameters.runBlockedTitle",
+            "Fill in the required parameters first"
+          ) }),
+          /* @__PURE__ */ jsx(AlertDialogDescription, { children: tr(
+            "fluidgrids.builder.requiredParameters.runBlockedDescription",
+            "These nodes have required parameters that are still empty. The workflow is saved as it is; it can run once they are filled in."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx("ul", { className: "space-y-1 text-sm", "data-testid": "missing-parameters-list", children: issues.map((issue) => /* @__PURE__ */ jsxs("li", { children: [
+          /* @__PURE__ */ jsx("span", { className: "font-medium text-foreground", children: issue.nodeLabel }),
+          /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+            ": ",
+            issue.missing.map((field) => field.label).join(", ")
+          ] })
+        ] }, issue.nodeId)) }),
+        /* @__PURE__ */ jsx(AlertDialogFooter, { children: /* @__PURE__ */ jsx(AlertDialogCancel, { onClick: onClose, children: tr("fluidgrids.builder.requiredParameters.close", "Close") }) })
+      ] })
     }
   );
-  return { requestRun, preparing, dialog };
 }
 function UnsavedRunDialog({
   open,
@@ -4643,7 +6298,7 @@ var getNodeMetadata = (value) => {
         console.error("[NodeComponent] Execute step error:", error);
       });
     }, [executeStep, id]);
-    const stepGuard = useRunGuard(handleExecuteStep);
+    const stepGuard = useRunGuard(handleExecuteStep, { nodeId: id });
     const missingCredentials = useMemo(() => {
       const visibleAdapters = getVisibleConnectionAdapters(
         String(value?.type ?? ""),
@@ -4655,6 +6310,18 @@ var getNodeMetadata = (value) => {
       const selected2 = data?.args?.connections ?? data?.args?.credentials ?? [];
       return missingRequiredAdapters(visibleAdapters, selected2).length > 0;
     }, [data]);
+    const boundFields = useFlowStore(
+      useShallow((s) => [...boundFieldsOf(id, s.workflow.edges)].sort())
+    );
+    const missingParameters = useMemo(() => {
+      if (data?.disabled === true)
+        return [];
+      return missingRequiredParameters(
+        nodeParamsOf({ type: value?.type, data }),
+        nodeStateOf({ data }),
+        new Set(boundFields)
+      ).map((field) => field.label);
+    }, [boundFields, data, id, value?.type]);
     if (isAdapterSubNode) {
       return /* @__PURE__ */ jsx(SubNodeComponent, { ...props, nodeType: value?.type });
     }
@@ -4779,6 +6446,7 @@ var getNodeMetadata = (value) => {
                 appName,
                 accentKey: value?.type || meta.title,
                 missingCredentials,
+                missingParameters,
                 label: nodeLabel,
                 isRenaming: isRenamingThisNode && !readOnly,
                 onStartRename: readOnly ? void 0 : handleStartRename,
@@ -5170,4 +6838,4 @@ function createNodeWithDefaultData(type, data) {
   return Object.assign(createNodeData(type, defaultData), data);
 }
 
-export { AUTOSAVE_DEBOUNCE_MS, AUTOSAVE_RETRY_DELAYS_MS, AVAILABLE_NODES, BILLING_PLANS_PATH, DURABLE_FUNCTION_NODE_TYPES, EDIT_SESSION_ID, FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, FluidGridsContext, FluidGridsProvider, NODES_METADATA, NODE_CONFIGS, NODE_TYPES, PHASE_C_FLAGS_OFF, RUNS_QUOTA_NAME, RUN_CONTROL_NODE_TYPES, WORKFLOWS_QUOTA_NAME, WORKFLOW_TEST_NODE_TYPES, autosaveAllowedFor, bannerOf, blankWorkflowCreateInput, buildOperationSeed, buildStickyNode, builderPathOf, canAutosave, canSignalRun, classifyCreateRefusal, clearCodeWorkflowDefinitionCache, codeBuildIdOf, connectionsForAdapter, createConfiguredNode, createThenOpen, declaredOutputFields, declaredSignals, departingSave, durableInterfaceOf, editStateFor, editingLeaseLocked, emitNodeInstalled, emitRunFailed, emitRunLimitHit, emitRunStarted, emitTemplateUsed, emitUpgradeClicked, emitWorkflowCreated, emitWorkflowLimitHit, emitWorkflowPublished, ensureNodeConfigsLoaded, fieldsFromIO, fieldsFromValue, filterPaletteNodes, findQuotaRefusal, findSaveConflict, forgetSessionForReload, formatElapsedMs, formatParameterValue, getNodeDetail, getNodeMetadata, inAppLeaveTarget, isDurableFunctionNodeType, isFlowComplete, isLocked, isNodeConfigsInitialized, isNodeTypeHiddenFromPalette, isOptionalAdapter, isParamVisible, isQuotaExhaustedFailure, isRunControlNodeType, leaseCallQueue, leaseCallSequence, leavingLosesChanges, liveInternalOperations, loadDefinitionJson, matchesAdapterProvider, newConnectionProviderKey, nodeStateDurationMs, nodesOf, onNodeTypesUpdate, openRunQuotaUpgradePrompt, parseParameterValue, parseRawSignalPayload, pathToExpression, payloadFromCardValues, phaseAfterAcquire, phaseAfterTakeOver, readDisplayOptions, refetchStoreNodes, refusalOfQuota, registerWorkflowNodeTypes, registryNodeData, releasesOnClose, rememberOwnStatusChange, rememberRevision, rememberSessionForReload, replaceAdapterConnections, resolveFluidGridsFlagsSettled, resolveNodeOperation, resolvePhaseCFlags, runDurationMs, runSignalTargets, runTriggerFromMode, saveFailureActionOf, saveIndicatorOf, savedEverythingBeforeLeaving, sessionBeforeReload, shouldReleaseForIdle, signalPayloadCard, structuredParameterType, subscribeWorkflowSaved, tickAction, touchesSavedFields, useCanvasEdges, useCodeWorkflowInterface, useContinuousOptimisationEnabled, useDurableFunctionNodesEnabled, useDurableParityEnabled, useEditLeaseLocked, useEditLeaseStore, useFlowValidator, useFluidGridsAnalytics, useFluidGridsContext, useFluidGridsFlag, useFluidGridsFlagsSettled, useGuardedNavigate, useInsertNode, useManualSave, useNodeExecution, useNodeRegistryRevision, usePaletteGates, usePhaseCFlags, useRunGuard, useSaveStatusStore, useSaveWorkflow, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled, watchLeavingLosesChanges, workflowFingerprint };
+export { AUTOSAVE_DEBOUNCE_MS, AUTOSAVE_RETRY_DELAYS_MS, AVAILABLE_NODES, BILLING_PLANS_PATH, ConditionTreeBuilder, DURABLE_FUNCTION_NODE_TYPES, EDIT_SESSION_ID, FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, FieldTree, FluidGridsContext, FluidGridsProvider, MissingParametersDialog, NODES_METADATA, NODE_CONFIGS, NODE_TYPES, PHASE_C_FLAGS_OFF, RUNS_QUOTA_NAME, RUN_CONTROL_NODE_TYPES, SwitchRulesEditor, WORKFLOWS_QUOTA_NAME, WORKFLOW_TEST_NODE_TYPES, asRecord4 as asRecord, autosaveAllowedFor, bannerOf, blankWorkflowCreateInput, boundFieldsOf, buildOperationSeed, buildStickyNode, builderPathOf, canAutosave, canSignalRun, casesFromRules, classifyCreateRefusal, clearCodeWorkflowDefinitionCache, codeBuildIdOf, coerceNumber, connectionsForAdapter, createConfiguredNode, createThenOpen, declaredSignals, departingSave, durableInterfaceOf, editStateFor, editingLeaseLocked, emitNodeInstalled, emitRunFailed, emitRunLimitHit, emitRunStarted, emitTemplateUsed, emitUpgradeClicked, emitWorkflowCreated, emitWorkflowLimitHit, emitWorkflowPublished, ensureNodeConfigsLoaded, fieldsFromValue, filterPaletteNodes, findQuotaRefusal, findSaveConflict, fixedParameterState, forgetSessionForReload, formatElapsedMs, formatParameterValue, getNodeDetail, getNodeMetadata, inAppLeaveTarget, isDurableFunctionNodeType, isFlowComplete, isLocked, isNodeConfigsInitialized, isNodeTypeHiddenFromPalette, isOptionalAdapter, isParamVisible, isQuotaExhaustedFailure, isRunControlNodeType, isStringOptionList, latestNodeLog, leaseCallQueue, leaseCallSequence, leavingLosesChanges, loadDefinitionJson, matchesAdapterProvider, missingRequiredParameters, newConnectionProviderKey, nodeStateDurationMs, nodeSubtitle, nodeTitle, nodesOf, onNodeTypesUpdate, openRunQuotaUpgradePrompt, optionListText, optionListValues, optionText, paramsFromOperation, parseMappingValue, parseParameterValue, parseRawSignalPayload, payloadFromCardValues, phaseAfterAcquire, phaseAfterTakeOver, refetchStoreNodes, refusalOfQuota, registerWorkflowNodeTypes, registryNodeData, releasesOnClose, rememberOwnStatusChange, rememberRevision, rememberSessionForReload, replaceAdapterConnections, resolveFluidGridsFlagsSettled, resolveLoadOptionsSpec, resolveNodeOperation, resolvePhaseCFlags, resolveUiSpec, runDurationMs, runSignalTargets, runTriggerFromMode, saveFailureActionOf, saveIndicatorOf, savedEverythingBeforeLeaving, selectedOperationOf, sessionBeforeReload, shouldReleaseForIdle, signalPayloadCard, stripSubmitActions, structuredParameterType, tickAction, touchesSavedFields, useCanvasEdges, useCodeWorkflowInterface, useContinuousOptimisationEnabled, useDurableFunctionNodesEnabled, useDurableParityEnabled, useEditLeaseLocked, useEditLeaseStore, useFlowValidator, useFluidGridsAnalytics, useFluidGridsContext, useFluidGridsFlag, useFluidGridsFlagsSettled, useGuardedNavigate, useInsertNode, useManualSave, useNodeConfig, useNodeExecution, usePaletteGates, usePhaseCFlags, useRunGuard, useSaveStatusStore, useSaveWorkflow, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled, watchLeavingLosesChanges, workflowFingerprint, workflowParameterIssues };