@platformatic/runtime 3.68.0 → 4.0.0-new-config.0

package/lib/config.js

@@ -9,22 +9,24 @@ import {
   omitProperties,
   runtimeUnwrappablePropertiesList
 } from '@platformatic/foundation'
-import { realpathSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
+import { loadAdditionalApplications } from '@platformatic/foundation/lib/v4/index.js'
 import { isAbsolute, join, resolve as resolvePath } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import {
-  ApplicationIdCollisionError,
   InspectAndInspectBrkError,
   InspectorHostError,
   InspectorPortError,
-  InvalidArgumentError,
-  InvalidEntrypointError
+  InvalidArgumentError
 } 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') {
@@ -143,17 +145,6 @@ export async function wrapInRuntimeConfig (config, context) {
     // 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 ?? {}
@@ -162,10 +153,8 @@ export async function wrapInRuntimeConfig (config, context) {
   /* c8 ignore next */
   const wrapped = {
     $schema: schema.$id,
-    ...(Object.keys(server).length > 0 ? { server } : {}),
     watch: !production,
     ...omitProperties(runtimeConfig, runtimeUnwrappablePropertiesList),
-    entrypoint: applicationId,
     applications: [
       {
         id: applicationId,
@@ -228,6 +217,49 @@ export function parseInspectorOptions (config, inspect, inspectBreak) {
   config.watch = false
 }
 
+/*
+  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.
+
+  Under v4 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 v3 file name that v4 never writes,
+  which fails as an unhelpful "unable to initialize the worker".
+*/
+export async function prepareAddedApplications (config, entries, existingIds = []) {
+  const metadata = config[kMetadata]
+
+  if (!metadata?.v4) {
+    const prepared = []
+
+    for (const entry of entries) {
+      prepared.push(await prepareApplication(config, entry, config.workers))
+    }
+
+    return prepared
+  }
+
+  const { applications } = await loadAdditionalApplications({
+    configPath: metadata.path,
+    entries,
+    existingIds,
+    rootEnvBlock: config.env,
+    command: metadata.v4.command,
+    mode: metadata.v4.mode,
+    production: metadata.v4.production,
+    // The runtime is the fallback scope for capability resolution, the same as at boot.
+    runtimeScope: runtimeScopePath
+  })
+
+  const prepared = []
+
+  for (const application of applications) {
+    prepared.push(await prepareV4Application(config, application, config.workers))
+  }
+
+  return prepared
+}
+
 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
@@ -249,10 +281,10 @@ export async function prepareApplication (config, application, defaultWorkers) {
       let pkg
 
       if (application.config) {
-        const config = await loadConfiguration(application.config)
-        pkg = await loadConfigurationModule(application.path, config)
+        const applicationConfig = await loadConfiguration(application.config)
+        pkg = await loadConfigurationModule(application.path, applicationConfig)
 
-        application.type = extractModuleFromSchemaUrl(config, true).module
+        application.type = extractModuleFromSchemaUrl(applicationConfig, true).module
         application.skipTelemetryHooks = pkg.skipTelemetryHooks
       } else {
         const { moduleName, capability } = await importCapabilityAndConfig(application.path)
@@ -279,10 +311,16 @@ export async function prepareApplication (config, application, defaultWorkers) {
     }
   }
 
+  return finalizeApplication(config, application, defaultWorkers)
+}
+
+// Everything an application needs regardless of how its capability was determined. v3 discovers
+// that by loading the application's config file; v4 has it from the loader's envelope before any
+// worker exists.
+export function finalizeApplication (config, application, defaultWorkers) {
   // Validate and coerce per-service workers
   parseWorkers(application, `Service "${application.id}"`, defaultWorkers)
 
-  application.entrypoint = application.id === config.entrypoint
   application.dependencies ??= []
   application.localUrl = `http://${application.id}.plt.local`
 
@@ -297,38 +335,37 @@ export async function prepareApplication (config, application, defaultWorkers) {
   return application
 }
 
-function canonicalPath (path) {
-  try {
-    return realpathSync(path)
-  } catch {
-    return resolvePath(path)
-  }
-}
-
-// 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
+/*
+  The v4 preparation. The loader resolved the path, selected the capability and imported its schema
+  subpath — which carries skipTelemetryHooks 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 prepareV4Application (config, application, defaultWorkers) {
+  // resolvedConfig replaces v3's 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
+  application.type = application.module ?? 'unknown'
+  application.skipTelemetryHooks = application.capabilityMetadata?.skipTelemetryHooks ?? false
+
+  // This is needed to work around a Rust bug on dylibs, as in the v3 path.
+  const modulesToLoad = application.capabilityMetadata?.modulesToLoad ?? []
+
+  if (modulesToLoad.length > 0 && application.path) {
+    const _require = createRequire(application.path)
+
+    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.
+      }
     }
-
-    const existingPath = isAbsolute(existing.path) ? existing.path : resolvePath(root, existing.path)
-
-    return canonicalPath(existingPath) === canonicalPath(entryPath) ? null : `the path "${existing.path}"`
   }
 
-  if (existing.url) {
-    const resolvedPath = join(resolvedApplicationsPath, existing.id)
-
-    return canonicalPath(resolvedPath) === canonicalPath(entryPath) ? null : `the URL "${existing.url}"`
-  }
-
-  return null
+  return finalizeApplication(config, application, defaultWorkers)
 }
 
 function isApplicationEnabled (application, environment) {
@@ -393,7 +430,7 @@ export async function transform (config, _, context) {
         }
 
         const scaleConfig = config.verticalScaler.applications[appId]
-        const workersConfig = appConfig.workers
+        const workersConfig = appConfig.workers ??= {}
 
         workersConfig.minimum ??= scaleConfig.minWorkers ?? config.workers.minimum
         workersConfig.maximum ??= scaleConfig.maxWorkers ?? config.workers.maximum
@@ -414,11 +451,7 @@ export async function transform (config, _, context) {
     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)
+    path = resolvePath(config[kMetadata].root, path)
     const entries = await readdir(path, { withFileTypes: true })
 
     for (let i = 0; i < entries.length; ++i) {
@@ -443,21 +476,7 @@ export async function transform (config, _, context) {
       const existingApplicationId = applications.findIndex(application => application.id === id)
 
       if (existingApplicationId !== -1) {
-        const existing = applications[existingApplicationId]
-
-        // 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)
-
-          if (source) {
-            throw new ApplicationIdCollisionError(id, entryPath, source)
-          }
-        }
-
-        applications[existingApplicationId] = { ...application, ...existing }
+        applications[existingApplicationId] = { ...application, ...applications[existingApplicationId] }
       } else {
         applications.push(application)
       }
@@ -470,54 +489,22 @@ export async function transform (config, _, context) {
     }
   }
 
+  return finalizeConfiguration(config, applications, context, production, prepareApplication)
+}
+
+// The half of the transform the loader does not own: inspector options, worker counts, the
+// per-application preparation, and the runtime-level normalizations. v4 reaches this 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
 
   for (let i = 0; i < applications.length; ++i) {
-    const application = await prepareApplication(config, applications[i], defaultWorkers)
-
-    if (application.entrypoint) {
-      hasValidEntrypoint = true
-    }
-  }
-
-  // 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)
+    await prepare(config, applications[i], defaultWorkers)
   }
 
   if (typeof config.metrics === 'boolean') {
@@ -557,3 +544,27 @@ export async function transform (config, _, context) {
 
   return config
 }
+
+/*
+  The v4 transform. What is absent is the point:
+
+  - no alias merging, because `services` and `web` do not exist in v4;
+  - 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 transformV4 (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, prepareV4Application)
+}

package/lib/errors.js

@@ -13,7 +13,11 @@ export const ERROR_PREFIX = 'PLT_RUNTIME'
 
 export const AddressInUseError = createError(
   `${ERROR_PREFIX}_EADDR_IN_USE`,
-  'The current port is in use by another application'
+  'Port %d is already in use by applications "%s" and "%s"'
+)
+export const WorkerAddressInUseError = createError(
+  `${ERROR_PREFIX}_WORKER_EADDR_IN_USE`,
+  'Port %d is already in use by another worker of the application "%s". Multiple workers can share a port only when the reusePort feature is available in your OS, otherwise set "server.portAssignment" to "perWorkerIncrement" in the application configuration or use a single worker.'
 )
 export const RuntimeExitedError = createError(
   `${ERROR_PREFIX}_RUNTIME_EXIT`,
@@ -98,18 +102,6 @@ export const NoConfigFileFoundError = createError(
   `${ERROR_PREFIX}_NO_CONFIG_FILE_FOUND`,
   "No config file found for application '%s'"
 )
-export const InvalidEntrypointError = createError(
-  `${ERROR_PREFIX}_INVALID_ENTRYPOINT`,
-  "Invalid entrypoint: '%s' does not exist"
-)
-export const ApplicationIdCollisionError = createError(
-  `${ERROR_PREFIX}_APPLICATION_ID_COLLISION`,
-  'The application id "%s" is used by the autoloaded directory "%s" and by a different application defined in the configuration file via %s. Application ids must be unique.'
-)
-export const MissingEntrypointError = createError(
-  `${ERROR_PREFIX}_MISSING_ENTRYPOINT`,
-  'Missing application entrypoint.'
-)
 export const MissingDependencyError = createError(`${ERROR_PREFIX}_MISSING_DEPENDENCY`, 'Missing dependency: "%s"')
 export const InspectAndInspectBrkError = createError(
   `${ERROR_PREFIX}_INSPECT_AND_INSPECT_BRK`,
@@ -232,10 +224,6 @@ export const HealthSignalTypeMustBeStringError = createError(
   `${ERROR_PREFIX}_HEALTH_SIGNAL_TYPE_MUST_BE_STRING`,
   'Health signal type must be a string, received "%s"'
 )
-export const CannotRemoveEntrypointError = createError(
-  `${ERROR_PREFIX}_CANNOT_REMOVE_ENTRYPOINT`,
-  'Cannot remove the entrypoint application.'
-)
 export const WorkerInterceptorNotReadyError = createError(
   `${ERROR_PREFIX}_WORKER_INTERCEPTOR_NOT_READY`,
   'The "%s" application worker interceptor is not ready'

package/lib/generator.js

@@ -1,4 +1,3 @@
-import createError from '@fastify/error'
 import {
   createEnvFileTool,
   defaultPackageManager,
@@ -23,44 +22,20 @@ const engines = {
   node: '>=22.19.0'
 }
 
-export const ERROR_PREFIX = 'PLT_RUNTIME_GEN'
-
-const NoApplicationNamedError = createError(
-  `${ERROR_PREFIX}_NO_APPLICATION_FOUND`,
-  "No application named '%s' has been added to this runtime."
-)
-const NoEntryPointError = createError(`${ERROR_PREFIX}_NO_ENTRYPOINT`, 'No entrypoint had been defined.')
-
-function getRuntimeWrappableProperties (skipServer) {
-  const wrappableProperties = {
+function getRuntimeWrappableProperties () {
+  return {
     logger: {
       level: '{PLT_SERVER_LOGGER_LEVEL}'
     },
     managementApi: '{PLT_MANAGEMENT_API}'
   }
-
-  if (!skipServer) {
-    wrappableProperties.server = {
-      hostname: '{PLT_SERVER_HOSTNAME}',
-      port: '{PORT}'
-    }
-  }
-
-  return wrappableProperties
 }
 
 function getRuntimeBaseEnvVars (config) {
-  const env = {}
-
-  if (!config.skipServer) {
-    env.PLT_SERVER_HOSTNAME = '127.0.0.1'
-    env.PORT = config.port || 3042
+  return {
+    PLT_SERVER_LOGGER_LEVEL: config.logLevel || 'info',
+    PLT_MANAGEMENT_API: true
   }
-
-  env.PLT_SERVER_LOGGER_LEVEL = config.logLevel || 'info'
-  env.PLT_MANAGEMENT_API = true
-
-  return env
 }
 
 export class RuntimeGenerator extends BaseGenerator {
@@ -73,7 +48,6 @@ export class RuntimeGenerator extends BaseGenerator {
     this.applicationsFolder = opts.applicationsFolder ?? 'applications'
     this.applications = []
     this.existingApplications = []
-    this.entryPoint = null
     this.packageManager = opts.packageManager ?? defaultPackageManager
   }
 
@@ -97,15 +71,6 @@ export class RuntimeGenerator extends BaseGenerator {
     application.setRuntime(this)
   }
 
-  setEntryPoint (entryPoint) {
-    const application =
-      this.existingApplications.includes(entryPoint) || this.applications.find(svc => svc.name === entryPoint)
-    if (!application) {
-      throw new NoApplicationNamedError(entryPoint)
-    }
-    this.entryPoint = application
-  }
-
   async generatePackageJson () {
     const template = {
       name: `${this.runtimeName}`,
@@ -165,8 +130,6 @@ export class RuntimeGenerator extends BaseGenerator {
 
       const { PLT_ROOT, ...existingEnvironment } = this.existingConfig[kMetadata].env
       this.config.env = existingEnvironment
-      this.config.port = this.config.env.PORT
-      this.entryPoint = this.existingConfig.applications.find(svc => svc.entrypoint)
       this.existingApplications = this.existingConfig.applications.map(s => s.id)
 
       this.updateRuntimeConfig(this.existingConfigRaw)
@@ -190,37 +153,42 @@ export class RuntimeGenerator extends BaseGenerator {
   }
 
   setApplicationsConfigValues () {
-    this.applications.forEach(({ application }) => {
+    let newApplicationOrdinal = 0
+    this.applications.forEach(({ name, application }) => {
       if (!application.config) {
         // set default config
         application.setConfig()
       }
+      const existingOrdinal = this.existingApplications.indexOf(name)
+      const ordinal = existingOrdinal === -1 ? this.existingApplications.length + newApplicationOrdinal++ : existingOrdinal
+      this.setApplicationPort(application, ordinal)
     })
   }
 
+  setApplicationPort (application, ordinal) {
+    if (application.config.port === 3042) {
+      application.setConfig({ port: 3042 + ordinal })
+    }
+  }
+
   async _getConfigFileContents () {
     const config = {
       $schema: `https://schemas.platformatic.dev/wattpm/${this.platformaticVersion}.json`,
-      entrypoint: this.entryPoint.name,
       watch: true,
       autoload: {
         path: this.config.autoload || this.applicationsFolder,
         exclude: ['docs']
       },
-      ...getRuntimeWrappableProperties(this.config.skipServer)
+      ...getRuntimeWrappableProperties()
     }
 
     return config
   }
 
   async _afterPrepare () {
-    if (!this.entryPoint) {
-      throw new NoEntryPointError()
-    }
     const applicationsEnv = await this.prepareApplicationFiles()
     this.addEnvVars({
       ...this.config.env,
-      ...this.getRuntimeEnv(),
       ...applicationsEnv
     })
 
@@ -258,21 +226,6 @@ export class RuntimeGenerator extends BaseGenerator {
 
   async prepareQuestions () {
     await this.populateFromExistingConfig()
-
-    if (this.existingConfig) {
-      return
-    }
-
-    if (!this.config.skipServer) {
-      // port
-      this.questions.push({
-        type: 'input',
-        name: 'port',
-        default: '3042',
-        message: 'What port do you want to use?',
-        filter: Number
-      })
-    }
   }
 
   setApplicationsDirectory () {
@@ -322,12 +275,6 @@ export class RuntimeGenerator extends BaseGenerator {
     // do nothing, makes no sense
   }
 
-  getRuntimeEnv () {
-    return {
-      PORT: this.config.port
-    }
-  }
-
   async postInstallActions () {
     for (const { application } of this.applications) {
       await application.postInstallActions()
@@ -451,6 +398,7 @@ export class RuntimeGenerator extends BaseGenerator {
         })
       }
       applicationInstance.setConfig(baseConfig)
+      this.setApplicationPort(applicationInstance, allNewApplicationsNames.indexOf(newApplication.name))
       applicationInstance.setConfigFields(newApplication.fields)
 
       const applicationEnvPrefix = `PLT_${applicationInstance.config.envPrefix}`
@@ -494,18 +442,6 @@ export class RuntimeGenerator extends BaseGenerator {
       contents: JSON.stringify(currrentPackageJson, null, 2)
     })
 
-    // set new entrypoint if specified
-    const newEntrypoint = newConfig.entrypoint
-    if (newEntrypoint) {
-      // load platformatic.json runtime config
-      const runtimePkgConfigFileData = JSON.parse(
-        await readFile(join(this.targetDirectory, this.runtimeConfig), 'utf-8')
-      )
-
-      this.setEntryPoint(newEntrypoint)
-      runtimePkgConfigFileData.entrypoint = newEntrypoint
-      this.updateRuntimeConfig(runtimePkgConfigFileData)
-    }
     await this.writeFiles()
     // save new env
     await envTool.save()
@@ -548,15 +484,6 @@ export class RuntimeGenerator extends BaseGenerator {
       tags: ['runtime-env']
     })
   }
-
-  updateConfigEntryPoint (entrypoint) {
-    // This can return null if the generator was not supposed to modify the config
-    const configObject = this.getRuntimeConfigFileObject()
-    const config = JSON.parse(configObject.contents)
-    config.entrypoint = entrypoint
-
-    this.updateRuntimeConfig(config)
-  }
 }
 
 export class WrappedGenerator extends BaseGenerator {
@@ -626,7 +553,7 @@ export class WrappedGenerator extends BaseGenerator {
   async #createConfigFile () {
     const config = {
       $schema: `https://schemas.platformatic.dev/${this.module}/${this.platformaticVersion}.json`,
-      runtime: getRuntimeWrappableProperties(this.config.skipServer)
+      runtime: getRuntimeWrappableProperties()
     }
 
     this.addFile({

package/lib/management-api.js

@@ -14,7 +14,7 @@ import { platform, tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { createWebSocketStream } from 'ws'
-import { prepareApplication } from './config.js'
+import { prepareAddedApplications } from './config.js'
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
 
@@ -169,11 +169,9 @@ export async function managementApiPlugin (app, opts) {
       }
     }
 
-    for (let i = 0; i < applications.length; i++) {
-      applications[i] = await prepareApplication(config, applications[i], config.workers)
-    }
+    const prepared = await prepareAddedApplications(config, applications, runtime.getApplicationsIds())
 
-    const created = await runtime.addApplications(applications, request.query.start !== 'false')
+    const created = await runtime.addApplications(prepared, request.query.start !== 'false')
     reply.code(201)
     return created
   })

package/lib/management-handlers.js

@@ -3,7 +3,7 @@ import {
   kMetadata,
   validate
 } from '@platformatic/foundation'
-import { prepareApplication } from './config.js'
+import { prepareAddedApplications } from './config.js'
 
 const allOperations = [
   'getRuntimeStatus',
@@ -138,11 +138,9 @@ export function createManagementHandlers (runtime, allowedOperations) {
 
     validate(applicationSchema, applications, {}, true, config[kMetadata].root)
 
-    for (let i = 0; i < applications.length; i++) {
-      applications[i] = await prepareApplication(config, applications[i], config.workers)
-    }
+    const prepared = await prepareAddedApplications(config, applications, runtime.getApplicationsIds())
 
-    return runtime.addApplications(applications, start)
+    return runtime.addApplications(prepared, start)
   })
 
   register('removeApplications', async ({ ids }) => {