@tangle-network/agent-integrations 0.53.24 → 0.53.26

package/dist/{chunk-YWNB5M5K.js → chunk-XZL47RBS.js}

@@ -82,7 +82,9 @@ __export(adapters_exports, {
   azureAdConnector: () => azureAdConnector,
   azureBlobStorageConnector: () => azureBlobStorageConnector,
   azureCommunicationServicesConnector: () => azureCommunicationServicesConnector,
+  azureEventGridConnector: () => azureEventGridConnector,
   azureOpenaiConnector: () => azureOpenaiConnector,
+  azureServiceBusConnector: () => azureServiceBusConnector,
   backblazeConnector: () => backblazeConnector,
   bamboohrConnector: () => bamboohrConnector,
   bannerbearConnector: () => bannerbearConnector,
@@ -786,11 +788,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 retryAfterMs5 = 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 ${retryAfterMs5}ms`,
+          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs7}ms`,
           inv.source.id,
-          { status: 429, body: response.data, retryAfterMs: retryAfterMs5 }
+          { status: 429, body: response.data, retryAfterMs: retryAfterMs7 }
         );
       }
       if (response.outcome === "conflict") {
@@ -11928,11 +11930,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 retryAfterMs5 = 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 ${retryAfterMs5}ms`,
+      `Azure Blob Storage rate limit (${response.status}); retry after ${retryAfterMs7}ms`,
       inv.source.id,
-      { status: response.status, retryAfterMs: retryAfterMs5 }
+      { status: response.status, retryAfterMs: retryAfterMs7 }
     );
   }
   if (!response.ok) {
@@ -12205,6 +12207,878 @@ 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";
+var MAX_RESPONSE_BYTES2 = 8 * 1024 * 1024;
+var MAX_MESSAGE_BYTES = 256 * 1024;
+var SERVICE_BUS_SUFFIXES = [
+  ".servicebus.windows.net",
+  ".servicebus.usgovcloudapi.net",
+  ".servicebus.chinacloudapi.cn",
+  ".servicebus.cloudapi.de"
+];
+var azureServiceBusConnector = {
+  manifest: {
+    kind: "azure-service-bus",
+    displayName: "Azure Service Bus",
+    description: "Send and receive Azure Service Bus queue and topic messages and discover queue, topic, and subscription entities with a customer-owned SAS connection string.",
+    auth: {
+      kind: "api-key",
+      hint: "Azure Service Bus connection string containing Endpoint, SharedAccessKeyName, and SharedAccessKey. EntityPath is supported and restricts this connection to that queue or topic."
+    },
+    category: "webhook",
+    // The REST receive-and-delete operation destructively consumes a message,
+    // and message delivery is at-least-once. Acceptance is not proof that a
+    // downstream consumer processed the payload exactly once.
+    defaultConsistencyModel: "advisory",
+    rateLimit: { requests: 600, windowMs: 6e4, scope: "data-source" },
+    capabilities: [
+      readCapability2("queues.list", "List queues visible to a namespace-level Manage policy.", listProperties()),
+      readCapability2("queues.get", "Get one queue description and message counts.", {
+        queue: { type: "string" }
+      }, ["queue"]),
+      readCapability2("topics.list", "List topics visible to a namespace-level Manage policy.", listProperties()),
+      readCapability2("topics.get", "Get one topic description and message counts.", {
+        topic: { type: "string" }
+      }, ["topic"]),
+      readCapability2("subscriptions.list", "List subscriptions for one topic.", {
+        topic: { type: "string" },
+        ...listProperties()
+      }, ["topic"]),
+      readCapability2("subscriptions.get", "Get one topic subscription description and message counts.", {
+        topic: { type: "string" },
+        subscription: { type: "string" }
+      }, ["topic", "subscription"]),
+      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"]),
+      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"]),
+      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"]),
+      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 }
+      }, ["topic", "subscription"])
+    ]
+  },
+  async executeRead(inv) {
+    const credentials = parseConnectionString(inv.source.credentials, inv.source.id);
+    let path;
+    let list2 = false;
+    switch (inv.capabilityName) {
+      case "queues.list":
+        requireNamespacePolicy(credentials, "queues.list");
+        path = "$Resources/Queues";
+        list2 = true;
+        break;
+      case "queues.get":
+        path = entityName(inv.args.queue, "queue");
+        enforceEntityPath(credentials, path);
+        break;
+      case "topics.list":
+        requireNamespacePolicy(credentials, "topics.list");
+        path = "$Resources/Topics";
+        list2 = true;
+        break;
+      case "topics.get":
+        path = entityName(inv.args.topic, "topic");
+        enforceEntityPath(credentials, path);
+        break;
+      case "subscriptions.list": {
+        const topic = entityName(inv.args.topic, "topic");
+        enforceEntityPath(credentials, topic);
+        path = `${topic}/Subscriptions/`;
+        list2 = true;
+        break;
+      }
+      case "subscriptions.get": {
+        const topic = entityName(inv.args.topic, "topic");
+        enforceEntityPath(credentials, topic);
+        path = `${topic}/Subscriptions/${entityName(inv.args.subscription, "subscription")}`;
+        break;
+      }
+      default:
+        throw new Error(`azure-service-bus: unknown read capability ${inv.capabilityName}`);
+    }
+    const query2 = list2 ? managementListQuery(inv.args) : new URLSearchParams({ "api-version": MANAGEMENT_API_VERSION });
+    const result = await serviceBusRequest(
+      credentials,
+      inv,
+      "GET",
+      path,
+      query2
+    );
+    const xml = decodeUtf82(result.body);
+    const data4 = list2 ? parseAtomFeed(xml) : parseAtomEntry(xml);
+    return { data: data4, fetchedAt: Date.now() };
+  },
+  async executeMutation(inv) {
+    const credentials = parseConnectionString(inv.source.credentials, inv.source.id);
+    let data4;
+    switch (inv.capabilityName) {
+      case "queues.send":
+        data4 = await sendMessage(credentials, inv, entityName(inv.args.queue, "queue"));
+        break;
+      case "topics.send":
+        data4 = await sendMessage(credentials, inv, entityName(inv.args.topic, "topic"));
+        break;
+      case "queues.receiveDelete":
+        data4 = await receiveAndDelete(credentials, inv, entityName(inv.args.queue, "queue"));
+        break;
+      case "subscriptions.receiveDelete":
+        data4 = await receiveAndDelete(
+          credentials,
+          inv,
+          `${entityName(inv.args.topic, "topic")}/subscriptions/${entityName(inv.args.subscription, "subscription")}`
+        );
+        break;
+      case "queues.deadLetters.receiveDelete":
+        data4 = await receiveAndDelete(
+          credentials,
+          inv,
+          `${entityName(inv.args.queue, "queue")}/$DeadLetterQueue`
+        );
+        break;
+      case "subscriptions.deadLetters.receiveDelete":
+        data4 = await receiveAndDelete(
+          credentials,
+          inv,
+          `${entityName(inv.args.topic, "topic")}/subscriptions/${entityName(inv.args.subscription, "subscription")}/$DeadLetterQueue`
+        );
+        break;
+      default:
+        throw new Error(`azure-service-bus: unknown mutation capability ${inv.capabilityName}`);
+    }
+    return {
+      status: "committed",
+      data: data4,
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  async test(source) {
+    try {
+      parseConnectionString(source.credentials, source.id);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, reason: error instanceof Error ? error.message : "Azure Service Bus connection string is invalid" };
+    }
+  }
+};
+function readCapability2(name, description, properties, required = []) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: { type: "object", properties, ...required.length ? { required } : {} }
+  };
+}
+function mutationCapability3(name, description, properties, required) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: { type: "object", properties, required },
+    cas: "none",
+    externalEffect: true
+  };
+}
+function sendProperties(entity) {
+  return {
+    [entity]: { type: "string" },
+    content: { type: "string", description: "UTF-8 text or canonical base64 message body." },
+    encoding: { type: "string", enum: ["utf-8", "base64"], default: "utf-8" },
+    contentType: { type: "string" },
+    brokerProperties: {
+      type: "object",
+      description: "Allowed broker properties such as MessageId, CorrelationId, Label, SessionId, TimeToLive, and ScheduledEnqueueTimeUtc."
+    },
+    applicationProperties: {
+      type: "object",
+      description: "Application property headers with string, number, or boolean values."
+    }
+  };
+}
+function listProperties() {
+  return {
+    skip: { type: "integer", minimum: 0 },
+    top: { type: "integer", minimum: 1, maximum: 1e3 }
+  };
+}
+function managementListQuery(args) {
+  const query2 = new URLSearchParams({ "api-version": MANAGEMENT_API_VERSION });
+  if (args.skip !== void 0) query2.set("$skip", String(boundedInteger(args.skip, "skip", 0, 1e6)));
+  if (args.top !== void 0) query2.set("$top", String(boundedInteger(args.top, "top", 1, 1e3)));
+  return query2;
+}
+function parseConnectionString(credentials, dataSourceId) {
+  if (credentials.kind !== "api-key") {
+    throw new CredentialsExpired("Azure Service Bus requires a connection string", dataSourceId);
+  }
+  const values = /* @__PURE__ */ new Map();
+  for (const part of credentials.apiKey.split(";")) {
+    if (!part.trim()) continue;
+    const separator = part.indexOf("=");
+    if (separator <= 0) {
+      throw new CredentialsExpired("Azure Service Bus connection string is malformed", dataSourceId);
+    }
+    const name = part.slice(0, separator).trim().toLowerCase();
+    if (values.has(name)) {
+      throw new CredentialsExpired(`Azure Service Bus connection string repeats ${name}`, dataSourceId);
+    }
+    values.set(name, part.slice(separator + 1).trim());
+  }
+  const endpointValue = values.get("endpoint");
+  const keyName = values.get("sharedaccesskeyname");
+  const keyValue = values.get("sharedaccesskey");
+  if (!endpointValue || !keyName || !keyValue) {
+    throw new CredentialsExpired("Azure Service Bus connection string is missing Endpoint, SharedAccessKeyName, or SharedAccessKey", dataSourceId);
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(endpointValue.replace(/^sb:/i, "https:"));
+  } catch {
+    throw new CredentialsExpired("Azure Service Bus Endpoint is invalid", dataSourceId);
+  }
+  if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.port || endpoint.search || endpoint.hash || endpoint.pathname !== "/" || !SERVICE_BUS_SUFFIXES.some((suffix) => endpoint.hostname.endsWith(suffix))) {
+    throw new CredentialsExpired("Azure Service Bus Endpoint must be a public Azure Service Bus namespace", dataSourceId);
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/.test(keyName)) {
+    throw new CredentialsExpired("Azure Service Bus SharedAccessKeyName is invalid", dataSourceId);
+  }
+  let key;
+  try {
+    key = Buffer.from(keyValue, "base64");
+  } catch {
+    throw new CredentialsExpired("Azure Service Bus SharedAccessKey is invalid base64", dataSourceId);
+  }
+  if (key.length < 16 || key.toString("base64").replace(/=+$/, "") !== keyValue.replace(/=+$/, "")) {
+    throw new CredentialsExpired("Azure Service Bus SharedAccessKey is invalid base64", dataSourceId);
+  }
+  const entityPathValue = values.get("entitypath");
+  const entityPath = entityPathValue ? entityName(entityPathValue, "EntityPath") : void 0;
+  return { endpoint, keyName, key, entityPath };
+}
+async function sendMessage(credentials, inv, entityPath) {
+  enforceEntityPath(credentials, entityPath);
+  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) {
+    throw new Error(`Azure Service Bus message exceeds ${MAX_MESSAGE_BYTES} bytes`);
+  }
+  const headers = {
+    "content-type": inv.args.contentType === void 0 ? "application/octet-stream" : requiredHeaderValue(inv.args.contentType, "contentType")
+  };
+  const brokerProperties = allowedBrokerProperties(inv.args.brokerProperties);
+  if (brokerProperties) {
+    const serializedBrokerProperties = JSON.stringify(brokerProperties);
+    if (Buffer.byteLength(serializedBrokerProperties) > 16 * 1024) {
+      throw new Error("brokerProperties exceeds 16384 bytes");
+    }
+    headers.BrokerProperties = serializedBrokerProperties;
+  }
+  Object.assign(headers, applicationPropertyHeaders(inv.args.applicationProperties));
+  const result = await serviceBusRequest(credentials, inv, "POST", `${entityPath}/messages`, void 0, headers, body);
+  return {
+    accepted: true,
+    entityPath,
+    size: body.byteLength,
+    location: result.response.headers.get("location") ?? void 0
+  };
+}
+async function receiveAndDelete(credentials, inv, entityPath) {
+  enforceEntityPath(credentials, entityPath);
+  const timeoutSeconds = inv.args.timeoutSeconds === void 0 ? 0 : boundedInteger(inv.args.timeoutSeconds, "timeoutSeconds", 0, 55);
+  const result = await serviceBusRequest(
+    credentials,
+    inv,
+    "DELETE",
+    `${entityPath}/messages/head`,
+    new URLSearchParams({ timeout: String(timeoutSeconds) }),
+    void 0,
+    void 0,
+    [200, 204]
+  );
+  if (result.response.status === 204) return { message: null };
+  const brokerPropertiesHeader = result.response.headers.get("brokerproperties");
+  let brokerProperties;
+  if (brokerPropertiesHeader) {
+    try {
+      brokerProperties = JSON.parse(brokerPropertiesHeader);
+    } catch {
+      throw new Error("Azure Service Bus returned invalid BrokerProperties JSON");
+    }
+  }
+  return {
+    message: {
+      body: Buffer.from(result.body).toString("base64"),
+      encoding: "base64",
+      contentType: result.response.headers.get("content-type") ?? "application/octet-stream",
+      brokerProperties,
+      applicationProperties: responseApplicationProperties(result.response.headers)
+    }
+  };
+}
+async function serviceBusRequest(credentials, inv, method, path, query2, headers = {}, body, acceptedStatuses = [200, 201, 202, 204]) {
+  const url = new URL(path.split("/").map(encodePathSegment2).join("/"), credentials.endpoint);
+  if (query2) url.search = query2.toString();
+  const resourceUri = `${url.origin}${url.pathname}`;
+  const expiry = Math.floor(Date.now() / 1e3) + 300;
+  const encodedResourceUri = encodeURIComponent(resourceUri);
+  const signature = createHmac3("sha256", credentials.key).update(`${encodedResourceUri}
+${expiry}`, "utf8").digest("base64");
+  const authorization = `SharedAccessSignature sr=${encodedResourceUri}&sig=${encodeURIComponent(signature)}&se=${expiry}&skn=${encodeURIComponent(credentials.keyName)}`;
+  const response = await fetch(url, {
+    method,
+    headers: { authorization, accept: "application/atom+xml, application/xml, */*", ...headers },
+    body: body === void 0 ? void 0 : Uint8Array.from(body).buffer
+  });
+  const responseBody = await readBounded(response, MAX_RESPONSE_BYTES2);
+  if (acceptedStatuses.includes(response.status)) return { response, body: responseBody };
+  const text = decodeUtf82(responseBody);
+  if (response.status === 401) {
+    throw new CredentialsExpired("Azure Service Bus rejected the shared access signature", inv.source.id, {
+      status: response.status,
+      body: redactProviderText(text)
+    });
+  }
+  if (response.status === 403) {
+    throw new ProviderConfigError("Azure Service Bus policy lacks permission for this operation", inv.source.id, {
+      status: response.status,
+      body: redactProviderText(text)
+    });
+  }
+  if (response.status === 429 || response.status === 503) {
+    throw new ProviderRateLimited("Azure Service Bus is throttling requests", inv.source.id, {
+      status: response.status,
+      body: redactProviderText(text),
+      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 entityName(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`);
+  }
+  return name;
+}
+function requireNamespacePolicy(credentials, capability) {
+  if (credentials.entityPath) {
+    throw new Error(`${capability} requires a namespace-level connection string without EntityPath`);
+  }
+}
+function enforceEntityPath(credentials, requestedPath) {
+  if (!credentials.entityPath) return;
+  const normalized = requestedPath.toLowerCase();
+  const allowed = credentials.entityPath.toLowerCase();
+  if (normalized !== allowed && normalized !== `${allowed}/$deadletterqueue` && !normalized.startsWith(`${allowed}/subscriptions/`)) {
+    throw new Error(`Connection string EntityPath restricts access to ${credentials.entityPath}`);
+  }
+}
+var BROKER_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+  "CorrelationId",
+  "SessionId",
+  "Label",
+  "MessageId",
+  "ReplyTo",
+  "ReplyToSessionId",
+  "To",
+  "TimeToLive",
+  "ScheduledEnqueueTimeUtc",
+  "PartitionKey",
+  "ViaPartitionKey",
+  "ForcePersistence"
+]);
+function allowedBrokerProperties(value) {
+  if (value === void 0) return void 0;
+  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 = {};
+  for (const [key, property] of entries) {
+    if (!BROKER_PROPERTY_NAMES.has(key)) throw new Error(`brokerProperties.${key} is not allowed`);
+    if (!["string", "number", "boolean"].includes(typeof property) || !Number.isFinite(typeof property === "number" ? property : 0)) {
+      throw new Error(`brokerProperties.${key} must be a finite string, number, or boolean`);
+    }
+    if (typeof property === "string") requiredHeaderValue(property, `brokerProperties.${key}`);
+    result[key] = property;
+  }
+  return result;
+}
+var RESERVED_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "brokerproperties",
+  "content-length",
+  "content-type",
+  "host"
+]);
+function applicationPropertyHeaders(value) {
+  if (value === void 0) return {};
+  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 = {};
+  let size = 0;
+  for (const [key, property] of entries) {
+    if (!/^[A-Za-z][A-Za-z0-9-]{0,63}$/.test(key) || RESERVED_HEADERS.has(key.toLowerCase()) || key.toLowerCase().startsWith("x-ms-")) {
+      throw new Error(`applicationProperties.${key} is not a safe header name`);
+    }
+    if (!["string", "number", "boolean"].includes(typeof property)) {
+      throw new Error(`applicationProperties.${key} must be a string, number, or boolean`);
+    }
+    if (typeof property === "number" && !Number.isFinite(property)) {
+      throw new Error(`applicationProperties.${key} must be finite`);
+    }
+    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] = headerValue2;
+  }
+  return result;
+}
+function responseApplicationProperties(headers) {
+  const result = {};
+  for (const [key, value] of headers.entries()) {
+    if (!RESERVED_HEADERS.has(key.toLowerCase()) && !key.toLowerCase().startsWith("x-ms-") && key.toLowerCase() !== "date" && key.toLowerCase() !== "server" && key.toLowerCase() !== "transfer-encoding") result[key] = value;
+  }
+  return result;
+}
+function parseAtomFeed(xml) {
+  const nextLink = xml.match(/<link\b(?=[^>]*\brel=["']next["'])(?=[^>]*\bhref=["']([^"']+)["'])[^>]*\/?>/i)?.[1];
+  return {
+    entries: [...xml.matchAll(/<entry\b[^>]*>([\s\S]*?)<\/entry>/gi)].map((match) => parseAtomEntry(match[0])),
+    ...nextLink ? { nextLink: decodeXml2(nextLink) } : {}
+  };
+}
+function parseAtomEntry(xml) {
+  const title = xmlValue(xml, "title");
+  const id2 = xmlValue(xml, "id");
+  const updated = xmlValue(xml, "updated");
+  const properties = {};
+  for (const match of xml.matchAll(/<(?:[A-Za-z0-9]+:)?([A-Za-z][A-Za-z0-9]*)\b[^>]*>([^<]*)<\/(?:[A-Za-z0-9]+:)?\1>/g)) {
+    const key = match[1];
+    if (["title", "id", "updated"].includes(key.toLowerCase())) continue;
+    const raw = decodeXml2(match[2]);
+    properties[key] = xmlScalar(raw);
+  }
+  return { title, 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"));
+  return match ? decodeXml2(match[1]) : void 0;
+}
+function xmlScalar(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) {
+    const parsed = Number(value);
+    if (Number.isSafeInteger(parsed)) return parsed;
+  }
+  return value;
+}
+function decodeXml2(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+async function readBounded(response, limit) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limit) throw new Error(`Azure Service Bus response exceeds ${limit} bytes`);
+  if (!response.body) return new Uint8Array();
+  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 Service Bus 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 body;
+}
+function strictBase64(value) {
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+    throw new Error("content must be canonical base64 when encoding=base64");
+  }
+  return Buffer.from(value, "base64");
+}
+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 = requiredString5(value, field);
+  if (/\r|\n/.test(parsed) || parsed.length > 4096) throw new Error(`${field} is not a safe header value`);
+  return parsed;
+}
+function boundedInteger(value, field, minimum, maximum) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${field} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return value;
+}
+function enumValue(value, field, choices) {
+  if (typeof value !== "string" || !choices.includes(value)) {
+    throw new Error(`${field} must be one of ${choices.join(", ")}`);
+  }
+  return value;
+}
+function decodeUtf82(value) {
+  return new TextDecoder("utf-8", { fatal: true }).decode(value);
+}
+function retryAfterMs4(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 redactProviderText(value) {
+  return value.replace(/SharedAccessSignature\s+[^\s<]+/gi, "SharedAccessSignature [redacted]").replace(/SharedAccessKey=[^;\s<]+/gi, "SharedAccessKey=[redacted]");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/connectors/adapters/basecamp.ts
 var basecampConnector = declarativeRestConnector({
   kind: "basecamp",
@@ -18735,7 +19609,7 @@ var checkoutConnector = declarativeRestConnector({
 });
 
 // src/connectors/adapters/docuseal.ts
-import { createHmac as createHmac3, 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) {
@@ -18860,11 +19734,11 @@ function docuseal(opts = {}) {
       if (!creds?.webhookSecret) return { valid: false, reason: "missing_webhook_secret" };
       const sig = firstHeader(headers, "x-docuseal-signature");
       if (!sig) return { valid: false, reason: "missing_signature_header" };
-      const expected = createHmac3("sha256", creds.webhookSecret).update(rawBody).digest("hex");
+      const expected = createHmac4("sha256", creds.webhookSecret).update(rawBody).digest("hex");
       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;
@@ -22482,7 +23356,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();
@@ -22510,7 +23384,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,
@@ -24429,11 +25303,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_BYTES2 = 8 * 1024 * 1024;
+var MAX_RESPONSE_BYTES3 = 8 * 1024 * 1024;
 var MAX_REQUEST_BYTES = 1e7;
 var MAX_TOKEN_CACHE_ENTRIES = 256;
 var tokenCache = /* @__PURE__ */ new Map();
@@ -24454,14 +25328,14 @@ var googlePubSubConnector = {
     defaultConsistencyModel: "advisory",
     rateLimit: { requests: 600, windowMs: 6e4, scope: "data-source" },
     capabilities: [
-      readCapability2("topics.list", "List topics in the service account project.", {
+      readCapability3("topics.list", "List topics in the service account project.", {
         pageSize: { type: "integer", minimum: 1, maximum: 1e3 },
         pageToken: { type: "string" }
       }),
-      readCapability2("topics.get", "Get one topic and its server-side configuration.", {
+      readCapability3("topics.get", "Get one topic and its server-side configuration.", {
         topic: { type: "string", description: "Topic ID in the service account project." }
       }, ["topic"]),
-      mutationCapability2("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" } },
@@ -24469,10 +25343,10 @@ var googlePubSubConnector = {
         schema: { type: "string", description: "Full Pub/Sub schema resource name." },
         schemaEncoding: { type: "string", enum: ["JSON", "BINARY"] }
       }, ["topic"]),
-      mutationCapability2("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"]),
-      mutationCapability2("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",
@@ -24481,14 +25355,14 @@ var googlePubSubConnector = {
           description: "Messages with either text (UTF-8) or data (base64), plus optional string attributes and orderingKey."
         }
       }, ["topic", "messages"]),
-      readCapability2("subscriptions.list", "List subscriptions in the service account project.", {
+      readCapability3("subscriptions.list", "List subscriptions in the service account project.", {
         pageSize: { type: "integer", minimum: 1, maximum: 1e3 },
         pageToken: { type: "string" }
       }),
-      readCapability2("subscriptions.get", "Get one subscription and its delivery configuration.", {
+      readCapability3("subscriptions.get", "Get one subscription and its delivery configuration.", {
         subscription: { type: "string" }
       }, ["subscription"]),
-      mutationCapability2("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 },
@@ -24504,18 +25378,18 @@ var googlePubSubConnector = {
         enableExactlyOnceDelivery: { type: "boolean" },
         labels: { type: "object", additionalProperties: { type: "string" } }
       }, ["subscription", "topic"]),
-      mutationCapability2("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"]),
-      mutationCapability2("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"]),
-      mutationCapability2("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"]),
-      mutationCapability2("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 }
@@ -24553,11 +25427,11 @@ 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 = requiredString4(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: requiredString4(inv.args.schema, "schema"),
-            ...inv.args.schemaEncoding === void 0 ? {} : { encoding: enumValue(inv.args.schemaEncoding, "schemaEncoding", ["JSON", "BINARY"]) }
+            schema: requiredString6(inv.args.schema, "schema"),
+            ...inv.args.schemaEncoding === void 0 ? {} : { encoding: enumValue2(inv.args.schemaEncoding, "schemaEncoding", ["JSON", "BINARY"]) }
           };
         }
         data4 = await pubSubRequest(credentials, inv, "PUT", topicPath(credentials, inv.args.topic), void 0, body);
@@ -24596,7 +25470,7 @@ var googlePubSubConnector = {
           "POST",
           `${subscriptionPath(credentials, inv.args.subscription)}:pull`,
           void 0,
-          { maxMessages: boundedInteger(inv.args.maxMessages, "maxMessages", 1, 1e3) }
+          { maxMessages: boundedInteger2(inv.args.maxMessages, "maxMessages", 1, 1e3) }
         );
         break;
       case "messages.acknowledge":
@@ -24618,7 +25492,7 @@ var googlePubSubConnector = {
           void 0,
           {
             ackIds: requiredStringArray(inv.args.ackIds, "ackIds", 1e3),
-            ackDeadlineSeconds: boundedInteger(inv.args.ackDeadlineSeconds, "ackDeadlineSeconds", 0, 600)
+            ackDeadlineSeconds: boundedInteger2(inv.args.ackDeadlineSeconds, "ackDeadlineSeconds", 0, 600)
           }
         );
         break;
@@ -24647,7 +25521,7 @@ var googlePubSubConnector = {
     }
   }
 };
-function readCapability2(name, description, properties, required = []) {
+function readCapability3(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -24655,7 +25529,7 @@ function readCapability2(name, description, properties, required = []) {
     parameters: { type: "object", properties, ...required.length ? { required } : {} }
   };
 }
-function mutationCapability2(name, description, properties, required) {
+function mutationCapability4(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -24675,7 +25549,7 @@ function parseServiceAccountCredentials(credentials, dataSourceId) {
   } catch {
     throw new CredentialsExpired("Google Pub/Sub service-account key must be valid JSON", dataSourceId);
   }
-  if (!isRecord(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);
@@ -24693,7 +25567,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);
@@ -24735,8 +25609,8 @@ async function exchangeAccessToken(credentials, dataSourceId, cacheKey) {
     body: form2
   });
   const body = await readJson(response, 64 * 1024);
-  if (!response.ok || !isRecord(body) || typeof body.access_token !== "string" || body.access_token.trim() === "") {
-    const reason = isRecord(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,
@@ -24772,9 +25646,9 @@ async function pubSubRequest(credentials, inv, method, path, query2, body) {
     },
     body: serialized
   });
-  const responseBody = await readJson(response, MAX_RESPONSE_BYTES2);
+  const responseBody = await readJson(response, MAX_RESPONSE_BYTES3);
   if (response.ok) return responseBody;
-  const providerError = isRecord(responseBody) && isRecord(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, {
@@ -24795,7 +25669,7 @@ async function pubSubRequest(credentials, inv, method, path, query2, body) {
       status: response.status,
       reason,
       body: responseBody,
-      retryAfterMs: retryAfterMs3(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs5(response.headers.get("retry-after"))
     });
   }
   const message = providerError && typeof providerError.message === "string" ? providerError.message : `HTTP ${response.status}`;
@@ -24811,7 +25685,7 @@ function subscriptionPath(credentials, value) {
   return `${projectPath(credentials, "subscriptions")}/${encodeURIComponent(resourceId(value, "subscription"))}`;
 }
 function resourceId(value, field) {
-  const id2 = requiredString4(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`);
   }
@@ -24819,8 +25693,8 @@ function resourceId(value, field) {
 }
 function pagination(args) {
   const query2 = new URLSearchParams();
-  if (args.pageSize !== void 0) query2.set("pageSize", String(boundedInteger(args.pageSize, "pageSize", 1, 1e3)));
-  if (args.pageToken !== void 0) query2.set("pageToken", requiredString4(args.pageToken, "pageToken"));
+  if (args.pageSize !== void 0) query2.set("pageSize", String(boundedInteger2(args.pageSize, "pageSize", 1, 1e3)));
+  if (args.pageToken !== void 0) query2.set("pageToken", requiredString6(args.pageToken, "pageToken"));
   return query2;
 }
 function subscriptionBody(credentials, args) {
@@ -24829,11 +25703,11 @@ 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 = requiredString4(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),
-      maxDeliveryAttempts: boundedInteger(args.maxDeliveryAttempts, "maxDeliveryAttempts", 5, 100)
+      maxDeliveryAttempts: boundedInteger2(args.maxDeliveryAttempts, "maxDeliveryAttempts", 5, 100)
     };
   } else if (args.maxDeliveryAttempts !== void 0) {
     throw new Error("maxDeliveryAttempts requires deadLetterTopic");
@@ -24855,15 +25729,15 @@ function publishMessages(value) {
     throw new Error("messages must contain 1 to 1000 entries");
   }
   return value.map((entry, index) => {
-    if (!isRecord(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`);
-    const data4 = hasText ? Buffer.from(entry.text, "utf8").toString("base64") : strictBase64(entry.data, `messages[${index}].data`);
+    const data4 = hasText ? Buffer.from(entry.text, "utf8").toString("base64") : strictBase642(entry.data, `messages[${index}].data`);
     const message = { data: data4 };
     const attributes = optionalStringMap(entry.attributes, `messages[${index}].attributes`);
     if (attributes) message.attributes = attributes;
-    if (entry.orderingKey !== void 0) message.orderingKey = requiredString4(entry.orderingKey, `messages[${index}].orderingKey`);
+    if (entry.orderingKey !== void 0) message.orderingKey = requiredString6(entry.orderingKey, `messages[${index}].orderingKey`);
     return message;
   });
 }
@@ -24904,11 +25778,11 @@ function requiredCredentialString(value, field, dataSourceId) {
   }
   return value.trim();
 }
-function requiredString4(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();
 }
-function boundedInteger(value, field, minimum, maximum) {
+function boundedInteger2(value, field, minimum, maximum) {
   if (!Number.isInteger(value) || value < minimum || value > maximum) {
     throw new Error(`${field} must be an integer from ${minimum} to ${maximum}`);
   }
@@ -24918,7 +25792,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) => requiredString4(entry, `${field}[${index}]`));
+  return value.map((entry, index) => requiredString6(entry, `${field}[${index}]`));
 }
 function optionalStringArray(value, field) {
   if (value === void 0) return void 0;
@@ -24926,16 +25800,16 @@ function optionalStringArray(value, field) {
 }
 function optionalStringMap(value, field) {
   if (value === void 0) return void 0;
-  if (!isRecord(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]) => [
-    requiredString4(key, `${field} key`),
-    requiredString4(entry, `${field}.${key}`)
+    requiredString6(key, `${field} key`),
+    requiredString6(entry, `${field}.${key}`)
   ]));
 }
 function setOptionalInteger(body, key, value, minimum, maximum) {
-  if (value !== void 0) body[key] = boundedInteger(value, key, minimum, maximum);
+  if (value !== void 0) body[key] = boundedInteger2(value, key, minimum, maximum);
 }
 function setOptionalBoolean(body, key, value) {
   if (value === void 0) return;
@@ -24946,17 +25820,17 @@ function setOptionalDuration(body, key, value) {
   if (value !== void 0) body[key] = duration(value, key);
 }
 function duration(value, field) {
-  const parsed = requiredString4(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;
 }
-function enumValue(value, field, choices) {
+function enumValue2(value, field, choices) {
   if (typeof value !== "string" || !choices.includes(value)) {
     throw new Error(`${field} must be one of ${choices.join(", ")}`);
   }
   return value;
 }
-function strictBase64(value, field) {
+function strictBase642(value, field) {
   if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
     throw new Error(`${field} must be canonical base64`);
   }
@@ -24965,14 +25839,14 @@ function strictBase64(value, field) {
 function base64UrlJson(value) {
   return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
 }
-function retryAfterMs3(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 isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -26748,7 +27622,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";
@@ -27021,7 +27895,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)) {
@@ -27875,7 +28749,7 @@ var granolaConnector = declarativeRestConnector({
 });
 
 // src/connectors/adapters/hellosign.ts
-import { createHmac as createHmac4, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHmac as createHmac5, timingSafeEqual as timingSafeEqual3 } from "crypto";
 var SCOPES6 = [
   "basic_account_info",
   "request_signature",
@@ -28098,11 +28972,11 @@ function hellosign(opts) {
       if (!event || typeof event.event_time !== "string" || typeof event.event_type !== "string" || typeof event.event_hash !== "string") {
         return { valid: false, reason: "missing_event_fields" };
       }
-      const expected = createHmac4("sha256", source.credentials.accessToken).update(`${event.event_time}${event.event_type}`).digest("hex");
+      const expected = createHmac5("sha256", source.credentials.accessToken).update(`${event.event_time}${event.event_type}`).digest("hex");
       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);
@@ -40041,7 +40915,7 @@ function outlookMail(opts) {
     async executeMutation(inv) {
       const accessToken4 = await ensureFreshAccessToken13(inv.source.credentials, clientId, clientSecret, inv.onCredentialsRotated);
       if (inv.capabilityName === "send_reply") return sendReply2(inv, accessToken4, timeoutMs);
-      if (inv.capabilityName === "send_message") return sendMessage(inv, accessToken4, timeoutMs);
+      if (inv.capabilityName === "send_message") return sendMessage2(inv, accessToken4, timeoutMs);
       if (inv.capabilityName === "create_draft") return createDraft(inv, accessToken4, timeoutMs);
       if (inv.capabilityName === "subscribe_folder") return subscribeFolder(inv, accessToken4, timeoutMs);
       if (inv.capabilityName === "forward_message") return forwardMessage(inv, accessToken4, timeoutMs);
@@ -40299,7 +41173,7 @@ function buildMessagePayload(args, idempotencyKey, cap) {
   }
   return payload;
 }
-async function sendMessage(inv, accessToken4, timeoutMs) {
+async function sendMessage2(inv, accessToken4, timeoutMs) {
   const args = inv.args ?? {};
   const message = buildMessagePayload(args, inv.idempotencyKey, "send_message");
   const res = await fetch(`${API7}/me/sendMail`, {
@@ -42581,7 +43455,7 @@ var rssConnector = {
     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 = {
@@ -42661,7 +43535,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 });
@@ -42715,7 +43589,7 @@ function parseRss(text) {
     return { feedTitle: null, feedUpdated: null, entries: [], format: "rss" };
   }
   const channelInner = stripAllElements(channelOuter, "item");
-  const feedTitle = decodeXml2(firstTagText(channelInner, "title"));
+  const feedTitle = decodeXml3(firstTagText(channelInner, "title"));
   const items = collectElements(channelOuter, "item");
   const entries = items.map((item) => {
     const guid = firstTagText(item, "guid");
@@ -42725,17 +43599,17 @@ function parseRss(text) {
     const contentEncoded = firstTagText(item, "content:encoded");
     const pubDate = firstTagText(item, "pubDate");
     const author = firstTagText(item, "author") ?? firstTagText(item, "dc:creator");
-    const categories = collectElements(item, "category").map((cat) => decodeXml2(stripTags(cat)) ?? "").filter(Boolean);
-    const id2 = decodeXml2(guid) ?? decodeXml2(link) ?? hash(item);
+    const categories = collectElements(item, "category").map((cat) => decodeXml3(stripTags(cat)) ?? "").filter(Boolean);
+    const id2 = decodeXml3(guid) ?? decodeXml3(link) ?? hash(item);
     return {
       id: id2,
-      title: decodeXml2(title),
-      link: decodeXml2(link),
-      summary: decodeXml2(description),
-      content: decodeXml2(contentEncoded),
-      published: normalizeDate(decodeXml2(pubDate)),
+      title: decodeXml3(title),
+      link: decodeXml3(link),
+      summary: decodeXml3(description),
+      content: decodeXml3(contentEncoded),
+      published: normalizeDate(decodeXml3(pubDate)),
       updated: null,
-      author: decodeXml2(author),
+      author: decodeXml3(author),
       categories
     };
   });
@@ -42744,17 +43618,17 @@ function parseRss(text) {
 function parseAtom(text, feedUrl) {
   const feedOuter = extractFirstElement(text, "feed") ?? text;
   const feedInner = stripAllElements(feedOuter, "entry");
-  const feedTitle = decodeXml2(firstTagText(feedInner, "title"));
-  const feedUpdated = normalizeDate(decodeXml2(firstTagText(feedInner, "updated")));
+  const feedTitle = decodeXml3(firstTagText(feedInner, "title"));
+  const feedUpdated = normalizeDate(decodeXml3(firstTagText(feedInner, "updated")));
   const items = collectElements(feedOuter, "entry");
   const entries = items.map((item) => {
-    const id2 = decodeXml2(firstTagText(item, "id"));
-    const title = decodeXml2(firstTagText(item, "title"));
-    const summary = decodeXml2(firstTagText(item, "summary"));
+    const id2 = decodeXml3(firstTagText(item, "id"));
+    const title = decodeXml3(firstTagText(item, "title"));
+    const summary = decodeXml3(firstTagText(item, "summary"));
     const contentNode = firstTagText(item, "content");
-    const published = normalizeDate(decodeXml2(firstTagText(item, "published")));
-    const updated = normalizeDate(decodeXml2(firstTagText(item, "updated")));
-    const author = decodeXml2(firstTagText(extractFirstElement(item, "author") ?? "", "name")) ?? decodeXml2(firstTagText(item, "author"));
+    const published = normalizeDate(decodeXml3(firstTagText(item, "published")));
+    const updated = normalizeDate(decodeXml3(firstTagText(item, "updated")));
+    const author = decodeXml3(firstTagText(extractFirstElement(item, "author") ?? "", "name")) ?? decodeXml3(firstTagText(item, "author"));
     const link = pickAtomLink(item);
     const categories = collectAtomCategories(item);
     return {
@@ -42762,7 +43636,7 @@ function parseAtom(text, feedUrl) {
       title,
       link,
       summary,
-      content: decodeXml2(contentNode),
+      content: decodeXml3(contentNode),
       published,
       updated,
       author,
@@ -42848,9 +43722,9 @@ function collectAtomCategories(entryOuter) {
   let m;
   while ((m = re.exec(entryOuter)) !== null) {
     const term = readAttr(m[1] ?? "", "term");
-    if (term) out.push(decodeXml2(term) ?? "");
+    if (term) out.push(decodeXml3(term) ?? "");
     else if (m[2]) {
-      const inner = decodeXml2(stripTags(m[2]));
+      const inner = decodeXml3(stripTags(m[2]));
       if (inner) out.push(inner);
     }
   }
@@ -42878,7 +43752,7 @@ function unwrapCdata(value) {
   out += value.slice(lastIdx);
   return out;
 }
-function decodeXml2(value) {
+function decodeXml3(value) {
   if (value === null) return null;
   const trimmed = value.trim();
   if (trimmed.length === 0) return null;
@@ -52665,17 +53539,17 @@ var zohoBookingsConnector = {
     category: "calendar",
     defaultConsistencyModel: "authoritative",
     capabilities: [
-      readCapability3("workspaces.list", "List Zoho Bookings workspaces.", {}),
-      readCapability3("services.list", "List services, optionally within one workspace.", {
+      readCapability4("workspaces.list", "List Zoho Bookings workspaces.", {}),
+      readCapability4("services.list", "List services, optionally within one workspace.", {
         workspace_id: { type: "string" }
       }),
-      readCapability3("resources.list", "List bookable resources, optionally for one service.", {
+      readCapability4("resources.list", "List bookable resources, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability3("staff.list", "List staff, optionally for one service.", {
+      readCapability4("staff.list", "List staff, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability3("appointments.list", "List appointments from a required start time.", {
+      readCapability4("appointments.list", "List appointments from a required start time.", {
         from_time: {
           type: "string",
           description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format."
@@ -52685,17 +53559,17 @@ var zohoBookingsConnector = {
         staff_id: { type: "string" },
         status: { type: "string" }
       }, ["from_time"]),
-      readCapability3("appointments.get", "Read one appointment by booking id.", {
+      readCapability4("appointments.get", "Read one appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"]),
-      readCapability3("availability.fetch", "Fetch open time slots for a service and date.", {
+      readCapability4("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"]),
-      mutationCapability3("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: {
@@ -52711,13 +53585,13 @@ var zohoBookingsConnector = {
         additional_fields: { type: "object" },
         payment_info: { type: "object" }
       }, ["service_id", "from_time", "customer_details"]),
-      mutationCapability3("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"]),
-      mutationCapability3("appointments.cancel", "Cancel an appointment by booking id.", {
+      mutationCapability5("appointments.cancel", "Cancel an appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"])
     ]
@@ -52834,7 +53708,7 @@ var zohoBookingsConnector = {
     }
   }
 };
-function readCapability3(name, description, properties, required = []) {
+function readCapability4(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -52843,7 +53717,7 @@ function readCapability3(name, description, properties, required = []) {
     requiredScopes: ["zohobookings.data.READ"]
   };
 }
-function mutationCapability3(name, description, properties, required) {
+function mutationCapability5(name, description, properties, required) {
   return {
     name,
     class: "mutation",
@@ -52898,7 +53772,7 @@ async function request2(source, path, options) {
     throw new ProviderRateLimited("Zoho Bookings rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs4(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}`);
@@ -52943,7 +53817,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 retryAfterMs4(value) {
+function retryAfterMs6(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   return Number.isFinite(seconds) && seconds >= 0 ? Math.max(1e3, seconds * 1e3) : 6e4;
@@ -54082,11 +54956,11 @@ async function request3(source, path, options) {
     });
   }
   if (response.status === 429) {
-    const retryAfterMs5 = 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: retryAfterMs5
+      retryAfterMs: retryAfterMs7
     });
   }
   if (!response.ok) {
@@ -61746,6 +62620,8 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => googleCloudStorageConnector, googleOAuthEnvMap),
   defineFactoryAdapter(() => googlePubSubConnector, {}),
   defineFactoryAdapter(() => azureBlobStorageConnector, {}),
+  defineFactoryAdapter(() => azureEventGridConnector, {}),
+  defineFactoryAdapter(() => azureServiceBusConnector, {}),
   defineFactoryAdapter(() => backblazeConnector, {}),
   defineFactoryAdapter(() => cloudinaryConnector, {}),
   defineFactoryAdapter(() => codaConnector, {}),
@@ -62519,11 +63395,11 @@ function validateOutboundStartArgs(args) {
   assertNonEmptyString(args.agentId, "agentId", 128);
   assertE164(args.toNumber, "toNumber");
   assertE164(args.fromNumber, "fromNumber");
-  if (!isRecord2(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 && !isRecord2(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) {
@@ -62537,7 +63413,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 (!isRecord2(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);
@@ -62564,7 +63440,7 @@ function assertOptionalInteger(value, field, min, max) {
     throw new Error(`phony start_outbound_call ${field} must be an integer between ${min} and ${max}`);
   }
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function getJson(inv, token, url, label) {
@@ -62636,7 +63512,7 @@ var INGEST_FIELDS = [
 ];
 
 // src/connectors/adapters/webhook.ts
-import { createHmac as createHmac5 } from "crypto";
+import { createHmac as createHmac6 } from "crypto";
 var webhookConnector = {
   manifest: {
     kind: "webhook",
@@ -62750,7 +63626,7 @@ function signHeaders(creds, body, idempotencyKey) {
     "x-phony-idempotency-key": idempotencyKey
   };
   if (creds.kind === "hmac" && typeof creds.secret === "string" && creds.secret.length > 0) {
-    const sig = createHmac5("sha256", creds.secret).update(`${ts}.${body}`).digest("hex");
+    const sig = createHmac6("sha256", creds.secret).update(`${ts}.${body}`).digest("hex");
     headers["x-phony-signature"] = `sha256=${sig}`;
   }
   return headers;
@@ -141686,6 +142562,8 @@ export {
   avalaraConnector,
   azureAdConnector,
   azureBlobStorageConnector,
+  azureEventGridConnector,
+  azureServiceBusConnector,
   basecampConnector,
   backblazeConnector,
   biginByZohoConnector,
@@ -142254,4 +143132,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-YWNB5M5K.js.map
+//# sourceMappingURL=chunk-XZL47RBS.js.map