@platformatic/runtime 3.0.0-alpha.5 → 3.0.0-alpha.8

package/lib/runtime.js

@@ -1,97 +1,110 @@
-'use strict'
-
-const { ITC } = require('@platformatic/itc')
-const {
-  features,
-  ensureLoggableError,
+import {
+  deepmerge,
   ensureError,
+  ensureLoggableError,
+  executeInParallel,
   executeWithTimeout,
-  deepmerge,
-  parseMemorySize,
+  features,
+  kMetadata,
   kTimeout,
-  kMetadata
-} = require('@platformatic/foundation')
-const { once, EventEmitter } = require('node:events')
-const { existsSync } = require('node:fs')
-const { readFile } = require('node:fs/promises')
-const { STATUS_CODES } = require('node:http')
-const { join } = require('node:path')
-const { pathToFileURL } = require('node:url')
-const { setTimeout: sleep, setImmediate: immediate } = require('node:timers/promises')
-const { Worker } = require('node:worker_threads')
-const { Agent, interceptors: undiciInterceptors, request } = require('undici')
-const { createThreadInterceptor } = require('undici-thread-interceptor')
-const SonicBoom = require('sonic-boom')
-const { checkDependencies, topologicalSort } = require('./dependencies')
-const errors = require('./errors')
-const { abstractLogger, createLogger } = require('./logger')
-const { startManagementApi } = require('./management-api')
-const { startPrometheusServer } = require('./prom-server')
-const { startScheduler } = require('./scheduler')
-const { createSharedStore } = require('./shared-http-cache')
-const { getRuntimeTmpDir } = require('./utils')
-const { sendViaITC, waitEventFromITC } = require('./worker/itc')
-const { RoundRobinMap } = require('./worker/round-robin-map.js')
-const {
-  kId,
+  parseMemorySize
+} from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc'
+import fastify from 'fastify'
+import { EventEmitter, once } from 'node:events'
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { STATUS_CODES } from 'node:http'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { setImmediate as immediate, setTimeout as sleep } from 'node:timers/promises'
+import { pathToFileURL } from 'node:url'
+import { Worker } from 'node:worker_threads'
+import SonicBoom from 'sonic-boom'
+import { Agent, request, interceptors as undiciInterceptors } from 'undici'
+import { createThreadInterceptor } from 'undici-thread-interceptor'
+import {
+  ApplicationAlreadyStartedError,
+  ApplicationNotFoundError,
+  ApplicationNotStartedError,
+  ApplicationStartTimeoutError,
+  InvalidArgumentError,
+  MessagingError,
+  MissingEntrypointError,
+  RuntimeAbortedError,
+  RuntimeExitedError,
+  WorkerNotFoundError
+} from './errors.js'
+import { abstractLogger, createLogger } from './logger.js'
+import { startManagementApi } from './management-api.js'
+import { startPrometheusServer } from './prom-server.js'
+import { startScheduler } from './scheduler.js'
+import { createSharedStore } from './shared-http-cache.js'
+import { version } from './version.js'
+import { sendViaITC, waitEventFromITC } from './worker/itc.js'
+import { RoundRobinMap } from './worker/round-robin-map.js'
+import {
+  kApplicationId,
+  kConfig,
   kFullId,
-  kServiceId,
-  kWorkerId,
-  kITC,
   kHealthCheckTimer,
-  kConfig,
-  kWorkerStatus,
-  kStderrMarker,
+  kId,
+  kITC,
   kLastELU,
-  kWorkersBroadcast
-} = require('./worker/symbols')
-const fastify = require('fastify')
-
-const platformaticVersion = require('../package.json').version
-const kWorkerFile = join(__dirname, 'worker/main.js')
+  kStderrMarker,
+  kWorkerId,
+  kWorkersBroadcast,
+  kWorkerStatus
+} from './worker/symbols.js'
 
+const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
 const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
-const kForwardEvents = Symbol('plt.runtime.worker.forwardEvents')
 
 const MAX_LISTENERS_COUNT = 100
 const MAX_METRICS_QUEUE_LENGTH = 5 * 60 // 5 minutes in seconds
 const COLLECT_METRICS_TIMEOUT = 1000
 
+const MAX_CONCURRENCY = 5
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
 const MAX_WORKERS = 100
 
