@tangle-network/agent-integrations 0.53.25 → 0.53.27

package/dist/{chunk-EXPZGJ4A.js → chunk-4H5F6E7W.js}

@@ -82,6 +82,7 @@ __export(adapters_exports, {
   azureAdConnector: () => azureAdConnector,
   azureBlobStorageConnector: () => azureBlobStorageConnector,
   azureCommunicationServicesConnector: () => azureCommunicationServicesConnector,
+  azureEventGridConnector: () => azureEventGridConnector,
   azureOpenaiConnector: () => azureOpenaiConnector,
   azureServiceBusConnector: () => azureServiceBusConnector,
   backblazeConnector: () => backblazeConnector,
@@ -142,6 +143,7 @@ __export(adapters_exports, {
   chatsistantConnector: () => chatsistantConnector,
   chatwootConnector: () => chatwootConnector,
   checkoutConnector: () => checkoutConnector,
+  chessComConnector: () => chessComConnector,
   circleConnector: () => circleConnector,
   classifyGoogleError: () => classifyGoogleError,
   classifyGoogleReason: () => classifyGoogleReason,
@@ -740,10 +742,10 @@ function canonicalUri(pathname, service) {
   if (!pathname) return "/";
   if (service === "s3") return pathname;
   const segments = [];
-  for (const segment of pathname.split("/")) {
-    if (segment.length === 0 || segment === ".") continue;
-    if (segment === "..") segments.pop();
-    else segments.push(segment);
+  for (const segment2 of pathname.split("/")) {
+    if (segment2.length === 0 || segment2 === ".") continue;
+    if (segment2 === "..") segments.pop();
+    else segments.push(segment2);
   }
   const normalized = `/${segments.join("/")}${segments.length > 0 && pathname.endsWith("/") ? "/" : ""}`;
   return awsUriEncode(normalized).replace(/%2F/g, "/");
@@ -787,11 +789,11 @@ function declarativeRestConnector(spec) {
       const op = readOperation(spec, inv.capabilityName, "read");
       const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
       if (response.outcome === "rate-limited") {
-        const retryAfterMs6 = response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
+        const retryAfterMs7 = response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
         throw new ProviderRateLimited(
-          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs6}ms`,
+          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs7}ms`,
           inv.source.id,
-          { status: 429, body: response.data, retryAfterMs: retryAfterMs6 }
+          { status: 429, body: response.data, retryAfterMs: retryAfterMs7 }
         );
       }
       if (response.outcome === "conflict") {
@@ -11929,11 +11931,11 @@ async function azureRequest(credentials, inv, method, pathSegments, query2 = new
     throw new CredentialsExpired(`Azure Blob Storage rejected credentials (${response.status})`, inv.source.id);
   }
   if (response.status === 429 || response.status === 503) {
-    const retryAfterMs6 = retryAfter(response.headers.get("retry-after"));
+    const retryAfterMs7 = retryAfter(response.headers.get("retry-after"));
     throw new ProviderRateLimited(
-      `Azure Blob Storage rate limit (${response.status}); retry after ${retryAfterMs6}ms`,
+      `Azure Blob Storage rate limit (${response.status}); retry after ${retryAfterMs7}ms`,
       inv.source.id,
-      { status: response.status, retryAfterMs: retryAfterMs6 }
+      { status: response.status, retryAfterMs: retryAfterMs7 }
     );
   }
   if (!response.ok) {
@@ -12079,7 +12081,7 @@ function requiredContainer(value, allowSystem = true) {
 function requiredBlobName(value) {
   const name = requiredString3(value, "blobName");
   if (name.length > 1024) throw new Error("blobName cannot exceed 1024 characters");
-  if (name.split("/").some((segment) => segment === "." || segment === "..")) {
+  if (name.split("/").some((segment2) => segment2 === "." || segment2 === "..")) {
     throw new Error("blobName cannot contain dot path segments");
   }
   return name;
@@ -12206,6 +12208,317 @@ function numberOrUndefined(value) {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 
+// src/connectors/adapters/azure-event-grid.ts
+import { createHash as createHash3, timingSafeEqual } from "crypto";
+var API_VERSION2 = "2018-01-01";
+var MAX_BATCH_BYTES = 1024 * 1024;
+var MAX_EVENTS = 5e3;
+var EVENT_GRID_SUFFIXES = [
+  ".eventgrid.azure.net",
+  ".eventgrid.azure.us",
+  ".eventgrid.azure.cn"
+];
+var azureEventGridConnector = {
+  manifest: {
+    kind: "azure-event-grid",
+    displayName: "Azure Event Grid",
+    description: "Publish Event Grid and CloudEvents batches to customer topics and authenticate inbound subscription validation and event delivery.",
+    auth: {
+      kind: "api-key",
+      hint: "JSON containing endpoint, accessKey, and deliverySecret. endpoint is the Azure custom topic or domain /api/events URL. Configure deliverySecret as the static x-tangle-eventgrid-secret delivery header on each Event Grid subscription."
+    },
+    category: "webhook",
+    defaultConsistencyModel: "advisory",
+    rateLimit: { requests: 600, windowMs: 6e4, scope: "data-source" },
+    capabilities: [
+      mutationCapability2(
+        "events.publish",
+        "Publish a bounded batch using the native Azure Event Grid event schema.",
+        "Events require id, eventType, subject, eventTime, dataVersion, and data."
+      ),
+      mutationCapability2(
+        "cloudEvents.publish",
+        "Publish a bounded CloudEvents 1.0 batch.",
+        "CloudEvents require id, source, type, specversion=1.0, and data."
+      )
+    ]
+  },
+  async executeMutation(inv) {
+    const credentials = parseCredentials(inv.source.credentials, inv.source.id);
+    const events = inv.capabilityName === "events.publish" ? eventGridEvents(inv.args.events) : inv.capabilityName === "cloudEvents.publish" ? cloudEvents(inv.args.events) : void 0;
+    if (!events) throw new Error(`azure-event-grid: unknown mutation capability ${inv.capabilityName}`);
+    const body = JSON.stringify(events);
+    if (Buffer.byteLength(body) > MAX_BATCH_BYTES) {
+      throw new Error(`Azure Event Grid batch exceeds ${MAX_BATCH_BYTES} bytes`);
+    }
+    const response = await fetch(publishUrl(credentials.endpoint), {
+      method: "POST",
+      headers: {
+        "aeg-sas-key": credentials.accessKey,
+        "content-type": inv.capabilityName === "cloudEvents.publish" ? "application/cloudevents-batch+json; charset=utf-8" : "application/json; charset=utf-8",
+        accept: "application/json"
+      },
+      body
+    });
+    const responseBody = await readBoundedText(response, 256 * 1024);
+    if (!response.ok) throwEventGridError(response, responseBody, inv);
+    return {
+      status: "committed",
+      data: { accepted: true, count: events.length, requestId: response.headers.get("x-ms-request-id") ?? void 0 },
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  verifySignature({ headers, source }) {
+    let credentials;
+    try {
+      credentials = parseCredentials(source.credentials, source.id);
+    } catch {
+      return { valid: false, reason: "Azure Event Grid credentials are invalid" };
+    }
+    const provided = headerValue(headers, "x-tangle-eventgrid-secret");
+    if (!provided) return { valid: false, reason: "Missing x-tangle-eventgrid-secret delivery header" };
+    const expectedDigest = createHash3("sha256").update(credentials.deliverySecret).digest();
+    const providedDigest = createHash3("sha256").update(provided).digest();
+    return timingSafeEqual(expectedDigest, providedDigest) ? { valid: true } : { valid: false, reason: "Invalid x-tangle-eventgrid-secret delivery header" };
+  },
+  async handleInboundEvent({ rawBody }) {
+    if (Buffer.byteLength(rawBody) > MAX_BATCH_BYTES) {
+      throw new Error(`Azure Event Grid delivery exceeds ${MAX_BATCH_BYTES} bytes`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(rawBody);
+    } catch {
+      throw new Error("Azure Event Grid delivery body must be valid JSON");
+    }
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    if (entries.length > MAX_EVENTS) throw new Error(`Azure Event Grid delivery exceeds ${MAX_EVENTS} events`);
+    const validation = entries.find((entry) => isValidationEvent(entry));
+    if (validation && isRecord(validation.data) && typeof validation.data.validationCode === "string") {
+      return {
+        events: [],
+        response: { status: 200, body: { validationResponse: validation.data.validationCode } }
+      };
+    }
+    return {
+      events: entries.map((entry, index) => inboundEvent(entry, index))
+    };
+  },
+  async test(source) {
+    try {
+      parseCredentials(source.credentials, source.id);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, reason: error instanceof Error ? error.message : "Azure Event Grid credentials are invalid" };
+    }
+  }
+};
+function mutationCapability2(name, description, eventDescription) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        events: {
+          type: "array",
+          minItems: 1,
+          maxItems: MAX_EVENTS,
+          description: eventDescription
+        }
+      },
+      required: ["events"]
+    },
+    cas: "none",
+    externalEffect: true
+  };
+}
+function parseCredentials(credentials, dataSourceId) {
+  if (credentials.kind !== "api-key") {
+    throw new CredentialsExpired("Azure Event Grid requires a credential JSON bundle", dataSourceId);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(credentials.apiKey);
+  } catch {
+    throw new CredentialsExpired("Azure Event Grid credentials must be valid JSON", dataSourceId);
+  }
+  if (!isRecord(parsed)) throw new CredentialsExpired("Azure Event Grid credentials must be a JSON object", dataSourceId);
+  const endpointValue = credentialString(parsed.endpoint, "endpoint", dataSourceId);
+  const accessKey = credentialString(parsed.accessKey, "accessKey", dataSourceId);
+  const deliverySecret = credentialString(parsed.deliverySecret, "deliverySecret", dataSourceId);
+  let endpoint;
+  try {
+    endpoint = new URL(endpointValue);
+  } catch {
+    throw new CredentialsExpired("Azure Event Grid endpoint is invalid", dataSourceId);
+  }
+  if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.port || endpoint.search || endpoint.hash || endpoint.pathname.replace(/\/$/, "").toLowerCase() !== "/api/events" || !EVENT_GRID_SUFFIXES.some((suffix) => endpoint.hostname.endsWith(suffix))) {
+    throw new CredentialsExpired("Azure Event Grid endpoint must be a public Azure custom topic or domain /api/events URL", dataSourceId);
+  }
+  if (!canonicalBase64(accessKey) || Buffer.from(accessKey, "base64").length < 16) {
+    throw new CredentialsExpired("Azure Event Grid accessKey must be a valid base64 topic key", dataSourceId);
+  }
+  if (deliverySecret.length < 32 || deliverySecret.length > 4096) {
+    throw new CredentialsExpired("Azure Event Grid deliverySecret must contain 32 to 4096 characters", dataSourceId);
+  }
+  endpoint.pathname = "/api/events";
+  return { endpoint, accessKey, deliverySecret };
+}
+function publishUrl(endpoint) {
+  const url = new URL(endpoint);
+  url.searchParams.set("api-version", API_VERSION2);
+  return url;
+}
+function eventGridEvents(value) {
+  const entries = eventArray(value);
+  return entries.map((entry, index) => {
+    const result = {
+      id: requiredString4(entry.id, `events[${index}].id`),
+      eventType: requiredString4(entry.eventType, `events[${index}].eventType`),
+      subject: requiredString4(entry.subject, `events[${index}].subject`),
+      eventTime: isoDate(entry.eventTime, `events[${index}].eventTime`),
+      dataVersion: requiredString4(entry.dataVersion, `events[${index}].dataVersion`),
+      data: requiredJsonValue(entry.data, `events[${index}].data`)
+    };
+    if (entry.topic !== void 0) result.topic = requiredString4(entry.topic, `events[${index}].topic`);
+    return result;
+  });
+}
+function cloudEvents(value) {
+  const entries = eventArray(value);
+  return entries.map((entry, index) => {
+    if (entry.specversion !== "1.0") throw new Error(`events[${index}].specversion must be 1.0`);
+    const result = {
+      specversion: "1.0",
+      id: requiredString4(entry.id, `events[${index}].id`),
+      source: requiredString4(entry.source, `events[${index}].source`),
+      type: requiredString4(entry.type, `events[${index}].type`),
+      data: requiredJsonValue(entry.data, `events[${index}].data`)
+    };
+    if (entry.subject !== void 0) result.subject = requiredString4(entry.subject, `events[${index}].subject`);
+    if (entry.time !== void 0) result.time = isoDate(entry.time, `events[${index}].time`);
+    if (entry.datacontenttype !== void 0) result.datacontenttype = requiredString4(entry.datacontenttype, `events[${index}].datacontenttype`);
+    if (entry.dataschema !== void 0) result.dataschema = requiredString4(entry.dataschema, `events[${index}].dataschema`);
+    return result;
+  });
+}
+function eventArray(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > MAX_EVENTS) {
+    throw new Error(`events must contain 1 to ${MAX_EVENTS} entries`);
+  }
+  return value.map((entry, index) => {
+    if (!isRecord(entry)) throw new Error(`events[${index}] must be an object`);
+    return entry;
+  });
+}
+function inboundEvent(entry, index) {
+  if (!isRecord(entry)) throw new Error(`Azure Event Grid delivery entry ${index} must be an object`);
+  const eventType = typeof entry.eventType === "string" ? entry.eventType : typeof entry.type === "string" ? entry.type : "azure.event-grid.event";
+  return {
+    eventType,
+    providerEventId: typeof entry.id === "string" ? entry.id : void 0,
+    payload: entry
+  };
+}
+function isValidationEvent(value) {
+  return isRecord(value) && value.eventType === "Microsoft.EventGrid.SubscriptionValidationEvent";
+}
+function throwEventGridError(response, body, inv) {
+  const redacted = body.replace(/[A-Za-z0-9+/]{32,}={0,2}/g, "[redacted]").slice(0, 500);
+  if (response.status === 401) {
+    throw new CredentialsExpired("Azure Event Grid rejected the topic access key", inv.source.id, {
+      status: response.status,
+      body: redacted
+    });
+  }
+  if (response.status === 403) {
+    throw new ProviderConfigError("Azure Event Grid topic policy rejected publishing", inv.source.id, {
+      status: response.status,
+      body: redacted
+    });
+  }
+  if (response.status === 429 || response.status === 503) {
+    throw new ProviderRateLimited("Azure Event Grid is throttling publishes", inv.source.id, {
+      status: response.status,
+      body: redacted,
+      retryAfterMs: retryAfterMs3(response.headers.get("retry-after"))
+    });
+  }
+  throw new Error(`Azure Event Grid publish failed with HTTP ${response.status}: ${redacted}`);
+}
+async function readBoundedText(response, limit) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limit) throw new Error(`Azure Event Grid response exceeds ${limit} bytes`);
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > limit) {
+      await reader.cancel();
+      throw new Error(`Azure Event Grid response exceeds ${limit} bytes`);
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(body);
+}
+function headerValue(headers, name) {
+  const match = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+  return Array.isArray(match) ? match[0] : match;
+}
+function credentialString(value, field, dataSourceId) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new CredentialsExpired(`Azure Event Grid ${field} is missing`, dataSourceId);
+  }
+  return value.trim();
+}
+function requiredString4(value, field) {
+  if (typeof value !== "string" || value.trim() === "" || value.length > 4096) {
+    throw new Error(`${field} must be a non-empty string no longer than 4096 characters`);
+  }
+  return value;
+}
+function isoDate(value, field) {
+  const parsed = requiredString4(value, field);
+  const date = new Date(parsed);
+  if (!Number.isFinite(date.getTime())) throw new Error(`${field} must be an ISO 8601 timestamp`);
+  return date.toISOString();
+}
+function requiredJsonValue(value, field) {
+  if (value === void 0) throw new Error(`${field} is required`);
+  try {
+    if (JSON.stringify(value) === void 0) throw new Error("not JSON");
+  } catch {
+    throw new Error(`${field} must be JSON-serializable`);
+  }
+  return value;
+}
+function canonicalBase64(value) {
+  return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value) && Buffer.from(value, "base64").toString("base64").replace(/=+$/, "") === value.replace(/=+$/, "");
+}
+function retryAfterMs3(value) {
+  if (!value) return 6e4;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 6e4;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/connectors/adapters/azure-service-bus.ts
 import { createHmac as createHmac3 } from "crypto";
 var MANAGEMENT_API_VERSION = "2017-04";
@@ -12249,22 +12562,22 @@ var azureServiceBusConnector = {
         topic: { type: "string" },
         subscription: { type: "string" }
       }, ["topic", "subscription"]),
-      mutationCapability2("queues.send", "Send a UTF-8 or base64 message to a queue.", sendProperties("queue"), ["queue", "content"]),
-      mutationCapability2("topics.send", "Publish a UTF-8 or base64 message to a topic.", sendProperties("topic"), ["topic", "content"]),
-      mutationCapability2("queues.receiveDelete", "Receive and permanently delete the next queue message.", {
+      mutationCapability3("queues.send", "Send a UTF-8 or base64 message to a queue.", sendProperties("queue"), ["queue", "content"]),
+      mutationCapability3("topics.send", "Publish a UTF-8 or base64 message to a topic.", sendProperties("topic"), ["topic", "content"]),
+      mutationCapability3("queues.receiveDelete", "Receive and permanently delete the next queue message.", {
         queue: { type: "string" },
         timeoutSeconds: { type: "integer", minimum: 0, maximum: 55 }
       }, ["queue"]),
-      mutationCapability2("subscriptions.receiveDelete", "Receive and permanently delete the next message from a topic subscription.", {
+      mutationCapability3("subscriptions.receiveDelete", "Receive and permanently delete the next message from a topic subscription.", {
         topic: { type: "string" },
         subscription: { type: "string" },
         timeoutSeconds: { type: "integer", minimum: 0, maximum: 55 }
       }, ["topic", "subscription"]),
-      mutationCapability2("queues.deadLetters.receiveDelete", "Receive and permanently delete the next queue dead-letter message.", {
+      mutationCapability3("queues.deadLetters.receiveDelete", "Receive and permanently delete the next queue dead-letter message.", {
         queue: { type: "string" },
         timeoutSeconds: { type: "integer", minimum: 0, maximum: 55 }
       }, ["queue"]),
-      mutationCapability2("subscriptions.deadLetters.receiveDelete", "Receive and permanently delete the next subscription dead-letter message.", {
+      mutationCapability3("subscriptions.deadLetters.receiveDelete", "Receive and permanently delete the next subscription dead-letter message.", {
         topic: { type: "string" },
         subscription: { type: "string" },
         timeoutSeconds: { type: "integer", minimum: 0, maximum: 55 }
@@ -12383,7 +12696,7 @@ function readCapability2(name, description, properties, required = []) {
     parameters: { type: "object", properties, ...required.length ? { required } : {} }
   };
 }
-function mutationCapability2(name, description, properties, required) {
+function mutationCapability3(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -12471,7 +12784,7 @@ function parseConnectionString(credentials, dataSourceId) {
 }
 async function sendMessage(credentials, inv, entityPath) {
   enforceEntityPath(credentials, entityPath);
-  const content = requiredString4(inv.args.content, "content", true);
+  const content = requiredString5(inv.args.content, "content", true);
   const encoding = inv.args.encoding === void 0 ? "utf-8" : enumValue(inv.args.encoding, "encoding", ["utf-8", "base64"]);
   const body = encoding === "base64" ? strictBase64(content) : Buffer.from(content, "utf8");
   if (body.byteLength > MAX_MESSAGE_BYTES) {
@@ -12563,17 +12876,17 @@ ${expiry}`, "utf8").digest("base64");
     throw new ProviderRateLimited("Azure Service Bus is throttling requests", inv.source.id, {
       status: response.status,
       body: redactProviderText(text),
-      retryAfterMs: retryAfterMs3(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs4(response.headers.get("retry-after"))
     });
   }
   throw new Error(`Azure Service Bus request failed with HTTP ${response.status}: ${redactProviderText(text).slice(0, 500)}`);
 }
-function encodePathSegment2(segment) {
-  if (segment === "$Resources" || segment === "$DeadLetterQueue") return segment;
-  return encodeURIComponent(segment);
+function encodePathSegment2(segment2) {
+  if (segment2 === "$Resources" || segment2 === "$DeadLetterQueue") return segment2;
+  return encodeURIComponent(segment2);
 }
 function entityName(value, field) {
-  const name = requiredString4(value, field);
+  const name = requiredString5(value, field);
   if (!/^[A-Za-z0-9][A-Za-z0-9._~-]{0,259}$/.test(name)) {
     throw new Error(`${field} must be a valid Azure Service Bus entity name`);
   }
@@ -12608,7 +12921,7 @@ var BROKER_PROPERTY_NAMES = /* @__PURE__ */ new Set([
 ]);
 function allowedBrokerProperties(value) {
   if (value === void 0) return void 0;
-  if (!isRecord(value)) throw new Error("brokerProperties must be an object");
+  if (!isRecord2(value)) throw new Error("brokerProperties must be an object");
   const entries = Object.entries(value);
   if (entries.length > BROKER_PROPERTY_NAMES.size) throw new Error("brokerProperties contains too many fields");
   const result = {};
@@ -12631,7 +12944,7 @@ var RESERVED_HEADERS = /* @__PURE__ */ new Set([
 ]);
 function applicationPropertyHeaders(value) {
   if (value === void 0) return {};
-  if (!isRecord(value)) throw new Error("applicationProperties must be an object");
+  if (!isRecord2(value)) throw new Error("applicationProperties must be an object");
   const entries = Object.entries(value);
   if (entries.length > 64) throw new Error("applicationProperties cannot contain more than 64 entries");
   const result = {};
@@ -12646,10 +12959,10 @@ function applicationPropertyHeaders(value) {
     if (typeof property === "number" && !Number.isFinite(property)) {
       throw new Error(`applicationProperties.${key} must be finite`);
     }
-    const headerValue = requiredHeaderValue(String(property), `applicationProperties.${key}`);
-    size += Buffer.byteLength(key) + Buffer.byteLength(headerValue);
+    const headerValue2 = requiredHeaderValue(String(property), `applicationProperties.${key}`);
+    size += Buffer.byteLength(key) + Buffer.byteLength(headerValue2);
     if (size > 32 * 1024) throw new Error("applicationProperties exceeds 32768 bytes");
-    result[key] = headerValue;
+    result[key] = headerValue2;
   }
   return result;
 }
@@ -12668,7 +12981,7 @@ function parseAtomFeed(xml) {
   };
 }
 function parseAtomEntry(xml) {
-  const title = xmlValue(xml, "title");
+  const title2 = xmlValue(xml, "title");
   const id2 = xmlValue(xml, "id");
   const updated = xmlValue(xml, "updated");
   const properties = {};
@@ -12678,7 +12991,7 @@ function parseAtomEntry(xml) {
     const raw = decodeXml2(match[2]);
     properties[key] = xmlScalar(raw);
   }
-  return { title, id: id2, updated, properties };
+  return { title: title2, id: id2, updated, properties };
 }
 function xmlValue(xml, tag) {
   const match = xml.match(new RegExp(`<(?:[A-Za-z0-9]+:)?${tag}\\b[^>]*>([^<]*)<\\/(?:[A-Za-z0-9]+:)?${tag}>`, "i"));
@@ -12727,14 +13040,14 @@ function strictBase64(value) {
   }
   return Buffer.from(value, "base64");
 }
-function requiredString4(value, field, allowEmpty = false) {
+function requiredString5(value, field, allowEmpty = false) {
   if (typeof value !== "string" || !allowEmpty && value.trim() === "") {
     throw new Error(`${field} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
   }
   return allowEmpty ? value : value.trim();
 }
 function requiredHeaderValue(value, field) {
-  const parsed = requiredString4(value, field);
+  const parsed = requiredString5(value, field);
   if (/\r|\n/.test(parsed) || parsed.length > 4096) throw new Error(`${field} is not a safe header value`);
   return parsed;
 }
@@ -12753,7 +13066,7 @@ function enumValue(value, field, choices) {
 function decodeUtf82(value) {
   return new TextDecoder("utf-8", { fatal: true }).decode(value);
 }
-function retryAfterMs3(value) {
+function retryAfterMs4(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
@@ -12763,7 +13076,7 @@ function retryAfterMs3(value) {
 function redactProviderText(value) {
   return value.replace(/SharedAccessSignature\s+[^\s<]+/gi, "SharedAccessSignature [redacted]").replace(/SharedAccessKey=[^;\s<]+/gi, "SharedAccessKey=[redacted]");
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -19296,8 +19609,258 @@ var checkoutConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/chess-com.ts
+var API_ORIGIN = "https://api.chess.com";
+var DEFAULT_TIMEOUT_MS = 15e3;
+var MAX_RESPONSE_BYTES3 = 5 * 1024 * 1024;
+var USERNAME_PATTERN = /^[A-Za-z0-9_-]{3,25}$/;
+var SLUG_PATTERN = /^[A-Za-z0-9_-]{1,100}$/;
+var TITLES = ["GM", "WGM", "IM", "WIM", "FM", "WFM", "NM", "WNM", "CM", "WCM"];
+var usernameProperty = {
+  type: "string",
+  description: "Chess.com username, without a profile URL.",
+  pattern: USERNAME_PATTERN.source
+};
+var slugProperty = {
+  type: "string",
+  description: "Chess.com URL id (the final path segment of the public page URL).",
+  pattern: SLUG_PATTERN.source
+};
+var CAPABILITIES = [
+  readCapability3("get.player.profile", "Get the public profile for a Chess.com player.", { username: usernameProperty }, ["username"]),
+  readCapability3("get.player.stats", "Get ratings and game statistics for a Chess.com player.", { username: usernameProperty }, ["username"]),
+  readCapability3("player.current-games", "List a player\u2019s currently ongoing daily games.", { username: usernameProperty }, ["username"]),
+  readCapability3("player.game-archives", "List the monthly game archive URLs available for a player.", { username: usernameProperty }, ["username"]),
+  readCapability3("player.monthly-games", "Get a player\u2019s games for one calendar month as structured JSON.", {
+    username: usernameProperty,
+    year: { type: "integer", minimum: 2007, maximum: 2100 },
+    month: { type: "integer", minimum: 1, maximum: 12 }
+  }, ["username", "year", "month"]),
+  readCapability3("player.monthly-pgn", "Get a player\u2019s games for one calendar month as a PGN document.", {
+    username: usernameProperty,
+    year: { type: "integer", minimum: 2007, maximum: 2100 },
+    month: { type: "integer", minimum: 1, maximum: 12 }
+  }, ["username", "year", "month"]),
+  readCapability3("player.clubs", "List the public clubs a player belongs to.", { username: usernameProperty }, ["username"]),
+  readCapability3("player.matches", "List a player\u2019s current and finished team matches.", { username: usernameProperty }, ["username"]),
+  readCapability3("player.tournaments", "List a player\u2019s current, registered, and finished tournaments.", { username: usernameProperty }, ["username"]),
+  readCapability3("get.daily.puzzle", "Get the current Chess.com daily puzzle.", {}),
+  readCapability3("puzzle.random", "Get a random Chess.com puzzle.", {}),
+  readCapability3("players.titled", "List usernames holding a FIDE or national chess title.", {
+    title: { type: "string", enum: [...TITLES] }
+  }, ["title"]),
+  readCapability3("leaderboards.get", "Get current Chess.com leaderboards.", {}),
+  readCapability3("streamers.list", "List Chess.com streamers and their public channels.", {}),
+  readCapability3("country.get", "Get public information for a country.", {
+    country: { type: "string", description: "Two-letter ISO 3166 country code.", pattern: "^[A-Za-z]{2}$" }
+  }, ["country"]),
+  readCapability3("country.players", "List Chess.com players registered to a country.", {
+    country: { type: "string", description: "Two-letter ISO 3166 country code.", pattern: "^[A-Za-z]{2}$" }
+  }, ["country"]),
+  readCapability3("country.clubs", "List Chess.com clubs registered to a country.", {
+    country: { type: "string", description: "Two-letter ISO 3166 country code.", pattern: "^[A-Za-z]{2}$" }
+  }, ["country"]),
+  readCapability3("club.get", "Get public information for a Chess.com club.", { club: slugProperty }, ["club"]),
+  readCapability3("club.members", "List members of a Chess.com club, grouped by activity.", { club: slugProperty }, ["club"]),
+  readCapability3("club.matches", "List a Chess.com club\u2019s current and finished team matches.", { club: slugProperty }, ["club"]),
+  readCapability3("club.admins", "List public administrators for a Chess.com club.", { club: slugProperty }, ["club"]),
+  readCapability3("tournament.get", "Get public details for a Chess.com tournament.", { tournament: slugProperty }, ["tournament"]),
+  readCapability3("tournament.round", "Get one round of a Chess.com tournament.", {
+    tournament: slugProperty,
+    round: { type: "integer", minimum: 1 }
+  }, ["tournament", "round"]),
+  readCapability3("tournament.group", "Get one group within a Chess.com tournament round.", {
+    tournament: slugProperty,
+    round: { type: "integer", minimum: 1 },
+    group: { type: "integer", minimum: 1 }
+  }, ["tournament", "round", "group"])
+];
+var chessComConnector = {
+  manifest: {
+    kind: "chess-com",
+    displayName: "Chess.com",
+    description: "Read public Chess.com profiles, ratings, games, puzzles, leaderboards, clubs, countries, tournaments, and streaming data without credentials.",
+    auth: { kind: "none" },
+    category: "other",
+    defaultConsistencyModel: "cache",
+    rateLimit: { requests: 60, windowMs: 6e4, scope: "data-source" },
+    capabilities: CAPABILITIES
+  },
+  async executeRead(inv) {
+    const path = route(inv.capabilityName, inv.args);
+    const response = await fetch(`${API_ORIGIN}${path}`, {
+      method: "GET",
+      headers: {
+        accept: inv.capabilityName === "player.monthly-pgn" ? "application/x-chess-pgn, text/plain;q=0.9" : "application/json",
+        "user-agent": "Tangle-Integrations/1.0 (+https://tangle.tools)"
+      },
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    const body = await readBoundedBody(response);
+    if (!response.ok) {
+      const detail = body.length > 200 ? `${body.slice(0, 200)}\u2026` : body;
+      throw new Error(`Chess.com ${inv.capabilityName} failed: ${response.status} ${detail || response.statusText}`);
+    }
+    return {
+      data: parseBody(body, response.headers.get("content-type")),
+      etag: response.headers.get("etag") ?? response.headers.get("last-modified") ?? void 0,
+      fetchedAt: Date.now()
+    };
+  },
+  async test() {
+    try {
+      const response = await fetch(`${API_ORIGIN}/pub/leaderboards`, {
+        method: "GET",
+        headers: {
+          accept: "application/json",
+          "user-agent": "Tangle-Integrations/1.0 (+https://tangle.tools)"
+        },
+        signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+      });
+      return response.ok ? { ok: true } : { ok: false, reason: `Chess.com public API returned ${response.status}` };
+    } catch (error) {
+      return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+  }
+};
+function readCapability3(name, description, properties, required = []) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      additionalProperties: false
+    }
+  };
+}
+function route(capabilityName, args) {
+  const username = () => segment(args.username, "username", USERNAME_PATTERN);
+  const club = () => segment(args.club, "club", SLUG_PATTERN);
+  const tournament = () => segment(args.tournament, "tournament", SLUG_PATTERN);
+  switch (capabilityName) {
+    case "get.player.profile":
+      return `/pub/player/${username()}`;
+    case "get.player.stats":
+      return `/pub/player/${username()}/stats`;
+    case "player.current-games":
+      return `/pub/player/${username()}/games/current`;
+    case "player.game-archives":
+      return `/pub/player/${username()}/games/archives`;
+    case "player.monthly-games":
+      return `/pub/player/${username()}/games/${integer(args.year, "year", 2007, 2100)}/${month(args.month)}`;
+    case "player.monthly-pgn":
+      return `/pub/player/${username()}/games/${integer(args.year, "year", 2007, 2100)}/${month(args.month)}/pgn`;
+    case "player.clubs":
+      return `/pub/player/${username()}/clubs`;
+    case "player.matches":
+      return `/pub/player/${username()}/matches`;
+    case "player.tournaments":
+      return `/pub/player/${username()}/tournaments`;
+    case "get.daily.puzzle":
+      return "/pub/puzzle";
+    case "puzzle.random":
+      return "/pub/puzzle/random";
+    case "players.titled":
+      return `/pub/titled/${title(args.title)}`;
+    case "leaderboards.get":
+      return "/pub/leaderboards";
+    case "streamers.list":
+      return "/pub/streamers";
+    case "country.get":
+      return `/pub/country/${country(args.country)}`;
+    case "country.players":
+      return `/pub/country/${country(args.country)}/players`;
+    case "country.clubs":
+      return `/pub/country/${country(args.country)}/clubs`;
+    case "club.get":
+      return `/pub/club/${club()}`;
+    case "club.members":
+      return `/pub/club/${club()}/members`;
+    case "club.matches":
+      return `/pub/club/${club()}/matches`;
+    case "club.admins":
+      return `/pub/club/${club()}/admin`;
+    case "tournament.get":
+      return `/pub/tournament/${tournament()}`;
+    case "tournament.round":
+      return `/pub/tournament/${tournament()}/${integer(args.round, "round", 1, 1e6)}`;
+    case "tournament.group":
+      return `/pub/tournament/${tournament()}/${integer(args.round, "round", 1, 1e6)}/${integer(args.group, "group", 1, 1e6)}`;
+    default:
+      throw new Error(`Chess.com does not support capability ${capabilityName}`);
+  }
+}
+function segment(value, label, pattern) {
+  if (typeof value !== "string" || !pattern.test(value)) {
+    throw new Error(`${label} has an invalid Chess.com path value`);
+  }
+  return encodeURIComponent(value.toLowerCase());
+}
+function integer(value, label, minimum, maximum) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${label} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return value;
+}
+function month(value) {
+  return String(integer(value, "month", 1, 12)).padStart(2, "0");
+}
+function country(value) {
+  if (typeof value !== "string" || !/^[A-Za-z]{2}$/.test(value)) {
+    throw new Error("country must be a two-letter ISO 3166 code");
+  }
+  return value.toUpperCase();
+}
+function title(value) {
+  if (typeof value !== "string" || !TITLES.includes(value.toUpperCase())) {
+    throw new Error(`title must be one of ${TITLES.join(", ")}`);
+  }
+  return value.toUpperCase();
+}
+async function readBoundedBody(response) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_RESPONSE_BYTES3) {
+    throw new Error(`Chess.com response exceeds ${MAX_RESPONSE_BYTES3} bytes`);
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > MAX_RESPONSE_BYTES3) {
+      await reader.cancel();
+      throw new Error(`Chess.com response exceeds ${MAX_RESPONSE_BYTES3} bytes`);
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+function parseBody(body, contentType) {
+  if (body.length === 0) return null;
+  if (contentType?.includes("json")) {
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new Error("Chess.com returned malformed JSON");
+    }
+  }
+  return body;
+}
+
 // src/connectors/adapters/docuseal.ts
-import { createHmac as createHmac4, timingSafeEqual } from "crypto";
+import { createHmac as createHmac4, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var DEFAULT_BASE = "https://api.docuseal.com";
 function readDocuSealCredentials(creds) {
   if (creds.kind === "api-key" && typeof creds.apiKey === "string" && creds.apiKey.length > 0) {
@@ -19426,7 +19989,7 @@ function docuseal(opts = {}) {
       const a = Buffer.from(sig.toLowerCase(), "utf-8");
       const b = Buffer.from(expected, "utf-8");
       if (a.length !== b.length) return { valid: false, reason: "invalid_signature" };
-      return timingSafeEqual(a, b) ? { valid: true } : { valid: false, reason: "invalid_signature" };
+      return timingSafeEqual2(a, b) ? { valid: true } : { valid: false, reason: "invalid_signature" };
     },
     async handleInboundEvent({ rawBody }) {
       let parsed;
@@ -23044,7 +23607,7 @@ var frontConnector = declarativeRestConnector({
 });
 
 // src/connectors/oauth.ts
-import { createHash as createHash3, randomBytes } from "crypto";
+import { createHash as createHash4, randomBytes } from "crypto";
 var PENDING_TTL_MS = 10 * 60 * 1e3;
 var InMemoryOAuthFlowStore = class {
   pendingFlows = /* @__PURE__ */ new Map();
@@ -23072,7 +23635,7 @@ function startOAuthFlow(input) {
   const now = input.now ?? Date.now();
   store.sweep?.(now);
   const codeVerifier = base64Url(randomBytes(48));
-  const codeChallenge = base64Url(createHash3("sha256").update(codeVerifier).digest());
+  const codeChallenge = base64Url(createHash4("sha256").update(codeVerifier).digest());
   const state = base64Url(randomBytes(24));
   store.put(state, {
     codeVerifier,
@@ -24991,11 +25554,11 @@ var googleCloudStorageConnector = declarativeRestConnector({
 });
 
 // src/connectors/adapters/google-pubsub.ts
-import { createHash as createHash4, createSign } from "crypto";
+import { createHash as createHash5, createSign } from "crypto";
 var TOKEN_URL3 = "https://oauth2.googleapis.com/token";
 var API_ROOT = "https://pubsub.googleapis.com/v1";
 var PUBSUB_SCOPE = "https://www.googleapis.com/auth/pubsub";
-var MAX_RESPONSE_BYTES3 = 8 * 1024 * 1024;
+var MAX_RESPONSE_BYTES4 = 8 * 1024 * 1024;
 var MAX_REQUEST_BYTES = 1e7;
 var MAX_TOKEN_CACHE_ENTRIES = 256;
 var tokenCache = /* @__PURE__ */ new Map();
@@ -25016,14 +25579,14 @@ var googlePubSubConnector = {
     defaultConsistencyModel: "advisory",
     rateLimit: { requests: 600, windowMs: 6e4, scope: "data-source" },
     capabilities: [
-      readCapability3("topics.list", "List topics in the service account project.", {
+      readCapability4("topics.list", "List topics in the service account project.", {
         pageSize: { type: "integer", minimum: 1, maximum: 1e3 },
         pageToken: { type: "string" }
       }),
-      readCapability3("topics.get", "Get one topic and its server-side configuration.", {
+      readCapability4("topics.get", "Get one topic and its server-side configuration.", {
         topic: { type: "string", description: "Topic ID in the service account project." }
       }, ["topic"]),
-      mutationCapability3("topics.create", "Create a topic in the service account project.", {
+      mutationCapability4("topics.create", "Create a topic in the service account project.", {
         topic: { type: "string" },
         labels: { type: "object", additionalProperties: { type: "string" } },
         allowedPersistenceRegions: { type: "array", items: { type: "string" } },
@@ -25031,10 +25594,10 @@ var googlePubSubConnector = {
         schema: { type: "string", description: "Full Pub/Sub schema resource name." },
         schemaEncoding: { type: "string", enum: ["JSON", "BINARY"] }
       }, ["topic"]),
-      mutationCapability3("topics.delete", "Delete a topic. Existing subscriptions remain but stop receiving messages.", {
+      mutationCapability4("topics.delete", "Delete a topic. Existing subscriptions remain but stop receiving messages.", {
         topic: { type: "string" }
       }, ["topic"]),
-      mutationCapability3("messages.publish", "Publish up to 1,000 messages to a topic.", {
+      mutationCapability4("messages.publish", "Publish up to 1,000 messages to a topic.", {
         topic: { type: "string" },
         messages: {
           type: "array",
@@ -25043,14 +25606,14 @@ var googlePubSubConnector = {
           description: "Messages with either text (UTF-8) or data (base64), plus optional string attributes and orderingKey."
         }
       }, ["topic", "messages"]),
-      readCapability3("subscriptions.list", "List subscriptions in the service account project.", {
+      readCapability4("subscriptions.list", "List subscriptions in the service account project.", {
         pageSize: { type: "integer", minimum: 1, maximum: 1e3 },
         pageToken: { type: "string" }
       }),
-      readCapability3("subscriptions.get", "Get one subscription and its delivery configuration.", {
+      readCapability4("subscriptions.get", "Get one subscription and its delivery configuration.", {
         subscription: { type: "string" }
       }, ["subscription"]),
-      mutationCapability3("subscriptions.create", "Create a pull subscription for a topic.", {
+      mutationCapability4("subscriptions.create", "Create a pull subscription for a topic.", {
         subscription: { type: "string" },
         topic: { type: "string" },
         ackDeadlineSeconds: { type: "integer", minimum: 10, maximum: 600 },
@@ -25066,18 +25629,18 @@ var googlePubSubConnector = {
         enableExactlyOnceDelivery: { type: "boolean" },
         labels: { type: "object", additionalProperties: { type: "string" } }
       }, ["subscription", "topic"]),
-      mutationCapability3("subscriptions.delete", "Delete a subscription and discard its retained messages.", {
+      mutationCapability4("subscriptions.delete", "Delete a subscription and discard its retained messages.", {
         subscription: { type: "string" }
       }, ["subscription"]),
-      mutationCapability3("messages.pull", "Pull messages and make them temporarily unavailable to other subscribers.", {
+      mutationCapability4("messages.pull", "Pull messages and make them temporarily unavailable to other subscribers.", {
         subscription: { type: "string" },
         maxMessages: { type: "integer", minimum: 1, maximum: 1e3 }
       }, ["subscription", "maxMessages"]),
-      mutationCapability3("messages.acknowledge", "Acknowledge delivered messages by ack ID.", {
+      mutationCapability4("messages.acknowledge", "Acknowledge delivered messages by ack ID.", {
         subscription: { type: "string" },
         ackIds: { type: "array", minItems: 1, maxItems: 1e3, items: { type: "string" } }
       }, ["subscription", "ackIds"]),
-      mutationCapability3("messages.modifyAckDeadline", "Change the acknowledgement deadline for delivered messages.", {
+      mutationCapability4("messages.modifyAckDeadline", "Change the acknowledgement deadline for delivered messages.", {
         subscription: { type: "string" },
         ackIds: { type: "array", minItems: 1, maxItems: 1e3, items: { type: "string" } },
         ackDeadlineSeconds: { type: "integer", minimum: 0, maximum: 600 }
@@ -25115,10 +25678,10 @@ var googlePubSubConnector = {
         if (labels) body.labels = labels;
         const regions2 = optionalStringArray(inv.args.allowedPersistenceRegions, "allowedPersistenceRegions");
         if (regions2) body.messageStoragePolicy = { allowedPersistenceRegions: regions2 };
-        if (inv.args.kmsKeyName !== void 0) body.kmsKeyName = requiredString5(inv.args.kmsKeyName, "kmsKeyName");
+        if (inv.args.kmsKeyName !== void 0) body.kmsKeyName = requiredString6(inv.args.kmsKeyName, "kmsKeyName");
         if (inv.args.schema !== void 0) {
           body.schemaSettings = {
-            schema: requiredString5(inv.args.schema, "schema"),
+            schema: requiredString6(inv.args.schema, "schema"),
             ...inv.args.schemaEncoding === void 0 ? {} : { encoding: enumValue2(inv.args.schemaEncoding, "schemaEncoding", ["JSON", "BINARY"]) }
           };
         }
@@ -25209,7 +25772,7 @@ var googlePubSubConnector = {
     }
   }
 };
-function readCapability3(name, description, properties, required = []) {
+function readCapability4(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -25217,7 +25780,7 @@ function readCapability3(name, description, properties, required = []) {
     parameters: { type: "object", properties, ...required.length ? { required } : {} }
   };
 }
-function mutationCapability3(name, description, properties, required) {
+function mutationCapability4(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -25237,7 +25800,7 @@ function parseServiceAccountCredentials(credentials, dataSourceId) {
   } catch {
     throw new CredentialsExpired("Google Pub/Sub service-account key must be valid JSON", dataSourceId);
   }
-  if (!isRecord2(parsed) || parsed.type !== "service_account") {
+  if (!isRecord3(parsed) || parsed.type !== "service_account") {
     throw new CredentialsExpired("Google Pub/Sub requires a Google service_account key", dataSourceId);
   }
   const projectId = requiredCredentialString(parsed.project_id, "project_id", dataSourceId);
@@ -25255,7 +25818,7 @@ function parseServiceAccountCredentials(credentials, dataSourceId) {
   return { projectId, clientEmail, privateKey };
 }
 async function accessToken(credentials, dataSourceId) {
-  const cacheKey = createHash4("sha256").update(credentials.clientEmail).update("\0").update(credentials.privateKey).digest("hex");
+  const cacheKey = createHash5("sha256").update(credentials.clientEmail).update("\0").update(credentials.privateKey).digest("hex");
   const cached = tokenCache.get(cacheKey);
   if (cached && cached.expiresAt > Date.now() + 6e4) {
     tokenCache.delete(cacheKey);
@@ -25297,8 +25860,8 @@ async function exchangeAccessToken(credentials, dataSourceId, cacheKey) {
     body: form2
   });
   const body = await readJson(response, 64 * 1024);
-  if (!response.ok || !isRecord2(body) || typeof body.access_token !== "string" || body.access_token.trim() === "") {
-    const reason = isRecord2(body) && typeof body.error === "string" ? body.error : void 0;
+  if (!response.ok || !isRecord3(body) || typeof body.access_token !== "string" || body.access_token.trim() === "") {
+    const reason = isRecord3(body) && typeof body.error === "string" ? body.error : void 0;
     throw new CredentialsExpired("Google rejected the Pub/Sub service-account grant", dataSourceId, {
       status: response.status,
       reason,
@@ -25334,9 +25897,9 @@ async function pubSubRequest(credentials, inv, method, path, query2, body) {
     },
     body: serialized
   });
-  const responseBody = await readJson(response, MAX_RESPONSE_BYTES3);
+  const responseBody = await readJson(response, MAX_RESPONSE_BYTES4);
   if (response.ok) return responseBody;
-  const providerError = isRecord2(responseBody) && isRecord2(responseBody.error) ? responseBody.error : void 0;
+  const providerError = isRecord3(responseBody) && isRecord3(responseBody.error) ? responseBody.error : void 0;
   const reason = providerError && typeof providerError.status === "string" ? providerError.status : void 0;
   if (response.status === 401) {
     throw new CredentialsExpired("Google Pub/Sub credentials were rejected", inv.source.id, {
@@ -25357,7 +25920,7 @@ async function pubSubRequest(credentials, inv, method, path, query2, body) {
       status: response.status,
       reason,
       body: responseBody,
-      retryAfterMs: retryAfterMs4(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs5(response.headers.get("retry-after"))
     });
   }
   const message = providerError && typeof providerError.message === "string" ? providerError.message : `HTTP ${response.status}`;
@@ -25373,7 +25936,7 @@ function subscriptionPath(credentials, value) {
   return `${projectPath(credentials, "subscriptions")}/${encodeURIComponent(resourceId(value, "subscription"))}`;
 }
 function resourceId(value, field) {
-  const id2 = requiredString5(value, field);
+  const id2 = requiredString6(value, field);
   if (!/^[A-Za-z][A-Za-z0-9._~+%-]{2,254}$/.test(id2) || id2.toLowerCase().startsWith("goog")) {
     throw new Error(`${field} must be a valid Pub/Sub resource ID`);
   }
@@ -25382,7 +25945,7 @@ function resourceId(value, field) {
 function pagination(args) {
   const query2 = new URLSearchParams();
   if (args.pageSize !== void 0) query2.set("pageSize", String(boundedInteger2(args.pageSize, "pageSize", 1, 1e3)));
-  if (args.pageToken !== void 0) query2.set("pageToken", requiredString5(args.pageToken, "pageToken"));
+  if (args.pageToken !== void 0) query2.set("pageToken", requiredString6(args.pageToken, "pageToken"));
   return query2;
 }
 function subscriptionBody(credentials, args) {
@@ -25391,7 +25954,7 @@ function subscriptionBody(credentials, args) {
   setOptionalBoolean(body, "retainAckedMessages", args.retainAckedMessages);
   setOptionalDuration(body, "messageRetentionDuration", args.messageRetentionDuration);
   if (args.expirationTtl !== void 0) body.expirationPolicy = { ttl: duration(args.expirationTtl, "expirationTtl") };
-  if (args.filter !== void 0) body.filter = requiredString5(args.filter, "filter");
+  if (args.filter !== void 0) body.filter = requiredString6(args.filter, "filter");
   if (args.deadLetterTopic !== void 0) {
     body.deadLetterPolicy = {
       deadLetterTopic: topicPath(credentials, args.deadLetterTopic),
@@ -25417,7 +25980,7 @@ function publishMessages(value) {
     throw new Error("messages must contain 1 to 1000 entries");
   }
   return value.map((entry, index) => {
-    if (!isRecord2(entry)) throw new Error(`messages[${index}] must be an object`);
+    if (!isRecord3(entry)) throw new Error(`messages[${index}] must be an object`);
     const hasText = typeof entry.text === "string";
     const hasData = typeof entry.data === "string";
     if (hasText === hasData) throw new Error(`messages[${index}] requires exactly one of text or data`);
@@ -25425,7 +25988,7 @@ function publishMessages(value) {
     const message = { data: data4 };
     const attributes = optionalStringMap(entry.attributes, `messages[${index}].attributes`);
     if (attributes) message.attributes = attributes;
-    if (entry.orderingKey !== void 0) message.orderingKey = requiredString5(entry.orderingKey, `messages[${index}].orderingKey`);
+    if (entry.orderingKey !== void 0) message.orderingKey = requiredString6(entry.orderingKey, `messages[${index}].orderingKey`);
     return message;
   });
 }
@@ -25466,7 +26029,7 @@ function requiredCredentialString(value, field, dataSourceId) {
   }
   return value.trim();
 }
-function requiredString5(value, field) {
+function requiredString6(value, field) {
   if (typeof value !== "string" || value.trim() === "") throw new Error(`${field} must be a non-empty string`);
   return value.trim();
 }
@@ -25480,7 +26043,7 @@ function requiredStringArray(value, field, maximum) {
   if (!Array.isArray(value) || value.length < 1 || value.length > maximum) {
     throw new Error(`${field} must contain 1 to ${maximum} strings`);
   }
-  return value.map((entry, index) => requiredString5(entry, `${field}[${index}]`));
+  return value.map((entry, index) => requiredString6(entry, `${field}[${index}]`));
 }
 function optionalStringArray(value, field) {
   if (value === void 0) return void 0;
@@ -25488,12 +26051,12 @@ function optionalStringArray(value, field) {
 }
 function optionalStringMap(value, field) {
   if (value === void 0) return void 0;
-  if (!isRecord2(value)) throw new Error(`${field} must be an object of strings`);
+  if (!isRecord3(value)) throw new Error(`${field} must be an object of strings`);
   const entries = Object.entries(value);
   if (entries.length > 64) throw new Error(`${field} cannot contain more than 64 entries`);
   return Object.fromEntries(entries.map(([key, entry]) => [
-    requiredString5(key, `${field} key`),
-    requiredString5(entry, `${field}.${key}`)
+    requiredString6(key, `${field} key`),
+    requiredString6(entry, `${field}.${key}`)
   ]));
 }
 function setOptionalInteger(body, key, value, minimum, maximum) {
@@ -25508,7 +26071,7 @@ function setOptionalDuration(body, key, value) {
   if (value !== void 0) body[key] = duration(value, key);
 }
 function duration(value, field) {
-  const parsed = requiredString5(value, field);
+  const parsed = requiredString6(value, field);
   if (!/^\d+(?:\.\d{1,9})?s$/.test(parsed)) throw new Error(`${field} must be a protobuf duration ending in s`);
   return parsed;
 }
@@ -25527,14 +26090,14 @@ function strictBase642(value, field) {
 function base64UrlJson(value) {
   return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
 }
-function retryAfterMs4(value) {
+function retryAfterMs5(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
   const date = Date.parse(value);
   return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 6e4;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -26184,8 +26747,8 @@ async function getDocument(inv, accessToken4, timeoutMs) {
   };
 }
 async function createDocument(inv, accessToken4, timeoutMs) {
-  const { title, body } = inv.args ?? {};
-  if (!title || typeof title !== "string") {
+  const { title: title2, body } = inv.args ?? {};
+  if (!title2 || typeof title2 !== "string") {
     throw new Error("google-docs create_document: title is required");
   }
   const createRes = await fetch(`${API2}/documents`, {
@@ -26194,7 +26757,7 @@ async function createDocument(inv, accessToken4, timeoutMs) {
       authorization: `Bearer ${accessToken4}`,
       "content-type": "application/json"
     },
-    body: JSON.stringify({ title }),
+    body: JSON.stringify({ title: title2 }),
     signal: AbortSignal.timeout(timeoutMs)
   });
   if (!createRes.ok) {
@@ -27223,9 +27786,9 @@ async function getResponse(inv, accessToken4, timeoutMs) {
   };
 }
 async function createForm(inv, accessToken4, timeoutMs) {
-  const { title, documentTitle } = inv.args ?? {};
-  if (!title) throw new Error("google-forms create_form: title is required");
-  const info = { title };
+  const { title: title2, documentTitle } = inv.args ?? {};
+  if (!title2) throw new Error("google-forms create_form: title is required");
+  const info = { title: title2 };
   if (documentTitle) info.documentTitle = documentTitle;
   const res = await fetch(`${API4}/forms`, {
     method: "POST",
@@ -27310,7 +27873,7 @@ async function ensureFreshAccessToken5(creds, clientId, clientSecret) {
 }
 
 // src/connectors/adapters/google-sheets.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var SCOPES5 = ["https://www.googleapis.com/auth/spreadsheets"];
 var AUTH_URL6 = "https://accounts.google.com/o/oauth2/v2/auth";
 var TOKEN_URL7 = "https://oauth2.googleapis.com/token";
@@ -27583,7 +28146,7 @@ async function fetchAllRows(accessToken4, meta) {
 function rowFingerprint(values) {
   const keys = Object.keys(values).sort();
   const blob = keys.map((k) => `${k}=${values[k]}`).join("
");
-  return createHash5("sha256").update(blob).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(blob).digest("hex").slice(0, 16);
 }
 function matchesPredicate(row, predicate) {
   for (const [k, v] of Object.entries(predicate)) {
@@ -28437,7 +29000,7 @@ var granolaConnector = declarativeRestConnector({
 });
 
 // src/connectors/adapters/hellosign.ts
-import { createHmac as createHmac5, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHmac as createHmac5, timingSafeEqual as timingSafeEqual3 } from "crypto";
 var SCOPES6 = [
   "basic_account_info",
   "request_signature",
@@ -28664,7 +29227,7 @@ function hellosign(opts) {
       const a = Buffer.from(event.event_hash.toLowerCase(), "utf-8");
       const b = Buffer.from(expected.toLowerCase(), "utf-8");
       if (a.length !== b.length) return { valid: false, reason: "invalid_signature" };
-      return timingSafeEqual2(a, b) ? { valid: true } : { valid: false, reason: "invalid_signature" };
+      return timingSafeEqual3(a, b) ? { valid: true } : { valid: false, reason: "invalid_signature" };
     },
     async handleInboundEvent({ rawBody }) {
       const parsed = parseInboundBody(rawBody);
@@ -29682,7 +30245,7 @@ var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
 var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 var MAX_TIMEOUT_MS = 6e4;
-var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_TIMEOUT_MS2 = 15e3;
 var httpConnector = {
   manifest: {
     kind: "http",
@@ -29717,7 +30280,7 @@ var httpConnector = {
             },
             timeoutMs: {
               type: "number",
-              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS}, capped at ${MAX_TIMEOUT_MS}.`
+              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS2}, capped at ${MAX_TIMEOUT_MS}.`
             }
           },
           required: ["url"]
@@ -29751,7 +30314,7 @@ var httpConnector = {
             },
             timeoutMs: {
               type: "number",
-              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS}, capped at ${MAX_TIMEOUT_MS}.`
+              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS2}, capped at ${MAX_TIMEOUT_MS}.`
             }
           },
           required: ["url"]
@@ -29852,7 +30415,7 @@ function readMethod(value, fallback, allowed, capability) {
   return upper;
 }
 function readTimeout(value) {
-  if (value === void 0 || value === null) return DEFAULT_TIMEOUT_MS;
+  if (value === void 0 || value === null) return DEFAULT_TIMEOUT_MS2;
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     throw new Error("http.timeoutMs must be a positive finite number");
   }
@@ -38406,9 +38969,9 @@ var NOTION_SPEC = {
   ]
 };
 async function databasesUpdate(inv) {
-  const { title, properties } = inv.args;
+  const { title: title2, properties } = inv.args;
   const body = {};
-  if (title !== void 0) body.title = "{title}";
+  if (title2 !== void 0) body.title = "{title}";
   if (properties !== void 0) body.properties = "{properties}";
   const response = await executeRestRequest(
     NOTION_SPEC,
@@ -43075,7 +43638,7 @@ var ringcentralConnector = declarativeRestConnector({
 var ALLOWED_SCHEMES2 = /* @__PURE__ */ new Set(["http:", "https:"]);
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 200;
-var DEFAULT_TIMEOUT_MS2 = 15e3;
+var DEFAULT_TIMEOUT_MS3 = 15e3;
 var MAX_BODY_BYTES = 5 * 1024 * 1024;
 var READ_CAPABILITIES = [
   {
@@ -43138,12 +43701,12 @@ var rssConnector = {
         accept: "application/rss+xml, application/atom+xml, application/xml;q=0.9, text/xml;q=0.8, */*;q=0.1",
         "user-agent": "tangle-agent-integrations-rss/1.0"
       },
-      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS2)
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS3)
     });
     if (!res.ok) {
       throw new Error(`rss fetch ${res.status} ${res.statusText} for ${url.toString()}`);
     }
-    const body = await readBoundedText(res, MAX_BODY_BYTES);
+    const body = await readBoundedText2(res, MAX_BODY_BYTES);
     const parsed = parseFeed(body, url.toString());
     const filtered = filterAndLimit(parsed.entries, since, limit);
     const data4 = {
@@ -43223,7 +43786,7 @@ function readSinceMs(value) {
   }
   return ms;
 }
-async function readBoundedText(res, maxBytes) {
+async function readBoundedText2(res, maxBytes) {
   const reader = res.body?.getReader();
   if (!reader) return await res.text();
   const decoder = new TextDecoder("utf-8", { fatal: false });
@@ -43282,7 +43845,7 @@ function parseRss(text) {
   const entries = items.map((item) => {
     const guid = firstTagText(item, "guid");
     const link = firstTagText(item, "link");
-    const title = firstTagText(item, "title");
+    const title2 = firstTagText(item, "title");
     const description = firstTagText(item, "description");
     const contentEncoded = firstTagText(item, "content:encoded");
     const pubDate = firstTagText(item, "pubDate");
@@ -43291,7 +43854,7 @@ function parseRss(text) {
     const id2 = decodeXml3(guid) ?? decodeXml3(link) ?? hash(item);
     return {
       id: id2,
-      title: decodeXml3(title),
+      title: decodeXml3(title2),
       link: decodeXml3(link),
       summary: decodeXml3(description),
       content: decodeXml3(contentEncoded),
@@ -43311,7 +43874,7 @@ function parseAtom(text, feedUrl) {
   const items = collectElements(feedOuter, "entry");
   const entries = items.map((item) => {
     const id2 = decodeXml3(firstTagText(item, "id"));
-    const title = decodeXml3(firstTagText(item, "title"));
+    const title2 = decodeXml3(firstTagText(item, "title"));
     const summary = decodeXml3(firstTagText(item, "summary"));
     const contentNode = firstTagText(item, "content");
     const published = normalizeDate(decodeXml3(firstTagText(item, "published")));
@@ -43321,7 +43884,7 @@ function parseAtom(text, feedUrl) {
     const categories = collectAtomCategories(item);
     return {
       id: id2 ?? link ?? hash(item),
-      title,
+      title: title2,
       link,
       summary,
       content: decodeXml3(contentNode),
@@ -46024,7 +46587,7 @@ async function downloadFile(inv, accessToken4) {
       `slack download_file: file exceeds the ${MAX_INLINE_FILE_BYTES} byte inline limit`
     );
   }
-  const bytes = await readBoundedBody(response, MAX_INLINE_FILE_BYTES);
+  const bytes = await readBoundedBody2(response, MAX_INLINE_FILE_BYTES);
   return {
     data: {
       id: fileId,
@@ -46044,7 +46607,7 @@ function isSlackPrivateFileUrl(value) {
     return false;
   }
 }
-async function readBoundedBody(response, limitBytes) {
+async function readBoundedBody2(response, limitBytes) {
   if (!response.body) return new Uint8Array();
   const reader = response.body.getReader();
   const chunks = [];
@@ -53227,17 +53790,17 @@ var zohoBookingsConnector = {
     category: "calendar",
     defaultConsistencyModel: "authoritative",
     capabilities: [
-      readCapability4("workspaces.list", "List Zoho Bookings workspaces.", {}),
-      readCapability4("services.list", "List services, optionally within one workspace.", {
+      readCapability5("workspaces.list", "List Zoho Bookings workspaces.", {}),
+      readCapability5("services.list", "List services, optionally within one workspace.", {
         workspace_id: { type: "string" }
       }),
-      readCapability4("resources.list", "List bookable resources, optionally for one service.", {
+      readCapability5("resources.list", "List bookable resources, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability4("staff.list", "List staff, optionally for one service.", {
+      readCapability5("staff.list", "List staff, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability4("appointments.list", "List appointments from a required start time.", {
+      readCapability5("appointments.list", "List appointments from a required start time.", {
         from_time: {
           type: "string",
           description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format."
@@ -53247,17 +53810,17 @@ var zohoBookingsConnector = {
         staff_id: { type: "string" },
         status: { type: "string" }
       }, ["from_time"]),
-      readCapability4("appointments.get", "Read one appointment by booking id.", {
+      readCapability5("appointments.get", "Read one appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"]),
-      readCapability4("availability.fetch", "Fetch open time slots for a service and date.", {
+      readCapability5("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"]),
-      mutationCapability4("appointments.book", "Book an appointment for a customer.", {
+      mutationCapability5("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: {
@@ -53273,13 +53836,13 @@ var zohoBookingsConnector = {
         additional_fields: { type: "object" },
         payment_info: { type: "object" }
       }, ["service_id", "from_time", "customer_details"]),
-      mutationCapability4("appointments.reschedule", "Move an appointment to a new time, staff member, or group.", {
+      mutationCapability5("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"]),
-      mutationCapability4("appointments.cancel", "Cancel an appointment by booking id.", {
+      mutationCapability5("appointments.cancel", "Cancel an appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"])
     ]
@@ -53396,7 +53959,7 @@ var zohoBookingsConnector = {
     }
   }
 };
-function readCapability4(name, description, properties, required = []) {
+function readCapability5(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -53405,7 +53968,7 @@ function readCapability4(name, description, properties, required = []) {
     requiredScopes: ["zohobookings.data.READ"]
   };
 }
-function mutationCapability4(name, description, properties, required) {
+function mutationCapability5(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -53460,7 +54023,7 @@ async function request2(source, path, options) {
     throw new ProviderRateLimited("Zoho Bookings rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs5(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs6(response.headers.get("retry-after"))
     });
   }
   if (!response.ok) throw new Error(`zoho-bookings ${options.method} ${path} HTTP ${response.status}`);
@@ -53505,7 +54068,7 @@ function exactlyOne(args, keys, label) {
   const present = keys.filter((key) => args[key] !== void 0 && args[key] !== null && args[key] !== "");
   if (present.length !== 1) throw new Error(`zoho-bookings: exactly one ${label} is required`);
 }
-function retryAfterMs5(value) {
+function retryAfterMs6(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   return Number.isFinite(seconds) && seconds >= 0 ? Math.max(1e3, seconds * 1e3) : 6e4;
@@ -54644,11 +55207,11 @@ async function request3(source, path, options) {
     });
   }
   if (response.status === 429) {
-    const retryAfterMs6 = parseRetryAfter(response.headers.get("retry-after"));
+    const retryAfterMs7 = parseRetryAfter(response.headers.get("retry-after"));
     throw new ProviderRateLimited("Zoho Campaigns rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs6
+      retryAfterMs: retryAfterMs7
     });
   }
   if (!response.ok) {
@@ -62301,6 +62864,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => amazonSqsConnector, {}),
   defineFactoryAdapter(() => httpConnector, {}),
   defineFactoryAdapter(() => rssConnector, {}),
+  defineFactoryAdapter(() => chessComConnector, {}),
   defineFactoryAdapter(() => zapierConnector, {}),
   defineFactoryAdapter(() => makeConnector, {}),
   defineFactoryAdapter(() => n8nConnector, {}),
@@ -62308,6 +62872,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => googleCloudStorageConnector, googleOAuthEnvMap),
   defineFactoryAdapter(() => googlePubSubConnector, {}),
   defineFactoryAdapter(() => azureBlobStorageConnector, {}),
+  defineFactoryAdapter(() => azureEventGridConnector, {}),
   defineFactoryAdapter(() => azureServiceBusConnector, {}),
   defineFactoryAdapter(() => backblazeConnector, {}),
   defineFactoryAdapter(() => cloudinaryConnector, {}),
@@ -63082,11 +63647,11 @@ function validateOutboundStartArgs(args) {
   assertNonEmptyString(args.agentId, "agentId", 128);
   assertE164(args.toNumber, "toNumber");
   assertE164(args.fromNumber, "fromNumber");
-  if (!isRecord3(args.mission)) throw new Error("phony start_outbound_call requires mission");
+  if (!isRecord4(args.mission)) throw new Error("phony start_outbound_call requires mission");
   const mission = args.mission;
   assertNonEmptyString(mission.goal, "mission.goal", 2e3);
   if (mission.goal.trim().length < 8) throw new Error("phony start_outbound_call mission.goal must be at least 8 characters");
-  if (mission.successSchema !== void 0 && !isRecord3(mission.successSchema)) {
+  if (mission.successSchema !== void 0 && !isRecord4(mission.successSchema)) {
     throw new Error("phony start_outbound_call mission.successSchema must be an object when supplied");
   }
   if (mission.ivrHints !== void 0) {
@@ -63100,7 +63665,7 @@ function validateOutboundStartArgs(args) {
   if (args.missionId !== void 0) assertNonEmptyString(args.missionId, "missionId", 128);
   if (args.voiceCloneId !== void 0) assertNonEmptyString(args.voiceCloneId, "voiceCloneId", 128);
   if (args.callerProfile !== void 0) {
-    if (!isRecord3(args.callerProfile)) throw new Error("phony start_outbound_call callerProfile must be an object");
+    if (!isRecord4(args.callerProfile)) throw new Error("phony start_outbound_call callerProfile must be an object");
     if (args.callerProfile.userName !== void 0) assertNonEmptyString(args.callerProfile.userName, "callerProfile.userName", 120);
     if (args.callerProfile.companyName !== void 0) {
       assertNonEmptyString(args.callerProfile.companyName, "callerProfile.companyName", 120);
@@ -63127,7 +63692,7 @@ function assertOptionalInteger(value, field, min, max) {
     throw new Error(`phony start_outbound_call ${field} must be an integer between ${min} and ${max}`);
   }
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function getJson(inv, token, url, label) {
@@ -142249,6 +142814,7 @@ export {
   avalaraConnector,
   azureAdConnector,
   azureBlobStorageConnector,
+  azureEventGridConnector,
   azureServiceBusConnector,
   basecampConnector,
   backblazeConnector,
@@ -142274,6 +142840,7 @@ export {
   cashfreePaymentsConnector,
   circleConnector,
   checkoutConnector,
+  chessComConnector,
   docuseal,
   docusignConnector,
   dialpadConnector,
@@ -142818,4 +143385,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-EXPZGJ4A.js.map
+//# sourceMappingURL=chunk-4H5F6E7W.js.map