@octaviaflow/flow-rules 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,28 +1,3010 @@
-/**
- * @octaviaflow/flow-rules
- *
- * One definition of what a flow action accepts, and one definition of what
- * makes a flow valid.
- *
- * Both lived in `octaviaflow-ui` and were therefore reachable only from a
- * browser. That was fine while the editor was the only thing building flows.
- * It stopped being fine when an AI agent became a second author (DEV-391): an
- * agent that cannot read an action's input schema guesses at the config, and
- * an agent that cannot run the rules cannot tell whether what it built works.
- *
- * Copying either into Backend would have produced two rule sets that agree on
- * the day they are written — the same failure mode as a duplicated permission
- * predicate, and the copy that drifts would be the one the agent trusts. So
- * they live here, and both the editor and the server import them.
- *
- * NO React, and no imports from either consumer. The config PANELS stay in
- * octaviaflow-ui; this package is the data and the rules they are built on.
- */
-// ── The catalog: what an action is, and what it accepts ────────────────────
-export * from "./catalog/types";
-export { actionsRegistry, getAllActions, getActionById, getActionsByCategory, } from "./catalog/index";
-// ── The rules: what makes a flow valid (Flow Doctor's verdict) ─────────────
-export { validateNode, validateEdge, validateWorkflow, getNodeValidationStatus, getEdgeValidationStatus, } from "./rules/workflowValidator";
-export { getNodeConfigStatus, } from "./rules/nodeConfigStatus";
-// ── Ids, so a caller building a flow makes ones the editor recognises ──────
-export { generateWorkflowId, generateStepId, generateEdgeId, generateUUIDv4, } from "./ids";
+// 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/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/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: {}
+  }
+};
+
+// 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 }
+];
+// 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;
+}
+export {
+  ActionCategory,
+  ActionStatus,
+  ActionType,
+  CONDITION_OPERATORS,
+  FieldType,
+  actionsRegistry,
+  buildPathOptions,
+  collectArrayPaths,
+  collectArrayPathsFromSample,
+  generateEdgeId,
+  generateStepId,
+  generateUUIDv4,
+  generateWorkflowId,
+  getActionById,
+  getActionsByCategory,
+  getAllActions,
+  getEdgeValidationStatus,
+  getNodeConfigStatus,
+  getNodeValidationStatus,
+  inferSchemaFromSample,
+  validateEdge,
+  validateNode,
+  validateWorkflow
+};