serverless-offline 9.2.6 → 10.0.0

package/README.md

@@ -121,7 +121,6 @@ All CLI options are optional:
 --dockerNetwork             The network that the Docker container will connect to
 --dockerReadOnly            Marks if the docker code layer should be read only. Default: true
 --enforceSecureCookies      Enforce secure cookies
---hideStackTraces           Hide the stack trace on lambda failure. Default: false
 --host                  -o  Host name to listen on. Default: localhost
 --httpPort                  Http port to listen on. Default: 3000
 --httpsProtocol         -H  To enable HTTPS, specify directory (relative to your cwd, typically your project dir) for both cert.pem and key.pem files
@@ -134,10 +133,9 @@ All CLI options are optional:
 --noStripTrailingSlashInUrl Don't strip trailing slash from http routes.
 --noTimeout             -t  Disables the timeout feature.
 --prefix                -p  Adds a prefix to every path, to send your requests to http://localhost:3000/[prefix]/[your_path] instead. Default: ''
---printOutput               Turns on logging of your lambda outputs in the terminal.
 --reloadHandler             Reloads handler with each request.
 --resourceRoutes            Turns on loading of your HTTP proxy settings from serverless.yml
---useChildProcesses         [This option is deprecated] Run handlers in a child process.
+--terminateIdleLambdaTime   Number of seconds until an idle function is eligible for termination.
 --useDocker                 Run handlers in a docker container.
 --useInProcess              Run handlers in the same process as 'serverless-offline'.
 --webSocketHardTimeout      Set WebSocket hard timeout in seconds to reproduce AWS limits (https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html#apigateway-execution-service-websocket-limits-table). Default: 7200 (2 hours)
@@ -188,15 +186,6 @@ Lambda handlers for the `node.js` runtime can run in different execution modes w
 - global state is being shared across lambda handlers as well as with `serverless` and `serverless-offline`
 - easy debugging
 
-#### child-processes (this option is deprecated, please use the default worker-threads instead)
-
-- handlers run in a separate node.js instance
-- memory is not being shared between handlers, memory consumption is therefore higher
-- memory is being released when handlers reload or after usage
-- environment (process.env) is not being shared across handlers
-- global state is not being shared across handlers
-- debugging more complicated
-
 #### docker
 
 - handlers run in a docker container
@@ -215,10 +204,10 @@ the Lambda handler process is running in a child process.
 To use `Lambda.invoke` you need to set the lambda endpoint to the `serverless-offline` endpoint:
 
 ```js
-const { env } = require('node:process')
-const { Lambda } = require('aws-sdk')
+import { env } from 'node:process'
+import aws from 'aws-sdk'
 
-const lambda = new Lambda({
+const lambda = new aws.Lambda({
   apiVersion: '2015-03-31',
   // endpoint needs to be set only if it deviates from the default
   endpoint: env.IS_OFFLINE
@@ -230,17 +219,17 @@ const lambda = new Lambda({
 All your lambdas can then be invoked in a handler using
 
 ```js
-const { Buffer } = require('node:buffer')
-const { Lambda } = require('aws-sdk')
+import { Buffer } from 'node:buffer'
+import aws from 'aws-sdk'
 
 const { stringify } = JSON
 
-const lambda = new Lambda({
+const lambda = new aws.Lambda({
   apiVersion: '2015-03-31',
   endpoint: 'http://localhost:3002',
 })
 
-exports.handler = async function () {
+export async function handler() {
   const clientContextData = stringify({ foo: 'foo' })
 
   const params = {
@@ -623,9 +612,9 @@ Usage in order to send messages back to clients:
 Or,
 
 ```js
-const { ApiGatewayManagementApi } = require('aws-sdk')
+import aws from 'aws-sdk'
 
-const apiGatewayManagementApi = new ApiGatewayManagementApi({
+const apiGatewayManagementApi = new aws.ApiGatewayManagementApi({
   apiVersion: '2018-11-29',
   endpoint: 'http://localhost:3001',
 });

package/package.json

@@ -1,11 +1,13 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.2.6",
+  "version": "10.0.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
-  "main": "./src/index.js",
-  "exports": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./lambda": "./src/lambda/index.js"
+  },
   "type": "module",
   "scripts": {
     "format": "eslint . --fix",
@@ -189,18 +191,18 @@
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
     "@serverless/utils": "^6.7.0",
-    "aws-sdk": "^2.1195.0",
+    "aws-sdk": "^2.1209.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
     "fs-extra": "^10.1.0",
     "java-invoke-local": "0.0.6",
     "js-string-escape": "^1.0.1",
-    "jsonpath-plus": "^7.0.0",
+    "jsonpath-plus": "^7.2.0",
     "jsonschema": "^1.4.1",
     "jsonwebtoken": "^8.5.1",
     "jszip": "^3.10.1",
-    "luxon": "^3.0.1",
+    "luxon": "^3.0.3",
     "node-fetch": "^3.2.10",
     "node-schedule": "^2.1.0",
     "object.hasown": "^1.1.1",
@@ -211,7 +213,7 @@
   },
   "devDependencies": {
     "archiver": "^5.3.1",
-    "eslint": "^8.22.0",
+    "eslint": "^8.23.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",

package/src/ServerlessOffline.js

@@ -6,7 +6,7 @@ import {
   defaultOptions,
   SERVER_SHUTDOWN_TIMEOUT,
 } from './config/index.js'
-import { gray, orange } from './config/colors.js'
+import { gray } from './config/colors.js'
 
 export default class ServerlessOffline {
   #cliOptions = null
@@ -83,15 +83,6 @@ export default class ServerlessOffline {
     }
 
     await Promise.all(eventModules)
-
-    if (this.#options.useChildProcesses) {
-      log.notice()
-      log.warning(
-        orange(`'--useChildProcesses' is deprecated and will be removed in the next major version. Worker threads, the current default, should provide the same if not an even better developer experience.
-If you are experiencing any issues please let us know: https://github.com/dherault/serverless-offline/issues`),
-      )
-      log.notice()
-    }
   }
 
   async #ready() {

package/src/config/commandOptions.js

@@ -54,14 +54,6 @@ export default {
     type: 'boolean',
     usage: 'Enforce secure cookies',
   },
-  functionCleanupIdleTimeSeconds: {
-    type: 'string',
-    usage: 'Number of seconds until an idle function is eligible for cleanup',
-  },
-  hideStackTraces: {
-    type: 'boolean',
-    usage: 'Hide the stack trace on lambda failure. Default: false',
-  },
   host: {
     shortcut: 'o',
     type: 'string',
@@ -118,10 +110,6 @@ export default {
     usage:
       'Adds a prefix to every path, to send your requests to http://localhost:3000/prefix/[your_path] instead.',
   },
-  printOutput: {
-    type: 'boolean',
-    usage: 'Outputs your lambda response to the terminal.',
-  },
   reloadHandler: {
     type: 'boolean',
     usage: 'Reloads handler with each request.',
@@ -130,10 +118,10 @@ export default {
     type: 'boolean',
     usage: 'Turns on loading of your HTTP proxy settings from serverless.yml.',
   },
-  useChildProcesses: {
-    type: 'boolean',
+  terminateIdleLambdaTime: {
+    type: 'string',
     usage:
-      '[This option is deprecated] Use separate node process to run handlers.',
+      'Number of seconds until an idle function is eligible for termination.',
   },
   useDocker: {
     type: 'boolean',

package/src/config/defaultOptions.js

@@ -13,8 +13,6 @@ export default {
   dockerNetwork: null,
   dockerReadOnly: true,
   enforceSecureCookies: false,
-  functionCleanupIdleTimeSeconds: 60,
-  hideStackTraces: false,
   host: 'localhost',
   httpPort: 3000,
   httpsProtocol: null,
@@ -26,10 +24,9 @@ export default {
   noStripTrailingSlashInUrl: false,
   noTimeout: false,
   prefix: '',
-  printOutput: false,
   reloadHandler: false,
   resourceRoutes: false,
-  useChildProcesses: false,
+  terminateIdleLambdaTime: 60,
   useDocker: false,
   useInProcess: false,
   webSocketHardTimeout: 7200,

package/src/config/supportedRuntimes.js

@@ -2,10 +2,10 @@
 // https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
 
 // .NET CORE
-export const supportedDotnetcore = new Set([
-  // 'dotnet6',
-  // 'dotnetcore3.1',
-])
+// export const supportedDotnetcore = new Set([
+// 'dotnet6',
+// 'dotnetcore3.1',
+// ])
 
 // GO
 export const supportedGo = new Set(['go1.x'])
@@ -37,7 +37,7 @@ export const supportedRuby = new Set(['ruby2.7'])
 // deprecated runtimes
 // https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html
 export const supportedRuntimes = new Set([
-  ...supportedDotnetcore,
+  // ...supportedDotnetcore,
   ...supportedGo,
   ...supportedJava,
   ...supportedNodejs,
@@ -45,3 +45,9 @@ export const supportedRuntimes = new Set([
   ...supportedPython,
   ...supportedRuby,
 ])
+
+export const unsupportedDockerRuntimes = new Set([
+  'nodejs14.x',
+  'nodejs16.x',
+  'python3.9',
+])

package/src/events/http/HttpServer.js

@@ -580,21 +580,8 @@ export default class HttpServer {
 
       // Failure handling
       let errorStatusCode = '502'
-      if (err) {
-        // Since the --useChildProcesses option loads the handler in
-        // a separate process and serverless-offline communicates with it
-        // over IPC, we are unable to catch JavaScript unhandledException errors
-        // when the handler code contains bad JavaScript. Instead, we "catch"
-        // it here and reply in the same way that we would have above when
-        // we lazy-load the non-IPC handler function.
-        if (this.#options.useChildProcesses && err.ipcException) {
-          return this.#reply502(
-            response,
-            `Error while loading ${functionKey}`,
-            err,
-          )
-        }
 
+      if (err) {
         const errorMessage = (err.message || err).toString()
 
         const found = errorMessage.match(/\[(\d{3})]/)
@@ -614,10 +601,6 @@ export default class HttpServer {
 
         log.error(errorMessage)
 
-        if (!this.#options.hideStackTraces) {
-          log.error(err.stack)
-        }
-
         for (const [key, value] of entries(endpoint.responses)) {
           if (
             key !== 'default' &&
@@ -894,20 +877,6 @@ export default class HttpServer {
         }
       }
 
-      let whatToLog = result
-
-      try {
-        whatToLog = stringify(result)
-      } catch {
-        // nothing
-      } finally {
-        if (this.#options.printOutput) {
-          log.notice(
-            err ? `Replying ${statusCode}` : `[${statusCode}] ${whatToLog}`,
-          )
-        }
-      }
-
       return response
     }
   }

package/src/lambda/LambdaFunction.js

@@ -2,6 +2,7 @@ import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, join, resolve } from 'node:path'
 import process from 'node:process'
 import { performance } from 'node:perf_hooks'
+import { promisify } from 'node:util'
 import { log } from '@serverless/utils/log.js'
 import { emptyDir, ensureDir, remove } from 'fs-extra'
 import jszip from 'jszip'
@@ -18,6 +19,8 @@ import { createUniqueId } from '../utils/index.js'
 const { ceil } = Math
 const { entries, fromEntries } = Object
 
+const setTimeoutPromise = promisify(setTimeout)
+
 export default class LambdaFunction {
   #artifact = null
 
@@ -37,6 +40,8 @@ export default class LambdaFunction {
 
   #handler = null
 
+  #handlerRunDone = false
+
   #handlerRunner = null
 
   #idleTimeStarted = null
@@ -49,13 +54,15 @@ export default class LambdaFunction {
 
   #memorySize = null
 
+  #noTimeout = null
+
   #region = null
 
   #runtime = null
 
-  #timeout = null
+  #status = 'IDLE' // can be 'BUSY' or 'IDLE'
 
-  status = 'IDLE' // can be 'BUSY' or 'IDLE'
+  #timeout = null
 
   constructor(functionKey, functionDefinition, serverless, options) {
     const {
@@ -71,28 +78,28 @@ export default class LambdaFunction {
 
     const { handler, name, package: functionPackage = {} } = functionDefinition
 
-    const memorySize =
+    // this._executionTimeout = null
+    this.#functionKey = functionKey
+    this.#functionName = name
+    this.#handler = handler
+
+    this.#memorySize =
       functionDefinition.memorySize ||
       provider.memorySize ||
       DEFAULT_LAMBDA_MEMORY_SIZE
 
-    const runtime =
+    this.#noTimeout = options.noTimeout
+
+    this.#region = provider.region
+
+    this.#runtime =
       functionDefinition.runtime || provider.runtime || DEFAULT_LAMBDA_RUNTIME
 
-    const timeout =
+    this.#timeout =
       (functionDefinition.timeout ||
         provider.timeout ||
         DEFAULT_LAMBDA_TIMEOUT) * 1000
 
-    // this._executionTimeout = null
-    this.#functionKey = functionKey
-    this.#functionName = name
-    this.#handler = handler
-    this.#memorySize = memorySize
-    this.#region = provider.region
-    this.#runtime = runtime
-    this.#timeout = timeout
-
     this.#verifySupportedRuntime()
 
     const env = {
@@ -141,17 +148,17 @@ export default class LambdaFunction {
       handler,
       layers: functionDefinition.layers || [],
       provider,
-      runtime,
+      runtime: this.#runtime,
       serverlessPath,
       servicePackage: servicePackage.artifact
         ? resolve(servicepath, servicePackage.artifact)
         : undefined,
       servicePath: servicepath,
-      timeout,
+      timeout: this.#timeout,
     }
 
     this.#handlerRunner = new HandlerRunner(funOptions, options, env)
-    this.#lambdaContext = new LambdaContext(name, memorySize)
+    this.#lambdaContext = new LambdaContext(name, this.#memorySize)
   }
 
   #startExecutionTimer() {
@@ -259,16 +266,33 @@ export default class LambdaFunction {
     this.#initialized = true
   }
 
-  get idleTimeInMinutes() {
-    return (performance.now() - this.#idleTimeStarted) / 1000 / 60
+  get idleTimeInMillis() {
+    return performance.now() - this.#idleTimeStarted
   }
 
   get functionName() {
     return this.#functionName
   }
 
+  get status() {
+    return this.#status
+  }
+
+  async #timeoutAndTerminate() {
+    await setTimeoutPromise(this.#timeout)
+
+    // if the handler has finished before the timeout don't terminate
+    if (this.#handlerRunDone) {
+      return
+    }
+
+    await this.#handlerRunner.cleanup()
+
+    throw new Error('Lambda timeout.')
+  }
+
   async runHandler() {
-    this.status = 'BUSY'
+    this.#status = 'BUSY'
 
     if (!this.#initialized) {
       await this.#initialize()
@@ -283,7 +307,14 @@ export default class LambdaFunction {
 
     this.#startExecutionTimer()
 
-    const result = await this.#handlerRunner.run(this.#event, context)
+    this.#handlerRunDone = false
+
+    const result = await Promise.race([
+      this.#handlerRunner.run(this.#event, context),
+      ...(this.#noTimeout ? [] : [this.#timeoutAndTerminate()]),
+    ])
+
+    this.#handlerRunDone = true
 
     this.#stopExecutionTimer()
 
@@ -298,7 +329,7 @@ export default class LambdaFunction {
       )
     }
 
-    this.status = 'IDLE'
+    this.#status = 'IDLE'
     this.#startIdleTimer()
 
     return result

package/src/lambda/LambdaFunctionPool.js

@@ -20,19 +20,20 @@ export default class LambdaFunctionPool {
   }
 
   #startCleanTimer() {
+    const functionCleanupIdleTimeInMillis =
+      this.#options.terminateIdleLambdaTime * 1000
+
     // NOTE: don't use setInterval, as it would schedule always a new run,
     // regardless of function processing time and e.g. user action (debugging)
     this.#timerRef = setTimeout(() => {
       // console.log('run cleanup')
       this.#pool.forEach((lambdaFunctions) => {
         lambdaFunctions.forEach((lambdaFunction) => {
-          const { idleTimeInMinutes, status } = lambdaFunction
-          // console.log(idleTimeInMinutes, status)
+          const { idleTimeInMillis, status } = lambdaFunction
 
           if (
             status === 'IDLE' &&
-            idleTimeInMinutes >=
-              this.#options.functionCleanupIdleTimeSeconds / 60
+            idleTimeInMillis >= functionCleanupIdleTimeInMillis
           ) {
             // console.log(`removed Lambda Function ${lambdaFunction.functionName}`)
             lambdaFunction.cleanup()
@@ -43,7 +44,7 @@ export default class LambdaFunctionPool {
 
       // schedule new timer
       this.#startCleanTimer()
-    }, (this.#options.functionCleanupIdleTimeSeconds * 1000) / 2)
+    }, functionCleanupIdleTimeInMillis)
   }
 
   #cleanupPool() {

package/src/lambda/handler-runner/HandlerRunner.js

@@ -5,6 +5,7 @@ import {
   supportedNodejs,
   supportedPython,
   supportedRuby,
+  unsupportedDockerRuntimes,
 } from '../../config/index.js'
 
 export default class HandlerRunner {
@@ -23,25 +24,19 @@ export default class HandlerRunner {
   }
 
   async #loadRunner() {
-    const { useChildProcesses, useDocker, useInProcess } = this.#options
+    const { useDocker, useInProcess } = this.#options
     const { handler, runtime } = this.#funOptions
 
     log.debug(`Loading handler... (${handler})`)
 
     if (useDocker) {
-      // https://github.com/lambci/docker-lambda/issues/329
-      if (runtime === 'nodejs14.x') {
+      if (unsupportedDockerRuntimes.has(runtime)) {
         log.warning(
-          '"nodejs14.x" runtime is not supported with docker. See https://github.com/lambci/docker-lambda/issues/329',
+          `"${runtime}" runtime is not supported with docker. See https://github.com/lambci/docker-lambda`,
         )
         throw new Error('Unsupported runtime')
       }
 
-      if (runtime === 'python3.9') {
-        log.warning('"python3.9" runtime is not supported with docker.')
-        throw new Error('Unsupported runtime')
-      }
-
       const dockerOptions = {
         host: this.#options.dockerHost,
         hostServicePath: this.#options.dockerHostServicePath,
@@ -56,14 +51,6 @@ export default class HandlerRunner {
     }
 
     if (supportedNodejs.has(runtime)) {
-      if (useChildProcesses) {
-        const { default: ChildProcessRunner } = await import(
-          './child-process-runner/index.js'
-        )
-
-        return new ChildProcessRunner(this.#funOptions, this.#env)
-      }
-
       if (useInProcess) {
         const { default: InProcessRunner } = await import(
           './in-process-runner/index.js'

package/src/lambda/handler-runner/in-process-runner/InProcessRunner.js

@@ -86,11 +86,6 @@ export default class InProcessRunner {
     // no try/catch so that errors bubble up and are logged with root stack traces
     const result = handler(event, lambdaContext, callback)
 
-    // // not a Promise, which is not supported by aws
-    // if (result == null || typeof result.then !== 'function') {
-    //   throw new Error(`Synchronous function execution is not supported.`)
-    // }
-
     const responses = [callbackWrapper]
 
     // Promise was returned

package/src/lambda/handler-runner/ruby-runner/RubyRunner.js

@@ -83,7 +83,7 @@ export default class RubyRunner {
 
     // console.log(input)
 
-    const ruby = execa(
+    const { stderr, stdout } = await execa(
       runtime,
       [
         resolve(__dirname, 'invoke.rb'),
@@ -97,10 +97,6 @@ export default class RubyRunner {
       },
     )
 
-    const result = await ruby
-
-    const { stderr, stdout } = result
-
     if (stderr) {
       // TODO
 

package/src/utils/index.js

@@ -1,7 +1,10 @@
+export { default as checkDockerDaemon } from './checkDockerDaemon.js'
+export { default as checkGoVersion } from './checkGoVersion.js'
 export { default as createApiKey } from './createApiKey.js'
 export { default as createUniqueId } from './createUniqueId.js'
 export { default as detectExecutable } from './detectExecutable.js'
 export { default as formatToClfTime } from './formatToClfTime.js'
+export { default as generateHapiPath } from './generateHapiPath.js'
 export { default as getHttpApiCorsConfig } from './getHttpApiCorsConfig.js'
 export { default as jsonPath } from './jsonPath.js'
 export { default as lowerCaseKeys } from './lowerCaseKeys.js'
@@ -10,9 +13,7 @@ export { default as parseMultiValueHeaders } from './parseMultiValueHeaders.js'
 export { default as parseMultiValueQueryStringParameters } from './parseMultiValueQueryStringParameters.js'
 export { default as parseQueryStringParameters } from './parseQueryStringParameters.js'
 export { default as splitHandlerPathAndName } from './splitHandlerPathAndName.js'
-export { default as checkDockerDaemon } from './checkDockerDaemon.js'
-export { default as checkGoVersion } from './checkGoVersion.js'
-export { default as generateHapiPath } from './generateHapiPath.js'
+
 // export { default as baseImage } from './baseImage.js'
 
 const { isArray } = Array

package/src/lambda/handler-runner/child-process-runner/ChildProcessRunner.js

@@ -1,75 +0,0 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { log } from '@serverless/utils/log.js'
-import { execaNode } from 'execa'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const childProcessHelperPath = resolve(__dirname, 'childProcessHelper.js')
-
-export default class ChildProcessRunner {
-  #codeDir = null
-
-  #env = null
-
-  #functionKey = null
-
-  #handler = null
-
-  #servicePath = null
-
-  #timeout = null
-
-  constructor(funOptions, env) {
-    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
-
-    this.#codeDir = codeDir
-    this.#env = env
-    this.#functionKey = functionKey
-    this.#handler = handler
-    this.#servicePath = servicePath
-    this.#timeout = timeout
-  }
-
-  // no-op
-  // () => void
-  cleanup() {}
-
-  async run(event, context) {
-    const childProcess = execaNode(
-      childProcessHelperPath,
-      [this.#functionKey, this.#handler, this.#servicePath, this.#codeDir],
-      {
-        env: this.#env,
-        stdio: 'inherit',
-      },
-    )
-
-    childProcess.send({
-      context,
-      event,
-      timeout: this.#timeout,
-    })
-
-    let result
-
-    try {
-      result = await new Promise((res, rej) => {
-        childProcess.on('message', (data) => {
-          if (data.error) {
-            rej(data.error)
-            return
-          }
-          res(data.result)
-        })
-      })
-    } catch (err) {
-      // TODO
-      log.error(err)
-      throw err
-    } finally {
-      childProcess.kill()
-    }
-
-    return result
-  }
-}

package/src/lambda/handler-runner/child-process-runner/childProcessHelper.js

@@ -1,45 +0,0 @@
-import process, { argv } from 'node:process'
-import InProcessRunner from '../in-process-runner/index.js'
-
-// TODO handle this:
-process.on('uncaughtException', (err) => {
-  const {
-    constructor: { name },
-    message,
-    stack,
-  } = err
-
-  process.send({
-    // process.send() can't serialize an Error object, so we help it out a bit
-    error: {
-      constructor: {
-        name,
-      },
-      message,
-      stack,
-    },
-  })
-})
-
-const [, , functionKey, handler, servicePath, codeDir] = argv
-
-process.on('message', async (messageData) => {
-  const { context, event, timeout } = messageData
-
-  // TODO we could probably cache this in the module scope?
-  const inProcessRunner = new InProcessRunner(
-    {
-      codeDir,
-      functionKey,
-      handler,
-      servicePath,
-      timeout,
-    },
-    process.env,
-  )
-
-  const result = await inProcessRunner.run(event, context)
-
-  // TODO check serializeability (contains function, symbol etc)
-  process.send({ result })
-})

package/src/lambda/handler-runner/child-process-runner/index.js

@@ -1 +0,0 @@
-export { default } from './ChildProcessRunner.js'