@vercel/slack-bolt 1.3.1 → 1.4.1

package/dist/index.js

@@ -1,385 +1,509 @@
-'use strict';
-
-require('./chunk-QHMZVK6J.js');
-var bolt = require('@slack/bolt');
-var logger = require('@slack/logger');
-var functions = require('@vercel/functions');
-
-// src/errors.ts
-var ERROR_MESSAGES = {
-  // VercelReceiver errors
-  SIGNING_SECRET_REQUIRED: "SLACK_SIGNING_SECRET is required for VercelReceiver",
-  APP_NOT_INITIALIZED: "App not initialized",
-  REQUEST_TIMEOUT: "Request timeout",
-  EVENT_NOT_ACKNOWLEDGED: "Event not acknowledged within timeout period",
-  // Header validation errors
-  MISSING_REQUIRED_HEADER: (header) => `Missing required header: ${header}`,
-  // Generic fallback errors
-  REQUEST_VERIFICATION_FAILED: "Request verification failed",
-  INTERNAL_SERVER_ERROR: "Internal server error",
-  INTERNAL_SERVER_ERROR_HANDLER: "Internal Server Error",
-  ACKNOWLEDGMENT_ERROR: "Error in acknowledgment handler",
-  CREATE_HANDLER_ERROR: "Error in createHandler:",
-  // Error type names
-  TYPES: {
-    VERCEL_RECEIVER_ERROR: "VercelReceiverError",
-    SIGNATURE_VERIFICATION_ERROR: "SignatureVerificationError",
-    REQUEST_PARSING_ERROR: "RequestParsingError",
-    UNEXPECTED_ERROR: "UnexpectedError",
-    HANDLER_ERROR: "HandlerError"
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./preview-DeqpNNn_.js");
+let _slack_bolt = require("@slack/bolt");
+let _slack_logger = require("@slack/logger");
+let _slack_oauth = require("@slack/oauth");
+let _vercel_functions = require("@vercel/functions");
+let node_http = require("node:http");
+let node_net = require("node:net");
+//#region src/errors.ts
+const ERROR_MESSAGES = {
+	SIGNING_SECRET_REQUIRED: "SLACK_SIGNING_SECRET is required for VercelReceiver",
+	APP_NOT_INITIALIZED: "App not initialized",
+	OAUTH_NOT_CONFIGURED: "OAuth is not configured. Provide clientId, clientSecret, and stateSecret to enable OAuth.",
+	REQUEST_TIMEOUT: "Request timeout",
+	EVENT_NOT_ACKNOWLEDGED: "Event not acknowledged within timeout period",
+	MISSING_REQUIRED_HEADER: (header) => `Missing required header: ${header}`,
+	REQUEST_VERIFICATION_FAILED: "Request verification failed",
+	INTERNAL_SERVER_ERROR: "Internal server error",
+	INTERNAL_SERVER_ERROR_HANDLER: "Internal Server Error",
+	ACKNOWLEDGMENT_ERROR: "Error in acknowledgment handler",
+	CREATE_HANDLER_ERROR: "Error in createHandler:",
+	TYPES: {
+		VERCEL_RECEIVER_ERROR: "VercelReceiverError",
+		SIGNATURE_VERIFICATION_ERROR: "SignatureVerificationError",
+		REQUEST_PARSING_ERROR: "RequestParsingError",
+		UNEXPECTED_ERROR: "UnexpectedError",
+		HANDLER_ERROR: "HandlerError"
+	}
 };
 var VercelReceiverError = class extends Error {
-  constructor(message, statusCode = 500) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = ERROR_MESSAGES.TYPES.VERCEL_RECEIVER_ERROR;
-  }
+	constructor(message, statusCode = 500) {
+		super(message);
+		this.statusCode = statusCode;
+		this.name = ERROR_MESSAGES.TYPES.VERCEL_RECEIVER_ERROR;
+	}
 };
 var RequestParsingError = class extends VercelReceiverError {
-  constructor(message = "Failed to parse request") {
-    super(message, 400);
-    this.name = ERROR_MESSAGES.TYPES.REQUEST_PARSING_ERROR;
-  }
+	constructor(message = "Failed to parse request") {
+		super(message, 400);
+		this.name = ERROR_MESSAGES.TYPES.REQUEST_PARSING_ERROR;
+	}
 };
+/**
+* Determines the appropriate HTTP status code for a given error.
+* @param error The error to get status code for
+* @returns HTTP status code
+*/
 function getStatusCode(error) {
-  if (error instanceof VercelReceiverError) {
-    return error.statusCode;
-  }
-  if (error && typeof error === "object") {
-    const errorName = error.constructor?.name || error.name;
-    switch (errorName) {
-      case "ReceiverAuthenticityError":
-        return 401;
-      case "ReceiverMultipleAckError":
-        return 500;
-      case "RequestParsingError":
-        return 400;
-      case "SignatureVerificationError":
-        return 400;
-      default:
-        return 500;
-    }
-  }
-  return 500;
+	if (error instanceof VercelReceiverError) return error.statusCode;
+	if (error && typeof error === "object") switch (error.constructor?.name || error.name) {
+		case "ReceiverAuthenticityError": return 401;
+		case "ReceiverMultipleAckError": return 500;
+		case "RequestParsingError": return 400;
+		case "SignatureVerificationError": return 400;
+		default: return 500;
+	}
+	return 500;
 }
+/**
+* Gets the error message for response.
+* @param error The error to get message for
+* @returns Error message string
+*/
 function getErrorMessage(error) {
-  if (error && typeof error === "object" && "message" in error) {
-    return String(error.message);
-  }
-  return ERROR_MESSAGES.INTERNAL_SERVER_ERROR;
+	if (error && typeof error === "object" && "message" in error) return String(error.message);
+	return ERROR_MESSAGES.INTERNAL_SERVER_ERROR;
 }
+/**
+* Gets the error type for response.
+* @param error The error to get type for
+* @returns Error type string
+*/
 function getErrorType(error) {
-  if (error && typeof error === "object") {
-    const ctorName = error.constructor?.name;
-    const nameProp = error.name;
-    const errorName = ctorName ?? nameProp ?? ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR;
-    return errorName === "Error" ? ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR : errorName;
-  }
-  return ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR;
+	if (error && typeof error === "object") {
+		const ctorName = error.constructor?.name;
+		const nameProp = error.name;
+		const errorName = ctorName ?? nameProp ?? ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR;
+		return errorName === "Error" ? ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR : errorName;
+	}
+	return ERROR_MESSAGES.TYPES.UNEXPECTED_ERROR;
 }
-
-// src/index.ts
-var LOG_PREFIX = "[@vercel/slack-bolt]";
-var ACK_TIMEOUT_MS = 3001;
-var SLACK_RETRY_NUM_HEADER = "x-slack-retry-num";
-var SLACK_RETRY_REASON_HEADER = "x-slack-retry-reason";
-var SLACK_TIMESTAMP_HEADER = "x-slack-request-timestamp";
-var SLACK_SIGNATURE_HEADER = "x-slack-signature";
+//#endregion
+//#region src/oauth-adapters.ts
+/**
+* Minimal Web <-> Node HTTP adapters for @slack/oauth InstallProvider.
+*
+* These do NOT implement the full IncomingMessage/ServerResponse contract.
+* Only the methods actually called by InstallProvider are intercepted.
+* Do not reuse for other Node libraries without verifying which methods
+* they call.
+*
+* Targets @slack/oauth\@3.0.5 InstallProvider internals.
+* Do not upgrade without running the integration tests.
+*/
+/**
+* Wraps a Web API Request as a minimal Node.js IncomingMessage
+* so it can be passed to @slack/oauth's InstallProvider methods.
+*/
+function toIncomingMessage(req) {
+	const url = new URL(req.url);
+	const msg = new node_http.IncomingMessage(new node_net.Socket());
+	msg.url = url.pathname + url.search;
+	msg.method = req.method;
+	for (const [key, value] of req.headers.entries()) msg.headers[key.toLowerCase()] = value;
+	if (req.body) req.arrayBuffer().then((buf) => {
+		msg.push(Buffer.from(buf));
+		msg.push(null);
+	}).catch(() => msg.destroy());
+	else msg.push(null);
+	return msg;
+}
+/**
+* Creates a fake ServerResponse that captures setHeader/writeHead/end calls
+* and converts them into a Web API Response.
+*
+* InstallProvider uses res.setHeader() for Location, Set-Cookie, Content-Type
+* and res.getHeader() to read back Set-Cookie before appending.
+*/
+function createResponseCapture() {
+	let statusCode = 200;
+	const capturedHeaders = {};
+	const chunks = [];
+	const res = new node_http.ServerResponse(new node_http.IncomingMessage(new node_net.Socket()));
+	const originalSetHeader = res.setHeader.bind(res);
+	res.setHeader = (name, value) => {
+		const key = name.toLowerCase();
+		if (Array.isArray(value)) capturedHeaders[key] = [...value];
+		else capturedHeaders[key] = String(value);
+		return originalSetHeader(name, value);
+	};
+	const originalGetHeader = res.getHeader.bind(res);
+	res.getHeader = (name) => {
+		const val = capturedHeaders[name.toLowerCase()];
+		if (val !== void 0) return val;
+		return originalGetHeader(name);
+	};
+	const originalWriteHead = res.writeHead.bind(res);
+	res.writeHead = (code, ...args) => {
+		statusCode = code;
+		const headersArg = args.find((a) => a !== void 0 && typeof a === "object" && !Array.isArray(a));
+		if (headersArg) for (const [key, value] of Object.entries(headersArg)) {
+			const lower = key.toLowerCase();
+			capturedHeaders[lower] = value;
+		}
+		return originalWriteHead(code, ...args);
+	};
+	const originalEnd = res.end.bind(res);
+	res.end = (chunk, ...args) => {
+		if (chunk !== void 0 && chunk !== null) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+		return originalEnd(chunk, ...args);
+	};
+	res.toResponse = () => {
+		const body = chunks.length > 0 ? Buffer.concat(chunks).toString() : null;
+		const webHeaders = new Headers();
+		for (const [key, value] of Object.entries(capturedHeaders)) if (Array.isArray(value)) for (const v of value) webHeaders.append(key, v);
+		else webHeaders.set(key, value);
+		return new Response(body, {
+			status: statusCode,
+			headers: webHeaders
+		});
+	};
+	return res;
+}
+//#endregion
+//#region src/index.ts
+const LOG_PREFIX = "[@vercel/slack-bolt]";
+const ACK_TIMEOUT_MS = 3001;
+const SLACK_RETRY_NUM_HEADER = "x-slack-retry-num";
+const SLACK_RETRY_REASON_HEADER = "x-slack-retry-reason";
+const SLACK_TIMESTAMP_HEADER = "x-slack-request-timestamp";
+const SLACK_SIGNATURE_HEADER = "x-slack-signature";
+/**
+* A Slack Bolt receiver implementation designed for Vercel's serverless environment.
+* Handles Slack events, interactions, and slash commands with automatic request verification,
+* background processing, and timeout management.
+*
+* @example
+* ```typescript
+* import { App } from '@slack/bolt';
+* import { VercelReceiver, createHandler } from '@vercel/slack-bolt';
+*
+* const receiver = new VercelReceiver();
+*
+* const app = new App({
+*   receiver,
+*   token: process.env.SLACK_BOT_TOKEN,
+*   signingSecret: process.env.SLACK_SIGNING_SECRET,
+* });
+* ```
+*
+*/
 var VercelReceiver = class {
-  signingSecret;
-  signatureVerification;
-  logger;
-  customPropertiesExtractor;
-  ackTimeoutMs;
-  app;
-  /**
-   * Gets the logger instance used by this receiver.
-   * @returns The logger instance
-   */
-  getLogger() {
-    return this.logger;
-  }
-  /**
-   * Creates a new VercelReceiver instance.
-   *
-   * @param options - Configuration options for the receiver
-   * @throws {VercelReceiverError} When signing secret is not provided
-   *
-   * @example
-   * ```typescript
-   * const receiver = new VercelReceiver();
-   * ```
-   */
-  constructor({
-    signingSecret = process.env.SLACK_SIGNING_SECRET,
-    signatureVerification = true,
-    logger: logger$1,
-    logLevel = logger.LogLevel.INFO,
-    customPropertiesExtractor,
-    ackTimeoutMs = ACK_TIMEOUT_MS
-  } = {}) {
-    if (!signingSecret) {
-      throw new VercelReceiverError(ERROR_MESSAGES.SIGNING_SECRET_REQUIRED);
-    }
-    this.signingSecret = signingSecret;
-    this.signatureVerification = signatureVerification;
-    this.logger = this.createScopedLogger(
-      logger$1 ?? new logger.ConsoleLogger(),
-      logLevel
-    );
-    this.customPropertiesExtractor = customPropertiesExtractor;
-    this.ackTimeoutMs = ackTimeoutMs;
-    this.logger.debug("VercelReceiver initialized");
-  }
-  /**
-   * Initializes the receiver with a Slack Bolt app instance.
-   * This method is called automatically by the Bolt framework.
-   *
-   * @param app - The Slack Bolt app instance
-   */
-  init(app) {
-    this.app = app;
-    this.logger.debug("App initialized in VercelReceiver");
-  }
-  /**
-   * Starts the receiver and returns a handler function for processing requests.
-   * This method is called automatically by the Bolt framework.
-   *
-   * @returns A handler function that processes incoming Slack requests
-   */
-  async start() {
-    this.logger.debug("VercelReceiver started");
-    return this.toHandler();
-  }
-  /**
-   * Stops the receiver. This method is called automatically by the Bolt framework.
-   */
-  async stop() {
-    this.logger.debug("VercelReceiver stopped");
-  }
-  /**
-   * Creates a handler function that processes incoming Slack requests.
-   * This is the main entry point for handling Slack events in Vercel.
-   * It is called automatically by the Bolt framework in the start() method.
-   *
-   * @returns A handler function compatible with Vercel's function signature
-   */
-  toHandler() {
-    return async (req) => {
-      try {
-        const rawBody = await req.text();
-        if (this.signatureVerification) {
-          this.verifyRequest(req, rawBody);
-        }
-        const body = await this.parseRequestBody(req, rawBody);
-        if (body.type === "url_verification") {
-          this.logger.debug("Handling URL verification challenge");
-          return Response.json({ challenge: body.challenge });
-        }
-        return await this.handleSlackEvent(req, body);
-      } catch (error) {
-        return this.handleError(error);
-      }
-    };
-  }
-  async parseRequestBody(req, rawBody) {
-    const contentType = req.headers.get("content-type");
-    try {
-      if (contentType === "application/x-www-form-urlencoded") {
-        const parsedBody = {};
-        const params = new URLSearchParams(rawBody);
-        for (const [key, value] of params.entries()) {
-          parsedBody[key] = value;
-        }
-        if (typeof parsedBody.payload === "string") {
-          return JSON.parse(parsedBody.payload);
-        }
-        return parsedBody;
-      }
-      if (contentType === "application/json") {
-        return JSON.parse(rawBody);
-      }
-      this.logger.warn(`Unexpected content-type detected: ${contentType}`);
-      return JSON.parse(rawBody);
-    } catch (e) {
-      throw new RequestParsingError(
-        `Failed to parse body as JSON data for content-type: ${contentType}. Error: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-  async handleSlackEvent(req, body) {
-    if (!this.app) {
-      throw new VercelReceiverError(ERROR_MESSAGES.APP_NOT_INITIALIZED, 500);
-    }
-    let isAcknowledged = false;
-    let responseResolver;
-    let responseRejecter;
-    const responsePromise = new Promise((resolve, reject) => {
-      responseResolver = resolve;
-      responseRejecter = reject;
-    });
-    const timeoutId = setTimeout(() => {
-      if (!isAcknowledged) {
-        isAcknowledged = true;
-        this.logger.error(ERROR_MESSAGES.EVENT_NOT_ACKNOWLEDGED);
-        const error = new VercelReceiverError(
-          ERROR_MESSAGES.REQUEST_TIMEOUT,
-          408
-        );
-        responseRejecter(error);
-      }
-    }, this.ackTimeoutMs);
-    const ackFn = async (responseBody) => {
-      this.logger.debug(`ack() call begins (body: ${responseBody})`);
-      if (isAcknowledged) {
-        throw new bolt.ReceiverMultipleAckError();
-      }
-      isAcknowledged = true;
-      clearTimeout(timeoutId);
-      try {
-        let body2;
-        if (typeof responseBody === "undefined") {
-          body2 = void 0;
-        } else if (typeof responseBody === "string") {
-          body2 = responseBody;
-        } else {
-          body2 = JSON.stringify(responseBody);
-        }
-        const response = new Response(body2, {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-        responseResolver(response);
-      } catch (error) {
-        this.logger.error(ERROR_MESSAGES.ACKNOWLEDGMENT_ERROR, error);
-        responseRejecter(
-          error instanceof Error ? error : new Error(String(error))
-        );
-      }
-    };
-    const event = this.createSlackReceiverEvent({
-      body,
-      headers: req.headers,
-      ack: ackFn,
-      request: req
-    });
-    functions.waitUntil(
-      this.app.processEvent(event).catch((error) => {
-        return this.handleError(error);
-      })
-    );
-    try {
-      return await responsePromise;
-    } catch (error) {
-      return this.handleError(error);
-    }
-  }
-  verifyRequest(req, body) {
-    const timestamp = req.headers.get(SLACK_TIMESTAMP_HEADER);
-    const signature = req.headers.get(SLACK_SIGNATURE_HEADER);
-    if (!signature) {
-      throw new bolt.ReceiverAuthenticityError(
-        ERROR_MESSAGES.MISSING_REQUIRED_HEADER(SLACK_SIGNATURE_HEADER)
-      );
-    }
-    if (!timestamp) {
-      throw new bolt.ReceiverAuthenticityError(
-        ERROR_MESSAGES.MISSING_REQUIRED_HEADER(SLACK_TIMESTAMP_HEADER)
-      );
-    }
-    try {
-      bolt.verifySlackRequest({
-        signingSecret: this.signingSecret,
-        body,
-        headers: {
-          "x-slack-signature": signature,
-          "x-slack-request-timestamp": Number.parseInt(timestamp, 10)
-        },
-        logger: this.logger
-      });
-    } catch (error) {
-      throw new bolt.ReceiverAuthenticityError(
-        error instanceof Error ? error.message : "Failed to verify request signature"
-      );
-    }
-  }
-  createSlackReceiverEvent({
-    body,
-    headers,
-    ack,
-    request
-  }) {
-    const customProperties = this.customPropertiesExtractor ? this.customPropertiesExtractor(request) : {};
-    const retryNum = headers.get(SLACK_RETRY_NUM_HEADER) || "0";
-    const retryReason = headers.get(SLACK_RETRY_REASON_HEADER) || "";
-    return {
-      body,
-      ack,
-      retryNum: Number(retryNum),
-      retryReason,
-      customProperties
-    };
-  }
-  handleError(error) {
-    const errorMessage = getErrorMessage(error);
-    const errorType = getErrorType(error);
-    const errorStatusCode = getStatusCode(error);
-    this.logger.error(error);
-    return new Response(
-      JSON.stringify({
-        error: errorMessage,
-        type: errorType
-      }),
-      {
-        status: errorStatusCode,
-        headers: { "content-type": "application/json" }
-      }
-    );
-  }
-  createScopedLogger(logger, logLevel) {
-    logger.setLevel(logLevel);
-    return {
-      ...logger,
-      error: (...args) => logger.error?.(LOG_PREFIX, ...args),
-      warn: (...args) => logger.warn?.(LOG_PREFIX, ...args),
-      info: (...args) => logger.info?.(LOG_PREFIX, ...args),
-      debug: (...args) => logger.debug?.(LOG_PREFIX, ...args),
-      setLevel: logger.setLevel,
-      getLevel: logger.getLevel
-    };
-  }
+	signingSecret;
+	signatureVerification;
+	logger;
+	customPropertiesExtractor;
+	ackTimeoutMs;
+	app;
+	installer;
+	installUrlOptions;
+	installCallbackOptions;
+	installPathOptions;
+	stateVerification;
+	/**
+	* Gets the logger instance used by this receiver.
+	* @returns The logger instance
+	*/
+	getLogger() {
+		return this.logger;
+	}
+	/**
+	* Creates a new VercelReceiver instance.
+	*
+	* @param options - Configuration options for the receiver
+	* @throws {VercelReceiverError} When signing secret is not provided
+	*
+	* @example
+	* ```typescript
+	* const receiver = new VercelReceiver();
+	* ```
+	*/
+	constructor({ signingSecret = process.env.SLACK_SIGNING_SECRET, signatureVerification = true, logger, logLevel = _slack_logger.LogLevel.INFO, customPropertiesExtractor, ackTimeoutMs = ACK_TIMEOUT_MS, clientId = process.env.SLACK_CLIENT_ID, clientSecret = process.env.SLACK_CLIENT_SECRET, stateSecret = process.env.SLACK_STATE_SECRET, scopes, redirectUri, installationStore, installerOptions = {} } = {}) {
+		if (!signingSecret) throw new VercelReceiverError(ERROR_MESSAGES.SIGNING_SECRET_REQUIRED);
+		this.signingSecret = signingSecret;
+		this.signatureVerification = signatureVerification;
+		this.logger = this.createScopedLogger(logger ?? new _slack_logger.ConsoleLogger(), logLevel);
+		this.customPropertiesExtractor = customPropertiesExtractor;
+		this.ackTimeoutMs = ackTimeoutMs;
+		this.stateVerification = installerOptions.stateVerification;
+		if (clientId !== void 0 && clientSecret !== void 0 && (installerOptions.stateVerification === false || stateSecret !== void 0 || installerOptions.stateStore !== void 0)) {
+			this.installer = new _slack_oauth.InstallProvider({
+				clientId,
+				clientSecret,
+				stateSecret,
+				installationStore,
+				logger,
+				logLevel,
+				directInstall: installerOptions.directInstall,
+				stateStore: installerOptions.stateStore,
+				stateVerification: installerOptions.stateVerification,
+				legacyStateVerification: installerOptions.legacyStateVerification,
+				stateCookieName: installerOptions.stateCookieName,
+				stateCookieExpirationSeconds: installerOptions.stateCookieExpirationSeconds,
+				renderHtmlForInstallPath: installerOptions.renderHtmlForInstallPath,
+				authVersion: installerOptions.authVersion ?? "v2",
+				clientOptions: installerOptions.clientOptions,
+				authorizationUrl: installerOptions.authorizationUrl
+			});
+			this.installUrlOptions = {
+				scopes: scopes ?? [],
+				userScopes: installerOptions.userScopes,
+				metadata: installerOptions.metadata,
+				redirectUri
+			};
+			this.installCallbackOptions = installerOptions.callbackOptions ?? {};
+			this.installPathOptions = installerOptions.installPathOptions ?? {};
+		}
+		this.logger.debug("VercelReceiver initialized");
+	}
+	/**
+	* Initializes the receiver with a Slack Bolt app instance.
+	* This method is called automatically by the Bolt framework.
+	*
+	* @param app - The Slack Bolt app instance
+	*/
+	init(app) {
+		this.app = app;
+		this.logger.debug("App initialized in VercelReceiver");
+	}
+	/**
+	* Starts the receiver and returns a handler function for processing requests.
+	* This method is called automatically by the Bolt framework.
+	*
+	* @returns A handler function that processes incoming Slack requests
+	*/
+	async start() {
+		this.logger.debug("VercelReceiver started");
+		return this.toHandler();
+	}
+	/**
+	* Stops the receiver. This method is called automatically by the Bolt framework.
+	*/
+	async stop() {
+		this.logger.debug("VercelReceiver stopped");
+	}
+	/**
+	* Handles requests to the OAuth install path.
+	* Renders an "Add to Slack" page or redirects directly to Slack's authorize URL.
+	*/
+	handleInstall = async (req) => {
+		if (!this.installer) throw new VercelReceiverError(ERROR_MESSAGES.OAUTH_NOT_CONFIGURED);
+		const nodeReq = toIncomingMessage(req);
+		const capture = createResponseCapture();
+		await this.installer.handleInstallPath(nodeReq, capture, this.installPathOptions, this.installUrlOptions);
+		return capture.toResponse();
+	};
+	/**
+	* Handles the OAuth redirect callback from Slack.
+	* Exchanges the authorization code for tokens and stores the installation.
+	*/
+	handleCallback = async (req) => {
+		if (!this.installer) throw new VercelReceiverError(ERROR_MESSAGES.OAUTH_NOT_CONFIGURED);
+		const nodeReq = toIncomingMessage(req);
+		const capture = createResponseCapture();
+		if (this.stateVerification === false) await this.installer.handleCallback(nodeReq, capture, this.installCallbackOptions, this.installUrlOptions);
+		else await this.installer.handleCallback(nodeReq, capture, this.installCallbackOptions);
+		return capture.toResponse();
+	};
+	/**
+	* Creates a handler function that processes incoming Slack requests.
+	* This is the main entry point for handling Slack events in Vercel.
+	* It is called automatically by the Bolt framework in the start() method.
+	*
+	* @returns A handler function compatible with Vercel's function signature
+	*/
+	toHandler() {
+		return async (req) => {
+			try {
+				const rawBody = await req.text();
+				if (this.signatureVerification) this.verifyRequest(req, rawBody);
+				const body = await this.parseRequestBody(req, rawBody);
+				if (body.type === "url_verification") {
+					this.logger.debug("Handling URL verification challenge");
+					return Response.json({ challenge: body.challenge });
+				}
+				return await this.handleSlackEvent(req, body);
+			} catch (error) {
+				return this.handleError(error);
+			}
+		};
+	}
+	async parseRequestBody(req, rawBody) {
+		const contentType = req.headers.get("content-type");
+		try {
+			if (contentType === "application/x-www-form-urlencoded") {
+				const parsedBody = {};
+				const params = new URLSearchParams(rawBody);
+				for (const [key, value] of params.entries()) parsedBody[key] = value;
+				if (typeof parsedBody.payload === "string") return JSON.parse(parsedBody.payload);
+				return parsedBody;
+			}
+			if (contentType === "application/json") return JSON.parse(rawBody);
+			this.logger.warn(`Unexpected content-type detected: ${contentType}`);
+			return JSON.parse(rawBody);
+		} catch (e) {
+			throw new RequestParsingError(`Failed to parse body as JSON data for content-type: ${contentType}. Error: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+	async handleSlackEvent(req, body) {
+		if (!this.app) throw new VercelReceiverError(ERROR_MESSAGES.APP_NOT_INITIALIZED, 500);
+		let isAcknowledged = false;
+		let responseResolver;
+		let responseRejecter;
+		const responsePromise = new Promise((resolve, reject) => {
+			responseResolver = resolve;
+			responseRejecter = reject;
+		});
+		const timeoutId = setTimeout(() => {
+			if (!isAcknowledged) {
+				isAcknowledged = true;
+				this.logger.error(ERROR_MESSAGES.EVENT_NOT_ACKNOWLEDGED);
+				const error = new VercelReceiverError(ERROR_MESSAGES.REQUEST_TIMEOUT, 408);
+				responseRejecter(error);
+			}
+		}, this.ackTimeoutMs);
+		const ackFn = async (responseBody) => {
+			this.logger.debug(`ack() call begins (body: ${responseBody})`);
+			if (isAcknowledged) throw new _slack_bolt.ReceiverMultipleAckError();
+			isAcknowledged = true;
+			clearTimeout(timeoutId);
+			try {
+				let body;
+				if (typeof responseBody === "undefined") body = void 0;
+				else if (typeof responseBody === "string") body = responseBody;
+				else body = JSON.stringify(responseBody);
+				const response = new Response(body, {
+					status: 200,
+					headers: { "Content-Type": "application/json" }
+				});
+				responseResolver(response);
+			} catch (error) {
+				this.logger.error(ERROR_MESSAGES.ACKNOWLEDGMENT_ERROR, error);
+				responseRejecter(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		const event = this.createSlackReceiverEvent({
+			body,
+			headers: req.headers,
+			ack: ackFn,
+			request: req
+		});
+		(0, _vercel_functions.waitUntil)(this.app.processEvent(event).catch((error) => {
+			return this.handleError(error);
+		}));
+		try {
+			return await responsePromise;
+		} catch (error) {
+			return this.handleError(error);
+		}
+	}
+	verifyRequest(req, body) {
+		const timestamp = req.headers.get(SLACK_TIMESTAMP_HEADER);
+		const signature = req.headers.get(SLACK_SIGNATURE_HEADER);
+		if (!signature) throw new _slack_bolt.ReceiverAuthenticityError(ERROR_MESSAGES.MISSING_REQUIRED_HEADER(SLACK_SIGNATURE_HEADER));
+		if (!timestamp) throw new _slack_bolt.ReceiverAuthenticityError(ERROR_MESSAGES.MISSING_REQUIRED_HEADER(SLACK_TIMESTAMP_HEADER));
+		try {
+			(0, _slack_bolt.verifySlackRequest)({
+				signingSecret: this.signingSecret,
+				body,
+				headers: {
+					"x-slack-signature": signature,
+					"x-slack-request-timestamp": Number.parseInt(timestamp, 10)
+				},
+				logger: this.logger
+			});
+		} catch (error) {
+			throw new _slack_bolt.ReceiverAuthenticityError(error instanceof Error ? error.message : "Failed to verify request signature");
+		}
+	}
+	createSlackReceiverEvent({ body, headers, ack, request }) {
+		const customProperties = this.customPropertiesExtractor ? this.customPropertiesExtractor(request) : {};
+		const retryNum = headers.get(SLACK_RETRY_NUM_HEADER) || "0";
+		const retryReason = headers.get(SLACK_RETRY_REASON_HEADER) || "";
+		return {
+			body,
+			ack,
+			retryNum: Number(retryNum),
+			retryReason,
+			customProperties
+		};
+	}
+	handleError(error) {
+		const errorMessage = getErrorMessage(error);
+		const errorType = getErrorType(error);
+		const errorStatusCode = getStatusCode(error);
+		this.logger.error(error);
+		return new Response(JSON.stringify({
+			error: errorMessage,
+			type: errorType
+		}), {
+			status: errorStatusCode,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	createScopedLogger(logger, logLevel) {
+		logger.setLevel(logLevel);
+		return {
+			...logger,
+			error: (...args) => logger.error?.(LOG_PREFIX, ...args),
+			warn: (...args) => logger.warn?.(LOG_PREFIX, ...args),
+			info: (...args) => logger.info?.(LOG_PREFIX, ...args),
+			debug: (...args) => logger.debug?.(LOG_PREFIX, ...args),
+			setLevel: logger.setLevel,
+			getLevel: logger.getLevel
+		};
+	}
 };
+/**
+* Creates a Vercel-compatible handler function for a Slack Bolt app.
+* This is the recommended way to create handlers for deployment on Vercel.
+*
+* @param {App} app - The initialized Slack Bolt app instance.
+* @param {VercelReceiver} receiver - The VercelReceiver instance.
+* @returns {VercelHandler} A handler function compatible with Vercel's function signature.
+*
+* @example
+* ```typescript
+* // api/events.ts
+* import { createHandler } from '@vercel/slack-bolt';
+* import { app, receiver } from '../app';
+*
+* const handler = createHandler(app, receiver);
+*
+* export const POST = async (req: Request) => {
+*   return handler(req);
+* };
+* ```
+*
+* @throws {Error} If app initialization fails.
+* @throws {VercelReceiverError} If request processing fails.
+*/
 function createHandler(app, receiver) {
-  let initPromise = null;
-  return async (req) => {
-    try {
-      if (!initPromise) {
-        initPromise = app.init().catch((error) => {
-          initPromise = null;
-          throw error;
-        });
-      }
-      await initPromise;
-      receiver.init(app);
-      const handler = await receiver.start();
-      return handler(req);
-    } catch (error) {
-      console.error(ERROR_MESSAGES.CREATE_HANDLER_ERROR, error);
-      return new Response(
-        JSON.stringify({
-          error: ERROR_MESSAGES.INTERNAL_SERVER_ERROR_HANDLER,
-          type: ERROR_MESSAGES.TYPES.HANDLER_ERROR
-        }),
-        { status: 500, headers: { "content-type": "application/json" } }
-      );
-    }
-  };
+	let initPromise = null;
+	return async (req) => {
+		try {
+			if (!initPromise) initPromise = app.init().catch((error) => {
+				initPromise = null;
+				throw error;
+			});
+			await initPromise;
+			receiver.init(app);
+			return (await receiver.start())(req);
+		} catch (error) {
+			console.error(ERROR_MESSAGES.CREATE_HANDLER_ERROR, error);
+			return new Response(JSON.stringify({
+				error: ERROR_MESSAGES.INTERNAL_SERVER_ERROR_HANDLER,
+				type: ERROR_MESSAGES.TYPES.HANDLER_ERROR
+			}), {
+				status: 500,
+				headers: { "content-type": "application/json" }
+			});
+		}
+	};
 }
-
+//#endregion
 exports.VercelReceiver = VercelReceiver;
 exports.createHandler = createHandler;
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map