@octaviaflow/flow-rules 0.3.1 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,4095 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  ActionCategory: () => ActionCategory,
+  ActionStatus: () => ActionStatus,
+  ActionType: () => ActionType,
+  AggregateFunction: () => AggregateFunction,
+  CONDITION_OPERATORS: () => CONDITION_OPERATORS,
+  ConditionConfig: () => ConditionConfig,
+  DATABASE_CONNECTOR_IDS: () => DATABASE_CONNECTOR_IDS,
+  DebugConfig: () => DebugConfig,
+  EdgeType: () => EdgeType,
+  EmailConfig: () => EmailConfig,
+  FieldType: () => FieldType,
+  ForEachConfig: () => ForEachConfig,
+  JoinType: () => JoinType,
+  LogicalOperator: () => LogicalOperator,
+  ManualTriggerConfig: () => ManualTriggerConfig,
+  NodeStatus: () => NodeStatus,
+  QueryMode: () => QueryMode,
+  QueryType: () => QueryType,
+  STORAGE_CONNECTOR_IDS: () => STORAGE_CONNECTOR_IDS,
+  SortDirection: () => SortDirection,
+  TRANSFORM_OPERATIONS: () => TRANSFORM_OPERATIONS,
+  TransformConfig: () => TransformConfig,
+  VariablesConfig: () => VariablesConfig,
+  actionsRegistry: () => actionsRegistry,
+  buildPathOptions: () => buildPathOptions,
+  collectArrayPaths: () => collectArrayPaths,
+  collectArrayPathsFromSample: () => collectArrayPathsFromSample,
+  emailDefinition: () => emailDefinition,
+  flattenNestedWorkflow: () => flattenNestedWorkflow,
+  generateConnectionsFromSteps: () => generateConnectionsFromSteps,
+  generateEdgeId: () => generateEdgeId,
+  generateStepId: () => generateStepId,
+  generateUUIDv4: () => generateUUIDv4,
+  generateWorkflowId: () => generateWorkflowId,
+  getActionById: () => getActionById,
+  getActionsByCategory: () => getActionsByCategory,
+  getAllActions: () => getAllActions,
+  getEdgeValidationStatus: () => getEdgeValidationStatus,
+  getNodeConfigStatus: () => getNodeConfigStatus,
+  getNodeValidationStatus: () => getNodeValidationStatus,
+  getStorageProvider: () => getStorageProvider,
+  inferSchemaFromSample: () => inferSchemaFromSample,
+  isQueryableConnector: () => isQueryableConnector,
+  migrateDelayConfig: () => migrateDelayConfig,
+  queryDefinition: () => queryDefinition,
+  storageConfigKeys: () => storageConfigKeys,
+  transformConnectionToEdge: () => transformConnectionToEdge,
+  transformFlowToWorkflow: () => transformFlowToWorkflow,
+  transformStepToNode: () => transformStepToNode,
+  validateEdge: () => validateEdge,
+  validateFlowData: () => validateFlowData,
+  validateNode: () => validateNode,
+  validateWorkflow: () => validateWorkflow
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/catalog/types.ts
+var ActionCategory;
+((ActionCategory) => {
+  ActionCategory["Trigger"] = "trigger";
+  ActionCategory["Action"] = "action";
+  ActionCategory["Logic"] = "logic";
+  ActionCategory["Transform"] = "transform";
+  ActionCategory["AI"] = "ai";
+  ActionCategory["Database"] = "database";
+  ActionCategory["API"] = "api";
+  ActionCategory["Storage"] = "storage";
+  ActionCategory["FileStorage"] = "file_storage";
+  ActionCategory["Communication"] = "communication";
+  ActionCategory["CRM"] = "crm";
+  ActionCategory["Ecommerce"] = "ecommerce";
+  ActionCategory["Marketing"] = "marketing";
+  ActionCategory["Analytics"] = "analytics";
+  ActionCategory["Productivity"] = "productivity";
+  ActionCategory["Custom"] = "custom";
+  ActionCategory["Utility"] = "utility";
+})(ActionCategory ||= {});
+var ActionType;
+((ActionType) => {
+  ActionType["Schedule"] = "schedule";
+  ActionType["Webhook"] = "webhook";
+  ActionType["Manual"] = "manual";
+  ActionType["DataChange"] = "data_change";
+  ActionType["Event"] = "event";
+  ActionType["Read"] = "read";
+  ActionType["Write"] = "write";
+  ActionType["Update"] = "update";
+  ActionType["Delete"] = "delete";
+  ActionType["Query"] = "query";
+  ActionType["HTTPRequest"] = "http_request";
+  ActionType["GraphQLQuery"] = "graphql_query";
+  ActionType["Condition"] = "condition";
+  ActionType["ForEach"] = "for_each";
+  ActionType["Group"] = "group";
+  ActionType["Format"] = "format";
+  ActionType["AIAgent"] = "ai_agent";
+  ActionType["Embedding"] = "embedding";
+  ActionType["VectorSearch"] = "vector_search";
+  ActionType["ImageGeneration"] = "image_generation";
+  ActionType["ImageAnalysis"] = "image_analysis";
+  ActionType["SpeechToText"] = "speech_to_text";
+  ActionType["TextToSpeech"] = "text_to_speech";
+  ActionType["Transform"] = "transform";
+  ActionType["FileOperation"] = "file_operation";
+  ActionType["FileAction"] = "file_action";
+  ActionType["CsvAction"] = "csv_action";
+  ActionType["JsonAction"] = "json_action";
+  ActionType["XmlAction"] = "xml_action";
+  ActionType["ExcelAction"] = "excel_action";
+  ActionType["S3Action"] = "s3_action";
+  ActionType["FtpAction"] = "ftp_action";
+  ActionType["GoogleDriveAction"] = "google_drive_action";
+  ActionType["DropboxAction"] = "dropbox_action";
+  ActionType["OneDriveAction"] = "onedrive_action";
+  ActionType["StorageAction"] = "storage_action";
+  ActionType["EmailSend"] = "email_send";
+  ActionType["SlackMessage"] = "slack_message";
+  ActionType["WhatsappSend"] = "whatsapp_send";
+  ActionType["TeamsMessage"] = "teams_message";
+  ActionType["GoogleChat"] = "google_chat";
+  ActionType["WebhookCall"] = "webhook_call";
+  ActionType["Delay"] = "delay";
+  ActionType["Wait"] = "wait";
+  ActionType["Console"] = "console";
+  ActionType["Debug"] = "debug";
+  ActionType["Error"] = "error";
+  ActionType["CustomCode"] = "custom_code";
+  ActionType["CustomAction"] = "custom_action";
+  ActionType["IdpExtract"] = "idp_extract";
+})(ActionType ||= {});
+var ActionStatus;
+((ActionStatus) => {
+  ActionStatus["Stable"] = "stable";
+  ActionStatus["Beta"] = "beta";
+  ActionStatus["Alpha"] = "alpha";
+  ActionStatus["Experimental"] = "experimental";
+  ActionStatus["Deprecated"] = "deprecated";
+})(ActionStatus ||= {});
+var FieldType;
+((FieldType) => {
+  FieldType["String"] = "string";
+  FieldType["Number"] = "number";
+  FieldType["Boolean"] = "boolean";
+  FieldType["Date"] = "date";
+  FieldType["DateTime"] = "datetime";
+  FieldType["Array"] = "array";
+  FieldType["Object"] = "object";
+  FieldType["JSON"] = "json";
+  FieldType["File"] = "file";
+  FieldType["Image"] = "image";
+  FieldType["Select"] = "select";
+  FieldType["MultiSelect"] = "multi_select";
+  FieldType["Code"] = "code";
+  FieldType["Expression"] = "expression";
+  FieldType["Mapping"] = "mapping";
+  FieldType["Connection"] = "connection";
+  FieldType["Secret"] = "secret";
+  FieldType["Color"] = "color";
+  FieldType["URL"] = "url";
+  FieldType["Email"] = "email";
+  FieldType["Phone"] = "phone";
+  FieldType["RichText"] = "rich_text";
+  FieldType["Markdown"] = "markdown";
+})(FieldType ||= {});
+// src/ids.ts
+function randomSuffix(length = 7) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (let i = 0;i < length; i++) {
+    out += (bytes[i] % 36).toString(36);
+  }
+  return out;
+}
+function generateUUIDv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = crypto.getRandomValues(new Uint8Array(1))[0] % 16;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateWorkflowId() {
+  return generateUUIDv4();
+}
+function generateStepId() {
+  return `node_${Date.now()}_${randomSuffix(7)}`;
+}
+function generateEdgeId(sourceId, targetId) {
+  return `edge_${sourceId}_${targetId}_${Date.now()}_${randomSuffix(7)}`;
+}
+
+// src/catalog/triggers/manual-trigger/config.ts
+var ManualTriggerConfig = {
+  defaults: {
+    description: ""
+  },
+  schema: {
+    description: {
+      type: "string",
+      maxLength: 500,
+      required: false,
+      description: "Optional description for this trigger (shown on node)"
+    }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (config.description !== undefined) {
+      if (typeof config.description !== "string") {
+        errors.push("Description must be a string");
+      }
+      if (config.description.length > 500) {
+        errors.push("Description must not exceed 500 characters");
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  },
+  merge: (userConfig) => {
+    return {
+      ...ManualTriggerConfig.defaults,
+      ...userConfig
+    };
+  },
+  getLabel: (config) => {
+    if (config.description) {
+      return `Manual Trigger: ${config.description}`;
+    }
+    return "Manual Trigger";
+  }
+};
+
+// src/catalog/triggers/manual-trigger/index.ts
+var manualTriggerDefinition = {
+  id: "manual_trigger",
+  name: "Manual Trigger",
+  description: "Manually trigger workflow with optional description",
+  category: "trigger" /* Trigger */,
+  type: "manual" /* Manual */,
+  tags: ["trigger", "manual", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "PlayOutline",
+  color: "#0f62fe",
+  inputSchema: {
+    fields: [
+      {
+        key: "description",
+        label: "Description",
+        type: "string" /* String */,
+        description: "Optional description for this trigger (shown on node)",
+        placeholder: "e.g., Manual data sync, Testing workflow, etc.",
+        validation: {
+          required: false,
+          maxLength: 500
+        }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "triggeredAt",
+        type: "datetime" /* DateTime */,
+        description: "Timestamp when workflow was triggered"
+      },
+      {
+        key: "executionId",
+        type: "string" /* String */,
+        description: "Unique execution ID for this workflow run"
+      },
+      {
+        key: "description",
+        type: "string" /* String */,
+        description: "The description provided by the user (if any)"
+      }
+    ],
+    sampleOutput: {
+      triggeredAt: new Date().toISOString(),
+      executionId: `exec_${Date.now()}_${randomSuffix(9)}`,
+      description: "Manual data sync"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/triggers/schedule-trigger/index.ts
+var scheduleTriggerDefinition = {
+  id: "schedule_trigger",
+  name: "Schedule Trigger",
+  description: "Trigger workflow on a schedule using cron or intervals",
+  category: "trigger" /* Trigger */,
+  type: "schedule" /* Schedule */,
+  tags: ["trigger", "schedule", "cron", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Time",
+  color: "#0f62fe",
+  inputSchema: {
+    fields: [
+      {
+        key: "scheduleType",
+        label: "Schedule Type",
+        type: "select" /* Select */,
+        description: "Type of schedule",
+        defaultValue: "interval",
+        options: [
+          { label: "Interval", value: "interval" },
+          { label: "Cron Expression", value: "cron" },
+          { label: "Specific Time", value: "specific" }
+        ],
+        validation: { required: true }
+      },
+      {
+        key: "interval",
+        label: "Interval",
+        type: "number" /* Number */,
+        description: "Interval value (used with interval type)",
+        validation: { required: false, min: 1 }
+      },
+      {
+        key: "intervalUnit",
+        label: "Interval Unit",
+        type: "select" /* Select */,
+        description: "Unit for interval (minutes, hours, days)",
+        defaultValue: "minutes",
+        options: [
+          { label: "Minutes", value: "minutes" },
+          { label: "Hours", value: "hours" },
+          { label: "Days", value: "days" },
+          { label: "Weeks", value: "weeks" }
+        ],
+        validation: { required: false }
+      },
+      {
+        key: "cronExpression",
+        label: "Cron Expression",
+        type: "string" /* String */,
+        description: "Cron expression (e.g., 0 0 * * * for daily at midnight)",
+        placeholder: "0 0 * * *",
+        validation: { required: false }
+      },
+      {
+        key: "timezone",
+        label: "Timezone",
+        type: "string" /* String */,
+        description: "Timezone for schedule (e.g., UTC, America/New_York)",
+        defaultValue: "UTC",
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "scheduledAt",
+        type: "datetime" /* DateTime */,
+        description: "When the schedule was triggered"
+      },
+      {
+        key: "nextRun",
+        type: "datetime" /* DateTime */,
+        description: "When the next run is scheduled"
+      },
+      {
+        key: "scheduleType",
+        type: "string" /* String */,
+        description: "Type of schedule that triggered"
+      }
+    ],
+    sampleOutput: {
+      scheduledAt: new Date().toISOString(),
+      nextRun: new Date(Date.now() + 3600000).toISOString(),
+      scheduleType: "interval"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/triggers/webhook-trigger/index.ts
+var webhookTriggerDefinition = {
+  id: "webhook_trigger",
+  name: "Webhook Trigger",
+  description: "Trigger workflow via HTTP webhook",
+  category: "trigger" /* Trigger */,
+  type: "webhook" /* Webhook */,
+  tags: ["trigger", "webhook", "http", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "WebhookAlt",
+  color: "#0f62fe",
+  inputSchema: {
+    fields: [
+      {
+        key: "webhookPath",
+        label: "Webhook Path",
+        type: "string" /* String */,
+        description: "Custom path for the webhook URL",
+        placeholder: "/my-webhook",
+        validation: { required: false }
+      },
+      {
+        key: "method",
+        label: "HTTP Method",
+        type: "select" /* Select */,
+        description: "Allowed HTTP methods",
+        defaultValue: "POST",
+        options: [
+          { label: "GET", value: "GET" },
+          { label: "POST", value: "POST" },
+          { label: "PUT", value: "PUT" },
+          { label: "PATCH", value: "PATCH" },
+          { label: "DELETE", value: "DELETE" }
+        ],
+        validation: { required: true }
+      },
+      {
+        key: "requireAuth",
+        label: "Require Authentication",
+        type: "boolean" /* Boolean */,
+        description: "Require API key or token for webhook",
+        defaultValue: true,
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "webhookUrl",
+        type: "url" /* URL */,
+        description: "The generated webhook URL"
+      },
+      {
+        key: "method",
+        type: "string" /* String */,
+        description: "HTTP method used"
+      },
+      {
+        key: "payload",
+        type: "json" /* JSON */,
+        description: "Request payload received"
+      },
+      {
+        key: "headers",
+        type: "object" /* Object */,
+        description: "Request headers"
+      }
+    ],
+    sampleOutput: {
+      webhookUrl: "https://api.example.com/webhooks/trigger-123",
+      method: "POST",
+      payload: { data: "example" },
+      headers: { "content-type": "application/json" }
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/triggers/connector-trigger/index.ts
+var connectorTriggerDefinition = {
+  id: "connector_trigger",
+  name: "Connector Trigger",
+  description: "Trigger workflow when a connector platform event occurs",
+  category: "trigger" /* Trigger */,
+  type: "event" /* Event */,
+  tags: ["trigger", "connector", "event", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Connect",
+  color: "#6929c4",
+  inputSchema: {
+    fields: [
+      {
+        key: "connectorInstanceId",
+        label: "Connector Instance",
+        type: "string" /* String */,
+        description: "The connected app instance to listen to",
+        validation: { required: true }
+      },
+      {
+        key: "events",
+        label: "Events",
+        type: "json" /* JSON */,
+        description: "Entity/operation pairs to subscribe to",
+        validation: { required: true }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "eventType",
+        type: "string" /* String */,
+        description: "The type of event that occurred"
+      },
+      {
+        key: "entity",
+        type: "string" /* String */,
+        description: "The entity that changed (e.g. Invoice)"
+      },
+      {
+        key: "operation",
+        type: "string" /* String */,
+        description: "The operation performed (e.g. Create)"
+      },
+      {
+        key: "payload",
+        type: "json" /* JSON */,
+        description: "The event payload from the connector"
+      }
+    ],
+    sampleOutput: {
+      eventType: "connector.event",
+      entity: "Invoice",
+      operation: "Create",
+      payload: { id: "123", amount: 500 }
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/actions/http-request/index.ts
+var httpRequestDefinition = {
+  id: "http_request",
+  name: "HTTP Request",
+  description: "Make HTTP requests to external APIs and services",
+  category: "api" /* API */,
+  type: "http_request" /* HTTPRequest */,
+  tags: ["api", "http", "request", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "CloudUpload",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      {
+        key: "apiType",
+        label: "API Type",
+        type: "select" /* Select */,
+        description: "Type of API request to make",
+        defaultValue: "rest",
+        options: [
+          { label: "REST", value: "rest" },
+          { label: "GraphQL", value: "graphql" }
+        ],
+        validation: { required: true }
+      },
+      {
+        key: "method",
+        label: "Method",
+        type: "select" /* Select */,
+        description: "HTTP method to use (REST only)",
+        defaultValue: "GET",
+        options: [
+          { label: "GET", value: "GET" },
+          { label: "POST", value: "POST" },
+          { label: "PUT", value: "PUT" },
+          { label: "PATCH", value: "PATCH" },
+          { label: "DELETE", value: "DELETE" },
+          { label: "HEAD", value: "HEAD" },
+          { label: "OPTIONS", value: "OPTIONS" }
+        ],
+        validation: { required: false }
+      },
+      {
+        key: "url",
+        label: "URL",
+        type: "url" /* URL */,
+        description: "The URL to send the request to. Supports {{variable}} interpolation.",
+        placeholder: "https://api.example.com/endpoint",
+        validation: { required: true }
+      },
+      {
+        key: "headers",
+        label: "Headers",
+        type: "json" /* JSON */,
+        description: "HTTP headers (JSON object or key-value array). Supports {{variable}} interpolation.",
+        defaultValue: {},
+        validation: { required: false }
+      },
+      {
+        key: "body",
+        label: "Request Body",
+        type: "json" /* JSON */,
+        description: "Request body for POST/PUT/PATCH. Supports {{variable}} interpolation.",
+        validation: { required: false }
+      },
+      {
+        key: "graphqlQuery",
+        label: "GraphQL Query",
+        type: "string" /* String */,
+        description: "GraphQL query or mutation string (GraphQL only)",
+        validation: { required: false }
+      },
+      {
+        key: "graphqlVariables",
+        label: "GraphQL Variables",
+        type: "json" /* JSON */,
+        description: "GraphQL variables object. Supports {{variable}} interpolation.",
+        defaultValue: {},
+        validation: { required: false }
+      },
+      {
+        key: "auth",
+        label: "Authentication",
+        type: "json" /* JSON */,
+        description: 'Authentication config: { type: "none"|"basic"|"bearer"|"apikey", token?, username?, password?, apiKeyName?, apiKeyValue?, apiKeyLocation? }',
+        defaultValue: { type: "none" },
+        validation: { required: false }
+      },
+      {
+        key: "timeout",
+        label: "Timeout (ms)",
+        type: "number" /* Number */,
+        description: "Request timeout in milliseconds",
+        defaultValue: 30000,
+        validation: { required: false, min: 1000 }
+      },
+      {
+        key: "failOnError",
+        label: "Fail on non-2xx",
+        type: "boolean" /* Boolean */,
+        description: "If true, step fails when response status is not 2xx. Default: true.",
+        defaultValue: true,
+        validation: { required: false }
+      },
+      {
+        key: "responseType",
+        label: "Response Type",
+        type: "select" /* Select */,
+        description: "How to parse the response body. JSON tries to parse as JSON; Text returns raw text; Binary returns Uint8Array bytes plus fileName/contentType/size.",
+        defaultValue: "json",
+        options: [
+          { label: "JSON", value: "json" },
+          { label: "Text", value: "text" },
+          { label: "Binary", value: "binary" }
+        ],
+        validation: { required: false }
+      },
+      {
+        key: "expectedContentTypes",
+        label: "Expected Content-Types",
+        type: "json" /* JSON */,
+        description: 'Optional array of content-type prefixes (e.g. ["application/pdf"]). Logs a warning if the response content-type does not start with any of these.',
+        defaultValue: [],
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "status",
+        type: "number" /* Number */,
+        description: "HTTP status code"
+      },
+      {
+        key: "statusText",
+        type: "string" /* String */,
+        description: "HTTP status text"
+      },
+      {
+        key: "ok",
+        type: "boolean" /* Boolean */,
+        description: "True if status is 2xx"
+      },
+      {
+        key: "headers",
+        type: "object" /* Object */,
+        description: "Response headers"
+      },
+      {
+        key: "body",
+        type: "json" /* JSON */,
+        description: "Response body (parsed JSON or raw string)"
+      },
+      {
+        key: "duration",
+        type: "number" /* Number */,
+        description: "Request duration in milliseconds"
+      },
+      {
+        key: "graphqlErrors",
+        type: "json" /* JSON */,
+        description: "GraphQL errors array (GraphQL only, present when errors returned)"
+      },
+      {
+        key: "pages",
+        type: "number" /* Number */,
+        description: "Number of pages fetched (pagination only)"
+      },
+      {
+        key: "attempts",
+        type: "number" /* Number */,
+        description: "Total fetch attempts made (includes retries)"
+      },
+      {
+        key: "extracted",
+        type: "object" /* Object */,
+        description: "Named fields extracted from response body via dot-notation paths"
+      },
+      {
+        key: "fileName",
+        type: "string" /* String */,
+        description: "Derived file name (only present when Response Type is Binary). Sourced from Content-Disposition header or URL pathname."
+      },
+      {
+        key: "contentType",
+        type: "string" /* String */,
+        description: "Response content-type (only present when Response Type is Binary). Defaults to application/octet-stream when missing."
+      },
+      {
+        key: "size",
+        type: "number" /* Number */,
+        description: "Response body size in bytes (only present when Response Type is Binary)."
+      }
+    ],
+    sampleOutput: {
+      status: 200,
+      statusText: "OK",
+      ok: true,
+      headers: { "content-type": "application/json" },
+      body: { success: true, data: {} },
+      duration: 245,
+      attempts: 1,
+      extracted: {}
+    }
+  },
+  execution: {
+    timeout: 30000,
+    retryable: true
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/actions/console-log/index.ts
+var consoleLogDefinition = {
+  id: "console_log",
+  name: "Console Log",
+  description: "Log messages to the workflow console for debugging",
+  category: "utility" /* Utility */,
+  type: "console" /* Console */,
+  tags: ["utility", "logging", "debug", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Terminal",
+  color: "#525252",
+  inputSchema: {
+    fields: [
+      {
+        key: "message",
+        label: "Message",
+        type: "string" /* String */,
+        description: "Message to log",
+        placeholder: "e.g., Processing user data...",
+        validation: { required: true }
+      },
+      {
+        key: "level",
+        label: "Log Level",
+        type: "select" /* Select */,
+        description: "Log level for the message",
+        defaultValue: "info",
+        options: [
+          { label: "Info", value: "info" },
+          { label: "Warning", value: "warning" },
+          { label: "Error", value: "error" },
+          { label: "Debug", value: "debug" }
+        ],
+        validation: { required: true }
+      },
+      {
+        key: "data",
+        label: "Data",
+        type: "json" /* JSON */,
+        description: "Additional data to log",
+        validation: { required: false }
+      },
+      {
+        key: "includeInputData",
+        label: "Include previous step output",
+        type: "boolean" /* Boolean */,
+        description: 'When off, only the custom message prints — useful for summary "Done" logs that follow a ForEach.',
+        defaultValue: true,
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "logged",
+        type: "boolean" /* Boolean */,
+        description: "Whether the message was successfully logged"
+      },
+      {
+        key: "timestamp",
+        type: "datetime" /* DateTime */,
+        description: "Timestamp of the log entry"
+      },
+      {
+        key: "level",
+        type: "string" /* String */,
+        description: "Log level used"
+      }
+    ],
+    sampleOutput: {
+      logged: true,
+      timestamp: new Date().toISOString(),
+      level: "info"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/actions/delay/index.ts
+var delayDefinition = {
+  id: "delay",
+  name: "Delay",
+  description: "Pause workflow execution for a specified duration",
+  category: "utility" /* Utility */,
+  type: "delay" /* Delay */,
+  tags: ["utility", "delay", "wait", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Timer",
+  color: "#8f8f8f",
+  inputSchema: {
+    fields: [
+      {
+        key: "duration",
+        label: "Duration (ms)",
+        type: "number" /* Number */,
+        description: "Duration to delay in milliseconds",
+        defaultValue: 1000,
+        validation: { required: true, min: 0 }
+      },
+      {
+        key: "unit",
+        label: "Unit",
+        type: "select" /* Select */,
+        description: "Time unit for the duration",
+        defaultValue: "milliseconds",
+        options: [
+          { label: "Milliseconds", value: "milliseconds" },
+          { label: "Seconds", value: "seconds" },
+          { label: "Minutes", value: "minutes" },
+          { label: "Hours", value: "hours" }
+        ],
+        validation: { required: true }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "delayedFor",
+        type: "number" /* Number */,
+        description: "Actual delay duration in milliseconds"
+      },
+      {
+        key: "completedAt",
+        type: "datetime" /* DateTime */,
+        description: "Timestamp when delay completed"
+      }
+    ],
+    sampleOutput: {
+      delayedFor: 1000,
+      completedAt: new Date().toISOString()
+    }
+  },
+  execution: {
+    timeout: 3600000
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/logic/condition/index.ts
+var conditionDefinition = {
+  id: "condition",
+  name: "Condition",
+  description: "Branch workflow execution based on conditions",
+  category: "logic" /* Logic */,
+  type: "condition" /* Condition */,
+  tags: ["logic", "condition", "branching", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "DecisionTree",
+  color: "#f1c21b",
+  inputSchema: {
+    fields: [
+      {
+        key: "mode",
+        label: "Mode",
+        type: "string" /* String */,
+        description: "Authoring mode (visual builder).",
+        defaultValue: "visual",
+        validation: { required: true }
+      },
+      {
+        key: "filters",
+        label: "Condition Filters",
+        type: "array" /* Array */,
+        description: "Visual condition filters (field / operator / value rows)",
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "result",
+        type: "boolean" /* Boolean */,
+        description: "Result of the condition evaluation"
+      },
+      {
+        key: "branch",
+        type: "string" /* String */,
+        description: "Which branch was taken (true or false)"
+      }
+    ],
+    sampleOutput: {
+      result: true,
+      branch: "true"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/logic/for-each/index.ts
+var forEachDefinition = {
+  id: "for_each",
+  name: "ForEach",
+  description: "Iterate over array items and execute actions for each",
+  category: "logic" /* Logic */,
+  type: "for_each" /* ForEach */,
+  tags: ["logic", "loop", "iteration", "array", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Repeat",
+  color: "#f1c21b",
+  inputSchema: {
+    fields: [
+      {
+        key: "arrayPath",
+        label: "Records in",
+        type: "expression" /* Expression */,
+        description: "Path to the array to iterate over",
+        placeholder: "e.g., Account, data.items",
+        validation: { required: false }
+      },
+      {
+        key: "itemVariable",
+        label: "Item Variable Name",
+        type: "string" /* String */,
+        description: "Name of the variable for each item",
+        defaultValue: "item",
+        validation: { required: true }
+      },
+      {
+        key: "indexVariable",
+        label: "Index Variable Name",
+        type: "string" /* String */,
+        description: "Name of the variable for the index",
+        defaultValue: "index",
+        validation: { required: false }
+      },
+      {
+        key: "batchSize",
+        label: "Batch Size",
+        type: "number" /* Number */,
+        description: "Number of items to process per batch (0 = all at once)",
+        defaultValue: 0,
+        validation: { required: false }
+      },
+      {
+        key: "continueOnError",
+        label: "Continue on Error",
+        type: "boolean" /* Boolean */,
+        description: "Whether to continue processing remaining items if one fails",
+        defaultValue: false,
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "itemsProcessed",
+        type: "number" /* Number */,
+        description: "Number of items processed"
+      },
+      {
+        key: "results",
+        type: "array" /* Array */,
+        description: "Results from each iteration"
+      }
+    ],
+    sampleOutput: {
+      itemsProcessed: 5,
+      results: [{ item: 1 }, { item: 2 }]
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/logic/group/index.ts
+var groupDefinition = {
+  id: "group",
+  name: "Group",
+  description: "Visually group a set of steps — drop nodes inside to nest them.",
+  category: "logic" /* Logic */,
+  type: "group" /* Group */,
+  tags: ["logic", "container", "subflow", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "GroupObjects",
+  color: "#6f6f6f",
+  inputSchema: { fields: [] },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "result",
+        type: "object",
+        description: "Aggregated output of the contained steps."
+      }
+    ]
+  },
+  version: "1.0.0",
+  createdAt: "2026-05-19T00:00:00Z",
+  updatedAt: "2026-05-19T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/general/query/types.ts
+var QueryMode;
+((QueryMode) => {
+  QueryMode["Visual"] = "visual";
+  QueryMode["SQL"] = "sql";
+})(QueryMode ||= {});
+var QueryType;
+((QueryType) => {
+  QueryType["Select"] = "select";
+  QueryType["Insert"] = "insert";
+  QueryType["Update"] = "update";
+  QueryType["Delete"] = "delete";
+  QueryType["Custom"] = "custom";
+})(QueryType ||= {});
+var LogicalOperator;
+((LogicalOperator) => {
+  LogicalOperator["And"] = "and";
+  LogicalOperator["Or"] = "or";
+})(LogicalOperator ||= {});
+var SortDirection;
+((SortDirection) => {
+  SortDirection["Ascending"] = "asc";
+  SortDirection["Descending"] = "desc";
+})(SortDirection ||= {});
+var JoinType;
+((JoinType) => {
+  JoinType["Inner"] = "inner";
+  JoinType["Left"] = "left";
+  JoinType["Right"] = "right";
+  JoinType["Full"] = "full";
+})(JoinType ||= {});
+var AggregateFunction;
+((AggregateFunction) => {
+  AggregateFunction["Count"] = "count";
+  AggregateFunction["Sum"] = "sum";
+  AggregateFunction["Average"] = "avg";
+  AggregateFunction["Min"] = "min";
+  AggregateFunction["Max"] = "max";
+  AggregateFunction["CountDistinct"] = "count_distinct";
+})(AggregateFunction ||= {});
+// src/catalog/general/query/config.ts
+var BuildQueryConfigDefaults = {
+  mode: "visual" /* Visual */,
+  queryType: "select" /* Select */,
+  timeout: 30000,
+  maxRows: 1000,
+  visualConfig: {
+    tables: [],
+    fields: [],
+    filters: undefined,
+    joins: [],
+    groupBy: [],
+    sort: [],
+    limit: 10,
+    offset: 0
+  },
+  sqlConfig: {
+    sql: "",
+    parameters: {}
+  }
+};
+function isQueryableConnector(connector) {
+  if (connector.isQueryable !== undefined) {
+    return connector.isQueryable;
+  }
+  if (connector.category === "storage") {
+    return false;
+  }
+  if (!connector.type) {
+    return false;
+  }
+  const storageTypes = [
+    "dropbox",
+    "google_drive",
+    "google-drive",
+    "onedrive",
+    "box",
+    "ftp",
+    "sftp",
+    "s3",
+    "azure_blob",
+    "azure-blob",
+    "storage"
+  ];
+  return !storageTypes.includes(connector.type.toLowerCase());
+}
+
+// src/catalog/general/query/index.ts
+var queryDefinition = {
+  id: "query",
+  name: "Query",
+  description: "Execute queries against connected databases, APIs, and CRMs",
+  longDescription: "Create powerful queries using either a visual no-code builder or advanced SQL editor. Supports databases (PostgreSQL, MySQL, MongoDB, etc.), APIs (REST, GraphQL), and CRMs (Salesforce, HubSpot). Query results can be used as input for downstream actions.",
+  category: "database" /* Database */,
+  type: "query" /* Query */,
+  tags: ["query", "database", "sql", "visual-builder", "no-code", "api", "crm", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "QueryQueue",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      {
+        key: "connectorId",
+        label: "Select Connector",
+        type: "connection" /* Connection */,
+        description: "Choose a connected database, API, or CRM (storage connectors like Dropbox/Google Drive are not supported)",
+        validation: { required: true },
+        helpText: "Only queryable connectors are shown. File storage connectors have separate actions."
+      },
+      {
+        key: "mode",
+        label: "Query Mode",
+        type: "select" /* Select */,
+        description: "Choose between visual query builder or SQL editor",
+        options: [
+          {
+            label: "Visual Builder (No-Code)",
+            value: "visual" /* Visual */,
+            description: "Build queries visually without writing code"
+          },
+          {
+            label: "SQL Editor (Advanced)",
+            value: "sql" /* SQL */,
+            description: "Write raw SQL queries with syntax highlighting"
+          }
+        ],
+        defaultValue: "visual" /* Visual */,
+        validation: { required: true }
+      },
+      {
+        key: "queryType",
+        label: "Query Type",
+        type: "select" /* Select */,
+        description: "Type of query operation — the Query action reads data; use Transform to write",
+        options: [
+          { label: "SELECT (Read Data)", value: "select" /* Select */ }
+        ],
+        defaultValue: "select" /* Select */,
+        validation: { required: true },
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "visual" /* Visual */,
+            action: "show"
+          }
+        ]
+      },
+      {
+        key: "visualConfig.tables",
+        label: "Select Tables",
+        type: "multi_select" /* MultiSelect */,
+        description: "Choose one or more tables to query",
+        validation: { required: true },
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "visual" /* Visual */,
+            action: "show"
+          }
+        ],
+        optionsSource: {
+          type: "dynamic",
+          dependsOn: ["connectorId"]
+        }
+      },
+      {
+        key: "visualConfig.fields",
+        label: "Select Fields",
+        type: "array" /* Array */,
+        description: "Choose fields to include in the query result",
+        validation: { required: true },
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "visual" /* Visual */,
+            action: "show"
+          }
+        ]
+      },
+      {
+        key: "visualConfig.limit",
+        label: "Limit",
+        type: "number" /* Number */,
+        description: "Maximum number of rows to return",
+        defaultValue: 10,
+        validation: { required: false, min: 1, max: 1e4 },
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "visual" /* Visual */,
+            action: "show"
+          }
+        ]
+      },
+      {
+        key: "sqlConfig.sql",
+        label: "SQL Query",
+        type: "code" /* Code */,
+        language: "sql",
+        description: "Write your SQL query here",
+        placeholder: "SELECT * FROM users WHERE status = 'active' LIMIT 100",
+        validation: { required: true },
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "sql" /* SQL */,
+            action: "show"
+          }
+        ]
+      },
+      {
+        key: "sqlConfig.parameters",
+        label: "Query Parameters",
+        type: "json" /* JSON */,
+        description: 'Parameters for parameterized queries (e.g., {"userId": 123})',
+        validation: { required: false },
+        advanced: true,
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "sql" /* SQL */,
+            action: "show"
+          }
+        ]
+      },
+      {
+        key: "timeout",
+        label: "Query Timeout (ms)",
+        type: "number" /* Number */,
+        description: "Maximum time to wait for query execution",
+        defaultValue: 30000,
+        validation: { required: false, min: 1000, max: 300000 },
+        advanced: true
+      },
+      {
+        key: "maxRows",
+        label: "Max Rows",
+        type: "number" /* Number */,
+        description: "Maximum number of rows to return",
+        defaultValue: 1000,
+        validation: { required: false, min: 1, max: 1e4 },
+        advanced: true
+      }
+    ],
+    groups: [
+      {
+        id: "connection",
+        label: "Connection",
+        description: "Select the data source to query",
+        fields: ["connectorId"]
+      },
+      {
+        id: "query_mode",
+        label: "Query Configuration",
+        description: "Configure how you want to build your query",
+        fields: ["mode", "queryType"]
+      },
+      {
+        id: "visual_builder",
+        label: "Visual Query Builder",
+        description: "Build your query visually without writing code",
+        fields: ["visualConfig.tables", "visualConfig.fields", "visualConfig.limit"]
+      },
+      {
+        id: "sql_editor",
+        label: "SQL Editor",
+        description: "Write raw SQL queries",
+        fields: ["sqlConfig.sql", "sqlConfig.parameters"]
+      },
+      {
+        id: "settings",
+        label: "Advanced Settings",
+        description: "Configure query execution settings",
+        collapsed: true,
+        fields: ["timeout", "maxRows"]
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "data",
+        type: "array" /* Array */,
+        description: "Query result data as an array of objects",
+        example: [{ id: 1, name: "John Doe", email: "john@example.com" }]
+      },
+      {
+        key: "rowCount",
+        type: "number" /* Number */,
+        description: "Number of rows returned",
+        example: 1
+      },
+      {
+        key: "columns",
+        type: "array" /* Array */,
+        description: "Column names in the result set",
+        example: ["id", "name", "email"]
+      },
+      {
+        key: "executionTime",
+        type: "number" /* Number */,
+        description: "Query execution time in milliseconds",
+        example: 45
+      },
+      {
+        key: "generatedSQL",
+        type: "string" /* String */,
+        description: "The SQL query that was executed (for visual builder mode)",
+        example: "SELECT id, name, email FROM users WHERE status = 'active' LIMIT 100"
+      }
+    ],
+    sampleOutput: {
+      data: [
+        { id: 1, name: "John Doe", email: "john@example.com", status: "active" },
+        { id: 2, name: "Jane Smith", email: "jane@example.com", status: "active" }
+      ],
+      rowCount: 2,
+      columns: ["id", "name", "email", "status"],
+      executionTime: 45,
+      generatedSQL: "SELECT id, name, email, status FROM users WHERE status = 'active' LIMIT 100"
+    }
+  },
+  execution: {
+    timeout: 30000,
+    retryable: true,
+    requiresAuth: true
+  },
+  testable: true,
+  version: "1.0.0",
+  createdAt: "2025-01-19T00:00:00Z",
+  updatedAt: "2025-01-19T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true
+};
+
+// src/catalog/general/transform/index.ts
+var transformDefinition = {
+  id: "transform",
+  name: "Transform",
+  description: "Map and transform data between workflow steps using the visual field mapper",
+  category: "transform" /* Transform */,
+  type: "transform" /* Transform */,
+  tags: ["transform", "mapping", "data", "reshape", "convert", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Transform",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      {
+        key: "name",
+        label: "Transform Name",
+        type: "string" /* String */,
+        description: "A descriptive name for this transform step",
+        defaultValue: "Transform",
+        validation: { required: false }
+      },
+      {
+        key: "mappings",
+        label: "Field Mappings",
+        type: "array" /* Array */,
+        description: "Map source fields from upstream nodes to target output fields",
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "result",
+        type: "json" /* JSON */,
+        description: "Transformed data output"
+      },
+      {
+        key: "mappedFieldCount",
+        type: "number" /* Number */,
+        description: "Number of fields that were mapped/transformed"
+      }
+    ],
+    sampleOutput: {
+      result: { name: "John Doe", email: "john@example.com", age: 30 },
+      mappedFieldCount: 3
+    },
+    dynamic: true
+  },
+  version: "2.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2026-02-13T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/storage/csv-action/index.ts
+var csvActionDefinition = {
+  id: "csv_action",
+  name: "CSV",
+  description: "Parse CSV files into structured records or generate CSV files from workflow data",
+  category: "storage" /* Storage */,
+  type: "csv_action" /* CsvAction */,
+  tags: ["csv", "parse", "generate", "file", "format", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Document",
+  color: "#198038",
+  inputSchema: {
+    fields: [
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (CSV → Records)", value: "parse" }, { label: "Generate (Records → CSV)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "content", label: "CSV Content", type: "string" /* String */, description: "Paste CSV content or use FX token from upstream step" },
+      { key: "delimiter", label: "Delimiter", type: "select" /* Select */, options: [{ label: "Comma (,)", value: "," }, { label: "Semicolon (;)", value: ";" }, { label: "Tab", value: "\t" }, { label: "Pipe (|)", value: "|" }], defaultValue: "," },
+      { key: "headerRow", label: "Header Row", type: "number" /* Number */, description: "Row number containing column headers (default: 1)", defaultValue: 1 },
+      { key: "encoding", label: "Encoding", type: "select" /* Select */, options: [{ label: "UTF-8", value: "utf-8" }, { label: "Latin-1", value: "latin1" }, { label: "ASCII", value: "ascii" }], defaultValue: "utf-8" },
+      { key: "includeHeader", label: "Include Header Row", type: "boolean" /* Boolean */, description: "Include column headers in generated CSV", defaultValue: true },
+      { key: "fileName", label: "Output File Name", type: "string" /* String */, description: "Name for generated file (e.g. export.csv)", defaultValue: "export.csv" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "array" /* Array */, description: "Parsed records (parse mode) — loop these with a ForEach. Generated CSV string in generate mode." },
+      { key: "columns", type: "json" /* JSON */, description: "Column names" },
+      { key: "rowCount", type: "number" /* Number */, description: "Number of records" }
+    ],
+    sampleOutput: { data: [{ id: 1, name: "Widget", price: 9.99 }], columns: ["id", "name", "price"], rowCount: 1 }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/json-action/index.ts
+var jsonActionDefinition = {
+  id: "json_action",
+  name: "JSON",
+  description: "Parse JSON/JSONL files into structured records or generate JSON from workflow data",
+  category: "storage" /* Storage */,
+  type: "json_action" /* JsonAction */,
+  tags: ["json", "jsonl", "parse", "generate", "file", "format", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "DataStructured",
+  color: "#f1c21b",
+  inputSchema: {
+    fields: [
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (JSON → Records)", value: "parse" }, { label: "Generate (Records → JSON)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "format", label: "Format", type: "select" /* Select */, options: [{ label: "JSON (array)", value: "json" }, { label: "JSONL (one object per line)", value: "jsonl" }], defaultValue: "json" },
+      { key: "content", label: "JSON Content", type: "string" /* String */, description: "Paste JSON content or use FX token from upstream step" },
+      { key: "prettyPrint", label: "Pretty Print", type: "boolean" /* Boolean */, description: "Format output with indentation", defaultValue: true },
+      { key: "fileName", label: "Output File Name", type: "string" /* String */, defaultValue: "export.json" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "array" /* Array */, description: "Parsed records (parse mode) — loop these with a ForEach. Generated JSON string in generate mode." },
+      { key: "columns", type: "json" /* JSON */, description: "Field names" },
+      { key: "rowCount", type: "number" /* Number */, description: "Number of records" }
+    ],
+    sampleOutput: { data: [{ id: 1, name: "Widget" }], columns: ["id", "name"], rowCount: 1 }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/xml-action/index.ts
+var xmlActionDefinition = {
+  id: "xml_action",
+  name: "XML",
+  description: "Parse XML files into structured records or generate XML from workflow data",
+  category: "storage" /* Storage */,
+  type: "xml_action" /* XmlAction */,
+  tags: ["xml", "parse", "generate", "file", "format", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "Code",
+  color: "#e65100",
+  inputSchema: {
+    fields: [
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (XML → Records)", value: "parse" }, { label: "Generate (Records → XML)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "content", label: "XML Content", type: "string" /* String */, description: "Paste XML or use FX token" },
+      { key: "rootElement", label: "Root Element", type: "string" /* String */, description: "Root XML element name (for generate)", defaultValue: "data" },
+      { key: "rowElement", label: "Row Element", type: "string" /* String */, description: "Element name per record (for generate)", defaultValue: "row" },
+      { key: "fileName", label: "Output File Name", type: "string" /* String */, defaultValue: "export.xml" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "array" /* Array */, description: "Parsed records (parse mode) — loop these with a ForEach. Generated XML string in generate mode." },
+      { key: "columns", type: "json" /* JSON */, description: "Field names" },
+      { key: "rowCount", type: "number" /* Number */, description: "Number of records" }
+    ],
+    sampleOutput: { data: [{ id: 1, name: "Widget" }], columns: ["id", "name"], rowCount: 1 }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/excel-action/index.ts
+var excelActionDefinition = {
+  id: "excel_action",
+  name: "Excel",
+  description: "Parse Excel (.xlsx) files into structured records or generate Excel files from workflow data",
+  category: "storage" /* Storage */,
+  type: "excel_action" /* ExcelAction */,
+  tags: ["excel", "xlsx", "xls", "spreadsheet", "parse", "generate", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Spreadsheet",
+  color: "#217346",
+  inputSchema: {
+    fields: [
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (Excel → Records)", value: "parse" }, { label: "Generate (Records → Excel)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "content", label: "Excel File", type: "string" /* String */, description: "S3 key of uploaded Excel file or FX token from upstream" },
+      { key: "sheetName", label: "Sheet Name", type: "string" /* String */, description: "Name of sheet to read (default: first sheet)" },
+      { key: "headerRow", label: "Header Row", type: "number" /* Number */, description: "Row number containing headers", defaultValue: 1 },
+      { key: "fileName", label: "Output File Name", type: "string" /* String */, defaultValue: "export.xlsx" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "array" /* Array */, description: "Parsed records (parse mode) — loop these with a ForEach. File metadata in generate mode." },
+      { key: "columns", type: "json" /* JSON */, description: "Column names" },
+      { key: "rowCount", type: "number" /* Number */, description: "Number of records" },
+      { key: "s3Key", type: "string" /* String */, description: "S3 key of generated file" }
+    ],
+    sampleOutput: { data: [{ id: 1, name: "Widget" }], columns: ["id", "name"], rowCount: 1 }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/s3-action/index.ts
+var s3ActionDefinition = {
+  id: "s3_action",
+  name: "AWS S3",
+  description: "Upload, download, list, delete, or copy files in Amazon S3 buckets",
+  category: "storage" /* Storage */,
+  type: "s3_action" /* S3Action */,
+  tags: ["s3", "aws", "storage", "cloud", "bucket", "upload", "download", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "CloudUpload",
+  color: "#569A31",
+  inputSchema: {
+    fields: [
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "List Files", value: "list" }, { label: "Upload File", value: "upload" }, { label: "Download File", value: "download" }, { label: "Delete File", value: "delete" }, { label: "Copy File", value: "copy" }, { label: "Move / Rename", value: "move" }, { label: "Get Signed URL", value: "presign" }], defaultValue: "download", validation: { required: true } },
+      { key: "bucket", label: "Bucket Name", type: "string" /* String */, description: "S3 bucket name (defaults to the connector’s bucket)" },
+      { key: "key", label: "Object Key (Path)", type: "string" /* String */, description: "S3 object key, e.g. data/reports/monthly.csv" },
+      { key: "prefix", label: "Prefix (for List)", type: "string" /* String */, description: "Filter objects by prefix (folder path)" },
+      { key: "content", label: "File Content (for Upload)", type: "string" /* String */, description: "Content to upload — use FX token from upstream step" },
+      { key: "contentType", label: "Content Type", type: "string" /* String */, description: "MIME type (e.g. text/csv, application/json)", defaultValue: "application/octet-stream" },
+      { key: "destBucket", label: "Destination Bucket (for Copy)", type: "string" /* String */ },
+      { key: "destKey", label: "Destination Key (for Copy)", type: "string" /* String */ },
+      { key: "expiresIn", label: "URL Expiry (seconds)", type: "number" /* Number */, description: "Presigned URL expiry time", defaultValue: 3600 },
+      { key: "maxKeys", label: "Max Results (for List)", type: "number" /* Number */, defaultValue: 100 }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "json" /* JSON */, description: "Downloaded content, file list, or operation result" },
+      { key: "key", type: "string" /* String */, description: "S3 object key" },
+      { key: "url", type: "string" /* String */, description: "Presigned URL (for presign operation)" }
+    ],
+    sampleOutput: { data: "file content here", key: "data/reports/monthly.csv" }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/ftp-action/index.ts
+var ftpActionDefinition = {
+  id: "ftp_action",
+  name: "FTP / SFTP",
+  description: "Upload, download, list, delete, or move files on FTP/SFTP servers. Select a configured FTP connector, then pick files from the remote file explorer.",
+  category: "storage" /* Storage */,
+  type: "ftp_action" /* FtpAction */,
+  tags: ["ftp", "sftp", "ftps", "file", "transfer", "server", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "DataBackup",
+  color: "#005d5d",
+  inputSchema: {
+    fields: [
+      { key: "connector", label: "FTP / SFTP Connection", type: "connection" /* Connection */, description: "Select a configured FTP/SFTP connector from Integrations", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Download File", value: "download" }, { label: "Upload File", value: "upload" }, { label: "List Files", value: "list" }, { label: "Delete File", value: "delete" }, { label: "Move / Rename", value: "move" }], defaultValue: "download", validation: { required: true } },
+      { key: "remotePath", label: "Remote Path", type: "string" /* String */, description: "File or folder path on the server (use file explorer to browse)" },
+      { key: "content", label: "File Content (Upload)", type: "string" /* String */, description: "Content to upload — use FX token from upstream step" },
+      { key: "fileName", label: "File Name (Upload)", type: "string" /* String */, description: "Name for the uploaded file" },
+      { key: "destPath", label: "Destination Path (Move)", type: "string" /* String */, description: "New path for moved/renamed file" },
+      { key: "ifExists", label: "If File Exists", type: "select" /* Select */, options: [{ label: "Overwrite", value: "overwrite" }, { label: "Skip", value: "skip" }], defaultValue: "overwrite" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "json" /* JSON */, description: "Downloaded content, file list, or result" },
+      { key: "files", type: "json" /* JSON */, description: "List of files (for list op)" },
+      { key: "success", type: "boolean" /* Boolean */, description: "Whether operation succeeded" }
+    ],
+    sampleOutput: { success: true, data: "file content here" }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-29T00:00:00Z",
+  updatedAt: "2026-03-29T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/google-drive-action/index.ts
+var googleDriveActionDefinition = {
+  id: "google_drive_action",
+  name: "Google Drive",
+  description: "Upload, download, list, delete, move, copy, or share files in Google Drive",
+  category: "storage" /* Storage */,
+  type: "google_drive_action" /* GoogleDriveAction */,
+  tags: ["google", "drive", "cloud", "storage", "upload", "download", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "CloudUpload",
+  color: "#4285F4",
+  inputSchema: {
+    fields: [
+      { key: "connector", label: "Google Account", type: "connection" /* Connection */, description: "Select a connected Google Sheets connector (shares Drive access)", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Upload File", value: "upload" }, { label: "Download File", value: "download" }, { label: "List Files", value: "list" }, { label: "Delete File", value: "delete" }, { label: "Move File", value: "move" }, { label: "Copy File", value: "copy" }, { label: "Share File", value: "share" }, { label: "Create Folder", value: "create_folder" }], defaultValue: "upload", validation: { required: true } },
+      { key: "fileId", label: "File ID / Path", type: "string" /* String */, description: "Google Drive file ID (use file explorer to browse)" },
+      { key: "folderId", label: "Folder ID", type: "string" /* String */, description: "Target folder (root if empty)" },
+      { key: "fileName", label: "File Name", type: "string" /* String */ },
+      { key: "content", label: "File Content (Upload)", type: "string" /* String */, description: "Content to upload — use FX token from upstream" },
+      { key: "mimeType", label: "MIME Type", type: "string" /* String */, defaultValue: "application/octet-stream" },
+      { key: "destFolderId", label: "Destination Folder (Move/Copy)", type: "string" /* String */ },
+      { key: "shareEmail", label: "Share With Email", type: "string" /* String */ },
+      { key: "shareRole", label: "Permission", type: "select" /* Select */, options: [{ label: "Viewer", value: "reader" }, { label: "Editor", value: "writer" }], defaultValue: "reader" },
+      { key: "query", label: "Search Query (List)", type: "string" /* String */, description: "e.g. name contains 'report'" },
+      { key: "pageSize", label: "Max Results", type: "number" /* Number */, defaultValue: 50 }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "json" /* JSON */, description: "File content, file list, or operation result" },
+      { key: "fileId", type: "string" /* String */, description: "Google Drive file ID" },
+      { key: "webViewLink", type: "string" /* String */, description: "Link to view file in browser" }
+    ],
+    sampleOutput: { fileId: "1abc...", webViewLink: "https://drive.google.com/file/d/1abc.../view" }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/dropbox-action/index.ts
+var dropboxActionDefinition = {
+  id: "dropbox_action",
+  name: "Dropbox",
+  description: "Upload, download, list, delete, move, or copy files in Dropbox",
+  category: "storage" /* Storage */,
+  type: "dropbox_action" /* DropboxAction */,
+  tags: ["dropbox", "cloud", "storage", "upload", "download", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "CloudUpload",
+  color: "#0061FF",
+  inputSchema: {
+    fields: [
+      { key: "connector", label: "Dropbox Account", type: "connection" /* Connection */, description: "Select a connected Dropbox account", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Download File", value: "download" }, { label: "Upload File", value: "upload" }, { label: "List Files", value: "list" }, { label: "Delete", value: "delete" }, { label: "Move", value: "move" }, { label: "Copy", value: "copy" }, { label: "Create Folder", value: "create_folder" }, { label: "Get Shared Link", value: "shared_link" }], defaultValue: "download", validation: { required: true } },
+      { key: "path", label: "File / Folder Path", type: "string" /* String */, description: "Path on Dropbox (use file explorer to browse)" },
+      { key: "content", label: "File Content (Upload)", type: "string" /* String */, description: "Content to upload — use FX token from upstream" },
+      { key: "fileName", label: "File Name (Upload)", type: "string" /* String */ },
+      { key: "destPath", label: "Destination Path (Move/Copy)", type: "string" /* String */ },
+      { key: "mode", label: "Upload Mode", type: "select" /* Select */, options: [{ label: "Add (fail if exists)", value: "add" }, { label: "Overwrite", value: "overwrite" }], defaultValue: "overwrite" }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "json" /* JSON */, description: "File content, list, or metadata" },
+      { key: "path", type: "string" /* String */, description: "Dropbox file path" },
+      { key: "sharedLink", type: "string" /* String */, description: "Shared link URL" }
+    ],
+    sampleOutput: { path: "/reports/monthly.csv", data: "content..." }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/onedrive-action/index.ts
+var onedriveActionDefinition = {
+  id: "onedrive_action",
+  name: "OneDrive",
+  description: "Upload, download, list, delete, move, or copy files in Microsoft OneDrive",
+  category: "storage" /* Storage */,
+  type: "onedrive_action" /* OneDriveAction */,
+  tags: ["onedrive", "microsoft", "cloud", "storage", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "CloudUpload",
+  color: "#0078D4",
+  inputSchema: {
+    fields: [
+      { key: "connector", label: "Microsoft Account", type: "connection" /* Connection */, description: "Select a connected Microsoft/OneDrive account", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Download File", value: "download" }, { label: "Upload File", value: "upload" }, { label: "List Files", value: "list" }, { label: "Delete", value: "delete" }, { label: "Move", value: "move" }, { label: "Copy", value: "copy" }], defaultValue: "download", validation: { required: true } },
+      { key: "path", label: "File / Folder Path", type: "string" /* String */, description: "Path on OneDrive (use file explorer to browse)" },
+      { key: "itemId", label: "Item ID", type: "string" /* String */, description: "OneDrive item ID (alternative to path)" },
+      { key: "content", label: "File Content (Upload)", type: "string" /* String */, description: "Content to upload — use FX token from upstream" },
+      { key: "fileName", label: "File Name (Upload)", type: "string" /* String */ },
+      { key: "destPath", label: "Destination Path (Move/Copy)", type: "string" /* String */ }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "data", type: "json" /* JSON */, description: "File content, list, or metadata" },
+      { key: "itemId", type: "string" /* String */, description: "OneDrive item ID" },
+      { key: "webUrl", type: "string" /* String */, description: "Browser URL" }
+    ],
+    sampleOutput: { itemId: "abc123", webUrl: "https://onedrive.live.com/..." }
+  },
+  version: "1.0.0",
+  createdAt: "2026-03-28T00:00:00Z",
+  updatedAt: "2026-03-28T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/storage/storage-action/index.ts
+var storageActionDefinition = {
+  id: "storage_action",
+  name: "Storage",
+  description: "Browse, transfer, and manage files on any connected storage — cloud (Amazon S3, Google Drive, OneDrive, Dropbox, GCS, Azure Blob) or FTP/SFTP.",
+  category: "storage" /* Storage */,
+  type: "storage_action" /* StorageAction */,
+  tags: ["storage", "files", "s3", "dropbox", "onedrive", "google drive", "ftp", "sftp", "upload", "download", "cloud", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "CloudUpload",
+  color: "#4F46E5",
+  inputSchema: {
+    fields: [
+      { key: "connector", label: "Storage connector", type: "connection" /* Connection */, description: "Pick a connected storage connector — its provider drives the available operations.", validation: { required: true } },
+      {
+        key: "operation",
+        label: "Operation",
+        type: "select" /* Select */,
+        options: [
+          { label: "List files", value: "list" },
+          { label: "Download file", value: "download" },
+          { label: "Upload file", value: "upload" },
+          { label: "Delete file", value: "delete" },
+          { label: "Copy file", value: "copy" },
+          { label: "Move / rename", value: "move" },
+          { label: "Get signed URL", value: "presign" },
+          { label: "Share", value: "share" },
+          { label: "Create folder", value: "create_folder" },
+          { label: "Transfer to another connector", value: "transfer" }
+        ],
+        defaultValue: "download",
+        validation: { required: true }
+      },
+      { key: "path", label: "Path", type: "string" /* String */, description: "File or folder path — use the file browser in the panel." },
+      { key: "destPath", label: "Destination path", type: "string" /* String */, description: "Target for copy / move." },
+      { key: "content", label: "File content (for Upload)", type: "string" /* String */, description: "Content to upload — bind an FX token from an upstream step." }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "operation", type: "string" /* String */, description: "The operation that ran" },
+      { key: "data", type: "json" /* JSON */, description: "Operation result or downloaded content" },
+      { key: "files", type: "json" /* JSON */, description: "Listing (for the List operation)" },
+      { key: "path", type: "string" /* String */, description: "Affected file/folder path" },
+      { key: "url", type: "string" /* String */, description: "Signed URL (for the Get signed URL operation)" }
+    ],
+    sampleOutput: {
+      operation: "list",
+      files: [
+        { name: "report.csv", path: "/reports/report.csv", ext: "csv", mimeType: "text/csv", type: "file", size: 2048, modifiedAt: "2026-06-18T10:00:00Z" }
+      ]
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2026-06-05T00:00:00Z",
+  updatedAt: "2026-06-05T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/communication/email-send/index.ts
+var emailDefinition = {
+  id: "email",
+  name: "Email",
+  description: "Send an email through any connected email service provider",
+  category: "communication" /* Communication */,
+  type: "email_send" /* EmailSend */,
+  tags: ["communication", "email", "smtp", "sendgrid", "ses", "imap", "pop3", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Email",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      {
+        key: "connection",
+        label: "Email Service",
+        type: "connection" /* Connection */,
+        description: "Email service connection (SMTP, IMAP, SendGrid, AWS SES, etc.)",
+        validation: { required: true }
+      },
+      {
+        key: "operation",
+        label: "Operation",
+        type: "select" /* Select */,
+        description: "Email operation — Send is the only operation available today",
+        options: [
+          { label: "Send", value: "send" }
+        ],
+        defaultValue: "send",
+        validation: { required: true }
+      },
+      {
+        key: "to",
+        label: "To",
+        type: "string" /* String */,
+        description: "Recipient email address(es), comma-separated (for send operation)",
+        validation: { required: false }
+      },
+      {
+        key: "cc",
+        label: "CC",
+        type: "string" /* String */,
+        description: "CC email address(es), comma-separated (for send operation)",
+        validation: { required: false }
+      },
+      {
+        key: "bcc",
+        label: "BCC",
+        type: "string" /* String */,
+        description: "BCC email address(es), comma-separated (for send operation)",
+        validation: { required: false }
+      },
+      {
+        key: "subject",
+        label: "Subject",
+        type: "string" /* String */,
+        description: "Email subject (for send operation)",
+        validation: { required: false }
+      },
+      {
+        key: "body",
+        label: "Body",
+        type: "string" /* String */,
+        description: "Email body content (for send operation)",
+        validation: { required: false }
+      },
+      {
+        key: "isHtml",
+        label: "Is HTML",
+        type: "boolean" /* Boolean */,
+        description: "Whether body is HTML content",
+        defaultValue: false,
+        validation: { required: false }
+      },
+      {
+        key: "attachments",
+        label: "Attachments",
+        type: "array" /* Array */,
+        description: "File attachments (URLs or file paths)",
+        validation: { required: false }
+      },
+      {
+        key: "folder",
+        label: "Folder",
+        type: "string" /* String */,
+        description: "Email folder (Inbox, Sent, Drafts, etc.)",
+        validation: { required: false }
+      },
+      {
+        key: "query",
+        label: "Search Query",
+        type: "string" /* String */,
+        description: "Search criteria (for search/read operations)",
+        validation: { required: false }
+      },
+      {
+        key: "limit",
+        label: "Limit",
+        type: "number" /* Number */,
+        description: "Maximum number of emails to retrieve",
+        defaultValue: 10,
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "success",
+        type: "boolean" /* Boolean */,
+        description: "Whether operation was successful"
+      },
+      {
+        key: "data",
+        type: "json" /* JSON */,
+        description: "Operation result data (emails, message ID, etc.)"
+      },
+      {
+        key: "count",
+        type: "number" /* Number */,
+        description: "Number of emails affected/returned"
+      },
+      {
+        key: "messageId",
+        type: "string" /* String */,
+        description: "Email message ID (for send operation)"
+      }
+    ],
+    sampleOutput: {
+      success: true,
+      data: [{ id: "email_123", from: "sender@example.com", subject: "Test" }],
+      count: 1,
+      messageId: "msg_123456"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/communication/slack-message/index.ts
+var slackMessageDefinition = {
+  id: "slack_message",
+  name: "Slack",
+  description: "Send messages to Slack channels or users",
+  category: "communication" /* Communication */,
+  type: "slack_message" /* SlackMessage */,
+  tags: ["communication", "slack", "chat", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "brand:slack",
+  color: "#4A154B",
+  inputSchema: {
+    fields: [
+      { key: "connection", label: "Slack Workspace", type: "connection" /* Connection */, validation: { required: true } },
+      { key: "channel", label: "Channel/User", type: "string" /* String */, validation: { required: true } },
+      { key: "message", label: "Message", type: "string" /* String */, validation: { required: true } },
+      { key: "blocks", label: "Blocks (JSON)", type: "json" /* JSON */, validation: { required: false } }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "success", type: "boolean" /* Boolean */, description: "Whether message was sent" },
+      { key: "timestamp", type: "string" /* String */, description: "Message timestamp" }
+    ],
+    sampleOutput: { success: true, timestamp: "1234567890.123456" }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/communication/whatsapp-send/index.ts
+var whatsappSendDefinition = {
+  id: "whatsapp_send",
+  name: "WhatsApp",
+  description: "Send a WhatsApp message — an approved template, or freeform text inside the 24-hour reply window",
+  category: "communication" /* Communication */,
+  type: "whatsapp_send" /* WhatsappSend */,
+  tags: ["communication", "whatsapp", "messaging", "template", "built-in"],
+  status: "beta" /* Beta */,
+  icon: "brand:whatsapp",
+  color: "#25D366",
+  inputSchema: {
+    fields: [
+      { key: "connection", label: "WhatsApp Connection", type: "connection" /* Connection */, validation: { required: true } },
+      { key: "to", label: "To (phone number)", type: "string" /* String */, validation: { required: true } },
+      { key: "mode", label: "Message Type", type: "select" /* Select */, validation: { required: true } },
+      { key: "templateName", label: "Template", type: "string" /* String */, validation: { required: false } },
+      { key: "templateLanguage", label: "Template Language", type: "string" /* String */, validation: { required: false } },
+      { key: "templateVariables", label: "Template Variables", type: "json" /* JSON */, validation: { required: false } },
+      { key: "text", label: "Message", type: "string" /* String */, validation: { required: false } }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "ok", type: "boolean" /* Boolean */, description: "Whether WhatsApp accepted the message" },
+      { key: "messageId", type: "string" /* String */, description: "WhatsApp message ID (wamid…)" },
+      { key: "waId", type: "string" /* String */, description: "Recipient's resolved WhatsApp ID" },
+      { key: "mode", type: "string" /* String */, description: "template | text" }
+    ],
+    sampleOutput: {
+      ok: true,
+      messageId: "wamid.HBgMOTE4ODAyODg1MTQ1FQIAERgSN0YxN0E5RkQ5MEQ4RkE5QzFEAA==",
+      waId: "919876543210",
+      mode: "template"
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2026-07-30T00:00:00Z",
+  updatedAt: "2026-07-30T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/communication/teams-message/index.ts
+var teamsMessageDefinition = {
+  id: "teams_message",
+  name: "Teams",
+  description: "Post messages to Microsoft Teams channels via OAuth 2.0",
+  category: "communication" /* Communication */,
+  type: "teams_message" /* TeamsMessage */,
+  tags: ["communication", "teams", "microsoft", "chat", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "brand:teams",
+  color: "#4B53BC",
+  inputSchema: {
+    fields: [
+      { key: "connection", label: "Teams Account", type: "connection" /* Connection */, validation: { required: true } },
+      { key: "teamId", label: "Team", type: "string" /* String */, validation: { required: true } },
+      { key: "channelId", label: "Channel", type: "string" /* String */, validation: { required: true } },
+      { key: "title", label: "Subject", type: "string" /* String */, validation: { required: false } },
+      { key: "message", label: "Message", type: "string" /* String */, validation: { required: true } }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "ok", type: "boolean" /* Boolean */, description: "Whether the message was sent" },
+      { key: "id", type: "string" /* String */, description: "Sent message id" },
+      { key: "webUrl", type: "string" /* String */, description: "Deep link to the message" }
+    ],
+    sampleOutput: { ok: true, id: "1700000000000", webUrl: "https://teams.microsoft.com/l/message/..." }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/communication/google-chat/index.ts
+var googleChatDefinition = {
+  id: "google_chat",
+  name: "Google Chat",
+  description: "Post a message to a Google Chat space (OAuth 2.0 — pick any space you belong to)",
+  category: "communication" /* Communication */,
+  type: "google_chat" /* GoogleChat */,
+  tags: ["communication", "google", "chat", "webhook", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "brand:google_chat",
+  color: "#00AC47",
+  inputSchema: {
+    fields: [
+      { key: "connection", label: "Google Chat Space", type: "connection" /* Connection */, validation: { required: true } },
+      { key: "text", label: "Message", type: "string" /* String */, validation: { required: true } },
+      { key: "threadKey", label: "Thread Key", type: "string" /* String */, validation: { required: false } }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "ok", type: "boolean" /* Boolean */, description: "Whether the message was sent" },
+      { key: "name", type: "string" /* String */, description: "Created message resource name" }
+    ],
+    sampleOutput: { ok: true, name: "spaces/AAAA/messages/BBBB" }
+  },
+  version: "1.0.0",
+  createdAt: "2026-06-18T00:00:00Z",
+  updatedAt: "2026-06-18T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/communication/webhook-call/index.ts
+var webhookCallDefinition = {
+  id: "webhook_call",
+  name: "Webhook Call",
+  description: "Call external webhooks with custom payloads",
+  category: "communication" /* Communication */,
+  type: "webhook_call" /* WebhookCall */,
+  tags: ["communication", "webhook", "http", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Webhook",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      { key: "url", label: "Webhook URL", type: "url" /* URL */, validation: { required: true } },
+      { key: "method", label: "Method", type: "select" /* Select */, options: [
+        { label: "POST", value: "POST" },
+        { label: "PUT", value: "PUT" },
+        { label: "PATCH", value: "PATCH" },
+        { label: "GET", value: "GET" }
+      ], defaultValue: "POST", validation: { required: true } },
+      { key: "payload", label: "Payload", type: "json" /* JSON */, validation: { required: false } },
+      { key: "headers", label: "Headers", type: "json" /* JSON */, validation: { required: false } }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "statusCode", type: "number" /* Number */, description: "HTTP status code" },
+      { key: "response", type: "json" /* JSON */, description: "Response body" },
+      { key: "success", type: "boolean" /* Boolean */, description: "Whether call succeeded" }
+    ],
+    sampleOutput: { statusCode: 200, response: {}, success: true }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/utility/debug/index.ts
+var debugDefinition = {
+  id: "debug",
+  name: "Debug",
+  description: "Inspect, assert, watch, profile, or log workflow data at any point. Supports condition gating, sampling, and schema-drift detection.",
+  category: "utility" /* Utility */,
+  type: "debug" /* Debug */,
+  tags: ["utility", "debug", "observability", "assert", "snapshot", "profile", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Debug",
+  color: "#6929C4",
+  inputSchema: { fields: [] },
+  outputSchema: {
+    type: "object",
+    properties: [],
+    sampleOutput: { debugged: true, mode: "log" }
+  },
+  version: "2.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2026-05-02T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/utility/error/index.ts
+var errorDefinition = {
+  id: "error",
+  name: "Error",
+  description: "Throw an error to stop workflow execution",
+  category: "utility" /* Utility */,
+  type: "error" /* Error */,
+  tags: ["utility", "error", "control", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "ErrorFilled",
+  color: "#da3742",
+  inputSchema: {
+    fields: [
+      {
+        key: "message",
+        label: "Error Message",
+        type: "string" /* String */,
+        description: "Error message to throw",
+        validation: { required: true }
+      },
+      {
+        key: "code",
+        label: "Error Code",
+        type: "string" /* String */,
+        description: "Error code",
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "void",
+    properties: [],
+    sampleOutput: null
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/utility/variables/index.ts
+var variablesDefinition = {
+  id: "variables",
+  name: "Variables",
+  description: "Emit one or more typed user-defined values as a step output. Sources: literal, expression, prompt, secret, env.",
+  category: "utility" /* Utility */,
+  type: "write" /* Write */,
+  tags: ["utility", "variables", "value", "expression", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Parameter",
+  color: "#0F62FE",
+  inputSchema: { fields: [] },
+  outputSchema: {
+    type: "object",
+    properties: [],
+    sampleOutput: {}
+  },
+  version: "1.0.0",
+  createdAt: "2026-05-02T00:00:00Z",
+  updatedAt: "2026-05-02T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
+// src/catalog/api/graphql-query/index.ts
+var graphqlQueryDefinition = {
+  id: "graphql_query",
+  name: "GraphQL Query",
+  description: "Execute GraphQL queries against GraphQL endpoints",
+  category: "api" /* API */,
+  type: "graphql_query" /* GraphQLQuery */,
+  tags: ["api", "graphql", "query", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "GraphQL",
+  color: "#0043ce",
+  inputSchema: {
+    fields: [
+      {
+        key: "endpoint",
+        label: "GraphQL Endpoint",
+        type: "url" /* URL */,
+        description: "GraphQL endpoint URL",
+        validation: { required: true }
+      },
+      {
+        key: "query",
+        label: "Query",
+        type: "code" /* Code */,
+        description: "GraphQL query",
+        language: "json",
+        validation: { required: true }
+      },
+      {
+        key: "variables",
+        label: "Variables",
+        type: "json" /* JSON */,
+        description: "Query variables",
+        validation: { required: false }
+      },
+      {
+        key: "headers",
+        label: "Headers",
+        type: "json" /* JSON */,
+        description: "HTTP headers",
+        validation: { required: false }
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "data",
+        type: "json" /* JSON */,
+        description: "Query result data"
+      },
+      {
+        key: "errors",
+        type: "array" /* Array */,
+        description: "GraphQL errors"
+      }
+    ],
+    sampleOutput: {
+      data: { user: { id: "1", name: "John" } },
+      errors: []
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-12-15T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/ai/ai-agent/index.ts
+var aiAgentDefinition = {
+  id: "ai_agent",
+  name: "AI Agent",
+  description: "Run a reusable AI agent. Pick a saved agent from /ai/agents; optionally override model, temperature, or instructions per step.",
+  category: "ai" /* AI */,
+  type: "ai_agent" /* AIAgent */,
+  tags: ["ai", "agent", "chat", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Bot",
+  color: "#7c3aed",
+  inputSchema: {
+    fields: [
+      {
+        key: "agentId",
+        label: "Agent",
+        type: "string" /* String */,
+        description: "Saved Agent public id (e.g. agt_xxx).",
+        validation: { required: true }
+      },
+      {
+        key: "input",
+        label: "Input",
+        type: "string" /* String */,
+        description: "Chat agents: a string (template-supported via {{step.field}}). ETL agents: rows array. When blank, falls back to upstream step output."
+      },
+      {
+        key: "overrides",
+        label: "Overrides",
+        type: "json" /* JSON */,
+        description: "Optional per-step overrides of the agent’s own settings: model, temperature, maxTokens, topP, instructions and instructionsMode."
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "text", type: "string" /* String */, description: "Agent response text (chat agents)" },
+      { key: "rows", type: "json" /* JSON */, description: "Output rows (etl agents)" },
+      { key: "usage", type: "json" /* JSON */, description: "Token usage + cost: tokensIn, tokensOut, latencyMs, costUsd" },
+      { key: "model", type: "string" /* String */, description: "Model that produced the response" },
+      { key: "agentVersion", type: "number" /* Number */, description: "Version of the agent definition that ran" }
+    ],
+    sampleOutput: {
+      text: "Sure — happy to help. What would you like to know?",
+      usage: { tokensIn: 42, tokensOut: 18, latencyMs: 612, costUsd: 0.000041 },
+      model: "gpt-4o-mini",
+      agentVersion: 3
+    }
+  },
+  version: "1.0.0",
+  createdAt: "2026-05-27T00:00:00Z",
+  updatedAt: "2026-05-27T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: true
+};
+
+// src/catalog/ai/idp-extract/index.ts
+var idpExtractDefinition = {
+  id: "idp_extract",
+  name: "IDP",
+  description: "Extract structured data from documents received from an upstream step. Configure the model provider, model, and the JSON Schema to extract.",
+  category: "ai" /* AI */,
+  type: "idp_extract" /* IdpExtract */,
+  tags: ["ai", "idp", "document", "extract", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "DocumentImport",
+  color: "#0F62FE",
+  inputSchema: {
+    fields: [
+      {
+        key: "llmConnectorId",
+        label: "Model provider (connector)",
+        type: "select" /* Select */,
+        description: "Connected AI provider (OpenAI, Anthropic, Gemini, …). Resolved at execution time.",
+        validation: { required: true }
+      },
+      {
+        key: "model",
+        label: "Model",
+        type: "select" /* Select */,
+        description: "LLM available on the selected provider (e.g. gpt-4o, claude-3.5-sonnet, gemini-2.0-flash). Vision-capable models recommended.",
+        validation: { required: true }
+      },
+      {
+        key: "expectedSchema",
+        label: "Output schema",
+        type: "json" /* JSON */,
+        description: "JSON Schema describing the fields to extract. The LLM is forced to emit JSON matching this shape.",
+        validation: { required: false }
+      },
+      {
+        key: "systemPromptOverride",
+        label: "System prompt override",
+        type: "string" /* String */,
+        description: "Optional extra instructions appended to the extraction prompt."
+      },
+      {
+        key: "strategy",
+        label: "Strategy",
+        type: "select" /* Select */,
+        description: "vision-direct sends the file as an image to a vision LLM. auto picks based on PDF text content.",
+        defaultValue: "vision-direct"
+      }
+    ]
+  },
+  outputSchema: {
+    type: "object",
+    properties: [
+      { key: "state", type: "string" /* String */, description: "Aggregate state — completed | partial-success | failed." },
+      {
+        key: "pages",
+        type: "array" /* Array */,
+        description: "One row per file received from upstream: { fileName, data, confidence, audit, error? }"
+      },
+      {
+        key: "totals",
+        type: "object" /* Object */,
+        description: "Summary { pages, completed, failed }"
+      }
+    ]
+  },
+  version: "2.0.0",
+  createdAt: "2026-05-06T00:00:00Z",
+  updatedAt: "2026-05-10T00:00:00Z",
+  createdBy: "system"
+};
+
+// src/catalog/index.ts
+var actionsRegistry = {
+  ["trigger" /* Trigger */]: {
+    manual_trigger: manualTriggerDefinition,
+    schedule_trigger: scheduleTriggerDefinition,
+    webhook_trigger: webhookTriggerDefinition,
+    connector_trigger: connectorTriggerDefinition
+  },
+  ["action" /* Action */]: {
+    http_request: httpRequestDefinition,
+    console_log: consoleLogDefinition,
+    delay: delayDefinition,
+    query: queryDefinition,
+    transform: transformDefinition
+  },
+  ["logic" /* Logic */]: {
+    condition: conditionDefinition,
+    for_each: forEachDefinition,
+    group: groupDefinition
+  },
+  ["transform" /* Transform */]: {},
+  ["database" /* Database */]: {},
+  ["storage" /* Storage */]: {
+    csv_action: csvActionDefinition,
+    json_action: jsonActionDefinition,
+    excel_action: excelActionDefinition,
+    xml_action: xmlActionDefinition,
+    storage_action: storageActionDefinition,
+    s3_action: { ...s3ActionDefinition, deprecated: true, replacedBy: "storage_action" },
+    ftp_action: { ...ftpActionDefinition, deprecated: true, replacedBy: "storage_action" },
+    google_drive_action: { ...googleDriveActionDefinition, deprecated: true, replacedBy: "storage_action" },
+    dropbox_action: { ...dropboxActionDefinition, deprecated: true, replacedBy: "storage_action" },
+    onedrive_action: { ...onedriveActionDefinition, deprecated: true, replacedBy: "storage_action" }
+  },
+  ["communication" /* Communication */]: {
+    email: emailDefinition,
+    slack_message: slackMessageDefinition,
+    whatsapp_send: whatsappSendDefinition,
+    teams_message: teamsMessageDefinition,
+    google_chat: googleChatDefinition,
+    webhook_call: webhookCallDefinition
+  },
+  ["utility" /* Utility */]: {
+    variables: variablesDefinition,
+    debug: debugDefinition
+  },
+  ["ecommerce" /* Ecommerce */]: {},
+  ["api" /* API */]: {},
+  ["ai" /* AI */]: {
+    ai_agent: aiAgentDefinition,
+    idp_extract: idpExtractDefinition
+  }
+};
+var getAllActions = () => {
+  const allActions = [];
+  for (const category of Object.values(actionsRegistry)) {
+    allActions.push(...Object.values(category).filter((action) => action !== undefined));
+  }
+  return allActions;
+};
+var getActionById = (id) => {
+  for (const category of Object.values(actionsRegistry)) {
+    for (const action of Object.values(category)) {
+      if (action.id === id) {
+        return action;
+      }
+    }
+  }
+  return;
+};
+var getActionsByCategory = (category) => {
+  const categoryActions = actionsRegistry[category];
+  if (!categoryActions)
+    return [];
+  return Object.values(categoryActions);
+};
+// src/rules/nodeConfigStatus.ts
+var HIDDEN_STATUS_ACTIONS = new Set(["console_log"]);
+function isFieldFilled(value) {
+  if (value === undefined || value === null)
+    return false;
+  if (typeof value === "string")
+    return value.trim().length > 0;
+  if (typeof value === "number")
+    return true;
+  if (typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.length > 0;
+  if (typeof value === "object")
+    return Object.keys(value).length > 0;
+  return false;
+}
+function isSatisfiedOutOfBand(actionId, fieldKey, config) {
+  if (actionId === "connector_trigger" && fieldKey === "events") {
+    return Number(config.eventCount ?? 0) > 0;
+  }
+  if (MESSAGE_BODY_ACTIONS.has(actionId) && (fieldKey === "message" || fieldKey === "text")) {
+    const text = config.text ?? config.message;
+    if (typeof text === "string" && text.trim().length > 0)
+      return true;
+    return Array.isArray(config.blocks) && config.blocks.length > 0;
+  }
+  return false;
+}
+var MESSAGE_BODY_ACTIONS = new Set([
+  "slack_message",
+  "teams_message",
+  "google_chat"
+]);
+function getNestedValue(config, keyPath) {
+  const parts = keyPath.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function isFieldActive(field, config) {
+  if (!field.conditional || field.conditional.length === 0) {
+    return true;
+  }
+  return field.conditional.some((cond) => {
+    if (cond.action !== "show" && cond.action !== "require") {
+      return false;
+    }
+    const fieldValue = getNestedValue(config, cond.field);
+    switch (cond.operator) {
+      case "==":
+        return fieldValue === cond.value;
+      case "!=":
+        return fieldValue !== cond.value;
+      case ">":
+        return fieldValue > cond.value;
+      case "<":
+        return fieldValue < cond.value;
+      case ">=":
+        return fieldValue >= cond.value;
+      case "<=":
+        return fieldValue <= cond.value;
+      case "in":
+        return Array.isArray(cond.value) && cond.value.includes(fieldValue);
+      case "not_in":
+        return Array.isArray(cond.value) && !cond.value.includes(fieldValue);
+      case "contains":
+        return typeof fieldValue === "string" && fieldValue.includes(cond.value);
+      default:
+        return false;
+    }
+  });
+}
+function getNodeConfigStatus(node) {
+  if (HIDDEN_STATUS_ACTIONS.has(node.actionDefinitionId)) {
+    return {
+      status: "hidden",
+      requiredTotal: 0,
+      requiredFilled: 0,
+      optionalTotal: 0,
+      optionalFilled: 0,
+      missingRequired: [],
+      filledOptional: []
+    };
+  }
+  const definition = getActionById(node.actionDefinitionId);
+  if (!definition) {
+    return {
+      status: "unconfigured",
+      requiredTotal: 0,
+      requiredFilled: 0,
+      optionalTotal: 0,
+      optionalFilled: 0,
+      missingRequired: [],
+      filledOptional: []
+    };
+  }
+  const fields = definition.inputSchema?.fields ?? [];
+  const config = node.config ?? {};
+  const activeFields = fields.filter((f) => !f.hidden && isFieldActive(f, config));
+  const requiredFields = activeFields.filter((f) => f.validation?.required);
+  const optionalFields = activeFields.filter((f) => !f.validation?.required);
+  const missingRequired = [];
+  let requiredFilled = 0;
+  for (const field of requiredFields) {
+    const value = getNestedValue(config, field.key);
+    if (isFieldFilled(value)) {
+      requiredFilled++;
+    } else if (isFieldFilled(field.defaultValue)) {
+      requiredFilled++;
+    } else if (isSatisfiedOutOfBand(node.actionDefinitionId, field.key, config)) {
+      requiredFilled++;
+    } else {
+      missingRequired.push(field.key);
+    }
+  }
+  const filledOptional = [];
+  let optionalFilled = 0;
+  for (const field of optionalFields) {
+    const value = getNestedValue(config, field.key);
+    if (isFieldFilled(value)) {
+      optionalFilled++;
+      filledOptional.push(field.key);
+    }
+  }
+  const requiredTotal = requiredFields.length;
+  const optionalTotal = optionalFields.length;
+  let status;
+  if (requiredTotal === 0) {
+    status = "valid";
+  } else if (missingRequired.length === 0) {
+    status = "valid";
+  } else if (requiredFilled > 0 || optionalFilled > 0) {
+    status = "warning";
+  } else {
+    status = "error";
+  }
+  return {
+    status,
+    requiredTotal,
+    requiredFilled,
+    optionalTotal,
+    optionalFilled,
+    missingRequired,
+    filledOptional
+  };
+}
+
+// src/rules/workflowValidator.ts
+var nodeName = (n) => n.label || n.id;
+function validateNode(node, allNodes, allEdges) {
+  const errors = [];
+  if (!node.id || node.id.trim().length === 0) {
+    errors.push({
+      id: `node-${node.id}-id`,
+      type: "node",
+      severity: "error",
+      message: "Node ID is required",
+      nodeId: node.id
+    });
+  }
+  if (!node.label || node.label.trim().length === 0) {
+    errors.push({
+      id: `node-${node.id}-label`,
+      type: "node",
+      severity: "error",
+      message: "Node label is required",
+      nodeId: node.id
+    });
+  }
+  const cfg = getNodeConfigStatus(node);
+  if (cfg.missingRequired.length > 0) {
+    const fields = cfg.missingRequired.slice(0, 4).join(", ");
+    const more = cfg.missingRequired.length > 4 ? ` +${cfg.missingRequired.length - 4} more` : "";
+    errors.push({
+      id: `node-${node.id}-config`,
+      type: "node",
+      severity: "error",
+      message: `Missing required settings: ${fields}${more}. Open the step and fill them in.`,
+      nodeId: node.id
+    });
+  }
+  const hasOutput = allEdges.some((edge) => edge.source === node.id);
+  if (!hasOutput && node.type === "trigger") {
+    errors.push({
+      id: `node-${node.id}-output`,
+      type: "node",
+      severity: "warning",
+      message: `Trigger "${nodeName(node)}" has no outgoing connections`,
+      nodeId: node.id
+    });
+  }
+  return errors;
+}
+function validateEdge(edge, allNodes, allEdges = []) {
+  const errors = [];
+  const sourceNode = allNodes.find((n) => n.id === edge.source);
+  if (!sourceNode) {
+    errors.push({
+      id: `edge-${edge.id}-source`,
+      type: "edge",
+      severity: "error",
+      message: `Source node "${edge.source}" does not exist`,
+      edgeId: edge.id
+    });
+  }
+  const targetNode = allNodes.find((n) => n.id === edge.target);
+  if (!targetNode) {
+    errors.push({
+      id: `edge-${edge.id}-target`,
+      type: "edge",
+      severity: "error",
+      message: `Target node "${edge.target}" does not exist`,
+      edgeId: edge.id
+    });
+  }
+  if (edge.source === edge.target) {
+    errors.push({
+      id: `edge-${edge.id}-loop`,
+      type: "edge",
+      severity: "error",
+      message: "Nodes cannot connect to themselves",
+      edgeId: edge.id
+    });
+  }
+  const key = (e) => `${e.source}|${e.sourceHandle ?? ""}→${e.target}|${e.targetHandle ?? ""}`;
+  const myKey = key(edge);
+  const firstIndex = allEdges.findIndex((e) => key(e) === myKey);
+  const myIndex = allEdges.findIndex((e) => e.id === edge.id);
+  if (firstIndex !== -1 && myIndex > firstIndex) {
+    errors.push({
+      id: `edge-${edge.id}-duplicate`,
+      type: "edge",
+      severity: "warning",
+      message: `Duplicate connection between "${sourceNode ? nodeName(sourceNode) : edge.source}" and "${targetNode ? nodeName(targetNode) : edge.target}"`,
+      edgeId: edge.id
+    });
+  }
+  return errors;
+}
+function validateWorkflow(nodes, edges) {
+  const allErrors = [];
+  const hasTrigger = nodes.some((node) => node.type === "trigger");
+  if (!hasTrigger) {
+    allErrors.push({
+      id: "workflow-trigger",
+      type: "workflow",
+      severity: "error",
+      message: "Workflow must have at least one trigger node"
+    });
+  }
+  const hasAction = nodes.some((node) => node.type === "action");
+  if (!hasAction && nodes.length > 0) {
+    allErrors.push({
+      id: "workflow-action",
+      type: "workflow",
+      severity: "warning",
+      message: "Workflow should have at least one action node"
+    });
+  }
+  nodes.forEach((node) => {
+    const nodeErrors = validateNode(node, nodes, edges);
+    allErrors.push(...nodeErrors);
+  });
+  edges.forEach((edge) => {
+    const edgeErrors = validateEdge(edge, nodes, edges);
+    allErrors.push(...edgeErrors);
+  });
+  if (nodes.length > 0 && edges.length > 0) {
+    const inDegree = new Map(nodes.map((n) => [n.id, 0]));
+    const out = new Map;
+    for (const e of edges) {
+      if (e.source === e.target)
+        continue;
+      if (!inDegree.has(e.source) || !inDegree.has(e.target))
+        continue;
+      inDegree.set(e.target, (inDegree.get(e.target) ?? 0) + 1);
+      const list = out.get(e.source);
+      if (list)
+        list.push(e.target);
+      else
+        out.set(e.source, [e.target]);
+    }
+    const queue = nodes.filter((n) => (inDegree.get(n.id) ?? 0) === 0).map((n) => n.id);
+    let visited = 0;
+    while (queue.length) {
+      const cur = queue.shift();
+      visited++;
+      for (const next of out.get(cur) ?? []) {
+        const d = (inDegree.get(next) ?? 1) - 1;
+        inDegree.set(next, d);
+        if (d === 0)
+          queue.push(next);
+      }
+    }
+    if (visited < nodes.length) {
+      const stuck = nodes.filter((n) => (inDegree.get(n.id) ?? 0) > 0);
+      const names = stuck.slice(0, 3).map(nodeName).join(", ");
+      const more = stuck.length > 3 ? ` +${stuck.length - 3} more` : "";
+      allErrors.push({
+        id: "workflow-cycle",
+        type: "workflow",
+        severity: "error",
+        message: `Circular connection detected involving: ${names}${more}. Break the loop — execution order is undefined inside a cycle.`,
+        nodeId: stuck[0]?.id
+      });
+    }
+  }
+  const isTrigger = (n) => n.type === "trigger" || String(n.actionDefinitionId ?? "").endsWith("_trigger");
+  const triggerIds = nodes.filter(isTrigger).map((n) => n.id);
+  const adjacency = new Map;
+  for (const e of edges) {
+    const list = adjacency.get(e.source);
+    if (list)
+      list.push(e.target);
+    else
+      adjacency.set(e.source, [e.target]);
+  }
+  const reachable = new Set(triggerIds);
+  const queue = [...triggerIds];
+  while (queue.length) {
+    const cur = queue.shift();
+    for (const next of adjacency.get(cur) ?? []) {
+      if (!reachable.has(next)) {
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const n of nodes) {
+      if (reachable.has(n.id)) {
+        if (n.parentId && !reachable.has(n.parentId)) {
+          reachable.add(n.parentId);
+          changed = true;
+        }
+      } else if (n.parentId && reachable.has(n.parentId)) {
+        reachable.add(n.id);
+        changed = true;
+      }
+    }
+  }
+  nodes.forEach((node) => {
+    if (isTrigger(node))
+      return;
+    const isConnected = edges.some((e) => e.source === node.id || e.target === node.id);
+    const wontRun = triggerIds.length > 0 ? !reachable.has(node.id) : !isConnected;
+    if (wontRun) {
+      allErrors.push({
+        id: `node-${node.id}-orphan`,
+        type: "node",
+        severity: "warning",
+        message: isConnected ? `"${nodeName(node)}" isn't reachable from a trigger and won't run.` : `"${nodeName(node)}" isn't connected to a flow and won't run.`,
+        nodeId: node.id
+      });
+    }
+  });
+  if (triggerIds.length > 1) {
+    const parentOf = new Map(nodes.filter((n) => n.parentId).map((n) => [n.id, n.parentId]));
+    const undirected = new Map;
+    const link = (a, b) => {
+      const la = undirected.get(a);
+      if (la)
+        la.push(b);
+      else
+        undirected.set(a, [b]);
+    };
+    for (const e of edges) {
+      link(e.source, e.target);
+      link(e.target, e.source);
+    }
+    for (const [child, parent] of parentOf) {
+      link(child, parent);
+      link(parent, child);
+    }
+    const seen = new Set;
+    let flowsWithTrigger = 0;
+    for (const t of triggerIds) {
+      if (seen.has(t))
+        continue;
+      flowsWithTrigger++;
+      const stack = [t];
+      seen.add(t);
+      while (stack.length) {
+        const cur = stack.pop();
+        for (const next of undirected.get(cur) ?? []) {
+          if (!seen.has(next)) {
+            seen.add(next);
+            stack.push(next);
+          }
+        }
+      }
+    }
+    if (flowsWithTrigger > 1) {
+      allErrors.push({
+        id: "workflow-multi-flow",
+        type: "workflow",
+        severity: "warning",
+        message: `This canvas holds ${flowsWithTrigger} separate flows. Each trigger runs only its own flow — consider splitting them into separate flows for clarity.`
+      });
+    }
+  }
+  const errors = allErrors.filter((e) => e.severity === "error");
+  const warnings = allErrors.filter((e) => e.severity === "warning");
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function getNodeValidationStatus(nodeId, validationResult) {
+  const hasError = validationResult.errors.some((e) => e.nodeId === nodeId);
+  if (hasError)
+    return "error";
+  const hasWarning = validationResult.warnings.some((e) => e.nodeId === nodeId);
+  if (hasWarning)
+    return "warning";
+  return "valid";
+}
+function getEdgeValidationStatus(edgeId, validationResult) {
+  const hasError = validationResult.errors.some((e) => e.edgeId === edgeId);
+  if (hasError)
+    return "error";
+  const hasWarning = validationResult.warnings.some((e) => e.edgeId === edgeId);
+  if (hasWarning)
+    return "warning";
+  return "valid";
+}
+// src/catalog/logic/condition/config.ts
+var CONDITION_OPERATORS = [
+  { id: "equals", label: "Equals", needsValue: true },
+  { id: "not_equals", label: "Not Equals", needsValue: true },
+  { id: "greater_than", label: "Greater Than", needsValue: true },
+  { id: "greater_than_equals", label: "Greater Than or Equals", needsValue: true },
+  { id: "less_than", label: "Less Than", needsValue: true },
+  { id: "less_than_equals", label: "Less Than or Equals", needsValue: true },
+  { id: "like", label: "Like", needsValue: true },
+  { id: "contains", label: "Contains", needsValue: true },
+  { id: "starts_with", label: "Starts With", needsValue: true },
+  { id: "ends_with", label: "Ends With", needsValue: true },
+  { id: "is_null", label: "Is Null", needsValue: false },
+  { id: "is_not_null", label: "Is Not Null", needsValue: false },
+  { id: "is_empty", label: "Is Empty", needsValue: false }
+];
+var ConditionConfig = {
+  defaults: {
+    mode: "visual",
+    filters: [],
+    condition: ""
+  },
+  schema: {
+    mode: { type: "select", required: true },
+    filters: { type: "array", required: false },
+    condition: { type: "expression", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (config.mode === "expression") {
+      if (!config.condition) {
+        errors.push("Condition expression is required");
+      } else {
+        try {
+          new Function(`return ${config.condition}`);
+        } catch (e) {
+          errors.push(`Invalid expression: ${e instanceof Error ? e.message : "Unknown error"}`);
+        }
+      }
+    } else {
+      if (!config.filters || config.filters.length === 0) {
+        errors.push("At least one condition filter is required");
+      } else {
+        config.filters.forEach((f, i) => {
+          if (!f.field)
+            errors.push(`Filter ${i + 1}: Field is required`);
+          if (!f.operator)
+            errors.push(`Filter ${i + 1}: Operator is required`);
+          const opDef = CONDITION_OPERATORS.find((o) => o.id === f.operator);
+          if (opDef?.needsValue && !f.value) {
+            errors.push(`Filter ${i + 1}: Value is required`);
+          }
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ConditionConfig.defaults, ...userConfig };
+  },
+  generateName: (filters) => {
+    if (filters.length === 0)
+      return "If …";
+    const parts = filters.map((f, i) => {
+      const opLabel = CONDITION_OPERATORS.find((o) => o.id === f.operator)?.label || f.operator;
+      const base = `${f.field || "?"} ${opLabel}${f.value ? ` ${f.value}` : ""}`;
+      if (i === 0)
+        return base;
+      return `${(f.logicalOperator || "and").toUpperCase()} ${base}`;
+    });
+    return `If ${parts.join(" ")}`;
+  },
+  getLabel: (config) => {
+    if (config.mode === "expression")
+      return `If ${config.condition || "…"}`;
+    return ConditionConfig.generateName(config.filters);
+  },
+  createFilterId: () => `cond_${Date.now()}_${randomSuffix(5)}`
+};
+// src/catalog/logic/for-each/config.ts
+var SOURCELESS_MODES = new Set(["range", "cursor", "while"]);
+var ForEachConfig = {
+  defaults: {
+    arrayPath: "",
+    iterationMode: "records",
+    itemVariable: "item",
+    indexVariable: "index",
+    batchSize: 0,
+    continueOnError: false,
+    concurrency: "sequential",
+    collect: "array"
+  },
+  schema: {
+    arrayPath: { type: "select", required: false },
+    iterationMode: { type: "select", required: false },
+    itemVariable: { type: "string", required: true },
+    indexVariable: { type: "string", required: false },
+    batchSize: { type: "number", required: false },
+    continueOnError: { type: "boolean", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    const mode = config.iterationMode || "records";
+    if (mode === "range") {
+      if (!config.count || config.count <= 0) {
+        errors.push("Range mode needs a positive iteration count");
+      }
+    } else if (mode === "nested") {
+      if (!config.arrayPath)
+        errors.push("Select the records to drill into");
+      if (!config.nestedPath)
+        errors.push('Nested mode needs the sub-array path to iterate (e.g. "lineItems")');
+    } else if (!SOURCELESS_MODES.has(mode)) {
+      if (!config.arrayPath) {
+        errors.push("Array path is required — select which records to iterate over");
+      }
+    }
+    if (config.concurrency === "parallel" && config.maxConcurrency !== undefined && config.maxConcurrency < 1) {
+      errors.push("Max concurrency must be at least 1");
+    }
+    if (config.batchSize !== undefined && config.batchSize < 0) {
+      errors.push("Batch size must be 0 (all) or a positive number");
+    }
+    if (config.collect === "groupBy" && !config.groupByPath) {
+      errors.push("Group-by collection needs a field path to group on");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ForEachConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    const mode = config.iterationMode || "records";
+    if (mode === "range")
+      return `ForEach ×${config.count ?? "…"}`;
+    if (mode === "cursor")
+      return "ForEach (paginate)";
+    if (mode === "while")
+      return "ForEach (while)";
+    return `ForEach in ${config.arrayPath || "…"}`;
+  },
+  generateName: (arrayPath) => {
+    return `ForEach in ${arrayPath || "…"}`;
+  }
+};
+// src/catalog/logic/for-each/pathOptions.ts
+function inferSchemaFromSample(sample) {
+  const properties = {};
+  for (const [key, value] of Object.entries(sample)) {
+    if (value === null || value === undefined) {
+      properties[key] = { type: "string" };
+    } else if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+        properties[key] = { type: "array", items: inferSchemaFromSample(value[0]) };
+      } else {
+        properties[key] = { type: "array" };
+      }
+    } else if (typeof value === "object") {
+      properties[key] = inferSchemaFromSample(value);
+    } else if (typeof value === "number") {
+      properties[key] = { type: "number" };
+    } else if (typeof value === "boolean") {
+      properties[key] = { type: "boolean" };
+    } else {
+      properties[key] = { type: "string" };
+    }
+  }
+  return { type: "object", properties };
+}
+function collectArrayPaths(schema, prefix, add, depth = 0) {
+  if (!schema || typeof schema !== "object" || depth > 8)
+    return;
+  if (schema.type === "array") {
+    if (prefix) {
+      const itemsType = schema.items?.type;
+      const label = itemsType === "object" ? "array of objects" : "array";
+      add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+    }
+    if (schema.items) {
+      collectArrayPaths(schema.items, prefix, add, depth + 1);
+    }
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const next = prefix ? `${prefix}.${key}` : key;
+      collectArrayPaths(child, next, add, depth + 1);
+    }
+  }
+}
+function collectArrayPathsFromSample(sample, prefix, add, depth = 0) {
+  if (!sample || typeof sample !== "object" || depth > 8)
+    return;
+  if (Array.isArray(sample)) {
+    if (prefix) {
+      const itemsObj = sample.length > 0 && typeof sample[0] === "object" && sample[0] !== null;
+      const label = itemsObj ? "array of objects" : "array";
+      add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+    }
+    if (sample.length > 0) {
+      collectArrayPathsFromSample(sample[0], prefix, add, depth + 1);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(sample)) {
+    const next = prefix ? `${prefix}.${key}` : key;
+    collectArrayPathsFromSample(value, next, add, depth + 1);
+  }
+}
+function buildPathOptions(upstreamNodes) {
+  const paths = [];
+  const seen = new Set;
+  const add = (id, text, description) => {
+    if (seen.has(id))
+      return;
+    seen.add(id);
+    paths.push({ id, text, description });
+  };
+  if (upstreamNodes) {
+    for (const node of upstreamNodes) {
+      const label = node.label || node.type || "Upstream";
+      const queryTable = node.config?.visualConfig?.tables?.[0];
+      add("data", queryTable ? `${queryTable} (${label})` : `All records (${label})`, queryTable ? `Iterate over every ${queryTable} record` : "Iterate over every record from upstream");
+      const schema = node.outputSchema || node.config?._outputSchema;
+      if (schema)
+        collectArrayPaths(schema, "", add);
+      const output = node.executionData?.output;
+      if (output) {
+        const records = Array.isArray(output.data) ? output.data : Array.isArray(output) ? output : null;
+        if (records && records.length > 0 && typeof records[0] === "object") {
+          collectArrayPathsFromSample(records[0], "", add);
+        }
+      }
+    }
+  }
+  if (paths.length === 0) {
+    add("data", "data (upstream output)");
+  }
+  return paths;
+}
+// src/catalog/utility/variables/config.ts
+var RESERVED_KEYS = new Set(["_lineage", "_meta", "_redacted", "_error"]);
+var KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var VariablesConfig = {
+  defaults: {
+    fields: []
+  },
+  validate(config) {
+    const errors = [];
+    const fields = config.fields ?? [];
+    const seen = new Set;
+    for (const f of fields) {
+      if (!f.key) {
+        errors.push("Each field needs a key.");
+        continue;
+      }
+      if (RESERVED_KEYS.has(f.key)) {
+        errors.push(`"${f.key}" is reserved — pick another key.`);
+        continue;
+      }
+      if (!KEY_PATTERN.test(f.key)) {
+        errors.push(`"${f.key}" is not a valid identifier (letters, digits, underscore; must not start with a digit).`);
+        continue;
+      }
+      if (seen.has(f.key)) {
+        errors.push(`Duplicate key "${f.key}".`);
+        continue;
+      }
+      seen.add(f.key);
+      if (!f.type)
+        errors.push(`"${f.key}" is missing a type.`);
+      if (!f.source)
+        errors.push(`"${f.key}" is missing a source.`);
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  computeOutputSchema(fields) {
+    const properties = {};
+    for (const f of fields) {
+      properties[f.key] = fieldToJsonSchema(f);
+    }
+    return { type: "object", properties };
+  }
+};
+function fieldToJsonSchema(f) {
+  const node = { type: f.type };
+  if (f.description)
+    node.description = f.description;
+  if (f.validation?.enum)
+    node.enum = f.validation.enum;
+  return node;
+}
+// src/catalog/utility/debug/config.ts
+var DebugConfig = {
+  defaults: {
+    mode: "log",
+    label: "",
+    log: { level: "info", message: "" }
+  },
+  validate(config) {
+    const errors = [];
+    if (!config.mode)
+      errors.push("Mode is required.");
+    if (!config.label?.trim())
+      errors.push("Label is required.");
+    switch (config.mode) {
+      case "log":
+        if (!config.log?.message?.trim())
+          errors.push("Log mode: message is required.");
+        if (!config.log?.level)
+          errors.push("Log mode: level is required.");
+        break;
+      case "snapshot":
+        break;
+      case "watch":
+        if (!config.watch?.expressions?.length) {
+          errors.push("Watch mode: add at least one expression.");
+        } else {
+          for (const e of config.watch.expressions) {
+            if (!e.label?.trim())
+              errors.push("Watch mode: each expression needs a label.");
+            if (!e.expression?.trim())
+              errors.push("Watch mode: each expression needs an expression string.");
+          }
+        }
+        break;
+      case "assert":
+        if (!config.assert?.predicate?.trim())
+          errors.push("Assert mode: predicate is required.");
+        if (!config.assert?.failureMessage?.trim())
+          errors.push("Assert mode: failure message is required.");
+        break;
+      case "profile":
+        if (!config.profile?.scope)
+          errors.push("Profile mode: scope is required.");
+        break;
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  migrateLegacyStub(config) {
+    if (config.mode) {
+      const { value: _stub, ...rest } = config;
+      return { ...DebugConfig.defaults, ...rest };
+    }
+    return {
+      mode: "log",
+      label: config.label ?? "Debug",
+      log: {
+        level: "info",
+        message: config.label ?? "Debug",
+        includeInputData: true
+      }
+    };
+  },
+  merge(userConfig) {
+    return { ...DebugConfig.defaults, ...userConfig };
+  },
+  getLabel(config) {
+    return `Debug [${config.mode}]: ${config.label}`;
+  }
+};
+// src/catalog/actions/delay/migrate.ts
+var LEGACY_UNITS = new Set([
+  "milliseconds",
+  "seconds",
+  "minutes",
+  "hours"
+]);
+function migrateDelayConfig(raw) {
+  if (raw && typeof raw === "object" && "mode" in raw) {
+    return raw;
+  }
+  const legacy = raw ?? {};
+  const duration = typeof legacy.duration === "number" && Number.isFinite(legacy.duration) ? legacy.duration : 1;
+  const unit = typeof legacy.unit === "string" && LEGACY_UNITS.has(legacy.unit) ? legacy.unit : "milliseconds";
+  return {
+    mode: "fixed",
+    fixed: { duration, unit }
+  };
+}
+// src/catalog/communication/email-send/config.ts
+var EmailConfig = {
+  defaults: {
+    connection: "",
+    operation: "send",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    isHtml: false,
+    attachments: [],
+    folder: "Inbox",
+    query: "",
+    limit: 10
+  },
+  schema: {
+    connection: { type: "connection", required: true },
+    operation: { type: "select", required: true },
+    to: { type: "string", required: false },
+    cc: { type: "string", required: false },
+    bcc: { type: "string", required: false },
+    subject: { type: "string", required: false },
+    body: { type: "string", required: false },
+    isHtml: { type: "boolean", required: false },
+    attachments: { type: "array", required: false },
+    folder: { type: "string", required: false },
+    query: { type: "string", required: false },
+    limit: { type: "number", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Email service connection is required");
+    if (!config.operation)
+      errors.push("Operation is required");
+    if (config.operation === "send") {
+      if (!config.to)
+        errors.push("Recipient email is required for send operation");
+      if (!config.subject)
+        errors.push("Subject is required for send operation");
+      if (!config.body)
+        errors.push("Body is required for send operation");
+    } else if (config.operation) {
+      errors.push("Only Send is available for the Email action right now");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...EmailConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    switch (config.operation) {
+      case "send":
+        return `Email: Send to ${config.to}`;
+      case "read":
+        return `Email: Read from ${config.folder}`;
+      case "search":
+        return `Email: Search "${config.query}"`;
+      case "delete":
+        return `Email: Delete from ${config.folder}`;
+      case "move":
+        return `Email: Move to ${config.folder}`;
+      case "mark_read":
+        return `Email: Mark as read`;
+      default:
+        return `Email: ${config.operation}`;
+    }
+  }
+};
+// src/catalog/general/transform/config.ts
+var TRANSFORM_OPERATIONS = [
+  { id: "upsert", label: "Upsert" },
+  { id: "insert", label: "Insert" },
+  { id: "update", label: "Update" },
+  { id: "delete", label: "Delete" }
+];
+var DATABASE_CONNECTOR_IDS = new Set(["mongodb", "postgresql", "mysql", "sqlite", "google_sheets"]);
+var TransformConfig = {
+  defaults: {
+    name: "Transform",
+    operation: "upsert",
+    connectorId: "",
+    database: "",
+    objectName: "",
+    mode: "visual",
+    mappings: [],
+    expression: "",
+    fieldDefaults: {},
+    upsertMatchKey: "",
+    sheetHeaders: [],
+    createTabIfMissing: true,
+    writeHeaderRow: true,
+    clearBeforeWrite: false,
+    sheetCustomLayout: false,
+    sheetHeaderRow: 1,
+    sheetColumns: ""
+  },
+  schema: {
+    operation: { type: "select", required: true },
+    connectorId: { type: "connection", required: true },
+    database: { type: "text", required: false },
+    objectName: { type: "select", required: true },
+    mode: { type: "select", required: true },
+    mappings: { type: "array", required: false },
+    expression: { type: "code", required: false }
+  },
+  generateName: (operation, connectorLabel, objectName) => {
+    const opLabel = TRANSFORM_OPERATIONS.find((o) => o.id === operation)?.label || "Transform";
+    const target = connectorLabel || "Target";
+    const obj = objectName || "Object";
+    return `${opLabel} → ${target} · ${obj}`;
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.operation) {
+      errors.push("Operation is required");
+    }
+    if (!config.connectorId) {
+      errors.push("Target connector is required");
+    }
+    if (!config.objectName) {
+      errors.push("Object (table) is required");
+    }
+    const isLegacyExpression = config.mode === "expression" && !!config.expression?.trim();
+    if (!isLegacyExpression) {
+      if (!config.mappings || config.mappings.length === 0) {
+        errors.push("At least one field mapping is required");
+      } else {
+        config.mappings.forEach((mapping, index) => {
+          if (!mapping.sourceField) {
+            errors.push(`Mapping ${index + 1}: Source field is required`);
+          }
+          if (!mapping.targetField) {
+            errors.push(`Mapping ${index + 1}: Target field is required`);
+          }
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...TransformConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    const count = config.mappings?.length ?? 0;
+    return `${config.name || "Transform"} (${count} field${count !== 1 ? "s" : ""})`;
+  },
+  createMappingId: () => {
+    return `map_${Date.now()}_${randomSuffix(5)}`;
+  }
+};
+// src/catalog/storage/storageCapabilities.ts
+var contentTypeField = {
+  key: "contentType",
+  label: "Content type",
+  type: "string",
+  placeholder: "application/octet-stream",
+  advanced: true,
+  hint: "MIME type for the uploaded file."
+};
+var STORAGE_PROVIDERS = {
+  aws_s3: {
+    connectorId: "aws_s3",
+    label: "Amazon S3",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "prefix", label: "Folder", selectMode: "folder" }, fields: [{ key: "maxKeys", label: "Max results", type: "number", defaultValue: 100, advanced: true }] },
+      { value: "download", label: "Download file", path: { key: "key", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "key", label: "Destination key", selectMode: "both", required: true }, content: true, fields: [contentTypeField] },
+      { value: "delete", label: "Delete file", path: { key: "key", label: "File", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy file", path: { key: "key", label: "Source file", selectMode: "both", required: true }, dest: { key: "destKey", label: "Destination key", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "key", label: "Source file", selectMode: "both", required: true }, dest: { key: "destKey", label: "Destination key", selectMode: "both", required: true } },
+      { value: "presign", label: "Get signed URL", path: { key: "key", label: "File", selectMode: "both", required: true }, fields: [{ key: "expiresIn", label: "Expiry (seconds)", type: "number", defaultValue: 3600, advanced: true }] }
+    ]
+  },
+  ftp_sftp: {
+    connectorId: "ftp_sftp",
+    label: "FTP / SFTP",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "remotePath", label: "Folder", selectMode: "folder" } },
+      { value: "download", label: "Download file", path: { key: "remotePath", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "remotePath", label: "Destination path", selectMode: "both", required: true }, content: true },
+      { value: "delete", label: "Delete file", path: { key: "remotePath", label: "File", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "remotePath", label: "Source file", selectMode: "both", required: true }, dest: { key: "destPath", label: "Destination path", selectMode: "both", required: true } }
+    ]
+  },
+  dropbox: {
+    connectorId: "dropbox",
+    label: "Dropbox",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "path", label: "Folder", selectMode: "folder" } },
+      { value: "download", label: "Download file", path: { key: "path", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "path", label: "Destination path", selectMode: "both", required: true }, content: true, fields: [{ key: "mode", label: "Write mode", type: "select", options: [{ label: "Overwrite", value: "overwrite" }, { label: "Add (keep both)", value: "add" }], defaultValue: "overwrite", advanced: true }] },
+      { value: "delete", label: "Delete file", path: { key: "path", label: "File", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy file", path: { key: "path", label: "Source file", selectMode: "both", required: true }, dest: { key: "destPath", label: "Destination path", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "path", label: "Source file", selectMode: "both", required: true }, dest: { key: "destPath", label: "Destination path", selectMode: "both", required: true } }
+    ]
+  },
+  onedrive: {
+    connectorId: "onedrive",
+    label: "OneDrive",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "path", label: "Folder", selectMode: "folder" } },
+      { value: "download", label: "Download file", path: { key: "path", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "path", label: "Destination path", selectMode: "both", required: true }, content: true, fields: [contentTypeField] },
+      { value: "delete", label: "Delete file", path: { key: "path", label: "File", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy file", path: { key: "path", label: "Source file", selectMode: "both", required: true }, dest: { key: "destPath", label: "Destination path", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "path", label: "Source file", selectMode: "both", required: true }, dest: { key: "destPath", label: "Destination path", selectMode: "both", required: true } }
+    ]
+  },
+  google_drive: {
+    connectorId: "google_drive",
+    label: "Google Drive",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "folderId", label: "Folder", selectMode: "folder" }, fields: [{ key: "query", label: "Search query", type: "string", advanced: true }, { key: "pageSize", label: "Max results", type: "number", defaultValue: 50, advanced: true }] },
+      { value: "download", label: "Download file", path: { key: "fileId", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "folderId", label: "Destination folder", selectMode: "both" }, content: true, fields: [{ key: "fileName", label: "File name", type: "string", required: true }, { key: "mimeType", label: "Content type", type: "string", advanced: true }] },
+      { value: "delete", label: "Delete file", path: { key: "fileId", label: "File", selectMode: "both", required: true } },
+      { value: "move", label: "Move", path: { key: "fileId", label: "File", selectMode: "both", required: true }, dest: { key: "destFolderId", label: "Destination folder", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy", path: { key: "fileId", label: "File", selectMode: "both", required: true }, dest: { key: "destFolderId", label: "Destination folder", selectMode: "both" }, fields: [{ key: "fileName", label: "New name", type: "string" }] },
+      { value: "share", label: "Share", path: { key: "fileId", label: "File", selectMode: "both", required: true }, fields: [{ key: "shareEmail", label: "Share with (email)", type: "string", required: true }, { key: "shareRole", label: "Role", type: "select", options: [{ label: "Viewer", value: "reader" }, { label: "Editor", value: "writer" }], defaultValue: "reader" }] },
+      { value: "create_folder", label: "Create folder", path: { key: "folderId", label: "Parent folder", selectMode: "both" }, fields: [{ key: "fileName", label: "Folder name", type: "string", required: true }] }
+    ]
+  },
+  gcs: {
+    connectorId: "gcs",
+    label: "Google Cloud Storage",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "prefix", label: "Folder", selectMode: "folder" }, fields: [{ key: "maxKeys", label: "Max results", type: "number", defaultValue: 100, advanced: true }] },
+      { value: "download", label: "Download file", path: { key: "key", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "key", label: "Destination key", selectMode: "both", required: true }, content: true, fields: [contentTypeField] },
+      { value: "delete", label: "Delete file", path: { key: "key", label: "File", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy file", path: { key: "key", label: "Source file", selectMode: "both", required: true }, dest: { key: "destKey", label: "Destination key", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "key", label: "Source file", selectMode: "both", required: true }, dest: { key: "destKey", label: "Destination key", selectMode: "both", required: true } },
+      { value: "presign", label: "Get signed URL", path: { key: "key", label: "File", selectMode: "both", required: true }, fields: [{ key: "expiresIn", label: "Expiry (seconds)", type: "number", defaultValue: 3600, advanced: true }] }
+    ]
+  },
+  azure_blob: {
+    connectorId: "azure_blob",
+    label: "Azure Blob Storage",
+    browse: true,
+    operations: [
+      { value: "list", label: "List files", path: { key: "prefix", label: "Folder", selectMode: "folder" }, fields: [{ key: "maxKeys", label: "Max results", type: "number", defaultValue: 100, advanced: true }] },
+      { value: "download", label: "Download file", path: { key: "blob", label: "File", selectMode: "both", required: true } },
+      { value: "upload", label: "Upload file", path: { key: "blob", label: "Destination blob", selectMode: "both", required: true }, content: true, fields: [contentTypeField] },
+      { value: "delete", label: "Delete file", path: { key: "blob", label: "File", selectMode: "both", required: true } },
+      { value: "copy", label: "Copy file", path: { key: "blob", label: "Source blob", selectMode: "both", required: true }, dest: { key: "destBlob", label: "Destination blob", selectMode: "both", required: true } },
+      { value: "move", label: "Move / rename", path: { key: "blob", label: "Source blob", selectMode: "both", required: true }, dest: { key: "destBlob", label: "Destination blob", selectMode: "both", required: true } },
+      { value: "presign", label: "Get signed URL", path: { key: "blob", label: "File", selectMode: "both", required: true }, fields: [{ key: "expiresIn", label: "Expiry (seconds)", type: "number", defaultValue: 3600, advanced: true }] }
+    ]
+  }
+};
+STORAGE_PROVIDERS.google_sheets = { ...STORAGE_PROVIDERS.google_drive, connectorId: "google_sheets" };
+var transferOp = {
+  value: "transfer",
+  label: "Transfer to another connector",
+  path: { key: "path", label: "Source file or folder", selectMode: "both", required: true }
+};
+for (const id of ["aws_s3", "ftp_sftp", "dropbox", "onedrive", "google_drive", "gcs", "azure_blob"]) {
+  STORAGE_PROVIDERS[id].operations.push(transferOp);
+}
+var syncOp = {
+  value: "sync",
+  label: "Sync folder to another connector",
+  path: { key: "path", label: "Source folder", selectMode: "both", required: true },
+  fields: [
+    {
+      key: "ifExists",
+      label: "If a file already exists",
+      type: "select",
+      options: [
+        { label: "Overwrite", value: "overwrite" },
+        { label: "Skip it", value: "skip" },
+        { label: "Keep both (rename)", value: "rename" }
+      ],
+      defaultValue: "overwrite",
+      hint: "What to do when the destination already has the file."
+    },
+    {
+      key: "onError",
+      label: "On file error",
+      type: "select",
+      options: [
+        { label: "Stop the sync", value: "abort" },
+        { label: "Skip the file & continue", value: "skip" }
+      ],
+      defaultValue: "abort",
+      hint: "A bad file (timeout, lock, permission) stops the whole sync, or is skipped."
+    }
+  ]
+};
+for (const id of ["aws_s3", "ftp_sftp", "dropbox", "onedrive", "google_drive", "gcs", "azure_blob"]) {
+  STORAGE_PROVIDERS[id].operations.push(syncOp);
+}
+var STORAGE_CONNECTOR_IDS = Object.keys(STORAGE_PROVIDERS).filter((id) => id !== "google_sheets");
+function getStorageProvider(connectorId) {
+  if (!connectorId)
+    return;
+  return STORAGE_PROVIDERS[connectorId] ?? STORAGE_PROVIDERS[connectorId.replace(/-/g, "_")];
+}
+function storageConfigKeys() {
+  const keys = new Set([
+    "operation",
+    "connector",
+    "content",
+    "outputAs",
+    "path",
+    "destPath",
+    "destConnector",
+    "sourceIsDirectory",
+    "cursor",
+    "fileBudget",
+    "timeBudgetMs"
+  ]);
+  for (const provider of Object.values(STORAGE_PROVIDERS)) {
+    for (const op of provider.operations) {
+      if (op.path)
+        keys.add(op.path.key);
+      if (op.dest)
+        keys.add(op.dest.key);
+      for (const f of op.fields ?? [])
+        keys.add(f.key);
+    }
+  }
+  return [...keys];
+}
+// src/catalog/workflow.ts
+var NodeStatus;
+((NodeStatus) => {
+  NodeStatus["Idle"] = "idle";
+  NodeStatus["Running"] = "running";
+  NodeStatus["Success"] = "success";
+  NodeStatus["Error"] = "error";
+  NodeStatus["Warning"] = "warning";
+  NodeStatus["Disabled"] = "disabled";
+})(NodeStatus ||= {});
+var EdgeType;
+((EdgeType) => {
+  EdgeType["Default"] = "default";
+  EdgeType["Conditional"] = "conditional";
+  EdgeType["Loop"] = "loop";
+  EdgeType["Error"] = "error";
+})(EdgeType ||= {});
+// src/rules/flattenNestedWorkflow.ts
+function workflowIsNested(workflow) {
+  const stack = [...workflow.steps];
+  while (stack.length > 0) {
+    const s = stack.pop();
+    if (s.branches && Object.keys(s.branches).length > 0)
+      return true;
+  }
+  return false;
+}
+function flattenNestedWorkflow(workflow) {
+  if (!workflowIsNested(workflow))
+    return workflow;
+  const flatSteps = [];
+  const flatConns = [...workflow.connections];
+  const groups = [];
+  const walk = (steps, parentIdForSubflow) => {
+    for (const step of steps) {
+      const { branches, ...rest } = step;
+      const flatStep = {
+        ...rest,
+        ...parentIdForSubflow ? { parentId: parentIdForSubflow } : {}
+      };
+      flatSteps.push(flatStep);
+      if (!branches)
+        continue;
+      if (branches.body && step.type === "group") {
+        const body = branches.body;
+        groups.push({
+          group: flatStep,
+          bodyStepIds: body.steps.map((s) => s.id),
+          bodyConnections: body.connections
+        });
+        for (const c of body.connections)
+          flatConns.push(c);
+        walk(body.steps, step.id);
+      }
+      for (const branchKey of Object.keys(branches)) {
+        if (branchKey === "body" && step.type === "group")
+          continue;
+        const sub = branches[branchKey];
+        if (!sub)
+          continue;
+        for (const c of sub.connections)
+          flatConns.push(c);
+        walk(sub.steps, parentIdForSubflow);
+      }
+    }
+  };
+  walk(workflow.steps, undefined);
+  for (const g of groups) {
+    if (g.bodyStepIds.length === 0)
+      continue;
+    const bodyIdSet = new Set(g.bodyStepIds);
+    const inDeg = new Map;
+    const outDeg = new Map;
+    for (const id of g.bodyStepIds) {
+      inDeg.set(id, 0);
+      outDeg.set(id, 0);
+    }
+    for (const c of g.bodyConnections) {
+      if (bodyIdSet.has(c.sourceStepId)) {
+        outDeg.set(c.sourceStepId, (outDeg.get(c.sourceStepId) ?? 0) + 1);
+      }
+      if (bodyIdSet.has(c.targetStepId)) {
+        inDeg.set(c.targetStepId, (inDeg.get(c.targetStepId) ?? 0) + 1);
+      }
+    }
+    const roots = g.bodyStepIds.filter((id) => (inDeg.get(id) ?? 0) === 0);
+    const leaves = g.bodyStepIds.filter((id) => (outDeg.get(id) ?? 0) === 0);
+    for (const rootId of roots) {
+      flatConns.push({
+        id: `synth-inner-in-${g.group.id}-${rootId}`,
+        sourceStepId: g.group.id,
+        targetStepId: rootId,
+        sourcePort: "_inner_in"
+      });
+    }
+    for (const leafId of leaves) {
+      flatConns.push({
+        id: `synth-inner-out-${leafId}-${g.group.id}`,
+        sourceStepId: leafId,
+        targetStepId: g.group.id,
+        targetPort: "_inner_out"
+      });
+    }
+  }
+  return { ...workflow, steps: flatSteps, connections: flatConns };
+}
+
+// src/rules/flowShape.ts
+function transformStepToNode(step) {
+  const stepType = step.type;
+  const stepActionDefId = step.actionDefinitionId ?? "";
+  const nodeType = stepType === "trigger" ? "trigger" : stepType === "group" || stepActionDefId === "group" ? "group" : "action";
+  let nodeStatus = "idle" /* Idle */;
+  switch (step.status?.toLowerCase()) {
+    case "running":
+    case "executing":
+      nodeStatus = "running" /* Running */;
+      break;
+    case "completed":
+    case "success":
+      nodeStatus = "success" /* Success */;
+      break;
+    case "failed":
+    case "error":
+      nodeStatus = "error" /* Error */;
+      break;
+    case "pending":
+    case "waiting":
+      nodeStatus = "idle" /* Idle */;
+      break;
+    default:
+      nodeStatus = "idle" /* Idle */;
+  }
+  const position = step.position || { x: step.position_x || 0, y: step.position_y || 0 };
+  const posX = typeof position === "object" && position !== null && "x" in position ? position.x : step.position_x || 0;
+  const posY = typeof position === "object" && position !== null && "y" in position ? position.y : step.position_y || 0;
+  const config = step.config || {};
+  const configData = config.data || config || {};
+  const derivedFromName = step.name ? step.name.toLowerCase().replace(/\s+/g, "_") : undefined;
+  const resolvedActionDefinitionId = step.actionDefinitionId || config.connector_id || step.connector_id || derivedFromName || step.type;
+  const actionDef = getActionById(resolvedActionDefinitionId);
+  const node = {
+    id: step.id,
+    type: nodeType,
+    actionDefinitionId: resolvedActionDefinitionId,
+    actionDefinition: actionDef,
+    label: step.label || step.name,
+    description: step.description || config.description || actionDef?.description || "",
+    icon: actionDef?.icon ?? getIconForStepType(step.type),
+    position: {
+      x: posX,
+      y: posY
+    },
+    ...step.parentId ? { parentId: step.parentId } : {},
+    ...step.extent ? { extent: step.extent } : {},
+    ...step.disabled ? { disabled: true } : {},
+    ...step.dimensions && nodeType === "group" ? { dimensions: step.dimensions } : nodeType === "group" ? { dimensions: { width: 480, height: 240 } } : {},
+    config: {
+      ...configData,
+      timeout: step.timeout_seconds,
+      retryPolicy: step.retry_policy,
+      notes: step.notes,
+      tags: step.tags,
+      stepCount: step.step_count
+    },
+    ports: {
+      input: nodeType === "action" || nodeType === "group" ? [
+        {
+          id: `${step.id}-input`,
+          type: "input",
+          position: "top",
+          connected: false
+        }
+      ] : [],
+      output: (() => {
+        if (resolvedActionDefinitionId === "condition") {
+          return [
+            { id: `${step.id}_output_true`, type: "output", position: "bottom", label: "True", connected: false },
+            { id: `${step.id}_output_false`, type: "output", position: "bottom", label: "False", connected: false }
+          ];
+        }
+        if (resolvedActionDefinitionId === "for_each" || resolvedActionDefinitionId === "for-each") {
+          return [
+            { id: `${step.id}_output_each`, type: "output", position: "bottom", label: "Each", connected: false },
+            { id: `${step.id}_output_done`, type: "output", position: "bottom", label: "Done", connected: false }
+          ];
+        }
+        if (resolvedActionDefinitionId === "group") {
+          return [
+            { id: `${step.id}_output_0`, type: "output", position: "bottom", connected: false }
+          ];
+        }
+        return [
+          { id: `${step.id}-output`, type: "output", position: "bottom", connected: false }
+        ];
+      })()
+    },
+    configStatus: step.configStatus || undefined,
+    ...step.outputSchema ? { outputSchema: step.outputSchema } : {},
+    status: nodeStatus,
+    selected: false,
+    dragging: false,
+    isValid: step.configStatus ? step.configStatus === "valid" : true,
+    expanded: step.expanded,
+    minimized: false,
+    locked: false,
+    createdAt: step.created_at || new Date().toISOString(),
+    updatedAt: step.updated_at || new Date().toISOString()
+  };
+  return node;
+}
+function transformConnectionToEdge(connection) {
+  const sourceStepId = connection.sourceStepId || connection.source_step_id;
+  const targetStepId = connection.targetStepId || connection.target_step_id;
+  const sourcePort = connection.sourcePort || connection.source_port || `${sourceStepId}-output`;
+  const targetPort = connection.targetPort || connection.target_port || `${targetStepId}-input`;
+  let edgeType = "default" /* Default */;
+  if (connection.type === "success" || connection.type === "failure") {
+    edgeType = "conditional" /* Conditional */;
+  }
+  return {
+    id: connection.id,
+    source: sourceStepId,
+    target: targetStepId,
+    sourcePort,
+    targetPort,
+    type: edgeType,
+    label: connection.label,
+    selected: false,
+    animated: false,
+    createdAt: new Date().toISOString()
+  };
+}
+function generateConnectionsFromSteps(steps) {
+  const connections = [];
+  const sortedSteps = [...steps].sort((a, b) => a.step_count - b.step_count);
+  for (let i = 0;i < sortedSteps.length - 1; i++) {
+    const sourceStep = sortedSteps[i];
+    const targetStep = sortedSteps[i + 1];
+    connections.push({
+      id: `${sourceStep.id}-${targetStep.id}`,
+      source_step_id: sourceStep.id,
+      target_step_id: targetStep.id,
+      source_port: `${sourceStep.id}-output`,
+      target_port: `${targetStep.id}-input`,
+      type: "default"
+    });
+  }
+  return connections;
+}
+function getIconForStepType(type) {
+  const iconMap = {
+    trigger: "PlayOutline",
+    transform: "Transform",
+    action: "Application",
+    condition: "DecisionTree",
+    loop: "Repeat"
+  };
+  return iconMap[type] || "Application";
+}
+function transformFlowToWorkflow(flow) {
+  const flatWorkflow = flattenNestedWorkflow(flow.workflow);
+  const nodes = flatWorkflow.steps.map((step) => transformStepToNode(step));
+  let connections = flatWorkflow.connections;
+  if (connections === undefined || connections === null) {
+    connections = generateConnectionsFromSteps(flatWorkflow.steps);
+  } else {
+    connections = connections || [];
+  }
+  const edges = connections.map((conn, index) => {
+    if (!conn.id) {
+      conn.id = `edge-${conn.source_step_id}-${conn.target_step_id}-${index}`;
+    }
+    return transformConnectionToEdge(conn);
+  });
+  edges.forEach((edge) => {
+    const sourceNode = nodes.find((n) => n.id === edge.source);
+    const targetNode = nodes.find((n) => n.id === edge.target);
+    if (sourceNode) {
+      const port = sourceNode.ports.output.find((p) => p.id === edge.sourcePort);
+      if (port)
+        port.connected = true;
+    }
+    if (targetNode) {
+      const port = targetNode.ports.input.find((p) => p.id === edge.targetPort);
+      if (port)
+        port.connected = true;
+    }
+  });
+  return {
+    id: flow.workflow.id,
+    name: flow.workflow.name,
+    description: flow.workflow.description,
+    nodes,
+    edges,
+    workflowHistory: flow.workflowHistory || []
+  };
+}
+function validateFlowData(flow) {
+  if (!flow || typeof flow !== "object")
+    return false;
+  const f = flow;
+  return typeof f.id === "string" && typeof f.name === "string" && f.workflow !== undefined && typeof f.workflow === "object" && f.workflow !== null && Array.isArray(f.workflow.steps);
+}