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

package/lib/runtime.js

@@ -5,7 +5,6 @@ import {
   executeInParallel,
   executeWithTimeout,
   features,
-  kEnvFileFallbackKeys,
   kMetadata,
   kTimeout,
   parseMemorySize
@@ -25,6 +24,7 @@ import { STATUS_CODES } from 'node:http'
 import { createRequire } from 'node:module'
 import { availableParallelism } from 'node:os'
 import { basename, dirname, isAbsolute, join } from 'node:path'
+import { randomUUID } from 'node:crypto'
 import { Readable } from 'node:stream'
 import { finished } from 'node:stream/promises'
 import { setImmediate as immediate, setTimeout as sleep } from 'node:timers/promises'
@@ -32,7 +32,7 @@ import { pathToFileURL } from 'node:url'
 import { Worker } from 'node:worker_threads'
 import SonicBoom from 'sonic-boom'
 import { Agent, request, interceptors as undiciInterceptors } from 'undici'
-import { createThreadInterceptor } from 'undici-thread-interceptor'
+import { createCoordinator, createInterceptor } from 'undici-thread-interceptor'
 import { pprofCapturePreloadPath } from './config.js'
 import {
   AddressInUseError,
@@ -53,17 +53,17 @@ import {
   MessagingError,
   MetricFamilyCollisionError,
   MissingPprofCapture,
+  MixedServingStateError,
   ReservedITCHandlerNameError,
   RuntimeAbortedError,
   RuntimeExtensionBuildAlreadyCalledError,
-  WorkerInterceptorJoinTimeoutError,
   WorkerNotFoundError
 } from './errors.js'
 import { abstractLogger, createLogger } from './logger.js'
 import { startManagementApi } from './management-api.js'
 import { createManagementHandlers } from './management-handlers.js'
 import { OpenTelemetryMetricsForwarder } from './opentelemetry-metrics.js'
-import { createChannelCreationHook } from './policies.js'
+import { createChannelCreationHook, createTargetPermissionHook } from './policies.js'
 import { startHealthProbesServer, startPrometheusServer } from './prom-server.js'
 import { startScheduler } from './scheduler.js'
 import { createSharedStore } from './shared-http-cache.js'
@@ -79,7 +79,6 @@ import {
   kFullId,
   kHealthCheckTimer,
   kId,
-  kInterceptorReadyPromise,
   kIsSubprocessHost,
   kITC,
   kLastHealthCheckELU,
@@ -87,6 +86,7 @@ import {
   kWorkerHealthSignals,
   kWorkerId,
   kWorkerPortOffset,
+  kWorkerServerOptions,
   kWorkerUrl,
   kWorkersBroadcast,
   kWorkerStartTime,
@@ -176,6 +176,55 @@ const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
 const MAX_WORKERS = 100
 const DEFAULT_RESTART_ON_ERROR_DELAY = 5000
 
+/*
+  Both public payloads are built from a snapshot and frozen through. What a consumer could observe
+  in v3 was scalars and a file path, so handing out interior state was harmless in practice; v4
+  nests resolvedConfig -- an entire capability payload -- inside every entry, and the getters read
+  straight off live state. A consumer mutating what it received would be editing the configuration
+  that later restarts and scale-up workers read, silently, and would make worker generations
+  disagree about what they are running. setApplicationConfigPatch exists precisely so that changing
+  a running application's configuration is explicit, patch-shaped and visible.
+
+  Only plain objects and arrays are copied. Anything carrying its own prototype -- a class
+  instance, a stream, a buffer -- is handed back as it is, because a copy of it would not be the
+  thing; the hazard this closes is a consumer editing configuration, not one editing a socket.
+*/
+function frozenSnapshot (value, seen = new Map()) {
+  if (value === null || typeof value !== 'object') {
+    return value
+  }
+
+  if (seen.has(value)) {
+    return seen.get(value)
+  }
+
+  if (Array.isArray(value)) {
+    const copy = []
+    seen.set(value, copy)
+
+    for (const entry of value) {
+      copy.push(frozenSnapshot(entry, seen))
+    }
+
+    return Object.freeze(copy)
+  }
+
+  const prototype = Object.getPrototypeOf(value)
+
+  if (prototype !== Object.prototype && prototype !== null) {
+    return value
+  }
+
+  const copy = {}
+  seen.set(value, copy)
+
+  for (const [key, entry] of Object.entries(value)) {
+    copy[key] = frozenSnapshot(entry, seen)
+  }
+
+  return Object.freeze(copy)
+}
+
 export class Runtime extends EventEmitter {
   logger
   error
@@ -201,11 +250,15 @@ export class Runtime extends EventEmitter {
   #healthMetricsCollectionActive
 
   #meshInterceptor
+  #meshCoordinator
+  #meshId
   #dispatcher
 
   #managementApi
   #prometheusServer
   #healthProbesServer
+  #metricsServersInitialized
+  #metricsServersStartPromise
   #opentelemetryMetricsForwarder
   #inspectorServer
   #metricsLabelName
@@ -223,6 +276,7 @@ export class Runtime extends EventEmitter {
   #extensionLivenessChecks
   #extensionHealthRoutes
   #lastOverloadProfiles
+  #servingStates
   #restartingApplications
   #restartingWorkers
   #workerPortOffsets
@@ -255,13 +309,7 @@ export class Runtime extends EventEmitter {
     this.#applicationRestartCounts = new Map()
     this.#workers = new RoundRobinMap()
     this.#channelCreationHook = createChannelCreationHook(this.#config)
-    this.#meshInterceptor = createThreadInterceptor({
-      domain: '.plt.local',
-      timeout: this.#config.applicationTimeout,
-      meshTimeout: this.#context.meshTimeout ?? true,
-      onChannelCreation: this.#channelCreationHook,
-      onError: this.#onMeshInterceptorError.bind(this)
-    })
+    this.#meshId = `runtime-${randomUUID()}`
     this.logger = abstractLogger // This is replaced by the real logger in init() and eventually removed in close()
     this.#status = undefined
     this.#restartingApplications = new Set()
@@ -296,20 +344,26 @@ export class Runtime extends EventEmitter {
     // Registered per-worker in #setupWorker, reserved so extensions cannot clobber it
     this.#reservedITCHandlerNames.add('profiling:started')
     this.#extensions = []
+    this.#metricsServersInitialized = false
+    this.#metricsServersStartPromise = null
     this.#extensionsWantHealthMetrics = false
     this.#extensionReadinessChecks = new Map()
     this.#extensionLivenessChecks = new Map()
     this.#extensionHealthRoutes = []
     this.#lastOverloadProfiles = new Map()
+    this.#servingStates = new Map()
     this.#sharedContext = {}
 
-    if (this.#isProduction) {
-      this.#env.PLT_DEV = 'false'
-      this.#env.PLT_ENVIRONMENT = 'production'
-    } else {
-      this.#env.PLT_DEV = 'true'
-      this.#env.PLT_ENVIRONMENT = 'development'
-    }
+    /*
+      v3 injected `PLT_DEV` and `PLT_ENVIRONMENT` here. v4 removes them: an application branches on
+      its own variables, or the decision moves into the configuration, where the context carries
+      `production` and `mode` with types. `NODE_ENV` is the one the runtime still defaults, at the
+      bottom of the env ladder, so anything the project sets outranks it.
+
+      They were worse than redundant by the end -- the v4 worker environment is the one the loader
+      resolved per application, and these were written onto the runtime's own copy, so under
+      `wattpm start` an application still read `PLT_ENVIRONMENT=development`.
+    */
   }
 
   async init () {
@@ -327,10 +381,9 @@ export class Runtime extends EventEmitter {
       this.#metricsLabelName = 'applicationId'
     }
 
-    // Initialize process-level metrics registry in the main thread if metrics or management API is enabled
+    // Initialize process-level metrics registry only when metrics are enabled.
     // These metrics are the same across all workers and only need to be collected once
-    // We need this for management API as it can request metrics even without explicit metrics config
-    if (config.metrics || config.managementApi) {
+    if (config.metrics && config.metrics.enabled !== false) {
       this.#processMetricsRegistry = new metricsClient.Registry()
       collectProcessMetrics(this.#processMetricsRegistry)
     }
@@ -366,12 +419,22 @@ export class Runtime extends EventEmitter {
     // readiness/liveness checks and probe routes before Fastify starts listening.
     await this.#loadExtensions()
 
-    if (config.metrics || (typeof config.healthProbes === 'object' && config.healthProbes !== null)) {
-      this.#prometheusServer = await startPrometheusServer(this, config.metrics ?? false, config.healthProbes)
+    // A runtime without applications exits during start and must not briefly
+    // claim the default health-probe port. Applications added later, including
+    // by extension start hooks, initialize these servers in addApplications().
+    if (config.applications.length > 0) {
+      await this.#ensureMetricsServersStarted()
     }
 
-    this.#healthProbesServer = await startHealthProbesServer(this, config.metrics, config.healthProbes)
-    this.#assertExtensionHealthRoutesApplied()
+    this.#meshCoordinator = createCoordinator({ meshId: this.#meshId })
+    this.#meshInterceptor = createInterceptor({
+      meshId: this.#meshId,
+      domain: '.plt.local',
+      connectTimeout: this.#config.applicationTimeout,
+      bootstrapTimeout: this.#config.applicationTimeout,
+      allowTarget: createTargetPermissionHook(this.#config)
+    })
+    await this.#meshInterceptor.ready
 
     await this.addApplications(this.#config.applications)
     await this.#setDispatcher(config.undici)
@@ -487,7 +550,8 @@ export class Runtime extends EventEmitter {
 
     await this.stopApplications(this.getApplicationsIds(), silent)
 
-    await this.#meshInterceptor.close()
+    await this.#meshInterceptor?.close()
+    this.#meshCoordinator?.destroy()
     this.#workersBroadcastChannel?.close()
 
     this.#updateStatus('stopped')
@@ -520,6 +584,7 @@ export class Runtime extends EventEmitter {
     clearTimeout(this.#healthMetricsTimer)
     this.#healthMetricsCollectionActive = false
     this.#lastOverloadProfiles.clear()
+    this.#servingStates.clear()
 
     await this.stop(silent)
     this.#updateStatus('closing')
@@ -666,6 +731,10 @@ export class Runtime extends EventEmitter {
 
     await executeInParallel(this.#setupApplication.bind(this), setupInvocations, this.#concurrency)
 
+    if (applications.length > 0) {
+      await this.#ensureMetricsServersStarted()
+    }
+
     for (const application of applications) {
       this.logger.debug(`Added application "${application.id}".`)
       this.emitAndNotify('application:added', application)
@@ -677,7 +746,7 @@ export class Runtime extends EventEmitter {
 
     const created = []
     for (const { id } of applications) {
-      created.push(await this.getApplicationDetails(id))
+      created.push(await this.#buildApplicationDetails(id))
     }
 
     this.#updateLoggingPrefixes()
@@ -693,8 +762,13 @@ export class Runtime extends EventEmitter {
 
       // Use allowUnloaded so that applications without a live worker
       // (stopped or crashed with restartOnError: 0) can still be removed.
-      const details = await this.getApplicationDetails(application, true)
+      const details = await this.#buildApplicationDetails(application, true)
       details.status = 'removed'
+
+      // The snapshot is taken while the application is still up, but what it reports is an
+      // application about to be gone: it is not making a claim about how it would serve.
+      delete details.servingState
+
       removed.push(details)
     }
 
@@ -735,8 +809,24 @@ export class Runtime extends EventEmitter {
     const levels = topologicalLevels(applications, dependencies)
 
     for (const level of levels) {
-      const startInvocations = level.map(app => [app, silent])
-      await executeInParallel(this.startApplication.bind(this), startInvocations, this.#concurrency)
+      const applicationsWithPort = await Promise.all(
+        level.map(async applicationId => {
+          const worker = await this.#getWorkerByIdOrNext(applicationId)
+          const applicationConfig = await sendViaITC(worker, 'getApplicationConfig')
+          const port = Number(applicationConfig?.server?.port)
+          return { applicationId, hasPort: Number.isInteger(port) && port > 0 }
+        })
+      )
+
+      for (const hasPort of [true, false]) {
+        const startInvocations = applicationsWithPort
+          .filter(application => application.hasPort === hasPort)
+          .map(({ applicationId }) => [applicationId, silent])
+
+        if (startInvocations.length > 0) {
+          await executeInParallel(this.startApplication.bind(this), startInvocations, this.#concurrency)
+        }
+      }
     }
   }
 
@@ -838,6 +928,7 @@ export class Runtime extends EventEmitter {
     }
 
     await this.#registerApplicationSchedulerJobs(id)
+    await this.#collectServingState(id)
 
     this.emitAndNotify('application:started', id)
     await this.#dynamicWorkersScaler?.applyPendingUpdate(id)
@@ -864,6 +955,11 @@ export class Runtime extends EventEmitter {
       await executeInParallel(this.#stopWorker.bind(this), stopInvocations, this.#concurrency)
     }
 
+    // Absent rather than 'inactive': a stopped application is not making a claim about how it
+    // would serve, and conflating "not started" with "started and serving nothing" is the exact
+    // distinction this field exists to draw.
+    this.#servingStates.delete(id)
+
     this.emitAndNotify('application:stopped', id)
   }
 
@@ -1308,6 +1404,8 @@ export class Runtime extends EventEmitter {
       this.#healthProbesServer = null
     }
 
+    this.#metricsServersInitialized = false
+
     if (this.#opentelemetryMetricsForwarder) {
       await this.#opentelemetryMetricsForwarder.close()
       this.#opentelemetryMetricsForwarder = null
@@ -1321,10 +1419,7 @@ export class Runtime extends EventEmitter {
       entry.applied = false
     }
 
-    this.#prometheusServer = await startPrometheusServer(this, metricsConfig, this.#config.healthProbes)
-
-    this.#healthProbesServer = await startHealthProbesServer(this, metricsConfig, this.#config.healthProbes)
-    this.#assertExtensionHealthRoutesApplied()
+    await this.#ensureMetricsServersStarted()
 
     await this.#startOpenTelemetryMetricsForwarder(metricsConfig?.opentelemetry)
 
@@ -1346,6 +1441,41 @@ export class Runtime extends EventEmitter {
     return { success: true, config: metricsConfig }
   }
 
+  async #ensureMetricsServersStarted () {
+    if (this.#metricsServersInitialized) {
+      return
+    }
+
+    if (this.#metricsServersStartPromise) {
+      return this.#metricsServersStartPromise
+    }
+
+    this.#metricsServersStartPromise = (async () => {
+      const config = this.#config
+
+      try {
+        if (config.metrics || (typeof config.healthProbes === 'object' && config.healthProbes !== null)) {
+          this.#prometheusServer = await startPrometheusServer(this, config.metrics ?? false, config.healthProbes)
+        }
+
+        this.#healthProbesServer = await startHealthProbesServer(this, config.metrics, config.healthProbes)
+        this.#assertExtensionHealthRoutesApplied()
+        this.#metricsServersInitialized = true
+      } catch (err) {
+        await Promise.allSettled([this.#prometheusServer?.close(), this.#healthProbesServer?.close()])
+        this.#prometheusServer = null
+        this.#healthProbesServer = null
+        throw err
+      }
+    })()
+
+    try {
+      await this.#metricsServersStartPromise
+    } finally {
+      this.#metricsServersStartPromise = null
+    }
+  }
+
   async #startOpenTelemetryMetricsForwarder (config) {
     if (!config?.endpoint || config.enabled === false || config.enabled === 'false') {
       return
@@ -1581,6 +1711,14 @@ export class Runtime extends EventEmitter {
       execPath: process.execPath,
       nodeVersion: process.version,
       projectDir: this.#root,
+      /*
+        What `applications:add`/`remove --save` actually consume, so they can stop reading the whole
+        runtime configuration over HTTP to get at three values. `autoload` is the declaration as
+        authored, not the expansion: v4 expands it in the eval worker, and --save has to edit what
+        the file says rather than what it produced.
+      */
+      configPath: this.#config[kMetadata]?.path ?? null,
+      autoload: this.#config.autoload ?? null,
       packageName: packageJson.name ?? null,
       packageVersion: packageJson.version ?? null,
       platformaticVersion: version,
@@ -1592,13 +1730,31 @@ export class Runtime extends EventEmitter {
     return this.#env
   }
 
+  /*
+    What a watcher has to follow to know this configuration changed. v4 reports the whole set the
+    evaluation read; v3 resolves per worker and has no such set, so it is the deciding file alone --
+    which is what dev watched before either way.
+  */
+  getConfigurationWatchTargets () {
+    const metadata = this.#config[kMetadata]
+    const targets = metadata?.v4?.watchTargets
+
+    if (targets) {
+      return { files: [...targets.files], directories: [...targets.directories] }
+    }
+
+    return { files: metadata?.path ? [metadata.path] : [], directories: [] }
+  }
+
   getRuntimeConfig (includeMeta = false) {
+    // includeMeta is an internal contract and hands back live state, symbol key and all. It leaves
+    // the public surface with the DTO change; until then, its in-tree callers depend on identity.
     if (includeMeta) {
       return this.#config
     }
 
     const { [kMetadata]: _, ...config } = this.#config
-    return config
+    return frozenSnapshot(config)
   }
 
   getInterceptor () {
@@ -1617,6 +1773,41 @@ export class Runtime extends EventEmitter {
     return this.#managementApi?.server.address() ?? null
   }
 
+  /*
+    servingState is computed per worker: for a worker-classified capability it depends on what the
+    application's factory returned in *that* worker, and nothing stops arbitrary code from returning
+    a server from worker 0 and a background result from worker 1. Sampling one worker -- which is
+    what getApplicationDetails does for every other field -- would make the reported value depend on
+    which worker the selector picked, and, worse, would leave mesh dispatch routing a share of
+    requests to a worker that destroys them. So every worker answers and a mixed answer is refused,
+    naming each worker and the state it reported.
+  */
+  async #collectServingState (id) {
+    const invocations = this.#workers.getKeys(id).map(workerId => [workerId, this.#workers.get(workerId)])
+
+    if (invocations.length === 0) {
+      this.#servingStates.delete(id)
+      return
+    }
+
+    const states = await sendMultipleViaITC(invocations, 'getServingState', undefined, [], this.#concurrency)
+    const reported = Object.entries(states).filter(([, state]) => typeof state === 'string')
+
+    if (reported.length === 0) {
+      this.#servingStates.delete(id)
+      return
+    }
+
+    const distinct = new Set(reported.map(([, state]) => state))
+
+    if (distinct.size > 1) {
+      this.#servingStates.delete(id)
+      throw new MixedServingStateError(id, reported.map(([worker, state]) => `${worker} reported ${state}`).join(', '))
+    }
+
+    this.#servingStates.set(id, reported[0][1])
+  }
+
   async getCustomHealthChecks () {
     const invocations = []
 
@@ -1768,7 +1959,7 @@ export class Runtime extends EventEmitter {
       // Drop any configured custom label that shares the name of the application
       // label (a config can set both `applicationLabel: 'serviceId'` and a static
       // `serviceId` label): keeping it would make these runtime-wide metrics look
-      // like they belong to an application, both here and in getFormattedMetrics().
+      // like they belong to an application during metrics aggregation.
       const processLabels = { ...this.#config.metrics?.labels }
       delete processLabels[this.#metricsLabelName]
       this.#applyLabelsToMetrics(processMetricsJson, processLabels, processMetrics)
@@ -1933,155 +2124,6 @@ export class Runtime extends EventEmitter {
     return output
   }
 
-  async getFormattedMetrics () {
-    try {
-      const { metrics } = await this.getMetrics()
-
-      if (metrics === null || metrics.length === 0) {
-        return null
-      }
-
-      const metricsNames = [
-        'process_cpu_percent_usage',
-        'process_resident_memory_bytes',
-        'nodejs_heap_size_total_bytes',
-        'nodejs_heap_size_used_bytes',
-        'nodejs_heap_space_size_total_bytes',
-        'nodejs_eventloop_utilization',
-        'http_request_all_summary_seconds'
-      ]
-
-      const applicationsMetrics = {}
-
-      // Process-level metrics are reported only once for the whole runtime, without
-      // an application label, since they are shared by all the applications running
-      // in worker threads (see issue #3332). Applications running as separate OS
-      // processes report their own labeled values, which take precedence below.
-      const runtimeProcessMetrics = {}
-      const applicationProcessMetrics = new Set()
-
-      for (const metric of metrics) {
-        const { name, values } = metric
-
-        if (!metricsNames.includes(name)) continue
-        if (!values || values.length === 0) continue
-
-        const labels = values[0].labels
-        // Use the configured label name (serviceId for v2 compatibility, applicationId for v3+)
-        const applicationId = labels?.[this.#metricsLabelName]
-
-        if (!applicationId) {
-          if (name === 'process_cpu_percent_usage') {
-            runtimeProcessMetrics.cpu = values[0].value
-            continue
-          }
-          if (name === 'process_resident_memory_bytes') {
-            runtimeProcessMetrics.rss = values[0].value
-            continue
-          }
-
-          throw new Error(`Missing ${this.#metricsLabelName} label in metrics`)
-        }
-
-        if (name === 'process_cpu_percent_usage' || name === 'process_resident_memory_bytes') {
-          applicationProcessMetrics.add(`${applicationId}:${name}`)
-        }
-
-        let applicationMetrics = applicationsMetrics[applicationId]
-        if (!applicationMetrics) {
-          applicationMetrics = {
-            cpu: 0,
-            rss: 0,
-            totalHeapSize: 0,
-            usedHeapSize: 0,
-            newSpaceSize: 0,
-            oldSpaceSize: 0,
-            elu: 0,
-            latency: {
-              p50: 0,
-              p90: 0,
-              p95: 0,
-              p99: 0
-            }
-          }
-          applicationsMetrics[applicationId] = applicationMetrics
-        }
-
-        parsePromMetric(applicationMetrics, metric)
-      }
-
-      // Apply the runtime-wide process-level values to every application that did
-      // not report its own (i.e. every application running in a worker thread).
-      for (const [applicationId, applicationMetrics] of Object.entries(applicationsMetrics)) {
-        if (
-          runtimeProcessMetrics.cpu !== undefined &&
-          !applicationProcessMetrics.has(`${applicationId}:process_cpu_percent_usage`)
-        ) {
-          applicationMetrics.cpu = runtimeProcessMetrics.cpu
-        }
-
-        if (
-          runtimeProcessMetrics.rss !== undefined &&
-          !applicationProcessMetrics.has(`${applicationId}:process_resident_memory_bytes`)
-        ) {
-          applicationMetrics.rss = runtimeProcessMetrics.rss
-        }
-      }
-
-      function parsePromMetric (applicationMetrics, promMetric) {
-        const { name } = promMetric
-
-        if (name === 'process_cpu_percent_usage') {
-          applicationMetrics.cpu = promMetric.values[0].value
-          return
-        }
-        if (name === 'process_resident_memory_bytes') {
-          applicationMetrics.rss = promMetric.values[0].value
-          return
-        }
-        if (name === 'nodejs_heap_size_total_bytes') {
-          applicationMetrics.totalHeapSize = promMetric.values[0].value
-          return
-        }
-        if (name === 'nodejs_heap_size_used_bytes') {
-          applicationMetrics.usedHeapSize = promMetric.values[0].value
-          return
-        }
-        if (name === 'nodejs_heap_space_size_total_bytes') {
-          const newSpaceSize = promMetric.values.find(value => value.labels.space === 'new')
-          const oldSpaceSize = promMetric.values.find(value => value.labels.space === 'old')
-
-          applicationMetrics.newSpaceSize = newSpaceSize.value
-          applicationMetrics.oldSpaceSize = oldSpaceSize.value
-          return
-        }
-        if (name === 'nodejs_eventloop_utilization') {
-          applicationMetrics.elu = promMetric.values[0].value
-          return
-        }
-        if (name === 'http_request_all_summary_seconds') {
-          applicationMetrics.latency = {
-            p50: promMetric.values.find(value => value.labels.quantile === 0.5)?.value || 0,
-            p90: promMetric.values.find(value => value.labels.quantile === 0.9)?.value || 0,
-            p95: promMetric.values.find(value => value.labels.quantile === 0.95)?.value || 0,
-            p99: promMetric.values.find(value => value.labels.quantile === 0.99)?.value || 0
-          }
-        }
-      }
-
-      return {
-        version: 1,
-        date: new Date().toISOString(),
-        applications: applicationsMetrics
-      }
-    } catch (err) {
-      // If any metric is missing, return nothing
-      this.logger.warn({ err }, 'Cannot fetch metrics')
-
-      return null
-    }
-  }
-
   getSharedContext () {
     return this.#sharedContext
   }
@@ -2100,12 +2142,16 @@ export class Runtime extends EventEmitter {
   }
 
   async getApplications (allowUnloaded = false) {
-    return {
+    return frozenSnapshot({
       production: this.#isProduction,
       applications: await Promise.all(
-        this.getApplicationsIds().map(id => this.getApplicationDetails(id, allowUnloaded))
+        this.getApplicationsIds().map(id => this.#buildApplicationDetails(id, allowUnloaded))
       )
-    }
+    })
+  }
+
+  async getApplicationDetails (id, allowUnloaded = false) {
+    return frozenSnapshot(await this.#buildApplicationDetails(id, allowUnloaded))
   }
 
   async getApplicationMeta (id) {
@@ -2133,7 +2179,7 @@ export class Runtime extends EventEmitter {
     }
   }
 
-  async getApplicationDetails (id, allowUnloaded = false) {
+  async #buildApplicationDetails (id, allowUnloaded = false) {
     let application
 
     try {
@@ -2146,7 +2192,7 @@ export class Runtime extends EventEmitter {
       throw e
     }
 
-    const { localUrl, config, path } = application[kConfig]
+    const { localUrl, config, configPath, path } = application[kConfig]
 
     const sourceMaps = application[kConfig].sourceMaps ?? this.#config.sourceMaps
     const status = await sendViaITC(application, 'getStatus')
@@ -2155,7 +2201,6 @@ export class Runtime extends EventEmitter {
     const applicationDetails = {
       id,
       type,
-      config,
       path,
       status,
       dependencies,
@@ -2164,6 +2209,27 @@ export class Runtime extends EventEmitter {
       sourceMaps
     }
 
+    /*
+      v3's `config` was the application's configuration file path. v4 evaluates that file main-side
+      and hands the worker the payload, so the path becomes `configPath` and the entry's own
+      `config` is no longer a path to report. Emitting the key that matches the dialect keeps a
+      consumer from reading one and silently getting the other.
+    */
+    if (typeof config === 'string') {
+      applicationDetails.config = config
+    } else if (configPath) {
+      applicationDetails.configPath = configPath
+    }
+
+    // status is worker lifecycle; servingState is how the thing serves. They are different
+    // questions, and the runtime gates URL emission on status === 'started', so they cannot share
+    // a field.
+    const servingState = this.#servingStates.get(id)
+
+    if (servingState) {
+      applicationDetails.servingState = servingState
+    }
+
     if (this.#isProduction) {
       applicationDetails.workers = this.#workers.getKeys(id).length
     }
@@ -2431,6 +2497,17 @@ export class Runtime extends EventEmitter {
     }
   }
 
+  async #refuseUnresolvedApplication (id) {
+    const executable = getExecutable() ?? 'platformatic'
+
+    this.logger.error(
+      `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
+      id
+    )
+
+    await this.closeAndThrow(new RuntimeAbortedError())
+  }
+
   async #setupApplication (applicationConfig) {
     if (this.#status === 'stopping' || this.#status === 'closed') {
       return
@@ -2446,13 +2523,7 @@ export class Runtime extends EventEmitter {
         applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, id)
 
         if (!existsSync(applicationConfig.path)) {
-          const executable = getExecutable() ?? 'platformatic'
-          this.logger.error(
-            `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
-            id
-          )
-
-          await this.closeAndThrow(new RuntimeAbortedError())
+          await this.#refuseUnresolvedApplication(id)
         }
       } else {
         this.logger.error(
@@ -2462,6 +2533,15 @@ export class Runtime extends EventEmitter {
 
         await this.closeAndThrow(new RuntimeAbortedError())
       }
+    } else if (applicationConfig.unresolved) {
+      /*
+        A remote application that declares where its clone belongs, and whose clone is not there --
+        either the directory is missing or it holds no application at all. The pathless case above
+        is the same state said differently, and both are what `resolve` exists to fix, so both get
+        the message that names it rather than the capability detector's report that the directory
+        holds nothing.
+      */
+      await this.#refuseUnresolvedApplication(id)
     }
 
     let workers = applicationConfig.workers.static
@@ -2527,11 +2607,11 @@ export class Runtime extends EventEmitter {
       inspectorOptions.port = inspectorOptions.port + this.#workers.size + 1
     }
 
-    if (config.telemetry) {
-      applicationConfig.telemetry = {
-        ...config.telemetry,
-        ...applicationConfig.telemetry,
-        applicationName: `${config.telemetry.applicationName}-${applicationConfig.id}`
+    if (config.tracing) {
+      applicationConfig.tracing = {
+        ...config.tracing,
+        ...applicationConfig.tracing,
+        applicationName: `${config.tracing.applicationName}-${applicationConfig.id}`
       }
     }
 
@@ -2540,9 +2620,9 @@ export class Runtime extends EventEmitter {
 
     const execArgv = applicationConfig.execArgv ?? []
 
-    if (!applicationConfig.skipTelemetryHooks && config.telemetry && config.telemetry.enabled !== false) {
+    if (!applicationConfig.skipTracingHooks && config.tracing && config.tracing.enabled !== false) {
       const require = createRequire(import.meta.url)
-      const telemetryPath = require.resolve('@platformatic/telemetry')
+      const telemetryPath = require.resolve('@platformatic/tracing')
       const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
       const hookUrl = pathToFileURL(require.resolve('@opentelemetry/instrumentation/hook.mjs'))
 
@@ -2598,6 +2678,7 @@ export class Runtime extends EventEmitter {
     const worker = new Worker(kWorkerFile, {
       workerData: {
         config: workerConfig,
+        meshId: this.#meshId,
         applicationConfig: {
           ...applicationConfig,
           isProduction: this.#isProduction,
@@ -2615,10 +2696,7 @@ export class Runtime extends EventEmitter {
           codeRangeSizeMb
         },
         inspectorOptions,
-        dirname: this.#root,
-        // Keys of the worker environment which only come from an env file of the runtime:
-        // the env file of the application is allowed to override those.
-        envFileFallbackKeys: this.#env[kEnvFileFallbackKeys] ?? []
+        dirname: this.#root
       },
       argv: applicationConfig.arguments,
       execArgv,
@@ -2739,6 +2817,10 @@ export class Runtime extends EventEmitter {
     // Forward events from the worker
     // Do not use emitAndNotify here since we don't want to forward unknown events
     worker[kITC].on('event', ({ event, payload }) => {
+      if (event === 'serverOptions') {
+        worker[kWorkerServerOptions] = payload[0]
+      }
+
       event = `application:worker:event:${event}`
 
       this.emit(event, ...payload, workerId, applicationId, index)
@@ -2924,11 +3006,6 @@ export class Runtime extends EventEmitter {
       this.#workers.set(workerId, worker)
     }
 
-    // Setup the interceptor
-    // kInterceptorReadyPromise resolves when the worker
-    // is ready to receive requests: after calling the replaceServer method
-    worker[kInterceptorReadyPromise] = this.#meshInterceptor.route(applicationId, worker)
-
     // Wait for initialization
     try {
       await waitEventFromITC(worker, 'init')
@@ -3369,12 +3446,6 @@ export class Runtime extends EventEmitter {
 
       this.#recordWorkerUrl(worker, id, workerUrl)
 
-      // Wait for the interceptor to be ready
-      const interceptorResult = await executeWithTimeout(worker[kInterceptorReadyPromise], config.startTimeout)
-      if (interceptorResult === kTimeout) {
-        throw new WorkerInterceptorJoinTimeoutError(label, config.startTimeout)
-      }
-
       worker[kWorkerStatus] = 'started'
       worker[kWorkerStartTime] = Date.now()
 
@@ -3560,7 +3631,6 @@ export class Runtime extends EventEmitter {
   }
 
   async #discardWorker (worker) {
-    await this.#meshInterceptor.unroute(worker[kApplicationId], worker, true)
     worker.removeAllListeners('exit')
     await worker.terminate()
 
@@ -3730,6 +3800,7 @@ export class Runtime extends EventEmitter {
 
     const stopBeforeStart =
       Boolean(worker[kWorkerUrl]) &&
+      worker[kWorkerServerOptions]?.port !== 0 &&
       (config.reuseTcpPorts === false || applicationConfig.reuseTcpPorts === false || !features.node.reusePort)
 
     try {
@@ -3970,11 +4041,20 @@ export class Runtime extends EventEmitter {
   }
 
   async #getRuntimePackageJson () {
-    const runtimeDir = this.#root
-    const packageJsonPath = join(runtimeDir, 'package.json')
-    const packageJsonFile = await readFile(packageJsonPath, 'utf8')
-    const packageJson = JSON.parse(packageJsonFile)
-    return packageJson
+    const packageJsonPath = join(this.#root, 'package.json')
+
+    /*
+      A project need not have one, and a runtime that cannot report its metadata without one is a
+      runtime whose `applications:add --save` stops working -- that command reads `projectDir`,
+      `configPath` and `autoload` from this, and has done since `GET /config` was removed. The
+      metadata already declares `packageName` and `packageVersion` as nullable, so absence is a
+      state its shape allows.
+    */
+    try {
+      return JSON.parse(await readFile(packageJsonPath, 'utf8'))
+    } catch {
+      return {}
+    }
   }
 
   #handleWorkerStandardStreams (worker, applicationId, workerId) {
@@ -4391,6 +4471,10 @@ export class Runtime extends EventEmitter {
           report.started.push(newIndex)
           startedWorkersCount++
         }
+
+        // A worker added after boot re-runs the application's code, so it can answer differently
+        // from the workers already running. Scale-up is the second place the answers must agree.
+        await this.#collectServingState(applicationId)
         report.success = true
       } catch (err) {
         if (pendingWorkerId) {
@@ -4478,6 +4562,10 @@ export class Runtime extends EventEmitter {
       }
     }
 
+    if (applicationConfig.sourcePath) {
+      allows.add(`--allow-fs-read=${join(applicationConfig.sourcePath, '*')}`)
+    }
+
     if (write?.length) {
       for (const p of write) {
         allows.add(`--allow-fs-write=${isAbsolute(p) ? p : join(applicationConfig.path, p)}`)
@@ -4952,18 +5040,6 @@ export class Runtime extends EventEmitter {
     this.#loggerContext.updatePrefixes(ids)
   }
 
-  #onMeshInterceptorError (error) {
-    const worker = error.port
-
-    this.logger.error(
-      { err: ensureLoggableError(error.cause) },
-      `The ${this.#workerExtendedLabel(worker[kApplicationId], worker[kWorkerId])} threw an error during mesh network setup. Replacing it ...`
-    )
-
-    this.emit('application:worker:init:failed', { application: worker[kApplicationId], worker: worker[kWorkerId] })
-    worker.terminate()
-  }
-
   #getPortOwner (port, applicationId, hostname, includeSameApplication = false) {
     if (!Number.isInteger(port) || port <= 0) {
       return null