@platformatic/runtime 3.55.0 → 3.56.0

package/index.d.ts

@@ -1,6 +1,7 @@
 import { FastifyError } from '@fastify/error'
 import { Configuration, ConfigurationOptions, logFatalError, parseArgs } from '@platformatic/foundation'
 import { BaseGenerator } from '@platformatic/generators'
+import { PlatformaticGlobal } from '@platformatic/globals'
 import { JSONSchemaType } from 'ajv'
 import * as colorette from 'colorette'
 import { Logger } from 'pino'
@@ -27,6 +28,12 @@ export interface ApplicationsCommands {
   help: Record<string, string | (() => string)>
 }
 
+export interface LoopbackMessagingOptions {
+  logger?: Logger
+  mount?: boolean
+  runtimeConfig?: { messagingTimeout?: number; [key: string]: unknown }
+}
+
 export namespace errors {
   export const RuntimeExitedError: () => FastifyError
   export const UnknownRuntimeAPICommandError: (command: string) => FastifyError
@@ -61,7 +68,6 @@ export namespace symbols {
   export const kWorkerStatus: unique symbol
   export const kWorkerHealthSignals: unique symbol
   export const kStderrMarker: string
-  export const kInterceptors: unique symbol
   export const kWorkersBroadcast: unique symbol
 }
 
@@ -191,3 +197,8 @@ export declare function transform (
 ): Promise<RuntimeConfiguration>
 
 export declare function loadApplicationsCommands (): Promise<ApplicationsCommands>
+
+export declare function setupLoopbackMessaging (
+  targetId: string,
+  options?: LoopbackMessagingOptions
+): PlatformaticGlobal['messaging'] & { unmount: () => void }

package/index.js

@@ -176,6 +176,7 @@ export async function create (configOrRoot, sourceOrConfig, context) {
 export { prepareApplication, transform, wrapInRuntimeConfig } from './lib/config.js'
 export * as errors from './lib/errors.js'
 export { RuntimeGenerator as Generator, WrappedGenerator } from './lib/generator.js'
+export { setupLoopbackMessaging } from './lib/loopback-messaging.js'
 export { Runtime } from './lib/runtime.js'
 export { schema } from './lib/schema.js'
 export * from './lib/version.js'

package/lib/config.js

@@ -18,8 +18,7 @@ import {
   InspectorHostError,
   InspectorPortError,
   InvalidArgumentError,
-  InvalidEntrypointError,
-  MissingEntrypointError
+  InvalidEntrypointError
 } from './errors.js'
 import { schema } from './schema.js'
 import { upgrade } from './upgrade.js'
@@ -438,15 +437,8 @@ export async function transform (config, _, context) {
     }
   }
 
-  if (!hasValidEntrypoint && !context.allowMissingEntrypoint) {
-    if (config.entrypoint) {
-      throw new InvalidEntrypointError(config.entrypoint)
-    } else if (applications.length >= 1) {
-      throw new MissingEntrypointError()
-    }
-    // If there are no applications, and no entrypoint it's an empty app.
-    // It won't start, but we should be able to parse and operate on it,
-    // like adding other applications.
+  if (!hasValidEntrypoint && config.entrypoint && !context.allowMissingEntrypoint) {
+    throw new InvalidEntrypointError(config.entrypoint)
   }
 
   if (typeof config.metrics === 'boolean') {

package/lib/errors.js

@@ -49,6 +49,10 @@ export const ApplicationStartTimeoutError = createError(
   `${ERROR_PREFIX}_APPLICATION_START_TIMEOUT`,
   "Application with id '%s' failed to start in %dms."
 )
+export const ApplicationDependencyNotFoundError = createError(
+  `${ERROR_PREFIX}_APPLICATION_DEPENDENCY_NOT_FOUND`,
+  'Application dependency %s not found. Available applications are: %s'
+)
 export const ApplicationsDependenciesCycleError = createError(
   `${ERROR_PREFIX}_APPLICATIONS_DEPENDENCIES_CYCLE`,
   'Detected a cycle in the applications dependencies: %s'

package/lib/generator.js

@@ -19,17 +19,6 @@ import { transform } from './config.js'
 import { schema } from './schema.js'
 import { getArrayDifference } from './utils.js'
 
-const wrappableProperties = {
-  logger: {
-    level: '{PLT_SERVER_LOGGER_LEVEL}'
-  },
-  server: {
-    hostname: '{PLT_SERVER_HOSTNAME}',
-    port: '{PORT}'
-  },
-  managementApi: '{PLT_MANAGEMENT_API}'
-}
-
 const engines = {
   node: '>=22.19.0'
 }
@@ -42,13 +31,36 @@ const NoApplicationNamedError = createError(
 )
 const NoEntryPointError = createError(`${ERROR_PREFIX}_NO_ENTRYPOINT`, 'No entrypoint had been defined.')
 
+function getRuntimeWrappableProperties (skipServer) {
+  const wrappableProperties = {
+    logger: {
+      level: '{PLT_SERVER_LOGGER_LEVEL}'
+    },
+    managementApi: '{PLT_MANAGEMENT_API}'
+  }
+
+  if (!skipServer) {
+    wrappableProperties.server = {
+      hostname: '{PLT_SERVER_HOSTNAME}',
+      port: '{PORT}'
+    }
+  }
+
+  return wrappableProperties
+}
+
 function getRuntimeBaseEnvVars (config) {
-  return {
-    PLT_SERVER_HOSTNAME: '127.0.0.1',
-    PORT: config.port || 3042,
-    PLT_SERVER_LOGGER_LEVEL: config.logLevel || 'info',
-    PLT_MANAGEMENT_API: true
+  const env = {}
+
+  if (!config.skipServer) {
+    env.PLT_SERVER_HOSTNAME = '127.0.0.1'
+    env.PORT = config.port || 3042
   }
+
+  env.PLT_SERVER_LOGGER_LEVEL = config.logLevel || 'info'
+  env.PLT_MANAGEMENT_API = true
+
+  return env
 }
 
 export class RuntimeGenerator extends BaseGenerator {
@@ -195,7 +207,7 @@ export class RuntimeGenerator extends BaseGenerator {
         path: this.config.autoload || this.applicationsFolder,
         exclude: ['docs']
       },
-      ...wrappableProperties
+      ...getRuntimeWrappableProperties(this.config.skipServer)
     }
 
     return config
@@ -251,13 +263,15 @@ export class RuntimeGenerator extends BaseGenerator {
       return
     }
 
-    // port
-    this.questions.push({
-      type: 'input',
-      name: 'port',
-      default: 3042,
-      message: 'What port do you want to use?'
-    })
+    if (!this.config.skipServer) {
+      // port
+      this.questions.push({
+        type: 'input',
+        name: 'port',
+        default: 3042,
+        message: 'What port do you want to use?'
+      })
+    }
   }
 
   setApplicationsDirectory () {
@@ -611,7 +625,7 @@ export class WrappedGenerator extends BaseGenerator {
   async #createConfigFile () {
     const config = {
       $schema: `https://schemas.platformatic.dev/${this.module}/${this.platformaticVersion}.json`,
-      runtime: wrappableProperties
+      runtime: getRuntimeWrappableProperties(this.config.skipServer)
     }
 
     this.addFile({

package/lib/loopback-messaging.js

@@ -0,0 +1,78 @@
+import { abstractLogger } from '@platformatic/foundation'
+import { getMessaging, removeGlobals, updateGlobals } from '@platformatic/globals'
+import { MessageChannel } from 'node:worker_threads'
+import { MessagingITC } from './worker/messaging.js'
+
+class LoopbackMessagingITC extends MessagingITC {
+  #application
+  #channel
+
+  constructor (id, application, runtimeConfig, logger, channel) {
+    super(id, runtimeConfig, logger)
+
+    this.#application = application
+    this.#channel = channel
+    this.addSource(channel)
+  }
+
+  // Force the next worker to be the channel
+  _getNextWorker () {
+    return { application: this.#application, channel: this.#channel }
+  }
+}
+
+class LoopbackMessaging extends LoopbackMessagingITC {
+  #target
+  #channel
+  #previousGlobals
+
+  constructor (targetId, config, logger) {
+    const channel = new MessageChannel()
+
+    super('loopback-messaging', targetId, config, logger, channel.port1)
+    this.#channel = channel
+    this.#target = new LoopbackMessagingITC(targetId, 'loopback-messaging', config, logger, channel.port2)
+  }
+
+  mount () {
+    this.#previousGlobals = getMessaging({ throwOnMissing: false })
+
+    updateGlobals({
+      messaging: {
+        handle: this.#target.handle.bind(this.#target),
+        send: this.#target.send.bind(this.#target),
+        notify: this.#target.notify.bind(this.#target)
+      }
+    })
+
+    return this
+  }
+
+  unmount () {
+    if (this.#previousGlobals) {
+      updateGlobals({ messaging: this.#previousGlobals })
+    } else {
+      removeGlobals(['messaging'])
+    }
+
+    this.close()
+    this.#target.close()
+    this.#channel.port1.close()
+    this.#channel.port2.close()
+  }
+}
+
+export function setupLoopbackMessaging (targetId, options) {
+  options ??= {}
+
+  const runtimeConfig = { ...(options.runtimeConfig ?? {}) }
+  runtimeConfig.messagingTimeout ??= 5000
+
+  const messaging = new LoopbackMessaging(targetId, runtimeConfig, options.logger ?? abstractLogger)
+
+  if (options.mount !== false) {
+    messaging.mount()
+  }
+
+  return messaging
+}

package/lib/management-api.js

@@ -9,7 +9,7 @@ import {
 } from '@platformatic/foundation'
 import fastify from 'fastify'
 import { platform, tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { createWebSocketStream } from 'ws'
 import { prepareApplication } from './config.js'
@@ -342,8 +342,8 @@ export async function startManagementApi (runtime, config) {
   const customSocket = typeof config === 'object' ? config?.socket : null
 
   const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
-  if (platform() !== 'win32' && !customSocket) {
-    await createDirectory(runtimePIDDir, true)
+  if (platform() !== 'win32') {
+    await createDirectory(customSocket ? dirname(customSocket) : runtimePIDDir, typeof customSocket !== 'string')
   }
 
   let socketPath = null

package/lib/runtime.js

@@ -9,6 +9,7 @@ import {
   kTimeout,
   parseMemorySize
 } from '@platformatic/foundation'
+import { getExecutable } from '@platformatic/globals'
 import { ITC } from '@platformatic/itc'
 import { collectProcessMetrics, client as metricsClient } from '@platformatic/metrics'
 import fastify from 'fastify'
@@ -36,7 +37,6 @@ import {
   CannotRemoveEntrypointError,
   InvalidArgumentError,
   MessagingError,
-  MissingEntrypointError,
   MissingPprofCapture,
   RuntimeAbortedError,
   WorkerInterceptorJoinTimeoutError,
@@ -274,14 +274,18 @@ export class Runtime extends EventEmitter {
       await this.init()
     }
 
-    if (typeof this.#config.entrypoint === 'undefined') {
-      throw new MissingEntrypointError()
-    }
     this.#updateStatus('starting')
     this.#createWorkersBroadcastChannel()
 
     try {
-      await this.startApplications(this.getApplicationsIds(), silent)
+      const applications = this.getApplicationsIds()
+      await this.startApplications(applications, silent)
+
+      if (applications.length === 0) {
+        this.#updateStatus('started')
+        await this.close(silent)
+        return
+      }
 
       if (this.#config.inspectorOptions) {
         const { port } = this.#config.inspectorOptions
@@ -327,7 +331,9 @@ export class Runtime extends EventEmitter {
     this.#startHealthMetricsCollectionIfNeeded()
 
     await this.#dynamicWorkersScaler?.start()
-    this.#showUrl()
+    if (this.#url) {
+      this.#showUrl()
+    }
     return this.#url
   }
 
@@ -582,7 +588,7 @@ export class Runtime extends EventEmitter {
 
     // Now, topological sort the applications based on their dependencies.
     // If circular dependencies are detected, an error with proper error code is thrown.
-    applications = topologicalSort(dependencies)
+    applications = topologicalSort(applications, dependencies)
 
     // Group into dependency levels so that each level's dependencies are all
     // in previous levels. Levels are started sequentially, but applications
@@ -1122,6 +1128,10 @@ export class Runtime extends EventEmitter {
   }
 
   async getEntrypointDetails () {
+    if (!this.#entrypointId) {
+      return null
+    }
+
     return this.getApplicationDetails(this.#entrypointId)
   }
 
@@ -1168,6 +1178,10 @@ export class Runtime extends EventEmitter {
   }
 
   async getMetrics (format = 'json') {
+    if (this.#config.metrics === false || this.#config.metrics?.enabled === false) {
+      throw new Error('Metrics are disabled')
+    }
+
     let metrics = null
 
     const applicationRestartMetrics = format === 'json'
@@ -1716,6 +1730,10 @@ export class Runtime extends EventEmitter {
   }
 
   #showUrl () {
+    if (!this.#url) {
+      return
+    }
+
     this.logger.info(`Platformatic is now listening at ${this.#url}`)
   }
 
@@ -1734,7 +1752,7 @@ export class Runtime extends EventEmitter {
         applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, id)
 
         if (!existsSync(applicationConfig.path)) {
-          const executable = globalThis.platformatic?.executable ?? 'platformatic'
+          const executable = getExecutable() ?? 'platformatic'
           this.logger.error(
             `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
             id
@@ -2713,6 +2731,12 @@ export class Runtime extends EventEmitter {
 
   async #createWorkersBroadcastChannel () {
     this.#workersBroadcastChannel?.close()
+
+    if (this.#config.applications.length === 0) {
+      this.#workersBroadcastChannel = undefined
+      return
+    }
+
     this.#workersBroadcastChannel = new BroadcastChannel(kWorkersBroadcast)
   }
 

package/lib/utils.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { ApplicationsDependenciesCycleError } from './errors.js'
+import { ApplicationDependencyNotFoundError, ApplicationsDependenciesCycleError } from './errors.js'
 
 export function getArrayDifference (a, b) {
   return a.filter(element => {
@@ -48,13 +48,22 @@ export function topologicalLevels (sorted, graph) {
   return levels
 }
 
-// Graph: Map<string, string[]>
-export function topologicalSort (graph) {
+// valid: string[] | Map<string, string[]>, graph?: Map<string, string[]>
+export function topologicalSort (valid, graph) {
+  if (!graph) {
+    graph = valid
+    valid = Array.from(graph.keys())
+  }
+
   const result = []
   const visited = new Set()
   const path = []
 
   function visit (node) {
+    if (!valid.includes(node)) {
+      throw new ApplicationDependencyNotFoundError(node, valid.join(', '))
+    }
+
     if (visited.has(node)) {
       return
     }

package/lib/worker/controller.js

@@ -8,6 +8,16 @@ import {
   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'
@@ -17,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) {
@@ -29,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()
@@ -142,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.'
         )
@@ -193,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) {
@@ -244,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 })
   }
 
@@ -300,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.'
     )
@@ -326,6 +354,7 @@ export class Controller extends EventEmitter {
 
     const dispatcher = getGlobalDispatcher().compose(interceptor)
 
+    markAsPlatformaticDispatcher(dispatcher)
     setGlobalDispatcher(dispatcher)
     mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
   }
@@ -336,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,14 +1,46 @@
-import { mirrorGlobalDispatcherForBuiltinFetch } from '@platformatic/foundation'
+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)
@@ -28,17 +60,39 @@ export async function setDispatcher (runtimeConfig) {
 
   const dispatcherOpts = await getDispatcherOpts(runtimeConfig.undici)
 
-  const dispatcher = new Agent(dispatcherOpts).compose(
-    [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
-  )
-  setGlobalDispatcher(dispatcher)
-  mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
+  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)) {
@@ -98,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
 
@@ -199,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

@@ -6,6 +6,7 @@ import {
   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'
@@ -25,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.`
   )
@@ -38,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)
   }
 }
@@ -201,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()
   })
@@ -210,11 +214,11 @@ async function main () {
   const runtimeConfig = workerData.config
   const applicationConfig = workerData.applicationConfig
 
-  setupBufferPool(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
-  setupDefaultHighWaterMark(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
+  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)
 
@@ -226,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)
@@ -301,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) {
@@ -322,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
   }

package/lib/worker/symbols.js

@@ -1,5 +1,5 @@
 export const kConfig = Symbol.for('plt.runtime.config')
-export const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
+export const kId = Symbol.for('plt.runtime.id')
 export const kFullId = Symbol.for('plt.runtime.fullId')
 export const kApplicationId = Symbol.for('plt.runtime.application.id')
 export const kWorkerId = Symbol.for('plt.runtime.worker.id')
@@ -8,7 +8,6 @@ export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
 export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
-export const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
 export const kLastHealthCheckELU = Symbol.for('plt.runtime.worker.lastHealthCheckELU')
 export const kLastWorkerScalerELU = Symbol.for('plt.runtime.worker.lastWorkerScalerELU')
 export const kInterceptorReadyPromise = Symbol.for('plt.runtime.worker.interceptorReadyPromise')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.55.0",
+  "version": "3.56.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -36,14 +36,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.55.0",
-    "@platformatic/composer": "3.55.0",
-    "@platformatic/node": "3.55.0",
-    "@platformatic/service": "3.55.0",
-    "@platformatic/sql-graphql": "3.55.0",
-    "@platformatic/gateway": "3.55.0",
-    "@platformatic/sql-mapper": "3.55.0",
-    "@platformatic/wattpm-pprof-capture": "3.55.0"
+    "@platformatic/composer": "3.56.0",
+    "@platformatic/db": "3.56.0",
+    "@platformatic/service": "3.56.0",
+    "@platformatic/gateway": "3.56.0",
+    "@platformatic/sql-graphql": "3.56.0",
+    "@platformatic/sql-mapper": "3.56.0",
+    "@platformatic/node": "3.56.0",
+    "@platformatic/wattpm-pprof-capture": "3.56.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -70,15 +70,16 @@
     "semgrator": "^0.3.0",
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
-    "undici": "^7.0.0",
+    "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/itc": "3.55.0",
-    "@platformatic/foundation": "3.55.0",
-    "@platformatic/metrics": "3.55.0",
-    "@platformatic/basic": "3.55.0",
-    "@platformatic/generators": "3.55.0",
-    "@platformatic/telemetry": "3.55.0"
+    "@platformatic/basic": "3.56.0",
+    "@platformatic/generators": "3.56.0",
+    "@platformatic/globals": "3.56.0",
+    "@platformatic/metrics": "3.56.0",
+    "@platformatic/itc": "3.56.0",
+    "@platformatic/telemetry": "3.56.0",
+    "@platformatic/foundation": "3.56.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.55.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.56.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",