@backstage/backend-app-api 0.5.0-next.1 → 0.5.0

package/dist/index.cjs.js

@@ -21,6 +21,7 @@ var minimatch = require('minimatch');
 var errors = require('@backstage/errors');
 var winston = require('winston');
 var backendPluginApi = require('@backstage/backend-plugin-api');
+var alpha = require('@backstage/backend-plugin-api/alpha');
 var backendCommon = require('@backstage/backend-common');
 var PromiseRouter = require('express-promise-router');
 var types = require('@backstage/types');
@@ -584,31 +585,31 @@ function createCorsOriginMatcher(allowedOriginPatterns) {
   };
 }
 
-var __accessCheck$7 = (obj, member, msg) => {
+var __accessCheck$8 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$7 = (obj, member, getter) => {
-  __accessCheck$7(obj, member, "read from private field");
+var __privateGet$8 = (obj, member, getter) => {
+  __accessCheck$8(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$7 = (obj, member, value) => {
+var __privateAdd$8 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$7 = (obj, member, value, setter) => {
-  __accessCheck$7(obj, member, "write to private field");
+var __privateSet$8 = (obj, member, value, setter) => {
+  __accessCheck$8(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _config, _logger;
 const _MiddlewareFactory = class _MiddlewareFactory {
   constructor(options) {
-    __privateAdd$7(this, _config, void 0);
-    __privateAdd$7(this, _logger, void 0);
-    __privateSet$7(this, _config, options.config);
-    __privateSet$7(this, _logger, options.logger);
+    __privateAdd$8(this, _config, void 0);
+    __privateAdd$8(this, _logger, void 0);
+    __privateSet$8(this, _config, options.config);
+    __privateSet$8(this, _logger, options.logger);
   }
   /**
    * Creates a new {@link MiddlewareFactory}.
@@ -654,7 +655,7 @@ const _MiddlewareFactory = class _MiddlewareFactory {
    * @returns An Express request handler
    */
   logging() {
-    const logger = __privateGet$7(this, _logger).child({
+    const logger = __privateGet$8(this, _logger).child({
       type: "incomingRequest"
     });
     return morgan__default["default"]("combined", {
@@ -678,7 +679,7 @@ const _MiddlewareFactory = class _MiddlewareFactory {
    * @returns An Express request handler
    */
   helmet() {
-    return helmet__default["default"](readHelmetOptions(__privateGet$7(this, _config).getOptionalConfig("backend")));
+    return helmet__default["default"](readHelmetOptions(__privateGet$8(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Returns a middleware that implements the cors library.
@@ -693,7 +694,7 @@ const _MiddlewareFactory = class _MiddlewareFactory {
    * @returns An Express request handler
    */
   cors() {
-    return cors__default["default"](readCorsOptions(__privateGet$7(this, _config).getOptionalConfig("backend")));
+    return cors__default["default"](readCorsOptions(__privateGet$8(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Express middleware to handle errors during request processing.
@@ -718,7 +719,7 @@ const _MiddlewareFactory = class _MiddlewareFactory {
   error(options = {}) {
     var _a;
     const showStackTraces = (_a = options.showStackTraces) != null ? _a : process.env.NODE_ENV === "development";
-    const logger = __privateGet$7(this, _logger).child({
+    const logger = __privateGet$8(this, _logger).child({
       type: "errorHandler"
     });
     return (error, req, res, next) => {
@@ -776,31 +777,31 @@ const escapeRegExp = (text) => {
   return text.replace(/[.*+?^${}(\)|[\]\\]/g, "\\$&");
 };
 
-var __accessCheck$6 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$6 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
+var __privateGet$7 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$6 = (obj, member, value) => {
+var __privateAdd$7 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$6 = (obj, member, value, setter) => {
-  __accessCheck$6(obj, member, "write to private field");
+var __privateSet$7 = (obj, member, value, setter) => {
+  __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _winston, _addRedactions;
 const _WinstonLogger = class _WinstonLogger {
   constructor(winston, addRedactions) {
-    __privateAdd$6(this, _winston, void 0);
-    __privateAdd$6(this, _addRedactions, void 0);
-    __privateSet$6(this, _winston, winston);
-    __privateSet$6(this, _addRedactions, addRedactions);
+    __privateAdd$7(this, _winston, void 0);
+    __privateAdd$7(this, _addRedactions, void 0);
+    __privateSet$7(this, _winston, winston);
+    __privateSet$7(this, _addRedactions, addRedactions);
   }
   /**
    * Creates a {@link WinstonLogger} instance.
@@ -877,44 +878,44 @@ const _WinstonLogger = class _WinstonLogger {
     );
   }
   error(message, meta) {
-    __privateGet$6(this, _winston).error(message, meta);
+    __privateGet$7(this, _winston).error(message, meta);
   }
   warn(message, meta) {
-    __privateGet$6(this, _winston).warn(message, meta);
+    __privateGet$7(this, _winston).warn(message, meta);
   }
   info(message, meta) {
-    __privateGet$6(this, _winston).info(message, meta);
+    __privateGet$7(this, _winston).info(message, meta);
   }
   debug(message, meta) {
-    __privateGet$6(this, _winston).debug(message, meta);
+    __privateGet$7(this, _winston).debug(message, meta);
   }
   child(meta) {
-    return new _WinstonLogger(__privateGet$6(this, _winston).child(meta));
+    return new _WinstonLogger(__privateGet$7(this, _winston).child(meta));
   }
   addRedactions(redactions) {
     var _a;
-    (_a = __privateGet$6(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
+    (_a = __privateGet$7(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
   }
 };
 _winston = new WeakMap();
 _addRedactions = new WeakMap();
 let WinstonLogger = _WinstonLogger;
 
-var __accessCheck$5 = (obj, member, msg) => {
+var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$5 = (obj, member, value) => {
+var __privateAdd$6 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$5 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
+var __privateSet$6 = (obj, member, value, setter) => {
+  __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
@@ -922,25 +923,25 @@ var _hasStarted$1, _startupTasks$1, _hasShutdown, _shutdownTasks;
 class BackendLifecycleImpl {
   constructor(logger) {
     this.logger = logger;
-    __privateAdd$5(this, _hasStarted$1, false);
-    __privateAdd$5(this, _startupTasks$1, []);
-    __privateAdd$5(this, _hasShutdown, false);
-    __privateAdd$5(this, _shutdownTasks, []);
+    __privateAdd$6(this, _hasStarted$1, false);
+    __privateAdd$6(this, _startupTasks$1, []);
+    __privateAdd$6(this, _hasShutdown, false);
+    __privateAdd$6(this, _shutdownTasks, []);
   }
   addStartupHook(hook, options) {
-    if (__privateGet$5(this, _hasStarted$1)) {
+    if (__privateGet$6(this, _hasStarted$1)) {
       throw new Error("Attempted to add startup hook after startup");
     }
-    __privateGet$5(this, _startupTasks$1).push({ hook, options });
+    __privateGet$6(this, _startupTasks$1).push({ hook, options });
   }
   async startup() {
-    if (__privateGet$5(this, _hasStarted$1)) {
+    if (__privateGet$6(this, _hasStarted$1)) {
       return;
     }
-    __privateSet$5(this, _hasStarted$1, true);
-    this.logger.debug(`Running ${__privateGet$5(this, _startupTasks$1).length} startup tasks...`);
+    __privateSet$6(this, _hasStarted$1, true);
+    this.logger.debug(`Running ${__privateGet$6(this, _startupTasks$1).length} startup tasks...`);
     await Promise.all(
-      __privateGet$5(this, _startupTasks$1).map(async ({ hook, options }) => {
+      __privateGet$6(this, _startupTasks$1).map(async ({ hook, options }) => {
         var _a;
         const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
         try {
@@ -953,21 +954,21 @@ class BackendLifecycleImpl {
     );
   }
   addShutdownHook(hook, options) {
-    if (__privateGet$5(this, _hasShutdown)) {
+    if (__privateGet$6(this, _hasShutdown)) {
       throw new Error("Attempted to add shutdown hook after shutdown");
     }
-    __privateGet$5(this, _shutdownTasks).push({ hook, options });
+    __privateGet$6(this, _shutdownTasks).push({ hook, options });
   }
   async shutdown() {
-    if (__privateGet$5(this, _hasShutdown)) {
+    if (__privateGet$6(this, _hasShutdown)) {
       return;
     }
-    __privateSet$5(this, _hasShutdown, true);
+    __privateSet$6(this, _hasShutdown, true);
     this.logger.debug(
-      `Running ${__privateGet$5(this, _shutdownTasks).length} shutdown tasks...`
+      `Running ${__privateGet$6(this, _shutdownTasks).length} shutdown tasks...`
     );
     await Promise.all(
-      __privateGet$5(this, _shutdownTasks).map(async ({ hook, options }) => {
+      __privateGet$6(this, _shutdownTasks).map(async ({ hook, options }) => {
         var _a;
         const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
         try {
@@ -994,21 +995,21 @@ const rootLifecycleServiceFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-var __accessCheck$4 = (obj, member, msg) => {
+var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$4 = (obj, member, value) => {
+var __privateAdd$5 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
+var __privateSet$5 = (obj, member, value, setter) => {
+  __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
@@ -1018,25 +1019,25 @@ class BackendPluginLifecycleImpl {
     this.logger = logger;
     this.rootLifecycle = rootLifecycle;
     this.pluginMetadata = pluginMetadata;
-    __privateAdd$4(this, _hasStarted, false);
-    __privateAdd$4(this, _startupTasks, []);
+    __privateAdd$5(this, _hasStarted, false);
+    __privateAdd$5(this, _startupTasks, []);
   }
   addStartupHook(hook, options) {
-    if (__privateGet$4(this, _hasStarted)) {
+    if (__privateGet$5(this, _hasStarted)) {
       throw new Error("Attempted to add startup hook after startup");
     }
-    __privateGet$4(this, _startupTasks).push({ hook, options });
+    __privateGet$5(this, _startupTasks).push({ hook, options });
   }
   async startup() {
-    if (__privateGet$4(this, _hasStarted)) {
+    if (__privateGet$5(this, _hasStarted)) {
       return;
     }
-    __privateSet$4(this, _hasStarted, true);
+    __privateSet$5(this, _hasStarted, true);
     this.logger.debug(
-      `Running ${__privateGet$4(this, _startupTasks).length} plugin startup tasks...`
+      `Running ${__privateGet$5(this, _startupTasks).length} plugin startup tasks...`
     );
     await Promise.all(
-      __privateGet$4(this, _startupTasks).map(async ({ hook, options }) => {
+      __privateGet$5(this, _startupTasks).map(async ({ hook, options }) => {
         var _a;
         const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
         try {
@@ -1074,273 +1075,195 @@ const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-var __accessCheck$3 = (obj, member, msg) => {
+var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$3 = (obj, member, value) => {
+var __privateAdd$4 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$3 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$3(obj, member, "access private method");
-  return method;
-};
-var _startPromise, _features, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _doStart, doStart_fn, _getRootLifecycleImpl, getRootLifecycleImpl_fn, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn;
-class BackendInitializer {
-  constructor(serviceHolder) {
-    __privateAdd$3(this, _getInitDeps);
-    __privateAdd$3(this, _doStart);
-    // Bit of a hacky way to grab the lifecycle services, potentially find a nicer way to do this
-    __privateAdd$3(this, _getRootLifecycleImpl);
-    __privateAdd$3(this, _getPluginLifecycleImpl);
-    __privateAdd$3(this, _startPromise, void 0);
-    __privateAdd$3(this, _features, new Array());
-    __privateAdd$3(this, _extensionPoints, /* @__PURE__ */ new Map());
-    __privateAdd$3(this, _serviceHolder, void 0);
-    __privateSet$3(this, _serviceHolder, serviceHolder);
-  }
-  add(feature) {
-    if (__privateGet$3(this, _startPromise)) {
-      throw new Error("feature can not be added after the backend has started");
-    }
-    if (feature.$$type !== "@backstage/BackendFeature") {
-      throw new Error(
-        `Failed to add feature, invalid type '${feature.$$type}'`
-      );
-    }
-    const internalFeature = feature;
-    if (internalFeature.version !== "v1") {
-      throw new Error(
-        `Failed to add feature, invalid version '${internalFeature.version}'`
-      );
-    }
-    __privateGet$3(this, _features).push(internalFeature);
-  }
-  async start() {
-    if (__privateGet$3(this, _startPromise)) {
-      throw new Error("Backend has already started");
-    }
-    const exitHandler = async () => {
-      process.removeListener("SIGTERM", exitHandler);
-      process.removeListener("SIGINT", exitHandler);
-      process.removeListener("beforeExit", exitHandler);
-      try {
-        await this.stop();
-        process.exit(0);
-      } catch (error) {
-        console.error(error);
-        process.exit(1);
-      }
-    };
-    process.addListener("SIGTERM", exitHandler);
-    process.addListener("SIGINT", exitHandler);
-    process.addListener("beforeExit", exitHandler);
-    __privateSet$3(this, _startPromise, __privateMethod$2(this, _doStart, doStart_fn).call(this));
-    await __privateGet$3(this, _startPromise);
-  }
-  async stop() {
-    if (!__privateGet$3(this, _startPromise)) {
-      return;
-    }
-    await __privateGet$3(this, _startPromise);
-    const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
-    await lifecycleService.shutdown();
+var _nodes, _allProvided;
+class Node {
+  constructor(value, consumes, provides) {
+    this.value = value;
+    this.consumes = consumes;
+    this.provides = provides;
+  }
+  static from(input) {
+    return new Node(
+      input.value,
+      input.consumes ? new Set(input.consumes) : /* @__PURE__ */ new Set(),
+      input.provides ? new Set(input.provides) : /* @__PURE__ */ new Set()
+    );
   }
 }
-_startPromise = new WeakMap();
-_features = new WeakMap();
-_extensionPoints = new WeakMap();
-_serviceHolder = new WeakMap();
-_getInitDeps = new WeakSet();
-getInitDeps_fn = async function(deps, pluginId) {
-  const result = /* @__PURE__ */ new Map();
-  const missingRefs = /* @__PURE__ */ new Set();
-  for (const [name, ref] of Object.entries(deps)) {
-    const extensionPoint = __privateGet$3(this, _extensionPoints).get(
-      ref
-    );
-    if (extensionPoint) {
-      result.set(name, extensionPoint);
-    } else {
-      const impl = await __privateGet$3(this, _serviceHolder).get(
-        ref,
-        pluginId
-      );
-      if (impl) {
-        result.set(name, impl);
-      } else {
-        missingRefs.add(ref);
+const _DependencyGraph = class _DependencyGraph {
+  constructor(nodes) {
+    __privateAdd$4(this, _nodes, void 0);
+    __privateAdd$4(this, _allProvided, void 0);
+    __privateSet$4(this, _nodes, nodes);
+    __privateSet$4(this, _allProvided, /* @__PURE__ */ new Set());
+    for (const node of __privateGet$4(this, _nodes).values()) {
+      for (const produced of node.provides) {
+        __privateGet$4(this, _allProvided).add(produced);
       }
     }
   }
-  if (missingRefs.size > 0) {
-    const missing = Array.from(missingRefs).join(", ");
-    throw new Error(
-      `No extension point or service available for the following ref(s): ${missing}`
+  static fromMap(nodes) {
+    return this.fromIterable(
+      Object.entries(nodes).map(([key, node]) => ({
+        value: String(key),
+        ...node
+      }))
     );
   }
-  return Object.fromEntries(result);
-};
-_doStart = new WeakSet();
-doStart_fn = async function() {
-  for (const ref of __privateGet$3(this, _serviceHolder).getServiceRefs()) {
-    if (ref.scope === "root") {
-      await __privateGet$3(this, _serviceHolder).get(ref, "root");
+  static fromIterable(nodeInputs) {
+    const nodes = new Array();
+    for (const nodeInput of nodeInputs) {
+      nodes.push(Node.from(nodeInput));
     }
-  }
-  const pluginInits = /* @__PURE__ */ new Map();
-  const moduleInits = /* @__PURE__ */ new Map();
-  for (const feature of __privateGet$3(this, _features)) {
-    for (const r of feature.getRegistrations()) {
-      const provides = /* @__PURE__ */ new Set();
-      if (r.type === "plugin") {
-        for (const [extRef, extImpl] of r.extensionPoints) {
-          if (__privateGet$3(this, _extensionPoints).has(extRef)) {
-            throw new Error(
-              `ExtensionPoint with ID '${extRef.id}' is already registered`
-            );
-          }
-          __privateGet$3(this, _extensionPoints).set(extRef, extImpl);
-          provides.add(extRef);
-        }
+    return new _DependencyGraph(nodes);
+  }
+  // Find all nodes that consume dependencies that are not provided by any other node
+  findUnsatisfiedDeps() {
+    const unsatisfiedDependencies = [];
+    for (const node of __privateGet$4(this, _nodes).values()) {
+      const unsatisfied = Array.from(node.consumes).filter(
+        (id) => !__privateGet$4(this, _allProvided).has(id)
+      );
+      if (unsatisfied.length > 0) {
+        unsatisfiedDependencies.push({ value: node.value, unsatisfied });
       }
-      if (r.type === "plugin") {
-        if (pluginInits.has(r.pluginId)) {
-          throw new Error(`Plugin '${r.pluginId}' is already registered`);
-        }
-        pluginInits.set(r.pluginId, {
-          provides,
-          consumes: new Set(Object.values(r.init.deps)),
-          init: r.init
-        });
-      } else {
-        let modules = moduleInits.get(r.pluginId);
-        if (!modules) {
-          modules = /* @__PURE__ */ new Map();
-          moduleInits.set(r.pluginId, modules);
+    }
+    return unsatisfiedDependencies;
+  }
+  // Detect circular dependencies within the graph, returning the path of nodes that
+  // form a cycle, with the same node as the first and last element of the array.
+  detectCircularDependency() {
+    for (const startNode of __privateGet$4(this, _nodes)) {
+      const visited = /* @__PURE__ */ new Set();
+      const stack = new Array([
+        startNode,
+        [startNode.value]
+      ]);
+      while (stack.length > 0) {
+        const [node, path] = stack.pop();
+        if (visited.has(node)) {
+          continue;
         }
-        if (modules.has(r.moduleId)) {
-          throw new Error(
-            `Module '${r.moduleId}' for plugin '${r.pluginId}' is already registered`
+        visited.add(node);
+        for (const produced of node.provides) {
+          const consumerNodes = __privateGet$4(this, _nodes).filter(
+            (other) => other.consumes.has(produced)
           );
+          for (const consumer of consumerNodes) {
+            if (consumer === startNode) {
+              return [...path, startNode.value];
+            }
+            if (!visited.has(consumer)) {
+              stack.push([consumer, [...path, consumer.value]]);
+            }
+          }
         }
-        modules.set(r.moduleId, {
-          provides,
-          consumes: new Set(Object.values(r.init.deps)),
-          init: r.init
-        });
       }
     }
+    return void 0;
   }
-  const allPluginIds = [
-    .../* @__PURE__ */ new Set([...pluginInits.keys(), ...moduleInits.keys()])
-  ];
-  await Promise.all(
-    allPluginIds.map(async (pluginId) => {
-      var _a;
-      const modules = (_a = moduleInits.get(pluginId)) != null ? _a : [];
-      await Promise.all(
-        Array.from(modules).map(async ([moduleId, moduleInit]) => {
-          const moduleDeps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, moduleInit.init.deps, pluginId);
-          await moduleInit.init.func(moduleDeps).catch((error) => {
-            throw new errors.ForwardedError(
-              `Module '${moduleId}' for plugin '${pluginId}' startup failed`,
-              error
-            );
-          });
-        })
-      );
-      const pluginInit = pluginInits.get(pluginId);
-      if (pluginInit) {
-        const pluginDeps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, pluginInit.init.deps, pluginId);
-        await pluginInit.init.func(pluginDeps).catch((error) => {
-          throw new errors.ForwardedError(
-            `Plugin '${pluginId}' startup failed`,
-            error
-          );
-        });
+  /**
+   * Traverses the dependency graph in topological order, calling the provided
+   * function for each node and waiting for it to resolve.
+   *
+   * The nodes are traversed in parallel, but in such a way that no node is
+   * visited before all of its dependencies.
+   *
+   * Dependencies of nodes that are not produced by any other nodes will be ignored.
+   */
+  async parallelTopologicalTraversal(fn) {
+    const allProvided = __privateGet$4(this, _allProvided);
+    const producedSoFar = /* @__PURE__ */ new Set();
+    const waiting = new Set(__privateGet$4(this, _nodes).values());
+    const visited = /* @__PURE__ */ new Set();
+    const results = new Array();
+    let inFlight = 0;
+    async function processMoreNodes() {
+      if (waiting.size === 0) {
+        return;
       }
-      const lifecycleService2 = await __privateMethod$2(this, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn).call(this, pluginId);
-      await lifecycleService2.startup();
-    })
-  );
-  const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
-  await lifecycleService.startup();
-  if (process.env.NODE_ENV !== "test") {
-    const rootLogger = await __privateGet$3(this, _serviceHolder).get(
-      backendPluginApi.coreServices.rootLogger,
-      "root"
-    );
-    process.on("unhandledRejection", (reason) => {
-      var _a;
-      (_a = rootLogger == null ? void 0 : rootLogger.child({ type: "unhandledRejection" })) == null ? void 0 : _a.error("Unhandled rejection", reason);
-    });
-    process.on("uncaughtException", (error) => {
-      var _a;
-      (_a = rootLogger == null ? void 0 : rootLogger.child({ type: "uncaughtException" })) == null ? void 0 : _a.error("Uncaught exception", error);
-    });
-  }
-};
-_getRootLifecycleImpl = new WeakSet();
-getRootLifecycleImpl_fn = async function() {
-  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
-    backendPluginApi.coreServices.rootLifecycle,
-    "root"
-  );
-  if (lifecycleService instanceof BackendLifecycleImpl) {
-    return lifecycleService;
-  }
-  throw new Error("Unexpected root lifecycle service implementation");
-};
-_getPluginLifecycleImpl = new WeakSet();
-getPluginLifecycleImpl_fn = async function(pluginId) {
-  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
-    backendPluginApi.coreServices.lifecycle,
-    pluginId
-  );
-  if (lifecycleService instanceof BackendPluginLifecycleImpl) {
-    return lifecycleService;
+      const nodesToProcess = [];
+      for (const node of waiting) {
+        let ready = true;
+        for (const consumed of node.consumes) {
+          if (allProvided.has(consumed) && !producedSoFar.has(consumed)) {
+            ready = false;
+            continue;
+          }
+        }
+        if (ready) {
+          nodesToProcess.push(node);
+        }
+      }
+      for (const node of nodesToProcess) {
+        waiting.delete(node);
+      }
+      if (nodesToProcess.length === 0 && inFlight === 0) {
+        throw new Error("Circular dependency detected");
+      }
+      await Promise.all(nodesToProcess.map(processNode));
+    }
+    async function processNode(node) {
+      visited.add(node);
+      inFlight += 1;
+      const result = await fn(node.value);
+      results.push(result);
+      node.provides.forEach((produced) => producedSoFar.add(produced));
+      inFlight -= 1;
+      await processMoreNodes();
+    }
+    await processMoreNodes();
+    return results;
   }
-  throw new Error("Unexpected plugin lifecycle service implementation");
 };
+_nodes = new WeakMap();
+_allProvided = new WeakMap();
+let DependencyGraph = _DependencyGraph;
 
-var __accessCheck$2 = (obj, member, msg) => {
+var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$2(obj, member, "read from private field");
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$2 = (obj, member, value) => {
+var __privateAdd$3 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$2 = (obj, member, value, setter) => {
-  __accessCheck$2(obj, member, "write to private field");
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var __privateMethod$1 = (obj, member, method) => {
-  __accessCheck$2(obj, member, "access private method");
+var __privateMethod$2 = (obj, member, method) => {
+  __accessCheck$3(obj, member, "access private method");
   return method;
 };
 var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
 function toInternalServiceFactory(factory) {
   const f = factory;
-  if (f.$$type !== "@backstage/ServiceFactory") {
+  if (f.$$type !== "@backstage/BackendFeature") {
     throw new Error(`Invalid service factory, bad type '${f.$$type}'`);
   }
   if (f.version !== "v1") {
@@ -1352,33 +1275,33 @@ const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.pluginMetadata,
     deps: {},
-    factory: async () => ({ getId: () => options.pluginId })
+    factory: async () => ({ getId: () => options == null ? void 0 : options.pluginId })
   })
 );
 class ServiceRegistry {
   constructor(factories) {
-    __privateAdd$2(this, _resolveFactory);
-    __privateAdd$2(this, _checkForMissingDeps);
-    __privateAdd$2(this, _providedFactories, void 0);
-    __privateAdd$2(this, _loadedDefaultFactories, void 0);
-    __privateAdd$2(this, _implementations, void 0);
-    __privateAdd$2(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
-    __privateSet$2(this, _providedFactories, new Map(
+    __privateAdd$3(this, _resolveFactory);
+    __privateAdd$3(this, _checkForMissingDeps);
+    __privateAdd$3(this, _providedFactories, void 0);
+    __privateAdd$3(this, _loadedDefaultFactories, void 0);
+    __privateAdd$3(this, _implementations, void 0);
+    __privateAdd$3(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _providedFactories, new Map(
       factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
     ));
-    __privateSet$2(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
-    __privateSet$2(this, _implementations, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _implementations, /* @__PURE__ */ new Map());
   }
   getServiceRefs() {
-    return Array.from(__privateGet$2(this, _providedFactories).values()).map((f) => f.service);
+    return Array.from(__privateGet$3(this, _providedFactories).values()).map((f) => f.service);
   }
   get(ref, pluginId) {
     var _a;
-    return (_a = __privateMethod$1(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
+    return (_a = __privateMethod$2(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
       if (factory.service.scope === "root") {
-        let existing = __privateGet$2(this, _rootServiceImplementations).get(factory);
+        let existing = __privateGet$3(this, _rootServiceImplementations).get(factory);
         if (!existing) {
-          __privateMethod$1(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+          __privateMethod$2(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
           const rootDeps = new Array();
           for (const [name, serviceRef] of Object.entries(factory.deps)) {
             if (serviceRef.scope !== "root") {
@@ -1392,13 +1315,13 @@ class ServiceRegistry {
           existing = Promise.all(rootDeps).then(
             (entries) => factory.factory(Object.fromEntries(entries), void 0)
           );
-          __privateGet$2(this, _rootServiceImplementations).set(factory, existing);
+          __privateGet$3(this, _rootServiceImplementations).set(factory, existing);
         }
         return existing;
       }
-      let implementation = __privateGet$2(this, _implementations).get(factory);
+      let implementation = __privateGet$3(this, _implementations).get(factory);
       if (!implementation) {
-        __privateMethod$1(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+        __privateMethod$2(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
         const rootDeps = new Array();
         for (const [name, serviceRef] of Object.entries(factory.deps)) {
           if (serviceRef.scope === "root") {
@@ -1420,7 +1343,7 @@ class ServiceRegistry {
           }),
           byPlugin: /* @__PURE__ */ new Map()
         };
-        __privateGet$2(this, _implementations).set(factory, implementation);
+        __privateGet$3(this, _implementations).set(factory, implementation);
       }
       let result = implementation.byPlugin.get(pluginId);
       if (!result) {
@@ -1456,18 +1379,18 @@ resolveFactory_fn = function(ref, pluginId) {
       toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
     );
   }
-  let resolvedFactory = __privateGet$2(this, _providedFactories).get(ref.id);
+  let resolvedFactory = __privateGet$3(this, _providedFactories).get(ref.id);
   const { __defaultFactory: defaultFactory } = ref;
   if (!resolvedFactory && !defaultFactory) {
     return void 0;
   }
   if (!resolvedFactory) {
-    let loadedFactory = __privateGet$2(this, _loadedDefaultFactories).get(defaultFactory);
+    let loadedFactory = __privateGet$3(this, _loadedDefaultFactories).get(defaultFactory);
     if (!loadedFactory) {
       loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
         (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
       );
-      __privateGet$2(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
+      __privateGet$3(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
     }
     resolvedFactory = loadedFactory.catch((error) => {
       throw new Error(
@@ -1485,7 +1408,7 @@ checkForMissingDeps_fn = function(factory, pluginId) {
     if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
       return false;
     }
-    if (__privateGet$2(this, _providedFactories).get(ref.id)) {
+    if (__privateGet$3(this, _providedFactories).get(ref.id)) {
       return false;
     }
     return !ref.__defaultFactory;
@@ -1498,6 +1421,321 @@ checkForMissingDeps_fn = function(factory, pluginId) {
   }
 };
 
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$2(obj, member, "access private method");
+  return method;
+};
+var _startPromise, _features, _extensionPoints, _serviceHolder, _providedServiceFactories, _defaultApiFactories, _getInitDeps, getInitDeps_fn, _addFeature, addFeature_fn, _doStart, doStart_fn, _getRootLifecycleImpl, getRootLifecycleImpl_fn, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn;
+class BackendInitializer {
+  constructor(defaultApiFactories) {
+    __privateAdd$2(this, _getInitDeps);
+    __privateAdd$2(this, _addFeature);
+    __privateAdd$2(this, _doStart);
+    // Bit of a hacky way to grab the lifecycle services, potentially find a nicer way to do this
+    __privateAdd$2(this, _getRootLifecycleImpl);
+    __privateAdd$2(this, _getPluginLifecycleImpl);
+    __privateAdd$2(this, _startPromise, void 0);
+    __privateAdd$2(this, _features, new Array());
+    __privateAdd$2(this, _extensionPoints, /* @__PURE__ */ new Map());
+    __privateAdd$2(this, _serviceHolder, void 0);
+    __privateAdd$2(this, _providedServiceFactories, new Array());
+    __privateAdd$2(this, _defaultApiFactories, void 0);
+    __privateSet$2(this, _defaultApiFactories, defaultApiFactories);
+  }
+  add(feature) {
+    if (__privateGet$2(this, _startPromise)) {
+      throw new Error("feature can not be added after the backend has started");
+    }
+    __privateMethod$1(this, _addFeature, addFeature_fn).call(this, feature);
+  }
+  async start() {
+    if (__privateGet$2(this, _startPromise)) {
+      throw new Error("Backend has already started");
+    }
+    const exitHandler = async () => {
+      process.removeListener("SIGTERM", exitHandler);
+      process.removeListener("SIGINT", exitHandler);
+      process.removeListener("beforeExit", exitHandler);
+      try {
+        await this.stop();
+        process.exit(0);
+      } catch (error) {
+        console.error(error);
+        process.exit(1);
+      }
+    };
+    process.addListener("SIGTERM", exitHandler);
+    process.addListener("SIGINT", exitHandler);
+    process.addListener("beforeExit", exitHandler);
+    __privateSet$2(this, _startPromise, __privateMethod$1(this, _doStart, doStart_fn).call(this));
+    await __privateGet$2(this, _startPromise);
+  }
+  async stop() {
+    if (!__privateGet$2(this, _startPromise)) {
+      return;
+    }
+    try {
+      await __privateGet$2(this, _startPromise);
+    } catch (error) {
+    }
+    const lifecycleService = await __privateMethod$1(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+    await lifecycleService.shutdown();
+  }
+}
+_startPromise = new WeakMap();
+_features = new WeakMap();
+_extensionPoints = new WeakMap();
+_serviceHolder = new WeakMap();
+_providedServiceFactories = new WeakMap();
+_defaultApiFactories = new WeakMap();
+_getInitDeps = new WeakSet();
+getInitDeps_fn = async function(deps, pluginId) {
+  const result = /* @__PURE__ */ new Map();
+  const missingRefs = /* @__PURE__ */ new Set();
+  for (const [name, ref] of Object.entries(deps)) {
+    const ep = __privateGet$2(this, _extensionPoints).get(ref);
+    if (ep) {
+      if (ep.pluginId !== pluginId) {
+        throw new Error(
+          `Extension point registered for plugin '${ep.pluginId}' may not be used by module for plugin '${pluginId}'`
+        );
+      }
+      result.set(name, ep.impl);
+    } else {
+      const impl = await __privateGet$2(this, _serviceHolder).get(
+        ref,
+        pluginId
+      );
+      if (impl) {
+        result.set(name, impl);
+      } else {
+        missingRefs.add(ref);
+      }
+    }
+  }
+  if (missingRefs.size > 0) {
+    const missing = Array.from(missingRefs).join(", ");
+    throw new Error(
+      `No extension point or service available for the following ref(s): ${missing}`
+    );
+  }
+  return Object.fromEntries(result);
+};
+_addFeature = new WeakSet();
+addFeature_fn = function(feature) {
+  if (feature.$$type !== "@backstage/BackendFeature") {
+    throw new Error(
+      `Failed to add feature, invalid type '${feature.$$type}'`
+    );
+  }
+  if (isServiceFactory(feature)) {
+    if (feature.service.id === backendPluginApi.coreServices.pluginMetadata.id) {
+      throw new Error(
+        `The ${backendPluginApi.coreServices.pluginMetadata.id} service cannot be overridden`
+      );
+    }
+    if (__privateGet$2(this, _providedServiceFactories).find(
+      (sf) => sf.service.id === feature.service.id
+    )) {
+      throw new Error(
+        `Duplicate service implementations provided for ${feature.service.id}`
+      );
+    }
+    __privateGet$2(this, _providedServiceFactories).push(feature);
+  } else if (isInternalBackendFeature(feature)) {
+    if (feature.version !== "v1") {
+      throw new Error(
+        `Failed to add feature, invalid version '${feature.version}'`
+      );
+    }
+    __privateGet$2(this, _features).push(feature);
+  } else {
+    throw new Error(
+      `Failed to add feature, invalid feature ${JSON.stringify(feature)}`
+    );
+  }
+};
+_doStart = new WeakSet();
+doStart_fn = async function() {
+  __privateSet$2(this, _serviceHolder, new ServiceRegistry([
+    ...__privateGet$2(this, _defaultApiFactories),
+    ...__privateGet$2(this, _providedServiceFactories)
+  ]));
+  const featureDiscovery = await __privateGet$2(this, _serviceHolder).get(
+    alpha.featureDiscoveryServiceRef,
+    "root"
+  );
+  if (featureDiscovery) {
+    const { features } = await featureDiscovery.getBackendFeatures();
+    for (const feature of features) {
+      __privateMethod$1(this, _addFeature, addFeature_fn).call(this, feature);
+    }
+  }
+  for (const ref of __privateGet$2(this, _serviceHolder).getServiceRefs()) {
+    if (ref.scope === "root") {
+      await __privateGet$2(this, _serviceHolder).get(ref, "root");
+    }
+  }
+  const pluginInits = /* @__PURE__ */ new Map();
+  const moduleInits = /* @__PURE__ */ new Map();
+  for (const feature of __privateGet$2(this, _features)) {
+    for (const r of feature.getRegistrations()) {
+      const provides = /* @__PURE__ */ new Set();
+      if (r.type === "plugin" || r.type === "module") {
+        for (const [extRef, extImpl] of r.extensionPoints) {
+          if (__privateGet$2(this, _extensionPoints).has(extRef)) {
+            throw new Error(
+              `ExtensionPoint with ID '${extRef.id}' is already registered`
+            );
+          }
+          __privateGet$2(this, _extensionPoints).set(extRef, {
+            impl: extImpl,
+            pluginId: r.pluginId
+          });
+          provides.add(extRef);
+        }
+      }
+      if (r.type === "plugin") {
+        if (pluginInits.has(r.pluginId)) {
+          throw new Error(`Plugin '${r.pluginId}' is already registered`);
+        }
+        pluginInits.set(r.pluginId, {
+          provides,
+          consumes: new Set(Object.values(r.init.deps)),
+          init: r.init
+        });
+      } else {
+        let modules = moduleInits.get(r.pluginId);
+        if (!modules) {
+          modules = /* @__PURE__ */ new Map();
+          moduleInits.set(r.pluginId, modules);
+        }
+        if (modules.has(r.moduleId)) {
+          throw new Error(
+            `Module '${r.moduleId}' for plugin '${r.pluginId}' is already registered`
+          );
+        }
+        modules.set(r.moduleId, {
+          provides,
+          consumes: new Set(Object.values(r.init.deps)),
+          init: r.init
+        });
+      }
+    }
+  }
+  const allPluginIds = [
+    .../* @__PURE__ */ new Set([...pluginInits.keys(), ...moduleInits.keys()])
+  ];
+  await Promise.all(
+    allPluginIds.map(async (pluginId) => {
+      const modules = moduleInits.get(pluginId);
+      if (modules) {
+        const tree = DependencyGraph.fromIterable(
+          Array.from(modules).map(([moduleId, moduleInit]) => ({
+            value: { moduleId, moduleInit },
+            // Relationships are reversed at this point since we're only interested in the extension points.
+            // If a modules provides extension point A we want it to be initialized AFTER all modules
+            // that depend on extension point A, so that they can provide their extensions.
+            consumes: Array.from(moduleInit.provides).map((p) => p.id),
+            provides: Array.from(moduleInit.consumes).map((c) => c.id)
+          }))
+        );
+        const circular = tree.detectCircularDependency();
+        if (circular) {
+          throw new errors.ConflictError(
+            `Circular dependency detected for modules of plugin '${pluginId}', ${circular.map(({ moduleId }) => `'${moduleId}'`).join(" -> ")}`
+          );
+        }
+        await tree.parallelTopologicalTraversal(
+          async ({ moduleId, moduleInit }) => {
+            const moduleDeps = await __privateMethod$1(this, _getInitDeps, getInitDeps_fn).call(this, moduleInit.init.deps, pluginId);
+            await moduleInit.init.func(moduleDeps).catch((error) => {
+              throw new errors.ForwardedError(
+                `Module '${moduleId}' for plugin '${pluginId}' startup failed`,
+                error
+              );
+            });
+          }
+        );
+      }
+      const pluginInit = pluginInits.get(pluginId);
+      if (pluginInit) {
+        const pluginDeps = await __privateMethod$1(this, _getInitDeps, getInitDeps_fn).call(this, pluginInit.init.deps, pluginId);
+        await pluginInit.init.func(pluginDeps).catch((error) => {
+          throw new errors.ForwardedError(
+            `Plugin '${pluginId}' startup failed`,
+            error
+          );
+        });
+      }
+      const lifecycleService2 = await __privateMethod$1(this, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn).call(this, pluginId);
+      await lifecycleService2.startup();
+    })
+  );
+  const lifecycleService = await __privateMethod$1(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+  await lifecycleService.startup();
+  if (process.env.NODE_ENV !== "test") {
+    const rootLogger = await __privateGet$2(this, _serviceHolder).get(
+      backendPluginApi.coreServices.rootLogger,
+      "root"
+    );
+    process.on("unhandledRejection", (reason) => {
+      var _a;
+      (_a = rootLogger == null ? void 0 : rootLogger.child({ type: "unhandledRejection" })) == null ? void 0 : _a.error("Unhandled rejection", reason);
+    });
+    process.on("uncaughtException", (error) => {
+      var _a;
+      (_a = rootLogger == null ? void 0 : rootLogger.child({ type: "uncaughtException" })) == null ? void 0 : _a.error("Uncaught exception", error);
+    });
+  }
+};
+_getRootLifecycleImpl = new WeakSet();
+getRootLifecycleImpl_fn = async function() {
+  const lifecycleService = await __privateGet$2(this, _serviceHolder).get(
+    backendPluginApi.coreServices.rootLifecycle,
+    "root"
+  );
+  if (lifecycleService instanceof BackendLifecycleImpl) {
+    return lifecycleService;
+  }
+  throw new Error("Unexpected root lifecycle service implementation");
+};
+_getPluginLifecycleImpl = new WeakSet();
+getPluginLifecycleImpl_fn = async function(pluginId) {
+  const lifecycleService = await __privateGet$2(this, _serviceHolder).get(
+    backendPluginApi.coreServices.lifecycle,
+    pluginId
+  );
+  if (lifecycleService instanceof BackendPluginLifecycleImpl) {
+    return lifecycleService;
+  }
+  throw new Error("Unexpected plugin lifecycle service implementation");
+};
+function isServiceFactory(feature) {
+  return !!feature.service;
+}
+function isInternalBackendFeature(feature) {
+  return typeof feature.getRegistrations === "function";
+}
+
 var __accessCheck$1 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -1516,16 +1754,14 @@ var __privateSet$1 = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _services, _initializer;
+var _initializer;
 class BackstageBackend {
-  constructor(apiFactories) {
-    __privateAdd$1(this, _services, void 0);
+  constructor(defaultServiceFactories) {
     __privateAdd$1(this, _initializer, void 0);
-    __privateSet$1(this, _services, new ServiceRegistry(apiFactories));
-    __privateSet$1(this, _initializer, new BackendInitializer(__privateGet$1(this, _services)));
+    __privateSet$1(this, _initializer, new BackendInitializer(defaultServiceFactories));
   }
   add(feature) {
-    __privateGet$1(this, _initializer).add(feature);
+    __privateGet$1(this, _initializer).add(typeof feature === "function" ? feature() : feature);
   }
   async start() {
     await __privateGet$1(this, _initializer).start();
@@ -1534,11 +1770,10 @@ class BackstageBackend {
     await __privateGet$1(this, _initializer).stop();
   }
 }
-_services = new WeakMap();
 _initializer = new WeakMap();
 
 function createSpecializedBackend(options) {
-  const services = options.services.map(
+  const services = options.defaultServiceFactories.map(
     (sf) => typeof sf === "function" ? sf() : sf
   );
   const exists = /* @__PURE__ */ new Set();