-const telemetryPath = require.resolve('@platformatic/telemetry')
-const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
+export class Runtime extends EventEmitter {
+  logger
+  error
 
-class Runtime extends EventEmitter {
+  #loggerDestination
+  #stdio
+
+  #status // starting, started, stopping, stopped, closed
   #root
   #config
   #env
   #context
+  #sharedContext
   #isProduction
-  #runtimeTmpDir
-  #servicesIds
+  #concurrency
   #entrypointId
   #url
-  #loggerDestination
+
   #metrics
   #metricsTimeout
-  #status // starting, started, stopping, stopped, closed
+
   #meshInterceptor
   #dispatcher
+
   #managementApi
   #prometheusServer
   #inspectorServer
+
+  #applicationsConfigsPatches
   #workers
   #workersBroadcastChannel
   #workerITCHandlers
   #restartingWorkers
+
   #sharedHttpCache
-  servicesConfigsPatches
   #scheduler
-  #stdio
-  #sharedContext
 
   constructor (config, context) {
     super()
@@ -102,19 +115,15 @@ class Runtime extends EventEmitter {
     this.#env = config[kMetadata].env
     this.#context = context ?? {}
     this.#isProduction = this.#context.isProduction ?? this.#context.production ?? false
-    this.#runtimeTmpDir = getRuntimeTmpDir(this.#root)
+    this.#concurrency = this.#context.concurrency ?? MAX_CONCURRENCY
     this.#workers = new RoundRobinMap()
-    this.#servicesIds = []
     this.#url = undefined
-    this.#meshInterceptor = createThreadInterceptor({
-      domain: '.plt.local',
-      timeout: this.#config.serviceTimeout
-    })
+    this.#meshInterceptor = createThreadInterceptor({ domain: '.plt.local', timeout: this.#config.applicationTimeout })
     this.logger = abstractLogger // This is replaced by the real logger in init() and eventually removed in close()
     this.#status = undefined
     this.#restartingWorkers = new Map()
     this.#sharedHttpCache = null
-    this.servicesConfigsPatches = new Map()
+    this.#applicationsConfigsPatches = new Map()
 
     if (!this.#config.logger.captureStdio) {
       this.#stdio = {
@@ -124,9 +133,9 @@ class Runtime extends EventEmitter {
     }
 
     this.#workerITCHandlers = {
-      getServiceMeta: this.getServiceMeta.bind(this),
-      listServices: () => this.#servicesIds,
-      getServices: this.getServices.bind(this),
+      getApplicationMeta: this.getApplicationMeta.bind(this),
+      listApplications: this.getApplicationsIds.bind(this),
+      getApplications: this.getApplications.bind(this),
       getWorkers: this.getWorkers.bind(this),
       getWorkerMessagingChannel: this.#getWorkerMessagingChannel.bind(this),
       getHttpCacheValue: this.#getHttpCacheValue.bind(this),
@@ -145,10 +154,6 @@ class Runtime extends EventEmitter {
     }
 
     const config = this.#config
-    const autoloadEnabled = config.autoload
-
-    // This cannot be transferred to worker threads
-    delete config.configManager
 
     if (config.managementApi) {
       this.#managementApi = await startManagementApi(this, this.#root)
@@ -163,19 +168,18 @@ class Runtime extends EventEmitter {
     this.logger = logger
     this.#loggerDestination = destination
 
-    this.#servicesIds = config.services.map(service => service.id)
     this.#createWorkersBroadcastChannel()
 
     const workersConfig = []
-    for (const service of config.services) {
-      const count = service.workers ?? this.#config.workers
-      if (count > 1 && service.entrypoint && !features.node.reusePort) {
+    for (const application of config.applications) {
+      const count = application.workers ?? this.#config.workers
+      if (count > 1 && application.entrypoint && !features.node.reusePort) {
         this.logger.warn(
-          `"${service.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${count}`
+          `"${application.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${count}`
         )
-        workersConfig.push({ id: service.id, workers: 1 })
+        workersConfig.push({ id: application.id, workers: 1 })
       } else {
-        workersConfig.push({ id: service.id, workers: count })
+        workersConfig.push({ id: application.id, workers: count })
       }
     }
 
@@ -189,64 +193,7 @@ class Runtime extends EventEmitter {
       this.#env['PLT_ENVIRONMENT'] = 'development'
     }
 
-    // Create all services, each in is own worker thread
-    for (const serviceConfig of config.services) {
-      // If there is no service path, check if the service was resolved
-      if (!serviceConfig.path) {
-        if (serviceConfig.url) {
-          // Try to backfill the path for external services
-          serviceConfig.path = join(this.#root, config.resolvedServicesBasePath, serviceConfig.id)
-
-          if (!existsSync(serviceConfig.path)) {
-            const executable = globalThis.platformatic?.executable ?? 'platformatic'
-            this.logger.error(
-              `The path for service "%s" does not exist. Please run "${executable} resolve" and try again.`,
-              serviceConfig.id
-            )
-
-            await this.closeAndThrow(new errors.RuntimeAbortedError())
-          }
-        } else {
-          this.logger.error(
-            'The service "%s" has no path defined. Please check your configuration and try again.',
-            serviceConfig.id
-          )
-
-          await this.closeAndThrow(new errors.RuntimeAbortedError())
-        }
-      }
-
-      await this.#setupService(serviceConfig)
-    }
-
-    try {
-      checkDependencies(config.services)
-
-      // Make sure the list exists before computing the dependencies, otherwise some services might not be stopped
-      if (autoloadEnabled) {
-        this.#workers = topologicalSort(this.#workers, config)
-      }
-
-      // Recompute the list of services after sorting
-      this.#servicesIds = config.services.map(service => service.id)
-
-      // When autoloading is disabled, add a warning if a service is defined before its dependencies
-      if (!autoloadEnabled) {
-        for (let i = 0; i < config.services.length; i++) {
-          const current = config.services[i]
-
-          for (const dep of current.dependencies ?? []) {
-            if (config.services.findIndex(s => s.id === dep.id) > i) {
-              this.logger.warn(
-                `Service "${current.id}" depends on service "${dep.id}", but it is defined and it will be started before it. Please check your configuration file.`
-              )
-            }
-          }
-        }
-      }
-    } catch (e) {
-      await this.closeAndThrow(e)
-    }
+    await this.#setupApplications()
 
     await this.#setDispatcher(config.undici)
 
@@ -263,17 +210,19 @@ class Runtime extends EventEmitter {
     }
 
     if (typeof this.#config.entrypoint === 'undefined') {
-      throw new errors.MissingEntrypointError()
+      throw new MissingEntrypointError()
     }
     this.#updateStatus('starting')
     this.#createWorkersBroadcastChannel()
 
-    // Important: do not use Promise.all here since it won't properly manage dependencies
     try {
-      for (const service of this.#servicesIds) {
-        await this.startService(service, silent)
+      const startInvocations = []
+      for (const application of this.getApplicationsIds()) {
+        startInvocations.push([application, silent])
       }
 
+      await executeInParallel(this.startApplication.bind(this), startInvocations, this.#concurrency)
+
       if (this.#config.inspectorOptions) {
         const { port } = this.#config.inspectorOptions
 
@@ -304,7 +253,7 @@ class Runtime extends EventEmitter {
 
         await server.listen({ port })
         this.logger.info(
-          'The inspector server is now listening for all services. Open `chrome://inspect` in Google Chrome to connect.'
+          'The inspector server is now listening for all applications. Open `chrome://inspect` in Google Chrome to connect.'
         )
         this.#inspectorServer = server
       }
@@ -339,19 +288,38 @@ class Runtime extends EventEmitter {
 
     // Stop the entrypoint first so that no new requests are accepted
     if (this.#entrypointId) {
-      await this.stopService(this.#entrypointId, silent)
+      await this.stopApplication(this.#entrypointId, silent)
+    }
+
+    const stopInvocations = []
+
+    const allApplications = await this.getApplications(true)
+
+    // Construct the reverse dependency graph
+    const dependents = {}
+    for (const application of allApplications.applications) {
+      for (const dependency of application.dependencies ?? []) {
+        let applicationDependents = dependents[dependency]
+        if (!applicationDependents) {
+          applicationDependents = new Set()
+          dependents[dependency] = applicationDependents
+        }
+
+        applicationDependents.add(application.id)
+      }
     }
 
-    // Stop services in reverse order to ensure services which depend on others are stopped first
-    for (const service of this.#servicesIds.reverse()) {
+    for (const application of this.getApplicationsIds()) {
       // The entrypoint has been stopped above
-      if (service === this.#entrypointId) {
+      if (application === this.#entrypointId) {
         continue
       }
 
-      await this.stopService(service, silent)
+      stopInvocations.push([application, silent, Array.from(dependents[application] ?? [])])
     }
 
+    await executeInParallel(this.stopApplication.bind(this), stopInvocations, this.#concurrency)
+
     await this.#meshInterceptor.close()
     this.#workersBroadcastChannel?.close()
 
@@ -370,16 +338,11 @@ class Runtime extends EventEmitter {
     return this.#url
   }
 
-  getRuntimeStatus () {
-    return this.#status
-  }
-
   async close (silent = false) {
-    this.#updateStatus('closing')
-
     clearInterval(this.#metricsTimeout)
 
     await this.stop(silent)
+    this.#updateStatus('closing')
 
     // The management API autocloses by itself via event in management-api.js.
     // This is needed to let management API stop endpoint to reply.
@@ -404,6 +367,7 @@ class Runtime extends EventEmitter {
 
   async closeAndThrow (error) {
     this.#updateStatus('errored', error)
+    this.error = error
 
     // Wait for the next tick so that any pending logging is properly flushed
     await sleep(1)
@@ -412,71 +376,9 @@ class Runtime extends EventEmitter {
     throw error
   }
 
-  async startService (id, silent = false) {
-    // Since when a service is stopped the worker is deleted, we consider a service start if its first service
-    // is no longer in the init phase
-    const firstWorker = this.#workers.get(`${id}:0`)
-    if (firstWorker && firstWorker[kWorkerStatus] !== 'boot' && firstWorker[kWorkerStatus] !== 'init') {
-      throw new errors.ApplicationAlreadyStartedError()
-    }
-
-    const config = this.#config
-    const serviceConfig = config.services.find(s => s.id === id)
-
-    if (!serviceConfig) {
-      throw new errors.ServiceNotFoundError(id, Array.from(this.#servicesIds).join(', '))
-    }
-
-    const workersCount = await this.#workers.getCount(serviceConfig.id)
-
-    this.emit('service:starting', id)
-
-    for (let i = 0; i < workersCount; i++) {
-      await this.#startWorker(config, serviceConfig, workersCount, id, i, silent)
-    }
-
-    this.emit('service:started', id)
-  }
-
-  async stopService (id, silent = false) {
-    const config = this.#config
-    const serviceConfig = config.services.find(s => s.id === id)
-
-    if (!serviceConfig) {
-      throw new errors.ServiceNotFoundError(id, Array.from(this.#servicesIds).join(', '))
-    }
-
-    const workersCount = await this.#workers.getCount(serviceConfig.id)
-
-    this.emit('service:stopping', id)
-
-    for (let i = 0; i < workersCount; i++) {
-      await this.#stopWorker(workersCount, id, i, silent)
-    }
-
-    this.emit('service:stopped', id)
-  }
-
-  async buildService (id) {
-    const service = await this.#getServiceById(id)
-
-    this.emit('service:building', id)
-    try {
-      await sendViaITC(service, 'build')
-      this.emit('service:built', id)
-    } catch (e) {
-      // The service exports no meta, return an empty object
-      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
-        return {}
-      }
-
-      throw e
-    }
-  }
-
   async inject (id, injectParams) {
-    // Make sure the service exists
-    await this.#getServiceById(id, true)
+    // Make sure the application exists
+    await this.#getApplicationById(id, true)
 
     if (typeof injectParams === 'string') {
       injectParams = { url: injectParams }
@@ -519,6 +421,109 @@ class Runtime extends EventEmitter {
     }
   }
 
+  emit (event, payload) {
+    for (const worker of this.#workers.values()) {
+      worker[kITC].notify('runtime:event', { event, payload })
+    }
+
+    this.logger.trace({ event, payload }, 'Runtime event')
+    return super.emit(event, payload)
+  }
+
+  async sendCommandToApplication (id, name, message) {
+    const application = await this.#getApplicationById(id)
+
+    try {
+      return await sendViaITC(application, name, message)
+    } catch (e) {
+      // The application exports no meta, return an empty object
+      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
+        return {}
+      }
+
+      throw e
+    }
+  }
+
+  async startApplication (id, silent = false) {
+    // Since when an application is stopped the worker is deleted, we consider an application start if its first application
+    // is no longer in the init phase
+    const firstWorker = this.#workers.get(`${id}:0`)
+    if (firstWorker && firstWorker[kWorkerStatus] !== 'boot' && firstWorker[kWorkerStatus] !== 'init') {
+      throw new ApplicationAlreadyStartedError()
+    }
+
+    const config = this.#config
+    const applicationConfig = config.applications.find(s => s.id === id)
+
+    if (!applicationConfig) {
+      throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
+    }
+
+    const workersCount = await this.#workers.getCount(applicationConfig.id)
+
+    this.emit('application:starting', id)
+
+    for (let i = 0; i < workersCount; i++) {
+      await this.#startWorker(config, applicationConfig, workersCount, id, i, silent)
+    }
+
+    this.emit('application:started', id)
+  }
+
+  async stopApplication (id, silent = false, dependents = []) {
+    const config = this.#config
+    const applicationConfig = config.applications.find(s => s.id === id)
+
+    if (!applicationConfig) {
+      throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
+    }
+
+    const workersCount = await this.#workers.getCount(applicationConfig.id)
+
+    this.emit('application:stopping', id)
+
+    if (typeof workersCount === 'number') {
+      const stopInvocations = []
+      for (let i = 0; i < workersCount; i++) {
+        stopInvocations.push([workersCount, id, i, silent, undefined, dependents])
+      }
+
+      await executeInParallel(this.#stopWorker.bind(this), stopInvocations, this.#concurrency)
+    }
+
+    this.emit('application:stopped', id)
+  }
+
+  async buildApplication (id) {
+    const application = await this.#getApplicationById(id)
+
+    this.emit('application:building', id)
+    try {
+      await sendViaITC(application, 'build')
+      this.emit('application:built', id)
+    } catch (e) {
+      // The application exports no meta, return an empty object
+      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
+        return {}
+      }
+
+      throw e
+    }
+  }
+
+  async startApplicationProfiling (id, options = {}, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(service, 'startProfiling', options)
+  }
+
+  async stopApplicationProfiling (id, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(service, 'stopProfiling')
+  }
+
   async updateUndiciInterceptors (undiciConfig) {
     this.#config.undici = undiciConfig
 
@@ -546,7 +551,7 @@ class Runtime extends EventEmitter {
       try {
         metrics = await this.getFormattedMetrics()
       } catch (error) {
-        if (!(error instanceof errors.RuntimeExitedError)) {
+        if (!(error instanceof RuntimeExitedError)) {
           this.logger.error({ err: ensureLoggableError(error) }, 'Error collecting metrics')
         }
         return
@@ -560,6 +565,25 @@ class Runtime extends EventEmitter {
     }, COLLECT_METRICS_TIMEOUT).unref()
   }
 
+  invalidateHttpCache (options = {}) {
+    const { keys, tags } = options
+
+    if (!this.#sharedHttpCache) {
+      return
+    }
+
+    const promises = []
+    if (keys && keys.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteKeys(keys))
+    }
+
+    if (tags && tags.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteTags(tags))
+    }
+
+    return Promise.all(promises)
+  }
+
   async addLoggerDestination (writableStream) {
     // Add the stream - We output everything we get
     this.#loggerDestination.add({ stream: writableStream, level: 1 })
@@ -579,10 +603,153 @@ class Runtime extends EventEmitter {
     this.on('closed', onClose)
   }
 
+  async updateSharedContext (options = {}) {
+    const { context, overwrite = false } = options
+
+    const sharedContext = overwrite ? {} : this.#sharedContext
+    Object.assign(sharedContext, context)
+
+    this.#sharedContext = sharedContext
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'setSharedContext', sharedContext))
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        this.logger.error({ err: result.reason }, 'Cannot update shared context')
+      }
+    }
+
+    return sharedContext
+  }
+
+  setApplicationConfigPatch (id, patch) {
+    this.#applicationsConfigsPatches.set(id, patch)
+  }
+
+  removeApplicationConfigPatch (id) {
+    this.#applicationsConfigsPatches.delete(id)
+  }
+
+  /**
+   * Updates the resources of the applications, such as the number of workers and health configurations (e.g., heap memory settings).
+   *
+   * This function handles three update scenarios for each application:
+   *  1. **Updating workers only**: Adjusts the number of workers for the application.
+   *  2. **Updating health configurations only**: Updates health parameters like `maxHeapTotal` or `maxYoungGeneration`.
+   *  3. **Updating both workers and health configurations**: Scales the workers and also applies health settings.
+   *
+   * When updating both workers and health:
+   *  - **Scaling down workers**: Stops extra workers, then restarts the remaining workers with the previous settings.
+   *  - **Scaling up workers**: Starts new workers with the updated heap settings, then restarts the old workers with the updated settings.
+   *
+   * Scaling up new resources (workers and/or heap memory) may fails due to insufficient memory, in this case the operation may fail partially or entirely.
+   * Scaling down is expected to succeed without issues.
+   *
+   * @param {Array<Object>} updates - An array of objects that define the updates for each application.
+   * @param {string} updates[].application - The ID of the application to update.
+   * @param {number} [updates[].workers] - The desired number of workers for the application. If omitted, workers will not be updated.
+   * @param {Object} [updates[].health] - The health configuration to update for the application, which may include:
+   *   @param {string|number} [updates[].health.maxHeapTotal] - The maximum heap memory for the application. Can be a valid memory string (e.g., '1G', '512MB') or a number representing bytes.
+   *   @param {string|number} [updates[].health.maxYoungGeneration] - The maximum young generation memory for the application. Can be a valid memory string (e.g., '128MB') or a number representing bytes.
+   *
+   * @returns {Promise<Array<Object>>} - A promise that resolves to an array of reports for each application, detailing the success or failure of the operations:
+   *   - `application`: The application ID.
+   *   - `workers`: The workers' update report, including the current, new number of workers, started workers, and success status.
+   *   - `health`: The health update report, showing the current and new heap settings, updated workers, and success status.
+   *
+   * @example
+   * await runtime.updateApplicationsResources([
+   *   { application: 'application-1', workers: 2, health: { maxHeapTotal: '1G', maxYoungGeneration: '128 MB' } },
+   *   { application: 'application-2', health: { maxHeapTotal: '1G' } },
+   *   { application: 'application-3', workers: 2 },
+   * ])
+   *
+   * In this example:
+   * - `application-1` will have 2 workers and updated heap memory configurations.
+   * - `application-2` will have updated heap memory settings (without changing workers).
+   * - `application-3` will have its workers set to 2 but no change in memory settings.
+   *
+   * @throws {InvalidArgumentError} - Throws if any update parameter is invalid, such as:
+   *   - Missing application ID.
+   *   - Invalid worker count (not a positive integer).
+   *   - Invalid memory size format for `maxHeapTotal` or `maxYoungGeneration`.
+   * @throws {ApplicationNotFoundError} - Throws if the specified application ID does not exist in the current application configuration.
+   */
+  async updateApplicationsResources (updates) {
+    if (this.#status === 'stopping' || this.#status === 'closed') {
+      this.logger.warn('Cannot update application resources when the runtime is stopping or closed')
+      return
+    }
+
+    const ups = await this.#validateUpdateApplicationResources(updates)
+    const config = this.#config
+
+    const report = []
+    for (const update of ups) {
+      const { applicationId, config: applicationConfig, workers, health, currentWorkers, currentHealth } = update
+
+      if (workers && health) {
+        const r = await this.#updateApplicationWorkersAndHealth(
+          applicationId,
+          config,
+          applicationConfig,
+          workers,
+          health,
+          currentWorkers,
+          currentHealth
+        )
+        report.push({
+          application: applicationId,
+          workers: r.workers,
+          health: r.health
+        })
+      } else if (health) {
+        const r = await this.#updateApplicationHealth(
+          applicationId,
+          config,
+          applicationConfig,
+          currentWorkers,
+          currentHealth,
+          health
+        )
+        report.push({
+          application: applicationId,
+          health: r.health
+        })
+      } else if (workers) {
+        const r = await this.#updateApplicationWorkers(
+          applicationId,
+          config,
+          applicationConfig,
+          workers,
+          currentWorkers
+        )
+        report.push({
+          application: applicationId,
+          workers: r.workers
+        })
+      }
+    }
+
+    return report
+  }
+
+  setConcurrency (concurrency) {
+    this.#concurrency = concurrency
+  }
+
   async getUrl () {
     return this.#url
   }
 
+  getRuntimeStatus () {
+    return this.#status
+  }
+
   async getRuntimeMetadata () {
     const packageJson = await this.#getRuntimePackageJson()
     const entrypointDetails = await this.getEntrypointDetails()
@@ -598,7 +765,7 @@ class Runtime extends EventEmitter {
       packageName: packageJson.name ?? null,
       packageVersion: packageJson.version ?? null,
       url: entrypointDetails?.url ?? null,
-      platformaticVersion
+      platformaticVersion: version
     }
   }
 
@@ -628,47 +795,19 @@ class Runtime extends EventEmitter {
   }
 
   getManagementApiUrl () {
-    return this.#managementApi?.server.address()
+    return this.#managementApi?.server.address() ?? null
   }
 
   async getEntrypointDetails () {
-    return this.getServiceDetails(this.#entrypointId)
-  }
-
-  async getServices () {
-    return {
-      entrypoint: this.#entrypointId,
-      production: this.#isProduction,
-      services: await Promise.all(this.#servicesIds.map(id => this.getServiceDetails(id)))
-    }
-  }
-
-  async getWorkers () {
-    const status = {}
-
-    for (const [service, { count }] of Object.entries(this.#workers.configuration)) {
-      for (let i = 0; i < count; i++) {
-        const label = `${service}:${i}`
-        const worker = this.#workers.get(label)
-
-        status[label] = {
-          service,
-          worker: i,
-          status: worker?.[kWorkerStatus] ?? 'exited',
-          thread: worker?.threadId
-        }
-      }
-    }
-
-    return status
+    return this.getApplicationDetails(this.#entrypointId)
   }
 
   async getCustomHealthChecks () {
     const status = {}
 
-    for (const [service, { count }] of Object.entries(this.#workers.configuration)) {
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
       for (let i = 0; i < count; i++) {
-        const label = `${service}:${i}`
+        const label = `${application}:${i}`
         const worker = this.#workers.get(label)
 
         status[label] = await sendViaITC(worker, 'getCustomHealthCheck')
@@ -681,83 +820,16 @@ class Runtime extends EventEmitter {
   async getCustomReadinessChecks () {
     const status = {}
 
-    for (const [service, { count }] of Object.entries(this.#workers.configuration)) {
-      for (let i = 0; i < count; i++) {
-        const label = `${service}:${i}`
-        const worker = this.#workers.get(label)
-
-        status[label] = await sendViaITC(worker, 'getCustomReadinessCheck')
-      }
-    }
-
-    return status
-  }
-
-  async getServiceDetails (id, allowUnloaded = false) {
-    let service
-
-    try {
-      service = await this.#getServiceById(id)
-    } catch (e) {
-      if (allowUnloaded) {
-        return { id, status: 'stopped' }
-      }
-
-      throw e
-    }
-
-    const { entrypoint, dependencies, localUrl } = service[kConfig]
-
-    const status = await sendViaITC(service, 'getStatus')
-    const { type, version } = await sendViaITC(service, 'getServiceInfo')
-
-    const serviceDetails = {
-      id,
-      type,
-      status,
-      version,
-      localUrl,
-      entrypoint,
-      dependencies
-    }
-
-    if (this.#isProduction) {
-      serviceDetails.workers = this.#workers.getCount(id)
-    }
-
-    if (entrypoint) {
-      serviceDetails.url = status === 'started' ? this.#url : null
-    }
-
-    return serviceDetails
-  }
-
-  async getService (id, ensureStarted = true) {
-    return this.#getServiceById(id, ensureStarted)
-  }
-
-  async getServiceConfig (id, ensureStarted = true) {
-    const service = await this.#getServiceById(id, ensureStarted)
-
-    return sendViaITC(service, 'getServiceConfig')
-  }
-
-  async getServiceEnv (id, ensureStarted = true) {
-    const service = await this.#getServiceById(id, ensureStarted)
-
-    return sendViaITC(service, 'getServiceEnv')
-  }
-
-  async getServiceOpenapiSchema (id) {
-    const service = await this.#getServiceById(id, true)
-
-    return sendViaITC(service, 'getServiceOpenAPISchema')
-  }
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
+      for (let i = 0; i < count; i++) {
+        const label = `${application}:${i}`
+        const worker = this.#workers.get(label)
 
-  async getServiceGraphqlSchema (id) {
-    const service = await this.#getServiceById(id, true)
+        status[label] = await sendViaITC(worker, 'getCustomReadinessCheck')
+      }
+    }
 
-    return sendViaITC(service, 'getServiceGraphQLSchema')
+    return status
   }
 
   async getMetrics (format = 'json') {
@@ -765,26 +837,30 @@ class Runtime extends EventEmitter {
 
     for (const worker of this.#workers.values()) {
       try {
-        // The service might be temporarily unavailable
+        // The application might be temporarily unavailable
         if (worker[kWorkerStatus] !== 'started') {
           continue
         }
 
-        const serviceMetrics = await sendViaITC(worker, 'getMetrics', format)
-        if (serviceMetrics) {
+        const applicationMetrics = await sendViaITC(worker, 'getMetrics', format)
+        if (applicationMetrics) {
           if (metrics === null) {
             metrics = format === 'json' ? [] : ''
           }
 
           if (format === 'json') {
-            metrics.push(...serviceMetrics)
+            metrics.push(...applicationMetrics)
           } else {
-            metrics += serviceMetrics
+            metrics += applicationMetrics
           }
         }
       } catch (e) {
-        // The service exited while we were sending the ITC, skip it
-        if (e.code === 'PLT_RUNTIME_SERVICE_NOT_STARTED' || e.code === 'PLT_RUNTIME_SERVICE_EXIT') {
+        // The application exited while we were sending the ITC, skip it
+        if (
+          e.code === 'PLT_RUNTIME_APPLICATION_NOT_STARTED' ||
+          e.code === 'PLT_RUNTIME_APPLICATION_EXIT' ||
+          e.code === 'PLT_RUNTIME_APPLICATION_WORKER_EXIT'
+        ) {
           continue
         }
 
@@ -817,7 +893,7 @@ class Runtime extends EventEmitter {
         'http_request_all_summary_seconds'
       ]
 
-      const servicesMetrics = {}
+      const applicationsMetrics = {}
 
       for (const metric of metrics) {
         const { name, values } = metric
@@ -826,15 +902,15 @@ class Runtime extends EventEmitter {
         if (!values || values.length === 0) continue
 
         const labels = values[0].labels
-        const serviceId = labels?.serviceId
+        const applicationId = labels?.applicationId
 
-        if (!serviceId) {
-          throw new Error('Missing serviceId label in metrics')
+        if (!applicationId) {
+          throw new Error('Missing applicationId label in metrics')
         }
 
-        let serviceMetrics = servicesMetrics[serviceId]
-        if (!serviceMetrics) {
-          serviceMetrics = {
+        let applicationMetrics = applicationsMetrics[applicationId]
+        if (!applicationMetrics) {
+          applicationMetrics = {
             cpu: 0,
             rss: 0,
             totalHeapSize: 0,
@@ -849,45 +925,45 @@ class Runtime extends EventEmitter {
               p99: 0
             }
           }
-          servicesMetrics[serviceId] = serviceMetrics
+          applicationsMetrics[applicationId] = applicationMetrics
         }
 
-        parsePromMetric(serviceMetrics, metric)
+        parsePromMetric(applicationMetrics, metric)
       }
 
-      function parsePromMetric (serviceMetrics, promMetric) {
+      function parsePromMetric (applicationMetrics, promMetric) {
         const { name } = promMetric
 
         if (name === 'process_cpu_percent_usage') {
-          serviceMetrics.cpu = promMetric.values[0].value
+          applicationMetrics.cpu = promMetric.values[0].value
           return
         }
         if (name === 'process_resident_memory_bytes') {
-          serviceMetrics.rss = promMetric.values[0].value
+          applicationMetrics.rss = promMetric.values[0].value
           return
         }
         if (name === 'nodejs_heap_size_total_bytes') {
-          serviceMetrics.totalHeapSize = promMetric.values[0].value
+          applicationMetrics.totalHeapSize = promMetric.values[0].value
           return
         }
         if (name === 'nodejs_heap_size_used_bytes') {
-          serviceMetrics.usedHeapSize = promMetric.values[0].value
+          applicationMetrics.usedHeapSize = promMetric.values[0].value
           return
         }
         if (name === 'nodejs_heap_space_size_total_bytes') {
           const newSpaceSize = promMetric.values.find(value => value.labels.space === 'new')
           const oldSpaceSize = promMetric.values.find(value => value.labels.space === 'old')
 
-          serviceMetrics.newSpaceSize = newSpaceSize.value
-          serviceMetrics.oldSpaceSize = oldSpaceSize.value
+          applicationMetrics.newSpaceSize = newSpaceSize.value
+          applicationMetrics.oldSpaceSize = oldSpaceSize.value
           return
         }
         if (name === 'nodejs_eventloop_utilization') {
-          serviceMetrics.elu = promMetric.values[0].value
+          applicationMetrics.elu = promMetric.values[0].value
           return
         }
         if (name === 'http_request_all_summary_seconds') {
-          serviceMetrics.latency = {
+          applicationMetrics.latency = {
             p50: promMetric.values.find(value => value.labels.quantile === 0.5)?.value || 0,
             p90: promMetric.values.find(value => value.labels.quantile === 0.9)?.value || 0,
             p95: promMetric.values.find(value => value.labels.quantile === 0.95)?.value || 0,
@@ -899,7 +975,7 @@ class Runtime extends EventEmitter {
       return {
         version: 1,
         date: new Date().toISOString(),
-        services: servicesMetrics
+        applications: applicationsMetrics
       }
     } catch (err) {
       // If any metric is missing, return nothing
@@ -909,123 +985,157 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async getServiceMeta (id) {
-    const service = await this.#getServiceById(id)
+  getSharedContext () {
+    return this.#sharedContext
+  }
 
-    try {
-      return await sendViaITC(service, 'getServiceMeta')
-    } catch (e) {
-      // The service exports no meta, return an empty object
-      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
-        return {}
-      }
+  async getApplicationResourcesInfo (id) {
+    const workers = this.#workers.getCount(id)
 
-      throw e
-    }
+    const worker = await this.#getWorkerById(id, 0, false, false)
+    const health = worker[kConfig].health
+
+    return { workers, health }
   }
 
-  setServiceConfigPatch (id, patch) {
-    this.servicesConfigsPatches.set(id, patch)
+  getApplicationsIds () {
+    return this.#config.applications.map(application => application.id)
   }
 
-  removeServiceConfigPatch (id) {
-    this.servicesConfigsPatches.delete(id)
+  async getApplications (allowUnloaded = false) {
+    return {
+      entrypoint: this.#entrypointId,
+      production: this.#isProduction,
+      applications: await Promise.all(
+        this.getApplicationsIds().map(id => this.getApplicationDetails(id, allowUnloaded))
+      )
+    }
   }
 
-  #getHttpCacheValue ({ request }) {
-    if (!this.#sharedHttpCache) {
-      return
+  async getWorkers () {
+    const status = {}
+
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
+      for (let i = 0; i < count; i++) {
+        const label = `${application}:${i}`
+        const worker = this.#workers.get(label)
+
+        status[label] = {
+          application,
+          worker: i,
+          status: worker?.[kWorkerStatus] ?? 'exited',
+          thread: worker?.threadId
+        }
+      }
     }
 
-    return this.#sharedHttpCache.getValue(request)
+    return status
   }
 
-  #setHttpCacheValue ({ request, response, payload }) {
-    if (!this.#sharedHttpCache) {
-      return
-    }
+  async getApplicationMeta (id) {
+    const application = await this.#getApplicationById(id)
 
-    return this.#sharedHttpCache.setValue(request, response, payload)
+    try {
+      return await sendViaITC(application, 'getApplicationMeta')
+    } catch (e) {
+      // The application exports no meta, return an empty object
+      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
+        return {}
+      }
+
+      throw e
+    }
   }
 
-  #deleteHttpCacheValue ({ request }) {
-    if (!this.#sharedHttpCache) {
-      return
+  async getApplicationDetails (id, allowUnloaded = false) {
+    let application
+
+    try {
+      application = await this.#getApplicationById(id)
+    } catch (e) {
+      if (allowUnloaded) {
+        return { id, status: 'stopped' }
+      }
+
+      throw e
     }
 
-    return this.#sharedHttpCache.delete(request)
-  }
+    const { entrypoint, localUrl } = application[kConfig]
 
-  invalidateHttpCache (options = {}) {
-    const { keys, tags } = options
+    const status = await sendViaITC(application, 'getStatus')
+    const { type, version, dependencies } = await sendViaITC(application, 'getApplicationInfo')
 
-    if (!this.#sharedHttpCache) {
-      return
+    const applicationDetails = {
+      id,
+      type,
+      status,
+      dependencies,
+      version,
+      localUrl,
+      entrypoint
     }
 
-    const promises = []
-    if (keys && keys.length > 0) {
-      promises.push(this.#sharedHttpCache.deleteKeys(keys))
+    if (this.#isProduction) {
+      applicationDetails.workers = this.#workers.getCount(id)
     }
 
-    if (tags && tags.length > 0) {
-      promises.push(this.#sharedHttpCache.deleteTags(tags))
+    if (entrypoint) {
+      applicationDetails.url = status === 'started' ? this.#url : null
     }
 
-    return Promise.all(promises)
+    return applicationDetails
   }
 
-  async sendCommandToService (id, name, message) {
-    const service = await this.#getServiceById(id)
+  async getApplication (id, ensureStarted = true) {
+    return this.#getApplicationById(id, ensureStarted)
+  }
 
-    try {
-      return await sendViaITC(service, name, message)
-    } catch (e) {
-      // The service exports no meta, return an empty object
-      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
-        return {}
-      }
+  async getApplicationConfig (id, ensureStarted = true) {
+    const application = await this.#getApplicationById(id, ensureStarted)
 
-      throw e
-    }
+    return sendViaITC(application, 'getApplicationConfig')
   }
 
-  emit (event, payload) {
-    for (const worker of this.#workers.values()) {
-      if (worker[kForwardEvents]) {
-        worker[kITC].notify('runtime:event', { event, payload })
-      }
-    }
+  async getApplicationEnv (id, ensureStarted = true) {
+    const application = await this.#getApplicationById(id, ensureStarted)
 
-    this.logger.trace({ event, payload }, 'Runtime event')
-    return super.emit(event, payload)
+    return sendViaITC(application, 'getApplicationEnv')
   }
 
-  async updateSharedContext (options = {}) {
-    const { context, overwrite = false } = options
+  async getApplicationOpenapiSchema (id) {
+    const application = await this.#getApplicationById(id, true)
 
-    const sharedContext = overwrite ? {} : this.#sharedContext
-    Object.assign(sharedContext, context)
+    return sendViaITC(application, 'getApplicationOpenAPISchema')
+  }
 
-    this.#sharedContext = sharedContext
+  async getApplicationGraphqlSchema (id) {
+    const application = await this.#getApplicationById(id, true)
 
-    const promises = []
-    for (const worker of this.#workers.values()) {
-      promises.push(sendViaITC(worker, 'setSharedContext', sharedContext))
+    return sendViaITC(application, 'getApplicationGraphQLSchema')
+  }
+
+  #getHttpCacheValue ({ request }) {
+    if (!this.#sharedHttpCache) {
+      return
     }
 
-    const results = await Promise.allSettled(promises)
-    for (const result of results) {
-      if (result.status === 'rejected') {
-        this.logger.error({ err: result.reason }, 'Cannot update shared context')
-      }
+    return this.#sharedHttpCache.getValue(request)
+  }
+
+  #setHttpCacheValue ({ request, response, payload }) {
+    if (!this.#sharedHttpCache) {
+      return
     }
 
-    return sharedContext
+    return this.#sharedHttpCache.setValue(request, response, payload)
   }
 
-  getSharedContext () {
-    return this.#sharedContext
+  #deleteHttpCacheValue ({ request }) {
+    if (!this.#sharedHttpCache) {
+      return
+    }
+
+    return this.#sharedHttpCache.delete(request)
   }
 
   async #setDispatcher (undiciConfig) {
@@ -1055,23 +1165,65 @@ class Runtime extends EventEmitter {
     this.logger.info(`Platformatic is now listening at ${this.#url}`)
   }
 
-  async #setupService (serviceConfig) {
-    if (this.#status === 'stopping' || this.#status === 'closed') return
+  async #setupApplications () {
+    const config = this.#config
+    const setupInvocations = []
+
+    // Parse all applications and verify we're not missing any path or resolved application
+    for (const applicationConfig of config.applications) {
+      // If there is no application path, check if the application was resolved
+      if (!applicationConfig.path) {
+        if (applicationConfig.url) {
+          // Try to backfill the path for external applications
+          applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, applicationConfig.id)
+
+          if (!existsSync(applicationConfig.path)) {
+            const executable = globalThis.platformatic?.executable ?? 'platformatic'
+            this.logger.error(
+              `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
+              applicationConfig.id
+            )
+
+            await this.closeAndThrow(new RuntimeAbortedError())
+          }
+        } else {
+          this.logger.error(
+            'The application "%s" has no path defined. Please check your configuration and try again.',
+            applicationConfig.id
+          )
+
+          await this.closeAndThrow(new RuntimeAbortedError())
+        }
+      }
+
+      setupInvocations.push([applicationConfig])
+    }
+
+    await executeInParallel(this.#setupApplication.bind(this), setupInvocations, this.#concurrency)
+  }
+
+  async #setupApplication (applicationConfig) {
+    if (this.#status === 'stopping' || this.#status === 'closed') {
+      return
+    }
 
     const config = this.#config
-    const workersCount = await this.#workers.getCount(serviceConfig.id)
-    const id = serviceConfig.id
+    const workersCount = await this.#workers.getCount(applicationConfig.id)
+    const id = applicationConfig.id
+    const setupInvocations = []
 
     for (let i = 0; i < workersCount; i++) {
-      await this.#setupWorker(config, serviceConfig, workersCount, id, i)
+      setupInvocations.push([config, applicationConfig, workersCount, id, i])
     }
 
-    this.emit('service:init', id)
+    await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
+
+    this.emit('application:init', id)
   }
 
-  async #setupWorker (config, serviceConfig, workersCount, serviceId, index, enabled = true) {
+  async #setupWorker (config, applicationConfig, workersCount, applicationId, index, enabled = true) {
     const { restartOnError } = config
-    const workerId = `${serviceId}:${index}`
+    const workerId = `${applicationId}:${index}`
 
     // Handle inspector
     let inspectorOptions
@@ -1085,36 +1237,40 @@ class Runtime extends EventEmitter {
     }
 
     if (config.telemetry) {
-      serviceConfig.telemetry = {
+      applicationConfig.telemetry = {
         ...config.telemetry,
-        ...serviceConfig.telemetry,
-        serviceName: `${config.telemetry.serviceName}-${serviceConfig.id}`
+        ...applicationConfig.telemetry,
+        applicationName: `${config.telemetry.applicationName}-${applicationConfig.id}`
       }
     }
 
-    const errorLabel = this.#workerExtendedLabel(serviceId, index, workersCount)
-    const health = deepmerge(config.health ?? {}, serviceConfig.health ?? {})
+    const errorLabel = this.#workerExtendedLabel(applicationId, index, workersCount)
+    const health = deepmerge(config.health ?? {}, applicationConfig.health ?? {})
 
     const execArgv = []
 
-    if (!serviceConfig.skipTelemetryHooks && config.telemetry && config.telemetry.enabled !== false) {
+    if (!applicationConfig.skipTelemetryHooks && config.telemetry && config.telemetry.enabled !== false) {
+      const require = createRequire(import.meta.url)
+      const telemetryPath = require.resolve('@platformatic/telemetry')
+      const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
       const hookUrl = pathToFileURL(require.resolve('@opentelemetry/instrumentation/hook.mjs'))
+
       // We need the following because otherwise some open telemetry instrumentations won't work with ESM (like express)
       // see: https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md#instrumentation-hook-required-for-esm
       execArgv.push('--import', `data:text/javascript, import { register } from 'node:module'; register('${hookUrl}')`)
       execArgv.push('--import', pathToFileURL(openTelemetrySetupPath))
     }
 
-    if ((serviceConfig.sourceMaps ?? config.sourceMaps) === true) {
+    if ((applicationConfig.sourceMaps ?? config.sourceMaps) === true) {
       execArgv.push('--enable-source-maps')
     }
 
     const workerEnv = structuredClone(this.#env)
 
-    if (serviceConfig.nodeOptions?.trim().length > 0) {
+    if (applicationConfig.nodeOptions?.trim().length > 0) {
       const originalNodeOptions = workerEnv['NODE_OPTIONS'] ?? ''
 
-      workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${serviceConfig.nodeOptions}`.trim()
+      workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${applicationConfig.nodeOptions}`.trim()
     }
 
     const maxHeapTotal =
@@ -1132,10 +1288,10 @@ class Runtime extends EventEmitter {
     const worker = new Worker(kWorkerFile, {
       workerData: {
         config,
-        serviceConfig: {
-          ...serviceConfig,
+        applicationConfig: {
+          ...applicationConfig,
           isProduction: this.#isProduction,
-          configPatch: this.servicesConfigsPatches.get(serviceId)
+          configPatch: this.#applicationsConfigsPatches.get(applicationId)
         },
         worker: {
           id: workerId,
@@ -1145,7 +1301,7 @@ class Runtime extends EventEmitter {
         inspectorOptions,
         dirname: this.#root
       },
-      argv: serviceConfig.arguments,
+      argv: applicationConfig.arguments,
       execArgv,
       env: workerEnv,
       resourceLimits: {
@@ -1156,13 +1312,14 @@ class Runtime extends EventEmitter {
       stderr: true
     })
 
-    this.#handleWorkerStandardStreams(worker, serviceId, workersCount > 1 ? index : undefined)
+    this.#handleWorkerStandardStreams(worker, applicationId, workersCount > 1 ? index : undefined)
 
     // Make sure the listener can handle a lot of API requests at once before raising a warning
     worker.setMaxListeners(1e3)
 
-    // Track service exiting
-    const eventPayload = { service: serviceId, worker: index, workersCount }
+    // Track application exiting
+    const eventPayload = { application: applicationId, worker: index, workersCount }
+
     worker.once('exit', code => {
       if (worker[kWorkerStatus] === 'exited') {
         return
@@ -1170,7 +1327,7 @@ class Runtime extends EventEmitter {
 
       const started = worker[kWorkerStatus] === 'started'
       worker[kWorkerStatus] = 'exited'
-      this.emit('service:worker:exited', eventPayload)
+      this.emit('application:worker:exited', eventPayload)
 
       this.#cleanupWorker(worker)
 
@@ -1181,13 +1338,13 @@ class Runtime extends EventEmitter {
       // Wait for the next tick so that crashed from the thread are logged first
       setImmediate(() => {
         if (started && (!config.watch || code !== 0)) {
-          this.emit('service:worker:error', { ...eventPayload, code })
+          this.emit('application:worker:error', { ...eventPayload, code })
           this.#broadcastWorkers()
 
           this.logger.warn(`The ${errorLabel} unexpectedly exited with code ${code}.`)
         }
 
-        // Restart the service if it was started
+        // Restart the application if it was started
         if (started && this.#status === 'started') {
           if (restartOnError > 0) {
             if (restartOnError < IMMEDIATE_RESTART_MAX_THRESHOLD) {
@@ -1196,28 +1353,29 @@ class Runtime extends EventEmitter {
               this.logger.warn(`The ${errorLabel} will be restarted in ${restartOnError}ms ...`)
             }
 
-            this.#restartCrashedWorker(config, serviceConfig, workersCount, serviceId, index, false, 0).catch(err => {
-              this.logger.error({ err: ensureLoggableError(err) }, `${errorLabel} could not be restarted.`)
-            })
+            this.#restartCrashedWorker(config, applicationConfig, workersCount, applicationId, index, false, 0).catch(
+              err => {
+                this.logger.error({ err: ensureLoggableError(err) }, `${errorLabel} could not be restarted.`)
+              }
+            )
           } else {
-            this.emit('service:worker:unvailable', eventPayload)
+            this.emit('application:worker:unvailable', eventPayload)
             this.logger.warn(`The ${errorLabel} is no longer available.`)
           }
         }
       })
     })
 
-    worker[kId] = workersCount > 1 ? workerId : serviceId
+    worker[kId] = workersCount > 1 ? workerId : applicationId
     worker[kFullId] = workerId
-    worker[kServiceId] = serviceId
+    worker[kApplicationId] = applicationId
     worker[kWorkerId] = workersCount > 1 ? index : undefined
     worker[kWorkerStatus] = 'boot'
-    worker[kForwardEvents] = false
 
     if (inspectorOptions) {
       worker[kInspectorOptions] = {
         port: inspectorOptions.port,
-        id: serviceId,
+        id: applicationId,
         dirname: this.#root
       }
     }
@@ -1226,41 +1384,36 @@ class Runtime extends EventEmitter {
     worker[kITC] = new ITC({
       name: workerId + '-runtime',
       port: worker,
-      handlers: {
-        ...this.#workerITCHandlers,
-        setEventsForwarding (value) {
-          worker[kForwardEvents] = value
-        }
-      }
+      handlers: this.#workerITCHandlers
     })
     worker[kITC].listen()
 
     // Forward events from the worker
     worker[kITC].on('event', ({ event, payload }) => {
-      this.emit(`service:worker:event:${event}`, { ...eventPayload, payload })
+      this.emit(`application:worker:event:${event}`, { ...eventPayload, payload })
     })
 
     // Only activate watch for the first instance
     if (index === 0) {
-      // Handle services changes
+      // Handle applications changes
       // This is not purposely activated on when this.#config.watch === true
-      // so that services can eventually manually trigger a restart. This mechanism is current
-      // used by the composer.
+      // so that applications can eventually manually trigger a restart. This mechanism is current
+      // used by the gateway.
       worker[kITC].on('changed', async () => {
-        this.emit('service:worker:changed', eventPayload)
+        this.emit('application:worker:changed', eventPayload)
 
         try {
           const wasStarted = worker[kWorkerStatus].startsWith('start')
-          await this.stopService(serviceId)
+          await this.stopApplication(applicationId)
 
           if (wasStarted) {
-            await this.startService(serviceId)
+            await this.startApplication(applicationId)
           }
 
-          this.logger.info(`The service "${serviceId}" has been successfully reloaded ...`)
-          this.emit('service:worker:reloaded', eventPayload)
+          this.logger.info(`The application "${applicationId}" has been successfully reloaded ...`)
+          this.emit('application:worker:reloaded', eventPayload)
 
-          if (serviceConfig.entrypoint) {
+          if (applicationConfig.entrypoint) {
             this.#showUrl()
           }
         } catch (e) {
@@ -1274,27 +1427,19 @@ class Runtime extends EventEmitter {
       this.#workers.set(workerId, worker)
 
       // Setup the interceptor
-      this.#meshInterceptor.route(serviceId, worker)
+      this.#meshInterceptor.route(applicationId, worker)
     }
 
-    // Store dependencies
-    const [{ dependencies }] = await waitEventFromITC(worker, 'init')
-
-    if (serviceConfig.entrypoint) {
-      this.#entrypointId = serviceId
-    }
+    // Wait for initialization
+    await waitEventFromITC(worker, 'init')
 
-    serviceConfig.dependencies = dependencies
-    for (const { envVar, url } of dependencies) {
-      if (envVar) {
-        serviceConfig.localServiceEnvVars.set(envVar, url)
-      }
+    if (applicationConfig.entrypoint) {
+      this.#entrypointId = applicationId
     }
 
-    // This must be done here as the dependencies are filled above
-    worker[kConfig] = { ...serviceConfig, health, workers: workersCount }
+    worker[kConfig] = { ...applicationConfig, health, workers: workersCount }
     worker[kWorkerStatus] = 'init'
-    this.emit('service:worker:init', eventPayload)
+    this.emit('application:worker:init', eventPayload)
 
     return worker
   }
@@ -1312,7 +1457,7 @@ class Runtime extends EventEmitter {
     return health
   }
 
-  #setupHealthCheck (config, serviceConfig, workersCount, id, index, worker, errorLabel, timeout) {
+  #setupHealthCheck (config, applicationConfig, workersCount, id, index, worker, errorLabel, timeout) {
     // Clear the timeout when exiting
     worker.on('exit', () => clearTimeout(worker[kHealthCheckTimer]))
 
@@ -1338,9 +1483,9 @@ class Runtime extends EventEmitter {
         health = { elu: -1, heapUsed: -1, heapTotal: -1 }
       }
 
-      this.emit('service:worker:health', {
+      this.emit('application:worker:health', {
         id: worker[kId],
-        service: id,
+        application: id,
         worker: index,
         currentHealth: health,
         unhealthy,
@@ -1367,14 +1512,14 @@ class Runtime extends EventEmitter {
 
       if (unhealthyChecks === maxUnhealthyChecks) {
         try {
-          this.emit('service:worker:unhealthy', { service: id, worker: index })
+          this.emit('application:worker:unhealthy', { application: id, worker: index })
 
           this.logger.error(
             { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
             `The ${errorLabel} is unhealthy. Replacing it ...`
           )
 
-          await this.#replaceWorker(config, serviceConfig, workersCount, id, index, worker)
+          await this.#replaceWorker(config, applicationConfig, workersCount, id, index, worker)
         } catch (e) {
           this.logger.error(
             { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
@@ -1391,7 +1536,7 @@ class Runtime extends EventEmitter {
 
   async #startWorker (
     config,
-    serviceConfig,
+    applicationConfig,
     workersCount,
     id,
     index,
@@ -1410,16 +1555,16 @@ class Runtime extends EventEmitter {
       worker = await this.#getWorkerById(id, index, false, false)
     }
 
-    const eventPayload = { service: id, worker: index, workersCount }
+    const eventPayload = { application: id, worker: index, workersCount }
 
-    // The service was stopped, recreate the thread
+    // The application was stopped, recreate the thread
     if (!worker) {
-      await this.#setupService(serviceConfig, index)
+      await this.#setupApplication(applicationConfig, index)
       worker = await this.#getWorkerById(id, index)
     }
 
     worker[kWorkerStatus] = 'starting'
-    this.emit('service:worker:starting', eventPayload)
+    this.emit('application:worker:starting', eventPayload)
 
     try {
       let workerUrl
@@ -1427,10 +1572,10 @@ class Runtime extends EventEmitter {
         workerUrl = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
 
         if (workerUrl === kTimeout) {
-          this.emit('service:worker:startTimeout', eventPayload)
+          this.emit('application:worker:startTimeout', eventPayload)
           this.logger.info(`The ${label} failed to start in ${config.startTimeout}ms. Forcefully killing the thread.`)
           worker.terminate()
-          throw new errors.ServiceStartTimeoutError(id, config.startTimeout)
+          throw new ApplicationStartTimeoutError(id, config.startTimeout)
         }
       } else {
         workerUrl = await sendViaITC(worker, 'start')
@@ -1443,7 +1588,7 @@ class Runtime extends EventEmitter {
       }
 
       worker[kWorkerStatus] = 'started'
-      this.emit('service:worker:started', eventPayload)
+      this.emit('application:worker:started', eventPayload)
       this.#broadcastWorkers()
 
       if (!silent) {
@@ -1456,7 +1601,7 @@ class Runtime extends EventEmitter {
         // however, the health event will start when the worker is started
         this.#setupHealthCheck(
           config,
-          serviceConfig,
+          applicationConfig,
           workersCount,
           id,
           index,
@@ -1467,6 +1612,7 @@ class Runtime extends EventEmitter {
       }
     } catch (err) {
       const error = ensureError(err)
+      worker[kITC].notify('application:worker:start:processed')
 
       // TODO: handle port allocation error here
       if (error.code === 'EADDRINUSE' || error.code === 'EACCES') throw error
@@ -1474,21 +1620,21 @@ class Runtime extends EventEmitter {
       this.#cleanupWorker(worker)
 
       if (worker[kWorkerStatus] !== 'exited') {
-        // This prevent the exit handler to restart service
+        // This prevent the exit handler to restart application
         worker[kWorkerStatus] = 'exited'
 
         // Wait for the worker to exit gracefully, otherwise we terminate it
-        const waitTimeout = await executeWithTimeout(once(worker, 'exit'), config.gracefulShutdown.service)
+        const waitTimeout = await executeWithTimeout(once(worker, 'exit'), config.gracefulShutdown.application)
 
         if (waitTimeout === kTimeout) {
           await worker.terminate()
         }
       }
 
-      this.emit('service:worker:start:error', { ...eventPayload, error })
+      this.emit('application:worker:start:error', { ...eventPayload, error })
 
-      if (error.code !== 'PLT_RUNTIME_SERVICE_START_TIMEOUT') {
-        this.logger.error({ err: ensureLoggableError(error) }, `Failed to start ${label}.`)
+      if (error.code !== 'PLT_RUNTIME_APPLICATION_START_TIMEOUT') {
+        this.logger.error({ err: ensureLoggableError(error) }, `Failed to start ${label}: ${error.message}`)
       }
 
       const restartOnError = config.restartOnError
@@ -1499,6 +1645,7 @@ class Runtime extends EventEmitter {
 
       if (bootstrapAttempt++ >= MAX_BOOTSTRAP_ATTEMPTS || restartOnError === 0) {
         this.logger.error(`Failed to start ${label} after ${MAX_BOOTSTRAP_ATTEMPTS} attempts.`)
+        this.emit('application:worker:start:failed', { ...eventPayload, error })
         throw error
       }
 
@@ -1512,11 +1659,11 @@ class Runtime extends EventEmitter {
         )
       }
 
-      await this.#restartCrashedWorker(config, serviceConfig, workersCount, id, index, silent, bootstrapAttempt)
+      await this.#restartCrashedWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
     }
   }
 
-  async #stopWorker (workersCount, id, index, silent, worker = undefined) {
+  async #stopWorker (workersCount, id, index, silent, worker, dependents) {
     if (!worker) {
       worker = await this.#getWorkerById(id, index, false, false)
     }
@@ -1530,11 +1677,11 @@ class Runtime extends EventEmitter {
       return this.#discardWorker(worker)
     }
 
-    const eventPayload = { service: id, worker: index, workersCount }
+    const eventPayload = { application: id, worker: index, workersCount }
 
     worker[kWorkerStatus] = 'stopping'
     worker[kITC].removeAllListeners('changed')
-    this.emit('service:worker:stopping', eventPayload)
+    this.emit('application:worker:stopping', eventPayload)
 
     const label = this.#workerExtendedLabel(id, index, workersCount)
 
@@ -1547,11 +1694,15 @@ class Runtime extends EventEmitter {
 
     // Always send the stop message, it will shut down workers that only had ITC and interceptors setup
     try {
-      await executeWithTimeout(sendViaITC(worker, 'stop'), exitTimeout)
+      await executeWithTimeout(sendViaITC(worker, 'stop', { force: !!this.error, dependents }), exitTimeout)
     } catch (error) {
-      this.emit('service:worker:stop:timeout', eventPayload)
+      this.emit('application:worker:stop:error', eventPayload)
       this.logger.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
     } finally {
+      worker[kITC].notify('application:worker:stop:processed')
+      // Wait for the processed message to be received
+      await sleep(1)
+
       worker[kITC].close()
     }
 
@@ -1559,19 +1710,19 @@ class Runtime extends EventEmitter {
       this.logger.info(`Stopped the ${label}...`)
     }
 
-    // Wait for the worker thread to finish, we're going to create a new one if the service is ever restarted
+    // Wait for the worker thread to finish, we're going to create a new one if the application is ever restarted
     const res = await executeWithTimeout(exitPromise, exitTimeout)
 
     // If the worker didn't exit in time, kill it
     if (res === kTimeout) {
-      this.emit('service:worker:exit:timeout', eventPayload)
+      this.emit('application:worker:exit:timeout', eventPayload)
       await worker.terminate()
     }
 
     await this.#avoidOutOfOrderThreadLogs()
 
     worker[kWorkerStatus] = 'stopped'
-    this.emit('service:worker:stopped', eventPayload)
+    this.emit('application:worker:stopped', eventPayload)
     this.#broadcastWorkers()
   }
 
@@ -1588,18 +1739,20 @@ class Runtime extends EventEmitter {
   }
 
   async #discardWorker (worker) {
-    this.#meshInterceptor.unroute(worker[kServiceId], worker, true)
+    this.#meshInterceptor.unroute(worker[kApplicationId], worker, true)
     worker.removeAllListeners('exit')
     await worker.terminate()
 
     return this.#cleanupWorker(worker)
   }
 
-  #workerExtendedLabel (serviceId, workerId, workersCount) {
-    return workersCount > 1 ? `worker ${workerId} of the service "${serviceId}"` : `service "${serviceId}"`
+  #workerExtendedLabel (applicationId, workerId, workersCount) {
+    return workersCount > 1
+      ? `worker ${workerId} of the application "${applicationId}"`
+      : `application "${applicationId}"`
   }
 
-  async #restartCrashedWorker (config, serviceConfig, workersCount, id, index, silent, bootstrapAttempt) {
+  async #restartCrashedWorker (config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt) {
     const workerId = `${id}:${index}`
 
     let restartPromise = this.#restartingWorkers.get(workerId)
@@ -1619,8 +1772,8 @@ class Runtime extends EventEmitter {
         }
 
         try {
-          await this.#setupWorker(config, serviceConfig, workersCount, id, index)
-          await this.#startWorker(config, serviceConfig, workersCount, id, index, silent, bootstrapAttempt)
+          await this.#setupWorker(config, applicationConfig, workersCount, id, index)
+          await this.#startWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
 
           this.logger.info(
             `The ${this.#workerExtendedLabel(id, index, workersCount)} has been successfully restarted ...`
@@ -1647,13 +1800,13 @@ class Runtime extends EventEmitter {
     await restartPromise
   }
 
-  async #replaceWorker (config, serviceConfig, workersCount, serviceId, index, worker) {
-    const workerId = `${serviceId}:${index}`
+  async #replaceWorker (config, applicationConfig, workersCount, applicationId, index, worker) {
+    const workerId = `${applicationId}:${index}`
     let newWorker
 
     try {
       // Create a new worker
-      newWorker = await this.#setupWorker(config, serviceConfig, workersCount, serviceId, index, false)
+      newWorker = await this.#setupWorker(config, applicationConfig, workersCount, applicationId, index, false)
 
       // Make sure the runtime hasn't been stopped in the meanwhile
       if (this.#status !== 'started') {
@@ -1661,7 +1814,7 @@ class Runtime extends EventEmitter {
       }
 
       // Add the worker to the mesh
-      await this.#startWorker(config, serviceConfig, workersCount, serviceId, index, false, 0, newWorker, true)
+      await this.#startWorker(config, applicationConfig, workersCount, applicationId, index, false, 0, newWorker, true)
 
       // Make sure the runtime hasn't been stopped in the meanwhile
       if (this.#status !== 'started') {
@@ -1669,7 +1822,7 @@ class Runtime extends EventEmitter {
       }
 
       this.#workers.set(workerId, newWorker)
-      this.#meshInterceptor.route(serviceId, newWorker)
+      this.#meshInterceptor.route(applicationId, newWorker)
 
       // Remove the old worker and then kill it
       await sendViaITC(worker, 'removeFromMesh')
@@ -1678,52 +1831,54 @@ class Runtime extends EventEmitter {
       throw e
     }
 
-    await this.#stopWorker(workersCount, serviceId, index, false, worker)
+    await this.#stopWorker(workersCount, applicationId, index, false, worker, [])
   }
 
-  async #getServiceById (serviceId, ensureStarted = false, mustExist = true) {
-    // If the serviceId includes the worker, properly split
+  async #getApplicationById (applicationId, ensureStarted = false, mustExist = true) {
+    // If the applicationId includes the worker, properly split
     let workerId
-    const matched = serviceId.match(/^(.+):(\d+)$/)
+    const matched = applicationId.match(/^(.+):(\d+)$/)
 
     if (matched) {
-      serviceId = matched[1]
+      applicationId = matched[1]
       workerId = matched[2]
     }
 
-    return this.#getWorkerById(serviceId, workerId, ensureStarted, mustExist)
+    return this.#getWorkerById(applicationId, workerId, ensureStarted, mustExist)
   }
 
-  async #getWorkerById (serviceId, workerId, ensureStarted = false, mustExist = true) {
+  async #getWorkerById (applicationId, workerId, ensureStarted = false, mustExist = true) {
     let worker
 
     if (typeof workerId !== 'undefined') {
-      worker = this.#workers.get(`${serviceId}:${workerId}`)
+      worker = this.#workers.get(`${applicationId}:${workerId}`)
     } else {
-      worker = this.#workers.next(serviceId)
+      worker = this.#workers.next(applicationId)
     }
 
+    const applicationsIds = this.getApplicationsIds()
+
     if (!worker) {
-      if (!mustExist && this.#servicesIds.includes(serviceId)) {
+      if (!mustExist && applicationsIds.includes(applicationId)) {
         return null
       }
 
-      if (this.#servicesIds.includes(serviceId)) {
+      if (applicationsIds.includes(applicationId)) {
         const availableWorkers = Array.from(this.#workers.keys())
-          .filter(key => key.startsWith(serviceId + ':'))
+          .filter(key => key.startsWith(applicationId + ':'))
           .map(key => key.split(':')[1])
           .join(', ')
-        throw new errors.WorkerNotFoundError(workerId, serviceId, availableWorkers)
+        throw new WorkerNotFoundError(workerId, applicationId, availableWorkers)
       } else {
-        throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
+        throw new ApplicationNotFoundError(applicationId, applicationsIds.join(', '))
       }
     }
 
     if (ensureStarted) {
-      const serviceStatus = await sendViaITC(worker, 'getStatus')
+      const applicationStatus = await sendViaITC(worker, 'getStatus')
 
-      if (serviceStatus !== 'started') {
-        throw new errors.ServiceNotStartedError(serviceId)
+      if (applicationStatus !== 'started') {
+        throw new ApplicationNotStartedError(applicationId)
       }
     }
 
@@ -1744,17 +1899,17 @@ class Runtime extends EventEmitter {
         continue
       }
 
-      const service = worker[kServiceId]
-      let serviceWorkers = workers.get(service)
+      const application = worker[kApplicationId]
+      let applicationWorkers = workers.get(application)
 
-      if (!serviceWorkers) {
-        serviceWorkers = []
-        workers.set(service, serviceWorkers)
+      if (!applicationWorkers) {
+        applicationWorkers = []
+        workers.set(application, applicationWorkers)
       }
 
-      serviceWorkers.push({
+      applicationWorkers.push({
         id: worker[kId],
-        service: worker[kServiceId],
+        application: worker[kApplicationId],
         worker: worker[kWorkerId],
         thread: worker.threadId
       })
@@ -1767,8 +1922,8 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async #getWorkerMessagingChannel ({ service, worker }, context) {
-    const target = await this.#getWorkerById(service, worker, true, true)
+  async #getWorkerMessagingChannel ({ application, worker }, context) {
+    const target = await this.#getWorkerById(application, worker, true, true)
 
     const { port1, port2 } = new MessageChannel()
 
@@ -1779,11 +1934,11 @@ class Runtime extends EventEmitter {
     )
 
     if (response === kTimeout) {
-      throw new errors.MessagingError(service, 'Timeout while establishing a communication channel.')
+      throw new MessagingError(application, 'Timeout while establishing a communication channel.')
     }
 
     context.transferList = [port2]
-    this.emit('service:worker:messagingChannel', { service, worker })
+    this.emit('application:worker:messagingChannel', { application, worker })
     return port2
   }
 
@@ -1795,8 +1950,8 @@ class Runtime extends EventEmitter {
     return packageJson
   }
 
-  #handleWorkerStandardStreams (worker, serviceId, workerId) {
-    const binding = { name: serviceId }
+  #handleWorkerStandardStreams (worker, applicationId, workerId) {
+    const binding = { name: applicationId }
 
     if (typeof workerId !== 'undefined') {
       binding.worker = workerId
@@ -1893,187 +2048,83 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async getServiceResourcesInfo (id) {
-    const workers = this.#workers.getCount(id)
-
-    const worker = await this.#getWorkerById(id, 0, false, false)
-    const health = worker[kConfig].health
-
-    return { workers, health }
-  }
-
-  async #updateServiceConfigWorkers (serviceId, workers) {
-    this.logger.info(`Updating service "${serviceId}" config workers to ${workers}`)
+  async #updateApplicationConfigWorkers (applicationId, workers) {
+    this.logger.info(`Updating application "${applicationId}" config workers to ${workers}`)
 
-    this.#config.services.find(s => s.id === serviceId).workers = workers
-    const service = await this.#getServiceById(serviceId)
-    this.#workers.setCount(serviceId, workers)
-    service[kConfig].workers = workers
+    this.#config.applications.find(s => s.id === applicationId).workers = workers
+    const application = await this.#getApplicationById(applicationId)
+    this.#workers.setCount(applicationId, workers)
+    application[kConfig].workers = workers
 
     const promises = []
     for (const [workerId, worker] of this.#workers.entries()) {
-      if (workerId.startsWith(`${serviceId}:`)) {
-        promises.push(sendViaITC(worker, 'updateWorkersCount', { serviceId, workers }))
+      if (workerId.startsWith(`${applicationId}:`)) {
+        promises.push(sendViaITC(worker, 'updateWorkersCount', { applicationId, workers }))
       }
     }
 
     const results = await Promise.allSettled(promises)
     for (const result of results) {
       if (result.status === 'rejected') {
-        this.logger.error({ err: result.reason }, `Cannot update service "${serviceId}" workers`)
+        this.logger.error({ err: result.reason }, `Cannot update application "${applicationId}" workers`)
         throw result.reason
       }
     }
   }
 
-  async #updateServiceConfigHealth (serviceId, health) {
-    this.logger.info(`Updating service "${serviceId}" config health heap to ${JSON.stringify(health)}`)
+  async #updateApplicationConfigHealth (applicationId, health) {
+    this.logger.info(`Updating application "${applicationId}" config health heap to ${JSON.stringify(health)}`)
     const { maxHeapTotal, maxYoungGeneration } = health
 
-    const service = this.#config.services.find(s => s.id === serviceId)
+    const application = this.#config.applications.find(s => s.id === applicationId)
     if (maxHeapTotal) {
-      service.health.maxHeapTotal = maxHeapTotal
+      application.health.maxHeapTotal = maxHeapTotal
     }
     if (maxYoungGeneration) {
-      service.health.maxYoungGeneration = maxYoungGeneration
-    }
-  }
-
-  /**
-   * Updates the resources of the services, such as the number of workers and health configurations (e.g., heap memory settings).
-   *
-   * This function handles three update scenarios for each service:
-   *  1. **Updating workers only**: Adjusts the number of workers for the service.
-   *  2. **Updating health configurations only**: Updates health parameters like `maxHeapTotal` or `maxYoungGeneration`.
-   *  3. **Updating both workers and health configurations**: Scales the workers and also applies health settings.
-   *
-   * When updating both workers and health:
-   *  - **Scaling down workers**: Stops extra workers, then restarts the remaining workers with the previous settings.
-   *  - **Scaling up workers**: Starts new workers with the updated heap settings, then restarts the old workers with the updated settings.
-   *
-   * Scaling up new resources (workers and/or heap memory) may fails due to insufficient memory, in this case the operation may fail partially or entirely.
-   * Scaling down is expected to succeed without issues.
-   *
-   * @param {Array<Object>} updates - An array of objects that define the updates for each service.
-   * @param {string} updates[].service - The ID of the service to update.
-   * @param {number} [updates[].workers] - The desired number of workers for the service. If omitted, workers will not be updated.
-   * @param {Object} [updates[].health] - The health configuration to update for the service, which may include:
-   *   @param {string|number} [updates[].health.maxHeapTotal] - The maximum heap memory for the service. Can be a valid memory string (e.g., '1G', '512MB') or a number representing bytes.
-   *   @param {string|number} [updates[].health.maxYoungGeneration] - The maximum young generation memory for the service. Can be a valid memory string (e.g., '128MB') or a number representing bytes.
-   *
-   * @returns {Promise<Array<Object>>} - A promise that resolves to an array of reports for each service, detailing the success or failure of the operations:
-   *   - `service`: The service ID.
-   *   - `workers`: The workers' update report, including the current, new number of workers, started workers, and success status.
-   *   - `health`: The health update report, showing the current and new heap settings, updated workers, and success status.
-   *
-   * @example
-   * await runtime.updateServicesResources([
-   *   { service: 'service-1', workers: 2, health: { maxHeapTotal: '1G', maxYoungGeneration: '128 MB' } },
-   *   { service: 'service-2', health: { maxHeapTotal: '1G' } },
-   *   { service: 'service-3', workers: 2 },
-   * ])
-   *
-   * In this example:
-   * - `service-1` will have 2 workers and updated heap memory configurations.
-   * - `service-2` will have updated heap memory settings (without changing workers).
-   * - `service-3` will have its workers set to 2 but no change in memory settings.
-   *
-   * @throws {InvalidArgumentError} - Throws if any update parameter is invalid, such as:
-   *   - Missing service ID.
-   *   - Invalid worker count (not a positive integer).
-   *   - Invalid memory size format for `maxHeapTotal` or `maxYoungGeneration`.
-   * @throws {ServiceNotFoundError} - Throws if the specified service ID does not exist in the current service configuration.
-   */
-  async updateServicesResources (updates) {
-    if (this.#status === 'stopping' || this.#status === 'closed') {
-      this.logger.warn('Cannot update service resources when the runtime is stopping or closed')
-      return
-    }
-
-    const ups = await this.#validateUpdateServiceResources(updates)
-    const config = this.#config
-
-    const report = []
-    for (const update of ups) {
-      const { serviceId, config: serviceConfig, workers, health, currentWorkers, currentHealth } = update
-
-      if (workers && health) {
-        const r = await this.#updateServiceWorkersAndHealth(
-          serviceId,
-          config,
-          serviceConfig,
-          workers,
-          health,
-          currentWorkers,
-          currentHealth
-        )
-        report.push({
-          service: serviceId,
-          workers: r.workers,
-          health: r.health
-        })
-      } else if (health) {
-        const r = await this.#updateServiceHealth(
-          serviceId,
-          config,
-          serviceConfig,
-          currentWorkers,
-          currentHealth,
-          health
-        )
-        report.push({
-          service: serviceId,
-          health: r.health
-        })
-      } else if (workers) {
-        const r = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
-        report.push({
-          service: serviceId,
-          workers: r.workers
-        })
-      }
+      application.health.maxYoungGeneration = maxYoungGeneration
     }
-
-    return report
   }
 
-  async #validateUpdateServiceResources (updates) {
+  async #validateUpdateApplicationResources (updates) {
     if (!Array.isArray(updates)) {
-      throw new errors.InvalidArgumentError('updates', 'must be an array')
+      throw new InvalidArgumentError('updates', 'must be an array')
     }
     if (updates.length === 0) {
-      throw new errors.InvalidArgumentError('updates', 'must have at least one element')
+      throw new InvalidArgumentError('updates', 'must have at least one element')
     }
 
     const config = this.#config
     const validatedUpdates = []
     for (const update of updates) {
-      const { service: serviceId } = update
+      const { application: applicationId } = update
 
-      if (!serviceId) {
-        throw new errors.InvalidArgumentError('service', 'must be a string')
+      if (!applicationId) {
+        throw new InvalidArgumentError('application', 'must be a string')
       }
-      const serviceConfig = config.services.find(s => s.id === serviceId)
-      if (!serviceConfig) {
-        throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
+      const applicationConfig = config.applications.find(s => s.id === applicationId)
+      if (!applicationConfig) {
+        throw new ApplicationNotFoundError(applicationId, Array.from(this.getApplicationsIds()).join(', '))
       }
 
-      const { workers: currentWorkers, health: currentHealth } = await this.getServiceResourcesInfo(serviceId)
+      const { workers: currentWorkers, health: currentHealth } = await this.getApplicationResourcesInfo(applicationId)
 
       let workers
       if (update.workers !== undefined) {
         if (typeof update.workers !== 'number') {
-          throw new errors.InvalidArgumentError('workers', 'must be a number')
+          throw new InvalidArgumentError('workers', 'must be a number')
         }
         if (update.workers <= 0) {
-          throw new errors.InvalidArgumentError('workers', 'must be greater than 0')
+          throw new InvalidArgumentError('workers', 'must be greater than 0')
         }
         if (update.workers > MAX_WORKERS) {
-          throw new errors.InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
+          throw new InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
         }
 
         if (currentWorkers === update.workers) {
-          this.logger.warn({ serviceId, workers: update.workers }, 'No change in the number of workers for service')
+          this.logger.warn(
+            { applicationId, workers: update.workers },
+            'No change in the number of workers for application'
+          )
         } else {
           workers = update.workers
         }
@@ -2086,22 +2137,19 @@ class Runtime extends EventEmitter {
             try {
               maxHeapTotal = parseMemorySize(update.health.maxHeapTotal)
             } catch {
-              throw new errors.InvalidArgumentError('maxHeapTotal', 'must be a valid memory size')
+              throw new InvalidArgumentError('maxHeapTotal', 'must be a valid memory size')
             }
           } else if (typeof update.health.maxHeapTotal === 'number') {
             maxHeapTotal = update.health.maxHeapTotal
             if (update.health.maxHeapTotal <= 0) {
-              throw new errors.InvalidArgumentError('maxHeapTotal', 'must be greater than 0')
+              throw new InvalidArgumentError('maxHeapTotal', 'must be greater than 0')
             }
           } else {
-            throw new errors.InvalidArgumentError(
-              'maxHeapTotal',
-              'must be a number or a string representing a memory size'
-            )
+            throw new InvalidArgumentError('maxHeapTotal', 'must be a number or a string representing a memory size')
           }
 
           if (currentHealth.maxHeapTotal === maxHeapTotal) {
-            this.logger.warn({ serviceId, maxHeapTotal }, 'No change in the max heap total for service')
+            this.logger.warn({ applicationId, maxHeapTotal }, 'No change in the max heap total for application')
             maxHeapTotal = undefined
           }
         }
@@ -2111,22 +2159,25 @@ class Runtime extends EventEmitter {
             try {
               maxYoungGeneration = parseMemorySize(update.health.maxYoungGeneration)
             } catch {
-              throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be a valid memory size')
+              throw new InvalidArgumentError('maxYoungGeneration', 'must be a valid memory size')
             }
           } else if (typeof update.health.maxYoungGeneration === 'number') {
             maxYoungGeneration = update.health.maxYoungGeneration
             if (update.health.maxYoungGeneration <= 0) {
-              throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be greater than 0')
+              throw new InvalidArgumentError('maxYoungGeneration', 'must be greater than 0')
             }
           } else {
-            throw new errors.InvalidArgumentError(
+            throw new InvalidArgumentError(
               'maxYoungGeneration',
               'must be a number or a string representing a memory size'
             )
           }
 
           if (currentHealth.maxYoungGeneration && currentHealth.maxYoungGeneration === maxYoungGeneration) {
-            this.logger.warn({ serviceId, maxYoungGeneration }, 'No change in the max young generation for service')
+            this.logger.warn(
+              { applicationId, maxYoungGeneration },
+              'No change in the max young generation for application'
+            )
             maxYoungGeneration = undefined
           }
         }
@@ -2143,17 +2194,24 @@ class Runtime extends EventEmitter {
             health.maxYoungGeneration = maxYoungGeneration
           }
         }
-        validatedUpdates.push({ serviceId, config: serviceConfig, workers, health, currentWorkers, currentHealth })
+        validatedUpdates.push({
+          applicationId,
+          config: applicationConfig,
+          workers,
+          health,
+          currentWorkers,
+          currentHealth
+        })
       }
     }
 
     return validatedUpdates
   }
 
-  async #updateServiceWorkersAndHealth (
-    serviceId,
+  async #updateApplicationWorkersAndHealth (
+    applicationId,
     config,
-    serviceConfig,
+    applicationConfig,
     workers,
     health,
     currentWorkers,
@@ -2161,12 +2219,18 @@ class Runtime extends EventEmitter {
   ) {
     if (currentWorkers > workers) {
       // stop workers
-      const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
+      const reportWorkers = await this.#updateApplicationWorkers(
+        applicationId,
+        config,
+        applicationConfig,
+        workers,
+        currentWorkers
+      )
       // update heap for current workers
-      const reportHealth = await this.#updateServiceHealth(
-        serviceId,
+      const reportHealth = await this.#updateApplicationHealth(
+        applicationId,
         config,
-        serviceConfig,
+        applicationConfig,
         workers,
         currentHealth,
         health
@@ -2174,15 +2238,21 @@ class Runtime extends EventEmitter {
 
       return { workers: reportWorkers, health: reportHealth }
     } else {
-      // update service heap
-      await this.#updateServiceConfigHealth(serviceId, health)
+      // update application heap
+      await this.#updateApplicationConfigHealth(applicationId, health)
       // start new workers with new heap
-      const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
+      const reportWorkers = await this.#updateApplicationWorkers(
+        applicationId,
+        config,
+        applicationConfig,
+        workers,
+        currentWorkers
+      )
       // update heap for current workers
-      const reportHealth = await this.#updateServiceHealth(
-        serviceId,
+      const reportHealth = await this.#updateApplicationHealth(
+        applicationId,
         config,
-        serviceConfig,
+        applicationConfig,
         currentWorkers,
         currentHealth,
         health,
@@ -2193,10 +2263,10 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async #updateServiceHealth (
-    serviceId,
+  async #updateApplicationHealth (
+    applicationId,
     config,
-    serviceConfig,
+    applicationConfig,
     currentWorkers,
     currentHealth,
     health,
@@ -2209,16 +2279,16 @@ class Runtime extends EventEmitter {
     }
     try {
       if (updateConfig) {
-        await this.#updateServiceConfigHealth(serviceId, health)
+        await this.#updateApplicationConfigHealth(applicationId, health)
       }
 
       for (let i = 0; i < currentWorkers; i++) {
         this.logger.info(
           { health: { current: currentHealth, new: health } },
-          `Restarting service "${serviceId}" worker ${i} to update config health heap...`
+          `Restarting application "${applicationId}" worker ${i} to update config health heap...`
         )
 
-        const worker = await this.#getWorkerById(serviceId, i)
+        const worker = await this.#getWorkerById(applicationId, i)
         if (health.maxHeapTotal) {
           worker[kConfig].health.maxHeapTotal = health.maxHeapTotal
         }
@@ -2226,22 +2296,22 @@ class Runtime extends EventEmitter {
           worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration
         }
 
-        await this.#replaceWorker(config, serviceConfig, currentWorkers, serviceId, i, worker)
+        await this.#replaceWorker(config, applicationConfig, currentWorkers, applicationId, i, worker)
         report.updated.push(i)
         this.logger.info(
           { health: { current: currentHealth, new: health } },
-          `Restarted service "${serviceId}" worker ${i}`
+          `Restarted application "${applicationId}" worker ${i}`
         )
       }
       report.success = true
     } catch (err) {
       if (report.updated.length < 1) {
-        this.logger.error({ err }, 'Cannot update service health heap, no worker updated')
-        await this.#updateServiceConfigHealth(serviceId, currentHealth)
+        this.logger.error({ err }, 'Cannot update application health heap, no worker updated')
+        await this.#updateApplicationConfigHealth(applicationId, currentHealth)
       } else {
         this.logger.error(
           { err },
-          `Cannot update service health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`
+          `Cannot update application health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`
         )
       }
       report.success = false
@@ -2249,7 +2319,7 @@ class Runtime extends EventEmitter {
     return report
   }
 
-  async #updateServiceWorkers (serviceId, config, serviceConfig, workers, currentWorkers) {
+  async #updateApplicationWorkers (applicationId, config, applicationConfig, workers, currentWorkers) {
     const report = {
       current: currentWorkers,
       new: workers
@@ -2257,47 +2327,47 @@ class Runtime extends EventEmitter {
     if (currentWorkers < workers) {
       report.started = []
       try {
-        await this.#updateServiceConfigWorkers(serviceId, workers)
+        await this.#updateApplicationConfigWorkers(applicationId, workers)
         for (let i = currentWorkers; i < workers; i++) {
-          await this.#setupWorker(config, serviceConfig, workers, serviceId, i)
-          await this.#startWorker(config, serviceConfig, workers, serviceId, i, false, 0)
+          await this.#setupWorker(config, applicationConfig, workers, applicationId, i)
+          await this.#startWorker(config, applicationConfig, workers, applicationId, i, false, 0)
           report.started.push(i)
         }
         report.success = true
       } catch (err) {
         if (report.started.length < 1) {
-          this.logger.error({ err }, 'Cannot start service workers, no worker started')
-          await this.#updateServiceConfigWorkers(serviceId, currentWorkers)
+          this.logger.error({ err }, 'Cannot start application workers, no worker started')
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers)
         } else {
           this.logger.error(
             { err },
-            `Cannot start service workers, started workers: ${report.started.length} out of ${workers}`
+            `Cannot start application workers, started workers: ${report.started.length} out of ${workers}`
           )
-          await this.#updateServiceConfigWorkers(serviceId, currentWorkers + report.started.length)
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers + report.started.length)
         }
         report.success = false
       }
     } else {
-      // keep the current workers count until all the service workers are all stopped
+      // keep the current workers count until all the application workers are all stopped
       report.stopped = []
       try {
         for (let i = currentWorkers - 1; i >= workers; i--) {
-          const worker = await this.#getWorkerById(serviceId, i, false, false)
+          const worker = await this.#getWorkerById(applicationId, i, false, false)
           await sendViaITC(worker, 'removeFromMesh')
-          await this.#stopWorker(currentWorkers, serviceId, i, false, worker)
+          await this.#stopWorker(currentWorkers, applicationId, i, false, worker, [])
           report.stopped.push(i)
         }
-        await this.#updateServiceConfigWorkers(serviceId, workers)
+        await this.#updateApplicationConfigWorkers(applicationId, workers)
         report.success = true
       } catch (err) {
         if (report.stopped.length < 1) {
-          this.logger.error({ err }, 'Cannot stop service workers, no worker stopped')
+          this.logger.error({ err }, 'Cannot stop application workers, no worker stopped')
         } else {
           this.logger.error(
             { err },
-            `Cannot stop service workers, stopped workers: ${report.stopped.length} out of ${workers}`
+            `Cannot stop application workers, stopped workers: ${report.stopped.length} out of ${workers}`
           )
-          await this.#updateServiceConfigWorkers(serviceId, currentWorkers - report.stopped)
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers - report.stopped)
         }
         report.success = false
       }
@@ -2305,5 +2375,3 @@ class Runtime extends EventEmitter {
     return report
   }
 }
-
-module.exports = { Runtime }