@tangle-network/agent-integrations 0.53.28 → 0.53.30

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

@@ -181,10 +181,13 @@ __export(adapters_exports, {
   copperConnector: () => copperConnector,
   copyAiConnector: () => copyAiConnector,
   couchbaseConnector: () => couchbaseConnector,
+  createKafkaConnector: () => createKafkaConnector,
+  createSftpConnector: () => createSftpConnector,
   createTangleIdentityClient: () => createTangleIdentityClient,
   crispConnector: () => crispConnector,
   crustdataConnector: () => crustdataConnector,
   cryptolensConnector: () => cryptolensConnector,
+  csvFilesConnector: () => csvFilesConnector,
   customerIoConnector: () => customerIoConnector,
   customgptConnector: () => customgptConnector,
   dappierConnector: () => dappierConnector,
@@ -230,6 +233,7 @@ __export(adapters_exports, {
   etsyConnector: () => etsyConnector,
   everhourConnector: () => everhourConnector,
   exaConnector: () => exaConnector,
+  excelFilesConnector: () => excelFilesConnector,
   facebookLeadsConnector: () => facebookLeadsConnector,
   facebookPagesConnector: () => facebookPagesConnector,
   factorsAiConnector: () => factorsAiConnector,
@@ -349,6 +353,7 @@ __export(adapters_exports, {
   jotformConnector: () => jotformConnector,
   justInvoiceConnector: () => justInvoiceConnector,
   justcallConnector: () => justcallConnector,
+  kafkaConnector: () => kafkaConnector,
   kallabotAiConnector: () => kallabotAiConnector,
   kapsoConnector: () => kapsoConnector,
   kimaiConnector: () => kimaiConnector,
@@ -466,6 +471,7 @@ __export(adapters_exports, {
   pagerdutyConnector: () => pagerdutyConnector,
   pandadoc: () => pandadoc,
   paperformConnector: () => paperformConnector,
+  parquetFilesConnector: () => parquetFilesConnector,
   parseurConnector: () => parseurConnector,
   pastefyConnector: () => pastefyConnector,
   paychexConnector: () => paychexConnector,
@@ -494,6 +500,7 @@ __export(adapters_exports, {
   predictLeadsConnector: () => predictLeadsConnector,
   productboardConnector: () => productboardConnector,
   proxycurlConnector: () => proxycurlConnector,
+  publicKafkaSocketFactory: () => publicKafkaSocketFactory,
   pushbulletConnector: () => pushbulletConnector,
   pushoverConnector: () => pushoverConnector,
   qawafelConnector: () => qawafelConnector,
@@ -542,6 +549,7 @@ __export(adapters_exports, {
   serperConnector: () => serperConnector,
   serpstatConnector: () => serpstatConnector,
   serviceNowConnector: () => serviceNowConnector,
+  sftpConnector: () => sftpConnector,
   sharepoint: () => sharepoint,
   shippoConnector: () => shippoConnector,
   shopifyConnector: () => shopifyConnector,
@@ -4446,6 +4454,233 @@ var cartloomConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/csv-files.ts
+import { parse } from "csv-parse/sync";
+import { stringify } from "csv-stringify/sync";
+
+// src/connectors/adapters/file-payload.ts
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_RECORDS = 1e4;
+function readBase64File(value, label = "fileBase64") {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label} is required`);
+  }
+  if (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+    throw new Error(`${label} must be canonical base64`);
+  }
+  const file = Buffer.from(value, "base64");
+  if (file.byteLength > MAX_FILE_BYTES) {
+    throw new Error(`${label} exceeds the ${MAX_FILE_BYTES}-byte limit`);
+  }
+  return file;
+}
+function encodeFile(file) {
+  if (file.byteLength > MAX_FILE_BYTES) {
+    throw new Error(`generated file exceeds the ${MAX_FILE_BYTES}-byte limit`);
+  }
+  return {
+    fileBase64: Buffer.from(file).toString("base64"),
+    byteLength: file.byteLength
+  };
+}
+function readRecords(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("records must be a non-empty array of objects");
+  }
+  if (value.length > MAX_RECORDS) {
+    throw new Error(`records exceeds the ${MAX_RECORDS}-record limit`);
+  }
+  assertStructuredInputSize(value, "records");
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) {
+      throw new Error(`records[${index}] must be an object`);
+    }
+    return entry;
+  });
+}
+function readRows(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("rows must be a non-empty array of arrays");
+  }
+  if (value.length > MAX_RECORDS) {
+    throw new Error(`rows exceeds the ${MAX_RECORDS}-row limit`);
+  }
+  assertStructuredInputSize(value, "rows");
+  return value.map((entry, index) => {
+    if (!Array.isArray(entry)) throw new Error(`rows[${index}] must be an array`);
+    return entry;
+  });
+}
+function readOptionalString(value, label) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${label} must be a non-empty string`);
+  return value;
+}
+function readBoolean(value, fallback, label) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
+  return value;
+}
+function readBoundedInteger(value, fallback, minimum, maximum, label) {
+  if (value === void 0 || value === null) return fallback;
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${label} must be an integer from ${minimum} through ${maximum}`);
+  }
+  return value;
+}
+function jsonSafe(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("base64");
+  if (Array.isArray(value)) return value.map(jsonSafe);
+  if (isPlainRecord(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, jsonSafe(entry)]));
+  }
+  return value;
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function assertStructuredInputSize(value, label) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value, (_key, entry) => typeof entry === "bigint" ? entry.toString() : entry);
+  } catch {
+    throw new Error(`${label} must be JSON-serializable`);
+  }
+  if (Buffer.byteLength(serialized, "utf8") > MAX_FILE_BYTES) {
+    throw new Error(`${label} exceeds the ${MAX_FILE_BYTES}-byte input limit`);
+  }
+}
+
+// src/connectors/adapters/csv-files.ts
+var MAX_COLUMNS = 256;
+var MAX_RECORD_SIZE = 1024 * 1024;
+var csvFilesConnector = {
+  manifest: {
+    kind: "csv-files",
+    displayName: "CSV Files",
+    description: "Parse bounded CSV files into records and create CSV files from structured records.",
+    auth: { kind: "none" },
+    defaultConsistencyModel: "advisory",
+    category: "database",
+    capabilities: [
+      {
+        name: "csv.parse",
+        class: "read",
+        description: "Parse a base64-encoded CSV file into object records or row arrays.",
+        parameters: {
+          type: "object",
+          properties: {
+            fileBase64: { type: "string", description: "CSV file content encoded as canonical base64." },
+            delimiter: { type: "string", minLength: 1, maxLength: 1, default: "," },
+            header: { type: "boolean", default: true }
+          },
+          required: ["fileBase64"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "csv.create",
+        class: "mutation",
+        description: "Create a base64-encoded CSV file from object records.",
+        parameters: {
+          type: "object",
+          properties: {
+            records: { type: "array", minItems: 1, maxItems: MAX_RECORDS, items: { type: "object" } },
+            columns: { type: "array", maxItems: MAX_COLUMNS, items: { type: "string", minLength: 1 } },
+            delimiter: { type: "string", minLength: 1, maxLength: 1, default: "," },
+            header: { type: "boolean", default: true }
+          },
+          required: ["records"],
+          additionalProperties: false
+        },
+        cas: "none",
+        externalEffect: true
+      }
+    ]
+  },
+  async executeRead({ capabilityName, args }) {
+    if (capabilityName !== "csv.parse") throw new Error(`Unknown CSV capability: ${capabilityName}`);
+    const file = readBase64File(args.fileBase64);
+    const delimiter = readDelimiter(args.delimiter);
+    const header2 = readBoolean(args.header, true, "header");
+    let recordCount = 0;
+    const records = parse(file, {
+      bom: true,
+      columns: header2,
+      delimiter,
+      max_record_size: MAX_RECORD_SIZE,
+      skip_empty_lines: true,
+      on_record(record) {
+        recordCount += 1;
+        if (recordCount > MAX_RECORDS) throw new Error(`CSV exceeds the ${MAX_RECORDS}-record limit`);
+        return record;
+      }
+    });
+    if (records.some(
+      (record) => header2 ? Object.keys(record).length > MAX_COLUMNS : Array.isArray(record) && record.length > MAX_COLUMNS
+    )) {
+      throw new Error(`CSV exceeds the ${MAX_COLUMNS}-column limit`);
+    }
+    return {
+      data: { records, recordCount: records.length, header: header2 },
+      fetchedAt: Date.now()
+    };
+  },
+  async executeMutation({ capabilityName, args }) {
+    if (capabilityName !== "csv.create") throw new Error(`Unknown CSV capability: ${capabilityName}`);
+    const records = readRecords(args.records);
+    const columns = readColumns(args.columns, records);
+    const delimiter = readDelimiter(args.delimiter);
+    const header2 = readBoolean(args.header, true, "header");
+    const csv = stringify(
+      records.map((record) => Object.fromEntries(columns.map((column) => [column, csvValue(record[column])]))),
+      { columns, delimiter, header: header2 }
+    );
+    return {
+      status: "committed",
+      data: { ...encodeFile(Buffer.from(csv, "utf8")), text: csv, columns, recordCount: records.length },
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  async test() {
+    return { ok: true };
+  }
+};
+function readDelimiter(value) {
+  const delimiter = readOptionalString(value, "delimiter") ?? ",";
+  if ([...delimiter].length !== 1 || delimiter === "\r" || delimiter === "\n" || delimiter === '"') {
+    throw new Error("delimiter must be one non-newline character other than a double quote");
+  }
+  return delimiter;
+}
+function readColumns(value, records) {
+  const columns = value === void 0 ? [...new Set(records.flatMap((record) => Object.keys(record)))] : value;
+  if (!Array.isArray(columns) || columns.length === 0 || columns.length > MAX_COLUMNS) {
+    throw new Error(`columns must contain 1 through ${MAX_COLUMNS} names`);
+  }
+  const parsed = columns.map((column, index) => {
+    if (typeof column !== "string" || column.length === 0) throw new Error(`columns[${index}] must be a non-empty string`);
+    return column;
+  });
+  if (new Set(parsed).size !== parsed.length) throw new Error("columns must not contain duplicates");
+  return parsed;
+}
+function csvValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("CSV numeric values must be finite");
+    return value;
+  }
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Date) return value.toISOString();
+  return JSON.stringify(value);
+}
+
 // src/connectors/adapters/chain-aware.ts
 var chainAwareConnector = declarativeRestConnector({
   kind: "chain-aware",
@@ -6679,6 +6914,175 @@ 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_SHEETS = 50;
+var MAX_UNCOMPRESSED_WORKBOOK_BYTES = 50 * 1024 * 1024;
+var MAX_ZIP_ENTRIES = 1e3;
+var excelFilesConnector = {
+  manifest: {
+    kind: "excel-files",
+    displayName: "Excel Files",
+    description: "Read bounded XLSX workbooks and create XLSX files from structured rows.",
+    auth: { kind: "none" },
+    defaultConsistencyModel: "advisory",
+    category: "spreadsheet",
+    capabilities: [
+      {
+        name: "excel.read",
+        class: "read",
+        description: "Read every sheet, or one named sheet, from a base64-encoded XLSX workbook.",
+        parameters: {
+          type: "object",
+          properties: {
+            fileBase64: { type: "string", description: "XLSX workbook content encoded as canonical base64." },
+            sheet: {
+              description: "Optional sheet name or one-based sheet number.",
+              oneOf: [{ type: "string", minLength: 1 }, { type: "integer", minimum: 1 }]
+            }
+          },
+          required: ["fileBase64"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "excel.create",
+        class: "mutation",
+        description: "Create a single-sheet base64-encoded XLSX workbook from row arrays.",
+        parameters: {
+          type: "object",
+          properties: {
+            rows: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_RECORDS,
+              items: { type: "array", maxItems: MAX_COLUMNS2 }
+            },
+            sheetName: { type: "string", minLength: 1, maxLength: 31, default: "Sheet1" }
+          },
+          required: ["rows"],
+          additionalProperties: false
+        },
+        cas: "none",
+        externalEffect: true
+      }
+    ]
+  },
+  async executeRead({ capabilityName, args }) {
+    if (capabilityName !== "excel.read") throw new Error(`Unknown Excel capability: ${capabilityName}`);
+    const file = readBase64File(args.fileBase64);
+    assertBoundedXlsxArchive(file);
+    const requestedSheet = readSheetSelector(args.sheet);
+    const workbook = await readXlsxFile(file);
+    if (workbook.length > MAX_SHEETS) throw new Error(`workbook exceeds the ${MAX_SHEETS}-sheet limit`);
+    const selected = requestedSheet === void 0 ? workbook : workbook.filter(
+      (sheet, index) => typeof requestedSheet === "number" ? index + 1 === requestedSheet : sheet.sheet === requestedSheet
+    );
+    if (requestedSheet !== void 0 && selected.length === 0) {
+      throw new Error(`sheet not found: ${requestedSheet}`);
+    }
+    let totalRows = 0;
+    const sheets = selected.map((sheet) => {
+      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`);
+        }
+      }
+      return { name: sheet.sheet, rows: jsonSafe(sheet.data) };
+    });
+    return {
+      data: { sheets, sheetCount: sheets.length, rowCount: totalRows },
+      fetchedAt: Date.now()
+    };
+  },
+  async executeMutation({ capabilityName, args }) {
+    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`);
+    }
+    const sheetName = readOptionalString(args.sheetName, "sheetName") ?? "Sheet1";
+    validateSheetName(sheetName);
+    const sheetData = rows.map((row) => row.map(excelCell));
+    const file = await writeXlsxFile(sheetData, { sheet: sheetName }).toBuffer();
+    return {
+      status: "committed",
+      data: { ...encodeFile(file), sheetName, rowCount: rows.length },
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  async test() {
+    return { ok: true };
+  }
+};
+function readSheetSelector(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string" && value.length > 0) return value;
+  if (Number.isInteger(value) && value >= 1) return value;
+  throw new Error("sheet must be a non-empty name or a one-based integer");
+}
+function validateSheetName(value) {
+  if (value.length > 31 || /[\\/*?:[\]]/.test(value)) {
+    throw new Error("sheetName must be at most 31 characters and contain no \\ / * ? : [ ] characters");
+  }
+}
+function excelCell(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean" || value instanceof Date) return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Excel numeric values must be finite");
+    return value;
+  }
+  if (typeof value === "bigint") return value.toString();
+  return JSON.stringify(value);
+}
+function assertBoundedXlsxArchive(file) {
+  const eocdSignature = 101010256;
+  const centralEntrySignature = 33639248;
+  if (file.byteLength < 22) throw new Error("XLSX file is missing its ZIP directory");
+  const searchStart = Math.max(0, file.byteLength - 65557);
+  let eocdOffset = -1;
+  for (let offset2 = file.byteLength - 22; offset2 >= searchStart; offset2 -= 1) {
+    if (file.readUInt32LE(offset2) === eocdSignature) {
+      eocdOffset = offset2;
+      break;
+    }
+  }
+  if (eocdOffset < 0) throw new Error("XLSX file is missing its ZIP directory");
+  const entryCount = file.readUInt16LE(eocdOffset + 10);
+  const centralSize = file.readUInt32LE(eocdOffset + 12);
+  const centralOffset = file.readUInt32LE(eocdOffset + 16);
+  if (entryCount === 65535 || centralSize === 4294967295 || centralOffset === 4294967295) {
+    throw new Error("ZIP64 XLSX workbooks are not supported");
+  }
+  if (entryCount === 0 || entryCount > MAX_ZIP_ENTRIES || centralOffset + centralSize > file.byteLength) {
+    throw new Error("XLSX ZIP directory is invalid or too large");
+  }
+  let offset = centralOffset;
+  let totalUncompressed = 0;
+  for (let index = 0; index < entryCount; index += 1) {
+    if (offset + 46 > file.byteLength || file.readUInt32LE(offset) !== centralEntrySignature) {
+      throw new Error("XLSX ZIP directory entry is invalid");
+    }
+    const compressedSize = file.readUInt32LE(offset + 20);
+    const uncompressedSize = file.readUInt32LE(offset + 24);
+    const fileNameLength = file.readUInt16LE(offset + 28);
+    const extraLength = file.readUInt16LE(offset + 30);
+    const commentLength = file.readUInt16LE(offset + 32);
+    totalUncompressed += uncompressedSize;
+    if (totalUncompressed > MAX_UNCOMPRESSED_WORKBOOK_BYTES || uncompressedSize > 0 && compressedSize === 0) {
+      throw new Error("XLSX workbook expands beyond the safe processing limit");
+    }
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+  if (offset > centralOffset + centralSize) throw new Error("XLSX ZIP directory length is invalid");
+}
+
 // src/connectors/adapters/everhour.ts
 var everhourConnector = declarativeRestConnector({
   kind: "everhour",
@@ -30336,7 +30740,7 @@ var httpConnector = {
     });
     const data4 = await parseResponse(res, method);
     if (!res.ok) {
-      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify(data4), 200)}`);
+      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify2(data4), 200)}`);
     }
     return {
       data: data4,
@@ -30371,7 +30775,7 @@ var httpConnector = {
       };
     }
     if (!res.ok) {
-      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify(data4), 200)}`);
+      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify2(data4), 200)}`);
     }
     return {
       status: "committed",
@@ -30501,7 +30905,7 @@ function parseRetryAfterMs(header2) {
   if (!Number.isFinite(date)) return 1e3;
   return Math.max(0, date - Date.now());
 }
-function stringify(value) {
+function stringify2(value) {
   if (typeof value === "string") return value;
   try {
     return JSON.stringify(value);
@@ -32756,6 +33160,548 @@ var justcallConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/kafka.ts
+import { isIP as isIP2 } from "net";
+import tls from "tls";
+import {
+  Kafka,
+  logLevel
+} from "kafkajs";
+
+// src/connectors/adapters/public-network.ts
+import { lookup } from "dns/promises";
+import ipaddr from "ipaddr.js";
+function isPublicNetworkAddress(value) {
+  if (!ipaddr.isValid(value)) return false;
+  let address = ipaddr.parse(value);
+  if (address.kind() === "ipv6" && address.isIPv4MappedAddress()) {
+    address = address.toIPv4Address();
+  }
+  return address.range() === "unicast";
+}
+async function resolvePublicHostAddresses(host) {
+  const addresses = ipaddr.isValid(host) ? [host] : (await lookup(host, { all: true, verbatim: true })).map((entry) => entry.address);
+  if (addresses.length === 0 || addresses.some((address) => !isPublicNetworkAddress(address))) {
+    throw new Error("host is not a public network target");
+  }
+  return addresses;
+}
+var publicDnsLookup = (hostname, options, callback) => {
+  const normalizedOptions = typeof options === "number" ? { family: options } : options;
+  lookup(hostname, { ...normalizedOptions, all: true, verbatim: true }).then((entries) => {
+    if (entries.length === 0 || entries.some((entry) => !isPublicNetworkAddress(entry.address))) {
+      callback(new Error("host is not a public network target"), "", 0);
+      return;
+    }
+    if (normalizedOptions?.all) {
+      callback(null, entries, void 0);
+      return;
+    }
+    callback(null, entries[0].address, entries[0].family);
+  }).catch((error) => callback(error instanceof Error ? error : new Error("DNS lookup failed"), "", 0));
+};
+
+// src/connectors/adapters/kafka.ts
+var MAX_TOPICS = 100;
+var MAX_MESSAGES = 100;
+var MAX_MESSAGE_BYTES2 = 1024 * 1024;
+var MAX_BATCH_BYTES2 = MAX_FILE_BYTES;
+var MAX_HEADERS = 64;
+var MAX_POLL_MS = 3e4;
+function createKafkaConnector(options = {}) {
+  const createClient = options.createClient ?? ((config) => new Kafka(config));
+  return {
+    manifest: {
+      kind: "kafka",
+      displayName: "Apache Kafka",
+      description: "Discover topics and groups, inspect offsets, produce records, and run bounded approved consumers over TLS.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with brokers and optional SASL or mutual-TLS credentials. TLS is mandatory and broker addresses must resolve publicly."
+      },
+      defaultConsistencyModel: "advisory",
+      category: "webhook",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability5("kafka.topics.list", "List Kafka topics visible to the connection.", emptySchema()),
+        readCapability5("kafka.topics.describe", "Read partition and replica metadata for selected topics.", {
+          type: "object",
+          properties: { topics: topicArraySchema() },
+          required: ["topics"],
+          additionalProperties: false
+        }),
+        readCapability5("kafka.offsets.list", "Read low, high, and current offsets for one topic.", topicSchema()),
+        readCapability5("kafka.groups.list", "List consumer groups visible to the connection.", emptySchema()),
+        readCapability5("kafka.group.offsets", "Read committed offsets for a consumer group.", {
+          type: "object",
+          properties: {
+            groupId: { type: "string", minLength: 1, maxLength: 255 },
+            topics: topicArraySchema()
+          },
+          required: ["groupId"],
+          additionalProperties: false
+        }),
+        mutationCapability5("kafka.messages.produce", "Produce one or more records with all acknowledgements enabled.", {
+          type: "object",
+          properties: {
+            topic: topicNameSchema(),
+            encoding: { type: "string", enum: ["utf8", "base64"], default: "utf8" },
+            messages: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_MESSAGES,
+              items: {
+                type: "object",
+                properties: {
+                  value: { type: "string" },
+                  key: { type: "string" },
+                  partition: { type: "integer", minimum: 0 },
+                  headers: { type: "object", additionalProperties: { type: "string" }, maxProperties: MAX_HEADERS }
+                },
+                required: ["value"],
+                additionalProperties: false
+              }
+            }
+          },
+          required: ["topic", "messages"],
+          additionalProperties: false
+        }),
+        mutationCapability5("kafka.messages.consume", "Join a consumer group and return a bounded batch without automatically committing offsets.", {
+          type: "object",
+          properties: {
+            topic: topicNameSchema(),
+            groupId: { type: "string", minLength: 1, maxLength: 255 },
+            encoding: { type: "string", enum: ["utf8", "base64"], default: "utf8" },
+            fromBeginning: { type: "boolean", default: false },
+            limit: { type: "integer", minimum: 1, maximum: MAX_MESSAGES, default: 25 },
+            timeoutMs: { type: "integer", minimum: 250, maximum: MAX_POLL_MS, default: 5e3 }
+          },
+          required: ["topic", "groupId"],
+          additionalProperties: false
+        }),
+        mutationCapability5("kafka.offsets.commit", "Commit explicit next offsets for a consumer group.", {
+          type: "object",
+          properties: {
+            groupId: { type: "string", minLength: 1, maxLength: 255 },
+            offsets: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_MESSAGES,
+              items: {
+                type: "object",
+                properties: {
+                  topic: topicNameSchema(),
+                  partition: { type: "integer", minimum: 0 },
+                  offset: { type: "string", pattern: "^[0-9]+$" },
+                  metadata: { type: "string", maxLength: 4096 }
+                },
+                required: ["topic", "partition", "offset"],
+                additionalProperties: false
+              }
+            }
+          },
+          required: ["groupId", "offsets"],
+          additionalProperties: false
+        }),
+        mutationCapability5("kafka.topics.create", "Create one Kafka topic with explicit partition and replication counts.", {
+          type: "object",
+          properties: {
+            topic: topicNameSchema(),
+            partitions: { type: "integer", minimum: 1, maximum: 100, default: 1 },
+            replicationFactor: { type: "integer", minimum: 1, maximum: 10, default: 1 }
+          },
+          required: ["topic"],
+          additionalProperties: false
+        }),
+        mutationCapability5("kafka.topics.delete", "Delete one or more Kafka topics.", {
+          type: "object",
+          properties: { topics: topicArraySchema() },
+          required: ["topics"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async executeRead({ source, capabilityName, args }) {
+      const client = createClient(readCredentials(source).config);
+      return withAdmin(client.admin(), async (admin) => {
+        let data4;
+        if (capabilityName === "kafka.topics.list") {
+          data4 = { topics: await admin.listTopics() };
+        } else if (capabilityName === "kafka.topics.describe") {
+          data4 = await admin.fetchTopicMetadata({ topics: readTopics(args.topics) });
+        } else if (capabilityName === "kafka.offsets.list") {
+          const topic = readTopic(args.topic);
+          data4 = { topic, partitions: await admin.fetchTopicOffsets(topic) };
+        } else if (capabilityName === "kafka.groups.list") {
+          data4 = await admin.listGroups();
+        } else if (capabilityName === "kafka.group.offsets") {
+          const groupId5 = readGroupId2(args.groupId);
+          const topics = args.topics === void 0 ? void 0 : readTopics(args.topics);
+          data4 = { groupId: groupId5, offsets: await admin.fetchOffsets({ groupId: groupId5, topics, resolveOffsets: true }) };
+        } else {
+          throw new Error(`Unknown Kafka read capability: ${capabilityName}`);
+        }
+        return { data: jsonSafe(data4), fetchedAt: Date.now() };
+      });
+    },
+    async executeMutation({ source, capabilityName, args }) {
+      const client = createClient(readCredentials(source).config);
+      let data4;
+      if (capabilityName === "kafka.messages.produce") {
+        data4 = await produce(client.producer({ idempotent: true, maxInFlightRequests: 1 }), args);
+      } else if (capabilityName === "kafka.messages.consume") {
+        data4 = await consume(client.consumer({
+          groupId: readGroupId2(args.groupId),
+          allowAutoTopicCreation: false,
+          maxBytes: MAX_BATCH_BYTES2,
+          maxBytesPerPartition: MAX_BATCH_BYTES2
+        }), args);
+      } else if (capabilityName === "kafka.offsets.commit") {
+        data4 = await commitOffsets(client.consumer({
+          groupId: readGroupId2(args.groupId),
+          allowAutoTopicCreation: false
+        }), args);
+      } else if (capabilityName === "kafka.topics.create") {
+        data4 = await withAdmin(client.admin(), async (admin) => ({
+          created: await admin.createTopics({
+            waitForLeaders: true,
+            topics: [{
+              topic: readTopic(args.topic),
+              numPartitions: readBoundedInteger(args.partitions, 1, 1, 100, "partitions"),
+              replicationFactor: readBoundedInteger(args.replicationFactor, 1, 1, 10, "replicationFactor")
+            }]
+          })
+        }));
+      } else if (capabilityName === "kafka.topics.delete") {
+        const topics = readTopics(args.topics);
+        data4 = await withAdmin(client.admin(), async (admin) => {
+          await admin.deleteTopics({ topics });
+          return { topics };
+        });
+      } else {
+        throw new Error(`Unknown Kafka mutation capability: ${capabilityName}`);
+      }
+      return {
+        status: "committed",
+        data: jsonSafe(data4),
+        committedAt: Date.now(),
+        idempotentReplay: false
+      };
+    },
+    async test(source) {
+      try {
+        const admin = createClient(readCredentials(source).config).admin();
+        await withAdmin(admin, (connected) => connected.listTopics());
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : "Kafka connection test failed" };
+      }
+    }
+  };
+}
+var kafkaConnector = createKafkaConnector();
+var publicKafkaSocketFactory = ({ host, port, ssl, onConnect }) => {
+  validateBrokerHost(host);
+  if (isIP2(host) !== 0 && !isPublicNetworkAddress(host)) {
+    throw new Error("Kafka broker is not a public network target");
+  }
+  const socket = tls.connect({
+    ...ssl,
+    host,
+    port,
+    servername: isIP2(host) === 0 ? host : void 0,
+    lookup: publicDnsLookup
+  }, onConnect);
+  socket.setKeepAlive(true, 6e4);
+  return socket;
+};
+async function withAdmin(admin, run) {
+  try {
+    await admin.connect();
+    return await run(admin);
+  } finally {
+    await admin.disconnect().catch(() => void 0);
+  }
+}
+async function produce(producer, args) {
+  const topic = readTopic(args.topic);
+  const encoding = readEncoding(args.encoding);
+  const messages = readMessageInputs(args.messages).map((message) => ({
+    value: decodeMessageValue(message.value, encoding, "value"),
+    key: message.key === void 0 ? void 0 : decodeMessageValue(message.key, encoding, "key"),
+    partition: message.partition === void 0 ? void 0 : readBoundedInteger(message.partition, 0, 0, Number.MAX_SAFE_INTEGER, "partition"),
+    headers: readHeaders(message.headers)
+  }));
+  const batchBytes = messages.reduce((total, message) => total + message.value.byteLength + (message.key?.byteLength ?? 0) + headerBytes(message.headers), 0);
+  if (batchBytes > MAX_BATCH_BYTES2) throw new Error(`messages exceed the ${MAX_BATCH_BYTES2}-byte batch limit`);
+  try {
+    await producer.connect();
+    return { topic, records: await producer.send({ topic, messages, acks: -1, timeout: 3e4 }) };
+  } finally {
+    await producer.disconnect().catch(() => void 0);
+  }
+}
+async function consume(consumer, args) {
+  const topic = readTopic(args.topic);
+  const encoding = readEncoding(args.encoding);
+  const limit = readBoundedInteger(args.limit, 25, 1, MAX_MESSAGES, "limit");
+  const timeoutMs = readBoundedInteger(args.timeoutMs, 5e3, 250, MAX_POLL_MS, "timeoutMs");
+  const messages = [];
+  let batchBytes = 0;
+  let resolveDone = () => void 0;
+  let rejectDone = () => void 0;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  let timer;
+  try {
+    await consumer.connect();
+    await consumer.subscribe({ topics: [topic], fromBeginning: readBoolean(args.fromBeginning, false, "fromBeginning") });
+    const run = consumer.run({
+      autoCommit: false,
+      partitionsConsumedConcurrently: 1,
+      eachMessage: async ({ partition, message }) => {
+        if (messages.length >= limit) return;
+        const messageBytes = (message.key?.byteLength ?? 0) + (message.value?.byteLength ?? 0) + headerBytes(message.headers);
+        if (messageBytes > MAX_MESSAGE_BYTES2) throw new Error(`Kafka message exceeds the ${MAX_MESSAGE_BYTES2}-byte limit`);
+        batchBytes += messageBytes;
+        if (batchBytes > MAX_BATCH_BYTES2) throw new Error(`Kafka batch exceeds the ${MAX_BATCH_BYTES2}-byte limit`);
+        messages.push({
+          topic,
+          partition,
+          offset: message.offset,
+          timestamp: message.timestamp,
+          key: encodeMessageValue(message.key, encoding),
+          value: encodeMessageValue(message.value, encoding),
+          headers: Object.fromEntries(Object.entries(message.headers ?? {}).map(([key, value]) => [key, encodeHeader(value, encoding)]))
+        });
+        if (messages.length >= limit) resolveDone();
+      }
+    });
+    run.catch(rejectDone);
+    timer = setTimeout(resolveDone, timeoutMs);
+    await done;
+    await consumer.stop();
+    await run;
+    return { topic, messages, messageCount: messages.length, offsetsCommitted: false };
+  } finally {
+    if (timer) clearTimeout(timer);
+    await consumer.disconnect().catch(() => void 0);
+  }
+}
+async function commitOffsets(consumer, args) {
+  if (!Array.isArray(args.offsets) || args.offsets.length === 0 || args.offsets.length > MAX_MESSAGES) {
+    throw new Error(`offsets must contain 1 through ${MAX_MESSAGES} entries`);
+  }
+  const offsets = args.offsets.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`offsets[${index}] must be an object`);
+    const offset = readOptionalString(entry.offset, `offsets[${index}].offset`);
+    if (!offset || !/^[0-9]+$/.test(offset) || BigInt(offset) > 9223372036854775807n) {
+      throw new Error(`offsets[${index}].offset must be a signed 64-bit non-negative integer string`);
+    }
+    return {
+      topic: readTopic(entry.topic),
+      partition: readBoundedInteger(entry.partition, 0, 0, Number.MAX_SAFE_INTEGER, `offsets[${index}].partition`),
+      offset,
+      metadata: readOptionalString(entry.metadata, `offsets[${index}].metadata`)
+    };
+  });
+  try {
+    await consumer.connect();
+    await consumer.commitOffsets(offsets);
+    return { groupId: readGroupId2(args.groupId), offsets };
+  } finally {
+    await consumer.disconnect().catch(() => void 0);
+  }
+}
+function readCredentials(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("Kafka credential must be valid JSON");
+    }
+  } else {
+    throw new Error("Kafka requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("Kafka credential must be a JSON object");
+  const brokers = readBrokers(raw.brokers);
+  const clientId = readOptionalString(raw.clientId, "clientId") ?? "tangle-integration-hub";
+  if (!/^[A-Za-z0-9._-]{1,128}$/.test(clientId)) throw new Error("clientId contains unsupported characters");
+  const sasl = readSasl(raw);
+  const ca = readPemList(raw.tlsCa, "tlsCa");
+  const cert = readOptionalString(raw.tlsCert, "tlsCert");
+  const key = readOptionalString(raw.tlsKey, "tlsKey");
+  if (Boolean(cert) !== Boolean(key)) throw new Error("tlsCert and tlsKey must be supplied together");
+  return {
+    config: {
+      brokers,
+      clientId,
+      ssl: {
+        minVersion: "TLSv1.2",
+        rejectUnauthorized: true,
+        ca,
+        cert,
+        key,
+        passphrase: readOptionalString(raw.tlsPassphrase, "tlsPassphrase")
+      },
+      sasl,
+      socketFactory: publicKafkaSocketFactory,
+      connectionTimeout: 1e4,
+      authenticationTimeout: 1e4,
+      requestTimeout: 3e4,
+      enforceRequestTimeout: true,
+      retry: { retries: 3, maxRetryTime: 3e4 },
+      logLevel: logLevel.NOTHING
+    }
+  };
+}
+function readBrokers(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+    throw new Error("brokers must contain 1 through 20 host:port entries");
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string" || entry.length === 0) throw new Error(`brokers[${index}] must be a host:port string`);
+    let parsed;
+    try {
+      parsed = new URL(`tcp://${entry}`);
+    } catch {
+      throw new Error(`brokers[${index}] is not a valid host:port`);
+    }
+    const host = parsed.hostname.replace(/^\[|\]$/g, "");
+    if (!parsed.port || parsed.username || parsed.password || !["", "/"].includes(parsed.pathname)) {
+      throw new Error(`brokers[${index}] must contain only host and port`);
+    }
+    validateBrokerHost(host);
+    if (isIP2(host) !== 0 && !isPublicNetworkAddress(host)) throw new Error(`brokers[${index}] is not a public network target`);
+    const port = Number(parsed.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`brokers[${index}] port is invalid`);
+    return entry;
+  });
+}
+function validateBrokerHost(host) {
+  const normalized = host.toLowerCase();
+  if (host.length === 0 || host.length > 253 || normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@]/.test(host)) {
+    throw new Error("Kafka broker must be a public hostname or IP address");
+  }
+}
+function readSasl(raw) {
+  if (raw.saslMechanism === void 0 || raw.saslMechanism === null) return void 0;
+  if (!["plain", "scram-sha-256", "scram-sha-512"].includes(String(raw.saslMechanism))) {
+    throw new Error("saslMechanism must be plain, scram-sha-256, or scram-sha-512");
+  }
+  const username = readOptionalString(raw.saslUsername, "saslUsername");
+  const password = readOptionalString(raw.saslPassword, "saslPassword");
+  if (!username || !password) throw new Error("SASL requires saslUsername and saslPassword");
+  return { mechanism: raw.saslMechanism, username, password };
+}
+function readPemList(value, label) {
+  if (value === void 0 || value === null) return void 0;
+  const values = Array.isArray(value) ? value : [value];
+  if (values.length === 0 || values.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    throw new Error(`${label} must be a PEM string or non-empty array of PEM strings`);
+  }
+  return values;
+}
+function readTopics(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_TOPICS) {
+    throw new Error(`topics must contain 1 through ${MAX_TOPICS} names`);
+  }
+  const topics = value.map(readTopic);
+  if (new Set(topics).size !== topics.length) throw new Error("topics must not contain duplicates");
+  return topics;
+}
+function readTopic(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9._-]{1,249}$/.test(value) || value === "." || value === "..") {
+    throw new Error("topic must be 1 through 249 Kafka-safe characters");
+  }
+  return value;
+}
+function readGroupId2(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 255 || /[\u0000-\u001f]/.test(value)) {
+    throw new Error("groupId must be 1 through 255 printable characters");
+  }
+  return value;
+}
+function readEncoding(value) {
+  if (value === void 0 || value === null || value === "utf8") return "utf8";
+  if (value === "base64") return "base64";
+  throw new Error("encoding must be utf8 or base64");
+}
+function readMessageInputs(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_MESSAGES) {
+    throw new Error(`messages must contain 1 through ${MAX_MESSAGES} entries`);
+  }
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`messages[${index}] must be an object`);
+    return entry;
+  });
+}
+function decodeMessageValue(value, encoding, label) {
+  if (typeof value !== "string") throw new Error(`${label} must be a string`);
+  if (encoding === "base64" && (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))) {
+    throw new Error(`${label} must be canonical base64`);
+  }
+  const decoded = Buffer.from(value, encoding);
+  if (decoded.byteLength > MAX_MESSAGE_BYTES2) throw new Error(`${label} exceeds the ${MAX_MESSAGE_BYTES2}-byte limit`);
+  return decoded;
+}
+function encodeMessageValue(value, encoding) {
+  return value ? value.toString(encoding) : null;
+}
+function encodeHeader(value, encoding) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value)) return value.map((entry) => Buffer.isBuffer(entry) ? entry.toString(encoding) : entry);
+  return Buffer.isBuffer(value) ? value.toString(encoding) : value;
+}
+function readHeaders(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (!isPlainRecord(value) || Object.keys(value).length > MAX_HEADERS) throw new Error(`headers must have at most ${MAX_HEADERS} string fields`);
+  const headers = Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+    if (typeof entry !== "string") throw new Error(`header ${key} must be a string`);
+    return [key, entry];
+  }));
+  if (headerBytes(headers) > MAX_MESSAGE_BYTES2) throw new Error(`headers exceed the ${MAX_MESSAGE_BYTES2}-byte limit`);
+  return headers;
+}
+function headerBytes(headers) {
+  if (!headers) return 0;
+  return Object.entries(headers).reduce((total, [key, value]) => {
+    const values = Array.isArray(value) ? value : [value];
+    return total + Buffer.byteLength(key, "utf8") + values.reduce((sum, entry) => {
+      if (Buffer.isBuffer(entry)) return sum + entry.byteLength;
+      if (typeof entry === "string") return sum + Buffer.byteLength(entry, "utf8");
+      return sum;
+    }, 0);
+  }, 0);
+}
+function emptySchema() {
+  return { type: "object", properties: {}, additionalProperties: false };
+}
+function topicSchema() {
+  return {
+    type: "object",
+    properties: { topic: topicNameSchema() },
+    required: ["topic"],
+    additionalProperties: false
+  };
+}
+function topicArraySchema() {
+  return { type: "array", minItems: 1, maxItems: MAX_TOPICS, items: topicNameSchema() };
+}
+function topicNameSchema() {
+  return { type: "string", minLength: 1, maxLength: 249, pattern: "^[A-Za-z0-9._-]+$" };
+}
+function readCapability5(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+function mutationCapability5(name, description, parameters) {
+  return { name, class: "mutation", description, parameters, cas: "none", externalEffect: true };
+}
+
 // src/connectors/adapters/lead-connector.ts
 var leadConnectorConnector = declarativeRestConnector({
   kind: "lead-connector",
@@ -42934,6 +43880,130 @@ var pipedriveConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/parquet-files.ts
+import { parquetReadObjects } from "hyparquet";
+import { parquetWriteBuffer } from "hyparquet-writer";
+var MAX_COLUMNS3 = 256;
+var parquetFilesConnector = {
+  manifest: {
+    kind: "parquet-files",
+    displayName: "Parquet Files",
+    description: "Read bounded Apache Parquet files and create Parquet files from structured records.",
+    auth: { kind: "none" },
+    defaultConsistencyModel: "advisory",
+    category: "database",
+    capabilities: [
+      {
+        name: "parquet.read",
+        class: "read",
+        description: "Read selected columns and a bounded row range from a base64-encoded Parquet file.",
+        parameters: {
+          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 } },
+            rowStart: { type: "integer", minimum: 0, default: 0 },
+            rowLimit: { type: "integer", minimum: 1, maximum: MAX_RECORDS, default: MAX_RECORDS }
+          },
+          required: ["fileBase64"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "parquet.create",
+        class: "mutation",
+        description: "Create a base64-encoded Parquet file from object records with inferred column types.",
+        parameters: {
+          type: "object",
+          properties: {
+            records: { type: "array", minItems: 1, maxItems: MAX_RECORDS, items: { type: "object" } }
+          },
+          required: ["records"],
+          additionalProperties: false
+        },
+        cas: "none",
+        externalEffect: true
+      }
+    ]
+  },
+  async executeRead({ capabilityName, args }) {
+    if (capabilityName !== "parquet.read") throw new Error(`Unknown Parquet capability: ${capabilityName}`);
+    const file = readBase64File(args.fileBase64);
+    const columns = readColumns2(args.columns);
+    const rowStart = readBoundedInteger(args.rowStart, 0, 0, Number.MAX_SAFE_INTEGER, "rowStart");
+    const rowLimit = readBoundedInteger(args.rowLimit, MAX_RECORDS, 1, MAX_RECORDS, "rowLimit");
+    const records = await parquetReadObjects({
+      file: asyncBuffer(file),
+      columns,
+      rowStart,
+      rowEnd: rowStart + rowLimit
+    });
+    return {
+      data: { records: jsonSafe(records), recordCount: records.length, rowStart },
+      fetchedAt: Date.now()
+    };
+  },
+  async executeMutation({ capabilityName, args }) {
+    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.some((name) => name.length === 0)) throw new Error("column names must not be empty");
+    const columnData = columnNames.map((name) => {
+      const data4 = records.map((record) => parquetValue(record[name]));
+      return { name, data: data4, type: inferParquetType(data4) };
+    });
+    const file = parquetWriteBuffer({ columnData });
+    return {
+      status: "committed",
+      data: { ...encodeFile(new Uint8Array(file)), columns: columnNames, recordCount: records.length },
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  async test() {
+    return { ok: true };
+  }
+};
+function asyncBuffer(file) {
+  return {
+    byteLength: file.byteLength,
+    slice(start, end) {
+      const boundedEnd = end === void 0 ? file.byteLength : Math.min(end, file.byteLength);
+      return Uint8Array.from(file.subarray(start, boundedEnd)).buffer;
+    }
+  };
+}
+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`);
+  }
+  const columns = value.map((entry, index) => {
+    if (typeof entry !== "string" || entry.length === 0) throw new Error(`columns[${index}] must be a non-empty string`);
+    return entry;
+  });
+  if (new Set(columns).size !== columns.length) throw new Error("columns must not contain duplicates");
+  return columns;
+}
+function parquetValue(value) {
+  if (value === void 0) return null;
+  if (typeof value === "number" && !Number.isFinite(value)) throw new Error("Parquet numeric values must be finite");
+  return value;
+}
+function inferParquetType(values) {
+  const present = values.filter((value) => value !== null && value !== void 0);
+  if (present.length === 0) return "JSON";
+  if (present.every((value) => typeof value === "boolean")) return "BOOLEAN";
+  if (present.every((value) => typeof value === "string")) return "STRING";
+  if (present.every((value) => typeof value === "number")) return "DOUBLE";
+  if (present.every((value) => typeof value === "bigint")) return "INT64";
+  if (present.every((value) => value instanceof Date)) return "TIMESTAMP";
+  return "JSON";
+}
+
 // src/connectors/adapters/quickbooks.ts
 var quickbooksConnector = declarativeRestConnector({
   kind: "quickbooks",
@@ -44194,6 +45264,355 @@ var salesforceConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/sftp.ts
+import { timingSafeEqual as timingSafeEqual4 } from "crypto";
+import { posix } from "path";
+import SftpClient from "ssh2-sftp-client";
+var MAX_LIST_ENTRIES = 1e3;
+var MAX_PATH_LENGTH = 1024;
+function createSftpConnector(options = {}) {
+  const createClient = options.createClient ?? (() => new SftpClient());
+  const lookupHost = options.lookupHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "sftp",
+      displayName: "SFTP",
+      description: "List, inspect, download, upload, move, and delete files over host-key-verified SFTP.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with host, username, SHA-256 hostFingerprint, and password or privateKey; optional port, passphrase, and rootPath."
+      },
+      defaultConsistencyModel: "advisory",
+      category: "storage",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        {
+          name: "sftp.list",
+          class: "read",
+          description: "List a directory within the connection root.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", default: "/" },
+              limit: { type: "integer", minimum: 1, maximum: MAX_LIST_ENTRIES, default: MAX_LIST_ENTRIES }
+            },
+            additionalProperties: false
+          }
+        },
+        {
+          name: "sftp.stat",
+          class: "read",
+          description: "Read file or directory metadata within the connection root.",
+          parameters: pathSchema()
+        },
+        {
+          name: "sftp.download",
+          class: "read",
+          description: `Download a file no larger than ${MAX_FILE_BYTES} bytes as base64.`,
+          parameters: pathSchema()
+        },
+        {
+          name: "sftp.upload",
+          class: "mutation",
+          description: `Upload a base64 file no larger than ${MAX_FILE_BYTES} bytes within the connection root.`,
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", minLength: 1 },
+              fileBase64: { type: "string" },
+              overwrite: { type: "boolean", default: false }
+            },
+            required: ["path", "fileBase64"],
+            additionalProperties: false
+          },
+          cas: "none",
+          externalEffect: true
+        },
+        {
+          name: "sftp.mkdir",
+          class: "mutation",
+          description: "Create a directory within the connection root.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", minLength: 1 },
+              recursive: { type: "boolean", default: true }
+            },
+            required: ["path"],
+            additionalProperties: false
+          },
+          cas: "none",
+          externalEffect: true
+        },
+        {
+          name: "sftp.rename",
+          class: "mutation",
+          description: "Move or rename a file without overwriting the destination.",
+          parameters: {
+            type: "object",
+            properties: {
+              sourcePath: { type: "string", minLength: 1 },
+              destinationPath: { type: "string", minLength: 1 }
+            },
+            required: ["sourcePath", "destinationPath"],
+            additionalProperties: false
+          },
+          cas: "none",
+          externalEffect: true
+        },
+        {
+          name: "sftp.delete",
+          class: "mutation",
+          description: "Delete a file within the connection root. Repeated deletion is safe.",
+          parameters: pathSchema(),
+          cas: "none",
+          externalEffect: true
+        }
+      ]
+    },
+    async executeRead({ source, capabilityName, args }) {
+      const credentials = readCredentials2(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");
+        return withSftp(credentials, createClient, lookupHost, async (client) => {
+          const safePath = await canonicalizeExistingPath(client, credentials.rootPath, path);
+          const allEntries = await client.list(safePath);
+          const entries = allEntries.slice(0, limit);
+          return { data: { path: safePath, entries, truncated: allEntries.length > limit }, fetchedAt: Date.now() };
+        });
+      }
+      if (capabilityName === "sftp.stat") {
+        const path = resolveRemotePath(credentials.rootPath, args.path);
+        return withSftp(credentials, createClient, lookupHost, async (client) => {
+          const safePath = await canonicalizeExistingPath(client, credentials.rootPath, path);
+          return { data: { path: safePath, stat: await client.stat(safePath) }, fetchedAt: Date.now() };
+        });
+      }
+      if (capabilityName === "sftp.download") {
+        const path = resolveRemotePath(credentials.rootPath, args.path);
+        return withSftp(credentials, createClient, lookupHost, async (client) => {
+          const safePath = await canonicalizeExistingPath(client, credentials.rootPath, path);
+          const stat = await client.stat(safePath);
+          if (!stat.isFile) throw new Error("sftp.download path is not a file");
+          if (stat.size > MAX_FILE_BYTES) throw new Error(`sftp.download file exceeds the ${MAX_FILE_BYTES}-byte limit`);
+          const file = await client.get(safePath);
+          if (!Buffer.isBuffer(file)) throw new Error("SFTP client returned a non-buffer download");
+          return { data: { path: safePath, ...encodeFile(file), modifyTime: stat.modifyTime }, fetchedAt: Date.now() };
+        });
+      }
+      throw new Error(`Unknown SFTP read capability: ${capabilityName}`);
+    },
+    async executeMutation({ source, capabilityName, args }) {
+      const credentials = readCredentials2(source);
+      const prepared = prepareMutation(capabilityName, args, credentials.rootPath);
+      return withSftp(credentials, createClient, lookupHost, async (client) => {
+        let data4;
+        if (prepared.kind === "upload") {
+          const path = await canonicalizeDestinationPath(client, credentials.rootPath, prepared.path);
+          if (!prepared.overwrite && await client.exists(path)) throw new Error("sftp.upload destination already exists");
+          await client.put(prepared.file, path);
+          data4 = { path, byteLength: prepared.file.byteLength };
+        } else if (prepared.kind === "mkdir") {
+          const path = await canonicalizeDestinationPath(client, credentials.rootPath, prepared.path);
+          await client.mkdir(path, prepared.recursive);
+          data4 = { path };
+        } else if (prepared.kind === "rename") {
+          const sourcePath = await canonicalizeExistingPath(client, credentials.rootPath, prepared.sourcePath);
+          const destinationPath = await canonicalizeDestinationPath(client, credentials.rootPath, prepared.destinationPath);
+          if (await client.exists(destinationPath)) throw new Error("sftp.rename destination already exists");
+          await client.rename(sourcePath, destinationPath);
+          data4 = { sourcePath, destinationPath };
+        } else {
+          const path = await canonicalizeDestinationPath(client, credentials.rootPath, prepared.path);
+          await client.delete(path, true);
+          data4 = { path };
+        }
+        return {
+          status: "committed",
+          data: data4,
+          committedAt: Date.now(),
+          idempotentReplay: false
+        };
+      });
+    },
+    async test(source) {
+      try {
+        const credentials = readCredentials2(source);
+        await withSftp(credentials, createClient, lookupHost, (client) => client.cwd());
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : "SFTP connection test failed" };
+      }
+    }
+  };
+}
+function prepareMutation(capabilityName, args, rootPath) {
+  if (capabilityName === "sftp.upload") {
+    return {
+      kind: "upload",
+      path: mutablePath(rootPath, args.path),
+      file: readBase64File(args.fileBase64),
+      overwrite: readBoolean(args.overwrite, false, "overwrite")
+    };
+  }
+  if (capabilityName === "sftp.mkdir") {
+    return {
+      kind: "mkdir",
+      path: mutablePath(rootPath, args.path),
+      recursive: readBoolean(args.recursive, true, "recursive")
+    };
+  }
+  if (capabilityName === "sftp.rename") {
+    return {
+      kind: "rename",
+      sourcePath: mutablePath(rootPath, args.sourcePath),
+      destinationPath: mutablePath(rootPath, args.destinationPath)
+    };
+  }
+  if (capabilityName === "sftp.delete") {
+    return { kind: "delete", path: mutablePath(rootPath, args.path) };
+  }
+  throw new Error(`Unknown SFTP mutation capability: ${capabilityName}`);
+}
+var sftpConnector = createSftpConnector();
+function pathSchema() {
+  return {
+    type: "object",
+    properties: { path: { type: "string", minLength: 1 } },
+    required: ["path"],
+    additionalProperties: false
+  };
+}
+async function withSftp(credentials, createClient, lookupHost, run) {
+  const addresses = await lookupHost(credentials.host);
+  if (addresses.length === 0) throw new Error("SFTP host did not resolve");
+  const client = createClient();
+  try {
+    await client.connect({
+      host: addresses[0],
+      port: credentials.port,
+      username: credentials.username,
+      password: credentials.password,
+      privateKey: credentials.privateKey,
+      passphrase: credentials.passphrase,
+      readyTimeout: 1e4,
+      retries: 1,
+      hostHash: "sha256",
+      hostVerifier: (hashedKey) => fingerprintMatches(credentials.hostFingerprint, hashedKey)
+    });
+    return await run(client);
+  } finally {
+    await client.end().catch(() => false);
+  }
+}
+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("SFTP credential must be valid JSON");
+    }
+  } else {
+    throw new Error("SFTP requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("SFTP credential must be a JSON object");
+  const host = requiredCredentialString2(raw.host, "host");
+  validateHostname(host);
+  const username = requiredCredentialString2(raw.username, "username");
+  const password = readOptionalString(raw.password, "password");
+  const privateKey = readOptionalString(raw.privateKey, "privateKey");
+  if (!password && !privateKey) throw new Error("SFTP credential requires password or privateKey");
+  const rootPath = normalizeRootPath(readOptionalString(raw.rootPath, "rootPath") ?? "/");
+  return {
+    host,
+    port: readBoundedInteger(raw.port, 22, 1, 65535, "port"),
+    username,
+    password,
+    privateKey,
+    passphrase: readOptionalString(raw.passphrase, "passphrase"),
+    hostFingerprint: parseFingerprint(requiredCredentialString2(raw.hostFingerprint, "hostFingerprint")),
+    rootPath
+  };
+}
+function requiredCredentialString2(value, label) {
+  const parsed = readOptionalString(value, label);
+  if (!parsed) throw new Error(`SFTP credential ${label} is required`);
+  return parsed;
+}
+function validateHostname(host) {
+  if (host.length > 253 || host.includes("://") || /[\s/@]/.test(host) || host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) {
+    throw new Error("SFTP host must be a public hostname or IP address without a scheme");
+  }
+}
+function parseFingerprint(value) {
+  if (/^[a-fA-F0-9]{64}$/.test(value)) return Buffer.from(value, "hex");
+  const match = /^SHA256:([A-Za-z0-9+/]{43}=?)$/.exec(value);
+  if (!match) throw new Error("hostFingerprint must be 64 hex characters or an SHA256: base64 fingerprint");
+  const parsed = Buffer.from(match[1], "base64");
+  if (parsed.byteLength !== 32) throw new Error("hostFingerprint must contain a 32-byte SHA-256 digest");
+  return parsed;
+}
+function fingerprintMatches(expected, actual) {
+  const parsed = Buffer.isBuffer(actual) ? actual : /^[a-fA-F0-9]{64}$/.test(actual) ? Buffer.from(actual, "hex") : Buffer.from(actual.replace(/^SHA256:/, ""), "base64");
+  return parsed.byteLength === expected.byteLength && timingSafeEqual4(parsed, expected);
+}
+function normalizeRootPath(value) {
+  if (!value.startsWith("/") || value.includes("\0") || value.length > MAX_PATH_LENGTH) {
+    throw new Error("rootPath must be an absolute SFTP path");
+  }
+  return posix.normalize(value);
+}
+function resolveRemotePath(rootPath, value) {
+  const requested = readOptionalString(value, "path");
+  if (!requested || requested.includes("\0") || requested.length > MAX_PATH_LENGTH) {
+    throw new Error("path must be a non-empty SFTP path");
+  }
+  const resolved = posix.resolve(rootPath, requested.replace(/^\/+/, ""));
+  if (rootPath !== "/" && resolved !== rootPath && !resolved.startsWith(`${rootPath}/`)) {
+    throw new Error("path escapes the configured SFTP root");
+  }
+  return resolved;
+}
+function mutablePath(rootPath, value) {
+  const path = resolveRemotePath(rootPath, value);
+  if (path === rootPath) throw new Error("mutation path cannot target the configured SFTP root");
+  return path;
+}
+async function canonicalizeExistingPath(client, configuredRoot, path) {
+  const root = posix.normalize(await client.realPath(configuredRoot));
+  const target = posix.normalize(await client.realPath(path));
+  assertWithinCanonicalRoot(root, target);
+  return target;
+}
+async function canonicalizeDestinationPath(client, configuredRoot, path) {
+  const root = posix.normalize(await client.realPath(configuredRoot));
+  if (await client.exists(path)) {
+    const existing = posix.normalize(await client.realPath(path));
+    assertWithinCanonicalRoot(root, existing);
+    return existing;
+  }
+  let ancestor = posix.dirname(path);
+  const missingSegments = [posix.basename(path)];
+  while (!await client.exists(ancestor)) {
+    if (ancestor === configuredRoot || ancestor === "/") break;
+    missingSegments.unshift(posix.basename(ancestor));
+    ancestor = posix.dirname(ancestor);
+  }
+  const canonicalAncestor = posix.normalize(await client.realPath(ancestor));
+  assertWithinCanonicalRoot(root, canonicalAncestor);
+  const destination = posix.join(canonicalAncestor, ...missingSegments);
+  assertWithinCanonicalRoot(root, destination);
+  return destination;
+}
+function assertWithinCanonicalRoot(root, target) {
+  if (root !== "/" && target !== root && !target.startsWith(`${root}/`)) {
+    throw new Error("SFTP path resolves outside the configured root");
+  }
+}
+
 // src/connectors/adapters/saleor.ts
 var saleorConnector = declarativeRestConnector({
   kind: "saleor",
@@ -53790,17 +55209,17 @@ var zohoBookingsConnector = {
     category: "calendar",
     defaultConsistencyModel: "authoritative",
     capabilities: [
-      readCapability5("workspaces.list", "List Zoho Bookings workspaces.", {}),
-      readCapability5("services.list", "List services, optionally within one workspace.", {
+      readCapability6("workspaces.list", "List Zoho Bookings workspaces.", {}),
+      readCapability6("services.list", "List services, optionally within one workspace.", {
         workspace_id: { type: "string" }
       }),
-      readCapability5("resources.list", "List bookable resources, optionally for one service.", {
+      readCapability6("resources.list", "List bookable resources, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability5("staff.list", "List staff, optionally for one service.", {
+      readCapability6("staff.list", "List staff, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability5("appointments.list", "List appointments from a required start time.", {
+      readCapability6("appointments.list", "List appointments from a required start time.", {
         from_time: {
           type: "string",
           description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format."
@@ -53810,17 +55229,17 @@ var zohoBookingsConnector = {
         staff_id: { type: "string" },
         status: { type: "string" }
       }, ["from_time"]),
-      readCapability5("appointments.get", "Read one appointment by booking id.", {
+      readCapability6("appointments.get", "Read one appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"]),
-      readCapability5("availability.fetch", "Fetch open time slots for a service and date.", {
+      readCapability6("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"]),
-      mutationCapability5("appointments.book", "Book an appointment for a customer.", {
+      mutationCapability6("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: {
@@ -53836,13 +55255,13 @@ var zohoBookingsConnector = {
         additional_fields: { type: "object" },
         payment_info: { type: "object" }
       }, ["service_id", "from_time", "customer_details"]),
-      mutationCapability5("appointments.reschedule", "Move an appointment to a new time, staff member, or group.", {
+      mutationCapability6("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"]),
-      mutationCapability5("appointments.cancel", "Cancel an appointment by booking id.", {
+      mutationCapability6("appointments.cancel", "Cancel an appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"])
     ]
@@ -53959,7 +55378,7 @@ var zohoBookingsConnector = {
     }
   }
 };
-function readCapability5(name, description, properties, required = []) {
+function readCapability6(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -53968,7 +55387,7 @@ function readCapability5(name, description, properties, required = []) {
     requiredScopes: ["zohobookings.data.READ"]
   };
 }
-function mutationCapability5(name, description, properties, required) {
+function mutationCapability6(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -62864,6 +64283,11 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => amazonSqsConnector, {}),
   defineFactoryAdapter(() => httpConnector, {}),
   defineFactoryAdapter(() => rssConnector, {}),
+  defineFactoryAdapter(() => kafkaConnector, {}),
+  defineFactoryAdapter(() => csvFilesConnector, {}),
+  defineFactoryAdapter(() => excelFilesConnector, {}),
+  defineFactoryAdapter(() => parquetFilesConnector, {}),
+  defineFactoryAdapter(() => sftpConnector, {}),
   defineFactoryAdapter(() => chessComConnector, {}),
   defineFactoryAdapter(() => zapierConnector, {}),
   defineFactoryAdapter(() => makeConnector, {}),
@@ -68840,7 +70264,7 @@ var sanityConnector = declarativeRestConnector({
 var figmaConnector = declarativeRestConnector({
   kind: "figma",
   displayName: "Figma",
-  description: "Read Figma files, components, comments, and team projects; post comments back into the design source of truth.",
+  description: "Read Figma files, components, comments, and project metadata; post comments back into the design source of truth.",
   auth: {
     kind: "oauth2",
     authorizationUrl: "https://www.figma.com/oauth",
@@ -68853,7 +70277,7 @@ var figmaConnector = declarativeRestConnector({
       "file_dev_resources:read",
       "file_versions:read",
       "library_content:read",
-      "projects:read",
+      "project_metadata:read",
       "team_library_content:read",
       "webhooks:write"
     ],
@@ -69069,35 +70493,16 @@ var figmaConnector = declarativeRestConnector({
       requiredScopes: ["file_comments:read"]
     },
     {
-      name: "teams.projects.list",
+      name: "projects.metadata.get",
       class: "read",
-      description: "List projects inside a Figma team.",
+      description: "Get metadata for a Figma project visible to the authenticated user.",
       parameters: {
         type: "object",
-        properties: { team_id: { type: "string" } },
-        required: ["team_id"]
-      },
-      request: { method: "GET", path: "/v1/teams/{team_id}/projects" },
-      requiredScopes: ["projects:read"]
-    },
-    {
-      name: "projects.files.list",
-      class: "read",
-      description: "List Figma files inside a project.",
-      parameters: {
-        type: "object",
-        properties: {
-          project_id: { type: "string" },
-          branch_data: { type: "boolean" }
-        },
+        properties: { project_id: { type: "string" } },
         required: ["project_id"]
       },
-      request: {
-        method: "GET",
-        path: "/v1/projects/{project_id}/files",
-        query: { branch_data: "{branch_data}" }
-      },
-      requiredScopes: ["projects:read"]
+      request: { method: "GET", path: "/v1/projects/{project_id}/meta" },
+      requiredScopes: ["project_metadata:read"]
     },
     {
       name: "teams.components.list",
@@ -69264,7 +70669,7 @@ var figmaConnector = declarativeRestConnector({
 var figjamConnector = declarativeRestConnector({
   kind: "figjam",
   displayName: "FigJam",
-  description: "Read FigJam boards (stickies, connectors, shapes, sections), list team/project boards, render board images, and post or delete board comments through the Figma REST API.",
+  description: "Read FigJam boards (stickies, connectors, shapes, sections), project metadata, render board images, and post or delete board comments through the Figma REST API.",
   auth: {
     kind: "oauth2",
     authorizationUrl: "https://www.figma.com/oauth",
@@ -69275,7 +70680,7 @@ var figjamConnector = declarativeRestConnector({
       "file_comments:write",
       "file_content:read",
       "file_versions:read",
-      "projects:read",
+      "project_metadata:read",
       "webhooks:write"
     ],
     clientIdEnv: "FIGMA_OAUTH_CLIENT_ID",
@@ -69433,33 +70838,16 @@ var figjamConnector = declarativeRestConnector({
       requiredScopes: ["file_comments:read"]
     },
     {
-      name: "teams.projects.list",
-      class: "read",
-      description: "List projects inside a Figma team (FigJam boards live alongside Figma design files inside projects).",
-      parameters: {
-        type: "object",
-        properties: { team_id: { type: "string" } },
-        required: ["team_id"]
-      },
-      request: { method: "GET", path: "/v1/teams/{team_id}/projects" },
-      requiredScopes: ["projects:read"]
-    },
-    {
-      name: "projects.files.list",
+      name: "projects.metadata.get",
       class: "read",
-      description: 'List files inside a project \u2014 response items expose a `type` field; FigJam boards are returned with type "jam" and design files with type "design".',
+      description: "Get metadata for a Figma/FigJam project visible to the authenticated user.",
       parameters: {
         type: "object",
-        properties: {
-          project_id: { type: "string" }
-        },
+        properties: { project_id: { type: "string" } },
         required: ["project_id"]
       },
-      request: {
-        method: "GET",
-        path: "/v1/projects/{project_id}/files"
-      },
-      requiredScopes: ["projects:read"]
+      request: { method: "GET", path: "/v1/projects/{project_id}/meta" },
+      requiredScopes: ["project_metadata:read"]
     },
     {
       name: "files.comments.create",
@@ -142735,6 +144123,7 @@ export {
   buttondownConnector,
   cambAiConnector,
   cartloomConnector,
+  csvFilesConnector,
   chainAwareConnector,
   chaindeskConnector,
   chatAidConnector,
@@ -142754,6 +144143,7 @@ export {
   dripConnector,
   echowinConnector,
   elevenlabsConnector,
+  excelFilesConnector,
   everhourConnector,
   featheryConnector,
   fellowConnector,
@@ -142857,6 +144247,9 @@ export {
   jiraCloudConnector,
   jotformConnector,
   justcallConnector,
+  createKafkaConnector,
+  kafkaConnector,
+  publicKafkaSocketFactory,
   leadConnectorConnector,
   lemonSqueezyConnector,
   linearConnector,
@@ -142892,12 +144285,15 @@ export {
   plaidConnector,
   pipedreamConnector,
   pipedriveConnector,
+  parquetFilesConnector,
   quickbooksConnector,
   recallAiConnector,
   rampConnector,
   ringcentralConnector,
   rssConnector,
   salesforceConnector,
+  createSftpConnector,
+  sftpConnector,
   saleorConnector,
   savvycalConnector,
   sharepoint,
@@ -143349,4 +144745,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-UC7J6GZF.js.map
+//# sourceMappingURL=chunk-5LDZLVKP.js.map