@platformatic/runtime 4.0.0-new-config.2 → 4.0.0-new-config.5

package/lib/schema.js

@@ -33,6 +33,12 @@ const runtimeLogger = {
   }
 }
 
+/*
+  The root logger is not the application one: it carries `captureStdio` and the `pino` key mapping,
+  which only the runtime reads. Naming them apart is what lets a person write the type of either.
+*/
+runtimeLogger.title = 'RuntimeLoggerOptions'
+
 schemaComponents.runtimeProperties.logger = runtimeLogger
 
 schemaComponents.runtimeProperties.verticalScaler.properties.applications = {
@@ -71,6 +77,76 @@ const platformaticRuntimeSchema = {
 
 export const schema = platformaticRuntimeSchema
 
+/*
+  The keys v4 does not implement. Validating a v4 configuration against the v3 schema accepted them
+  and then ignored them, which is the worst of both: `envfile: './deploy.env'` at the root looked
+  like it was doing something. They survive on the v3 schema, which still serves v3 projects, and
+  inside migrate's legacy reader.
+
+  Root `envfile` is removed, not renamed — an entry may still declare one, and that property lives
+  on the application schema rather than here.
+
+  `$schema` is different in kind: machine writers of the plain-object form still stamp it, and the
+  loader reads it for version detection and strips it before validation. The schema refusing it is
+  what makes the strip load-bearing rather than decorative — a stamp that reached AJV would mean the
+  loader had skipped the step that checks the file is not a v3 one.
+
+  `verticalScaler` is the deprecated spelling of `workers`, kept on the v3 schema with a transform
+  that migrates it. v4 has one spelling: a configuration that still says `verticalScaler` is told
+  so by the schema rather than being quietly rewritten, which is the only way the two cannot
+  disagree about which of them a project meant.
+
+  `services` and `web` are the same story: v3's spellings of `applications`, folded by the shared
+  transform. Alone they fail the pipeline's topology check by name; beside an `applications` key
+  they would validate and be folded silently, so the schema refuses them instead.
+*/
+const removedInV4 = ['envfile', 'strictEnv', '$schema', 'verticalScaler', 'services', 'web']
+
+const { ...v4Properties } = platformaticRuntimeSchema.properties
+
+for (const key of removedInV4) {
+  delete v4Properties[key]
+}
+
+/*
+  v3's entry anyOf required an id beside the path or url, because v3 derived ids only for
+  autoloaded applications. v4 derives them at every position -- explicit entries included, from the
+  package name and then the directory -- so requiring one would refuse an entry the loader handles.
+  What a v4 entry genuinely needs is a place: a path or a url.
+
+  Copied rather than edited, because `applications.items` is shared with the v3 schema, where the
+  requirement still holds.
+*/
+const v4EntryItems = {
+  ...v4Properties.applications.items,
+  anyOf: [{ required: ['path'] }, { required: ['url'] }]
+}
+
+v4Properties.applications = { ...v4Properties.applications, items: v4EntryItems }
+
+/*
+  The singular shorthand: one application with runtime options, Level 1b. It is an application
+  entry whose identity and place the loader both supply -- the id derives from the package name
+  and the path defaults to the configuration file's own directory -- so it keeps the entry's
+  properties and drops the anyOf entirely.
+*/
+const { anyOf: _entryRequirements, ...applicationShorthand } = v4EntryItems
+
+v4Properties.application = applicationShorthand
+
+export const v4Schema = {
+  ...platformaticRuntimeSchema,
+  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${version}-v4.json`,
+  properties: v4Properties,
+  /*
+    The v3 anyOf listed the removed spellings, and it is decorative on the v4 path anyway -- by the
+    time either validation pass runs, normalization has already defaulted `applications`. The gate
+    that actually asks the question is the pipeline's topology check, before that default; this
+    matches it so the schema and the loader tell the same story.
+  */
+  anyOf: [{ required: ['autoload'] }, { required: ['applications'] }, { required: ['application'] }]
+}
+
 if (import.meta.main) {
   console.log(JSON.stringify(platformaticRuntimeSchema, null, 2))
 }

package/lib/worker/controller.js

@@ -1,11 +1,9 @@
+import { configurationFileNames } from '@platformatic/foundation/lib/v4/index.js'
 import {
   ensureLoggableError,
   FileWatcher,
   kHandledError,
-  listRecognizedConfigurationFiles,
-  loadConfiguration,
-  loadConfigurationModule,
-  mirrorGlobalDispatcherForBuiltinFetch
+  loadConfigurationModule
 } from '@platformatic/foundation'
 import {
   getLogger,
@@ -20,14 +18,18 @@ import {
 import { importCapabilityPackage } from '@platformatic/basic'
 import debounce from 'debounce'
 import { EventEmitter } from 'node:events'
-import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { getActiveResourcesInfo } from 'node:process'
 import { workerData } from 'node:worker_threads'
-import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
-import { ApplicationAlreadyStartedError, exitCodes, RuntimeNotStartedError } from '../errors.js'
+import { getGlobalDispatcher } from 'undici'
+import {
+  ApplicationAlreadyStartedError,
+  exitCodes,
+  InvalidApplicationModuleError,
+  RuntimeNotStartedError
+} from '../errors.js'
 import { getApplicationUrl } from '../utils.js'
-import { markAsPlatformaticDispatcher, refreshGlobalDispatcher } from './interceptors.js'
+import { installGlobalDispatcher, refreshGlobalDispatcher } from './interceptors.js'
 
 function fetchApplicationUrl (application, key) {
   if (!key.endsWith('_URL') || !application.id) {
@@ -84,9 +86,10 @@ export class Controller extends EventEmitter {
       applicationId: this.applicationId,
       workerId: this.workerId,
       directory: this.applicationConfig.path,
+      sourcePath: this.applicationConfig.sourcePath,
       dependencies: this.applicationConfig.dependencies,
       isProduction: this.applicationConfig.isProduction,
-      telemetryConfig: this.applicationConfig.telemetry,
+      tracingConfig: this.applicationConfig.tracing,
       loggerConfig: runtimeConfig.logger,
       metricsConfig,
       worker: workerData?.worker,
@@ -133,45 +136,40 @@ export class Controller extends EventEmitter {
         with workers: 4 evaluated user code five times and could reach five different answers.
 
         The capability is imported through the canonical resolution order, application-scoped first,
-        so the copy that runs here is the copy whose schema validated the payload main-side.
-      */
-      /*
-        v4: the configuration was evaluated exactly once, main-side, and this worker receives the
-        validated capability payload as data. There is no file to re-read and no schema to
-        rediscover — which is the point, since re-parsing per worker meant an application with
-        workers: 4 evaluated user code five times and could reach five different answers.
-
-        The capability is imported through the canonical resolution order, application-scoped
-        first, so the copy that runs here is the copy whose schema validated the payload.
+        so the copy that runs here is the copy whose schema validated the payload main-side. When the
+        entry names an npm module, that module is the capability, resolved the same way.
       */
       if (appConfig.resolvedConfig) {
-        const pkg = await importCapabilityPackage(appConfig.path, appConfig.module)
-
-        this.capability = await pkg.create(appConfig.path, appConfig.resolvedConfig, this.#context)
-      } else {
-        // Before returning the base application, check if there is any file we recognize
-        // and the user just forgot to specify in the configuration.
-        if (!appConfig.config) {
-          const candidate = listRecognizedConfigurationFiles().find(f => existsSync(resolve(appConfig.path, f)))
+        const pkg = await importCapabilityPackage(appConfig.path, appConfig.module, {
+          runtimeScope: import.meta.filename
+        })
 
-          if (candidate) {
-            appConfig.config = resolve(appConfig.path, candidate)
-          }
+        // A module application names its capability directly. If that package exports no `create`,
+        // name it rather than letting the call below throw a bare "pkg.create is not a function".
+        if (appConfig.module && typeof pkg.create !== 'function') {
+          throw new InvalidApplicationModuleError(appConfig.module)
         }
 
-        if (appConfig.config) {
-          // Parse the configuration file the first time to obtain the schema
-          const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
-            onMissingEnv: this.#context.fetchApplicationUrl,
-            strictEnv: this.#context.strictEnv
-          })
-          const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
-          this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)
-          // We could not find a configuration file, we use the bundle @platformatic/basic with the runtime to load it
-        } else {
-          const pkg = await loadConfigurationModule(resolve(import.meta.dirname, '../..'), {}, '@platformatic/basic')
-          this.capability = await pkg.create(appConfig.path, {}, this.#context)
-        }
+        /*
+          `resolved` says this object has already been through the loader: its environment was
+          layered main-side, it holds no placeholders, and it has been validated against this
+          capability's schema. It is what tells the capability apart from an embedder handing over
+          an object nobody has checked, which still gets validated on the way in.
+        */
+        this.capability = await pkg.create(appConfig.path, appConfig.resolvedConfig, {
+          ...this.#context,
+          resolved: true
+        })
+      } else {
+        /*
+          No payload at all, which the v4 loader does not produce -- `prepareV4Application` gives
+          every entry a `resolvedConfig`, an empty object where there is nothing to say. What is
+          left here is an embedder constructing a Controller by hand, and the bundled base
+          capability is the answer for that: there is no configuration file to look for, because v4
+          decides that main-side and hands the result over.
+        */
+        const pkg = await loadConfigurationModule(resolve(import.meta.dirname, '../..'), {}, '@platformatic/basic')
+        this.capability = await pkg.create(appConfig.path, {}, this.#context)
       }
 
       this.#updateDispatcher()
@@ -323,11 +321,20 @@ export class Controller extends EventEmitter {
       return
     }
 
+    /*
+      The application's own configuration file is not the worker's to watch. The runtime evaluates
+      configuration once, main-side, and watches every file that evaluation read -- so a change to
+      one is a configuration change and the runtime reloads for it.
+
+      Watching it here as well meant both fired for a single edit: the runtime tore itself down and
+      rebuilt while this worker restarted the same application, and the rebuilt runtime could not
+      bind its management socket because the one it replaced had not released it yet.
+    */
     const fileWatcher = new FileWatcher({
       path: watch.path,
       /* c8 ignore next 2 */
       allowToWatch: watch?.allow,
-      watchIgnore: watch?.ignore || []
+      watchIgnore: [...(watch?.ignore || []), ...configurationFileNames]
     })
 
     fileWatcher.on('update', this.#debouncedRestart)
@@ -358,8 +365,8 @@ export class Controller extends EventEmitter {
   }
 
   #updateDispatcher () {
-    const telemetryConfig = this.#context.telemetryConfig
-    const telemetryId = telemetryConfig?.applicationName
+    const tracingConfig = this.#context.tracingConfig
+    const telemetryId = tracingConfig?.applicationName
 
     const interceptor = dispatch => {
       return function InterceptedDispatch (opts, handler) {
@@ -375,9 +382,7 @@ export class Controller extends EventEmitter {
 
     const dispatcher = getGlobalDispatcher().compose(interceptor)
 
-    markAsPlatformaticDispatcher(dispatcher)
-    setGlobalDispatcher(dispatcher)
-    mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
+    installGlobalDispatcher(dispatcher)
   }
 
   #setupHandlers (timeout) {

package/lib/worker/interceptors.js

@@ -6,14 +6,14 @@ import {
   getOnHttpCacheMiss,
   getOnHttpCacheRequest
 } from '@platformatic/globals'
-import { createTelemetryThreadInterceptorHooks } from '@platformatic/telemetry'
+import { createTelemetryThreadInterceptorHooks } from '@platformatic/tracing'
 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 } from 'undici'
-import { wire } from 'undici-thread-interceptor'
-import { createChannelCreationHook } from '../policies.js'
+import { workerData } from 'node:worker_threads'
+import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
+import { createInterceptor } from 'undici-thread-interceptor'
+import { createTargetPermissionHook } from '../policies.js'
 import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
 
 const kPlatformaticGlobalDispatcher = Symbol.for('platformatic.undici.globalDispatcher')
@@ -43,8 +43,11 @@ export function refreshGlobalDispatcher () {
 }
 
 export async function setDispatcher (runtimeConfig) {
-  const threadDispatcher = createThreadInterceptor(runtimeConfig)
-  const threadInterceptor = threadDispatcher.interceptor
+  const tracingHooks = runtimeConfig.tracing ? createTelemetryThreadInterceptorHooks() : {}
+  const threadDispatcher = createThreadInterceptor(runtimeConfig, tracingHooks)
+  const threadInterceptor = threadDispatcher
+
+  await threadDispatcher.ready
 
   let cacheInterceptor = null
   if (runtimeConfig.httpCache) {
@@ -65,30 +68,29 @@ export async function setDispatcher (runtimeConfig) {
       [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
     )
 
-    markAsPlatformaticDispatcher(dispatcher)
-    mirrorGlobalDispatcherForBuiltinFetch(dispatcher, createLegacyDispatcher(dispatcher))
+    installGlobalDispatcher(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 {
+    threadDispatcher: {
+      interceptor: threadDispatcher,
+      server: null,
+      serverHooks: tracingHooks.serverHooks
     }
   }
+}
 
-  return dispatcher
+export function installGlobalDispatcher (dispatcher) {
+  markAsPlatformaticDispatcher(dispatcher)
+  setGlobalDispatcher(dispatcher)
+  mirrorGlobalDispatcherForBuiltinFetch(
+    dispatcher,
+    globalThis[Symbol.for('undici.globalDispatcher.1')]
+  )
 }
 
 export async function updateUndiciInterceptors (undiciConfig) {
@@ -215,19 +217,17 @@ async function getDispatcherOpts (undiciConfig) {
   return dispatcherOpts
 }
 
-function createThreadInterceptor (runtimeConfig) {
-  const telemetry = runtimeConfig.telemetry
-
-  const telemetryHooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
-
-  const threadDispatcher = wire({
-    // Specifying the domain is critical to avoid flooding the DNS
-    // with requests for a domain that's never going to exist.
+function createThreadInterceptor (runtimeConfig, tracingHooks) {
+  const threadDispatcher = createInterceptor({
+    meshId: workerData.meshId,
     domain: '.plt.local',
-    port: parentPort,
-    timeout: runtimeConfig.applicationTimeout,
-    onChannelCreation: createChannelCreationHook(runtimeConfig),
-    ...telemetryHooks
+    connectTimeout: runtimeConfig.applicationTimeout,
+    bootstrapTimeout: runtimeConfig.applicationTimeout,
+    allowTarget: createTargetPermissionHook({
+      ...runtimeConfig,
+      applicationId: workerData.applicationConfig.id
+    }),
+    ...tracingHooks
   })
   return threadDispatcher
 }

package/lib/worker/itc.js

@@ -2,6 +2,7 @@ import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout }
 import { getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
 import { ITC, initializeITCTelemetry } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
+import { createServer } from 'undici-thread-interceptor'
 import { once } from 'node:events'
 import { createRequire } from 'node:module'
 import { Duplex } from 'node:stream'
@@ -114,6 +115,7 @@ async function safeHandleInITC (worker, fn) {
 async function closeITC (dispatcher, itc, messaging) {
   try {
     await dispatcher.interceptor.close()
+    await dispatcher.server?.close()
     itc.close()
     messaging.close()
   } finally {
@@ -208,7 +210,28 @@ export async function setupITC (controller, application, dispatcher, sharedConte
           }
         }
 
-        dispatcher.replaceServer(await controller.capability.getDispatchTarget())
+        const dispatchTarget = await controller.capability.getDispatchTarget()
+        if (dispatchTarget == null) {
+          await new Promise(() => {})
+        }
+
+        const serverTarget = dispatcher.serverHooks?.run
+          ? wrapDispatchTarget(dispatchTarget, dispatcher.serverHooks.run)
+          : dispatchTarget
+
+        dispatcher.server = createServer({
+          meshId: workerData.meshId,
+          serverId: workerData.worker.id,
+          domain: `${application.id}.plt.local`,
+          server: serverTarget,
+          bootstrapTimeout: workerData.config.applicationTimeout,
+          metadata: {
+            applicationId: application.id,
+            workerId: workerData.worker.id
+          },
+          ...dispatcher.serverHooks
+        })
+        await dispatcher.server.ready
 
         const scheduledTasks =
           typeof controller.capability.getScheduledTasks === 'function'
@@ -259,7 +282,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
       },
 
       async removeFromMesh () {
-        return dispatcher.interceptor.close()
+        await dispatcher.server?.close()
+        dispatcher.server = null
       },
 
       inject (injectParams) {
@@ -291,6 +315,12 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         return controller.capability.getInfo()
       },
 
+      // How this worker serves, which only the worker can answer: for a worker-classified
+      // capability it depends on what the application's factory returned in this worker.
+      getServingState () {
+        return controller.capability?.getServingState?.() ?? 'inactive'
+      },
+
       async getApplicationConfig () {
         const current = await controller.capability.getConfig()
         // Remove all undefined keys from the config
@@ -498,3 +528,20 @@ export async function setupITC (controller, application, dispatcher, sharedConte
   itc.listen()
   return itc
 }
+
+function wrapDispatchTarget (target, run) {
+  if (typeof target.inject === 'function') {
+    return {
+      inject: (req, callback) => run(req, () => target.inject(req, callback)),
+      server: target.server,
+      emit: target.emit?.bind(target),
+      listenerCount: target.listenerCount?.bind(target)
+    }
+  }
+
+  if (typeof target.emit === 'function') {
+    return target
+  }
+
+  return target
+}

package/lib/worker/main.js

@@ -7,18 +7,16 @@ import {
   parseMemorySize
 } from '@platformatic/foundation'
 import { getITC, getLogger, updateGlobals } from '@platformatic/globals'
-import { addPinoInstrumentation } from '@platformatic/telemetry'
+import { addPinoInstrumentation } from '@platformatic/tracing'
 import { Buffer } from 'node:buffer'
 import { subscribe } from 'node:diagnostics_channel'
 import { EventEmitter } from 'node:events'
-import { readFile } from 'node:fs/promises'
 import { ServerResponse } from 'node:http'
 import inspector from 'node:inspector'
 import { hostname } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join } from 'node:path'
 import { setDefaultHighWaterMark } from 'node:stream'
 import { pathToFileURL } from 'node:url'
-import { parseEnv } from 'node:util'
 import { threadId, workerData } from 'node:worker_threads'
 import pino from 'pino'
 import { install as installUndiciGlobals } from 'undici'
@@ -100,7 +98,7 @@ function createLogger () {
     pinoOptions.timestamp = buildPinoTimestamp(pinoOptions.timestamp)
   }
 
-  if (workerData.config.logger?.openTelemetryExporter && workerData.applicationConfig.telemetry?.enabled !== false) {
+  if (workerData.config.logger?.openTelemetryExporter && workerData.applicationConfig.tracing?.enabled !== false) {
     addPinoInstrumentation(pinoOptions)
   }
 
@@ -231,44 +229,19 @@ async function main () {
 
   await performPreloading(runtimeConfig, applicationConfig)
 
-  // Load env file and mixin env vars from application config
-  let envfile
-  if (applicationConfig.envfile) {
-    envfile = resolve(workerData.dirname, applicationConfig.envfile)
-  } else {
-    envfile = resolve(workerData.applicationConfig.path, '.env')
-  }
-
-  const logger = getLogger()
-  logger.debug({ envfile }, 'Loading envfile...')
-
-  // Note that process.loadEnvFile is not used here as it never overrides an already defined
-  // variable. The worker environment is seeded from the environment the runtime resolved, which
-  // might contain values coming from an env file of the runtime. Those are only defaults, so the
-  // env file of this application, which is more specific, is allowed to override them. Real
-  // environment variables are never overridden.
-  const envFileFallbackKeys = new Set(workerData.envFileFallbackKeys ?? [])
-
-  try {
-    const applicationEnv = parseEnv(await readFile(envfile, 'utf-8'))
-
-    for (const [key, value] of Object.entries(applicationEnv)) {
-      if (!(key in process.env) || envFileFallbackKeys.has(key)) {
-        process.env[key] = value
-      }
-    }
-  } catch {
-    // Ignore if the file doesn't exist, similar to dotenv behavior
-  }
-
-  if (runtimeConfig.env) {
-    Object.assign(process.env, runtimeConfig.env)
-  }
-  if (applicationConfig.env) {
-    Object.assign(process.env, applicationConfig.env)
-  }
+  /*
+    Nothing is layered onto process.env here, and that absence is load-bearing. The loader resolved
+    this worker's entire environment main-side -- env-file chains, both env blocks, the injected
+    topology URLs, with the real environment authoritative over all of them -- and the worker was
+    *spawned* with that result. Re-reading a .env or re-applying an env block on top re-decides
+    what was already decided, with the opposite precedence: v3 treated blocks as pins over the real
+    environment, and v4 declares the inversion as a breaking change. The suppression of a block
+    value by the real environment is reported at boot, main-side, where the ladder is resolved.
+  */
+  getLogger().debug('Using the worker environment resolved by the loader.')
 
   const { threadDispatcher } = await setDispatcher(runtimeConfig)
+  updateGlobals({ undiciThreadInterceptor: threadDispatcher.interceptor })
 
   const inspectorOptions = workerData.inspectorOptions
 
@@ -304,17 +277,7 @@ async function main () {
     metricsConfig
   )
 
-  await controller.init(cleanup)
-
-  if (runtimeConfig.basePath) {
-    const meta = await controller.capability.getMeta()
-    if (!meta.gateway?.wantsAbsoluteUrls) {
-      stripBasePath(runtimeConfig.basePath)
-    }
-  }
-
   const sharedContext = new SharedContext()
-  // Limit the amount of methods a user can call
   updateGlobals({
     sharedContext: {
       get: () => sharedContext.get(),
@@ -322,10 +285,20 @@ async function main () {
     }
   })
 
-  // Setup interaction with parent port
+  // Setup interaction with the parent before loading the application so plugins
+  // can register messaging handlers during their initialization.
   const itc = await setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
   updateGlobals({ itc })
 
+  await controller.init(cleanup)
+
+  if (runtimeConfig.basePath) {
+    const meta = await controller.capability.getMeta()
+    if (!meta.gateway?.wantsAbsoluteUrls) {
+      stripBasePath(runtimeConfig.basePath)
+    }
+  }
+
   // Setup management client for privileged applications
   if (applicationConfig.management) {
     const mgmtEnabled =
@@ -385,7 +358,9 @@ function stripBasePath (basePath) {
         request.url = '/' + request.url
       }
 
-      response[kBasePath] = basePath
+      if (response) {
+        response[kBasePath] = basePath
+      }
     }
   })
 

package/lib/worker/symbols.js

@@ -10,9 +10,9 @@ export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
 export const kWorkerUrl = Symbol.for('plt.runtime.worker.url')
 export const kWorkerPortOffset = Symbol.for('plt.runtime.worker.portOffset')
+export const kWorkerServerOptions = Symbol.for('plt.runtime.worker.serverOptions')
 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')
 export const kIsSubprocessHost = Symbol.for('plt.runtime.worker.isSubprocessHost')
 
 // This string marker should be safe to use since it belongs to Unicode private area

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "4.0.0-new-config.2",
+  "version": "4.0.0-new-config.5",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "~6.0.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "4.0.0-new-config.2",
-    "@platformatic/db": "4.0.0-new-config.2",
-    "@platformatic/gateway": "4.0.0-new-config.2",
-    "@platformatic/node": "4.0.0-new-config.2",
-    "@platformatic/sql-mapper": "4.0.0-new-config.2",
-    "@platformatic/sql-graphql": "4.0.0-new-config.2",
-    "@platformatic/wattpm-pprof-capture": "4.0.0-new-config.2",
-    "@platformatic/service": "4.0.0-new-config.2"
+    "@platformatic/composer": "4.0.0-new-config.5",
+    "@platformatic/db": "4.0.0-new-config.5",
+    "@platformatic/gateway": "4.0.0-new-config.5",
+    "@platformatic/node": "4.0.0-new-config.5",
+    "@platformatic/service": "4.0.0-new-config.5",
+    "@platformatic/sql-graphql": "4.0.0-new-config.5",
+    "@platformatic/sql-mapper": "4.0.0-new-config.5",
+    "@platformatic/wattpm-pprof-capture": "4.0.0-new-config.5"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -75,16 +75,16 @@
     "semver": "^7.6.3",
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
-    "undici": "^7.27.2",
-    "undici-thread-interceptor": "^1.3.1",
+    "undici": "^8.5.0",
+    "undici-thread-interceptor": "^2.1.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "4.0.0-new-config.2",
-    "@platformatic/foundation": "4.0.0-new-config.2",
-    "@platformatic/globals": "4.0.0-new-config.2",
-    "@platformatic/generators": "4.0.0-new-config.2",
-    "@platformatic/itc": "4.0.0-new-config.2",
-    "@platformatic/metrics": "4.0.0-new-config.2",
-    "@platformatic/telemetry": "4.0.0-new-config.2"
+    "@platformatic/basic": "4.0.0-new-config.5",
+    "@platformatic/foundation": "4.0.0-new-config.5",
+    "@platformatic/globals": "4.0.0-new-config.5",
+    "@platformatic/generators": "4.0.0-new-config.5",
+    "@platformatic/itc": "4.0.0-new-config.5",
+    "@platformatic/tracing": "4.0.0-new-config.5",
+    "@platformatic/metrics": "4.0.0-new-config.5"
   },
   "engines": {
     "node": ">=22.19.0"