@tangle-network/agent-integrations 0.53.30 → 0.53.33

package/dist/{chunk-5LDZLVKP.js → chunk-R5GQB3SQ.js}

@@ -182,6 +182,12 @@ __export(adapters_exports, {
   copyAiConnector: () => copyAiConnector,
   couchbaseConnector: () => couchbaseConnector,
   createKafkaConnector: () => createKafkaConnector,
+  createMongoDbConnector: () => createMongoDbConnector,
+  createMySqlConnector: () => createMySqlConnector,
+  createPostgresConnector: () => createPostgresConnector,
+  createRabbitMqConnector: () => createRabbitMqConnector,
+  createRedisConnector: () => createRedisConnector,
+  createRedshiftConnector: () => createRedshiftConnector,
   createSftpConnector: () => createSftpConnector,
   createTangleIdentityClient: () => createTangleIdentityClient,
   crispConnector: () => crispConnector,
@@ -218,6 +224,7 @@ __export(adapters_exports, {
   dripConnector: () => dripConnector,
   dropboxConnector: () => dropboxConnector,
   dubConnector: () => dubConnector,
+  duckdbConnector: () => duckdbConnector,
   dumplingAiConnector: () => dumplingAiConnector,
   dustConnector: () => dustConnector,
   easyPeasyAiConnector: () => easyPeasyAiConnector,
@@ -438,9 +445,11 @@ __export(adapters_exports, {
   mondayConnector: () => mondayConnector,
   mongodbConnector: () => mongodbConnector,
   mycaseConnector: () => mycaseConnector,
+  mysqlConnector: () => mysqlConnector,
   n8nConnector: () => n8nConnector,
   netlifyConnector: () => netlifyConnector,
   netsuiteConnector: () => netsuiteConnector,
+  neverbounceConnector: () => neverbounceConnector,
   niftyConnector: () => niftyConnector,
   ninjapipeConnector: () => ninjapipeConnector,
   nocodbConnector: () => nocodbConnector,
@@ -508,6 +517,7 @@ __export(adapters_exports, {
   quadernoConnector: () => quadernoConnector,
   quickbooksConnector: () => quickbooksConnector,
   quickzuConnector: () => quickzuConnector,
+  rabbitMqConnector: () => rabbitMqConnector,
   raiaAiConnector: () => raiaAiConnector,
   rampConnector: () => rampConnector,
   rapidtextAiConnector: () => rapidtextAiConnector,
@@ -515,6 +525,8 @@ __export(adapters_exports, {
   recallAiConnector: () => recallAiConnector,
   recurlyConnector: () => recurlyConnector,
   redditConnector: () => redditConnector,
+  redisConnector: () => redisConnector,
+  redshiftConnector: () => redshiftConnector,
   reoonVerifierConnector: () => reoonVerifierConnector,
   replyIoConnector: () => replyIoConnector,
   resolveConnectorAdapterFactoryOptions: () => resolveConnectorAdapterFactoryOptions,
@@ -1123,6 +1135,10 @@ function sameUrl(left, right) {
 function applyCredentials(headers, url, placement, credentials) {
   const token = credentialToken(credentials);
   if (placement.kind === "bearer") headers.authorization = `Bearer ${token}`;
+  if (placement.kind === "authorization-by-auth") {
+    const prefix = credentials.kind === "oauth2" ? placement.oauth2Prefix ?? "Bearer " : placement.apiKeyPrefix ?? "";
+    headers.authorization = `${prefix}${token}`;
+  }
   if (placement.kind === "basic-api-key") {
     headers.authorization = `Basic ${Buffer.from(`${token}:`).toString("base64")}`;
   }
@@ -6500,6 +6516,294 @@ var digitalPilotConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/duckdb.ts
+import {
+  DuckDBInstance
+} from "@duckdb/node-api";
+var MAX_ARGUMENTS = 100;
+var MAX_COLUMNS2 = 256;
+var MAX_EXECUTION_MS = 5e3;
+var MAX_INPUT_BYTES = 10 * 1024 * 1024;
+var MAX_QUERY_BYTES = 2e4;
+var MAX_RESULT_BYTES = 10 * 1024 * 1024;
+var MAX_ROWS = 1e4;
+var MAX_SCHEMA_DEPTH = 16;
+var MAX_TABLES = 16;
+var TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+var duckdbConnector = {
+  manifest: {
+    kind: "duckdb",
+    displayName: "DuckDB",
+    description: "Load bounded JSON tables into a throwaway in-memory DuckDB database and run a parameterized query.",
+    auth: { kind: "none" },
+    defaultConsistencyModel: "advisory",
+    category: "database",
+    capabilities: [
+      {
+        name: "create.and.query.db",
+        class: "read",
+        description: "Create in-memory tables from JSON arrays and return a bounded parameterized SQL query result.",
+        parameters: {
+          type: "object",
+          properties: {
+            tables: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_TABLES,
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string", pattern: TABLE_NAME.source, maxLength: 63 },
+                  data: { type: "array", maxItems: MAX_ROWS, items: { type: "object" } },
+                  schema: { type: "object", maxProperties: MAX_COLUMNS2 }
+                },
+                required: ["name", "data"],
+                additionalProperties: false
+              }
+            },
+            query: {
+              type: "string",
+              minLength: 1,
+              maxLength: MAX_QUERY_BYTES,
+              description: "A single relation-returning SQL query. Use $1, $2, and args for dynamic values."
+            },
+            args: {
+              type: "array",
+              maxItems: MAX_ARGUMENTS,
+              items: { type: ["string", "number", "boolean", "null"] }
+            },
+            maxRows: { type: "integer", minimum: 1, maximum: MAX_ROWS, default: 1e3 }
+          },
+          required: ["tables", "query"],
+          additionalProperties: false
+        }
+      }
+    ]
+  },
+  async executeRead({ capabilityName, args }) {
+    if (capabilityName !== "create.and.query.db") {
+      throw new Error(`Unknown DuckDB capability: ${capabilityName}`);
+    }
+    const tables = readTables(args.tables);
+    const query2 = readQuery(args.query);
+    const queryArgs = readArguments(args.args);
+    const maxRows = readBoundedInteger(args.maxRows, 1e3, 1, MAX_ROWS, "maxRows");
+    const instance = await DuckDBInstance.create(":memory:");
+    let connection;
+    let timedOut = false;
+    let timeout;
+    try {
+      const activeConnection = await instance.connect();
+      connection = activeConnection;
+      timeout = setTimeout(() => {
+        timedOut = true;
+        activeConnection.interrupt();
+      }, MAX_EXECUTION_MS);
+      await configureConnection(activeConnection);
+      throwIfTimedOut(timedOut);
+      for (const table of tables) {
+        await loadTable(activeConnection, table);
+        throwIfTimedOut(timedOut);
+      }
+      const reader = await activeConnection.runAndReadAll(
+        `SELECT * FROM (${query2}) AS "_tangle_result" LIMIT ${maxRows + 1}`,
+        queryArgs
+      );
+      throwIfTimedOut(timedOut);
+      const allRows = reader.getRowObjectsJson();
+      const truncated = allRows.length > maxRows;
+      const rows = truncated ? allRows.slice(0, maxRows) : allRows;
+      assertResultSize(rows);
+      return {
+        data: {
+          rows,
+          rowCount: rows.length,
+          truncated,
+          columns: reader.columnNameAndTypeObjectsJson()
+        },
+        fetchedAt: Date.now()
+      };
+    } catch (error) {
+      if (timedOut) throw new Error(`DuckDB execution exceeded ${MAX_EXECUTION_MS}ms`);
+      throw error;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      try {
+        connection?.closeSync();
+      } finally {
+        instance.closeSync();
+      }
+    }
+  },
+  async test() {
+    const instance = await DuckDBInstance.create(":memory:");
+    let connection;
+    try {
+      const activeConnection = await instance.connect();
+      connection = activeConnection;
+      await configureConnection(activeConnection);
+      const reader = await activeConnection.runAndReadAll("SELECT 1 AS ok");
+      if (reader.getRowObjectsJson()[0]?.ok !== 1) return { ok: false, reason: "DuckDB SELECT 1 returned an unexpected result" };
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    } finally {
+      try {
+        connection?.closeSync();
+      } finally {
+        instance.closeSync();
+      }
+    }
+  }
+};
+async function configureConnection(connection) {
+  await connection.run(`
+    SET memory_limit = '256MB';
+    SET max_temp_directory_size = '0B';
+    SET threads = 2;
+    SET enable_logging = false;
+    SET enable_external_access = false;
+    SET lock_configuration = true;
+  `);
+}
+async function loadTable(connection, table) {
+  const sourceData = stringifyJson(table.data, `${table.name}.data`);
+  let sourceSchema;
+  if (table.schema) {
+    assertDuckDbSchema(table.schema, `${table.name}.schema`);
+    sourceSchema = stringifyJson([table.schema], `${table.name}.schema`);
+  } else {
+    if (table.data.length === 0) {
+      throw new Error(`${table.name}.schema is required when data is empty`);
+    }
+    const detected = await connection.runAndReadAll(
+      "SELECT json_structure($sourceData) AS schema",
+      { sourceData }
+    );
+    const value = detected.getRowsJson()[0]?.[0];
+    if (typeof value !== "string") throw new Error(`Could not infer a schema for ${table.name}`);
+    let detectedSchema;
+    try {
+      detectedSchema = JSON.parse(value);
+    } catch {
+      throw new Error(`Could not parse the inferred schema for ${table.name}`);
+    }
+    assertDuckDbSchema(detectedSchema, `${table.name}.inferredSchema`);
+    sourceSchema = value;
+  }
+  await connection.run(
+    `CREATE TABLE ${quoteIdentifier(table.name)} AS
+       SELECT UNNEST(JSON_TRANSFORM($sourceData, $sourceSchema), recursive := true)`,
+    { sourceData, sourceSchema }
+  );
+}
+function readTables(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_TABLES) {
+    throw new Error(`tables must contain 1 through ${MAX_TABLES} entries`);
+  }
+  assertInputSize(value);
+  let totalRows = 0;
+  const tables = value.map((entry, tableIndex) => {
+    if (!isPlainRecord(entry)) throw new Error(`tables[${tableIndex}] must be an object`);
+    const { name, data: data4, schema } = entry;
+    if (typeof name !== "string" || !TABLE_NAME.test(name)) {
+      throw new Error(`tables[${tableIndex}].name must be a safe SQL identifier`);
+    }
+    if (!Array.isArray(data4) || data4.length > MAX_ROWS) {
+      throw new Error(`tables[${tableIndex}].data must contain at most ${MAX_ROWS} rows`);
+    }
+    const records = data4.map((record, rowIndex) => {
+      if (!isPlainRecord(record)) throw new Error(`tables[${tableIndex}].data[${rowIndex}] must be an object`);
+      if (Object.keys(record).length > MAX_COLUMNS2) {
+        throw new Error(`tables[${tableIndex}].data[${rowIndex}] exceeds ${MAX_COLUMNS2} columns`);
+      }
+      return record;
+    });
+    const columns = new Set(records.flatMap((record) => Object.keys(record)));
+    if (columns.size > MAX_COLUMNS2) {
+      throw new Error(`tables[${tableIndex}].data exceeds ${MAX_COLUMNS2} distinct columns`);
+    }
+    totalRows += records.length;
+    if (totalRows > MAX_ROWS) throw new Error(`tables exceed the ${MAX_ROWS}-row total limit`);
+    if (schema !== void 0 && (!isPlainRecord(schema) || Object.keys(schema).length > MAX_COLUMNS2)) {
+      throw new Error(`tables[${tableIndex}].schema must contain at most ${MAX_COLUMNS2} fields`);
+    }
+    return { name, data: records, schema };
+  });
+  if (new Set(tables.map((table) => table.name.toLowerCase())).size !== tables.length) {
+    throw new Error("table names must be unique ignoring case");
+  }
+  return tables;
+}
+function readQuery(value) {
+  if (typeof value !== "string" || value.trim().length === 0) throw new Error("query is required");
+  if (Buffer.byteLength(value, "utf8") > MAX_QUERY_BYTES) {
+    throw new Error(`query exceeds the ${MAX_QUERY_BYTES}-byte limit`);
+  }
+  return value.trim().replace(/;\s*$/, "");
+}
+function readArguments(value) {
+  if (value === void 0 || value === null) return {};
+  if (!Array.isArray(value) || value.length > MAX_ARGUMENTS) {
+    throw new Error(`args must contain at most ${MAX_ARGUMENTS} scalar values`);
+  }
+  return Object.fromEntries(value.map((entry, index) => {
+    if (entry !== null && typeof entry !== "string" && typeof entry !== "number" && typeof entry !== "boolean") {
+      throw new Error(`args[${index}] must be a string, number, boolean, or null`);
+    }
+    if (typeof entry === "number" && !Number.isFinite(entry)) throw new Error(`args[${index}] must be finite`);
+    return [String(index + 1), entry];
+  }));
+}
+function assertInputSize(value) {
+  const serialized = stringifyJson(value, "tables");
+  if (Buffer.byteLength(serialized, "utf8") > MAX_INPUT_BYTES) {
+    throw new Error(`tables exceed the ${MAX_INPUT_BYTES}-byte input limit`);
+  }
+}
+function assertResultSize(rows) {
+  const serialized = stringifyJson(rows, "DuckDB result");
+  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES) {
+    throw new Error(`DuckDB result exceeds the ${MAX_RESULT_BYTES}-byte output limit`);
+  }
+}
+function assertDuckDbSchema(value, label) {
+  let leaves = 0;
+  const visit = (entry, depth) => {
+    if (depth > MAX_SCHEMA_DEPTH) throw new Error(`${label} exceeds ${MAX_SCHEMA_DEPTH} nested levels`);
+    if (typeof entry === "string") {
+      leaves += 1;
+      if (leaves > MAX_COLUMNS2) throw new Error(`${label} exceeds ${MAX_COLUMNS2} leaf columns`);
+      return;
+    }
+    if (Array.isArray(entry)) {
+      if (entry.length !== 1) throw new Error(`${label} array schemas must contain exactly one element type`);
+      visit(entry[0], depth + 1);
+      return;
+    }
+    if (!isPlainRecord(entry) || Object.keys(entry).length === 0) {
+      throw new Error(`${label} must describe at least one DuckDB column type`);
+    }
+    for (const child of Object.values(entry)) visit(child, depth + 1);
+  };
+  visit(value, 0);
+}
+function stringifyJson(value, label) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) throw new Error("undefined");
+    return serialized;
+  } catch {
+    throw new Error(`${label} must be JSON-serializable`);
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function throwIfTimedOut(timedOut) {
+  if (timedOut) throw new Error(`DuckDB execution exceeded ${MAX_EXECUTION_MS}ms`);
+}
+
 // src/connectors/adapters/docsbot.ts
 var docsbotConnector = declarativeRestConnector({
   kind: "docsbot",
@@ -6917,7 +7221,7 @@ var elevenlabsConnector = declarativeRestConnector({
 // src/connectors/adapters/excel-files.ts
 import readXlsxFile from "read-excel-file/node";
 import writeXlsxFile from "write-excel-file/node";
-var MAX_COLUMNS2 = 256;
+var MAX_COLUMNS3 = 256;
 var MAX_SHEETS = 50;
 var MAX_UNCOMPRESSED_WORKBOOK_BYTES = 50 * 1024 * 1024;
 var MAX_ZIP_ENTRIES = 1e3;
@@ -6958,7 +7262,7 @@ var excelFilesConnector = {
               type: "array",
               minItems: 1,
               maxItems: MAX_RECORDS,
-              items: { type: "array", maxItems: MAX_COLUMNS2 }
+              items: { type: "array", maxItems: MAX_COLUMNS3 }
             },
             sheetName: { type: "string", minLength: 1, maxLength: 31, default: "Sheet1" }
           },
@@ -6988,8 +7292,8 @@ var excelFilesConnector = {
       totalRows += sheet.data.length;
       if (totalRows > MAX_RECORDS) throw new Error(`workbook exceeds the ${MAX_RECORDS}-row limit`);
       for (const [rowIndex, row] of sheet.data.entries()) {
-        if (row.length > MAX_COLUMNS2) {
-          throw new Error(`sheet ${sheet.sheet} row ${rowIndex + 1} exceeds the ${MAX_COLUMNS2}-column limit`);
+        if (row.length > MAX_COLUMNS3) {
+          throw new Error(`sheet ${sheet.sheet} row ${rowIndex + 1} exceeds the ${MAX_COLUMNS3}-column limit`);
         }
       }
       return { name: sheet.sheet, rows: jsonSafe(sheet.data) };
@@ -7003,7 +7307,7 @@ var excelFilesConnector = {
     if (capabilityName !== "excel.create") throw new Error(`Unknown Excel capability: ${capabilityName}`);
     const rows = readRows(args.rows);
     for (const [index, row] of rows.entries()) {
-      if (row.length > MAX_COLUMNS2) throw new Error(`rows[${index}] exceeds the ${MAX_COLUMNS2}-column limit`);
+      if (row.length > MAX_COLUMNS3) throw new Error(`rows[${index}] exceeds the ${MAX_COLUMNS3}-column limit`);
     }
     const sheetName = readOptionalString(args.sheetName, "sheetName") ?? "Sheet1";
     validateSheetName(sheetName);
@@ -16301,16 +16605,27 @@ var clickupConnector = declarativeRestConnector({
   displayName: "ClickUp",
   description: "Read and mutate ClickUp workspaces, spaces, folders, lists, tasks, comments, and time entries via the ClickUp REST v2 API.",
   auth: {
-    kind: "oauth2",
-    authorizationUrl: "https://app.clickup.com/api",
-    tokenUrl: "https://api.clickup.com/api/v2/oauth/token",
-    scopes: [],
-    clientIdEnv: "CLICKUP_OAUTH_CLIENT_ID",
-    clientSecretEnv: "CLICKUP_OAUTH_CLIENT_SECRET"
+    kind: "one_of",
+    preferred: "api-key",
+    options: [
+      {
+        kind: "api-key",
+        hint: "ClickUp personal API token (starts with pk_)."
+      },
+      {
+        kind: "oauth2",
+        authorizationUrl: "https://app.clickup.com/api",
+        tokenUrl: "https://api.clickup.com/api/v2/oauth/token",
+        scopes: [],
+        clientIdEnv: "CLICKUP_OAUTH_CLIENT_ID",
+        clientSecretEnv: "CLICKUP_OAUTH_CLIENT_SECRET"
+      }
+    ]
   },
   category: "other",
   defaultConsistencyModel: "authoritative",
   baseUrl: "https://api.clickup.com/api/v2",
+  credentialPlacement: { kind: "authorization-by-auth" },
   // GET /user — returns the authorized user; used as a cheap liveness probe.
   test: { method: "GET", path: "/user" },
   capabilities: [
@@ -38895,6 +39210,628 @@ var mollieConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/miro.ts
+var miroConnector = declarativeRestConnector({
+  kind: "miro",
+  displayName: "Miro",
+  description: "Read and edit Miro boards: list and search boards, read board items (sticky notes, shapes, text, cards, images, frames, connectors), create and update items, and post board content back into the source of truth.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://miro.com/oauth/authorize",
+    tokenUrl: "https://api.miro.com/v1/oauth/token",
+    scopes: [
+      "boards:read",
+      "boards:write",
+      "identity:read"
+    ],
+    clientIdEnv: "MIRO_OAUTH_CLIENT_ID",
+    clientSecretEnv: "MIRO_OAUTH_CLIENT_SECRET"
+  },
+  category: "doc",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.miro.com",
+  defaultHeaders: { accept: "application/json" },
+  // GET /v2/me returns the authenticated user — Miro's documented health probe.
+  test: { method: "GET", path: "/v2/me" },
+  capabilities: [
+    {
+      name: "me.get",
+      class: "read",
+      description: "Return the authenticated Miro user.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/v2/me" },
+      requiredScopes: ["identity:read"]
+    },
+    {
+      name: "boards.list",
+      class: "read",
+      description: "List boards accessible to the authenticated user. Supports cursor pagination via `cursor` and team / sort filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          team_id: { type: "string", description: "Filter to a single team id." },
+          query: { type: "string", description: "Free-text board name filter." },
+          owner: { type: "string", description: "Filter by owner user id." },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 },
+          sort: {
+            type: "string",
+            enum: ["default", "last_modified", "last_opened", "last_created", "alphabetically"]
+          }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards",
+        query: {
+          team_id: "{team_id}",
+          query: "{query}",
+          owner: "{owner}",
+          limit: "{limit}",
+          offset: "{offset}",
+          sort: "{sort}"
+        }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.get",
+      class: "read",
+      description: "Fetch a single Miro board by id.",
+      parameters: {
+        type: "object",
+        properties: { board_id: { type: "string" } },
+        required: ["board_id"]
+      },
+      request: { method: "GET", path: "/v2/boards/{board_id}" },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.members.list",
+      class: "read",
+      description: "List members (collaborators) of a Miro board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/members",
+        query: { limit: "{limit}", offset: "{offset}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "items.list",
+      class: "read",
+      description: "List all items on a board, optionally filtered by item type (sticky_note, text, shape, card, image, frame, connector, embed, app_card, document).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          type: {
+            type: "string",
+            enum: [
+              "sticky_note",
+              "text",
+              "shape",
+              "card",
+              "image",
+              "frame",
+              "connector",
+              "embed",
+              "app_card",
+              "document",
+              "preview"
+            ]
+          },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          cursor: { type: "string" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/items",
+        query: { type: "{type}", limit: "{limit}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "items.get",
+      class: "read",
+      description: "Fetch a single board item by id.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: { method: "GET", path: "/v2/boards/{board_id}/items/{item_id}" },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "connectors.list",
+      class: "read",
+      description: "List connector lines on a board (arrows / lines between items).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          cursor: { type: "string" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/connectors",
+        query: { limit: "{limit}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "tags.list",
+      class: "read",
+      description: "List tags defined on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/tags",
+        query: { limit: "{limit}", offset: "{offset}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.create",
+      class: "mutation",
+      description: "Create a new Miro board. Accepts an optional name, description, team_id, and sharing policy. Returns the new board id used by every items.* endpoint.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", maxLength: 60 },
+          description: { type: "string", maxLength: 300 },
+          team_id: { type: "string" },
+          policy: {
+            type: "object",
+            description: "Permissions + sharing policy. See https://developers.miro.com/reference/create-board for the full PolicyChange shape."
+          }
+        },
+        required: ["name"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards",
+        body: {
+          name: "{name}",
+          description: "{description}",
+          teamId: "{team_id}",
+          policy: "{policy}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.update",
+      class: "mutation",
+      description: "Update a Miro board (name, description, team, or sharing policy).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          name: { type: "string", maxLength: 60 },
+          description: { type: "string", maxLength: 300 },
+          team_id: { type: "string" },
+          policy: { type: "object" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/v2/boards/{board_id}",
+        body: {
+          name: "{name}",
+          description: "{description}",
+          teamId: "{team_id}",
+          policy: "{policy}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.delete",
+      class: "mutation",
+      description: "Delete a Miro board (irreversible).",
+      parameters: {
+        type: "object",
+        properties: { board_id: { type: "string" } },
+        required: ["board_id"]
+      },
+      request: { method: "DELETE", path: "/v2/boards/{board_id}" },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "sticky_notes.create",
+      class: "mutation",
+      description: "Create a sticky note on a board. `data.content` accepts plain text; `style.fillColor` is a Miro sticky-note color keyword (e.g. yellow, light_yellow, pink).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              content: { type: "string" },
+              shape: { type: "string", enum: ["square", "rectangle"] }
+            },
+            required: ["content"]
+          },
+          style: {
+            type: "object",
+            properties: {
+              fillColor: { type: "string" },
+              textAlign: { type: "string", enum: ["left", "center", "right"] },
+              textAlignVertical: { type: "string", enum: ["top", "middle", "bottom"] }
+            }
+          },
+          position: {
+            type: "object",
+            properties: {
+              x: { type: "number" },
+              y: { type: "number" },
+              origin: { type: "string", enum: ["center"] }
+            }
+          },
+          geometry: {
+            type: "object",
+            properties: {
+              width: { type: "number" },
+              height: { type: "number" }
+            }
+          },
+          parent: {
+            type: "object",
+            description: "Attach the sticky note to a frame: { id: <frame_item_id> }.",
+            properties: { id: { type: "string" } }
+          }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/sticky_notes",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "sticky_notes.update",
+      class: "mutation",
+      description: "Update a sticky note (content, style, position, geometry, or parent frame).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" },
+          data: { type: "object" },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/v2/boards/{board_id}/sticky_notes/{item_id}",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "text.create",
+      class: "mutation",
+      description: "Create a text item on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: { content: { type: "string" } },
+            required: ["content"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/texts",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "shapes.create",
+      class: "mutation",
+      description: "Create a shape item on a board. `data.shape` selects the geometric primitive (rectangle, round_rectangle, circle, triangle, rhombus, etc.).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              shape: {
+                type: "string",
+                description: "Miro shape kind; full enum at https://developers.miro.com/reference/create-shape-item."
+              },
+              content: { type: "string" }
+            },
+            required: ["shape"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/shapes",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "cards.create",
+      class: "mutation",
+      description: "Create a card item (title + description + assignee + due-date) on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              dueDate: { type: "string", format: "date-time" },
+              assigneeId: { type: "string" }
+            },
+            required: ["title"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/cards",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "frames.create",
+      class: "mutation",
+      description: "Create a frame on a board. Frames group items; child items can be attached via `parent.id` on item creation.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              format: { type: "string", enum: ["custom"] },
+              type: { type: "string", enum: ["freeform"] }
+            }
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/frames",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "images.create.by_url",
+      class: "mutation",
+      description: "Create an image item from a public URL (Miro fetches the image server-side).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              url: { type: "string", format: "uri" },
+              title: { type: "string" }
+            },
+            required: ["url"]
+          },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/images",
+        body: {
+          data: "{data}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "connectors.create",
+      class: "mutation",
+      description: "Create a connector line between two items on the board. `startItem.id` and `endItem.id` reference existing item ids.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          startItem: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+          },
+          endItem: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+          },
+          captions: {
+            type: "array",
+            items: { type: "object", properties: { content: { type: "string" } } }
+          },
+          style: { type: "object" },
+          shape: { type: "string", enum: ["straight", "elbowed", "curved"] }
+        },
+        required: ["board_id", "startItem", "endItem"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/connectors",
+        body: {
+          startItem: "{startItem}",
+          endItem: "{endItem}",
+          captions: "{captions}",
+          style: "{style}",
+          shape: "{shape}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "items.delete",
+      class: "mutation",
+      description: "Delete an item from a board (works across all item types).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: { method: "DELETE", path: "/v2/boards/{board_id}/items/{item_id}" },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.share",
+      class: "mutation",
+      description: "Invite users to a Miro board by email. Roles: viewer, commenter, editor, coowner.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          emails: { type: "array", items: { type: "string", format: "email" } },
+          role: {
+            type: "string",
+            enum: ["viewer", "commenter", "editor", "coowner"]
+          },
+          message: { type: "string" }
+        },
+        required: ["board_id", "emails", "role"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/members",
+        body: {
+          emails: "{emails}",
+          role: "{role}",
+          message: "{message}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    }
+  ]
+});
+
 // src/connectors/adapters/monday.ts
 var BOARD_FRAGMENT = `
   id
@@ -39019,7 +39956,7 @@ var mondayConnector = declarativeRestConnector({
   auth: {
     kind: "oauth2",
     authorizationUrl: "https://auth.monday.com/oauth2/authorize",
-    tokenUrl: "https://auth.monday.com/oauth2/token",
+    tokenUrl: "https://auth.monday.com/oauth_ms/oauth/token",
     scopes: [
       "me:read",
       "boards:read",
@@ -39409,6 +40346,475 @@ var mondayConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/mongodb.ts
+import { isIP as isIP3 } from "net";
+import { createSecureContext } from "tls";
+import {
+  BSON,
+  MongoClient
+} from "mongodb";
+var MAX_NAME_BYTES = 120;
+var MAX_FIELD_BYTES = 256;
+var MAX_FILTERS = 20;
+var MAX_PROJECTION_FIELDS = 64;
+var MAX_SORT_FIELDS = 8;
+var MAX_COLLECTIONS = 1e3;
+var MAX_INDEXES = 200;
+var MAX_DOCUMENTS = 1e3;
+var MAX_RESULT_BYTES2 = 10 * 1024 * 1024;
+var MAX_FILTER_BYTES = 1024 * 1024;
+var MAX_SCALAR_STRING_BYTES = 64 * 1024;
+var MAX_TLS_CA_BYTES = 256 * 1024;
+function createMongoDbConnector(options = {}) {
+  const createClient = options.createClient ?? defaultCreateClient;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "mongodb",
+      displayName: "MongoDB",
+      description: "Inspect MongoDB collections and indexes and run bounded structured document reads over a verified TLS connection.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with a public MongoDB host, database, user, password, optional port/auth source, and optional TLS CA. Verified TLS is mandatory."
+      },
+      category: "database",
+      defaultConsistencyModel: "authoritative",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability6("mongodb.collections.list", "List collections visible in the configured database.", {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }),
+        readCapability6("mongodb.collections.describe", "Read options and metadata for one collection.", collectionSchema()),
+        readCapability6("mongodb.indexes.list", "List bounded index metadata for one collection.", collectionSchema()),
+        readCapability6("mongodb.documents.find", "Read bounded documents using fixed scalar predicates, projection, and sort fields.", {
+          type: "object",
+          properties: {
+            collection: nameParameter("Collection name."),
+            filters: filterArraySchema(),
+            fields: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_PROJECTION_FIELDS,
+              uniqueItems: true,
+              items: fieldParameter()
+            },
+            includeId: { type: "boolean", default: true },
+            sort: {
+              type: "array",
+              maxItems: MAX_SORT_FIELDS,
+              items: {
+                type: "object",
+                properties: {
+                  field: fieldParameter(),
+                  direction: { type: "string", enum: ["asc", "desc"], default: "asc" }
+                },
+                required: ["field"],
+                additionalProperties: false
+              }
+            },
+            limit: { type: "integer", minimum: 1, maximum: MAX_DOCUMENTS, default: 100 },
+            skip: { type: "integer", minimum: 0, maximum: 1e6, default: 0 }
+          },
+          required: ["collection"],
+          additionalProperties: false
+        }),
+        readCapability6("mongodb.documents.count", "Count documents matching fixed scalar predicates within a bounded server execution time.", {
+          type: "object",
+          properties: {
+            collection: nameParameter("Collection name."),
+            filters: filterArraySchema()
+          },
+          required: ["collection"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async test(source) {
+      try {
+        await withClient(source, createClient, resolveHost, async (client, credentials) => {
+          const response = await client.db(credentials.database).command(
+            { ping: 1 },
+            { maxTimeMS: credentials.commandTimeoutMs }
+          );
+          if (response.ok !== 1) throw new Error("MongoDB ping returned an unexpected response");
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage(error, credentialSecrets(source)) };
+      }
+    },
+    async executeRead(invocation) {
+      const request4 = prepareRead(invocation);
+      const data4 = await withClient(invocation.source, createClient, resolveHost, async (client, credentials) => {
+        return executeRead(request4, client.db(credentials.database), credentials.commandTimeoutMs);
+      });
+      return { data: data4, fetchedAt: Date.now() };
+    }
+  };
+}
+var mongodbConnector = createMongoDbConnector();
+function defaultCreateClient(uri, options) {
+  return new MongoClient(uri, options);
+}
+async function withClient(source, createClient, resolveHost, run) {
+  const credentials = readCredentials2(source);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error("MongoDB host did not resolve");
+  const uriHost = isIP3(credentials.host) === 6 ? `[${credentials.host}]` : credentials.host;
+  const client = createClient(`mongodb://${uriHost}:${credentials.port}/`, {
+    appName: "tangle-integration-hub",
+    auth: { username: credentials.user, password: credentials.password },
+    authSource: credentials.authSource,
+    connectTimeoutMS: credentials.connectTimeoutMs,
+    directConnection: true,
+    lookup: pinnedLookup(addresses[0]),
+    maxIdleTimeMS: 5e3,
+    maxPoolSize: 1,
+    minPoolSize: 0,
+    rejectUnauthorized: true,
+    retryReads: true,
+    retryWrites: false,
+    serverSelectionTimeoutMS: credentials.connectTimeoutMs,
+    servername: isIP3(credentials.host) === 0 ? credentials.host : void 0,
+    secureContext: createSecureContext({ ca: credentials.tlsCa, minVersion: "TLSv1.2" }),
+    socketTimeoutMS: credentials.commandTimeoutMs,
+    tls: true
+  });
+  try {
+    await client.connect();
+    return await run(client, credentials);
+  } catch (error) {
+    throw new Error(safeErrorMessage(error, credentials.secrets));
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+async function executeRead(request4, database, commandTimeoutMs) {
+  if (request4.kind === "collections.list") {
+    const collections = await readCursor(
+      database.listCollections({}, { nameOnly: true, maxTimeMS: commandTimeoutMs }),
+      MAX_COLLECTIONS,
+      "MongoDB collection list"
+    );
+    return boundedResult({ collections }, "MongoDB collection list");
+  }
+  if (request4.kind === "collections.describe") {
+    const matches = await readCursor(
+      database.listCollections({ name: request4.collection }, { nameOnly: false, maxTimeMS: commandTimeoutMs }),
+      1,
+      "MongoDB collection description"
+    );
+    return boundedResult({ collection: matches[0] ?? null }, "MongoDB collection description");
+  }
+  if (request4.kind === "indexes.list") {
+    const indexes = await readCursor(
+      database.collection(request4.collection).listIndexes({ maxTimeMS: commandTimeoutMs }),
+      MAX_INDEXES,
+      "MongoDB index list"
+    );
+    return boundedResult({ collection: request4.collection, indexes }, "MongoDB index list");
+  }
+  if (request4.kind === "documents.find") {
+    const cursor = database.collection(request4.collection).find(request4.filter, {
+      ...request4.projection ? { projection: request4.projection } : {},
+      maxTimeMS: commandTimeoutMs
+    });
+    if (Object.keys(request4.sort).length > 0) cursor.sort(request4.sort);
+    cursor.skip(request4.skip).limit(request4.limit);
+    const documents = await readCursor(cursor, request4.limit, "MongoDB document result");
+    return boundedResult({ collection: request4.collection, documents }, "MongoDB document result");
+  }
+  if (request4.kind === "documents.count") {
+    const count = await database.collection(request4.collection).countDocuments(request4.filter, { maxTimeMS: commandTimeoutMs });
+    if (!Number.isSafeInteger(count) || count < 0) throw new Error("MongoDB returned a malformed document count");
+    return { collection: request4.collection, count };
+  }
+}
+function prepareRead(invocation) {
+  if (invocation.capabilityName === "mongodb.collections.list") return { kind: "collections.list" };
+  if (invocation.capabilityName === "mongodb.collections.describe") {
+    return { kind: "collections.describe", collection: readCollectionName(invocation.args.collection) };
+  }
+  if (invocation.capabilityName === "mongodb.indexes.list") {
+    return { kind: "indexes.list", collection: readCollectionName(invocation.args.collection) };
+  }
+  if (invocation.capabilityName === "mongodb.documents.find") {
+    return {
+      kind: "documents.find",
+      collection: readCollectionName(invocation.args.collection),
+      filter: readFilters(invocation.args.filters),
+      projection: readProjection(invocation.args.fields, invocation.args.includeId),
+      sort: readSort(invocation.args.sort),
+      limit: readBoundedInteger(invocation.args.limit, 100, 1, MAX_DOCUMENTS, "limit"),
+      skip: readBoundedInteger(invocation.args.skip, 0, 0, 1e6, "skip")
+    };
+  }
+  if (invocation.capabilityName === "mongodb.documents.count") {
+    return {
+      kind: "documents.count",
+      collection: readCollectionName(invocation.args.collection),
+      filter: readFilters(invocation.args.filters)
+    };
+  }
+  throw new Error(`Unknown MongoDB read capability: ${invocation.capabilityName}`);
+}
+async function readCursor(cursor, maximum, label) {
+  const entries = [];
+  let serializedBytes = 2;
+  try {
+    while (entries.length < maximum) {
+      const entry = await cursor.next();
+      if (entry === null) return entries;
+      serializedBytes += Buffer.byteLength(
+        JSON.stringify(BSON.EJSON.serialize(entry, { relaxed: true })),
+        "utf8"
+      ) + 1;
+      if (serializedBytes > MAX_RESULT_BYTES2) {
+        throw new Error(`${label} exceeds the ${MAX_RESULT_BYTES2}-byte limit`);
+      }
+      entries.push(entry);
+    }
+    if (await cursor.next() !== null) throw new Error(`${label} exceeds ${maximum} entries`);
+    return entries;
+  } finally {
+    await cursor.close().catch(() => void 0);
+  }
+}
+function readCredentials2(source) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error("MongoDB credential must be valid JSON");
+    }
+  } else {
+    throw new Error("MongoDB requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("MongoDB credential must be a JSON object");
+  const host = readHost(raw.host);
+  const database = readDatabaseName(raw.database, "database");
+  const user = readCredentialString(raw.user ?? raw.username, "user", 128);
+  const password = readCredentialString(raw.password, "password", 4096);
+  const authSource = raw.authSource === void 0 ? "admin" : readDatabaseName(raw.authSource, "authSource");
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES) {
+    throw new Error(`MongoDB tlsCa exceeds the ${MAX_TLS_CA_BYTES}-byte limit`);
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, 27017, 1, 65535, "port"),
+    database,
+    user,
+    password,
+    authSource,
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    commandTimeoutMs: readBoundedInteger(raw.commandTimeoutMs, 3e4, 1e3, 6e4, "commandTimeoutMs"),
+    secrets: [password]
+  };
+}
+function readFilters(value) {
+  if (value === void 0 || value === null) return {};
+  if (!Array.isArray(value) || value.length > MAX_FILTERS) {
+    throw new Error(`filters must contain at most ${MAX_FILTERS} entries`);
+  }
+  const predicates = value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`filters[${index}] must be an object`);
+    const field = readField(entry.field, `filters[${index}].field`);
+    const operator = entry.operator;
+    if (!["eq", "ne", "lt", "lte", "gt", "gte"].includes(String(operator))) {
+      throw new Error(`filters[${index}].operator is unsupported`);
+    }
+    const scalar = readScalar(entry.value, `filters[${index}].value`);
+    return { [field]: { [mongoOperator(String(operator))]: scalar } };
+  });
+  const filter = predicates.length === 0 ? {} : { $and: predicates };
+  if (Buffer.byteLength(JSON.stringify(filter), "utf8") > MAX_FILTER_BYTES) {
+    throw new Error(`MongoDB filters exceed the ${MAX_FILTER_BYTES}-byte limit`);
+  }
+  return filter;
+}
+function readProjection(fieldsValue, includeIdValue) {
+  const includeId = includeIdValue === void 0 || includeIdValue === null ? true : readBoolean2(includeIdValue, "includeId");
+  if (fieldsValue === void 0 || fieldsValue === null) return includeId ? void 0 : { _id: 0 };
+  const fields = readFieldArray(fieldsValue, "fields", MAX_PROJECTION_FIELDS, true);
+  return Object.fromEntries([
+    ...fields.map((field) => [field, 1]),
+    ...!includeId && !fields.includes("_id") ? [["_id", 0]] : []
+  ]);
+}
+function readSort(value) {
+  if (value === void 0 || value === null) return {};
+  if (!Array.isArray(value) || value.length > MAX_SORT_FIELDS) {
+    throw new Error(`sort must contain at most ${MAX_SORT_FIELDS} entries`);
+  }
+  const entries = value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`sort[${index}] must be an object`);
+    const field = readField(entry.field, `sort[${index}].field`);
+    const direction = entry.direction ?? "asc";
+    if (direction !== "asc" && direction !== "desc") {
+      throw new Error(`sort[${index}].direction must be asc or desc`);
+    }
+    return [field, direction === "asc" ? 1 : -1];
+  });
+  if (new Set(entries.map(([field]) => field)).size !== entries.length) {
+    throw new Error("sort must not contain duplicate fields");
+  }
+  return Object.fromEntries(entries);
+}
+function readFieldArray(value, label, maximum, required) {
+  if (!Array.isArray(value) || required && value.length === 0 || value.length > maximum) {
+    throw new Error(`${label} must contain ${required ? "1-" : "0-"}${maximum} fields`);
+  }
+  const fields = value.map((entry, index) => readField(entry, `${label}[${index}]`));
+  if (new Set(fields).size !== fields.length) throw new Error(`${label} must not contain duplicates`);
+  return fields;
+}
+function readScalar(value, label) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${label} must be finite`);
+    return value;
+  }
+  if (typeof value === "string") {
+    if (Buffer.byteLength(value, "utf8") > MAX_SCALAR_STRING_BYTES) {
+      throw new Error(`${label} exceeds the ${MAX_SCALAR_STRING_BYTES}-byte limit`);
+    }
+    return value;
+  }
+  throw new Error(`${label} must be a JSON scalar or null`);
+}
+function mongoOperator(value) {
+  return { eq: "$eq", ne: "$ne", lt: "$lt", lte: "$lte", gt: "$gt", gte: "$gte" }[value];
+}
+function boundedResult(value, label) {
+  const serialized = BSON.EJSON.serialize(value, { relaxed: true });
+  if (Buffer.byteLength(JSON.stringify(serialized), "utf8") > MAX_RESULT_BYTES2) {
+    throw new Error(`${label} exceeds the ${MAX_RESULT_BYTES2}-byte limit`);
+  }
+  return serialized;
+}
+function readHost(value) {
+  const host = readCredentialString(value, "host", 253);
+  const ipVersion = isIP3(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error("MongoDB host is not a public network target");
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error("MongoDB host must be a public hostname or IP address without a scheme or port");
+  }
+  return host;
+}
+function readName(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_NAME_BYTES || /[\u0000-\u001f\u007f/\\]/.test(value)) {
+    throw new Error(`${label} must be a non-empty MongoDB name under ${MAX_NAME_BYTES} bytes`);
+  }
+  return value;
+}
+function readCollectionName(value) {
+  const collection = readName(value, "collection");
+  if (collection.startsWith("system.") || collection.includes("$")) {
+    throw new Error("collection must not target MongoDB system or command namespaces");
+  }
+  return collection;
+}
+function readDatabaseName(value, label) {
+  const database = readName(value, label);
+  if (Buffer.byteLength(database, "utf8") > 63 || !/^[A-Za-z0-9_-]+$/.test(database)) {
+    throw new Error(`${label} must use only letters, numbers, underscores, or hyphens and stay under 63 bytes`);
+  }
+  return database;
+}
+function readField(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_FIELD_BYTES || !/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(value)) {
+    throw new Error(`${label} must be a dotted MongoDB field path under ${MAX_FIELD_BYTES} bytes`);
+  }
+  return value;
+}
+function readCredentialString(value, label, maximum) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maximum || label !== "password" && /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`MongoDB credential ${label} must be a non-empty string under ${maximum} characters`);
+  }
+  return value;
+}
+function readBoolean2(value, label) {
+  if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
+  return value;
+}
+function pinnedLookup(address) {
+  const family = isIP3(address);
+  return (_hostname, options, callback) => {
+    const normalizedOptions = typeof options === "number" ? { family: options } : options;
+    if (normalizedOptions?.family && normalizedOptions.family !== family) {
+      callback(new Error("MongoDB pinned address does not match the requested network family"), "", 0);
+      return;
+    }
+    if (normalizedOptions?.all) {
+      callback(null, [{ address, family }], void 0);
+      return;
+    }
+    callback(null, address, family);
+  };
+}
+function safeErrorMessage(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function credentialSecrets(source) {
+  try {
+    return readCredentials2(source).secrets;
+  } catch {
+    return [];
+  }
+}
+function collectionSchema() {
+  return {
+    type: "object",
+    properties: { collection: nameParameter("Collection name.") },
+    required: ["collection"],
+    additionalProperties: false
+  };
+}
+function filterArraySchema() {
+  return {
+    type: "array",
+    maxItems: MAX_FILTERS,
+    items: {
+      type: "object",
+      properties: {
+        field: fieldParameter(),
+        operator: { type: "string", enum: ["eq", "ne", "lt", "lte", "gt", "gte"] },
+        value: { type: ["string", "number", "boolean", "null"] }
+      },
+      required: ["field", "operator", "value"],
+      additionalProperties: false
+    }
+  };
+}
+function nameParameter(description) {
+  return { type: "string", minLength: 1, maxLength: MAX_NAME_BYTES, description };
+}
+function fieldParameter() {
+  return {
+    type: "string",
+    minLength: 1,
+    maxLength: MAX_FIELD_BYTES,
+    pattern: "^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$"
+  };
+}
+function readCapability6(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+
 // src/connectors/adapters/mycase.ts
 var pageProperties = {
   page: { type: "integer", minimum: 1 },
@@ -43883,7 +45289,7 @@ var pipedriveConnector = declarativeRestConnector({
 // src/connectors/adapters/parquet-files.ts
 import { parquetReadObjects } from "hyparquet";
 import { parquetWriteBuffer } from "hyparquet-writer";
-var MAX_COLUMNS3 = 256;
+var MAX_COLUMNS4 = 256;
 var parquetFilesConnector = {
   manifest: {
     kind: "parquet-files",
@@ -43901,7 +45307,7 @@ var parquetFilesConnector = {
           type: "object",
           properties: {
             fileBase64: { type: "string", description: "Parquet file content encoded as canonical base64." },
-            columns: { type: "array", maxItems: MAX_COLUMNS3, items: { type: "string", minLength: 1 } },
+            columns: { type: "array", maxItems: MAX_COLUMNS4, items: { type: "string", minLength: 1 } },
             rowStart: { type: "integer", minimum: 0, default: 0 },
             rowLimit: { type: "integer", minimum: 1, maximum: MAX_RECORDS, default: MAX_RECORDS }
           },
@@ -43947,8 +45353,8 @@ var parquetFilesConnector = {
     if (capabilityName !== "parquet.create") throw new Error(`Unknown Parquet capability: ${capabilityName}`);
     const records = readRecords(args.records);
     const columnNames = [...new Set(records.flatMap((record) => Object.keys(record)))];
-    if (columnNames.length === 0 || columnNames.length > MAX_COLUMNS3) {
-      throw new Error(`records must contain 1 through ${MAX_COLUMNS3} columns`);
+    if (columnNames.length === 0 || columnNames.length > MAX_COLUMNS4) {
+      throw new Error(`records must contain 1 through ${MAX_COLUMNS4} columns`);
     }
     if (columnNames.some((name) => name.length === 0)) throw new Error("column names must not be empty");
     const columnData = columnNames.map((name) => {
@@ -43978,8 +45384,8 @@ function asyncBuffer(file) {
 }
 function readColumns2(value) {
   if (value === void 0 || value === null) return void 0;
-  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_COLUMNS3) {
-    throw new Error(`columns must contain 1 through ${MAX_COLUMNS3} names`);
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_COLUMNS4) {
+    throw new Error(`columns must contain 1 through ${MAX_COLUMNS4} names`);
   }
   const columns = value.map((entry, index) => {
     if (typeof entry !== "string" || entry.length === 0) throw new Error(`columns[${index}] must be a non-empty string`);
@@ -44435,6 +45841,1143 @@ var quickbooksConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/rabbitmq.ts
+import { createHash as createHash7 } from "crypto";
+import { isIP as isIP4 } from "net";
+import {
+  connect as amqpConnect
+} from "amqplib";
+var MAX_MESSAGE_BYTES3 = 1024 * 1024;
+var MAX_NAME_BYTES2 = 255;
+var MAX_PEM_BYTES = 64 * 1024;
+var MAX_CA_CERTIFICATES = 16;
+var MAX_CA_BYTES = 256 * 1024;
+function createRabbitMqConnector(options = {}) {
+  const connect = options.connect ?? ((connectOptions, socketOptions) => amqpConnect(connectOptions, socketOptions));
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "rabbitmq",
+      displayName: "RabbitMQ",
+      description: "Inspect queues and exchanges and publish confirmed JSON messages over verified TLS.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with a public RabbitMQ host, username, password, virtual host, and optional TLS client credentials."
+      },
+      defaultConsistencyModel: "advisory",
+      category: "webhook",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability7("rabbitmq.queues.inspect", "Check a queue and return its current message and consumer counts.", {
+          type: "object",
+          properties: { queue: nameSchema("queue") },
+          required: ["queue"],
+          additionalProperties: false
+        }),
+        readCapability7("rabbitmq.exchanges.inspect", "Check whether a named exchange exists and is visible to the connection.", {
+          type: "object",
+          properties: { exchange: nameSchema("exchange") },
+          required: ["exchange"],
+          additionalProperties: false
+        }),
+        mutationCapability6("send.message.to.queue", "Publish a persistent JSON message directly to an existing queue with broker confirmation.", {
+          type: "object",
+          properties: {
+            queue: nameSchema("queue"),
+            data: {},
+            persistent: { type: "boolean", default: true },
+            expirationMs: { type: "integer", minimum: 1, maximum: 6048e5 },
+            priority: { type: "integer", minimum: 0, maximum: 255 }
+          },
+          required: ["queue", "data"],
+          additionalProperties: false
+        }),
+        mutationCapability6("send.message.to.exchange", "Publish a persistent JSON message to an existing exchange with broker confirmation.", {
+          type: "object",
+          properties: {
+            exchange: nameSchema("exchange"),
+            routingKey: { type: "string", maxLength: MAX_NAME_BYTES2, default: "" },
+            data: {},
+            persistent: { type: "boolean", default: true },
+            expirationMs: { type: "integer", minimum: 1, maximum: 6048e5 },
+            priority: { type: "integer", minimum: 0, maximum: 255 }
+          },
+          required: ["exchange", "data"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async executeRead({ source, capabilityName, args }) {
+      if (capabilityName === "rabbitmq.queues.inspect") {
+        const queue = readName2(args.queue, "queue");
+        const data4 = await withChannel(source, connect, resolveHost, async (channel) => {
+          const details = await channel.checkQueue(queue);
+          return { queue: details.queue, messageCount: details.messageCount, consumerCount: details.consumerCount };
+        });
+        return { data: data4, fetchedAt: Date.now() };
+      }
+      if (capabilityName === "rabbitmq.exchanges.inspect") {
+        const exchange = readName2(args.exchange, "exchange");
+        const data4 = await withChannel(source, connect, resolveHost, async (channel) => {
+          await channel.checkExchange(exchange);
+          return { exchange, exists: true };
+        });
+        return { data: data4, fetchedAt: Date.now() };
+      }
+      throw new Error(`Unknown RabbitMQ read capability: ${capabilityName}`);
+    },
+    async executeMutation({ source, capabilityName, args, idempotencyKey }) {
+      let data4;
+      if (capabilityName === "send.message.to.queue") {
+        const queue = readName2(args.queue, "queue");
+        const body = readJsonMessage(args.data);
+        const publishOptions = readPublishOptions(args, idempotencyKey);
+        data4 = await withConfirmChannel(source, connect, resolveHost, async (channel) => {
+          await channel.checkQueue(queue);
+          await publishConfirmed(channel, publishOptions, (options2) => channel.sendToQueue(queue, body, options2));
+          return { queue, confirmed: true, messageId: publishOptions.messageId, byteLength: body.byteLength };
+        });
+      } else if (capabilityName === "send.message.to.exchange") {
+        const exchange = readName2(args.exchange, "exchange");
+        const routingKey = readRoutingKey(args.routingKey);
+        const body = readJsonMessage(args.data);
+        const publishOptions = readPublishOptions(args, idempotencyKey);
+        data4 = await withConfirmChannel(source, connect, resolveHost, async (channel) => {
+          await channel.checkExchange(exchange);
+          await publishConfirmed(channel, publishOptions, (options2) => channel.publish(exchange, routingKey, body, options2));
+          return { exchange, routingKey, confirmed: true, messageId: publishOptions.messageId, byteLength: body.byteLength };
+        });
+      } else {
+        throw new Error(`Unknown RabbitMQ mutation capability: ${capabilityName}`);
+      }
+      return { status: "committed", data: data4, committedAt: Date.now(), idempotentReplay: false };
+    },
+    async test(source) {
+      try {
+        const credentials = readCredentials3(source);
+        await resolveHost(credentials.host);
+        const model2 = await connect(credentials.connectOptions, credentials.socketOptions);
+        await model2.close();
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage2(error, credentialSecrets2(source)) };
+      }
+    }
+  };
+}
+var rabbitMqConnector = createRabbitMqConnector();
+async function withChannel(source, connect, resolveHost, run) {
+  const credentials = readCredentials3(source);
+  await resolveHost(credentials.host);
+  let model2;
+  let channel;
+  try {
+    model2 = await connect(credentials.connectOptions, credentials.socketOptions);
+    channel = await model2.createChannel();
+    return await run(channel);
+  } catch (error) {
+    throw new Error(safeErrorMessage2(error, credentials.secrets));
+  } finally {
+    await channel?.close().catch(() => void 0);
+    await model2?.close().catch(() => void 0);
+  }
+}
+async function withConfirmChannel(source, connect, resolveHost, run) {
+  const credentials = readCredentials3(source);
+  await resolveHost(credentials.host);
+  let model2;
+  let channel;
+  try {
+    model2 = await connect(credentials.connectOptions, credentials.socketOptions);
+    channel = await model2.createConfirmChannel();
+    return await run(channel);
+  } catch (error) {
+    throw new Error(safeErrorMessage2(error, credentials.secrets));
+  } finally {
+    await channel?.close().catch(() => void 0);
+    await model2?.close().catch(() => void 0);
+  }
+}
+async function publishConfirmed(channel, publishOptions, publish) {
+  let returned;
+  const onReturn = (message) => {
+    returned = message;
+  };
+  channel.on("return", onReturn);
+  try {
+    publish(publishOptions);
+    await channel.waitForConfirms();
+    if (returned) throw new Error("RabbitMQ accepted but could not route the message");
+  } finally {
+    channel.removeListener("return", onReturn);
+  }
+}
+function readCredentials3(source) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error("RabbitMQ credential must be valid JSON");
+    }
+  } else {
+    throw new Error("RabbitMQ requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("RabbitMQ credential must be a JSON object");
+  const host = readHost2(raw.host);
+  const port = readBoundedInteger(raw.port, 5671, 1, 65535, "port");
+  const username = readRequiredString(raw.username, "username", 1024);
+  const password = readRequiredString(raw.password, "password", 4096);
+  const vhost = readOptionalString(raw.vhost, "vhost") ?? "/";
+  if (Buffer.byteLength(vhost, "utf8") > MAX_NAME_BYTES2 || /[\u0000-\u001f\u007f]/.test(vhost)) {
+    throw new Error(`vhost must be at most ${MAX_NAME_BYTES2} bytes without control characters`);
+  }
+  const ca = readPem(raw.tlsCa, "tlsCa", true);
+  const cert = readPem(raw.tlsCert, "tlsCert", false);
+  const key = readPem(raw.tlsKey, "tlsKey", false);
+  if (Boolean(cert) !== Boolean(key)) throw new Error("tlsCert and tlsKey must be supplied together");
+  const passphrase = readOptionalString(raw.tlsPassphrase, "tlsPassphrase");
+  return {
+    host,
+    connectOptions: {
+      protocol: "amqps",
+      hostname: host,
+      port,
+      username,
+      password,
+      vhost,
+      heartbeat: readBoundedInteger(raw.heartbeatSeconds, 30, 5, 300, "heartbeatSeconds"),
+      frameMax: MAX_MESSAGE_BYTES3 + 4096
+    },
+    socketOptions: {
+      minVersion: "TLSv1.2",
+      rejectUnauthorized: true,
+      servername: isIP4(host) === 0 ? host : void 0,
+      lookup: publicDnsLookup,
+      timeout: readBoundedInteger(raw.connectionTimeoutMs, 1e4, 1e3, 3e4, "connectionTimeoutMs"),
+      noDelay: true,
+      keepAlive: true,
+      keepAliveDelay: 6e4,
+      ca,
+      cert,
+      key,
+      passphrase
+    },
+    secrets: [password, ...cert ? [cert] : [], ...key ? [key] : [], ...passphrase ? [passphrase] : []]
+  };
+}
+function readHost2(value) {
+  const host = readRequiredString(value, "host", 253);
+  const ipVersion = isIP4(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error("RabbitMQ host is not a public network target");
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error("RabbitMQ host must be a public hostname or IP address without a scheme or port");
+  }
+  return host;
+}
+function readPublishOptions(args, idempotencyKey) {
+  const expirationMs = args.expirationMs === void 0 ? void 0 : readBoundedInteger(args.expirationMs, 0, 1, 6048e5, "expirationMs");
+  const priority = args.priority === void 0 ? void 0 : readBoundedInteger(args.priority, 0, 0, 255, "priority");
+  return {
+    mandatory: true,
+    persistent: readBoolean(args.persistent, true, "persistent"),
+    contentType: "application/json",
+    contentEncoding: "utf-8",
+    messageId: createHash7("sha256").update(idempotencyKey).digest("hex"),
+    timestamp: Math.floor(Date.now() / 1e3),
+    appId: "tangle-integration-hub",
+    expiration: expirationMs === void 0 ? void 0 : String(expirationMs),
+    priority
+  };
+}
+function readJsonMessage(value) {
+  if (value === void 0) throw new Error("data is required");
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    throw new Error("data must be JSON-serializable");
+  }
+  if (serialized === void 0) throw new Error("data must be JSON-serializable");
+  const body = Buffer.from(serialized);
+  if (body.byteLength > MAX_MESSAGE_BYTES3) throw new Error(`data exceeds the ${MAX_MESSAGE_BYTES3}-byte limit`);
+  return body;
+}
+function readName2(value, label) {
+  const name = readRequiredString(value, label, MAX_NAME_BYTES2);
+  if (Buffer.byteLength(name, "utf8") > MAX_NAME_BYTES2 || /[\u0000-\u001f\u007f]/.test(name)) {
+    throw new Error(`${label} must be at most ${MAX_NAME_BYTES2} bytes without control characters`);
+  }
+  return name;
+}
+function readRoutingKey(value) {
+  if (value === void 0 || value === null || value === "") return "";
+  return readName2(value, "routingKey");
+}
+function readRequiredString(value, label, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
+    throw new Error(`${label} must be a non-empty string no longer than ${maxLength} characters`);
+  }
+  return value;
+}
+function readPem(value, label, allowArray) {
+  if (value === void 0 || value === null) return void 0;
+  const values = Array.isArray(value) && allowArray ? value : [value];
+  if (values.length === 0 || values.length > MAX_CA_CERTIFICATES || values.some((entry) => typeof entry !== "string" || entry.length === 0 || Buffer.byteLength(entry, "utf8") > MAX_PEM_BYTES) || values.reduce((total, entry) => total + (typeof entry === "string" ? Buffer.byteLength(entry, "utf8") : 0), 0) > MAX_CA_BYTES) {
+    throw new Error(
+      allowArray ? `${label} must contain 1-${MAX_CA_CERTIFICATES} PEM strings, each under ${MAX_PEM_BYTES} bytes and ${MAX_CA_BYTES} bytes total` : `${label} must be a PEM string under ${MAX_PEM_BYTES} bytes`
+    );
+  }
+  return allowArray ? values : values[0];
+}
+function credentialSecrets2(source) {
+  try {
+    return readCredentials3(source).secrets;
+  } catch {
+    return [];
+  }
+}
+function safeErrorMessage2(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function readCapability7(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+function mutationCapability6(name, description, parameters) {
+  return { name, class: "mutation", description, parameters, cas: "none", externalEffect: true };
+}
+function nameSchema(label) {
+  return { type: "string", minLength: 1, maxLength: MAX_NAME_BYTES2, description: `Existing RabbitMQ ${label} name.` };
+}
+
+// src/connectors/adapters/redis.ts
+import { isIP as isIP5 } from "net";
+import {
+  createClient as createRedisClient
+} from "redis";
+var MAX_KEY_BYTES = 1024;
+var MAX_PATTERN_BYTES = 4096;
+var MAX_VALUE_BYTES = 1024 * 1024;
+var MAX_SCAN_KEYS = 1e3;
+var MAX_SCAN_BYTES = 1024 * 1024;
+var MAX_TLS_CA_BYTES2 = 256 * 1024;
+var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var SCAN_SCRIPT = `
+local page
+if ARGV[4] == '' then
+  page = redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', ARGV[3])
+else
+  page = redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', ARGV[3], 'TYPE', ARGV[4])
+end
+local keys = page[2]
+if #keys > tonumber(ARGV[5]) then return redis.error_reply('Redis SCAN page exceeds the configured key limit') end
+local bytes = 0
+for _, key in ipairs(keys) do
+  if string.len(key) > tonumber(ARGV[7]) then return redis.error_reply('Redis SCAN key exceeds the configured key limit') end
+  bytes = bytes + string.len(key)
+  if bytes > tonumber(ARGV[6]) then return redis.error_reply('Redis SCAN page exceeds the configured byte limit') end
+end
+return page
+`;
+var INSPECT_SCRIPT = `
+local kind = redis.call('TYPE', KEYS[1])
+if type(kind) == 'table' then kind = kind['ok'] end
+return { kind, redis.call('PTTL', KEYS[1]) }
+`;
+var READ_STRING_SCRIPT = `
+local kind = redis.call('TYPE', KEYS[1])
+if type(kind) == 'table' then kind = kind['ok'] end
+local ttl = redis.call('PTTL', KEYS[1])
+if kind == 'none' then return { kind, ttl, false, 0 } end
+if kind ~= 'string' then return redis.error_reply('WRONGTYPE key does not contain a string') end
+local length = redis.call('STRLEN', KEYS[1])
+if length > tonumber(ARGV[1]) then return redis.error_reply('Redis value exceeds the configured read limit') end
+return { kind, ttl, redis.call('GET', KEYS[1]), length }
+`;
+var COMPARE_SET_SCRIPT = `
+if redis.call('GET', KEYS[1]) ~= ARGV[1] then return 0 end
+if ARGV[3] ~= '' then
+  redis.call('SET', KEYS[1], ARGV[2], 'PX', ARGV[3])
+elseif ARGV[4] == '1' then
+  redis.call('SET', KEYS[1], ARGV[2], 'KEEPTTL')
+else
+  redis.call('SET', KEYS[1], ARGV[2])
+end
+return 1
+`;
+var COMPARE_DELETE_SCRIPT = `
+if redis.call('GET', KEYS[1]) ~= ARGV[1] then return 0 end
+return redis.call('DEL', KEYS[1])
+`;
+function createRedisConnector(options = {}) {
+  const createClient = options.createClient ?? defaultCreateClient2;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "redis",
+      displayName: "Redis",
+      description: "Inspect and scan Redis keys and perform bounded, approved string compare-and-swap mutations over verified TLS.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with a public Redis host, password, optional ACL username/database, and optional TLS CA. Verified TLS is mandatory."
+      },
+      defaultConsistencyModel: "authoritative",
+      category: "database",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability8("redis.keys.scan", "Read one bounded SCAN page without blocking the server with KEYS.", {
+          type: "object",
+          properties: {
+            cursor: { type: "string", pattern: "^[0-9]+$", default: "0" },
+            match: { type: "string", maxLength: MAX_PATTERN_BYTES, default: "*" },
+            count: { type: "integer", minimum: 1, maximum: MAX_SCAN_KEYS, default: 100 },
+            type: { type: "string", enum: ["string", "list", "set", "zset", "hash", "stream"] }
+          },
+          additionalProperties: false
+        }),
+        readCapability8("redis.key.inspect", "Read a key type and remaining expiry atomically.", keySchema()),
+        readCapability8("redis.string.get", "Read one bounded string value, type, and remaining expiry atomically.", keySchema()),
+        mutationCapability7("redis.string.set", "Set a bounded string only when the key is absent, present, or matches an expected value.", {
+          type: "object",
+          properties: {
+            key: keyParameter(),
+            value: { type: "string", maxLength: MAX_VALUE_BYTES },
+            condition: { type: "string", enum: ["absent", "present", "matches"] },
+            expectedValue: { type: "string", maxLength: MAX_VALUE_BYTES },
+            ttlMs: { type: "integer", minimum: 1, maximum: MAX_TTL_MS },
+            keepTtl: { type: "boolean", default: false }
+          },
+          required: ["key", "value", "condition"],
+          additionalProperties: false
+        }),
+        mutationCapability7("redis.string.delete", "Delete a string key only when its current value exactly matches the caller expectation.", {
+          type: "object",
+          properties: {
+            key: keyParameter(),
+            expectedValue: { type: "string", maxLength: MAX_VALUE_BYTES }
+          },
+          required: ["key", "expectedValue"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async test(source) {
+      try {
+        await withClient2(source, createClient, resolveHost, async (client) => {
+          const response = await client.ping();
+          if (response !== "PONG") throw new Error("Redis PING returned an unexpected response");
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage3(error, credentialSecrets3(source)) };
+      }
+    },
+    async executeRead({ source, capabilityName, args }) {
+      if (capabilityName === "redis.keys.scan") {
+        const cursor = readCursor2(args.cursor);
+        const match = readPattern(args.match);
+        const count = readBoundedInteger(args.count, 100, 1, MAX_SCAN_KEYS, "count");
+        const type = readScanType(args.type);
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
+          const reply = readArrayReply(await client.eval(SCAN_SCRIPT, {
+            keys: [],
+            arguments: [
+              cursor,
+              match,
+              String(count),
+              type ?? "",
+              String(MAX_SCAN_KEYS),
+              String(MAX_SCAN_BYTES),
+              String(MAX_KEY_BYTES)
+            ]
+          }), "scan");
+          const keys = readStringArray(reply[1], "scan keys");
+          assertScanPage(keys);
+          return { cursor: readCursor2(readReplyString(reply[0], "cursor")), keys };
+        });
+        return { data: data4, fetchedAt: Date.now() };
+      }
+      if (capabilityName === "redis.key.inspect") {
+        const key = readKey(args.key);
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
+          const reply = readArrayReply(await client.eval(INSPECT_SCRIPT, { keys: [key], arguments: [] }), "inspect");
+          const type = readReplyString(reply[0], "type");
+          return { key, exists: type !== "none", type, ttlMs: normalizeTtl(reply[1]) };
+        });
+        return { data: data4, fetchedAt: Date.now() };
+      }
+      if (capabilityName === "redis.string.get") {
+        const key = readKey(args.key);
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
+          const reply = readArrayReply(await client.eval(READ_STRING_SCRIPT, {
+            keys: [key],
+            arguments: [String(MAX_VALUE_BYTES)]
+          }), "string read");
+          const type = readReplyString(reply[0], "type");
+          const exists = type !== "none";
+          const value = exists ? readReplyString(reply[2], "value") : null;
+          if (value !== null && Buffer.byteLength(value, "utf8") > MAX_VALUE_BYTES) {
+            throw new Error(`Redis value exceeds the ${MAX_VALUE_BYTES}-byte limit`);
+          }
+          return {
+            key,
+            exists,
+            type,
+            ttlMs: normalizeTtl(reply[1]),
+            value,
+            byteLength: exists ? readReplyInteger(reply[3], "byteLength") : 0
+          };
+        });
+        return { data: data4, fetchedAt: Date.now() };
+      }
+      throw new Error(`Unknown Redis read capability: ${capabilityName}`);
+    },
+    async executeMutation({ source, capabilityName, args }) {
+      if (capabilityName === "redis.string.set") {
+        const input = readSetInput(args);
+        return withClient2(source, createClient, resolveHost, async (client) => {
+          let committed;
+          if (input.condition === "matches") {
+            committed = readReplyInteger(await client.eval(COMPARE_SET_SCRIPT, {
+              keys: [input.key],
+              arguments: [input.expectedValue, input.value, input.ttlMs === void 0 ? "" : String(input.ttlMs), input.keepTtl ? "1" : "0"]
+            }), "compare-and-set result") === 1;
+          } else {
+            const response = await client.set(input.key, input.value, {
+              condition: input.condition === "absent" ? "NX" : "XX",
+              expiration: input.ttlMs === void 0 ? input.keepTtl ? "KEEPTTL" : void 0 : { type: "PX", value: input.ttlMs }
+            });
+            committed = response === "OK";
+          }
+          if (!committed) return conflict(`Redis key ${input.key} did not satisfy condition ${input.condition}`);
+          return committedResult({ key: input.key, condition: input.condition, byteLength: Buffer.byteLength(input.value, "utf8") });
+        });
+      }
+      if (capabilityName === "redis.string.delete") {
+        const key = readKey(args.key);
+        const expectedValue = readValue(args.expectedValue, "expectedValue");
+        return withClient2(source, createClient, resolveHost, async (client) => {
+          const deleted = readReplyInteger(await client.eval(COMPARE_DELETE_SCRIPT, {
+            keys: [key],
+            arguments: [expectedValue]
+          }), "compare-and-delete result");
+          if (deleted !== 1) return conflict(`Redis key ${key} did not match the expected value`);
+          return committedResult({ key, deleted: true });
+        });
+      }
+      throw new Error(`Unknown Redis mutation capability: ${capabilityName}`);
+    }
+  };
+}
+var redisConnector = createRedisConnector();
+function defaultCreateClient2(options) {
+  return createRedisClient(options);
+}
+async function withClient2(source, createClient, resolveHost, run) {
+  const credentials = readCredentials4(source);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error("Redis host did not resolve");
+  let client;
+  try {
+    client = createClient({
+      username: credentials.username,
+      password: credentials.password,
+      database: credentials.database,
+      name: "tangle-integration-hub",
+      disableOfflineQueue: true,
+      commandsQueueMaxLength: 10,
+      maintNotifications: "disabled",
+      commandOptions: { abortSignal: AbortSignal.timeout(credentials.commandTimeoutMs) },
+      socket: {
+        host: addresses[0],
+        port: credentials.port,
+        tls: true,
+        servername: isIP5(credentials.host) === 0 ? credentials.host : void 0,
+        minVersion: "TLSv1.2",
+        rejectUnauthorized: true,
+        ca: credentials.tlsCa,
+        connectTimeout: credentials.connectTimeoutMs,
+        socketTimeout: credentials.commandTimeoutMs,
+        reconnectStrategy: false
+      }
+    });
+    client.on("error", () => void 0);
+    await client.connect();
+    return await run(client);
+  } catch (error) {
+    throw new Error(safeErrorMessage3(error, credentials.secrets));
+  } finally {
+    if (client?.isOpen) await client.close().catch(() => client?.destroy());
+    else client?.destroy();
+  }
+}
+function readCredentials4(source) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error("Redis credential must be valid JSON");
+    }
+  } else {
+    throw new Error("Redis requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("Redis credential must be a JSON object");
+  const host = readHost3(raw.host);
+  const username = readOptionalString(raw.username, "username");
+  if (username && (username.length > 128 || /[\u0000-\u001f\u007f]/.test(username))) {
+    throw new Error("Redis username must be at most 128 characters without control characters");
+  }
+  const password = readRequiredString2(raw.password, "password", 4096);
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES2) {
+    throw new Error(`Redis tlsCa exceeds the ${MAX_TLS_CA_BYTES2}-byte limit`);
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, 6380, 1, 65535, "port"),
+    username,
+    password,
+    database: readBoundedInteger(raw.database, 0, 0, 65535, "database"),
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    commandTimeoutMs: readBoundedInteger(raw.commandTimeoutMs, 1e4, 1e3, 3e4, "commandTimeoutMs"),
+    secrets: [password]
+  };
+}
+function readHost3(value) {
+  const host = readRequiredString2(value, "host", 253);
+  const ipVersion = isIP5(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error("Redis host is not a public network target");
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error("Redis host must be a public hostname or IP address without a scheme or port");
+  }
+  return host;
+}
+function readSetInput(args) {
+  const key = readKey(args.key);
+  const value = readValue(args.value, "value");
+  const condition = args.condition;
+  if (!["absent", "present", "matches"].includes(String(condition))) {
+    throw new Error("condition must be absent, present, or matches");
+  }
+  const expectedValue = args.expectedValue === void 0 ? void 0 : readValue(args.expectedValue, "expectedValue");
+  if (condition === "matches" && expectedValue === void 0) throw new Error("expectedValue is required when condition is matches");
+  if (condition !== "matches" && expectedValue !== void 0) throw new Error("expectedValue is only valid when condition is matches");
+  const ttlMs = args.ttlMs === void 0 ? void 0 : readBoundedInteger(args.ttlMs, 0, 1, MAX_TTL_MS, "ttlMs");
+  const keepTtl = readBoolean(args.keepTtl, false, "keepTtl");
+  if (ttlMs !== void 0 && keepTtl) throw new Error("ttlMs and keepTtl cannot be used together");
+  return { key, value, condition, expectedValue, ttlMs, keepTtl };
+}
+function readCursor2(value) {
+  if (value === void 0 || value === null || value === "") return "0";
+  if (typeof value !== "string" || !/^[0-9]+$/.test(value) || value.length > 32) {
+    throw new Error("cursor must be a Redis numeric cursor string");
+  }
+  return value;
+}
+function readPattern(value) {
+  if (value === void 0 || value === null || value === "") return "*";
+  if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > MAX_PATTERN_BYTES || /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`match must be under ${MAX_PATTERN_BYTES} bytes without control characters`);
+  }
+  return value;
+}
+function readScanType(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (!["string", "list", "set", "zset", "hash", "stream"].includes(String(value))) {
+    throw new Error("type must be string, list, set, zset, hash, or stream");
+  }
+  return String(value);
+}
+function assertScanPage(keys) {
+  if (!Array.isArray(keys) || keys.length > MAX_SCAN_KEYS) {
+    throw new Error(`Redis SCAN page exceeds ${MAX_SCAN_KEYS} keys`);
+  }
+  if (keys.some((key) => typeof key !== "string" || Buffer.byteLength(key, "utf8") > MAX_KEY_BYTES || /[\u0000-\u001f\u007f]/.test(key)) || Buffer.byteLength(JSON.stringify(keys), "utf8") > MAX_SCAN_BYTES) {
+    throw new Error(`Redis SCAN page exceeds the ${MAX_SCAN_BYTES}-byte limit`);
+  }
+}
+function readKey(value) {
+  return readBoundedString(value, "key", MAX_KEY_BYTES);
+}
+function readValue(value, label) {
+  if (typeof value !== "string") throw new Error(`${label} must be a string`);
+  if (Buffer.byteLength(value, "utf8") > MAX_VALUE_BYTES) {
+    throw new Error(`${label} exceeds the ${MAX_VALUE_BYTES}-byte limit`);
+  }
+  return value;
+}
+function readBoundedString(value, label, maxBytes) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > maxBytes || /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`${label} must be a non-empty string under ${maxBytes} bytes without control characters`);
+  }
+  return value;
+}
+function readRequiredString2(value, label, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
+    throw new Error(`${label} must be a non-empty string no longer than ${maxLength} characters`);
+  }
+  return value;
+}
+function readArrayReply(value, label) {
+  if (!Array.isArray(value)) throw new Error(`Redis ${label} returned a malformed response`);
+  return value;
+}
+function readStringArray(value, label) {
+  if (!Array.isArray(value)) throw new Error(`Redis response ${label} is malformed`);
+  return value.map((entry) => readReplyString(entry, label));
+}
+function readReplyString(value, label) {
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  throw new Error(`Redis response ${label} is malformed`);
+}
+function readReplyInteger(value, label) {
+  const parsed = typeof value === "bigint" ? Number(value) : typeof value === "string" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isSafeInteger(parsed)) throw new Error(`Redis response ${label} is malformed`);
+  return parsed;
+}
+function normalizeTtl(value) {
+  const ttl = readReplyInteger(value, "ttlMs");
+  return ttl >= 0 ? ttl : null;
+}
+function safeErrorMessage3(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function credentialSecrets3(source) {
+  try {
+    return readCredentials4(source).secrets;
+  } catch {
+    return [];
+  }
+}
+function committedResult(data4) {
+  return { status: "committed", data: data4, committedAt: Date.now(), idempotentReplay: false };
+}
+function conflict(message) {
+  return { status: "conflict", alternatives: [], currentState: null, message };
+}
+function readCapability8(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+function mutationCapability7(name, description, parameters) {
+  return { name, class: "mutation", description, parameters, cas: "optimistic-read-verify", externalEffect: true };
+}
+function keyParameter() {
+  return { type: "string", minLength: 1, maxLength: MAX_KEY_BYTES };
+}
+function keySchema() {
+  return {
+    type: "object",
+    properties: { key: keyParameter() },
+    required: ["key"],
+    additionalProperties: false
+  };
+}
+
+// src/connectors/adapters/redshift.ts
+import { isIP as isIP6 } from "net";
+import {
+  Client as PgClient
+} from "pg";
+var MAX_IDENTIFIER_BYTES = 127;
+var MAX_COLUMNS5 = 64;
+var MAX_FILTERS2 = 20;
+var MAX_ORDER_COLUMNS = 8;
+var MAX_PARAMETERS_BYTES = 10 * 1024 * 1024;
+var MAX_RESULT_ROWS = 1e4;
+var MAX_RESULT_BYTES3 = 10 * 1024 * 1024;
+var MAX_TLS_CA_BYTES3 = 256 * 1024;
+var REDSHIFT_PROVIDER = {
+  kind: "redshift",
+  displayName: "Amazon Redshift",
+  description: "Inspect Redshift schemas and tables and run bounded structured row reads over the verified PostgreSQL wire protocol.",
+  authHint: "JSON with a public Redshift host, database, user, password, optional port, and optional TLS CA. Verified TLS is mandatory.",
+  defaultPort: 5439
+};
+function createRedshiftConnector(options = {}) {
+  return createPostgresWireReadConnector(REDSHIFT_PROVIDER, options);
+}
+function createPostgresWireReadConnector(provider2, options = {}) {
+  const createClient = options.createClient ?? defaultCreateClient3;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: provider2.kind,
+      displayName: provider2.displayName,
+      description: provider2.description,
+      auth: {
+        kind: "api-key",
+        hint: provider2.authHint
+      },
+      defaultConsistencyModel: "authoritative",
+      category: "database",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability9(`${provider2.kind}.schemas.list`, `List schemas visible to the connected ${provider2.displayName} user.`, emptySchema2()),
+        readCapability9(`${provider2.kind}.tables.list`, "List tables and views in one schema.", {
+          type: "object",
+          properties: { schema: identifierSchema("Schema name; defaults to public.") },
+          additionalProperties: false
+        }),
+        readCapability9(`${provider2.kind}.tables.describe`, "Read ordered column metadata for one table or view.", {
+          type: "object",
+          properties: {
+            schema: identifierSchema("Schema name; defaults to public."),
+            table: identifierSchema("Table or view name.")
+          },
+          required: ["table"],
+          additionalProperties: false
+        }),
+        readCapability9(`${provider2.kind}.rows.select`, "Read bounded rows using an identifier-safe query builder with scalar predicates.", {
+          type: "object",
+          properties: {
+            schema: identifierSchema("Schema name; defaults to public."),
+            table: identifierSchema("Table or view name."),
+            columns: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_COLUMNS5,
+              uniqueItems: true,
+              items: identifierSchema("Column name.")
+            },
+            filters: {
+              type: "array",
+              maxItems: MAX_FILTERS2,
+              items: {
+                type: "object",
+                properties: {
+                  column: identifierSchema("Column name."),
+                  operator: { type: "string", enum: ["eq", "ne", "lt", "lte", "gt", "gte", "like", "is-null", "not-null"] },
+                  value: { type: ["string", "number", "boolean", "null"] }
+                },
+                required: ["column", "operator"],
+                additionalProperties: false
+              }
+            },
+            orderBy: {
+              type: "array",
+              maxItems: MAX_ORDER_COLUMNS,
+              items: {
+                type: "object",
+                properties: {
+                  column: identifierSchema("Column name."),
+                  direction: { type: "string", enum: ["asc", "desc"], default: "asc" }
+                },
+                required: ["column"],
+                additionalProperties: false
+              }
+            },
+            limit: { type: "integer", minimum: 1, maximum: MAX_RESULT_ROWS, default: 100 },
+            offset: { type: "integer", minimum: 0, maximum: 1e6, default: 0 }
+          },
+          required: ["table", "columns"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async test(source) {
+      try {
+        await withClient3(source, provider2, createClient, resolveHost, async (client) => {
+          await client.query({ text: "SELECT current_database() AS database_name, current_user AS user_name", values: [] });
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage4(error, credentialSecrets4(source, provider2)) };
+      }
+    },
+    async executeRead(inv) {
+      const query2 = buildQuery(inv, provider2);
+      const data4 = await withClient3(inv.source, provider2, createClient, resolveHost, async (client) => {
+        await client.query({ text: "BEGIN READ ONLY", values: [] });
+        try {
+          const result = await client.query(query2);
+          return boundedResult2(result, provider2.displayName);
+        } finally {
+          await client.query({ text: "ROLLBACK", values: [] }).catch(() => void 0);
+        }
+      });
+      return { data: data4, fetchedAt: Date.now() };
+    }
+  };
+}
+var redshiftConnector = createRedshiftConnector();
+function defaultCreateClient3(config) {
+  return new PgClient(config);
+}
+async function withClient3(source, provider2, createClient, resolveHost, run) {
+  const credentials = readCredentials5(source, provider2);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error(`${provider2.displayName} host did not resolve`);
+  let client;
+  try {
+    client = createClient({
+      host: addresses[0],
+      port: credentials.port,
+      user: credentials.user,
+      password: credentials.password,
+      database: credentials.database,
+      application_name: "tangle-integration-hub",
+      connectionTimeoutMillis: credentials.connectTimeoutMs,
+      query_timeout: credentials.queryTimeoutMs,
+      statement_timeout: credentials.queryTimeoutMs,
+      lock_timeout: credentials.queryTimeoutMs,
+      keepAlive: true,
+      keepAliveInitialDelayMillis: 6e4,
+      ssl: {
+        servername: isIP6(credentials.host) === 0 ? credentials.host : void 0,
+        minVersion: "TLSv1.2",
+        rejectUnauthorized: true,
+        ca: credentials.tlsCa
+      }
+    });
+    client.on("error", () => void 0);
+    await client.connect();
+    return await run(client);
+  } catch (error) {
+    throw new Error(safeErrorMessage4(error, credentials.secrets));
+  } finally {
+    await client?.end().catch(() => void 0);
+  }
+}
+function readCredentials5(source, provider2) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error(`${provider2.displayName} credential must be valid JSON`);
+    }
+  } else {
+    throw new Error(`${provider2.displayName} requires a structured credential bundle`);
+  }
+  if (!isPlainRecord(raw)) throw new Error(`${provider2.displayName} credential must be a JSON object`);
+  const host = readHost4(raw.host, provider2.displayName);
+  const user = readCredentialString2(raw.user ?? raw.username, "user", 128, provider2.displayName);
+  const password = readCredentialString2(raw.password, "password", 4096, provider2.displayName);
+  const database = readCredentialString2(raw.database, "database", MAX_IDENTIFIER_BYTES, provider2.displayName);
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES3) {
+    throw new Error(`${provider2.displayName} tlsCa exceeds the ${MAX_TLS_CA_BYTES3}-byte limit`);
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, provider2.defaultPort, 1, 65535, "port"),
+    user,
+    password,
+    database,
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    queryTimeoutMs: readBoundedInteger(raw.queryTimeoutMs, 3e4, 1e3, 6e4, "queryTimeoutMs"),
+    secrets: [password]
+  };
+}
+function buildQuery(inv, provider2) {
+  if (inv.capabilityName === `${provider2.kind}.schemas.list`) {
+    return {
+      text: `SELECT schema_name AS "schemaName", schema_owner AS "schemaOwner" FROM information_schema.schemata WHERE schema_name NOT LIKE 'pg_%' AND schema_name <> 'information_schema' ORDER BY schema_name LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: []
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.tables.list`) {
+    return {
+      text: `SELECT table_schema AS "schemaName", table_name AS "tableName", table_type AS "tableType" FROM information_schema.tables WHERE table_schema = $1 ORDER BY table_name LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: [readSchema(inv.args.schema)]
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.tables.describe`) {
+    return {
+      text: `SELECT table_schema AS "schemaName", table_name AS "tableName", column_name AS "columnName", ordinal_position AS "ordinalPosition", column_default AS "columnDefault", is_nullable AS "isNullable", data_type AS "dataType", character_maximum_length AS "characterMaximumLength", numeric_precision AS "numericPrecision", numeric_scale AS "numericScale" FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 ORDER BY ordinal_position LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: [readSchema(inv.args.schema), readIdentifier(inv.args.table, "table")]
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.rows.select`) return buildRowSelect(inv.args, provider2.displayName);
+  throw new Error(`Unknown ${provider2.displayName} read capability: ${inv.capabilityName}`);
+}
+function buildRowSelect(args, providerLabel) {
+  const schema = readSchema(args.schema);
+  const table = readIdentifier(args.table, "table");
+  const columns = readIdentifierArray(args.columns, "columns", MAX_COLUMNS5, true);
+  const filters = readFilters2(args.filters);
+  const orderBy = readOrderBy(args.orderBy);
+  const limit = readBoundedInteger(args.limit, 100, 1, MAX_RESULT_ROWS, "limit");
+  const offset = readBoundedInteger(args.offset, 0, 0, 1e6, "offset");
+  const values = [];
+  const predicates = filters.map((filter) => {
+    const column = quoteIdentifier2(filter.column);
+    if (filter.operator === "is-null") return `${column} IS NULL`;
+    if (filter.operator === "not-null") return `${column} IS NOT NULL`;
+    values.push(filter.value);
+    return `${column} ${sqlOperator(filter.operator)} $${values.length}`;
+  });
+  assertParameterBytes(values, providerLabel);
+  const where = predicates.length > 0 ? ` WHERE ${predicates.join(" AND ")}` : "";
+  const order = orderBy.length > 0 ? ` ORDER BY ${orderBy.map((entry) => `${quoteIdentifier2(entry.column)} ${entry.direction.toUpperCase()}`).join(", ")}` : "";
+  return {
+    text: `SELECT ${columns.map(quoteIdentifier2).join(", ")} FROM ${quoteIdentifier2(schema)}.${quoteIdentifier2(table)}${where}${order} LIMIT ${limit} OFFSET ${offset}`,
+    values
+  };
+}
+function readFilters2(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length > MAX_FILTERS2) throw new Error(`filters must contain at most ${MAX_FILTERS2} entries`);
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`filters[${index}] must be an object`);
+    const column = readIdentifier(entry.column, `filters[${index}].column`);
+    const operator = entry.operator;
+    if (!["eq", "ne", "lt", "lte", "gt", "gte", "like", "is-null", "not-null"].includes(String(operator))) {
+      throw new Error(`filters[${index}].operator is unsupported`);
+    }
+    const valueRequired = !["is-null", "not-null"].includes(String(operator));
+    if (valueRequired) assertScalar(entry.value, `filters[${index}].value`);
+    else if (entry.value !== void 0) throw new Error(`filters[${index}].value is not valid for ${operator}`);
+    if (valueRequired && entry.value === null) throw new Error(`filters[${index}] must use is-null or not-null for null values`);
+    if (operator === "like" && typeof entry.value !== "string") throw new Error(`filters[${index}].value must be a string for like`);
+    return { column, operator: String(operator), value: entry.value };
+  });
+}
+function readOrderBy(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length > MAX_ORDER_COLUMNS) throw new Error(`orderBy must contain at most ${MAX_ORDER_COLUMNS} entries`);
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`orderBy[${index}] must be an object`);
+    const column = readIdentifier(entry.column, `orderBy[${index}].column`);
+    const direction = entry.direction ?? "asc";
+    if (direction !== "asc" && direction !== "desc") throw new Error(`orderBy[${index}].direction must be asc or desc`);
+    return { column, direction };
+  });
+}
+function readIdentifierArray(value, label, max, required) {
+  if (!Array.isArray(value) || required && value.length === 0 || value.length > max) {
+    throw new Error(`${label} must contain ${required ? "1-" : "0-"}${max} identifiers`);
+  }
+  const identifiers = value.map((entry, index) => readIdentifier(entry, `${label}[${index}]`));
+  if (new Set(identifiers).size !== identifiers.length) throw new Error(`${label} must not contain duplicates`);
+  return identifiers;
+}
+function boundedResult2(result, providerLabel) {
+  if (!Array.isArray(result.rows) || result.rows.length > MAX_RESULT_ROWS) {
+    throw new Error(`${providerLabel} result exceeds ${MAX_RESULT_ROWS} rows`);
+  }
+  if (result.rowCount !== null && (!Number.isSafeInteger(result.rowCount) || result.rowCount < 0 || result.rowCount > MAX_RESULT_ROWS)) {
+    throw new Error(`${providerLabel} result returned a malformed row count`);
+  }
+  const data4 = {
+    rows: jsonSafe(result.rows),
+    columns: result.fields.map((field) => ({
+      name: field.name,
+      tableId: field.tableID,
+      columnId: field.columnID,
+      dataTypeId: field.dataTypeID
+    })),
+    rowCount: result.rowCount ?? result.rows.length
+  };
+  const serialized = JSON.stringify(data4);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES3) {
+    throw new Error(`${providerLabel} result exceeds the ${MAX_RESULT_BYTES3}-byte limit`);
+  }
+  return data4;
+}
+function assertParameterBytes(values, providerLabel) {
+  if (Buffer.byteLength(JSON.stringify(values), "utf8") > MAX_PARAMETERS_BYTES) {
+    throw new Error(`${providerLabel} filter values exceed the ${MAX_PARAMETERS_BYTES}-byte limit`);
+  }
+}
+function assertScalar(value, label) {
+  if (value !== null && !["string", "number", "boolean"].includes(typeof value)) throw new Error(`${label} must be a JSON scalar or null`);
+  if (typeof value === "number" && !Number.isFinite(value)) throw new Error(`${label} must be finite`);
+}
+function sqlOperator(value) {
+  return { eq: "=", ne: "<>", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "LIKE" }[value];
+}
+function readSchema(value) {
+  return value === void 0 || value === null ? "public" : readIdentifier(value, "schema");
+}
+function readIdentifier(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_IDENTIFIER_BYTES || !/^[A-Za-z_][A-Za-z0-9_$]*$/.test(value)) {
+    throw new Error(`${label} must be a SQL identifier under ${MAX_IDENTIFIER_BYTES} bytes`);
+  }
+  return value;
+}
+function quoteIdentifier2(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function readHost4(value, providerLabel) {
+  const host = readCredentialString2(value, "host", 253, providerLabel);
+  const ipVersion = isIP6(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error(`${providerLabel} host is not a public network target`);
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error(`${providerLabel} host must be a public hostname or IP address without a scheme or port`);
+  }
+  return host;
+}
+function readCredentialString2(value, label, maxLength, providerLabel) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength || label !== "password" && /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`${providerLabel} credential ${label} must be a non-empty string under ${maxLength} characters`);
+  }
+  return value;
+}
+function safeErrorMessage4(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function credentialSecrets4(source, provider2) {
+  try {
+    return readCredentials5(source, provider2).secrets;
+  } catch {
+    return [];
+  }
+}
+function emptySchema2() {
+  return { type: "object", properties: {}, additionalProperties: false };
+}
+function identifierSchema(description) {
+  return { type: "string", minLength: 1, maxLength: MAX_IDENTIFIER_BYTES, pattern: "^[A-Za-z_][A-Za-z0-9_$]*$", description };
+}
+function readCapability9(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+
+// src/connectors/adapters/postgres.ts
+var POSTGRES_PROVIDER = {
+  kind: "postgres",
+  displayName: "PostgreSQL",
+  description: "Inspect PostgreSQL schemas and tables and run bounded structured row reads over a verified TLS connection.",
+  authHint: "JSON with a public PostgreSQL host, database, user, password, optional port, and optional TLS CA. Verified TLS is mandatory.",
+  defaultPort: 5432
+};
+function createPostgresConnector(options = {}) {
+  return createPostgresWireReadConnector(POSTGRES_PROVIDER, options);
+}
+var postgresConnector = createPostgresConnector();
+
 // src/connectors/adapters/recall-ai.ts
 var recallAiRegions = [
   "https://us-east-1.recall.ai",
@@ -45371,7 +47914,7 @@ function createSftpConnector(options = {}) {
       ]
     },
     async executeRead({ source, capabilityName, args }) {
-      const credentials = readCredentials2(source);
+      const credentials = readCredentials6(source);
       if (capabilityName === "sftp.list") {
         const path = resolveRemotePath(credentials.rootPath, args.path ?? "/");
         const limit = readBoundedInteger(args.limit, MAX_LIST_ENTRIES, 1, MAX_LIST_ENTRIES, "limit");
@@ -45404,7 +47947,7 @@ function createSftpConnector(options = {}) {
       throw new Error(`Unknown SFTP read capability: ${capabilityName}`);
     },
     async executeMutation({ source, capabilityName, args }) {
-      const credentials = readCredentials2(source);
+      const credentials = readCredentials6(source);
       const prepared = prepareMutation(capabilityName, args, credentials.rootPath);
       return withSftp(credentials, createClient, lookupHost, async (client) => {
         let data4;
@@ -45438,7 +47981,7 @@ function createSftpConnector(options = {}) {
     },
     async test(source) {
       try {
-        const credentials = readCredentials2(source);
+        const credentials = readCredentials6(source);
         await withSftp(credentials, createClient, lookupHost, (client) => client.cwd());
         return { ok: true };
       } catch (error) {
@@ -45506,7 +48049,7 @@ async function withSftp(credentials, createClient, lookupHost, run) {
     await client.end().catch(() => false);
   }
 }
-function readCredentials2(source) {
+function readCredentials6(source) {
   let raw;
   if (source.credentials.kind === "custom") raw = source.credentials.values;
   else if (source.credentials.kind === "api-key") {
@@ -48855,7 +51398,15 @@ var squareConnector = declarativeRestConnector({
     kind: "oauth2",
     authorizationUrl: "https://connect.squareup.com/oauth2/authorize",
     tokenUrl: "https://connect.squareup.com/oauth2/token",
-    scopes: ["CUSTOMERS_READ", "CUSTOMERS_WRITE", "PAYMENTS_READ", "PAYMENTS_WRITE", "INVOICES_READ", "INVOICES_WRITE"],
+    scopes: [
+      "CUSTOMERS_READ",
+      "CUSTOMERS_WRITE",
+      "PAYMENTS_READ",
+      "PAYMENTS_WRITE",
+      "INVOICES_READ",
+      "INVOICES_WRITE",
+      "ITEMS_WRITE"
+    ],
     clientIdEnv: "SQUARE_OAUTH_CLIENT_ID",
     clientSecretEnv: "SQUARE_OAUTH_CLIENT_SECRET"
   },
@@ -55209,17 +57760,17 @@ var zohoBookingsConnector = {
     category: "calendar",
     defaultConsistencyModel: "authoritative",
     capabilities: [
-      readCapability6("workspaces.list", "List Zoho Bookings workspaces.", {}),
-      readCapability6("services.list", "List services, optionally within one workspace.", {
+      readCapability10("workspaces.list", "List Zoho Bookings workspaces.", {}),
+      readCapability10("services.list", "List services, optionally within one workspace.", {
         workspace_id: { type: "string" }
       }),
-      readCapability6("resources.list", "List bookable resources, optionally for one service.", {
+      readCapability10("resources.list", "List bookable resources, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability6("staff.list", "List staff, optionally for one service.", {
+      readCapability10("staff.list", "List staff, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability6("appointments.list", "List appointments from a required start time.", {
+      readCapability10("appointments.list", "List appointments from a required start time.", {
         from_time: {
           type: "string",
           description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format."
@@ -55229,17 +57780,17 @@ var zohoBookingsConnector = {
         staff_id: { type: "string" },
         status: { type: "string" }
       }, ["from_time"]),
-      readCapability6("appointments.get", "Read one appointment by booking id.", {
+      readCapability10("appointments.get", "Read one appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"]),
-      readCapability6("availability.fetch", "Fetch open time slots for a service and date.", {
+      readCapability10("availability.fetch", "Fetch open time slots for a service and date.", {
         service_id: { type: "string" },
         selected_date: { type: "string", description: "Date in YYYY-MM-DD format." },
         staff_id: { type: "string" },
         group_id: { type: "string" },
         resource_id: { type: "string" }
       }, ["service_id", "selected_date"]),
-      mutationCapability6("appointments.book", "Book an appointment for a customer.", {
+      mutationCapability8("appointments.book", "Book an appointment for a customer.", {
         service_id: { type: "string" },
         from_time: { type: "string", description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format." },
         customer_details: {
@@ -55255,13 +57806,13 @@ var zohoBookingsConnector = {
         additional_fields: { type: "object" },
         payment_info: { type: "object" }
       }, ["service_id", "from_time", "customer_details"]),
-      mutationCapability6("appointments.reschedule", "Move an appointment to a new time, staff member, or group.", {
+      mutationCapability8("appointments.reschedule", "Move an appointment to a new time, staff member, or group.", {
         booking_id: { type: "string" },
         start_time: { type: "string", description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format." },
         staff_id: { type: "string" },
         group_id: { type: "string" }
       }, ["booking_id"]),
-      mutationCapability6("appointments.cancel", "Cancel an appointment by booking id.", {
+      mutationCapability8("appointments.cancel", "Cancel an appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"])
     ]
@@ -55378,7 +57929,7 @@ var zohoBookingsConnector = {
     }
   }
 };
-function readCapability6(name, description, properties, required = []) {
+function readCapability10(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -55387,7 +57938,7 @@ function readCapability6(name, description, properties, required = []) {
     requiredScopes: ["zohobookings.data.READ"]
   };
 }
-function mutationCapability6(name, description, properties, required) {
+function mutationCapability8(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -62731,6 +65282,393 @@ var metabaseConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/mysql.ts
+import { connect as createSocket, isIP as isIP7 } from "net";
+import {
+  createConnection as createMysqlConnection
+} from "mysql2/promise";
+var MAX_PARAMETERS = 1e3;
+var MAX_PARAMETER_BYTES = 10 * 1024 * 1024;
+var MAX_RESULT_ROWS2 = 1e4;
+var MAX_RESULT_BYTES4 = 10 * 1024 * 1024;
+var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+function createMySqlConnector(options = {}) {
+  const createConnection = options.createConnection ?? defaultCreateConnection;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "mysql",
+      displayName: "MySQL",
+      description: "Inspect schemas and run bounded parameterized reads or approved compare-and-swap writes against MySQL over verified TLS.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with host, port, user, password, optional database, and optional tlsCa. TLS and public network targets are mandatory."
+      },
+      defaultConsistencyModel: "authoritative",
+      category: "database",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        {
+          name: "mysql.databases.list",
+          class: "read",
+          description: "List databases visible to the connected MySQL user.",
+          parameters: emptySchema3()
+        },
+        {
+          name: "mysql.tables.list",
+          class: "read",
+          description: "List base tables and views in one database.",
+          parameters: {
+            type: "object",
+            properties: { database: identifierSchema2("Database name; defaults to the connection database.") },
+            additionalProperties: false
+          }
+        },
+        {
+          name: "mysql.tables.describe",
+          class: "read",
+          description: "Read columns, types, nullability, defaults, and keys for one table.",
+          parameters: {
+            type: "object",
+            properties: {
+              database: identifierSchema2("Database name; defaults to the connection database."),
+              table: identifierSchema2("Table name.")
+            },
+            required: ["table"],
+            additionalProperties: false
+          }
+        },
+        {
+          name: "mysql.query",
+          class: "read",
+          description: "Run one parameterized SELECT, SHOW, DESCRIBE, or EXPLAIN statement inside a read-only transaction.",
+          parameters: statementSchema(false)
+        },
+        {
+          name: "mysql.execute",
+          class: "mutation",
+          description: "Run one approved parameterized INSERT, UPDATE, DELETE, or REPLACE statement and commit only when the affected-row count matches the caller expectation.",
+          parameters: statementSchema(true),
+          cas: "optimistic-read-verify",
+          externalEffect: true
+        }
+      ]
+    },
+    async test(source) {
+      try {
+        await withConnection(source, createConnection, resolveHost, async (connection) => {
+          await connection.ping();
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage5(error) };
+      }
+    },
+    async executeRead(inv) {
+      const query2 = readQuery2(inv);
+      assertReadStatement(query2.statement);
+      const data4 = await withConnection(inv.source, createConnection, resolveHost, async (connection) => {
+        await executeStatement(connection, {
+          statement: "START TRANSACTION READ ONLY",
+          parameters: []
+        }, queryTimeout(inv.source));
+        try {
+          const [rows, fields] = await executeStatement(connection, query2, queryTimeout(inv.source));
+          if (!Array.isArray(rows)) throw new Error("MySQL read returned a non-row result");
+          return boundedResult3(rows, fields);
+        } finally {
+          await connection.rollback().catch(() => void 0);
+        }
+      });
+      return { data: data4, fetchedAt: Date.now() };
+    },
+    async executeMutation(inv) {
+      if (inv.capabilityName !== "mysql.execute") {
+        throw new Error(`Unknown MySQL mutation capability: ${inv.capabilityName}`);
+      }
+      const query2 = readStatementArgs(inv.args);
+      assertMutationStatement(query2.statement);
+      const expectedAffectedRows = readBoundedInteger(
+        inv.args.expectedAffectedRows,
+        -1,
+        0,
+        MAX_RESULT_ROWS2,
+        "expectedAffectedRows"
+      );
+      if (expectedAffectedRows < 0) throw new Error("expectedAffectedRows is required");
+      return withConnection(inv.source, createConnection, resolveHost, async (connection) => {
+        await connection.beginTransaction();
+        try {
+          const [result] = await executeStatement(connection, query2, queryTimeout(inv.source));
+          const affectedRows = readAffectedRows(result);
+          if (affectedRows !== expectedAffectedRows) {
+            await connection.rollback();
+            return {
+              status: "conflict",
+              alternatives: [],
+              currentState: { affectedRows },
+              message: `MySQL write affected ${affectedRows} rows; expected ${expectedAffectedRows}. The transaction was rolled back.`
+            };
+          }
+          await connection.commit();
+          return committedMutation(result, affectedRows);
+        } catch (error) {
+          await connection.rollback().catch(() => void 0);
+          throw error;
+        }
+      });
+    }
+  };
+}
+var mysqlConnector = createMySqlConnector();
+async function defaultCreateConnection(config) {
+  return createMysqlConnection(config);
+}
+async function withConnection(source, createConnection, resolveHost, run) {
+  const credentials = readCredentials7(source);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error("MySQL host did not resolve");
+  const address = addresses[0];
+  let connection;
+  try {
+    connection = await createConnection({
+      host: credentials.host,
+      port: credentials.port,
+      user: credentials.user,
+      password: credentials.password,
+      database: credentials.database,
+      connectTimeout: credentials.connectTimeoutMs,
+      multipleStatements: false,
+      namedPlaceholders: false,
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      decimalNumbers: false,
+      dateStrings: true,
+      timezone: "Z",
+      charset: "utf8mb4",
+      enableKeepAlive: true,
+      maxPreparedStatements: 100,
+      stream: () => createSocket({ host: address, port: credentials.port }),
+      ssl: {
+        ca: credentials.tlsCa,
+        minVersion: "TLSv1.2",
+        rejectUnauthorized: true,
+        verifyIdentity: true
+      }
+    });
+    return await run(connection);
+  } finally {
+    if (connection) await connection.end().catch(() => void 0);
+  }
+}
+function readCredentials7(source) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error("MySQL credential must be valid JSON");
+    }
+  } else {
+    throw new Error("MySQL requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("MySQL credential must be a JSON object");
+  const host = requiredCredentialString3(raw.host, "host", 253);
+  validateHost(host);
+  const user = requiredCredentialString3(raw.user ?? raw.username, "user", 128);
+  const password = requiredCredentialString3(raw.password, "password", 4096);
+  const database = readOptionalString(raw.database, "database");
+  if (database && database.length > 64) throw new Error("MySQL credential database exceeds 64 characters");
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > 1024 * 1024) {
+    throw new Error("MySQL credential tlsCa exceeds the 1 MiB limit");
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, 3306, 1, 65535, "port"),
+    user,
+    password,
+    database,
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    queryTimeoutMs: readBoundedInteger(raw.queryTimeoutMs, DEFAULT_QUERY_TIMEOUT_MS, 1e3, 6e4, "queryTimeoutMs")
+  };
+}
+function readQuery2(inv) {
+  if (inv.capabilityName === "mysql.databases.list") {
+    return {
+      statement: "SELECT SCHEMA_NAME AS databaseName, DEFAULT_CHARACTER_SET_NAME AS characterSet, DEFAULT_COLLATION_NAME AS collation FROM information_schema.SCHEMATA ORDER BY SCHEMA_NAME",
+      parameters: []
+    };
+  }
+  if (inv.capabilityName === "mysql.tables.list") {
+    const database = readDatabase(inv.args.database, inv.source);
+    return {
+      statement: "SELECT TABLE_NAME AS tableName, TABLE_TYPE AS tableType, ENGINE AS engine, TABLE_ROWS AS estimatedRows, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME",
+      parameters: [database]
+    };
+  }
+  if (inv.capabilityName === "mysql.tables.describe") {
+    const database = readDatabase(inv.args.database, inv.source);
+    const table = readIdentifier2(inv.args.table, "table");
+    return {
+      statement: "SELECT COLUMN_NAME AS columnName, ORDINAL_POSITION AS ordinalPosition, COLUMN_DEFAULT AS columnDefault, IS_NULLABLE AS isNullable, DATA_TYPE AS dataType, COLUMN_TYPE AS columnType, COLUMN_KEY AS columnKey, EXTRA AS extra FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION",
+      parameters: [database, table]
+    };
+  }
+  if (inv.capabilityName === "mysql.query") return readStatementArgs(inv.args);
+  throw new Error(`Unknown MySQL read capability: ${inv.capabilityName}`);
+}
+function readStatementArgs(args) {
+  const statement = requiredString7(args.statement, "statement");
+  if (Buffer.byteLength(statement, "utf8") > 1024 * 1024) throw new Error("statement exceeds the 1 MiB limit");
+  const parameters = args.parameters === void 0 ? [] : args.parameters;
+  if (!Array.isArray(parameters) || parameters.length > MAX_PARAMETERS) {
+    throw new Error(`parameters must be an array with at most ${MAX_PARAMETERS} entries`);
+  }
+  for (const [index, value] of parameters.entries()) {
+    if (value !== null && !["string", "number", "boolean"].includes(typeof value)) {
+      throw new Error(`parameters[${index}] must be a JSON scalar or null`);
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error(`parameters[${index}] must be finite`);
+    }
+  }
+  if (Buffer.byteLength(JSON.stringify(parameters), "utf8") > MAX_PARAMETER_BYTES) {
+    throw new Error(`parameters exceed the ${MAX_PARAMETER_BYTES}-byte limit`);
+  }
+  return { statement, parameters };
+}
+function assertReadStatement(statement) {
+  const keyword = leadingKeyword(statement);
+  if (!["SELECT", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "WITH"].includes(keyword)) {
+    throw new Error("mysql.query accepts only SELECT, SHOW, DESCRIBE, or EXPLAIN statements");
+  }
+  if (/\b(?:INTO\s+(?:OUTFILE|DUMPFILE)|LOAD_FILE\s*\(|GET_LOCK\s*\(|RELEASE_LOCK\s*\(|SLEEP\s*\(|BENCHMARK\s*\(|FOR\s+UPDATE|LOCK\s+IN\s+SHARE\s+MODE)\b/i.test(statement)) {
+    throw new Error("mysql.query rejects file, lock, and delay side effects");
+  }
+}
+function assertMutationStatement(statement) {
+  const keyword = leadingKeyword(statement);
+  if (!["INSERT", "UPDATE", "DELETE", "REPLACE"].includes(keyword)) {
+    throw new Error("mysql.execute accepts only INSERT, UPDATE, DELETE, or REPLACE statements");
+  }
+}
+function leadingKeyword(statement) {
+  const withoutComments = statement.replace(/^\s*(?:--[^\n]*(?:\n|$)|#[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/\s*)*/u, "").trimStart();
+  return /^[A-Za-z]+/.exec(withoutComments)?.[0]?.toUpperCase() ?? "";
+}
+async function executeStatement(connection, query2, timeout) {
+  return connection.execute({ sql: query2.statement, values: query2.parameters, timeout });
+}
+function boundedResult3(rows, fields) {
+  if (rows.length > MAX_RESULT_ROWS2) throw new Error(`MySQL result exceeds ${MAX_RESULT_ROWS2} rows`);
+  const data4 = {
+    rows: jsonSafe(rows),
+    columns: fields.map((field) => ({
+      name: field.name,
+      table: field.table,
+      database: field.schema,
+      type: field.type
+    })),
+    rowCount: rows.length
+  };
+  const serialized = JSON.stringify(data4);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES4) {
+    throw new Error(`MySQL result exceeds the ${MAX_RESULT_BYTES4}-byte limit`);
+  }
+  return data4;
+}
+function readAffectedRows(result) {
+  if (!isPlainRecord(result) || !Number.isInteger(result.affectedRows) || result.affectedRows < 0) {
+    throw new Error("MySQL mutation did not return an affected-row count");
+  }
+  return result.affectedRows;
+}
+function committedMutation(result, affectedRows) {
+  const header2 = result;
+  const rawInsertId = header2.insertId;
+  const insertId = typeof rawInsertId === "number" && Number.isSafeInteger(rawInsertId) ? rawInsertId : typeof rawInsertId === "string" ? rawInsertId : void 0;
+  return {
+    status: "committed",
+    data: jsonSafe({
+      affectedRows,
+      changedRows: header2.changedRows,
+      insertId,
+      warningStatus: header2.warningStatus
+    }),
+    committedAt: Date.now(),
+    idempotentReplay: false
+  };
+}
+function readDatabase(value, source) {
+  const explicit = value === void 0 ? void 0 : readIdentifier2(value, "database");
+  if (explicit) return explicit;
+  const credentials = readCredentials7(source);
+  if (!credentials.database) throw new Error("database is required when the connection has no default database");
+  return credentials.database;
+}
+function queryTimeout(source) {
+  return readCredentials7(source).queryTimeoutMs;
+}
+function requiredString7(value, label) {
+  const parsed = readOptionalString(value, label);
+  if (!parsed) throw new Error(`${label} is required`);
+  return parsed;
+}
+function requiredCredentialString3(value, label, maxLength) {
+  const parsed = readOptionalString(value, label);
+  if (!parsed) throw new Error(`MySQL credential ${label} is required`);
+  if (parsed.length > maxLength) throw new Error(`MySQL credential ${label} exceeds ${maxLength} characters`);
+  return parsed;
+}
+function readIdentifier2(value, label) {
+  const parsed = requiredString7(value, label);
+  if (parsed.length > 64) throw new Error(`${label} exceeds 64 characters`);
+  return parsed;
+}
+function validateHost(host) {
+  const normalized = host.toLowerCase();
+  if (host.length > 253 || host.includes("://") || /[\s/@]/.test(host) || normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || isIP7(host) === 0 && !/^[A-Za-z0-9.-]+$/.test(host) || host.split(".").some((label) => !label || label.startsWith("-") || label.endsWith("-"))) {
+    throw new Error("MySQL host must be a public hostname or IP address without a scheme");
+  }
+}
+function emptySchema3() {
+  return { type: "object", properties: {}, additionalProperties: false };
+}
+function identifierSchema2(description) {
+  return { type: "string", minLength: 1, maxLength: 64, description };
+}
+function statementSchema(mutation) {
+  const properties = {
+    statement: { type: "string", minLength: 1, maxLength: 1024 * 1024 },
+    parameters: {
+      type: "array",
+      maxItems: MAX_PARAMETERS,
+      items: { type: ["string", "number", "boolean", "null"] },
+      description: "Values bound to ? placeholders in order."
+    }
+  };
+  if (mutation) {
+    properties.expectedAffectedRows = {
+      type: "integer",
+      minimum: 0,
+      maximum: MAX_RESULT_ROWS2,
+      description: "Commit only when MySQL reports exactly this many affected rows."
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required: mutation ? ["statement", "expectedAffectedRows"] : ["statement"],
+    additionalProperties: false
+  };
+}
+function safeErrorMessage5(error) {
+  return error instanceof Error && error.message ? error.message : "MySQL connection failed";
+}
+
 // src/connectors/adapters/segment.ts
 var segmentConnector = declarativeRestConnector({
   kind: "segment",
@@ -63875,6 +66813,49 @@ var hunterConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/neverbounce.ts
+var neverbounceConnector = declarativeRestConnector({
+  kind: "neverbounce",
+  displayName: "NeverBounce",
+  description: "Verify email deliverability with the NeverBounce API.",
+  auth: {
+    kind: "api-key",
+    hint: "NeverBounce API key from Apps > API in the NeverBounce dashboard."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.neverbounce.com/v4.2",
+  credentialPlacement: { kind: "query", parameter: "key" },
+  test: {
+    method: "GET",
+    path: "/account/info"
+  },
+  capabilities: [
+    {
+      name: "verify.email.address",
+      class: "mutation",
+      description: "Verify one email address and return deliverability status such as valid, invalid, disposable, catch-all, or unknown.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: {
+            type: "string",
+            description: "Email address to verify."
+          }
+        },
+        required: ["email"]
+      },
+      request: {
+        method: "GET",
+        path: "/single/check",
+        query: { email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
 // src/connectors/adapters/theirstack.ts
 var theirstackConnector = declarativeRestConnector({
   kind: "theirstack",
@@ -64226,6 +67207,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => digitalOceanConnector, {}),
   defineFactoryAdapter(() => clicksendConnector, {}),
   defineFactoryAdapter(() => metabaseConnector, {}),
+  defineFactoryAdapter(() => mysqlConnector, {}),
   defineFactoryAdapter(
     () => microsoftDynamics365BusinessCentralConnector,
     microsoftOAuthEnvMap
@@ -64284,6 +67266,12 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => httpConnector, {}),
   defineFactoryAdapter(() => rssConnector, {}),
   defineFactoryAdapter(() => kafkaConnector, {}),
+  defineFactoryAdapter(() => duckdbConnector, {}),
+  defineFactoryAdapter(() => rabbitMqConnector, {}),
+  defineFactoryAdapter(() => redisConnector, {}),
+  defineFactoryAdapter(() => redshiftConnector, {}),
+  defineFactoryAdapter(() => postgresConnector, {}),
+  defineFactoryAdapter(() => mongodbConnector, {}),
   defineFactoryAdapter(() => csvFilesConnector, {}),
   defineFactoryAdapter(() => excelFilesConnector, {}),
   defineFactoryAdapter(() => parquetFilesConnector, {}),
@@ -64352,14 +67340,15 @@ var CONNECTOR_ADAPTER_FACTORIES = [
     clientId: "LINEAR_OAUTH_CLIENT_ID",
     clientSecret: "LINEAR_OAUTH_CLIENT_SECRET"
   }),
+  defineFactoryAdapter(() => miroConnector, {
+    clientId: "MIRO_OAUTH_CLIENT_ID",
+    clientSecret: "MIRO_OAUTH_CLIENT_SECRET"
+  }),
   defineFactoryAdapter(() => mondayConnector, {
     clientId: "MONDAY_OAUTH_CLIENT_ID",
     clientSecret: "MONDAY_OAUTH_CLIENT_SECRET"
   }),
-  defineFactoryAdapter(() => clickupConnector, {
-    clientId: "CLICKUP_OAUTH_CLIENT_ID",
-    clientSecret: "CLICKUP_OAUTH_CLIENT_SECRET"
-  }),
+  defineFactoryAdapter(() => clickupConnector, {}),
   defineFactoryAdapter(() => basecampConnector, {
     clientId: "BASECAMP_OAUTH_CLIENT_ID",
     clientSecret: "BASECAMP_OAUTH_CLIENT_SECRET"
@@ -64581,6 +67570,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => builtwithConnector, {}),
   defineFactoryAdapter(() => fullenrichConnector, {}),
   defineFactoryAdapter(() => hunterConnector, {}),
+  defineFactoryAdapter(() => neverbounceConnector, {}),
   defineFactoryAdapter(() => theirstackConnector, {}),
   defineFactoryAdapter(() => zerobounceConnector, {})
 ];
@@ -70966,677 +73956,6 @@ var figjamConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/miro.ts
-var miroConnector = declarativeRestConnector({
-  kind: "miro",
-  displayName: "Miro",
-  description: "Read and edit Miro boards: list and search boards, read board items (sticky notes, shapes, text, cards, images, frames, connectors), create and update items, and post board content back into the source of truth.",
-  auth: {
-    kind: "oauth2",
-    authorizationUrl: "https://miro.com/oauth/authorize",
-    tokenUrl: "https://api.miro.com/v1/oauth/token",
-    scopes: [
-      "boards:read",
-      "boards:write",
-      "identity:read",
-      "team:read",
-      "organizations:read"
-    ],
-    clientIdEnv: "MIRO_OAUTH_CLIENT_ID",
-    clientSecretEnv: "MIRO_OAUTH_CLIENT_SECRET"
-  },
-  category: "doc",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "https://api.miro.com",
-  defaultHeaders: { accept: "application/json" },
-  // GET /v2/me returns the authenticated user — Miro's documented health probe.
-  test: { method: "GET", path: "/v2/me" },
-  capabilities: [
-    {
-      name: "me.get",
-      class: "read",
-      description: "Return the authenticated Miro user.",
-      parameters: { type: "object", properties: {} },
-      request: { method: "GET", path: "/v2/me" },
-      requiredScopes: ["identity:read"]
-    },
-    {
-      name: "boards.list",
-      class: "read",
-      description: "List boards accessible to the authenticated user. Supports cursor pagination via `cursor` and team / sort filters.",
-      parameters: {
-        type: "object",
-        properties: {
-          team_id: { type: "string", description: "Filter to a single team id." },
-          query: { type: "string", description: "Free-text board name filter." },
-          owner: { type: "string", description: "Filter by owner user id." },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 },
-          sort: {
-            type: "string",
-            enum: ["default", "last_modified", "last_opened", "last_created", "alphabetically"]
-          }
-        }
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards",
-        query: {
-          team_id: "{team_id}",
-          query: "{query}",
-          owner: "{owner}",
-          limit: "{limit}",
-          offset: "{offset}",
-          sort: "{sort}"
-        }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "boards.get",
-      class: "read",
-      description: "Fetch a single Miro board by id.",
-      parameters: {
-        type: "object",
-        properties: { board_id: { type: "string" } },
-        required: ["board_id"]
-      },
-      request: { method: "GET", path: "/v2/boards/{board_id}" },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "boards.members.list",
-      class: "read",
-      description: "List members (collaborators) of a Miro board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/members",
-        query: { limit: "{limit}", offset: "{offset}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "items.list",
-      class: "read",
-      description: "List all items on a board, optionally filtered by item type (sticky_note, text, shape, card, image, frame, connector, embed, app_card, document).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          type: {
-            type: "string",
-            enum: [
-              "sticky_note",
-              "text",
-              "shape",
-              "card",
-              "image",
-              "frame",
-              "connector",
-              "embed",
-              "app_card",
-              "document",
-              "preview"
-            ]
-          },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          cursor: { type: "string" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/items",
-        query: { type: "{type}", limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "items.get",
-      class: "read",
-      description: "Fetch a single board item by id.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: { method: "GET", path: "/v2/boards/{board_id}/items/{item_id}" },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "connectors.list",
-      class: "read",
-      description: "List connector lines on a board (arrows / lines between items).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          cursor: { type: "string" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/connectors",
-        query: { limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "tags.list",
-      class: "read",
-      description: "List tags defined on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/tags",
-        query: { limit: "{limit}", offset: "{offset}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "organizations.get",
-      class: "read",
-      description: "Read an organization (Enterprise plan).",
-      parameters: {
-        type: "object",
-        properties: { org_id: { type: "string" } },
-        required: ["org_id"]
-      },
-      request: { method: "GET", path: "/v2/orgs/{org_id}" },
-      requiredScopes: ["organizations:read"]
-    },
-    {
-      name: "organizations.teams.list",
-      class: "read",
-      description: "List teams in an organization (Enterprise plan).",
-      parameters: {
-        type: "object",
-        properties: {
-          org_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 100 },
-          cursor: { type: "string" }
-        },
-        required: ["org_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/orgs/{org_id}/teams",
-        query: { limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["organizations:read"]
-    },
-    {
-      name: "teams.get",
-      class: "read",
-      description: "Fetch a single team by id.",
-      parameters: {
-        type: "object",
-        properties: {
-          org_id: { type: "string" },
-          team_id: { type: "string" }
-        },
-        required: ["org_id", "team_id"]
-      },
-      request: { method: "GET", path: "/v2/orgs/{org_id}/teams/{team_id}" },
-      requiredScopes: ["team:read"]
-    },
-    {
-      name: "boards.create",
-      class: "mutation",
-      description: "Create a new Miro board. Accepts an optional name, description, team_id, and sharing policy. Returns the new board id used by every items.* endpoint.",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", maxLength: 60 },
-          description: { type: "string", maxLength: 300 },
-          team_id: { type: "string" },
-          policy: {
-            type: "object",
-            description: "Permissions + sharing policy. See https://developers.miro.com/reference/create-board for the full PolicyChange shape."
-          }
-        },
-        required: ["name"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards",
-        body: {
-          name: "{name}",
-          description: "{description}",
-          teamId: "{team_id}",
-          policy: "{policy}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.update",
-      class: "mutation",
-      description: "Update a Miro board (name, description, team, or sharing policy).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          name: { type: "string", maxLength: 60 },
-          description: { type: "string", maxLength: 300 },
-          team_id: { type: "string" },
-          policy: { type: "object" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "PATCH",
-        path: "/v2/boards/{board_id}",
-        body: {
-          name: "{name}",
-          description: "{description}",
-          teamId: "{team_id}",
-          policy: "{policy}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.delete",
-      class: "mutation",
-      description: "Delete a Miro board (irreversible).",
-      parameters: {
-        type: "object",
-        properties: { board_id: { type: "string" } },
-        required: ["board_id"]
-      },
-      request: { method: "DELETE", path: "/v2/boards/{board_id}" },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "sticky_notes.create",
-      class: "mutation",
-      description: "Create a sticky note on a board. `data.content` accepts plain text; `style.fillColor` is a Miro sticky-note color keyword (e.g. yellow, light_yellow, pink).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              content: { type: "string" },
-              shape: { type: "string", enum: ["square", "rectangle"] }
-            },
-            required: ["content"]
-          },
-          style: {
-            type: "object",
-            properties: {
-              fillColor: { type: "string" },
-              textAlign: { type: "string", enum: ["left", "center", "right"] },
-              textAlignVertical: { type: "string", enum: ["top", "middle", "bottom"] }
-            }
-          },
-          position: {
-            type: "object",
-            properties: {
-              x: { type: "number" },
-              y: { type: "number" },
-              origin: { type: "string", enum: ["center"] }
-            }
-          },
-          geometry: {
-            type: "object",
-            properties: {
-              width: { type: "number" },
-              height: { type: "number" }
-            }
-          },
-          parent: {
-            type: "object",
-            description: "Attach the sticky note to a frame: { id: <frame_item_id> }.",
-            properties: { id: { type: "string" } }
-          }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/sticky_notes",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "sticky_notes.update",
-      class: "mutation",
-      description: "Update a sticky note (content, style, position, geometry, or parent frame).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" },
-          data: { type: "object" },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: {
-        method: "PATCH",
-        path: "/v2/boards/{board_id}/sticky_notes/{item_id}",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "text.create",
-      class: "mutation",
-      description: "Create a text item on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: { content: { type: "string" } },
-            required: ["content"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/texts",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "shapes.create",
-      class: "mutation",
-      description: "Create a shape item on a board. `data.shape` selects the geometric primitive (rectangle, round_rectangle, circle, triangle, rhombus, etc.).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              shape: {
-                type: "string",
-                description: "Miro shape kind; full enum at https://developers.miro.com/reference/create-shape-item."
-              },
-              content: { type: "string" }
-            },
-            required: ["shape"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/shapes",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "cards.create",
-      class: "mutation",
-      description: "Create a card item (title + description + assignee + due-date) on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              description: { type: "string" },
-              dueDate: { type: "string", format: "date-time" },
-              assigneeId: { type: "string" }
-            },
-            required: ["title"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/cards",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "frames.create",
-      class: "mutation",
-      description: "Create a frame on a board. Frames group items; child items can be attached via `parent.id` on item creation.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              format: { type: "string", enum: ["custom"] },
-              type: { type: "string", enum: ["freeform"] }
-            }
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/frames",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "images.create.by_url",
-      class: "mutation",
-      description: "Create an image item from a public URL (Miro fetches the image server-side).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              url: { type: "string", format: "uri" },
-              title: { type: "string" }
-            },
-            required: ["url"]
-          },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/images",
-        body: {
-          data: "{data}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "connectors.create",
-      class: "mutation",
-      description: "Create a connector line between two items on the board. `startItem.id` and `endItem.id` reference existing item ids.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          startItem: {
-            type: "object",
-            properties: { id: { type: "string" } },
-            required: ["id"]
-          },
-          endItem: {
-            type: "object",
-            properties: { id: { type: "string" } },
-            required: ["id"]
-          },
-          captions: {
-            type: "array",
-            items: { type: "object", properties: { content: { type: "string" } } }
-          },
-          style: { type: "object" },
-          shape: { type: "string", enum: ["straight", "elbowed", "curved"] }
-        },
-        required: ["board_id", "startItem", "endItem"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/connectors",
-        body: {
-          startItem: "{startItem}",
-          endItem: "{endItem}",
-          captions: "{captions}",
-          style: "{style}",
-          shape: "{shape}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "items.delete",
-      class: "mutation",
-      description: "Delete an item from a board (works across all item types).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: { method: "DELETE", path: "/v2/boards/{board_id}/items/{item_id}" },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.share",
-      class: "mutation",
-      description: "Invite users to a Miro board by email. Roles: viewer, commenter, editor, coowner.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          emails: { type: "array", items: { type: "string", format: "email" } },
-          role: {
-            type: "string",
-            enum: ["viewer", "commenter", "editor", "coowner"]
-          },
-          message: { type: "string" }
-        },
-        required: ["board_id", "emails", "role"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/members",
-        body: {
-          emails: "{emails}",
-          role: "{role}",
-          message: "{message}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    }
-  ]
-});
-
 // src/connectors/adapters/canva.ts
 var canvaConnector = declarativeRestConnector({
   kind: "canva",
@@ -119253,309 +121572,6 @@ var mindStudioConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/mongodb.ts
-var mongodbConnector = declarativeRestConnector({
-  kind: "mongodb",
-  displayName: "MongoDB",
-  description: "Query, insert, update, and delete MongoDB documents via the Data API.",
-  auth: { kind: "api-key", hint: "MongoDB Data API key." },
-  category: "database",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "https://data.mongodb-api.com/app",
-  test: { method: "POST", path: "/{appId}/endpoint/data/v1/action/findOne" },
-  capabilities: [
-    {
-      name: "documents.find",
-      class: "read",
-      description: "Query documents in a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: 'Data source name (e.g., "Cluster0").' },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: 'Query filter (e.g., { "status": "active" }).' },
-          projection: { type: "object", description: "Fields to include/exclude." },
-          sort: { type: "object", description: "Sort criteria." },
-          limit: { type: "integer", description: "Maximum documents to return." },
-          skip: { type: "integer", description: "Documents to skip." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/find",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          projection: "{projection}",
-          sort: "{sort}",
-          limit: "{limit}",
-          skip: "{skip}"
-        }
-      }
-    },
-    {
-      name: "documents.findOne",
-      class: "read",
-      description: "Find a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          projection: { type: "object", description: "Fields to include/exclude." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/findOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          projection: "{projection}"
-        }
-      }
-    },
-    {
-      name: "documents.insertOne",
-      class: "mutation",
-      description: "Insert a single document into a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          document: { type: "object", description: "Document to insert." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "document"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/insertOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          document: "{document}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.insertMany",
-      class: "mutation",
-      description: "Insert multiple documents into a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          documents: { type: "array", items: { type: "object" }, description: "Array of documents to insert." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "documents"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/insertMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          documents: "{documents}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.updateOne",
-      class: "mutation",
-      description: "Update a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          update: { type: "object", description: 'Update operations (e.g., { "$set": { "status": "inactive" } }).' },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "update"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/updateOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          update: "{update}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "optimistic-read-verify"
-    },
-    {
-      name: "documents.updateMany",
-      class: "mutation",
-      description: "Update multiple documents matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          update: { type: "object", description: "Update operations." },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "update"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/updateMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          update: "{update}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "optimistic-read-verify"
-    },
-    {
-      name: "documents.replaceOne",
-      class: "mutation",
-      description: "Replace a single document entirely.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          replacement: { type: "object", description: "Replacement document." },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "replacement"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/replaceOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          replacement: "{replacement}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "etag-if-match"
-    },
-    {
-      name: "documents.deleteOne",
-      class: "mutation",
-      description: "Delete a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/deleteOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.deleteMany",
-      class: "mutation",
-      description: "Delete multiple documents matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/deleteMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.aggregate",
-      class: "read",
-      description: "Run an aggregation pipeline over a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          pipeline: { type: "array", items: { type: "object" }, description: "Aggregation stages." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "pipeline"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/aggregate",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          pipeline: "{pipeline}"
-        }
-      }
-    }
-  ]
-});
-
 // src/connectors/adapters/nifty.ts
 var niftyConnector = declarativeRestConnector({
   kind: "nifty",
@@ -124137,45 +126153,6 @@ var pollybotAiConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/postgres.ts
-var postgresConnector = declarativeRestConnector({
-  kind: "postgres",
-  displayName: "PostgreSQL",
-  description: "Execute queries and monitor PostgreSQL databases.",
-  auth: { kind: "api-key", hint: "PostgreSQL connection credentials." },
-  category: "database",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "postgresql://",
-  test: { method: "GET", path: "/" },
-  capabilities: [
-    {
-      name: "query.execute",
-      class: "read",
-      description: "Execute a SQL query against the database.",
-      parameters: {
-        type: "object",
-        properties: {
-          host: { type: "string", description: "PostgreSQL server hostname" },
-          port: { type: "integer", description: "PostgreSQL server port" },
-          user: { type: "string", description: "Database user" },
-          password: { type: "string", description: "Database password" },
-          database: { type: "string", description: "Database name" },
-          query: { type: "string", description: "SQL query to execute" },
-          args: { type: "array", description: "Query arguments for parameterized queries" },
-          query_timeout: { type: "integer", description: "Query timeout in milliseconds" },
-          connection_timeout_ms: { type: "integer", description: "Connection timeout in milliseconds" },
-          application_name: { type: "string", description: "Application name for the connection" },
-          enable_ssl: { type: "boolean", description: "Enable SSL connection" },
-          reject_unauthorized: { type: "boolean", description: "Verify server certificate" },
-          certificate: { type: "string", description: "CA certificate for SSL verification" }
-        },
-        required: ["host", "port", "user", "password", "database", "query"]
-      },
-      request: { method: "POST", path: "/query", body: "{query}" }
-    }
-  ]
-});
-
 // src/connectors/adapters/postiz.ts
 var postizConnector = declarativeRestConnector({
   kind: "postiz",
@@ -144139,6 +146116,7 @@ export {
   deepgramConnector,
   detectingAiConnector,
   digitalPilotConnector,
+  duckdbConnector,
   docsbotConnector,
   dripConnector,
   echowinConnector,
@@ -144269,7 +146247,10 @@ export {
   mastodonConnector,
   meetgeekAiConnector,
   mollieConnector,
+  miroConnector,
   mondayConnector,
+  createMongoDbConnector,
+  mongodbConnector,
   mycaseConnector,
   notionConnector,
   notion,
@@ -144287,6 +146268,14 @@ export {
   pipedriveConnector,
   parquetFilesConnector,
   quickbooksConnector,
+  createRabbitMqConnector,
+  rabbitMqConnector,
+  createRedisConnector,
+  redisConnector,
+  createRedshiftConnector,
+  redshiftConnector,
+  createPostgresConnector,
+  postgresConnector,
   recallAiConnector,
   rampConnector,
   ringcentralConnector,
@@ -144354,11 +146343,14 @@ export {
   googleBigqueryConnector,
   hightouchConnector,
   metabaseConnector,
+  createMySqlConnector,
+  mysqlConnector,
   segmentConnector,
   supabaseConnector,
   builtwithConnector,
   fullenrichConnector,
   hunterConnector,
+  neverbounceConnector,
   theirstackConnector,
   zerobounceConnector,
   CONNECTOR_ADAPTER_FACTORIES,
@@ -144384,7 +146376,6 @@ export {
   sanityConnector,
   figmaConnector,
   figjamConnector,
-  miroConnector,
   canvaConnector,
   adobeCreativeCloudConnector,
   clioConnector,
@@ -144604,7 +146595,6 @@ export {
   mailchainConnector,
   medullarConnector,
   mindStudioConnector,
-  mongodbConnector,
   niftyConnector,
   nocodbConnector,
   ntfyConnector,
@@ -144630,7 +146620,6 @@ export {
   plausibleConnector,
   pocketbaseConnector,
   pollybotAiConnector,
-  postgresConnector,
   postizConnector,
   posthogConnector,
   predictLeadsConnector,
@@ -144745,4 +146734,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-5LDZLVKP.js.map
+//# sourceMappingURL=chunk-R5GQB3SQ.js.map