@platformatic/runtime 3.54.0 → 3.56.0

package/lib/worker/controller.js

@@ -5,8 +5,19 @@ import {
   kHandledError,
   listRecognizedConfigurationFiles,
   loadConfiguration,
-  loadConfigurationModule
+  loadConfigurationModule,
+  mirrorGlobalDispatcherForBuiltinFetch
 } from '@platformatic/foundation'
+import {
+  getLogger,
+  getOnActiveResourcesEventLoop,
+  getOnHttpStatsConnected,
+  getOnHttpStatsFree,
+  getOnHttpStatsPending,
+  getOnHttpStatsQueued,
+  getOnHttpStatsRunning,
+  getOnHttpStatsSize
+} from '@platformatic/globals'
 import debounce from 'debounce'
 import { EventEmitter } from 'node:events'
 import { existsSync } from 'node:fs'
@@ -16,6 +27,7 @@ import { workerData } from 'node:worker_threads'
 import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
 import { ApplicationAlreadyStartedError, RuntimeNotStartedError } from '../errors.js'
 import { getApplicationUrl } from '../utils.js'
+import { markAsPlatformaticDispatcher, refreshGlobalDispatcher } from './interceptors.js'
 
 function fetchApplicationUrl (application, key) {
   if (!key.endsWith('_URL') || !application.id) {
@@ -28,7 +40,8 @@ function fetchApplicationUrl (application, key) {
 function handleUnhandled (app, type, err) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
 
-  globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
+  const logger = getLogger()
+  logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
 
   executeWithTimeout(app?.stop(), 1000)
     .catch()
@@ -141,7 +154,8 @@ export class Controller extends EventEmitter {
       }
     } catch (err) {
       if (err.validationErrors) {
-        globalThis.platformatic.logger.error(
+        const logger = getLogger()
+        logger.error(
           { err: ensureLoggableError(err) },
           'The application threw a validation error.'
         )
@@ -192,6 +206,9 @@ export class Controller extends EventEmitter {
 
     try {
       await this.capability.start({ listen })
+      if (refreshGlobalDispatcher()) {
+        this.#updateDispatcher()
+      }
       this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
@@ -243,18 +260,29 @@ export class Controller extends EventEmitter {
 
   async getMetrics ({ format }) {
     const dispatcher = getGlobalDispatcher()
-    if (globalThis.platformatic?.onHttpStatsFree && dispatcher?.stats) {
+    const onHttpStatsFree = getOnHttpStatsFree({ throwOnMissing: false })
+
+    if (onHttpStatsFree && dispatcher?.stats) {
+      const onHttpStatsConnected = getOnHttpStatsConnected()
+      const onHttpStatsPending = getOnHttpStatsPending()
+      const onHttpStatsQueued = getOnHttpStatsQueued()
+      const onHttpStatsRunning = getOnHttpStatsRunning()
+      const onHttpStatsSize = getOnHttpStatsSize()
+
       for (const url in dispatcher.stats) {
         const { free, connected, pending, queued, running, size } = dispatcher.stats[url]
-        globalThis.platformatic.onHttpStatsFree(url, free || 0)
-        globalThis.platformatic.onHttpStatsConnected(url, connected || 0)
-        globalThis.platformatic.onHttpStatsPending(url, pending || 0)
-        globalThis.platformatic.onHttpStatsQueued(url, queued || 0)
-        globalThis.platformatic.onHttpStatsRunning(url, running || 0)
-        globalThis.platformatic.onHttpStatsSize(url, size || 0)
+        onHttpStatsFree(url, free || 0)
+        onHttpStatsConnected(url, connected || 0)
+        onHttpStatsPending(url, pending || 0)
+        onHttpStatsQueued(url, queued || 0)
+        onHttpStatsRunning(url, running || 0)
+        onHttpStatsSize(url, size || 0)
       }
     }
-    globalThis.platformatic.onActiveResourcesEventLoop(getActiveResourcesInfo().length)
+    const onActiveResourcesEventLoop = getOnActiveResourcesEventLoop({ throwOnMissing: false })
+    if (onActiveResourcesEventLoop) {
+      onActiveResourcesEventLoop(getActiveResourcesInfo().length)
+    }
     return this.capability.getMetrics({ format })
   }
 
@@ -299,7 +327,8 @@ export class Controller extends EventEmitter {
   }
 
   #logAndThrow (err) {
-    globalThis.platformatic.logger.error(
+    const logger = getLogger()
+    logger.error(
       { err: ensureLoggableError(err) },
       err[kHandledError] ? err.message : 'The application threw an error.'
     )
@@ -325,7 +354,9 @@ export class Controller extends EventEmitter {
 
     const dispatcher = getGlobalDispatcher().compose(interceptor)
 
+    markAsPlatformaticDispatcher(dispatcher)
     setGlobalDispatcher(dispatcher)
+    mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
   }
 
   #setupHandlers () {
@@ -334,7 +365,8 @@ export class Controller extends EventEmitter {
 
     process.on('newListener', event => {
       if (event === 'uncaughtException' || event === 'unhandledRejection') {
-        globalThis.platformatic.logger.warn(
+        const logger = getLogger()
+        logger.warn(
           `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
         )
       }

package/lib/worker/health-signals.js

@@ -1,3 +1,4 @@
+import { getITC, updateGlobals } from '@platformatic/globals'
 import {
   HealthSignalMustBeObjectError,
   HealthSignalTypeMustBeStringError
@@ -60,7 +61,8 @@ export function initHealthSignalsApi (options = {}) {
           isSending = false
           try {
             const signals = queue.getAll()
-            await globalThis.platformatic.itc.send('sendHealthSignals', {
+            const itc = getITC()
+            await itc.send('sendHealthSignals', {
               workerId,
               signals
             })
@@ -76,5 +78,5 @@ export function initHealthSignalsApi (options = {}) {
     return promise
   }
 
-  globalThis.platformatic.sendHealthSignal = sendHealthSignal
+  updateGlobals({ sendHealthSignal })
 }

package/lib/worker/http-cache.js

@@ -1,7 +1,7 @@
+import { getClientSpansAls, getITC } from '@platformatic/globals'
 import { randomUUID } from 'node:crypto'
 import { Readable, Writable } from 'node:stream'
 import { interceptors } from 'undici'
-import { kITC } from './symbols.js'
 
 const kCacheIdHeader = Symbol('cacheIdHeader')
 const CACHE_ID_HEADER = 'x-plt-http-cache-id'
@@ -28,7 +28,7 @@ export class RemoteCacheStore {
       this.#logger.error(err, 'Error in onRequest http cache hook')
     }
 
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) return
 
     const sanitizedRequest = this.#sanitizeRequest(request)
@@ -68,7 +68,7 @@ export class RemoteCacheStore {
       value.headers = { ...value.headers, [CACHE_ID_HEADER]: cacheEntryId }
     }
 
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) throw new Error('Cannot write to cache without an ITC instance')
 
     const acc = []
@@ -96,7 +96,7 @@ export class RemoteCacheStore {
   }
 
   delete (request) {
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) throw new Error('Cannot delete from cache without an ITC instance')
 
     request = this.#sanitizeRequest(request)
@@ -120,7 +120,7 @@ export function httpCacheInterceptor (interceptorOpts) {
 
   // AsyncLocalStorage that contains a client http request span
   // Exists only when the nodejs capability telemetry is enabled
-  const clientSpansAls = globalThis.platformatic.clientSpansAls
+  const clientSpansAls = getClientSpansAls({ throwOnMissing: false })
 
   return originalDispatch => {
     const dispatch = (opts, handler) => {

package/lib/worker/interceptors.js

@@ -1,13 +1,46 @@
+import { getGlobalDispatcherFromKnownUndiciSymbols, mirrorGlobalDispatcherForBuiltinFetch } from '@platformatic/foundation'
+import {
+  getInterceptors,
+  getLogger,
+  getOnHttpCacheHit,
+  getOnHttpCacheMiss,
+  getOnHttpCacheRequest
+} from '@platformatic/globals'
 import { createTelemetryThreadInterceptorHooks } from '@platformatic/telemetry'
 import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { parentPort, workerData } from 'node:worker_threads'
-import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
+import { Agent, Client, Pool } from 'undici'
 import { wire } from 'undici-thread-interceptor'
 import { createChannelCreationHook } from '../policies.js'
 import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
-import { kInterceptors } from './symbols.js'
+
+const kPlatformaticGlobalDispatcher = Symbol.for('platformatic.undici.globalDispatcher')
+
+let composeRuntimeDispatcher
+
+export function markAsPlatformaticDispatcher (dispatcher) {
+  Object.defineProperty(dispatcher, kPlatformaticGlobalDispatcher, {
+    value: true,
+    enumerable: false,
+    configurable: true
+  })
+}
+
+export function refreshGlobalDispatcher () {
+  if (!composeRuntimeDispatcher) {
+    return false
+  }
+
+  const dispatcher = getGlobalDispatcherFromKnownUndiciSymbols()
+  if (!dispatcher || dispatcher[kPlatformaticGlobalDispatcher]) {
+    return false
+  }
+
+  composeRuntimeDispatcher(dispatcher)
+  return true
+}
 
 export async function setDispatcher (runtimeConfig) {
   const threadDispatcher = createThreadInterceptor(runtimeConfig)
@@ -27,15 +60,39 @@ export async function setDispatcher (runtimeConfig) {
 
   const dispatcherOpts = await getDispatcherOpts(runtimeConfig.undici)
 
-  setGlobalDispatcher(
-    new Agent(dispatcherOpts).compose([threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean))
-  )
+  function installDispatcher (baseDispatcher) {
+    const dispatcher = baseDispatcher.compose(
+      [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
+    )
+
+    markAsPlatformaticDispatcher(dispatcher)
+    mirrorGlobalDispatcherForBuiltinFetch(dispatcher, createLegacyDispatcher(dispatcher))
+    return dispatcher
+  }
+
+  composeRuntimeDispatcher = installDispatcher
+  installDispatcher(new Agent(dispatcherOpts))
 
   return { threadDispatcher }
 }
 
+function createLegacyDispatcher (dispatcher) {
+  const legacyDispatcher = globalThis[Symbol.for('undici.globalDispatcher.1')]
+  const currentDispatcher = globalThis[Symbol.for('undici.globalDispatcher.2')]
+
+  if (legacyDispatcher && legacyDispatcher !== currentDispatcher && legacyDispatcher.constructor?.name === 'Dispatcher1Wrapper') {
+    try {
+      return new legacyDispatcher.constructor(dispatcher)
+    } catch {
+      return dispatcher
+    }
+  }
+
+  return dispatcher
+}
+
 export async function updateUndiciInterceptors (undiciConfig) {
-  const updatableInterceptors = globalThis[kInterceptors]
+  const updatableInterceptors = getInterceptors()
   if (!updatableInterceptors) return
 
   if (Array.isArray(undiciConfig?.interceptors)) {
@@ -95,11 +152,7 @@ async function loadInterceptors (_require, interceptorsConfigs, key) {
 }
 
 async function loadInterceptor (_require, interceptorConfig, key) {
-  let updatableInterceptors = globalThis[kInterceptors]
-  if (!updatableInterceptors) {
-    updatableInterceptors = {}
-    globalThis[kInterceptors] = updatableInterceptors
-  }
+  const updatableInterceptors = getInterceptors()
 
   const { module, options } = interceptorConfig
 
@@ -196,24 +249,34 @@ function parseOrigins (origins) {
 
 function createHttpCacheInterceptor (runtimeConfig) {
   const httpCache = runtimeConfig.httpCache
+
   const cacheInterceptor = httpCacheInterceptor({
     store: new RemoteCacheStore({
       onRequest: opts => {
-        globalThis.platformatic?.onHttpCacheRequest?.(opts)
+        const onHttpCacheRequest = getOnHttpCacheRequest({ throwOnMissing: false })
+        if (onHttpCacheRequest) {
+          onHttpCacheRequest(opts)
+        }
       },
       onCacheHit: opts => {
-        globalThis.platformatic?.onHttpCacheHit?.(opts)
+        const onHttpCacheHit = getOnHttpCacheHit({ throwOnMissing: false })
+        if (onHttpCacheHit) {
+          onHttpCacheHit(opts)
+        }
       },
       onCacheMiss: opts => {
-        globalThis.platformatic?.onHttpCacheMiss?.(opts)
+        const onHttpCacheMiss = getOnHttpCacheMiss({ throwOnMissing: false })
+        if (onHttpCacheMiss) {
+          onHttpCacheMiss(opts)
+        }
       },
-      logger: globalThis.platformatic.logger
+      logger: getLogger()
     }),
     methods: httpCache.methods ?? ['GET', 'HEAD'],
     origins: parseOrigins(httpCache.origins),
     cacheByDefault: httpCache.cacheByDefault,
     type: httpCache.type,
-    logger: globalThis.platformatic.logger
+    logger: getLogger()
   })
   return cacheInterceptor
 }

package/lib/worker/itc.js

@@ -1,4 +1,5 @@
 import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout } from '@platformatic/foundation'
+import { getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
 import { initializeITCTelemetry, ITC } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
@@ -150,10 +151,10 @@ export async function waitEventFromITC (worker, event) {
 export async function setupITC (controller, application, dispatcher, sharedContext) {
   await initializeITCTelemetry()
 
-  const logger = globalThis.platformatic.logger
+  const logger = getLogger()
   const messaging = new MessagingITC(controller.applicationConfig.id, workerData.config, logger)
 
-  Object.assign(globalThis.platformatic ?? {}, {
+  updateGlobals({
     messaging: {
       handle: messaging.handle.bind(messaging),
       send: messaging.send.bind(messaging),
@@ -172,7 +173,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
           await once(controller, 'start')
         } else {
           // This gives a chance to a capability to perform custom logic
-          globalThis.platformatic.events.emit('start')
+          const events = getEvents()
+          events.emit('start')
 
           try {
             await controller.start()
@@ -205,7 +207,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
 
         if (force || status.startsWith('start')) {
           // This gives a chance to a capability to perform custom logic
-          globalThis.platformatic.events.emit('stop')
+          const events = getEvents()
+          events.emit('stop')
 
           await controller.stop(force, dependents)
         }
@@ -419,9 +422,16 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         // For service-based capabilities, expose the Fastify app
         replServer.context.app = controller.capability?.getApplication?.()
         replServer.context.capability = controller.capability
-        replServer.context.platformatic = globalThis.platformatic
+        replServer.context.platformatic = {
+          capability: controller.capability,
+          config: controller.config,
+          events: getEvents(),
+          itc,
+          logger: getLogger(),
+          messaging: getMessaging()
+        }
         replServer.context.config = controller.applicationConfig
-        replServer.context.logger = globalThis.platformatic?.logger
+        replServer.context.logger = getLogger()
 
         replServer.on('exit', () => {
           port.postMessage({ type: 'exit' })

package/lib/worker/main.js

@@ -3,15 +3,19 @@ import {
   buildPinoTimestamp,
   disablePinoDirectWrite,
   ensureLoggableError,
-  getPrivateSymbol
+  getPrivateSymbol,
+  parseMemorySize
 } from '@platformatic/foundation'
+import { getITC, getLogger, updateGlobals } from '@platformatic/globals'
 import { addPinoInstrumentation } from '@platformatic/telemetry'
+import { Buffer } from 'node:buffer'
 import { subscribe } from 'node:diagnostics_channel'
 import { EventEmitter } from 'node:events'
 import { ServerResponse } from 'node:http'
 import inspector from 'node:inspector'
 import { hostname } from 'node:os'
 import { join, resolve } from 'node:path'
+import { setDefaultHighWaterMark } from 'node:stream'
 import { pathToFileURL } from 'node:url'
 import { threadId, workerData } from 'node:worker_threads'
 import pino from 'pino'
@@ -22,11 +26,12 @@ import { initHealthSignalsApi } from './health-signals.js'
 import { setDispatcher } from './interceptors.js'
 import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
-import { kId, kITC, kStderrMarker } from './symbols.js'
+import { kStderrMarker } from './symbols.js'
 
 function handlePreInitializationUnhandled (type, err) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
-  globalThis.platformatic.logger.error(
+  const logger = getLogger()
+  logger.error(
     { err: ensureLoggableError(err) },
     `The ${label} threw an ${type} before initialization.`
   )
@@ -35,7 +40,8 @@ function handlePreInitializationUnhandled (type, err) {
 
 class ForwardingEventEmitter extends EventEmitter {
   emitAndNotify (event, ...args) {
-    globalThis.platformatic.itc.notify('event', { event, payload: args })
+    const itc = getITC()
+    itc.notify('event', { event, payload: args })
     return this.emit(event, ...args)
   }
 }
@@ -113,6 +119,36 @@ async function performPreloading (...sources) {
   }
 }
 
+function resolveHealthSize (runtimeConfig, applicationConfig, field, logger) {
+  const raw = applicationConfig.health?.[field] ?? runtimeConfig.health?.[field]
+  if (raw === undefined) {
+    return undefined
+  }
+
+  const size = typeof raw === 'string' ? parseMemorySize(raw) : raw
+
+  if (!Number.isInteger(size) || size < 0) {
+    logger.warn({ [field]: raw }, `Invalid health.${field}, ignoring`)
+    return undefined
+  }
+
+  return size
+}
+
+function setupBufferPool (runtimeConfig, applicationConfig, logger) {
+  const size = resolveHealthSize(runtimeConfig, applicationConfig, 'bufferPoolSize', logger)
+  if (size !== undefined) {
+    Buffer.poolSize = size
+  }
+}
+
+function setupDefaultHighWaterMark (runtimeConfig, applicationConfig, logger) {
+  const size = resolveHealthSize(runtimeConfig, applicationConfig, 'defaultHighWaterMark', logger)
+  if (size !== undefined) {
+    setDefaultHighWaterMark(false, size)
+  }
+}
+
 // Enable compile cache if configured (Node.js 22.1.0+)
 async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
   // Normalize boolean shorthand: true -> { enabled: true }
@@ -168,8 +204,9 @@ async function main () {
   const cleanup = setupHandlers()
 
   installUndiciGlobals(globalThis)
-  globalThis[kId] = threadId
-  globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
+  updateGlobals({
+    runtimeId: threadId,
+    interceptors: {},
     logger: createLogger(),
     events: new ForwardingEventEmitter()
   })
@@ -177,8 +214,11 @@ async function main () {
   const runtimeConfig = workerData.config
   const applicationConfig = workerData.applicationConfig
 
+  setupBufferPool(runtimeConfig, applicationConfig, getLogger())
+  setupDefaultHighWaterMark(runtimeConfig, applicationConfig, getLogger())
+
   // Enable compile cache early before loading user modules
-  await setupCompileCache(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
+  await setupCompileCache(runtimeConfig, applicationConfig, getLogger())
 
   await performPreloading(runtimeConfig, applicationConfig)
 
@@ -190,7 +230,8 @@ async function main () {
     envfile = resolve(workerData.applicationConfig.path, '.env')
   }
 
-  globalThis.platformatic.logger.debug({ envfile }, 'Loading envfile...')
+  const logger = getLogger()
+  logger.debug({ envfile }, 'Loading envfile...')
 
   try {
     process.loadEnvFile(envfile)
@@ -265,15 +306,16 @@ async function main () {
 
   const sharedContext = new SharedContext()
   // Limit the amount of methods a user can call
-  globalThis.platformatic.sharedContext = {
-    get: () => sharedContext.get(),
-    update: (...args) => sharedContext.update(...args)
-  }
+  updateGlobals({
+    sharedContext: {
+      get: () => sharedContext.get(),
+      update: (...args) => sharedContext.update(...args)
+    }
+  })
 
   // Setup interaction with parent port
   const itc = await setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
-  globalThis[kITC] = itc
-  globalThis.platformatic.itc = itc
+  updateGlobals({ itc })
 
   // Setup management client for privileged applications
   if (applicationConfig.management) {
@@ -286,7 +328,7 @@ async function main () {
       const ops = typeof applicationConfig.management === 'object'
         ? applicationConfig.management.operations
         : undefined
-      globalThis.platformatic.management = new ManagementClient(ops)
+      updateGlobals({ management: new ManagementClient(ops) })
     }
   }
 

package/lib/worker/management.js

@@ -1,4 +1,4 @@
-import { kITC } from './symbols.js'
+import { getITC } from '@platformatic/globals'
 
 export class ManagementClient {
   #allowedOperations
@@ -14,7 +14,8 @@ export class ManagementClient {
       throw new Error(`Operation "${operation}" is not allowed`)
     }
 
-    return globalThis[kITC].send('management:' + operation, data)
+    const itc = getITC()
+    return itc.send('management:' + operation, data)
   }
 
   getRuntimeStatus () {

package/lib/worker/messaging.js

@@ -10,9 +10,10 @@ import {
   startOutgoingMessagingSpanSync,
   traceIncomingMessagingHandler
 } from '@platformatic/itc'
+import { getITC } from '@platformatic/globals'
 import { MessagingError } from '../errors.js'
 import { RoundRobinMap } from './round-robin-map.js'
-import { kITC, kWorkersBroadcast } from './symbols.js'
+import { kWorkersBroadcast } from './symbols.js'
 
 const kPendingResponses = Symbol('plt.messaging.pendingResponses')
 
@@ -76,7 +77,7 @@ export class MessagingITC extends ITC {
 
     try {
       // Get the next worker for the application
-      const worker = this.#workers.next(application)
+      const worker = this._getNextWorker(application)
 
       if (!worker) {
         throw new MessagingError(application, 'No workers available')
@@ -85,8 +86,9 @@ export class MessagingITC extends ITC {
       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 itc = getITC()
         const channel = await executeWithTimeout(
-          globalThis[kITC].send('getWorkerMessagingChannel', {
+          itc.send('getWorkerMessagingChannel', {
             id: this.#id,
             application: worker.application,
             worker: worker.worker
@@ -100,10 +102,7 @@ export class MessagingITC extends ITC {
         }
 
         worker.channel = channel
-        this.#setupChannel(channel)
-
-        channel[kPendingResponses] = new Map()
-        channel.on('close', this.#handlePendingResponse.bind(this, channel))
+        this._setupChannel(channel)
       }
 
       const context = { ...options }
@@ -164,13 +163,11 @@ export class MessagingITC extends ITC {
 
   async addSource (channel) {
     this.#sources.add(channel)
-    this.#setupChannel(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)
-    })
+  _getNextWorker (application) {
+    return this.#workers.next(application)
   }
 
   _send (request, context) {
@@ -181,7 +178,7 @@ export class MessagingITC extends ITC {
       channel[kPendingResponses].set(request.reqId, { application, request })
     }
 
-    channel.postMessage(sanitize(request, transferList), { transferList })
+    channel.postMessage(sanitize(request, transferList), transferList)
   }
 
   _createClosePromise () {
@@ -209,11 +206,22 @@ export class MessagingITC extends ITC {
     this.#sources.clear()
   }
 
-  #setupChannel (channel) {
+  _setupChannel (channel) {
+    if (channel[kPendingResponses]) {
+      return
+    }
+
+    channel[kPendingResponses] = new Map()
+
     // Setup the message for processing
     channel.on('message', event => {
       this.#listener(event, { channel, message: event })
     })
+
+    channel.on('close', () => {
+      this.#sources.delete(channel)
+      this.#handlePendingResponse(channel)
+    })
   }
 
   #updateWorkers (event) {

package/lib/worker/shared-context.js

@@ -1,4 +1,4 @@
-import { kITC } from './symbols.js'
+import { getITC } from '@platformatic/globals'
 
 export class SharedContext {
   constructor () {
@@ -6,12 +6,14 @@ export class SharedContext {
   }
 
   update (context, options = {}) {
-    return globalThis[kITC].send('updateSharedContext', { ...options, context })
+    const itc = getITC()
+    return itc.send('updateSharedContext', { ...options, context })
   }
 
   get () {
     if (this.sharedContext === null) {
-      this.sharedContext = globalThis[kITC].send('getSharedContext')
+      const itc = getITC()
+      this.sharedContext = itc.send('getSharedContext')
     }
     return this.sharedContext
   }