serverless-spy 1.2.0 → 1.3.1

package/lib/extension/dist/layer/nodejs/node_modules/interceptor.js

@@ -2903,10 +2903,10 @@ ${longDate}
 ${credentialScope}
 ${(0, util_hex_encoding_1.toHex)(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path2 }) {
+      getCanonicalPath({ path }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path2.split("/")) {
+          for (const pathSegment of path.split("/")) {
             if ((pathSegment === null || pathSegment === void 0 ? void 0 : pathSegment.length) === 0)
               continue;
             if (pathSegment === ".")
@@ -2917,11 +2917,11 @@ ${(0, util_hex_encoding_1.toHex)(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${(path2 === null || path2 === void 0 ? void 0 : path2.startsWith("/")) ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && (path2 === null || path2 === void 0 ? void 0 : path2.endsWith("/")) ? "/" : ""}`;
+          const normalizedPath = `${(path === null || path === void 0 ? void 0 : path.startsWith("/")) ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && (path === null || path === void 0 ? void 0 : path.endsWith("/")) ? "/" : ""}`;
           const doubleEncoded = encodeURIComponent(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path2;
+        return path;
       }
       async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
         const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest);
@@ -7227,14 +7227,14 @@ var require_Aws_query = __commonJS({
       return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
     };
     var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-    var buildHttpRpcRequest = async (context, headers, path2, resolvedHostname, body) => {
+    var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
       const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
       const contents = {
         protocol,
         hostname,
         port,
         method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path2 : basePath + path2,
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
         headers
       };
       if (resolvedHostname !== void 0) {
@@ -8032,11 +8032,11 @@ var require_slurpFile = __commonJS({
     var fs_1 = require("fs");
     var { readFile } = fs_1.promises;
     var filePromisesHash = {};
-    var slurpFile = (path2) => {
-      if (!filePromisesHash[path2]) {
-        filePromisesHash[path2] = readFile(path2, "utf8");
+    var slurpFile = (path) => {
+      if (!filePromisesHash[path]) {
+        filePromisesHash[path] = readFile(path, "utf8");
       }
-      return filePromisesHash[path2];
+      return filePromisesHash[path];
     };
     exports.slurpFile = slurpFile;
   }
@@ -9967,7 +9967,7 @@ var require_node_http2_handler = __commonJS({
             rejectOriginal(abortError);
             return;
           }
-          const { hostname, method, port, protocol, path: path2, query } = request;
+          const { hostname, method, port, protocol, path, query } = request;
           const authority = `${protocol}//${hostname}${port ? `:${port}` : ""}`;
           const session = this.getSession(authority, disableConcurrentStreams || false);
           const reject = (err) => {
@@ -9980,7 +9980,7 @@ var require_node_http2_handler = __commonJS({
           const queryString = (0, querystring_builder_1.buildQueryString)(query || {});
           const req = session.request({
             ...request.headers,
-            [http2_1.constants.HTTP2_HEADER_PATH]: queryString ? `${path2}?${queryString}` : path2,
+            [http2_1.constants.HTTP2_HEADER_PATH]: queryString ? `${path}?${queryString}` : path,
             [http2_1.constants.HTTP2_HEADER_METHOD]: method
           });
           session.ref();
@@ -21142,14 +21142,14 @@ var require_Aws_json1_0 = __commonJS({
       return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
     };
     var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-    var buildHttpRpcRequest = async (context, headers, path2, resolvedHostname, body) => {
+    var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
       const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
       const contents = {
         protocol,
         hostname,
         port,
         method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path2 : basePath + path2,
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
         headers
       };
       if (resolvedHostname !== void 0) {
@@ -26272,6 +26272,373 @@ var require_dist_cjs49 = __commonJS({
   }
 });
 
+// extension/aws/Errors.js
+var require_Errors = __commonJS({
+  "extension/aws/Errors.js"(exports, module2) {
+    "use strict";
+    var util = require("util");
+    function _isError(obj) {
+      return obj && obj.name && obj.message && obj.stack && typeof obj.name === "string" && typeof obj.message === "string" && typeof obj.stack === "string";
+    }
+    function intoError(err) {
+      if (err instanceof Error) {
+        return err;
+      } else {
+        return new Error(err);
+      }
+    }
+    module2.exports.intoError = intoError;
+    function toRapidResponse(error) {
+      try {
+        if (util.types.isNativeError(error) || _isError(error)) {
+          return {
+            errorType: error.name,
+            errorMessage: error.message,
+            trace: error.stack.split("\n")
+          };
+        } else {
+          return {
+            errorType: typeof error,
+            errorMessage: error.toString(),
+            trace: []
+          };
+        }
+      } catch (_err) {
+        return {
+          errorType: "handled",
+          errorMessage: "callback called with Error argument, but there was a problem while retrieving one or more of its message, name, and stack"
+        };
+      }
+    }
+    module2.exports.toRapidResponse = toRapidResponse;
+    module2.exports.toFormatted = (error) => {
+      try {
+        return "	" + JSON.stringify(error, (_k, v) => _withEnumerableProperties(v));
+      } catch (err) {
+        return "	" + JSON.stringify(toRapidResponse(error));
+      }
+    };
+    function _withEnumerableProperties(error) {
+      if (error instanceof Error) {
+        let ret = Object.assign(
+          {
+            errorType: error.name,
+            errorMessage: error.message,
+            code: error.code
+          },
+          error
+        );
+        if (typeof error.stack == "string") {
+          ret.stack = error.stack.split("\n");
+        }
+        return ret;
+      } else {
+        return error;
+      }
+    }
+    var errorClasses = [
+      class ImportModuleError extends Error {
+      },
+      class HandlerNotFound extends Error {
+      },
+      class MalformedHandlerName extends Error {
+      },
+      class UserCodeSyntaxError extends Error {
+      },
+      class MalformedStreamingHandler extends Error {
+      },
+      class InvalidStreamingOperation extends Error {
+      },
+      class UnhandledPromiseRejection extends Error {
+        constructor(reason, promise) {
+          super(reason);
+          this.reason = reason;
+          this.promise = promise;
+        }
+      }
+    ];
+    errorClasses.forEach((e) => {
+      module2.exports[e.name] = e;
+      e.prototype.name = `Runtime.${e.name}`;
+    });
+  }
+});
+
+// extension/aws/VerboseLog.js
+var require_VerboseLog = __commonJS({
+  "extension/aws/VerboseLog.js"(exports) {
+    "use strict";
+    var EnvVarName = "AWS_LAMBDA_RUNTIME_VERBOSE";
+    var Tag = "RUNTIME";
+    var Verbosity = (() => {
+      if (!process.env[EnvVarName]) {
+        return 0;
+      }
+      try {
+        const verbosity = parseInt(process.env[EnvVarName]);
+        return verbosity < 0 ? 0 : verbosity > 3 ? 3 : verbosity;
+      } catch (_) {
+        return 0;
+      }
+    })();
+    exports.logger = function(category) {
+      return {
+        verbose: function() {
+          if (Verbosity >= 1) {
+            const args = [...arguments].map(
+              (arg) => typeof arg === "function" ? arg() : arg
+            );
+            console.log.apply(null, [Tag, category, ...args]);
+          }
+        },
+        vverbose: function() {
+          if (Verbosity >= 2) {
+            const args = [...arguments].map(
+              (arg) => typeof arg === "function" ? arg() : arg
+            );
+            console.log.apply(null, [Tag, category, ...args]);
+          }
+        },
+        vvverbose: function() {
+          if (Verbosity >= 3) {
+            const args = [...arguments].map(
+              (arg) => typeof arg === "function" ? arg() : arg
+            );
+            console.log.apply(null, [Tag, category, ...args]);
+          }
+        }
+      };
+    };
+  }
+});
+
+// extension/aws/HttpResponseStream.js
+var require_HttpResponseStream = __commonJS({
+  "extension/aws/HttpResponseStream.js"(exports, module2) {
+    "use strict";
+    var METADATA_PRELUDE_CONTENT_TYPE = "application/vnd.awslambda.http-integration-response";
+    var DELIMITER_LEN = 8;
+    var HttpResponseStream = class {
+      static from(underlyingStream, prelude) {
+        underlyingStream.setContentType(METADATA_PRELUDE_CONTENT_TYPE);
+        const metadataPrelude = JSON.stringify(prelude);
+        underlyingStream._onBeforeFirstWrite = (write) => {
+          write(metadataPrelude);
+          write(new Uint8Array(DELIMITER_LEN));
+        };
+        return underlyingStream;
+      }
+    };
+    module2.exports.HttpResponseStream = HttpResponseStream;
+  }
+});
+
+// extension/aws/UserFunction.js
+var require_UserFunction = __commonJS({
+  "extension/aws/UserFunction.js"(exports, module2) {
+    "use strict";
+    var path = require("path");
+    var fs = require("fs");
+    var {
+      HandlerNotFound,
+      MalformedHandlerName,
+      ImportModuleError,
+      UserCodeSyntaxError
+    } = require_Errors();
+    var { verbose } = require_VerboseLog().logger("LOADER");
+    var { HttpResponseStream } = require_HttpResponseStream();
+    var FUNCTION_EXPR = /^([^.]*)\.(.*)$/;
+    var RELATIVE_PATH_SUBSTRING = "..";
+    var HANDLER_STREAMING = Symbol.for("aws.lambda.runtime.handler.streaming");
+    var HANDLER_HIGHWATERMARK = Symbol.for(
+      "aws.lambda.runtime.handler.streaming.highWaterMark"
+    );
+    var STREAM_RESPONSE = "response";
+    var NoGlobalAwsLambda = process.env["AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA"] === "1" || process.env["AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA"] === "true";
+    function _moduleRootAndHandler(fullHandlerString) {
+      let handlerString = path.basename(fullHandlerString);
+      let moduleRoot = fullHandlerString.substring(
+        0,
+        fullHandlerString.indexOf(handlerString)
+      );
+      return [moduleRoot, handlerString];
+    }
+    function _splitHandlerString(handler2) {
+      let match = handler2.match(FUNCTION_EXPR);
+      if (!match || match.length != 3) {
+        throw new MalformedHandlerName("Bad handler");
+      }
+      return [match[1], match[2]];
+    }
+    function _resolveHandler(object, nestedProperty) {
+      return nestedProperty.split(".").reduce((nested, key) => {
+        return nested && nested[key];
+      }, object);
+    }
+    function _tryRequireFile(file, extension) {
+      const path2 = file + (extension || "");
+      verbose("Try loading as commonjs:", path2);
+      return fs.existsSync(path2) ? require(path2) : void 0;
+    }
+    async function _tryAwaitImport(file, extension) {
+      const path2 = file + (extension || "");
+      verbose("Try loading as esmodule:", path2);
+      if (fs.existsSync(path2)) {
+        return await import(path2);
+      }
+      return void 0;
+    }
+    function _hasFolderPackageJsonTypeModule(folder) {
+      if (folder.endsWith("/node_modules")) {
+        return false;
+      }
+      const pj = path.join(folder, "/package.json");
+      if (fs.existsSync(pj)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pj));
+          if (pkg) {
+            if (pkg.type === "module") {
+              verbose("type: module detected in", pj);
+              return true;
+            } else {
+              verbose("type: module not detected in", pj);
+              return false;
+            }
+          }
+        } catch (e) {
+          console.warn(
+            `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
+            e
+          );
+          return false;
+        }
+      }
+      if (folder === "/") {
+        return false;
+      }
+      return _hasFolderPackageJsonTypeModule(path.resolve(folder, ".."));
+    }
+    function _hasPackageJsonTypeModule(file) {
+      const jsPath = file + ".js";
+      return fs.existsSync(jsPath) ? _hasFolderPackageJsonTypeModule(path.resolve(path.dirname(jsPath))) : false;
+    }
+    async function _tryRequire(appRoot, moduleRoot, module3) {
+      verbose(
+        "Try loading as commonjs: ",
+        module3,
+        " with paths: ,",
+        appRoot,
+        moduleRoot
+      );
+      const lambdaStylePath = path.resolve(appRoot, moduleRoot, module3);
+      const extensionless = _tryRequireFile(lambdaStylePath);
+      if (extensionless) {
+        return extensionless;
+      }
+      const pjHasModule = _hasPackageJsonTypeModule(lambdaStylePath);
+      if (!pjHasModule) {
+        const loaded2 = _tryRequireFile(lambdaStylePath, ".js");
+        if (loaded2) {
+          return loaded2;
+        }
+      }
+      const loaded = pjHasModule && await _tryAwaitImport(lambdaStylePath, ".js") || await _tryAwaitImport(lambdaStylePath, ".mjs") || _tryRequireFile(lambdaStylePath, ".cjs");
+      if (loaded) {
+        return loaded;
+      }
+      verbose(
+        "Try loading as commonjs: ",
+        module3,
+        " with path(s): ",
+        appRoot,
+        moduleRoot
+      );
+      const nodeStylePath = require.resolve(module3, {
+        paths: [appRoot, moduleRoot]
+      });
+      return require(nodeStylePath);
+    }
+    async function _loadUserApp(appRoot, moduleRoot, module3) {
+      if (!NoGlobalAwsLambda) {
+        globalThis.awslambda = {
+          streamifyResponse: (handler2, options) => {
+            handler2[HANDLER_STREAMING] = STREAM_RESPONSE;
+            if (typeof (options == null ? void 0 : options.highWaterMark) === "number") {
+              handler2[HANDLER_HIGHWATERMARK] = parseInt(options.highWaterMark);
+            }
+            return handler2;
+          },
+          HttpResponseStream
+        };
+      }
+      try {
+        return await _tryRequire(appRoot, moduleRoot, module3);
+      } catch (e) {
+        if (e instanceof SyntaxError) {
+          throw new UserCodeSyntaxError(e);
+        } else if (e.code !== void 0 && e.code === "MODULE_NOT_FOUND") {
+          verbose("globalPaths", JSON.stringify(require("module").globalPaths));
+          throw new ImportModuleError(e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    function _throwIfInvalidHandler(fullHandlerString) {
+      if (fullHandlerString.includes(RELATIVE_PATH_SUBSTRING)) {
+        throw new MalformedHandlerName(
+          `'${fullHandlerString}' is not a valid handler name. Use absolute paths when specifying root directories in handler names.`
+        );
+      }
+    }
+    function _isHandlerStreaming(handler2) {
+      if (typeof handler2[HANDLER_STREAMING] === "undefined" || handler2[HANDLER_STREAMING] === null || handler2[HANDLER_STREAMING] === false) {
+        return false;
+      }
+      if (handler2[HANDLER_STREAMING] === STREAM_RESPONSE) {
+        return STREAM_RESPONSE;
+      } else {
+        throw new MalformedStreamingHandler(
+          "Only response streaming is supported."
+        );
+      }
+    }
+    function _highWaterMark(handler2) {
+      if (typeof handler2[HANDLER_HIGHWATERMARK] === "undefined" || handler2[HANDLER_HIGHWATERMARK] === null || handler2[HANDLER_HIGHWATERMARK] === false) {
+        return void 0;
+      }
+      const hwm = parseInt(handler2[HANDLER_HIGHWATERMARK]);
+      return isNaN(hwm) ? void 0 : hwm;
+    }
+    module2.exports.load = async function(appRoot, fullHandlerString) {
+      _throwIfInvalidHandler(fullHandlerString);
+      let [moduleRoot, moduleAndHandler] = _moduleRootAndHandler(fullHandlerString);
+      let [module3, handlerPath] = _splitHandlerString(moduleAndHandler);
+      let userApp = await _loadUserApp(appRoot, moduleRoot, module3);
+      let handlerFunc = _resolveHandler(userApp, handlerPath);
+      if (!handlerFunc) {
+        throw new HandlerNotFound(
+          `${fullHandlerString} is undefined or not exported`
+        );
+      }
+      if (typeof handlerFunc !== "function") {
+        throw new HandlerNotFound(`${fullHandlerString} is not a function`);
+      }
+      return handlerFunc;
+    };
+    module2.exports.isHandlerFunction = function(value) {
+      return typeof value === "function";
+    };
+    module2.exports.getHandlerMetadata = function(handlerFunc) {
+      return {
+        streaming: _isHandlerStreaming(handlerFunc),
+        highWaterMark: _highWaterMark(handlerFunc)
+      };
+    };
+    module2.exports.STREAM_RESPONSE = STREAM_RESPONSE;
+  }
+});
+
 // extension/interceptor.ts
 var interceptor_exports = {};
 __export(interceptor_exports, {
@@ -26279,6 +26646,150 @@ __export(interceptor_exports, {
 });
 module.exports = __toCommonJS(interceptor_exports);
 
+// node_modules/serialize-error/error-constructors.js
+var list = [
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError,
+  globalThis.DOMException,
+  globalThis.AssertionError,
+  globalThis.SystemError
+].filter(Boolean).map(
+  (constructor) => [constructor.name, constructor]
+);
+var errorConstructors = new Map(list);
+var error_constructors_default = errorConstructors;
+
+// node_modules/serialize-error/index.js
+var commonProperties = [
+  {
+    property: "name",
+    enumerable: false
+  },
+  {
+    property: "message",
+    enumerable: false
+  },
+  {
+    property: "stack",
+    enumerable: false
+  },
+  {
+    property: "code",
+    enumerable: true
+  },
+  {
+    property: "cause",
+    enumerable: false
+  }
+];
+var toJsonWasCalled = Symbol(".toJSON was called");
+var toJSON = (from) => {
+  from[toJsonWasCalled] = true;
+  const json = from.toJSON();
+  delete from[toJsonWasCalled];
+  return json;
+};
+var getErrorConstructor = (name) => error_constructors_default.get(name) ?? Error;
+var destroyCircular = ({
+  from,
+  seen,
+  to,
+  forceEnumerable,
+  maxDepth,
+  depth,
+  useToJSON,
+  serialize
+}) => {
+  if (!to) {
+    if (Array.isArray(from)) {
+      to = [];
+    } else if (!serialize && isErrorLike(from)) {
+      const Error2 = getErrorConstructor(from.name);
+      to = new Error2();
+    } else {
+      to = {};
+    }
+  }
+  seen.push(from);
+  if (depth >= maxDepth) {
+    return to;
+  }
+  if (useToJSON && typeof from.toJSON === "function" && from[toJsonWasCalled] !== true) {
+    return toJSON(from);
+  }
+  const continueDestroyCircular = (value) => destroyCircular({
+    from: value,
+    seen: [...seen],
+    forceEnumerable,
+    maxDepth,
+    depth,
+    useToJSON,
+    serialize
+  });
+  for (const [key, value] of Object.entries(from)) {
+    if (typeof Buffer === "function" && Buffer.isBuffer(value)) {
+      to[key] = "[object Buffer]";
+      continue;
+    }
+    if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
+      to[key] = "[object Stream]";
+      continue;
+    }
+    if (typeof value === "function") {
+      continue;
+    }
+    if (!value || typeof value !== "object") {
+      to[key] = value;
+      continue;
+    }
+    if (!seen.includes(from[key])) {
+      depth++;
+      to[key] = continueDestroyCircular(from[key]);
+      continue;
+    }
+    to[key] = "[Circular]";
+  }
+  for (const { property, enumerable } of commonProperties) {
+    if (typeof from[property] !== "undefined" && from[property] !== null) {
+      Object.defineProperty(to, property, {
+        value: isErrorLike(from[property]) ? continueDestroyCircular(from[property]) : from[property],
+        enumerable: forceEnumerable ? true : enumerable,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  return to;
+};
+function serializeError(value, options = {}) {
+  const {
+    maxDepth = Number.POSITIVE_INFINITY,
+    useToJSON = true
+  } = options;
+  if (typeof value === "object" && value !== null) {
+    return destroyCircular({
+      from: value,
+      seen: [],
+      forceEnumerable: true,
+      maxDepth,
+      depth: 0,
+      useToJSON,
+      serialize: true
+    });
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name ?? "anonymous"}]`;
+  }
+  return value;
+}
+function isErrorLike(value) {
+  return Boolean(value) && typeof value === "object" && "name" in value && "message" in value && "stack" in value;
+}
+
 // common/SpyEventSender.ts
 var import_client_apigatewaymanagementapi = __toESM(require_dist_cjs44());
 var import_client_dynamodb = __toESM(require_dist_cjs48());
@@ -26494,262 +27005,8 @@ var SpyEventSender = class {
   }
 };
 
-// extension/aws/UserFunction.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-
-// extension/aws/Errors.ts
-var ExtendedError = class extends Error {
-  constructor(reason) {
-    super(reason);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var ImportModuleError = class extends ExtendedError {
-};
-var HandlerNotFound = class extends ExtendedError {
-};
-var MalformedHandlerName = class extends ExtendedError {
-};
-var UserCodeSyntaxError = class extends ExtendedError {
-};
-var UnhandledPromiseRejection = class extends ExtendedError {
-  constructor(reason, promise) {
-    super(reason);
-    this.reason = reason;
-    this.promise = promise;
-  }
-};
-var errorClasses = [
-  ImportModuleError,
-  HandlerNotFound,
-  MalformedHandlerName,
-  UserCodeSyntaxError,
-  UnhandledPromiseRejection
-];
-errorClasses.forEach((e) => {
-  e.prototype.name = `Runtime.${e.name}`;
-});
-
-// extension/aws/UserFunction.ts
-var FUNCTION_EXPR = /^([^.]*)\.(.*)$/;
-var RELATIVE_PATH_SUBSTRING = "..";
-function _moduleRootAndHandler(fullHandlerString) {
-  const handlerString = import_path.default.basename(fullHandlerString);
-  const moduleRoot = fullHandlerString.substring(
-    0,
-    fullHandlerString.indexOf(handlerString)
-  );
-  return [moduleRoot, handlerString];
-}
-function _splitHandlerString(handler2) {
-  const match = handler2.match(FUNCTION_EXPR);
-  if (!match || match.length != 3) {
-    throw new MalformedHandlerName("Bad handler");
-  }
-  return [match[1], match[2]];
-}
-function _resolveHandler(object, nestedProperty) {
-  return nestedProperty.split(".").reduce((nested, key) => {
-    return nested && nested[key];
-  }, object);
-}
-function _canLoadAsFile(modulePath) {
-  return import_fs.default.existsSync(modulePath) || import_fs.default.existsSync(modulePath + ".js");
-}
-function _tryRequire(appRoot, moduleRoot, module2) {
-  const lambdaStylePath = import_path.default.resolve(appRoot, moduleRoot, module2);
-  if (_canLoadAsFile(lambdaStylePath)) {
-    return require(lambdaStylePath);
-  } else {
-    const nodeStylePath = require.resolve(module2, {
-      paths: [appRoot, moduleRoot]
-    });
-    return require(nodeStylePath);
-  }
-}
-function _loadUserApp(appRoot, moduleRoot, module2) {
-  try {
-    return _tryRequire(appRoot, moduleRoot, module2);
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      throw new UserCodeSyntaxError(e);
-    } else if (e.code !== void 0 && e.code === "MODULE_NOT_FOUND") {
-      throw new ImportModuleError(e);
-    } else {
-      throw e;
-    }
-  }
-}
-function _throwIfInvalidHandler(fullHandlerString) {
-  if (fullHandlerString.includes(RELATIVE_PATH_SUBSTRING)) {
-    throw new MalformedHandlerName(
-      `'${fullHandlerString}' is not a valid handler name. Use absolute paths when specifying root directories in handler names.`
-    );
-  }
-}
-var load = function(appRoot, fullHandlerString) {
-  _throwIfInvalidHandler(fullHandlerString);
-  const [moduleRoot, moduleAndHandler] = _moduleRootAndHandler(fullHandlerString);
-  const [module2, handlerPath] = _splitHandlerString(moduleAndHandler);
-  const userApp = _loadUserApp(appRoot, moduleRoot, module2);
-  const handlerFunc = _resolveHandler(userApp, handlerPath);
-  if (!handlerFunc) {
-    throw new HandlerNotFound(
-      `${fullHandlerString} is undefined or not exported`
-    );
-  }
-  if (typeof handlerFunc !== "function") {
-    throw new HandlerNotFound(`${fullHandlerString} is not a function`);
-  }
-  return handlerFunc;
-};
-
-// node_modules/serialize-error/error-constructors.js
-var list = [
-  EvalError,
-  RangeError,
-  ReferenceError,
-  SyntaxError,
-  TypeError,
-  URIError,
-  globalThis.DOMException,
-  globalThis.AssertionError,
-  globalThis.SystemError
-].filter(Boolean).map(
-  (constructor) => [constructor.name, constructor]
-);
-var errorConstructors = new Map(list);
-var error_constructors_default = errorConstructors;
-
-// node_modules/serialize-error/index.js
-var commonProperties = [
-  {
-    property: "name",
-    enumerable: false
-  },
-  {
-    property: "message",
-    enumerable: false
-  },
-  {
-    property: "stack",
-    enumerable: false
-  },
-  {
-    property: "code",
-    enumerable: true
-  },
-  {
-    property: "cause",
-    enumerable: false
-  }
-];
-var toJsonWasCalled = Symbol(".toJSON was called");
-var toJSON = (from) => {
-  from[toJsonWasCalled] = true;
-  const json = from.toJSON();
-  delete from[toJsonWasCalled];
-  return json;
-};
-var getErrorConstructor = (name) => error_constructors_default.get(name) ?? Error;
-var destroyCircular = ({
-  from,
-  seen,
-  to,
-  forceEnumerable,
-  maxDepth,
-  depth,
-  useToJSON,
-  serialize
-}) => {
-  if (!to) {
-    if (Array.isArray(from)) {
-      to = [];
-    } else if (!serialize && isErrorLike(from)) {
-      const Error2 = getErrorConstructor(from.name);
-      to = new Error2();
-    } else {
-      to = {};
-    }
-  }
-  seen.push(from);
-  if (depth >= maxDepth) {
-    return to;
-  }
-  if (useToJSON && typeof from.toJSON === "function" && from[toJsonWasCalled] !== true) {
-    return toJSON(from);
-  }
-  const continueDestroyCircular = (value) => destroyCircular({
-    from: value,
-    seen: [...seen],
-    forceEnumerable,
-    maxDepth,
-    depth,
-    useToJSON,
-    serialize
-  });
-  for (const [key, value] of Object.entries(from)) {
-    if (typeof Buffer === "function" && Buffer.isBuffer(value)) {
-      to[key] = "[object Buffer]";
-      continue;
-    }
-    if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
-      to[key] = "[object Stream]";
-      continue;
-    }
-    if (typeof value === "function") {
-      continue;
-    }
-    if (!value || typeof value !== "object") {
-      to[key] = value;
-      continue;
-    }
-    if (!seen.includes(from[key])) {
-      depth++;
-      to[key] = continueDestroyCircular(from[key]);
-      continue;
-    }
-    to[key] = "[Circular]";
-  }
-  for (const { property, enumerable } of commonProperties) {
-    if (typeof from[property] !== "undefined" && from[property] !== null) {
-      Object.defineProperty(to, property, {
-        value: isErrorLike(from[property]) ? continueDestroyCircular(from[property]) : from[property],
-        enumerable: forceEnumerable ? true : enumerable,
-        configurable: true,
-        writable: true
-      });
-    }
-  }
-  return to;
-};
-function serializeError(value, options = {}) {
-  const {
-    maxDepth = Number.POSITIVE_INFINITY,
-    useToJSON = true
-  } = options;
-  if (typeof value === "object" && value !== null) {
-    return destroyCircular({
-      from: value,
-      seen: [],
-      forceEnumerable: true,
-      maxDepth,
-      depth: 0,
-      useToJSON,
-      serialize: true
-    });
-  }
-  if (typeof value === "function") {
-    return `[Function: ${value.name ?? "anonymous"}]`;
-  }
-  return value;
-}
-function isErrorLike(value) {
-  return Boolean(value) && typeof value === "object" && "name" in value && "message" in value && "stack" in value;
-}
-
 // extension/interceptor.ts
+var import_UserFunction = __toESM(require_UserFunction());
 var ORIGINAL_HANDLER_KEY = "ORIGINAL_HANDLER";
 var subscribedToSQS = process.env["SSPY_SUBSCRIBED_TO_SQS" /* SSPY_SUBSCRIBED_TO_SQS */] === "true";
 var debugMode = process.env["SSPY_DEBUG" /* SSPY_DEBUG */] === "true";
@@ -26766,7 +27023,7 @@ var spyEventSender = new SpyEventSender({
   log,
   logError
 });
-var handler = (event, context, callback) => {
+var handler = async (event, context, callback) => {
   const contextSpy = {
     functionName: context.functionName,
     awsRequestId: context.awsRequestId,
@@ -26788,7 +27045,7 @@ var handler = (event, context, callback) => {
     context: contextSpy
   });
   promises.push(p);
-  const originalHandler = getOriginalHandler();
+  const originalHandler = await getOriginalHandler();
   const fail = (error) => {
     logError(error);
     const errorSerialized = serializeError(error);
@@ -26824,7 +27081,7 @@ var handler = (event, context, callback) => {
   try {
     const result = originalHandler(event, context, newCallback);
     if (isPromise(result)) {
-      return new Promise((resolve, reject) => {
+      return await new Promise((resolve, reject) => {
         result.then(
           (response) => succeed(response).then(() => {
             resolve(response);
@@ -26895,11 +27152,11 @@ async function sendLambdaSpyEvent(serviceKey, data) {
 async function sendRawSpyEvent(data) {
   await spyEventSender.publishSpyEvent(data);
 }
-function getOriginalHandler() {
+async function getOriginalHandler() {
   log("Original handler", process.env[ORIGINAL_HANDLER_KEY]);
   if (process.env[ORIGINAL_HANDLER_KEY] === void 0)
     throw Error("Missing original handler");
-  return load(
+  return (0, import_UserFunction.load)(
     process.env.LAMBDA_TASK_ROOT,
     process.env[ORIGINAL_HANDLER_KEY]
   );