@cloudwerk/trigger 0.0.1

package/dist/index.js

@@ -0,0 +1,1130 @@
+// src/errors.ts
+var TriggerError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "TriggerError";
+    this.code = code;
+  }
+};
+var TriggerConfigError = class extends TriggerError {
+  /** The configuration field that is invalid */
+  field;
+  constructor(message, field) {
+    super("CONFIG_ERROR", message);
+    this.name = "TriggerConfigError";
+    this.field = field;
+  }
+};
+var TriggerNoHandlerError = class extends TriggerError {
+  constructor(triggerName) {
+    super(
+      "NO_HANDLER",
+      `Trigger '${triggerName}' must define a handle() function`
+    );
+    this.name = "TriggerNoHandlerError";
+  }
+};
+var TriggerInvalidSourceError = class extends TriggerError {
+  /** The source type that is invalid */
+  sourceType;
+  constructor(message, sourceType) {
+    super("INVALID_SOURCE", message);
+    this.name = "TriggerInvalidSourceError";
+    this.sourceType = sourceType;
+  }
+};
+var TriggerInvalidCronError = class extends TriggerError {
+  /** The invalid cron expression */
+  cron;
+  constructor(cron, reason) {
+    super(
+      "INVALID_CRON",
+      `Invalid cron expression '${cron}'${reason ? `: ${reason}` : ""}`
+    );
+    this.name = "TriggerInvalidCronError";
+    this.cron = cron;
+  }
+};
+var TriggerInvalidWebhookPathError = class extends TriggerError {
+  /** The invalid path */
+  path;
+  constructor(path, reason) {
+    super(
+      "INVALID_WEBHOOK_PATH",
+      `Invalid webhook path '${path}'${reason ? `: ${reason}` : ""}`
+    );
+    this.name = "TriggerInvalidWebhookPathError";
+    this.path = path;
+  }
+};
+var TriggerContextError = class extends TriggerError {
+  constructor() {
+    super(
+      "CONTEXT_ERROR",
+      "Trigger context accessed outside of trigger execution. Context is only available during trigger handling."
+    );
+    this.name = "TriggerContextError";
+  }
+};
+var TriggerNotFoundError = class extends TriggerError {
+  /** The trigger name that was not found */
+  triggerName;
+  /** Available trigger names */
+  availableTriggers;
+  constructor(triggerName, availableTriggers) {
+    const available = availableTriggers.length > 0 ? `Available triggers: ${availableTriggers.join(", ")}` : "No triggers are configured";
+    super(
+      "TRIGGER_NOT_FOUND",
+      `Trigger '${triggerName}' not found. ${available}`
+    );
+    this.name = "TriggerNotFoundError";
+    this.triggerName = triggerName;
+    this.availableTriggers = availableTriggers;
+  }
+};
+var TriggerProcessingError = class extends TriggerError {
+  /** The trigger name that failed */
+  triggerName;
+  /** Number of execution attempts */
+  attempts;
+  /** The event that was being processed (if available) */
+  event;
+  constructor(message, triggerName, attempts, options) {
+    super("PROCESSING_ERROR", message, options);
+    this.name = "TriggerProcessingError";
+    this.triggerName = triggerName;
+    this.attempts = attempts;
+    this.event = options?.event;
+  }
+};
+var TriggerTimeoutError = class extends TriggerError {
+  /** The trigger name that timed out */
+  triggerName;
+  /** Configured timeout in milliseconds */
+  timeoutMs;
+  constructor(triggerName, timeoutMs) {
+    super(
+      "TIMEOUT_ERROR",
+      `Trigger '${triggerName}' execution exceeded timeout of ${timeoutMs}ms`
+    );
+    this.name = "TriggerTimeoutError";
+    this.triggerName = triggerName;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var TriggerMaxRetriesError = class extends TriggerError {
+  /** The trigger name that exceeded retries */
+  triggerName;
+  /** Maximum retries configured */
+  maxRetries;
+  /** The original error that caused the failure */
+  originalError;
+  constructor(triggerName, maxRetries, originalError) {
+    super(
+      "MAX_RETRIES_EXCEEDED",
+      `Trigger '${triggerName}' exceeded maximum retries (${maxRetries})`
+    );
+    this.name = "TriggerMaxRetriesError";
+    this.triggerName = triggerName;
+    this.maxRetries = maxRetries;
+    this.originalError = originalError;
+  }
+};
+var TriggerWebhookVerificationError = class extends TriggerError {
+  /** The trigger name */
+  triggerName;
+  /** The verification error message */
+  verificationError;
+  constructor(triggerName, verificationError) {
+    super(
+      "WEBHOOK_VERIFICATION_FAILED",
+      `Webhook signature verification failed for trigger '${triggerName}'${verificationError ? `: ${verificationError}` : ""}`
+    );
+    this.name = "TriggerWebhookVerificationError";
+    this.triggerName = triggerName;
+    this.verificationError = verificationError;
+  }
+};
+
+// src/define-trigger.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  delay: "1m",
+  backoff: "linear"
+};
+var DEFAULT_TIMEOUT = 3e4;
+function parseDuration(duration) {
+  if (typeof duration === "number") {
+    return duration;
+  }
+  const match = duration.match(/^(\d+)(s|m|h)$/);
+  if (!match) {
+    throw new TriggerConfigError(
+      `Invalid duration format: '${duration}'. Expected format like '30s', '5m', or '1h'`,
+      "duration"
+    );
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value;
+    case "m":
+      return value * 60;
+    case "h":
+      return value * 3600;
+    default:
+      throw new TriggerConfigError(`Unknown duration unit: ${unit}`, "duration");
+  }
+}
+function validateCron(cron) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length < 5 || parts.length > 6) {
+    throw new TriggerInvalidCronError(
+      cron,
+      `Expected 5 or 6 fields, got ${parts.length}`
+    );
+  }
+  const fieldNames = ["minute", "hour", "day of month", "month", "day of week"];
+  if (parts.length === 6) {
+    fieldNames.unshift("second");
+  }
+  const validChars = /^[\d,\-*/]+$/;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part !== "*" && part !== "?" && !validChars.test(part)) {
+      throw new TriggerInvalidCronError(
+        cron,
+        `Invalid characters in ${fieldNames[i]} field: '${part}'`
+      );
+    }
+  }
+}
+function validateWebhookPath(path) {
+  if (!path) {
+    throw new TriggerInvalidWebhookPathError(path, "Path cannot be empty");
+  }
+  if (!path.startsWith("/")) {
+    throw new TriggerInvalidWebhookPathError(
+      path,
+      "Path must start with /"
+    );
+  }
+  const validPath = /^[a-zA-Z0-9\-_/:.]+$/;
+  if (!validPath.test(path)) {
+    throw new TriggerInvalidWebhookPathError(
+      path,
+      "Path contains invalid characters"
+    );
+  }
+  if (path.includes("//")) {
+    throw new TriggerInvalidWebhookPathError(
+      path,
+      "Path cannot contain double slashes"
+    );
+  }
+}
+function validateSource(source) {
+  if (!source || typeof source !== "object") {
+    throw new TriggerInvalidSourceError("Source must be an object");
+  }
+  if (!("type" in source)) {
+    throw new TriggerInvalidSourceError("Source must have a type property");
+  }
+  switch (source.type) {
+    case "scheduled":
+      validateScheduledSource(source);
+      break;
+    case "queue":
+      if (!source.queue || typeof source.queue !== "string") {
+        throw new TriggerInvalidSourceError(
+          "Queue source must specify a queue name",
+          "queue"
+        );
+      }
+      break;
+    case "r2":
+      if (!source.bucket || typeof source.bucket !== "string") {
+        throw new TriggerInvalidSourceError(
+          "R2 source must specify a bucket name",
+          "r2"
+        );
+      }
+      if (!Array.isArray(source.events) || source.events.length === 0) {
+        throw new TriggerInvalidSourceError(
+          "R2 source must specify at least one event type",
+          "r2"
+        );
+      }
+      const validR2Events = ["object-create", "object-delete"];
+      for (const event of source.events) {
+        if (!validR2Events.includes(event)) {
+          throw new TriggerInvalidSourceError(
+            `Invalid R2 event type: '${event}'. Valid types: ${validR2Events.join(", ")}`,
+            "r2"
+          );
+        }
+      }
+      break;
+    case "webhook":
+      validateWebhookSource(source);
+      break;
+    case "email":
+      if (!source.address || typeof source.address !== "string") {
+        throw new TriggerInvalidSourceError(
+          "Email source must specify an address pattern",
+          "email"
+        );
+      }
+      break;
+    case "d1":
+      if (!source.database || typeof source.database !== "string") {
+        throw new TriggerInvalidSourceError(
+          "D1 source must specify a database name",
+          "d1"
+        );
+      }
+      if (!source.table || typeof source.table !== "string") {
+        throw new TriggerInvalidSourceError(
+          "D1 source must specify a table name",
+          "d1"
+        );
+      }
+      if (!Array.isArray(source.events) || source.events.length === 0) {
+        throw new TriggerInvalidSourceError(
+          "D1 source must specify at least one event type",
+          "d1"
+        );
+      }
+      break;
+    case "tail":
+      if (!Array.isArray(source.consumers) || source.consumers.length === 0) {
+        throw new TriggerInvalidSourceError(
+          "Tail source must specify at least one consumer",
+          "tail"
+        );
+      }
+      break;
+    default:
+      throw new TriggerInvalidSourceError(
+        `Unknown source type: '${source.type}'`
+      );
+  }
+}
+function validateScheduledSource(source) {
+  if (!source.cron || typeof source.cron !== "string") {
+    throw new TriggerInvalidSourceError(
+      "Scheduled source must specify a cron expression",
+      "scheduled"
+    );
+  }
+  validateCron(source.cron);
+}
+function validateWebhookSource(source) {
+  if (!source.path) {
+    throw new TriggerInvalidSourceError(
+      "Webhook source must specify a path",
+      "webhook"
+    );
+  }
+  validateWebhookPath(source.path);
+  if (source.methods) {
+    const validMethods = ["POST", "PUT", "PATCH"];
+    for (const method of source.methods) {
+      if (!validMethods.includes(method)) {
+        throw new TriggerInvalidSourceError(
+          `Invalid webhook method: '${method}'. Valid methods: ${validMethods.join(", ")}`,
+          "webhook"
+        );
+      }
+    }
+  }
+}
+function validateConfig(config) {
+  if (!config.handle || typeof config.handle !== "function") {
+    throw new TriggerNoHandlerError(config.name || "unknown");
+  }
+  if (!config.source) {
+    throw new TriggerInvalidSourceError("Trigger must have a source");
+  }
+  validateSource(config.source);
+  if (config.retry) {
+    const { maxAttempts, delay, backoff } = config.retry;
+    if (maxAttempts !== void 0) {
+      if (!Number.isInteger(maxAttempts) || maxAttempts < 0 || maxAttempts > 100) {
+        throw new TriggerConfigError(
+          "maxAttempts must be an integer between 0 and 100",
+          "maxAttempts"
+        );
+      }
+    }
+    if (delay !== void 0) {
+      parseDuration(delay);
+    }
+    if (backoff !== void 0 && backoff !== "linear" && backoff !== "exponential") {
+      throw new TriggerConfigError(
+        `Invalid backoff strategy: '${backoff}'. Valid strategies: 'linear', 'exponential'`,
+        "backoff"
+      );
+    }
+  }
+  if (config.timeout !== void 0) {
+    if (typeof config.timeout !== "number" || config.timeout <= 0) {
+      throw new TriggerConfigError(
+        "timeout must be a positive number (milliseconds)",
+        "timeout"
+      );
+    }
+    if (config.timeout > 6e5) {
+      throw new TriggerConfigError(
+        "timeout cannot exceed 600000ms (10 minutes)",
+        "timeout"
+      );
+    }
+  }
+  if (config.name !== void 0) {
+    if (typeof config.name !== "string" || config.name.length === 0) {
+      throw new TriggerConfigError("name must be a non-empty string", "name");
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(config.name)) {
+      throw new TriggerConfigError(
+        "name must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens",
+        "name"
+      );
+    }
+  }
+  if (config.onError !== void 0 && typeof config.onError !== "function") {
+    throw new TriggerConfigError("onError must be a function", "onError");
+  }
+}
+function defineTrigger(config) {
+  validateConfig(config);
+  const mergedRetryConfig = {
+    ...DEFAULT_RETRY_CONFIG,
+    ...config.retry
+  };
+  const definition = {
+    __brand: "cloudwerk-trigger",
+    name: config.name,
+    source: config.source,
+    retry: mergedRetryConfig,
+    timeout: config.timeout ?? DEFAULT_TIMEOUT,
+    handle: config.handle,
+    onError: config.onError
+  };
+  return definition;
+}
+function isTriggerDefinition(value) {
+  return typeof value === "object" && value !== null && "__brand" in value && value.__brand === "cloudwerk-trigger";
+}
+function getTriggerSourceType(definition) {
+  return definition.source.type;
+}
+
+// src/verifiers/utils.ts
+async function computeHmac(algorithm, secret, data) {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(secret);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: algorithm },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, data);
+  return arrayBufferToHex(signature);
+}
+function arrayBufferToHex(buffer) {
+  const bytes = new Uint8Array(buffer);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const aBytes = new TextEncoder().encode(a);
+  const bBytes = new TextEncoder().encode(b);
+  let result = 0;
+  for (let i = 0; i < aBytes.length; i++) {
+    result |= aBytes[i] ^ bBytes[i];
+  }
+  return result === 0;
+}
+function parseSignatureHeader(header, separator = ",") {
+  const result = /* @__PURE__ */ new Map();
+  for (const part of header.split(separator)) {
+    const [key, ...valueParts] = part.trim().split("=");
+    if (key && valueParts.length > 0) {
+      result.set(key, valueParts.join("="));
+    }
+  }
+  return result;
+}
+
+// src/verifiers/stripe.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
+function stripeVerifier(secret, options = {}) {
+  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+  return async (request, rawBody) => {
+    const signature = request.headers.get("stripe-signature");
+    if (!signature) {
+      return {
+        valid: false,
+        error: "Missing stripe-signature header"
+      };
+    }
+    const parts = parseSignatureHeader(signature);
+    const timestamp = parts.get("t");
+    const expectedSignature = parts.get("v1");
+    if (!timestamp || !expectedSignature) {
+      return {
+        valid: false,
+        error: "Invalid stripe-signature header format"
+      };
+    }
+    const timestampNum = parseInt(timestamp, 10);
+    if (isNaN(timestampNum)) {
+      return {
+        valid: false,
+        error: "Invalid timestamp in signature"
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestampNum) > tolerance) {
+      return {
+        valid: false,
+        error: `Timestamp outside tolerance (${tolerance}s)`
+      };
+    }
+    const payload = new TextDecoder().decode(rawBody);
+    const signedPayload = `${timestamp}.${payload}`;
+    const signedPayloadBytes = new TextEncoder().encode(signedPayload);
+    const computedSignature = await computeHmac(
+      "SHA-256",
+      secret,
+      signedPayloadBytes.buffer
+    );
+    if (!timingSafeEqual(computedSignature, expectedSignature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var stripe = stripeVerifier;
+
+// src/verifiers/github.ts
+function githubVerifier(secret) {
+  return async (request, rawBody) => {
+    const signatureHeader = request.headers.get("x-hub-signature-256") || request.headers.get("x-hub-signature");
+    if (!signatureHeader) {
+      return {
+        valid: false,
+        error: "Missing X-Hub-Signature-256 or X-Hub-Signature header"
+      };
+    }
+    const useSha256 = signatureHeader.startsWith("sha256=");
+    const algorithm = useSha256 ? "SHA-256" : "SHA-1";
+    const prefix = useSha256 ? "sha256=" : "sha1=";
+    if (!signatureHeader.startsWith(prefix)) {
+      return {
+        valid: false,
+        error: `Invalid signature format (expected ${prefix} prefix)`
+      };
+    }
+    const expectedSignature = signatureHeader.slice(prefix.length);
+    const computedSignature = await computeHmac(algorithm, secret, rawBody);
+    if (!timingSafeEqual(computedSignature, expectedSignature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var github = githubVerifier;
+
+// src/verifiers/slack.ts
+var DEFAULT_TOLERANCE_SECONDS2 = 300;
+function slackVerifier(signingSecret, options = {}) {
+  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE_SECONDS2;
+  return async (request, rawBody) => {
+    const timestamp = request.headers.get("x-slack-request-timestamp");
+    const signature = request.headers.get("x-slack-signature");
+    if (!timestamp) {
+      return {
+        valid: false,
+        error: "Missing X-Slack-Request-Timestamp header"
+      };
+    }
+    if (!signature) {
+      return {
+        valid: false,
+        error: "Missing X-Slack-Signature header"
+      };
+    }
+    const timestampNum = parseInt(timestamp, 10);
+    if (isNaN(timestampNum)) {
+      return {
+        valid: false,
+        error: "Invalid timestamp"
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestampNum) > tolerance) {
+      return {
+        valid: false,
+        error: `Timestamp outside tolerance (${tolerance}s)`
+      };
+    }
+    if (!signature.startsWith("v0=")) {
+      return {
+        valid: false,
+        error: "Invalid signature format (expected v0= prefix)"
+      };
+    }
+    const expectedSignature = signature.slice(3);
+    const body = new TextDecoder().decode(rawBody);
+    const sigBasestring = `v0:${timestamp}:${body}`;
+    const sigBasestringBytes = new TextEncoder().encode(sigBasestring);
+    const computedSignature = await computeHmac(
+      "SHA-256",
+      signingSecret,
+      sigBasestringBytes.buffer
+    );
+    if (!timingSafeEqual(computedSignature, expectedSignature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var slack = slackVerifier;
+
+// src/verifiers/twilio.ts
+function twilioVerifier(authToken, options) {
+  const { url } = options;
+  return async (request, rawBody) => {
+    const signature = request.headers.get("x-twilio-signature");
+    if (!signature) {
+      return {
+        valid: false,
+        error: "Missing X-Twilio-Signature header"
+      };
+    }
+    const body = new TextDecoder().decode(rawBody);
+    const params = new URLSearchParams(body);
+    const sortedParams = Array.from(params.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}${value}`).join("");
+    const signatureBase = url + sortedParams;
+    const signatureBaseBytes = new TextEncoder().encode(signatureBase);
+    const computedSignatureHex = await computeHmac(
+      "SHA-1",
+      authToken,
+      signatureBaseBytes.buffer
+    );
+    const computedSignatureBytes = new Uint8Array(
+      computedSignatureHex.match(/.{2}/g).map((byte) => parseInt(byte, 16))
+    );
+    const computedSignature = btoa(
+      String.fromCharCode(...computedSignatureBytes)
+    );
+    if (!timingSafeEqual(computedSignature, signature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var twilio = twilioVerifier;
+
+// src/verifiers/shopify.ts
+function shopifyVerifier(secret) {
+  return async (request, rawBody) => {
+    const signature = request.headers.get("x-shopify-hmac-sha256");
+    if (!signature) {
+      return {
+        valid: false,
+        error: "Missing X-Shopify-Hmac-Sha256 header"
+      };
+    }
+    const computedSignatureHex = await computeHmac("SHA-256", secret, rawBody);
+    const computedSignatureBytes = new Uint8Array(
+      computedSignatureHex.match(/.{2}/g).map((byte) => parseInt(byte, 16))
+    );
+    const computedSignature = btoa(
+      String.fromCharCode(...computedSignatureBytes)
+    );
+    if (!timingSafeEqual(computedSignature, signature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var shopify = shopifyVerifier;
+
+// src/verifiers/linear.ts
+function linearVerifier(secret) {
+  return async (request, rawBody) => {
+    const signature = request.headers.get("linear-signature");
+    if (!signature) {
+      return {
+        valid: false,
+        error: "Missing Linear-Signature header"
+      };
+    }
+    const computedSignature = await computeHmac("SHA-256", secret, rawBody);
+    if (!timingSafeEqual(computedSignature, signature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var linear = linearVerifier;
+
+// src/verifiers/custom.ts
+function customVerifier(secret, options) {
+  const {
+    header,
+    algorithm = "SHA-256",
+    encoding = "hex",
+    prefix,
+    timestampHeader,
+    timestampTolerance = 300,
+    buildSignatureBase
+  } = options;
+  return async (request, rawBody) => {
+    let signature = request.headers.get(header);
+    if (!signature) {
+      return {
+        valid: false,
+        error: `Missing ${header} header`
+      };
+    }
+    if (prefix) {
+      if (!signature.startsWith(prefix)) {
+        return {
+          valid: false,
+          error: `Invalid signature format (expected ${prefix} prefix)`
+        };
+      }
+      signature = signature.slice(prefix.length);
+    }
+    let timestamp;
+    if (timestampHeader) {
+      timestamp = request.headers.get(timestampHeader) ?? void 0;
+      if (!timestamp) {
+        return {
+          valid: false,
+          error: `Missing ${timestampHeader} header`
+        };
+      }
+      const timestampNum = parseInt(timestamp, 10);
+      if (isNaN(timestampNum)) {
+        return {
+          valid: false,
+          error: "Invalid timestamp"
+        };
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (Math.abs(now - timestampNum) > timestampTolerance) {
+        return {
+          valid: false,
+          error: `Timestamp outside tolerance (${timestampTolerance}s)`
+        };
+      }
+    }
+    const body = new TextDecoder().decode(rawBody);
+    const signatureBase = buildSignatureBase ? buildSignatureBase(body, timestamp) : body;
+    const signatureBaseBytes = new TextEncoder().encode(signatureBase);
+    const computedSignatureHex = await computeHmac(
+      algorithm,
+      secret,
+      signatureBaseBytes.buffer
+    );
+    let computedSignature;
+    if (encoding === "base64") {
+      const bytes = new Uint8Array(
+        computedSignatureHex.match(/.{2}/g).map((byte) => parseInt(byte, 16))
+      );
+      computedSignature = btoa(String.fromCharCode(...bytes));
+    } else {
+      computedSignature = computedSignatureHex;
+    }
+    if (!timingSafeEqual(computedSignature, signature)) {
+      return {
+        valid: false,
+        error: "Signature mismatch"
+      };
+    }
+    return { valid: true };
+  };
+}
+var custom = customVerifier;
+
+// src/verifiers/index.ts
+var verifiers = {
+  stripe,
+  github,
+  slack,
+  twilio,
+  shopify,
+  linear,
+  custom
+};
+
+// src/emit.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage();
+var emissionsStore = new AsyncLocalStorage();
+function runWithTriggerContext(context, fn) {
+  return contextStore.run(context, () => {
+    return emissionsStore.run([], fn);
+  });
+}
+function getTriggerContext() {
+  return contextStore.getStore();
+}
+function getPendingEmissions() {
+  return emissionsStore.getStore() ?? [];
+}
+function generateTraceId(prefix = "tr") {
+  const random = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  return `${prefix}_${random}`;
+}
+function createChildTraceId(parentTraceId) {
+  const suffix = crypto.randomUUID().slice(0, 8);
+  return `${parentTraceId}.${suffix}`;
+}
+async function emit(trigger, payload, options = {}) {
+  const context = getTriggerContext();
+  const emissions = emissionsStore.getStore();
+  const traceId = options.traceId ?? context?.traceId ?? generateTraceId();
+  const childTraceId = context ? createChildTraceId(traceId) : traceId;
+  const emittedAt = /* @__PURE__ */ new Date();
+  const emission = {
+    trigger,
+    payload,
+    options,
+    traceId: childTraceId,
+    emittedAt
+  };
+  if (emissions) {
+    emissions.push(emission);
+  }
+  return {
+    success: true,
+    traceId: childTraceId,
+    trigger,
+    emittedAt
+  };
+}
+async function emitMany(emissions, options = {}) {
+  return Promise.all(
+    emissions.map(([trigger, payload]) => emit(trigger, payload, options))
+  );
+}
+var defaultEmitter = {
+  emit,
+  getPendingEmissions,
+  clearPendingEmissions: () => {
+    const emissions = emissionsStore.getStore();
+    if (emissions) {
+      emissions.length = 0;
+    }
+  }
+};
+
+// src/observability.ts
+function generateSpanId() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function createTriggerSpan(triggerName, sourceType, traceId, parentSpanId) {
+  return {
+    spanId: generateSpanId(),
+    traceId,
+    parentSpanId,
+    triggerName,
+    sourceType,
+    operationName: `trigger.${triggerName}`,
+    startTime: Date.now(),
+    status: "unset",
+    attributes: {
+      "trigger.name": triggerName,
+      "trigger.source_type": sourceType
+    },
+    events: []
+  };
+}
+function endTriggerSpan(span, success, error) {
+  span.endTime = Date.now();
+  span.status = success ? "ok" : "error";
+  if (error) {
+    span.attributes["error.type"] = error.name;
+    span.attributes["error.message"] = error.message;
+    span.events.push({
+      name: "exception",
+      timestamp: Date.now(),
+      attributes: {
+        "exception.type": error.name,
+        "exception.message": error.message
+      }
+    });
+  }
+  return span;
+}
+function addSpanEvent(span, name, attributes) {
+  span.events.push({
+    name,
+    timestamp: Date.now(),
+    attributes
+  });
+}
+function setSpanAttributes(span, attributes) {
+  Object.assign(span.attributes, attributes);
+}
+var ExecutionTimer = class {
+  startTime;
+  endTime;
+  marks = /* @__PURE__ */ new Map();
+  constructor() {
+    this.startTime = performance.now();
+  }
+  /**
+   * Mark a point in time.
+   */
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  /**
+   * Get time since start to a mark.
+   */
+  getMarkDuration(name) {
+    const markTime = this.marks.get(name);
+    if (markTime === void 0) return void 0;
+    return markTime - this.startTime;
+  }
+  /**
+   * Stop the timer.
+   */
+  stop() {
+    this.endTime = performance.now();
+    return this.duration;
+  }
+  /**
+   * Get total duration in milliseconds.
+   */
+  get duration() {
+    const end = this.endTime ?? performance.now();
+    return end - this.startTime;
+  }
+  /**
+   * Get all marks with their durations.
+   */
+  getMarks() {
+    const result = {};
+    for (const [name, time] of this.marks) {
+      result[name] = time - this.startTime;
+    }
+    return result;
+  }
+};
+var ConsoleMetricsReporter = class {
+  prefix;
+  constructor(prefix = "[trigger]") {
+    this.prefix = prefix;
+  }
+  reportExecution(metrics) {
+    const status = metrics.success ? "SUCCESS" : "FAILED";
+    const duration = metrics.durationMs ? `${metrics.durationMs}ms` : "unknown";
+    console.log(
+      `${this.prefix} ${metrics.name} [${metrics.traceId}] ${status} (${duration})`
+    );
+    if (metrics.error) {
+      console.error(`${this.prefix} Error:`, metrics.error.message);
+    }
+  }
+  reportSpan(span) {
+    const duration = span.endTime ? `${span.endTime - span.startTime}ms` : "ongoing";
+    console.log(
+      `${this.prefix} Span: ${span.operationName} [${span.traceId}] ${span.status} (${duration})`
+    );
+    for (const event of span.events) {
+      console.log(`${this.prefix}   Event: ${event.name}`);
+    }
+  }
+  async flush() {
+  }
+};
+var NoOpMetricsReporter = class {
+  reportExecution(_metrics) {
+  }
+  reportSpan(_span) {
+  }
+  async flush() {
+  }
+};
+var MetricsCollector = class {
+  executions = [];
+  spans = [];
+  reporter;
+  constructor(reporter = new NoOpMetricsReporter()) {
+    this.reporter = reporter;
+  }
+  /**
+   * Record a trigger execution.
+   */
+  recordExecution(metrics) {
+    this.executions.push(metrics);
+    this.reporter.reportExecution(metrics);
+  }
+  /**
+   * Record a span.
+   */
+  recordSpan(span) {
+    this.spans.push(span);
+    this.reporter.reportSpan(span);
+  }
+  /**
+   * Get execution count for a trigger.
+   */
+  getExecutionCount(triggerName) {
+    return this.executions.filter((m) => m.name === triggerName).length;
+  }
+  /**
+   * Get success rate for a trigger.
+   */
+  getSuccessRate(triggerName) {
+    const executions = this.executions.filter((m) => m.name === triggerName);
+    if (executions.length === 0) return 0;
+    const successful = executions.filter((m) => m.success).length;
+    return successful / executions.length;
+  }
+  /**
+   * Get average duration for a trigger.
+   */
+  getAverageDuration(triggerName) {
+    const executions = this.executions.filter(
+      (m) => m.name === triggerName && m.durationMs !== void 0
+    );
+    if (executions.length === 0) return void 0;
+    const total = executions.reduce((sum, m) => sum + (m.durationMs ?? 0), 0);
+    return total / executions.length;
+  }
+  /**
+   * Get percentile duration for a trigger.
+   */
+  getPercentileDuration(triggerName, percentile) {
+    const executions = this.executions.filter((m) => m.name === triggerName && m.durationMs !== void 0).map((m) => m.durationMs).sort((a, b) => a - b);
+    if (executions.length === 0) return void 0;
+    const index = Math.ceil(percentile / 100 * executions.length) - 1;
+    return executions[Math.max(0, index)];
+  }
+  /**
+   * Get summary statistics for a trigger.
+   */
+  getSummary(triggerName) {
+    return {
+      count: this.getExecutionCount(triggerName),
+      successRate: this.getSuccessRate(triggerName),
+      avgDurationMs: this.getAverageDuration(triggerName),
+      p50DurationMs: this.getPercentileDuration(triggerName, 50),
+      p95DurationMs: this.getPercentileDuration(triggerName, 95),
+      p99DurationMs: this.getPercentileDuration(triggerName, 99)
+    };
+  }
+  /**
+   * Flush metrics to the reporter.
+   */
+  async flush() {
+    await this.reporter.flush();
+  }
+  /**
+   * Clear collected metrics.
+   */
+  clear() {
+    this.executions = [];
+    this.spans = [];
+  }
+};
+function createTriggerMetrics(name, sourceType, ctx, timer, success, error, retryCount = 0) {
+  const durationMs = timer.stop();
+  return {
+    name,
+    sourceType,
+    startedAt: new Date(Date.now() - durationMs),
+    endedAt: /* @__PURE__ */ new Date(),
+    durationMs,
+    success,
+    error,
+    retryCount,
+    traceId: ctx.traceId
+  };
+}
+export {
+  ConsoleMetricsReporter,
+  ExecutionTimer,
+  MetricsCollector,
+  NoOpMetricsReporter,
+  TriggerConfigError,
+  TriggerContextError,
+  TriggerError,
+  TriggerInvalidCronError,
+  TriggerInvalidSourceError,
+  TriggerInvalidWebhookPathError,
+  TriggerMaxRetriesError,
+  TriggerNoHandlerError,
+  TriggerNotFoundError,
+  TriggerProcessingError,
+  TriggerTimeoutError,
+  TriggerWebhookVerificationError,
+  addSpanEvent,
+  createChildTraceId,
+  createTriggerMetrics,
+  createTriggerSpan,
+  custom,
+  customVerifier,
+  defaultEmitter,
+  defineTrigger,
+  emit,
+  emitMany,
+  endTriggerSpan,
+  generateSpanId,
+  generateTraceId,
+  getPendingEmissions,
+  getTriggerContext,
+  getTriggerSourceType,
+  github,
+  githubVerifier,
+  isTriggerDefinition,
+  linear,
+  linearVerifier,
+  parseDuration,
+  runWithTriggerContext,
+  setSpanAttributes,
+  shopify,
+  shopifyVerifier,
+  slack,
+  slackVerifier,
+  stripe,
+  stripeVerifier,
+  twilio,
+  twilioVerifier,
+  verifiers
+};
+//# sourceMappingURL=index.js.map