@platformatic/runtime 2.70.0 → 2.70.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2700Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2701Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;
@@ -331,6 +331,7 @@ export type HttpsSchemasPlatformaticDevPlatformaticRuntime2700Json = {
     [k: string]: unknown;
   };
   serviceTimeout?: number | string;
+  messagingTimeout?: number | string;
   resolvedServicesBasePath?: string;
   env?: {
     [k: string]: string;

package/lib/errors.js

@@ -9,38 +9,108 @@ module.exports = {
   RuntimeExitedError: createError(`${ERROR_PREFIX}_RUNTIME_EXIT`, 'The runtime exited before the operation completed'),
   RuntimeAbortedError: createError(`${ERROR_PREFIX}_RUNTIME_ABORT`, 'The runtime aborted the operation'),
   // The following two use the same code as we only need to differentiate the label
-  ServiceExitedError: createError(`${ERROR_PREFIX}_SERVICE_EXIT`, 'The service "%s" exited prematurely with error code %d'),
-  WorkerExitedError: createError(`${ERROR_PREFIX}_SERVICE_EXIT`, 'The worker %s of the service "%s" exited prematurely with error code %d'),
-  UnknownRuntimeAPICommandError: createError(`${ERROR_PREFIX}_UNKNOWN_RUNTIME_API_COMMAND`, 'Unknown Runtime API command "%s"'),
-  ServiceNotFoundError: createError(`${ERROR_PREFIX}_SERVICE_NOT_FOUND`, 'Service %s not found. Available services are: %s'),
-  ServiceWorkerNotFoundError: createError(`${ERROR_PREFIX}_SERVICE_WORKER_NOT_FOUND`, 'Service %s worker %s not found'),
+  ServiceExitedError: createError(
+    `${ERROR_PREFIX}_SERVICE_EXIT`,
+    'The service "%s" exited prematurely with error code %d'
+  ),
+  WorkerExitedError: createError(
+    `${ERROR_PREFIX}_SERVICE_EXIT`,
+    'The worker %s of the service "%s" exited prematurely with error code %d'
+  ),
+  UnknownRuntimeAPICommandError: createError(
+    `${ERROR_PREFIX}_UNKNOWN_RUNTIME_API_COMMAND`,
+    'Unknown Runtime API command "%s"'
+  ),
+  ServiceNotFoundError: createError(
+    `${ERROR_PREFIX}_SERVICE_NOT_FOUND`,
+    'Service %s not found. Available services are: %s'
+  ),
+  WorkerNotFoundError: createError(
+    `${ERROR_PREFIX}_WORKER_NOT_FOUND`,
+    'Worker %s of service %s not found. Available services are: %s'
+  ),
   ServiceNotStartedError: createError(`${ERROR_PREFIX}_SERVICE_NOT_STARTED`, "Service with id '%s' is not started"),
-  ServiceStartTimeoutError: createError(`${ERROR_PREFIX}_SERVICE_START_TIMEOUT`, "Service with id '%s' failed to start in %dms."),
-  FailedToRetrieveOpenAPISchemaError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_OPENAPI_SCHEMA`, 'Failed to retrieve OpenAPI schema for service with id "%s": %s'),
-  FailedToRetrieveGraphQLSchemaError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_GRAPHQL_SCHEMA`, 'Failed to retrieve GraphQL schema for service with id "%s": %s'),
-  FailedToRetrieveMetaError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_META`, 'Failed to retrieve metadata for service with id "%s": %s'),
-  FailedToRetrieveMetricsError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_METRICS`, 'Failed to retrieve metrics for service with id "%s": %s'),
-  FailedToRetrieveHealthError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_HEALTH`, 'Failed to retrieve health for service with id "%s": %s'),
-  FailedToPerformCustomHealthCheckError: createError(`${ERROR_PREFIX}_FAILED_TO_PERFORM_CUSTOM_HEALTH_CHECK`, 'Failed to perform custom healthcheck for service with id "%s": %s'),
-  FailedToPerformCustomReadinessCheckError: createError(`${ERROR_PREFIX}_FAILED_TO_PERFORM_CUSTOM_READINESS_CHECK`, 'Failed to perform custom readiness check for service with id "%s": %s'),
-  ApplicationAlreadyStartedError: createError(`${ERROR_PREFIX}_APPLICATION_ALREADY_STARTED`, 'Application is already started'),
-  ApplicationNotStartedError: createError(`${ERROR_PREFIX}_APPLICATION_NOT_STARTED`, 'Application has not been started'),
-  ConfigPathMustBeStringError: createError(`${ERROR_PREFIX}_CONFIG_PATH_MUST_BE_STRING`, 'Config path must be a string'),
+  ServiceStartTimeoutError: createError(
+    `${ERROR_PREFIX}_SERVICE_START_TIMEOUT`,
+    "Service with id '%s' failed to start in %dms."
+  ),
+  FailedToRetrieveOpenAPISchemaError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_RETRIEVE_OPENAPI_SCHEMA`,
+    'Failed to retrieve OpenAPI schema for service with id "%s": %s'
+  ),
+  FailedToRetrieveGraphQLSchemaError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_RETRIEVE_GRAPHQL_SCHEMA`,
+    'Failed to retrieve GraphQL schema for service with id "%s": %s'
+  ),
+  FailedToRetrieveMetaError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_RETRIEVE_META`,
+    'Failed to retrieve metadata for service with id "%s": %s'
+  ),
+  FailedToRetrieveMetricsError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_RETRIEVE_METRICS`,
+    'Failed to retrieve metrics for service with id "%s": %s'
+  ),
+  FailedToRetrieveHealthError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_RETRIEVE_HEALTH`,
+    'Failed to retrieve health for service with id "%s": %s'
+  ),
+  FailedToPerformCustomHealthCheckError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_PERFORM_CUSTOM_HEALTH_CHECK`,
+    'Failed to perform custom healthcheck for service with id "%s": %s'
+  ),
+  FailedToPerformCustomReadinessCheckError: createError(
+    `${ERROR_PREFIX}_FAILED_TO_PERFORM_CUSTOM_READINESS_CHECK`,
+    'Failed to perform custom readiness check for service with id "%s": %s'
+  ),
+  ApplicationAlreadyStartedError: createError(
+    `${ERROR_PREFIX}_APPLICATION_ALREADY_STARTED`,
+    'Application is already started'
+  ),
+  ApplicationNotStartedError: createError(
+    `${ERROR_PREFIX}_APPLICATION_NOT_STARTED`,
+    'Application has not been started'
+  ),
+  ConfigPathMustBeStringError: createError(
+    `${ERROR_PREFIX}_CONFIG_PATH_MUST_BE_STRING`,
+    'Config path must be a string'
+  ),
   NoConfigFileFoundError: createError(`${ERROR_PREFIX}_NO_CONFIG_FILE_FOUND`, "No config file found for service '%s'"),
   InvalidEntrypointError: createError(`${ERROR_PREFIX}_INVALID_ENTRYPOINT`, "Invalid entrypoint: '%s' does not exist"),
   MissingEntrypointError: createError(`${ERROR_PREFIX}_MISSING_ENTRYPOINT`, 'Missing application entrypoint.'),
-  InvalidServicesWithWebError: createError(`${ERROR_PREFIX}_INVALID_SERVICES_WITH_WEB`, 'The "services" property cannot be used when the "web" property is also defined'),
+  InvalidServicesWithWebError: createError(
+    `${ERROR_PREFIX}_INVALID_SERVICES_WITH_WEB`,
+    'The "services" property cannot be used when the "web" property is also defined'
+  ),
   MissingDependencyError: createError(`${ERROR_PREFIX}_MISSING_DEPENDENCY`, 'Missing dependency: "%s"'),
-  InspectAndInspectBrkError: createError(`${ERROR_PREFIX}_INSPECT_AND_INSPECT_BRK`, '--inspect and --inspect-brk cannot be used together'),
-  InspectorPortError: createError(`${ERROR_PREFIX}_INSPECTOR_PORT`, 'Inspector port must be 0 or in range 1024 to 65535'),
+  InspectAndInspectBrkError: createError(
+    `${ERROR_PREFIX}_INSPECT_AND_INSPECT_BRK`,
+    '--inspect and --inspect-brk cannot be used together'
+  ),
+  InspectorPortError: createError(
+    `${ERROR_PREFIX}_INSPECTOR_PORT`,
+    'Inspector port must be 0 or in range 1024 to 65535'
+  ),
   InspectorHostError: createError(`${ERROR_PREFIX}_INSPECTOR_HOST`, 'Inspector host cannot be empty'),
-  CannotMapSpecifierToAbsolutePathError: createError(`${ERROR_PREFIX}_CANNOT_MAP_SPECIFIER_TO_ABSOLUTE_PATH`, 'Cannot map "%s" to an absolute path'),
-  NodeInspectorFlagsNotSupportedError: createError(`${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`, 'The Node.js inspector flags are not supported. Please use \'platformatic start --inspect\' instead.'),
-  FailedToUnlinkManagementApiSocket: createError(`${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`, 'Failed to unlink management API socket "%s"'),
+  CannotMapSpecifierToAbsolutePathError: createError(
+    `${ERROR_PREFIX}_CANNOT_MAP_SPECIFIER_TO_ABSOLUTE_PATH`,
+    'Cannot map "%s" to an absolute path'
+  ),
+  NodeInspectorFlagsNotSupportedError: createError(
+    `${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`,
+    "The Node.js inspector flags are not supported. Please use 'platformatic start --inspect' instead."
+  ),
+  FailedToUnlinkManagementApiSocket: createError(
+    `${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`,
+    'Failed to unlink management API socket "%s"'
+  ),
   LogFileNotFound: createError(`${ERROR_PREFIX}_LOG_FILE_NOT_FOUND`, 'Log file with index %s not found', 404),
   WorkerIsRequired: createError(`${ERROR_PREFIX}_REQUIRED_WORKER`, 'The worker parameter is required'),
   InvalidArgumentError: createError(`${ERROR_PREFIX}_INVALID_ARGUMENT`, 'Invalid argument: "%s"'),
+  MessagingError: createError(`${ERROR_PREFIX}_MESSAGING_ERROR`, 'Cannot send a message to service "%s": %s'),
 
   // TODO: should remove next one as it's not used anymore
-  CannotRemoveServiceOnUpdateError: createError(`${ERROR_PREFIX}_CANNOT_REMOVE_SERVICE_ON_UPDATE`, 'Cannot remove service "%s" when updating a Runtime'),
+  CannotRemoveServiceOnUpdateError: createError(
+    `${ERROR_PREFIX}_CANNOT_REMOVE_SERVICE_ON_UPDATE`,
+    'Cannot remove service "%s" when updating a Runtime'
+  )
 }

package/lib/runtime.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { ITC } = require('@platformatic/itc')
-const { features, ensureLoggableError, executeWithTimeout, deepmerge, parseMemorySize } = require('@platformatic/utils')
+const { features, ensureLoggableError, executeWithTimeout, deepmerge, parseMemorySize, kTimeout } = require('@platformatic/utils')
 const { once, EventEmitter } = require('node:events')
 const { createReadStream, watch, existsSync } = require('node:fs')
 const { readdir, readFile, stat, access } = require('node:fs/promises')
@@ -34,7 +34,8 @@ const {
   kConfig,
   kWorkerStatus,
   kStderrMarker,
-  kLastELU
+  kLastELU,
+  kWorkersBroadcast
 } = require('./worker/symbols')
 
 const fastify = require('fastify')
@@ -75,6 +76,8 @@ class Runtime extends EventEmitter {
   #prometheusServer
   #inspectorServer
   #workers
+  #workersBroadcastChannel
+  #workerITCHandlers
   #restartingWorkers
   #sharedHttpCache
   servicesConfigsPatches
@@ -107,6 +110,18 @@ class Runtime extends EventEmitter {
         stderr: new SonicBoom({ fd: process.stderr.fd })
       }
     }
+
+    this.#workerITCHandlers = {
+      getServiceMeta: this.getServiceMeta.bind(this),
+      listServices: () => this.#servicesIds,
+      getServices: this.getServices.bind(this),
+      getWorkers: this.getWorkers.bind(this),
+      getWorkerMessagingChannel: this.#getWorkerMessagingChannel.bind(this),
+      getHttpCacheValue: this.#getHttpCacheValue.bind(this),
+      setHttpCacheValue: this.#setHttpCacheValue.bind(this),
+      deleteHttpCacheValue: this.#deleteHttpCacheValue.bind(this),
+      invalidateHttpCache: this.invalidateHttpCache.bind(this)
+    }
   }
 
   async init () {
@@ -131,12 +146,15 @@ class Runtime extends EventEmitter {
 
     this.#isProduction = this.#configManager.args?.production ?? false
     this.#servicesIds = config.services.map(service => service.id)
+    this.#createWorkersBroadcastChannel()
 
     const workersConfig = []
     for (const service of config.services) {
       const count = service.workers ?? this.#configManager.current.workers
       if (count > 1 && service.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}`)
+        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}`
+        )
         workersConfig.push({ id: service.id, workers: 1 })
       } else {
         workersConfig.push({ id: service.id, workers: count })
@@ -226,6 +244,7 @@ class Runtime extends EventEmitter {
       throw new errors.MissingEntrypointError()
     }
     this.#updateStatus('starting')
+    this.#createWorkersBroadcastChannel()
 
     // Important: do not use Promise.all here since it won't properly manage dependencies
     try {
@@ -312,6 +331,7 @@ class Runtime extends EventEmitter {
     }
 
     await this.#meshInterceptor.close()
+    this.#workersBroadcastChannel?.close()
 
     this.#updateStatus('stopped')
   }
@@ -1211,6 +1231,8 @@ class Runtime extends EventEmitter {
       setImmediate(() => {
         if (started && (!config.watch || code !== 0)) {
           this.emit('service:worker:error', { ...eventPayload, code })
+          this.#broadcastWorkers()
+
           this.logger.warn(`The ${errorLabel} unexpectedly exited with code ${code}.`)
         }
 
@@ -1254,14 +1276,7 @@ class Runtime extends EventEmitter {
       name: workerId + '-runtime',
       port: worker,
       handlers: {
-        getServiceMeta: this.getServiceMeta.bind(this),
-        listServices: () => this.#servicesIds,
-        getServices: this.getServices.bind(this),
-        getWorkers: this.getWorkers.bind(this),
-        getHttpCacheValue: this.#getHttpCacheValue.bind(this),
-        setHttpCacheValue: this.#setHttpCacheValue.bind(this),
-        deleteHttpCacheValue: this.#deleteHttpCacheValue.bind(this),
-        invalidateHttpCache: this.invalidateHttpCache.bind(this),
+        ...this.#workerITCHandlers,
         setEventsForwarding (value) {
           worker[kForwardEvents] = value
         }
@@ -1286,7 +1301,7 @@ class Runtime extends EventEmitter {
             await this.startService(serviceId)
           }
 
-          this.logger?.info(`Service "${serviceId}" has been successfully reloaded ...`)
+          this.logger?.info(`The service "${serviceId}" has been successfully reloaded ...`)
 
           if (serviceConfig.entrypoint) {
             this.#showUrl()
@@ -1331,16 +1346,18 @@ class Runtime extends EventEmitter {
     if (features.node.worker.getHeapStatistics) {
       const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
       const currentELU = worker.performance.eventLoopUtilization()
-      const elu = worker.performance.eventLoopUtilization(currentELU, worker[kLastELU]).utilization
+      const elu = worker[kLastELU]
+        ? worker.performance.eventLoopUtilization(currentELU, worker[kLastELU])
+        : currentELU
       worker[kLastELU] = currentELU
-      return { elu, heapUsed, heapTotal }
+      return { elu: elu.utilization, heapUsed, heapTotal }
     }
 
     const health = await worker[kITC].send('getHealth')
     return health
   }
 
-  #setupHealthCheck (config, serviceConfig, workersCount, id, index, worker, errorLabel) {
+  #setupHealthCheck (config, serviceConfig, workersCount, id, index, worker, errorLabel, timeout) {
     // Clear the timeout when exiting
     worker.on('exit', () => clearTimeout(worker[kHealthCheckTimer]))
 
@@ -1350,6 +1367,10 @@ class Runtime extends EventEmitter {
     let unhealthyChecks = 0
 
     worker[kHealthCheckTimer] = setTimeout(async () => {
+      if (worker[kWorkerStatus] !== 'started') {
+        return
+      }
+
       let health, unhealthy, memoryUsage
       try {
         health = await this.#getHealth(worker)
@@ -1358,7 +1379,8 @@ class Runtime extends EventEmitter {
       } catch (err) {
         this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
         unhealthy = true
-        memoryUsage = 0
+        memoryUsage = -1
+        health = { elu: -1, heapUsed: -1, heapTotal: -1 }
       }
 
       const serviceId = worker[kServiceId]
@@ -1408,7 +1430,7 @@ class Runtime extends EventEmitter {
       } else {
         worker[kHealthCheckTimer].refresh()
       }
-    }, interval)
+    }, timeout ?? interval)
   }
 
   async #startWorker (
@@ -1448,7 +1470,7 @@ class Runtime extends EventEmitter {
       if (config.startTimeout > 0) {
         workerUrl = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
 
-        if (workerUrl === 'timeout') {
+        if (workerUrl === kTimeout) {
           this.emit('service:worker:startTimeout', eventPayload)
           this.logger.info(`The ${label} failed to start in ${config.startTimeout}ms. Forcefully killing the thread.`)
           worker.terminate()
@@ -1466,6 +1488,7 @@ class Runtime extends EventEmitter {
 
       worker[kWorkerStatus] = 'started'
       this.emit('service:worker:started', eventPayload)
+      this.#broadcastWorkers()
 
       if (!silent) {
         this.logger?.info(`Started the ${label}...`)
@@ -1473,12 +1496,9 @@ class Runtime extends EventEmitter {
 
       const { enabled, gracePeriod } = worker[kConfig].health
       if (enabled && config.restartOnError > 0) {
-        worker[kHealthCheckTimer] = setTimeout(
-          () => {
-            this.#setupHealthCheck(config, serviceConfig, workersCount, id, index, worker, label)
-          },
-          gracePeriod > 0 ? gracePeriod : 1
-        )
+        // if gracePeriod is 0, it will be set to 1 to start health checks immediately
+        // however, the health event will start when the worker is started
+        this.#setupHealthCheck(config, serviceConfig, workersCount, id, index, worker, label, gracePeriod > 0 ? gracePeriod : 1)
       }
     } catch (error) {
       // TODO: handle port allocation error here
@@ -1569,7 +1589,7 @@ class Runtime extends EventEmitter {
     const res = await executeWithTimeout(exitPromise, exitTimeout)
 
     // If the worker didn't exit in time, kill it
-    if (res === 'timeout') {
+    if (res === kTimeout) {
       this.emit('service:worker:exit:timeout', eventPayload)
       await worker.terminate()
     }
@@ -1578,6 +1598,7 @@ class Runtime extends EventEmitter {
 
     worker[kWorkerStatus] = 'stopped'
     this.emit('service:worker:stopped', eventPayload)
+    this.#broadcastWorkers()
   }
 
   #cleanupWorker (worker) {
@@ -1627,6 +1648,9 @@ class Runtime extends EventEmitter {
           await this.#setupWorker(config, serviceConfig, workersCount, id, index)
           await this.#startWorker(config, serviceConfig, workersCount, id, index, silent, bootstrapAttempt)
 
+          this.logger.info(
+            `The ${this.#workerExtendedLabel(id, index, workersCount)} has been successfully restarted ...`
+          )
           resolve()
         } catch (err) {
           // The runtime was stopped while the restart was happening, ignore any error.
@@ -1710,7 +1734,15 @@ class Runtime extends EventEmitter {
         return null
       }
 
-      throw new errors.ServiceWorkerNotFoundError(serviceId, workerId)
+      if (this.#servicesIds.includes(serviceId)) {
+        const availableWorkers = Array.from(this.#workers.keys())
+          .filter(key => key.startsWith(serviceId + ':'))
+          .map(key => key.split(':')[1])
+          .join(', ')
+        throw new errors.WorkerNotFoundError(workerId, serviceId, availableWorkers)
+      } else {
+        throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
+      }
     }
 
     if (ensureStarted) {
@@ -1724,6 +1756,59 @@ class Runtime extends EventEmitter {
     return worker
   }
 
+  async #createWorkersBroadcastChannel () {
+    this.#workersBroadcastChannel?.close()
+    this.#workersBroadcastChannel = new BroadcastChannel(kWorkersBroadcast)
+  }
+
+  async #broadcastWorkers () {
+    const workers = new Map()
+
+    // Create the list of workers
+    for (const worker of this.#workers.values()) {
+      if (worker[kWorkerStatus] !== 'started') {
+        continue
+      }
+
+      const service = worker[kServiceId]
+      let serviceWorkers = workers.get(service)
+
+      if (!serviceWorkers) {
+        serviceWorkers = []
+        workers.set(service, serviceWorkers)
+      }
+
+      serviceWorkers.push({
+        id: worker[kId],
+        service: worker[kServiceId],
+        worker: worker[kWorkerId],
+        thread: worker.threadId
+      })
+    }
+
+    this.#workersBroadcastChannel.postMessage(workers)
+  }
+
+  async #getWorkerMessagingChannel ({ service, worker }, context) {
+    const target = await this.#getWorkerById(service, worker, true, true)
+
+    const { port1, port2 } = new MessageChannel()
+
+    // Send the first port to the target
+    const response = await executeWithTimeout(
+      sendViaITC(target, 'saveMessagingChannel', port1, [port1]),
+      this.#configManager.current.messagingTimeout
+    )
+
+    if (response === kTimeout) {
+      throw new errors.MessagingError(service, 'Timeout while establishing a communication channel.')
+    }
+
+    context.transferList = [port2]
+    this.emit('service:worker:messagingChannel', { service, worker })
+    return port2
+  }
+
   async #getRuntimePackageJson () {
     const runtimeDir = this.#configManager.dirname
     const packageJsonPath = join(runtimeDir, 'package.json')
