@platformatic/runtime 3.71.1-alpha.0 → 4.0.0-alpha.1

package/lib/config.js

@@ -1,103 +1,109 @@
-import { importCapabilityAndConfig, validationOptions } from '@platformatic/basic'
-import {
-  extractModuleFromSchemaUrl,
-  findConfigurationFile,
-  kMetadata,
-  loadConfiguration,
-  loadConfigurationModule,
-  loadModule,
-  omitProperties,
-  runtimeUnwrappablePropertiesList
-} from '@platformatic/foundation'
-import { realpathSync } from 'node:fs'
-import { readdir, readFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
-import { isAbsolute, join, resolve as resolvePath } from 'node:path'
+import { createDirectory, kMetadata, loadModule } from '@platformatic/foundation'
+import { loadAdditionalApplications } from '@platformatic/foundation/loader'
+import { createRequire, findPackageJSON } from 'node:module'
+import { availableParallelism } from 'node:os'
+import { dirname, resolve as resolvePath } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import {
-  ApplicationIdCollisionError,
+  ApplicationsPortsOverlapError,
   InspectAndInspectBrkError,
   InspectorHostError,
   InspectorPortError,
   InvalidArgumentError,
-  InvalidEntrypointError
+  MissingDependencyError
 } from './errors.js'
-import { schema } from './schema.js'
-import { upgrade } from './upgrade.js'
+
+// The runtime package's own entry point, which is where the bundled capability copies live.
+const runtimeScopePath = fileURLToPath(new URL('../index.js', import.meta.url))
 
 // Validate and coerce workers values early to avoid runtime hangs when invalid
-function coercePositiveInteger (value) {
-  if (typeof value === 'number') {
-    if (!Number.isInteger(value) || value < 1) return null
-    return value
+function coercePositiveInteger (value, location) {
+  const count = typeof value === 'string' ? Number(value) : value
+  if (!Number.isInteger(count) || count < 1) {
+    const hint = typeof value === 'string' && /\{.*\}/.test(value) ? ' (check your environment variable)' : ''
+    throw new InvalidArgumentError(`${location} workers must be a positive integer; received "${value}"${hint}`)
   }
-  if (typeof value === 'string') {
-    // Trim to handle accidental spaces
-    const trimmed = value.trim()
-    if (trimmed.length === 0) return null
-    const num = Number(trimmed)
-    if (!Number.isFinite(num) || !Number.isInteger(num) || num < 1) return null
-    return num
-  }
-  return null
+  return count
 }
 
-function raiseInvalidWorkersError (location, received, hint) {
-  const extra = hint ? ` (${hint})` : ''
-  throw new InvalidArgumentError(`${location} workers must be a positive integer; received "${received}"${extra}`)
-}
+function coerceWorkers (workers, prefix) {
+  if (workers === undefined) return {}
 
-function parseWorkers (config, prefix, defaultWorkers = { static: 1, dynamic: false }) {
-  if (typeof config.workers !== 'undefined') {
-    // Number
-    if (typeof config.workers !== 'object') {
-      const coerced = coercePositiveInteger(config.workers)
-
-      if (coerced === null) {
-        const raw = config.workers
-        const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
-        raiseInvalidWorkersError(prefix, config.workers, hint)
-      } else {
-        config.workers = { static: coerced, dynamic: false }
-      }
-      // Object
-    } else {
-      for (const key of ['minimum', 'maximum', 'static']) {
-        if (typeof config.workers[key] === 'undefined') {
-          continue
-        }
-
-        const coerced = coercePositiveInteger(config.workers[key])
-        if (coerced === null) {
-          const raw = config.workers
-          const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
-          raiseInvalidWorkersError(`${prefix} ${key}`, config.workers, hint)
-        } else {
-          config.workers[key] = coerced
-        }
-      }
+  if (typeof workers !== 'object') {
+    return {
+      static: coercePositiveInteger(workers, prefix),
+      dynamic: false
     }
-  } else {
-    config.workers = {}
   }
 
-  // Fill missing values from defaults
-  for (const key of ['minimum', 'maximum', 'static', 'dynamic']) {
-    if (typeof config.workers[key] === 'undefined' && typeof defaultWorkers[key] !== 'undefined') {
-      config.workers[key] = defaultWorkers[key]
+  for (const key of ['minimum', 'maximum', 'static']) {
+    if (workers[key] !== undefined) {
+      workers[key] = coercePositiveInteger(workers[key], `${prefix} ${key}`)
     }
   }
+  return workers
+}
+
+function parseRuntimeWorkers (config) {
+  const workers = coerceWorkers(config.workers, 'Runtime')
+  workers.total ??= availableParallelism()
+  workers.static ??= 1
+  workers.dynamic ??= false
+
+  // Ajv does not apply property defaults inside the workers schema's anyOf branches.
+  workers.eluThreshold ??= 0.8
+  workers.processIntervalMs ??= 10000
+  workers.maxScaleUpStep ??= 1
+  workers.redistributionMs ??= 10000
+  workers.alphaUp ??= 0.2
+  workers.alphaDown ??= 0.1
+  workers.betaUp ??= 0.1
+  workers.betaDown ??= 0.1
+  workers.cooldowns ??= {}
+  workers.cooldowns.scaleUpAfterScaleUpMs ??= 5000
+  workers.cooldowns.scaleUpAfterScaleDownMs ??= 5000
+  workers.cooldowns.scaleDownAfterScaleUpMs ??= 30000
+  workers.cooldowns.scaleDownAfterScaleDownMs ??= 20000
+
+  if (workers.maximum < workers.minimum) {
+    throw new InvalidArgumentError(
+      `Workers minimum (${workers.minimum}) must not exceed maximum (${workers.maximum})`
+    )
+  }
+  if (workers.dynamic) {
+    workers.static = workers.minimum ?? 1
+  }
+
+  config.workers = workers
+}
 
-  // Additional validations
-  if (config.workers.maximum < config.workers.minimum) {
-    const t = config.workers.minimum
-    config.workers.minimum = config.workers.maximum
-    config.workers.maximum = t
+function parseApplicationWorkers (applicationConfig, config) {
+  const workers = coerceWorkers(applicationConfig.workers, `Service "${applicationConfig.id}"`)
+  for (const key of ['minimum', 'maximum', 'static', 'dynamic']) {
+    if (workers[key] === undefined && config.workers[key] !== undefined) {
+      workers[key] = config.workers[key]
+    }
   }
 
-  if (typeof config.workers.static === 'undefined') {
-    config.workers.static = config.workers.minimum
+  if (workers.maximum < workers.minimum) {
+    throw new InvalidArgumentError(
+      `Workers minimum (${workers.minimum}) must not exceed maximum (${workers.maximum})`
+    )
   }
+  if (workers.dynamic) {
+    for (const key of ['eluThreshold', 'heapThresholdMb']) {
+      if (workers[key] === undefined && config.workers[key] !== undefined) {
+        workers[key] = config.workers[key]
+      }
+    }
+    workers.minimum ??= 1
+    // An implicit maximum must accommodate the application's required minimum.
+    workers.maximum ??= Math.max(workers.minimum, config.workers.total)
+    workers.static = workers.minimum
+  }
+
+  applicationConfig.workers = workers
 }
 
 export function pprofCapturePreloadPath () {
@@ -130,62 +136,6 @@ export function autoDetectPprofCapture (config) {
   return config
 }
 
-export async function wrapInRuntimeConfig (config, context) {
-  let applicationId = 'main'
-  try {
-    const packageJson = JSON.parse(await readFile(join(config[kMetadata].root, 'package.json'), 'utf-8'))
-    applicationId = packageJson?.name ?? 'main'
-
-    if (applicationId.startsWith('@')) {
-      applicationId = applicationId.split('/')[1]
-    }
-  } catch (err) {
-    // on purpose, the package.json might be missing
-  }
-
-  // Carry over only the server properties that the user actually set, so
-  // we do not end up with a `{ hostname: undefined, ... }` object that then
-  // gets populated by schema defaults or trips truthy checks downstream.
-  const server = {}
-  if (config.server) {
-    for (const key of ['hostname', 'port', 'http2', 'https']) {
-      if (config.server[key] !== undefined) {
-        server[key] = config.server[key]
-      }
-    }
-  }
-  const production = context?.isProduction ?? context?.production
-
-  const runtimeConfig = config.runtime ?? {}
-
-  // Important: do not change the order of the properties in this object
-  /* c8 ignore next */
-  const wrapped = {
-    $schema: schema.$id,
-    ...(Object.keys(server).length > 0 ? { server } : {}),
-    watch: !production,
-    ...omitProperties(runtimeConfig, runtimeUnwrappablePropertiesList),
-    entrypoint: applicationId,
-    applications: [
-      {
-        id: applicationId,
-        path: config[kMetadata].root,
-        config: config[kMetadata].path,
-        ...(runtimeConfig.application ?? {})
-      }
-    ]
-  }
-
-  return loadConfiguration(wrapped, context?.schema ?? schema, {
-    validationOptions,
-    transform,
-    upgrade,
-    replaceEnv: true,
-    root: config[kMetadata].root,
-    ...context
-  })
-}
-
 export function parseInspectorOptions (config, inspect, inspectBreak) {
   const hasInspect = inspect != null
   const hasInspectBrk = inspectBreak != null
@@ -228,297 +178,226 @@ export function parseInspectorOptions (config, inspect, inspectBreak) {
   config.watch = false
 }
 
-export async function prepareApplication (config, application, defaultWorkers) {
-  // We need to have absolute paths here, ot the `loadConfig` will fail
-  // Make sure we don't resolve if env var was not replaced
-  if (application.path && !isAbsolute(application.path) && !application.path.match(/^\{.*\}$/)) {
-    application.path = resolvePath(config[kMetadata].root, application.path)
-  }
+/*
+  The one entry point for applications added while the runtime is running, shared by the HTTP route
+  and the management ITC handler so the two cannot drift.
+
+  An added application is evaluated exactly as boot evaluates one -- its configuration
+  file is found in its own directory, its environment is resolved main-side, and it arrives with
+  resolvedConfig. Skipping that leaves the worker to look for a config file name that is never written,
+  which fails as an unhelpful "unable to initialize the worker".
+*/
+export async function prepareAddedApplications (config, entries, existingIds = []) {
+  const metadata = config[kMetadata]
+
+  const { applications } = await loadAdditionalApplications({
+    configPath: metadata.path,
+    entries,
+    existingIds,
+    rootEnvBlock: config.env,
+    command: metadata.loader.command,
+    mode: metadata.loader.mode,
+    production: metadata.loader.production,
+    realEnv: metadata.loader.realEnv,
+    customEnvFile: metadata.loader.customEnvFile,
+    // The runtime is the fallback scope for capability resolution, the same as at boot.
+    runtimeScope: runtimeScopePath
+  })
 
-  if (application.path && application.config) {
-    application.config = resolvePath(application.path, application.config)
+  const prepared = []
+
+  for (const application of applications) {
+    prepared.push(await prepareRuntimeApplication(config, application))
   }
 
-  // Skip capability detection for external services (url without path)
-  // These services will have their path resolved later in runtime.js #setupApplication
-  // Attempting to detect capability here would cause slow glob operations on the cwd
-  if (application.url && !application.path) {
-    application.type = 'unknown'
-  } else {
-    try {
-      let pkg
+  return prepared
+}
 
-      if (application.config) {
-        const config = await loadConfiguration(application.config)
-        pkg = await loadConfigurationModule(application.path, config)
+const hostnameWildcards = new Set(['0.0.0.0', '::', '[::]'])
 
-        application.type = extractModuleFromSchemaUrl(config, true).module
-        application.skipTelemetryHooks = pkg.skipTelemetryHooks
-      } else {
-        const { moduleName, capability } = await importCapabilityAndConfig(application.path)
-        pkg = capability
+// The listener an application declares in its own configuration, when it can be determined without
+// starting it. A port coming from an environment variable which was not replaced, an ephemeral port
+// and a missing server block all yield null, in which case only the start time check applies.
+function declaredListener (applicationConfig) {
+  const server = applicationConfig?.server
 
-        application.type = moduleName
-      }
+  if (!server) {
+    return null
+  }
 
-      application.skipTelemetryHooks = pkg.skipTelemetryHooks
+  const port = Number(server.port)
 
-      // This is needed to work around Rust bug on dylibs:
-      // https://github.com/rust-lang/rust/issues/91979
-      // https://github.com/rollup/rollup/issues/5761
-      const _require = createRequire(application.path)
-      for (const m of pkg.modulesToLoad ?? []) {
-        const toLoad = _require.resolve(m)
-        loadModule(_require, toLoad).catch(() => {})
-      }
-    } catch (err) {
-      // This should not happen, it happens on running some unit tests if we prepare the runtime
-      // when not all the applications configs are available. Given that we are running this only
-      // to ddetermine the type of the application, it's safe to ignore this error and default to unknown
-      application.type = 'unknown'
-    }
+  if (!Number.isInteger(port) || port <= 0) {
+    return null
   }
 
-  // Validate and coerce per-service workers
-  parseWorkers(application, `Service "${application.id}"`, defaultWorkers)
+  return { port, hostname: server.hostname, perWorker: server.portAssignment === 'perWorkerIncrement' }
+}
 
-  application.entrypoint = application.id === config.entrypoint
-  application.dependencies ??= []
-  application.localUrl = `http://${application.id}.plt.local`
+// Two declared listeners can only be compared when both hostnames are known. When a hostname is
+// omitted the capability picks its own default, so unless the other side is a wildcard - which
+// overlaps with anything - the comparison is left to the start time check.
+function declaredListenersOverlap (first, second) {
+  const hostname = first.hostname?.toLowerCase()
+  const otherHostname = second.hostname?.toLowerCase()
 
-  if (typeof application.watch === 'undefined') {
-    application.watch = config.watch
+  // A wildcard overlaps with any other hostname, known or not
+  if (hostnameWildcards.has(hostname) || hostnameWildcards.has(otherHostname)) {
+    return true
   }
 
-  if (typeof application.management === 'undefined' && config.management) {
-    application.management = config.management
+  // Both applications rely on the same capability default, so they do collide
+  if (typeof hostname === 'undefined' && typeof otherHostname === 'undefined') {
+    return true
   }
 
-  return application
+  // Only one of the two defaults is unknown, so nothing can be concluded here
+  if (typeof hostname === 'undefined' || typeof otherHostname === 'undefined') {
+    return false
+  }
+
+  return hostname === otherHostname
 }
 
-function canonicalPath (path) {
-  try {
-    return realpathSync(path)
-  } catch {
-    return resolvePath(path)
-  }
+function describeDeclaredPorts (listener) {
+  const { port, last } = listener
+  return port === last ? `port ${port}` : `ports ${port}-${last}, one per worker`
 }
 
-// An autoloaded directory and an explicitly configured entry with the same id are the same application
-// only when they point to the same place: either the configured path resolves to the autoloaded
-// directory, or the entry is external and the autoloaded directory is where "resolve" would put it.
-// When they don't, returns a description of the configured entry to report in the error.
-function conflictingApplicationSource (root, resolvedApplicationsPath, existing, entryPath) {
-  if (existing.path) {
-    // The path still contains a placeholder, which means the environment variable was not replaced.
-    // There is nothing to compare in that case.
-    if (existing.path.match(/^\{.*\}$/)) {
-      return null
+// Rejects applications whose declared ports overlap before any of them is started, so that the
+// failure does not depend on which worker happens to report its URL first. This is best effort:
+// applications whose port cannot be determined here are checked when their workers start.
+function verifyApplicationsPorts (applications) {
+  const listeners = []
+
+  for (const application of applications) {
+    // The validated capability configuration is kept on the application (resolvedConfig), so the
+    // declared listener is read from it directly rather than being stashed on a symbol during a
+    // separate config-loading pass, as it once was.
+    const listener = declaredListener(application.resolvedConfig)
+
+    // Dynamic scaling changes how many ports the application ends up using, so leave it to the start time check
+    if (!listener || application.workers?.dynamic) {
+      continue
     }
 
-    const existingPath = isAbsolute(existing.path) ? existing.path : resolvePath(root, existing.path)
-
-    return canonicalPath(existingPath) === canonicalPath(entryPath) ? null : `the path "${existing.path}"`
+    const workers = listener.perWorker ? (application.workers?.static ?? 1) : 1
+    listeners.push({ ...listener, id: application.id, last: listener.port + workers - 1 })
   }
 
-  if (existing.url) {
-    const resolvedPath = join(resolvedApplicationsPath, existing.id)
+  for (let i = 0; i < listeners.length; i++) {
+    for (let j = i + 1; j < listeners.length; j++) {
+      const first = listeners[i]
+      const second = listeners[j]
 
-    return canonicalPath(resolvedPath) === canonicalPath(entryPath) ? null : `the URL "${existing.url}"`
-  }
+      const port = Math.max(first.port, second.port)
 
-  return null
+      if (port > Math.min(first.last, second.last) || !declaredListenersOverlap(first, second)) {
+        continue
+      }
+
+      throw new ApplicationsPortsOverlapError(
+        first.id,
+        describeDeclaredPorts(first),
+        second.id,
+        describeDeclaredPorts(second),
+        port
+      )
+    }
+  }
 }
 
-function isApplicationEnabled (application, environment) {
-  const { enabled } = application
+// Everything an application needs regardless of how its capability was determined, taken from the
+// loader's envelope before any worker exists rather than by loading the application's config file.
+export function finalizeApplication (config, application) {
+  // Validate and coerce per-service workers
+  parseApplicationWorkers(application, config)
 
-  if (typeof enabled === 'undefined') {
-    return true
-  }
+  application.dependencies ??= []
+  application.localUrl = `http://${application.id}.plt.local`
 
-  if (typeof enabled === 'string') {
-    return enabled !== 'false'
+  if (typeof application.watch === 'undefined') {
+    application.watch = config.watch
   }
 
-  if (typeof enabled === 'object' && enabled !== null) {
-    return enabled[environment] ?? true
+  if (typeof application.management === 'undefined' && config.management) {
+    application.management = config.management
   }
 
-  return enabled
+  return application
 }
 
-export async function transform (config, _, context) {
-  const production = context?.isProduction ?? context?.production
-  const environment = production ? 'production' : 'development'
-  const applications = [...(config.applications ?? []), ...(config.services ?? []), ...(config.web ?? [])]
-
-  const watchType = typeof config.watch
-  if (watchType === 'string') {
-    config.watch = config.watch === 'true'
-  } else if (watchType === 'undefined') {
-    config.watch = !production
-  }
-
-  // Migrate the old verticalScaler property, only applied if the new settings are not set, otherwise workers takes precedence
-  // TODO: Remove in the next major version
-  if (config.verticalScaler) {
-    config.workers ??= {}
-    config.workers.total ??= config.verticalScaler.maxTotalWorkers
-    config.workers.dynamic ??= config.verticalScaler.enabled
-    config.workers.minimum ??= config.verticalScaler.minWorkers ?? 1
-    config.workers.maximum ??= config.verticalScaler.maxWorkers ?? config.verticalScaler.maxTotalWorkers ?? 1
-    config.workers.maxMemory ??= config.verticalScaler.maxTotalMemory
-
-    if (config.verticalScaler.cooldownSec) {
-      config.workers.cooldown ??= config.verticalScaler.cooldownSec * 1000
-    }
-    if (config.verticalScaler.gracePeriod) {
-      config.workers.gracePeriod ??= config.verticalScaler.gracePeriod
-    }
-    if (config.verticalScaler.scaleUpELU) {
-      config.workers.scaleUpELU ??= config.verticalScaler.scaleUpELU
-    }
-    if (config.verticalScaler.scaleDownELU) {
-      config.workers.scaleDownELU ??= config.verticalScaler.scaleDownELU
+/*
+  The preparation step. The loader resolved the path, selected the capability and imported its schema
+  subpath — which carries skipTracingHooks and modulesToLoad — all main-side, before any worker
+  existed. So there is nothing to discover here, and in particular no application config file to
+  re-read: that is the whole point of evaluating configuration exactly once per load.
+*/
+export async function prepareRuntimeApplication (config, application) {
+  // resolvedConfig replaces the config file path in workerData: the worker receives the validated
+  // capability payload as data and never re-reads a file.
+  application.resolvedConfig = application.config ?? {}
+  application.config = undefined
+
+  /*
+    A module application names an npm package as its capability instead of describing one in a file.
+    The package is resolved from the runtime root, and its own directory (sourcePath) is kept
+    separate from the application's writable root (path) — which the module treats as a working
+    directory and which need not exist yet. Keyed on moduleApplication, not module: a regular
+    application also carries a module (its detected capability), and must not be resolved this way.
+  */
+  if (application.moduleApplication) {
+    if (!application.path) {
+      throw new InvalidArgumentError(`Application "${application.id}" must define path when module is set`)
     }
 
-    if (config.verticalScaler.applications) {
-      for (const appId in config.verticalScaler.applications) {
-        let appConfig = applications.find((app) => app.id === appId)
-        if (!appConfig) {
-          appConfig = { id: appId, workers: {} }
-          applications.push(appConfig)
-        }
-
-        const scaleConfig = config.verticalScaler.applications[appId]
-        const workersConfig = appConfig.workers
-
-        workersConfig.minimum ??= scaleConfig.minWorkers ?? config.workers.minimum
-        workersConfig.maximum ??= scaleConfig.maxWorkers ?? config.workers.maximum
-
-        if (scaleConfig.scaleUpELU) {
-          workersConfig.scaleUpELU ??= scaleConfig.scaleUpELU
-        }
-        if (scaleConfig.scaleDownELU) {
-          workersConfig.scaleDownELU ??= scaleConfig.scaleDownELU
-        }
-      }
+    try {
+      application.sourcePath = dirname(findPackageJSON(application.module, resolvePath(config[kMetadata].root, 'noop.js')))
+    } catch (error) {
+      throw new MissingDependencyError(application.module, { cause: error })
     }
 
-    config.verticalScaler = undefined
+    application.moduleRoot = config[kMetadata].root
+    await createDirectory(application.path)
   }
 
-  if (config.autoload) {
-    const { exclude = [], mappings = {} } = config.autoload
-    let { path } = config.autoload
-
-    // Capture these before the loop, as config is shadowed in its body
-    const root = config[kMetadata].root
-    const resolvedApplicationsPath = resolvePath(root, config.resolvedApplicationsBasePath ?? 'external')
-
-    path = resolvePath(root, path)
-    const entries = await readdir(path, { withFileTypes: true })
-
-    for (let i = 0; i < entries.length; ++i) {
-      const entry = entries[i]
-
-      if (exclude.includes(entry.name) || !entry.isDirectory()) {
-        continue
-      }
-
-      const mapping = mappings[entry.name] ?? {}
-      const id = mapping.id ?? entry.name
-      const entryPath = join(path, entry.name)
-
-      let config
-      const configFilename = mapping.config ?? (await findConfigurationFile(entryPath))
-
-      if (typeof configFilename === 'string') {
-        config = join(entryPath, configFilename)
-      }
-
-      const application = { id, config, path: entryPath, ...mapping }
-      const existingApplicationId = applications.findIndex(application => application.id === id)
-
-      if (existingApplicationId !== -1) {
-        const existing = applications[existingApplicationId]
+  application.type = application.module ?? 'unknown'
+  application.skipTracingHooks = application.capabilityMetadata?.skipTracingHooks ?? false
 
-        // Merging on the id alone can boot local code where the configuration named a repository, as
-        // the autoloaded path survives next to the configured url. Reject the duplicate instead: an id
-        // is the mesh hostname, the injected PLT_<ID>_URL name, the metrics label and the argument of
-        // "wattpm inject", so two different applications cannot share one.
-        if (isApplicationEnabled(existing, environment)) {
-          const source = conflictingApplicationSource(root, resolvedApplicationsPath, existing, entryPath)
+  // This is needed to work around a Rust bug on dylibs.
+  const modulesToLoad = application.capabilityMetadata?.modulesToLoad ?? []
 
-          if (source) {
-            throw new ApplicationIdCollisionError(id, entryPath, source)
-          }
-        }
+  if (modulesToLoad.length > 0 && application.path) {
+    const _require = createRequire(application.sourcePath ?? application.path)
 
-        applications[existingApplicationId] = { ...application, ...existing }
-      } else {
-        applications.push(application)
+    for (const m of modulesToLoad) {
+      try {
+        loadModule(_require, _require.resolve(m)).catch(() => {})
+      } catch {
+        // A module the capability names but the application cannot resolve is not fatal here; the
+        // worker reports it with its own context when it actually needs it.
       }
     }
   }
 
-  for (let i = applications.length - 1; i >= 0; --i) {
-    if (!isApplicationEnabled(applications[i], environment)) {
-      applications.splice(i, 1)
-    }
-  }
+  return finalizeApplication(config, application)
+}
 
+// The half of the transform the loader does not own: inspector options, worker counts, the
+// per-application preparation, and the runtime-level normalizations. This is reached directly,
+// having already expanded autoload and resolved enabled in the eval worker.
+export async function finalizeConfiguration (config, applications, context, production, prepare) {
   config.inspectorOptions = undefined
   parseInspectorOptions(config, context?.inspect, context?.inspectBreak)
 
-  let hasValidEntrypoint = false
-
   // Root-level workers
-  parseWorkers(config, 'Runtime', { static: 1, dynamic: false })
-  const defaultWorkers = config.workers
+  parseRuntimeWorkers(config)
 
   for (let i = 0; i < applications.length; ++i) {
-    const application = await prepareApplication(config, applications[i], defaultWorkers)
-
-    if (application.entrypoint) {
-      hasValidEntrypoint = true
-    }
+    await prepare(config, applications[i])
   }
 
-  // If there is no entrypoint, autodetect one
-  if (!config.entrypoint) {
-    // If there is only one application, it becomes the entrypoint
-    if (applications.length === 1) {
-      applications[0].entrypoint = true
-      config.entrypoint = applications[0].id
-      hasValidEntrypoint = true
-    } else {
-      // Search if exactly application uses @platformatic/gateway
-      const gateways = []
-
-      for (const application of applications) {
-        if (!application.config) {
-          continue
-        }
-
-        if (application.type === '@platformatic/gateway') {
-          gateways.push(application.id)
-        }
-      }
-
-      if (gateways.length === 1) {
-        applications.find(s => s.id === gateways[0]).entrypoint = true
-        config.entrypoint = gateways[0]
-        hasValidEntrypoint = true
-      }
-    }
-  }
-
-  if (!hasValidEntrypoint && config.entrypoint && !context.allowMissingEntrypoint) {
-    throw new InvalidEntrypointError(config.entrypoint)
-  }
+  verifyApplicationsPorts(applications)
 
   if (typeof config.metrics === 'boolean') {
     config.metrics = {
@@ -557,3 +436,27 @@ export async function transform (config, _, context) {
 
   return config
 }
+
+/*
+  The transform. What is absent is the point:
+
+  - no alias merging, because `services` and `web` do not exist;
+  - no autoload expansion and no `enabled` filtering, because both ran in the root eval worker,
+    which is the only place either runs. Leaving them reachable here would let a second expansion
+    re-merge entries and read the filesystem after the authoritative snapshot already exists;
+  - no verticalScaler migration, which the schema audit removes.
+
+  The `autoload` declaration survives as data beside the expanded list — `GET /metadata` reports it
+  and `applications:add --save` needs it to decide whether a new application belongs in a mapping
+  or as an explicit entry. It is carried, never re-executed.
+*/
+export async function transformConfiguration (config, _, context) {
+  const production = context?.isProduction ?? context?.production
+  const applications = config.applications ?? []
+
+  if (typeof config.watch === 'undefined') {
+    config.watch = !production
+  }
+
+  return finalizeConfiguration(config, applications, context, production, prepareRuntimeApplication)
+}