{"message":"Request received in region: us-west-2","runtimeContent":"// src/codeloader/codeLoader.ts\nvar CodeLoader = class _CodeLoader {\n  static DEFAULT_AWS_LAMBDA_HTTP_ENDPOINT = \"localhost:3000\";\n  entrypoint;\n  timeout;\n  logger;\n  lambdaHttpEndpoint;\n  constructor(config, logger) {\n    this.logger = logger;\n    this.timeout = config.timeout;\n    this.entrypoint = `${config.taskRoot}/${config.customerOverrideEntrypoint || config.defaultEntrypoint}`;\n    this.lambdaHttpEndpoint = process.env[config.lambdaHttpEndpointEnvVariableName] || _CodeLoader.DEFAULT_AWS_LAMBDA_HTTP_ENDPOINT;\n    process.env[config.lambdaHttpEndpointEnvVariableName] = this.lambdaHttpEndpoint;\n  }\n  async load() {\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => {\n      this.logger.error(\"customer code load timeout\");\n      controller.abort();\n    }, this.timeout);\n    try {\n      await Promise.race([this.importModule(), this.createTimeoutPromise(controller.signal)]);\n    } catch (error) {\n      this.logger.error(`error while loading customer code ${error}`);\n      throw new Error(\"could not load customer code\");\n    } finally {\n      this.logger.debug(\"finally: clear the timeout\");\n      clearTimeout(timeoutId);\n    }\n  }\n  async importModule() {\n    await import(this.entrypoint);\n  }\n  createTimeoutPromise(signal) {\n    return new Promise((_, reject) => {\n      signal.addEventListener(\n        \"abort\",\n        () => {\n          this.logger.error(\"abort signal received, failing\");\n          reject(new Error(signal.reason));\n        },\n        { once: true }\n      );\n    });\n  }\n  extractPortFromHostnameWithPort(hostnameWithPort) {\n    try {\n      const url = new URL(`http://${hostnameWithPort}`);\n      if (!url.port) {\n        throw new Error(\"No port specified in hostnameWithPort\");\n      }\n      return url.port;\n    } catch (error) {\n      throw new Error(\"Could not parse hostnameWithPort\");\n    }\n  }\n  getEntrypoint() {\n    return this.entrypoint;\n  }\n  getHttpEntrypoint() {\n    return this.lambdaHttpEndpoint;\n  }\n};\n\n// src/logger/logger.ts\nvar Logger = class {\n  isDebugEnabled;\n  constructor(envValue) {\n    this.isDebugEnabled = envValue?.toLowerCase() === \"true\" || envValue === \"1\";\n  }\n  debug(msg) {\n    if (this.isDebugEnabled) {\n      console.log(`[beta debug] `, msg);\n    }\n  }\n  error(msg) {\n    console.error(`[beta error] `, msg);\n  }\n};\n\n// src/portchecker/portChecker.ts\nimport { Socket } from \"net\";\nvar PortChecker = class {\n  host;\n  port;\n  logger;\n  socket;\n  abortController;\n  constructor(lambdaHttpEntrypoint, logger) {\n    this.logger = logger;\n    const { host, port } = this.parseHostAndPort(lambdaHttpEntrypoint);\n    this.host = host;\n    this.port = port;\n    this.logger.debug(`parsed host = ${host} and port = ${port}`);\n    this.abortController = new AbortController();\n    this.socket = this.createConnection({\n      host: this.host,\n      port: this.port,\n      signal: this.abortController.signal\n    });\n  }\n  async wait() {\n    this.socket.connect({ host: this.host, port: this.port });\n    return new Promise((resolve, reject) => {\n      this.socket.once(\"connect\", () => {\n        this.logger.debug(\"wait connect received\");\n        this.socket.end();\n        resolve();\n      }).once(\"error\", (error) => {\n        this.logger.error(\"wait error received\");\n        this.logger.error(error.message);\n        this.socket.end();\n        reject(new Error(`Connection error: ${error.message}`));\n      });\n    });\n  }\n  createConnection(options) {\n    return new Socket(options);\n  }\n  parseHostAndPort(lambdaHttpEntrypoint) {\n    try {\n      const parts = lambdaHttpEntrypoint.split(\":\");\n      if (parts.length !== 2) {\n        throw new Error();\n      }\n      const [host, portStr] = parts;\n      if (!host) {\n        throw new Error();\n      }\n      const port = parseInt(portStr, 10);\n      if (isNaN(port) || port < 1 || port > 65535) {\n        throw new Error();\n      }\n      return {\n        host,\n        port\n      };\n    } catch {\n      throw new Error(\"could not read lambda http entrypoint\");\n    }\n  }\n  getSocket() {\n    return this.socket;\n  }\n};\n\n// src/runtime.ts\nvar Runtime = class {\n  codeLoader;\n  portChecker;\n  shimClient;\n  logger;\n  constructor(codeLoader, portChecker, shimClient, logger) {\n    this.codeLoader = codeLoader;\n    this.portChecker = portChecker;\n    this.shimClient = shimClient;\n    this.logger = logger;\n  }\n  async start() {\n    try {\n      await this.codeLoader.load();\n    } catch (error) {\n      this.logger.error(`error while loading customer code: ${error}`);\n      await this.shimClient.initError(\"Application.InitCodeError\" /* ApplicationInitCodeError */);\n      process.exit(100 /* ApplicationInitCodeError */);\n    }\n    try {\n      await this.portChecker.wait();\n    } catch (error) {\n      this.logger.error(`error while waiting for the port: ${error}`);\n      await this.shimClient.initError(\"Application.TimeoutListenError\" /* ApplicationTimeoutListenError */);\n      process.exit(101 /* ApplicationTimeoutListenError */);\n    }\n    try {\n      await this.shimClient.ready();\n    } catch (error) {\n      this.logger.error(`error while calling /ready: ${error}`);\n      await this.shimClient.initError(\"Runtime.InternalError\" /* RuntimeInternalError */);\n      process.exit(103 /* RuntimeReadyInternalError */);\n    }\n  }\n};\n\n// src/consolepatcher/consolePatcher.ts\nimport { format } from \"util\";\nvar ConsolePatcher = class {\n  originalConsole;\n  logLevelPriority;\n  invokeStore;\n  constructor(invokeStore) {\n    this.invokeStore = invokeStore;\n    this.logLevelPriority = {\n      TRACE: 0,\n      DEBUG: 1,\n      INFO: 2,\n      WARN: 3,\n      ERROR: 4,\n      FATAL: 5\n    };\n    this.originalConsole = {\n      trace: console.trace,\n      debug: console.debug,\n      info: console.info,\n      log: console.log,\n      warn: console.warn,\n      error: console.error\n    };\n    this.patchConsole();\n  }\n  serializeError(error) {\n    return {\n      errorType: error.name ?? \"UnknownError\",\n      errorMessage: error.message,\n      stackTrace: typeof error.stack === \"string\" ? error.stack?.split(\"\\n\") : error.stack,\n      // copies all other custom properties from the error object\n      ...Object.fromEntries(\n        Object.entries(error).filter(([key]) => ![\"name\", \"message\", \"stack\"].includes(key))\n      )\n    };\n  }\n  jsonErrorReplacer = (_key, value) => {\n    if (value instanceof Error) {\n      return this.serializeError(value);\n    }\n    return value;\n  };\n  formatErrorMessage(messages) {\n    for (const message of messages) {\n      if (message instanceof Error) {\n        return this.serializeError(message);\n      }\n    }\n    return void 0;\n  }\n  formatJsonMessage(messages) {\n    if (messages.length === 0) {\n      return \"\";\n    }\n    if (messages.length === 1) {\n      const message = messages[0];\n      try {\n        JSON.stringify(message, this.jsonErrorReplacer);\n        return message;\n      } catch (_err) {\n      }\n    }\n    return format(...messages);\n  }\n  createLogEntry = (level, message, ...params) => {\n    const now = (/* @__PURE__ */ new Date()).toISOString();\n    const requestId = this.invokeStore.getRequestId();\n    const messages = [message, ...params];\n    let logEntry = {\n      timestamp: now,\n      level,\n      message: this.formatJsonMessage(messages),\n      requestId: requestId !== \"-\" ? requestId : void 0,\n      region: process.env[\"AWS_REGION\"]\n    };\n    const logError = this.formatErrorMessage(messages);\n    if (logError) {\n      if (messages.length <= 1) {\n        logEntry.message = logError;\n      } else {\n        logEntry = {\n          ...logEntry,\n          ...logError\n        };\n      }\n    }\n    return logEntry;\n  };\n  patchConsole() {\n    let awsLambdaLogLevel = process.env[\"AWS_LAMBDA_LOG_LEVEL\"]?.toUpperCase();\n    if (!awsLambdaLogLevel || !Object.keys(this.logLevelPriority).includes(awsLambdaLogLevel)) {\n      awsLambdaLogLevel = \"TRACE\";\n    }\n    if (awsLambdaLogLevel === \"FATAL\") {\n      awsLambdaLogLevel = \"ERROR\";\n    }\n    const awsLambdaLogLevelPriority = this.logLevelPriority[awsLambdaLogLevel];\n    console.trace = (message, ...optionalParams) => {\n      if (this.logLevelPriority.TRACE < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"TRACE\", message, ...optionalParams);\n      this.originalConsole.trace(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n    console.debug = (message, ...optionalParams) => {\n      if (this.logLevelPriority.DEBUG < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"DEBUG\", message, ...optionalParams);\n      this.originalConsole.debug(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n    console.info = (message, ...optionalParams) => {\n      if (this.logLevelPriority.INFO < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"INFO\", message, ...optionalParams);\n      this.originalConsole.info(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n    console.log = (message, ...optionalParams) => {\n      if (this.logLevelPriority.INFO < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"INFO\", message, ...optionalParams);\n      this.originalConsole.log(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n    console.warn = (message, ...optionalParams) => {\n      if (this.logLevelPriority.WARN < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"WARN\", message, ...optionalParams);\n      this.originalConsole.warn(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n    console.error = (message, ...optionalParams) => {\n      if (this.logLevelPriority.ERROR < awsLambdaLogLevelPriority) {\n        return;\n      }\n      const logEntry = this.createLogEntry(\"ERROR\", message, ...optionalParams);\n      this.originalConsole.error(JSON.stringify(logEntry, this.jsonErrorReplacer));\n    };\n  }\n};\n\n// src/httpinterceptor/httpInterceptor.ts\nimport http from \"http\";\n\n// node_modules/@aws/lambda-invoke-store/dist-es/invoke-store.js\nvar PROTECTED_KEYS = {\n  REQUEST_ID: Symbol.for(\"_AWS_LAMBDA_REQUEST_ID\"),\n  X_RAY_TRACE_ID: Symbol.for(\"_AWS_LAMBDA_X_RAY_TRACE_ID\"),\n  TENANT_ID: Symbol.for(\"_AWS_LAMBDA_TENANT_ID\")\n};\nvar NO_GLOBAL_AWS_LAMBDA = [\"true\", \"1\"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? \"\");\nif (!NO_GLOBAL_AWS_LAMBDA) {\n  globalThis.awslambda = globalThis.awslambda || {};\n}\nvar InvokeStoreBase = class {\n  static PROTECTED_KEYS = PROTECTED_KEYS;\n  isProtectedKey(key) {\n    return Object.values(PROTECTED_KEYS).includes(key);\n  }\n  getRequestId() {\n    return this.get(PROTECTED_KEYS.REQUEST_ID) ?? \"-\";\n  }\n  getXRayTraceId() {\n    return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);\n  }\n  getTenantId() {\n    return this.get(PROTECTED_KEYS.TENANT_ID);\n  }\n};\nvar InvokeStoreSingle = class extends InvokeStoreBase {\n  currentContext;\n  getContext() {\n    return this.currentContext;\n  }\n  hasContext() {\n    return this.currentContext !== void 0;\n  }\n  get(key) {\n    return this.currentContext?.[key];\n  }\n  set(key, value) {\n    if (this.isProtectedKey(key)) {\n      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);\n    }\n    this.currentContext = this.currentContext || {};\n    this.currentContext[key] = value;\n  }\n  run(context, fn) {\n    this.currentContext = context;\n    return fn();\n  }\n};\nvar InvokeStoreMulti = class _InvokeStoreMulti extends InvokeStoreBase {\n  als;\n  static async create() {\n    const instance = new _InvokeStoreMulti();\n    const asyncHooks = await import(\"node:async_hooks\");\n    instance.als = new asyncHooks.AsyncLocalStorage();\n    return instance;\n  }\n  getContext() {\n    return this.als.getStore();\n  }\n  hasContext() {\n    return this.als.getStore() !== void 0;\n  }\n  get(key) {\n    return this.als.getStore()?.[key];\n  }\n  set(key, value) {\n    if (this.isProtectedKey(key)) {\n      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);\n    }\n    const store = this.als.getStore();\n    if (!store) {\n      throw new Error(\"No context available\");\n    }\n    store[key] = value;\n  }\n  run(context, fn) {\n    return this.als.run(context, fn);\n  }\n};\nvar InvokeStore;\n(function(InvokeStore2) {\n  let instance = null;\n  async function getInstanceAsync(forceInvokeStoreMulti) {\n    if (!instance) {\n      instance = (async () => {\n        const isMulti = forceInvokeStoreMulti === true || \"AWS_LAMBDA_MAX_CONCURRENCY\" in process.env;\n        const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle();\n        if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {\n          return globalThis.awslambda.InvokeStore;\n        } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {\n          globalThis.awslambda.InvokeStore = newInstance;\n          return newInstance;\n        } else {\n          return newInstance;\n        }\n      })();\n    }\n    return instance;\n  }\n  InvokeStore2.getInstanceAsync = getInstanceAsync;\n  InvokeStore2._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === \"1\" ? {\n    reset: () => {\n      instance = null;\n      if (globalThis.awslambda?.InvokeStore) {\n        delete globalThis.awslambda.InvokeStore;\n      }\n      globalThis.awslambda = { InvokeStore: void 0 };\n    }\n  } : void 0;\n})(InvokeStore || (InvokeStore = {}));\n\n// src/httpinterceptor/httpInterceptor.ts\nvar REQUEST_ID_HEADER = \"lambda-web-request-id\";\nasync function patchHttpInterception() {\n  const invokeStore = await InvokeStore.getInstanceAsync(true);\n  const originalHttpEmit = http.Server.prototype.emit;\n  http.Server.prototype.emit = function(event, ...args) {\n    if (event === \"request\") {\n      const req = args[0];\n      const context = {\n        [InvokeStoreBase.PROTECTED_KEYS.REQUEST_ID]: req.headers[REQUEST_ID_HEADER]\n      };\n      return invokeStore.run(context, () => originalHttpEmit.call(this, event, ...args));\n    }\n    return originalHttpEmit.call(this, event, ...args);\n  };\n}\n\n// src/shimclient/shimClient.ts\nimport { request } from \"http\";\nvar RUNTIME_API_REQUIRED_ERROR = \"runtimeApi must be defined\";\nvar RUNTIME_API_FORMAT_ERROR = \"runtimeApi must be in format host:port\";\nvar RUNTIME_API_PORT_ERROR = \"runtimeApi port must be a valid number between 1 and 65535\";\nvar ShimClient = class {\n  host;\n  port;\n  logger;\n  version = \"2025-09-01\";\n  constructor(runtimeApi, logger) {\n    this.logger = logger;\n    if (!runtimeApi) {\n      this.logger.error(RUNTIME_API_REQUIRED_ERROR);\n      throw new Error(RUNTIME_API_REQUIRED_ERROR);\n    }\n    const parts = runtimeApi.split(\":\");\n    if (parts.length !== 2) {\n      this.logger.error(RUNTIME_API_FORMAT_ERROR);\n      throw new Error(RUNTIME_API_FORMAT_ERROR);\n    }\n    const [host, portStr] = parts;\n    const port = parseInt(portStr, 10);\n    if (isNaN(port) || port < 1 || port > 65535) {\n      this.logger.error(RUNTIME_API_PORT_ERROR);\n      throw new Error(RUNTIME_API_PORT_ERROR);\n    }\n    this.host = host;\n    this.port = port;\n    this.logger.debug(`shim client is built, runtime api = ${runtimeApi}`);\n  }\n  async post(path, headers = {}) {\n    return new Promise((resolve, reject) => {\n      const req = request(\n        {\n          host: this.host,\n          port: this.port,\n          path,\n          method: \"POST\",\n          headers: {\n            [\"Content-Type\" /* ContentType */]: \"application/json\" /* ApplicationJson */,\n            \"Content-Length\": \"2\",\n            ...headers\n          }\n        },\n        (res) => {\n          let data = \"\";\n          res.on(\"data\", (chunk) => data += chunk);\n          res.on(\"end\", () => {\n            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {\n              reject(new Error(`HTTP ${res.statusCode}: ${data}`));\n            } else {\n              resolve(data);\n            }\n          });\n        }\n      );\n      req.on(\"error\", reject);\n      req.write(\"{}\");\n      req.end();\n    });\n  }\n  async load() {\n    const response = await this.post(`/${this.version}/load`);\n    return response ? JSON.parse(response) : {};\n  }\n  async ready() {\n    await this.post(`/${this.version}/ready`);\n  }\n  async initError(enumError) {\n    await this.post(`/${this.version}/init/error`, {\n      [\"Lambda-Error-Type\" /* LambdaErrorType */]: enumError.toString()\n    });\n  }\n};\n\n// src/index.ts\nvar DEFAULT_ENTRYPOINT = \"index.js\";\nvar CODE_LOADING_TIMEOUT = 1e3;\nvar TASK_ROOT = \"/var/task\";\nvar AWS_LAMBDA_RUNTIME_API = \"AWS_LAMBDA_RUNTIME_API\";\nvar AWS_LAMBDA_BETA_DEBUG = \"AWS_LAMBDA_BETA_DEBUG\";\nvar AWS_LAMBDA_HTTP_ENDPOINT = \"AWS_LAMBDA_HTTP_ENDPOINT\";\nvar AWS_LAMBDA_ENTRYPOINT = \"AWS_LAMBDA_ENTRYPOINT\";\nvar debugLogger = new Logger(process.env[AWS_LAMBDA_BETA_DEBUG]);\nfunction parseLoadResponseAppConfig(loadResponse) {\n  const appConfig = {};\n  for (const envVar of loadResponse.applicationConfiguration ?? []) {\n    const index = envVar.indexOf(\"=\");\n    if (index !== -1) {\n      const key = envVar.substring(0, index);\n      const value = envVar.substring(index + 1);\n      appConfig[key] = value;\n    }\n  }\n  return appConfig;\n}\ntry {\n  const shimClient = new ShimClient(process.env[AWS_LAMBDA_RUNTIME_API], debugLogger);\n  try {\n    const loadResponse = await shimClient.load();\n    Object.assign(process.env, parseLoadResponseAppConfig(loadResponse));\n  } catch (error) {\n    debugLogger.error(`error while calling /load: ${error}`);\n    await shimClient.initError(\"Runtime.InternalError\" /* RuntimeInternalError */);\n    process.exit(102 /* RuntimeLoadInternalError */);\n  }\n  const invokeStore = await InvokeStore.getInstanceAsync(true);\n  new ConsolePatcher(invokeStore);\n  await patchHttpInterception();\n  const codeLoaderConfig = {\n    lambdaHttpEndpointEnvVariableName: AWS_LAMBDA_HTTP_ENDPOINT,\n    defaultEntrypoint: DEFAULT_ENTRYPOINT,\n    customerOverrideEntrypoint: process.env[AWS_LAMBDA_ENTRYPOINT],\n    timeout: CODE_LOADING_TIMEOUT,\n    taskRoot: TASK_ROOT\n  };\n  const codeLoader = new CodeLoader(codeLoaderConfig, debugLogger);\n  const portChecker = new PortChecker(codeLoader.getHttpEntrypoint(), debugLogger);\n  const runtime = new Runtime(codeLoader, portChecker, shimClient, debugLogger);\n  await runtime.start();\n} catch (error) {\n  debugLogger.error(`could not start the runtime: error = ${error}`);\n  process.exit(104 /* RuntimeInternalError */);\n}\n","error":""}