@burdenoff/fluidgrids-fe-sdk 2026.1031.7 → 2026.1101.2

package/dist/chunk-IA2ZCHNQ.js

@@ -0,0 +1,1336 @@
+import { structuredParameterType, parseParameterValue, liveInternalOperations, resolveNodeOperation, readDisplayOptions, getNodeDetail, useFlowStore, useNodeRegistryRevision, fieldsFromIO, pathToExpression, NODE_CONFIGS, resolveUiSpec, fieldsFromValue, declaredOutputFields, subscribeWorkflowSaved } from './chunk-NZJWKVER.js';
+import { useBuilderReadOnly } from './chunk-OCJTTHTS.js';
+import { EventRegistrationsDocument } from './chunk-IHEV5HTD.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
+import { useMemo, useState, useEffect, useRef, useCallback } from 'react';
+import { Icon } from '@iconify/react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { cn } from '@burdenoff/fe-libs/utils';
+
+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
+  )) });
+}
+
+// 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/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-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 };
+}
+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 isRecord(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 : isRecord(schema) ? schema.type : void 0;
+  const inlineItem = typeof type === "string" ? type.trim().toLowerCase().match(/^array<(.+)>$/)?.[1] : void 0;
+  const item = (isRecord(schema) ? schema.items : void 0) ?? inlineItem;
+  if (item === void 0) return true;
+  const itemType = typeof item === "string" ? item : isRecord(item) ? item.type : void 0;
+  return typeof itemType === "string" && itemType.trim().toLowerCase() === "string";
+}
+function readLoadOptionsSpec(value) {
+  if (!isRecord(value) || typeof value.operation !== "string" || typeof value.labelField !== "string" || typeof value.valueField !== "string")
+    return void 0;
+  let parameterArgs;
+  if (value.parameterArgs !== void 0) {
+    if (!isRecord(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: isRecord(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 isRecord(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/builder/lib/multiline-parameters.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function multilineParameters(operation) {
+  const names = /* @__PURE__ */ new Set();
+  if (!isRecord2(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: isRecord2(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 (!isRecord2(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 (isRecord2(operation.input_fields)) {
+    for (const [name, field] of Object.entries(operation.input_fields)) {
+      if (!isRecord2(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 = asRecord(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 asRecord(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(asRecord(map) ?? {})) {
+    if (typeof text === "string" && text.trim() !== "") labels[value] = text;
+  }
+  if (Array.isArray(options)) {
+    for (const option of options) {
+      const rec = asRecord(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 = asRecord(op?.input_fields);
+  if (!io) return [];
+  const multiline = multilineParameters(op);
+  return Object.entries(io).map(([name, spec]) => {
+    const rec = asRecord(spec);
+    const optsRaw = rec?.options ?? rec?.enum;
+    const options = Array.isArray(optsRaw) ? optsRaw.map(
+      (o) => typeof o === "string" ? o : asRecord(o)?.value ?? asRecord(o)?.name
+    ).filter((v) => typeof v === "string") : void 0;
+    const loadOptions = readLoadOptionsSpec(rec?.loadOptions);
+    const optionLabels = readOptionLabels(rec?.optionLabels, optsRaw);
+    const fields = asRecord(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 = asRecord(node.data);
+  const label = typeof data?.label === "string" ? data.label : "";
+  return label || getNodeDetail(node.type).title || node.id;
+}
+function nodeSubtitle(node) {
+  const data = asRecord(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 = asRecord(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(asRecord(node?.data), node?.type);
+  }, [node, registryRevision]);
+  const sourceOp = useMemo(() => {
+    return selectedOperationOf(asRecord(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(
+    () => !!asRecord(currentOp?.output_fields)?.webhookUrl,
+    [currentOp]
+  );
+  const isFormTrigger = useMemo(
+    () => !!asRecord(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 = asRecord(node?.data);
+    const args = asRecord(data?.args);
+    return asRecord(args?.state) ?? {};
+  }, [node]);
+  const isWebhookWait = useMemo(() => {
+    const type = asRecord(asRecord(node?.data)?.args)?.context;
+    const nodeType = asRecord(asRecord(type)?.node)?.type;
+    return nodeType === "internal:wait" && argsState.mode === "webhook";
+  }, [node, argsState]);
+  const connectionAdapters = useMemo(() => {
+    const op = asRecord(currentOp);
+    const manifest = asRecord(asRecord(node?.data)?.nodeData);
+    const raw = op?.connectionAdapters ?? op?.credentialAdapters ?? manifest?.connectionAdapters ?? manifest?.credentialAdapters;
+    if (!Array.isArray(raw)) return [];
+    return raw.map((a) => asRecord(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 = asRecord(asRecord(node?.data)?.args);
+    const fromList = (list, idKey) => {
+      if (!Array.isArray(list)) return [];
+      return list.map((c) => asRecord(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 = { ...asRecord(n.data) ?? {} };
+      const args = { ...asRecord(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 = { ...asRecord(n.data) ?? {} };
+      const args = { ...asRecord(data.args) ?? {} };
+      args.state = fixedParameterState(
+        asRecord(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 = { ...asRecord(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 = { ...asRecord(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 = { ...asRecord(n.data) ?? {} };
+      const merged = {
+        ...asRecord(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 = asRecord(node?.data);
+    return typeof data?.notes === "string" ? data.notes : "";
+  }, [node]);
+  const executionSettings = useMemo(
+    () => asRecord(asRecord(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;
+}
+
+export { ConditionTreeBuilder, FieldTree, SwitchRulesEditor, asRecord, casesFromRules, coerceNumber, fixedParameterState, isStringOptionList, latestNodeLog, nodeSubtitle, nodeTitle, optionListText, optionListValues, optionText, paramsFromOperation, parseMappingValue, resolveLoadOptionsSpec, selectedOperationOf, useNodeConfig };