@@ -1829,7 +1914,8 @@ class Runtime extends EventEmitter {
         }
       }
 
-      const pinoLog = typeof message?.level === 'number' && typeof message?.time === 'number' && typeof message?.msg === 'string'
+      const pinoLog =
+        typeof message?.level === 'number' && typeof message?.time === 'number' && typeof message?.msg === 'string'
 
       // Directly write to the Pino destination
       if (pinoLog) {

package/lib/worker/itc.js

@@ -9,6 +9,7 @@ const { Unpromise } = require('@watchable/unpromise')
 const errors = require('../errors')
 const { updateUndiciInterceptors } = require('./interceptors')
 const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
+const { MessagingITC } = require('./messaging')
 
 async function safeHandleInITC (worker, fn) {
   try {
@@ -47,8 +48,8 @@ async function safeHandleInITC (worker, fn) {
   }
 }
 
-async function sendViaITC (worker, name, message) {
-  return safeHandleInITC(worker, () => worker[kITC].send(name, message))
+async function sendViaITC (worker, name, message, transferList) {
+  return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
 }
 
 async function waitEventFromITC (worker, event) {
@@ -56,6 +57,15 @@ async function waitEventFromITC (worker, event) {
 }
 
 function setupITC (app, service, dispatcher) {
+  const messaging = new MessagingITC(app.appConfig.id, workerData.config)
+
+  Object.assign(globalThis.platformatic ?? {}, {
+    messaging: {
+      handle: messaging.handle.bind(messaging),
+      send: messaging.send.bind(messaging)
+    }
+  })
+
   const itc = new ITC({
     name: app.appConfig.id + '-worker',
     port: parentPort,
@@ -96,6 +106,7 @@ function setupITC (app, service, dispatcher) {
 
         await dispatcher.interceptor.close()
         itc.close()
+        messaging.close()
       },
 
       async build () {
@@ -116,8 +127,10 @@ function setupITC (app, service, dispatcher) {
 
       async updateWorkersCount (data) {
         const { serviceId, workers } = data
-        const w = workerData.config.serviceMap.get(serviceId)
-        if (w) { w.workers = workers }
+        const worker = workerData.config.serviceMap.get(serviceId)
+        if (worker) {
+          worker.workers = workers
+        }
         workerData.serviceConfig.workers = workers
         workerData.worker.count = workers
       },
@@ -195,6 +208,10 @@ function setupITC (app, service, dispatcher) {
         } catch (err) {
           throw new errors.FailedToPerformCustomReadinessCheckError(service.id, err.message)
         }
+      },
+
+      saveMessagingChannel (channel) {
+        messaging.addSource(channel)
       }
     }
   })

package/lib/worker/messaging.js

@@ -0,0 +1,186 @@
+'use strict'
+
+const { withResolvers, executeWithTimeout, kTimeout } = require('@platformatic/utils')
+const { ITC, generateResponse, sanitize } = require('@platformatic/itc')
+const errors = require('../errors')
+const { RoundRobinMap } = require('./round-robin-map')
+const { kWorkersBroadcast, kITC } = require('./symbols')
+
+const kPendingResponses = Symbol('plt.messaging.pendingResponses')
+
+class MessagingITC extends ITC {
+  #timeout
+  #listener
+  #closeResolvers
+  #broadcastChannel
+  #workers
+  #sources
+
+  constructor (id, runtimeConfig) {
+    super({
+      throwOnMissingHandler: true,
+      name: `${id}-messaging`
+    })
+
+    this.#timeout = runtimeConfig.messagingTimeout
+    this.#workers = new RoundRobinMap()
+    this.#sources = new Set()
+
+    // Start listening on the BroadcastChannel for the list of services
+    this.#broadcastChannel = new BroadcastChannel(kWorkersBroadcast)
+    this.#broadcastChannel.onmessage = this.#updateWorkers.bind(this)
+
+    this.listen()
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+  }
+
+  handle (message, handler) {
+    if (typeof message === 'object') {
+      for (const [name, fn] of Object.entries(message)) {
+        super.handle(name, fn)
+      }
+    } else {
+      super.handle(message, handler)
+    }
+  }
+
+  async send (service, name, message, options) {
+    // Get the next worker for the service
+    const worker = this.#workers.next(service)
+
+    if (!worker) {
+      throw new errors.MessagingError(service, 'No workers available')
+    }
+
+    if (!worker.channel) {
+      // Use twice the value here as a fallback measure. The target handler in the main thread is forwarding
+      // the request to the worker, using executeWithTimeout with the user set timeout value.
+      const channel = await executeWithTimeout(
+        globalThis[kITC].send('getWorkerMessagingChannel', { service: worker.service, worker: worker.worker }),
+        this.#timeout * 2
+      )
+
+      /* c8 ignore next 3 - Hard to test */
+      if (channel === kTimeout) {
+        throw new errors.MessagingError(service, 'Timeout while waiting for a communication channel.')
+      }
+
+      worker.channel = channel
+      this.#setupChannel(channel)
+
+      channel[kPendingResponses] = new Map()
+      channel.on('close', this.#handlePendingResponse.bind(this, channel))
+    }
+
+    const context = { ...options }
+    context.channel = worker.channel
+    context.service = worker.service
+    context.trackResponse = true
+
+    const response = await executeWithTimeout(super.send(name, message, context), this.#timeout)
+
+    if (response === kTimeout) {
+      throw new errors.MessagingError(service, 'Timeout while waiting for a response.')
+    }
+
+    return response
+  }
+
+  async addSource (channel) {
+    this.#sources.add(channel)
+    this.#setupChannel(channel)
+
+    // This has been closed on the other side.
+    // Pending messages will be silently discarded by Node (as postMessage does not throw) so we don't need to handle them.
+    channel.on('close', () => {
+      this.#sources.delete(channel)
+    })
+  }
+
+  _send (request, context) {
+    const { channel, transferList } = context
+
+    if (context.trackResponse) {
+      const service = context.service
+      channel[kPendingResponses].set(request.reqId, { service, request })
+    }
+
+    channel.postMessage(sanitize(request, transferList), { transferList })
+  }
+
+  _createClosePromise () {
+    const { promise, resolve, reject } = withResolvers()
+    this.#closeResolvers = { resolve, reject }
+    return promise
+  }
+
+  _close () {
+    this.#closeResolvers.resolve()
+    this.#broadcastChannel.close()
+
+    for (const source of this.#sources) {
+      source.close()
+    }
+
+    for (const worker of this.#workers.values()) {
+      worker.channel?.close()
+    }
+
+    this.#sources.clear()
+  }
+
+  #setupChannel (channel) {
+    // Setup the message for processing
+    channel.on('message', event => {
+      this.#listener(event, { channel })
+    })
+  }
+
+  #updateWorkers (event) {
+    // Gather all existing channels by thread, it will make them reusable
+    const existingChannels = new Map()
+    for (const source of this.#workers.values()) {
+      existingChannels.set(source.thread, source.channel)
+    }
+
+    // Create a brand new map
+    this.#workers = new RoundRobinMap()
+
+    const instances = []
+    for (const [service, workers] of event.data) {
+      const count = workers.length
+      const next = Math.floor(Math.random() * count)
+
+      instances.push({ id: service, next, workers: count })
+
+      for (let i = 0; i < count; i++) {
+        const worker = workers[i]
+        const channel = existingChannels.get(worker.thread)
+
+        // Note i is not the worker index as in runtime, but the index in the list of current alive workers for the service
+        this.#workers.set(`${service}:${i}`, { ...worker, channel })
+      }
+    }
+
+    this.#workers.configure(instances)
+  }
+
+  #handlePendingResponse (channel) {
+    for (const { service, request } of channel[kPendingResponses].values()) {
+      this._emitResponse(
+        generateResponse(
+          request,
+          new errors.MessagingError(service, 'The communication channel was closed before receiving a response.'),
+          null
+        )
+      )
+    }
+
+    channel[kPendingResponses].clear()
+  }
+}
+
+module.exports = { MessagingITC }

package/lib/worker/round-robin-map.js

@@ -16,7 +16,7 @@ class RoundRobinMap extends Map {
     this.#instances = {}
 
     for (const service of services) {
-      this.#instances[service.id] = { next: 0, count: service.workers }
+      this.#instances[service.id] = { next: service.next ?? 0, count: service.workers }
     }
   }
 

package/lib/worker/symbols.js

@@ -14,6 +14,9 @@ const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
 // This string marker should be safe to use since it belongs to Unicode private area
 const kStderrMarker = '\ue002'
 
+// Note that this is used to create a BroadcastChannel so it must be a string
+const kWorkersBroadcast = 'plt.runtime.workers'
+
 module.exports = {
   kConfig,
   kId,
@@ -25,5 +28,6 @@ module.exports = {
   kLastELU,
   kWorkerStatus,
   kStderrMarker,
-  kInterceptors
+  kInterceptors,
+  kWorkersBroadcast
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.70.0",
+  "version": "2.70.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,12 +37,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.70.0",
-    "@platformatic/db": "2.70.0",
-    "@platformatic/node": "2.70.0",
-    "@platformatic/service": "2.70.0",
-    "@platformatic/sql-graphql": "2.70.0",
-    "@platformatic/sql-mapper": "2.70.0"
+    "@platformatic/composer": "2.70.1",
+    "@platformatic/node": "2.70.1",
+    "@platformatic/service": "2.70.1",
+    "@platformatic/sql-graphql": "2.70.1",
+    "@platformatic/sql-mapper": "2.70.1",
+    "@platformatic/db": "2.70.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -76,24 +76,24 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.70.0",
-    "@platformatic/generators": "2.70.0",
-    "@platformatic/metrics": "2.70.0",
-    "@platformatic/itc": "2.70.0",
-    "@platformatic/telemetry": "2.70.0",
-    "@platformatic/ts-compiler": "2.70.0",
-    "@platformatic/utils": "2.70.0",
-    "@platformatic/config": "2.70.0"
+    "@platformatic/config": "2.70.1",
+    "@platformatic/basic": "2.70.1",
+    "@platformatic/generators": "2.70.1",
+    "@platformatic/itc": "2.70.1",
+    "@platformatic/metrics": "2.70.1",
+    "@platformatic/telemetry": "2.70.1",
+    "@platformatic/ts-compiler": "2.70.1",
+    "@platformatic/utils": "2.70.1"
   },
   "scripts": {
     "test": "pnpm run lint && borp --concurrency=1 --timeout=1200000 && tsd",
-    "test:main": "borp --concurrency=1 --timeout=300000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
-    "test:api": "borp --concurrency=1 --timeout=300000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
-    "test:cli": "borp --concurrency=1 --timeout=300000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
-    "test:start": "borp --concurrency=1 --timeout=300000 test/start/*.test.js test/start/*.test.mjs",
+    "test:main": "borp --concurrency=1 --timeout=1200000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
+    "test:api": "borp --concurrency=1 --timeout=1200000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
+    "test:cli": "borp --concurrency=1 --timeout=1200000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
+    "test:start": "borp --concurrency=1 --timeout=1200000 test/start/*.test.js test/start/*.test.mjs",
     "test:multiple-workers": "borp --concurrency=1 --timeout=1200000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
     "test:types": "tsd",
-    "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=300000 && tsd",
+    "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=1200000 && tsd",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "pnpm run gen-schema && pnpm run gen-types",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.70.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.70.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -1568,6 +1568,18 @@
       ],
       "default": 300000
     },
+    "messagingTimeout": {
+      "anyOf": [
+        {
+          "type": "number",
+          "minimum": 1
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "default": 30000
+    },
     "resolvedServicesBasePath": {
       "type": "string",
       "default": "external"