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

package/dist/index.cjs.js

@@ -585,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}.
@@ -655,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", {
@@ -679,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.
@@ -694,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.
@@ -719,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) => {
@@ -777,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.
@@ -878,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;
 };
@@ -923,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 {
@@ -954,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 {
@@ -995,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;
 };
@@ -1019,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 {
@@ -1075,6 +1075,169 @@ const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
   }
 });
 
+var __accessCheck$4 = (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");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+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$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 _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()
+    );
+  }
+}
+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);
+      }
+    }
+  }
+  static fromMap(nodes) {
+    return this.fromIterable(
+      Object.entries(nodes).map(([key, node]) => ({
+        value: String(key),
+        ...node
+      }))
+    );
+  }
+  static fromIterable(nodeInputs) {
+    const nodes = new Array();
+    for (const nodeInput of nodeInputs) {
+      nodes.push(Node.from(nodeInput));
+    }
+    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 });
+      }
+    }
+    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;
+        }
+        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]]);
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 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 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;
+  }
+};
+_nodes = new WeakMap();
+_allProvided = new WeakMap();
+let DependencyGraph = _DependencyGraph;
+
 var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -1097,29 +1260,214 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$3(obj, member, "access private method");
   return method;
 };
-var _startPromise, _features, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _addFeature, addFeature_fn, _doStart, doStart_fn, _getRootLifecycleImpl, getRootLifecycleImpl_fn, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn;
+var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
+function toInternalServiceFactory(factory) {
+  const f = factory;
+  if (f.$$type !== "@backstage/BackendFeature") {
+    throw new Error(`Invalid service factory, bad type '${f.$$type}'`);
+  }
+  if (f.version !== "v1") {
+    throw new Error(`Invalid service factory, bad version '${f.version}'`);
+  }
+  return f;
+}
+const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.pluginMetadata,
+    deps: {},
+    factory: async () => ({ getId: () => options == null ? void 0 : options.pluginId })
+  })
+);
+class ServiceRegistry {
+  constructor(factories) {
+    __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$3(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _implementations, /* @__PURE__ */ new Map());
+  }
+  getServiceRefs() {
+    return Array.from(__privateGet$3(this, _providedFactories).values()).map((f) => f.service);
+  }
+  get(ref, pluginId) {
+    var _a;
+    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$3(this, _rootServiceImplementations).get(factory);
+        if (!existing) {
+          __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") {
+              throw new Error(
+                `Failed to instantiate 'root' scoped service '${ref.id}' because it depends on '${serviceRef.scope}' scoped service '${serviceRef.id}'.`
+              );
+            }
+            const target = this.get(serviceRef, pluginId);
+            rootDeps.push(target.then((impl) => [name, impl]));
+          }
+          existing = Promise.all(rootDeps).then(
+            (entries) => factory.factory(Object.fromEntries(entries), void 0)
+          );
+          __privateGet$3(this, _rootServiceImplementations).set(factory, existing);
+        }
+        return existing;
+      }
+      let implementation = __privateGet$3(this, _implementations).get(factory);
+      if (!implementation) {
+        __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") {
+            const target = this.get(serviceRef, pluginId);
+            rootDeps.push(target.then((impl) => [name, impl]));
+          }
+        }
+        implementation = {
+          context: Promise.all(rootDeps).then(
+            (entries) => {
+              var _a2;
+              return (_a2 = factory.createRootContext) == null ? void 0 : _a2.call(factory, Object.fromEntries(entries));
+            }
+          ).catch((error) => {
+            const cause = errors.stringifyError(error);
+            throw new Error(
+              `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
+            );
+          }),
+          byPlugin: /* @__PURE__ */ new Map()
+        };
+        __privateGet$3(this, _implementations).set(factory, implementation);
+      }
+      let result = implementation.byPlugin.get(pluginId);
+      if (!result) {
+        const allDeps = new Array();
+        for (const [name, serviceRef] of Object.entries(factory.deps)) {
+          const target = this.get(serviceRef, pluginId);
+          allDeps.push(target.then((impl) => [name, impl]));
+        }
+        result = implementation.context.then(
+          (context) => Promise.all(allDeps).then(
+            (entries) => factory.factory(Object.fromEntries(entries), context)
+          )
+        ).catch((error) => {
+          const cause = errors.stringifyError(error);
+          throw new Error(
+            `Failed to instantiate service '${ref.id}' for '${pluginId}' because the factory function threw an error, ${cause}`
+          );
+        });
+        implementation.byPlugin.set(pluginId, result);
+      }
+      return result;
+    });
+  }
+}
+_providedFactories = new WeakMap();
+_loadedDefaultFactories = new WeakMap();
+_implementations = new WeakMap();
+_rootServiceImplementations = new WeakMap();
+_resolveFactory = new WeakSet();
+resolveFactory_fn = function(ref, pluginId) {
+  if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+    return Promise.resolve(
+      toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
+    );
+  }
+  let resolvedFactory = __privateGet$3(this, _providedFactories).get(ref.id);
+  const { __defaultFactory: defaultFactory } = ref;
+  if (!resolvedFactory && !defaultFactory) {
+    return void 0;
+  }
+  if (!resolvedFactory) {
+    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$3(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
+    }
+    resolvedFactory = loadedFactory.catch((error) => {
+      throw new Error(
+        `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
+          error
+        )}`
+      );
+    });
+  }
+  return Promise.resolve(resolvedFactory);
+};
+_checkForMissingDeps = new WeakSet();
+checkForMissingDeps_fn = function(factory, pluginId) {
+  const missingDeps = Object.values(factory.deps).filter((ref) => {
+    if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+      return false;
+    }
+    if (__privateGet$3(this, _providedFactories).get(ref.id)) {
+      return false;
+    }
+    return !ref.__defaultFactory;
+  });
+  if (missingDeps.length) {
+    const missing = missingDeps.map((r) => `'${r.id}'`).join(", ");
+    throw new Error(
+      `Failed to instantiate service '${factory.service.id}' for '${pluginId}' because the following dependent services are missing: ${missing}`
+    );
+  }
+};
+
+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(serviceHolder) {
-    __privateAdd$3(this, _getInitDeps);
-    __privateAdd$3(this, _addFeature);
-    __privateAdd$3(this, _doStart);
+  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$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);
+    __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$3(this, _startPromise)) {
+    if (__privateGet$2(this, _startPromise)) {
       throw new Error("feature can not be added after the backend has started");
     }
-    __privateMethod$2(this, _addFeature, addFeature_fn).call(this, feature);
+    __privateMethod$1(this, _addFeature, addFeature_fn).call(this, feature);
   }
   async start() {
-    if (__privateGet$3(this, _startPromise)) {
+    if (__privateGet$2(this, _startPromise)) {
       throw new Error("Backend has already started");
     }
     const exitHandler = async () => {
@@ -1137,18 +1485,18 @@ class BackendInitializer {
     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);
+    __privateSet$2(this, _startPromise, __privateMethod$1(this, _doStart, doStart_fn).call(this));
+    await __privateGet$2(this, _startPromise);
   }
   async stop() {
-    if (!__privateGet$3(this, _startPromise)) {
+    if (!__privateGet$2(this, _startPromise)) {
       return;
     }
     try {
-      await __privateGet$3(this, _startPromise);
+      await __privateGet$2(this, _startPromise);
     } catch (error) {
     }
-    const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+    const lifecycleService = await __privateMethod$1(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
     await lifecycleService.shutdown();
   }
 }
@@ -1156,18 +1504,23 @@ _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 extensionPoint = __privateGet$3(this, _extensionPoints).get(
-      ref
-    );
-    if (extensionPoint) {
-      result.set(name, extensionPoint);
+    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$3(this, _serviceHolder).get(
+      const impl = await __privateGet$2(this, _serviceHolder).get(
         ref,
         pluginId
       );
@@ -1193,44 +1546,70 @@ addFeature_fn = function(feature) {
       `Failed to add feature, invalid type '${feature.$$type}'`
     );
   }
-  const internalFeature = feature;
-  if (internalFeature.version !== "v1") {
+  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 version '${internalFeature.version}'`
+      `Failed to add feature, invalid feature ${JSON.stringify(feature)}`
     );
   }
-  __privateGet$3(this, _features).push(internalFeature);
 };
 _doStart = new WeakSet();
 doStart_fn = async function() {
-  const featureDiscovery = await __privateGet$3(this, _serviceHolder).get(
+  __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$2(this, _addFeature, addFeature_fn).call(this, feature);
+      __privateMethod$1(this, _addFeature, addFeature_fn).call(this, feature);
     }
   }
-  for (const ref of __privateGet$3(this, _serviceHolder).getServiceRefs()) {
+  for (const ref of __privateGet$2(this, _serviceHolder).getServiceRefs()) {
     if (ref.scope === "root") {
-      await __privateGet$3(this, _serviceHolder).get(ref, "root");
+      await __privateGet$2(this, _serviceHolder).get(ref, "root");
     }
   }
   const pluginInits = /* @__PURE__ */ new Map();
   const moduleInits = /* @__PURE__ */ new Map();
-  for (const feature of __privateGet$3(this, _features)) {
+  for (const feature of __privateGet$2(this, _features)) {
     for (const r of feature.getRegistrations()) {
       const provides = /* @__PURE__ */ new Set();
-      if (r.type === "plugin") {
+      if (r.type === "plugin" || r.type === "module") {
         for (const [extRef, extImpl] of r.extensionPoints) {
-          if (__privateGet$3(this, _extensionPoints).has(extRef)) {
+          if (__privateGet$2(this, _extensionPoints).has(extRef)) {
             throw new Error(
               `ExtensionPoint with ID '${extRef.id}' is already registered`
             );
           }
-          __privateGet$3(this, _extensionPoints).set(extRef, extImpl);
+          __privateGet$2(this, _extensionPoints).set(extRef, {
+            impl: extImpl,
+            pluginId: r.pluginId
+          });
           provides.add(extRef);
         }
       }
@@ -1267,22 +1646,39 @@ doStart_fn = async function() {
   ];
   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 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$2(this, _getInitDeps, getInitDeps_fn).call(this, pluginInit.init.deps, pluginId);
+        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`,
@@ -1290,14 +1686,14 @@ doStart_fn = async function() {
           );
         });
       }
-      const lifecycleService2 = await __privateMethod$2(this, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn).call(this, pluginId);
+      const lifecycleService2 = await __privateMethod$1(this, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn).call(this, pluginId);
       await lifecycleService2.startup();
     })
   );
-  const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+  const lifecycleService = await __privateMethod$1(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
   await lifecycleService.startup();
   if (process.env.NODE_ENV !== "test") {
-    const rootLogger = await __privateGet$3(this, _serviceHolder).get(
+    const rootLogger = await __privateGet$2(this, _serviceHolder).get(
       backendPluginApi.coreServices.rootLogger,
       "root"
     );
@@ -1313,7 +1709,7 @@ doStart_fn = async function() {
 };
 _getRootLifecycleImpl = new WeakSet();
 getRootLifecycleImpl_fn = async function() {
-  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
+  const lifecycleService = await __privateGet$2(this, _serviceHolder).get(
     backendPluginApi.coreServices.rootLifecycle,
     "root"
   );
@@ -1324,7 +1720,7 @@ getRootLifecycleImpl_fn = async function() {
 };
 _getPluginLifecycleImpl = new WeakSet();
 getPluginLifecycleImpl_fn = async function(pluginId) {
-  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
+  const lifecycleService = await __privateGet$2(this, _serviceHolder).get(
     backendPluginApi.coreServices.lifecycle,
     pluginId
   );
@@ -1333,189 +1729,12 @@ getPluginLifecycleImpl_fn = async function(pluginId) {
   }
   throw new Error("Unexpected plugin lifecycle service implementation");
 };
-
-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 _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
-function toInternalServiceFactory(factory) {
-  const f = factory;
-  if (f.$$type !== "@backstage/ServiceFactory") {
-    throw new Error(`Invalid service factory, bad type '${f.$$type}'`);
-  }
-  if (f.version !== "v1") {
-    throw new Error(`Invalid service factory, bad version '${f.version}'`);
-  }
-  return f;
+function isServiceFactory(feature) {
+  return !!feature.service;
 }
-const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
-  (options) => ({
-    service: backendPluginApi.coreServices.pluginMetadata,
-    deps: {},
-    factory: async () => ({ getId: () => 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(
-      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
-    ));
-    __privateSet$2(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
-    __privateSet$2(this, _implementations, /* @__PURE__ */ new Map());
-  }
-  getServiceRefs() {
-    return Array.from(__privateGet$2(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) => {
-      if (factory.service.scope === "root") {
-        let existing = __privateGet$2(this, _rootServiceImplementations).get(factory);
-        if (!existing) {
-          __privateMethod$1(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") {
-              throw new Error(
-                `Failed to instantiate 'root' scoped service '${ref.id}' because it depends on '${serviceRef.scope}' scoped service '${serviceRef.id}'.`
-              );
-            }
-            const target = this.get(serviceRef, pluginId);
-            rootDeps.push(target.then((impl) => [name, impl]));
-          }
-          existing = Promise.all(rootDeps).then(
-            (entries) => factory.factory(Object.fromEntries(entries), void 0)
-          );
-          __privateGet$2(this, _rootServiceImplementations).set(factory, existing);
-        }
-        return existing;
-      }
-      let implementation = __privateGet$2(this, _implementations).get(factory);
-      if (!implementation) {
-        __privateMethod$1(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") {
-            const target = this.get(serviceRef, pluginId);
-            rootDeps.push(target.then((impl) => [name, impl]));
-          }
-        }
-        implementation = {
-          context: Promise.all(rootDeps).then(
-            (entries) => {
-              var _a2;
-              return (_a2 = factory.createRootContext) == null ? void 0 : _a2.call(factory, Object.fromEntries(entries));
-            }
-          ).catch((error) => {
-            const cause = errors.stringifyError(error);
-            throw new Error(
-              `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
-            );
-          }),
-          byPlugin: /* @__PURE__ */ new Map()
-        };
-        __privateGet$2(this, _implementations).set(factory, implementation);
-      }
-      let result = implementation.byPlugin.get(pluginId);
-      if (!result) {
-        const allDeps = new Array();
-        for (const [name, serviceRef] of Object.entries(factory.deps)) {
-          const target = this.get(serviceRef, pluginId);
-          allDeps.push(target.then((impl) => [name, impl]));
-        }
-        result = implementation.context.then(
-          (context) => Promise.all(allDeps).then(
-            (entries) => factory.factory(Object.fromEntries(entries), context)
-          )
-        ).catch((error) => {
-          const cause = errors.stringifyError(error);
-          throw new Error(
-            `Failed to instantiate service '${ref.id}' for '${pluginId}' because the factory function threw an error, ${cause}`
-          );
-        });
-        implementation.byPlugin.set(pluginId, result);
-      }
-      return result;
-    });
-  }
+function isInternalBackendFeature(feature) {
+  return typeof feature.getRegistrations === "function";
 }
-_providedFactories = new WeakMap();
-_loadedDefaultFactories = new WeakMap();
-_implementations = new WeakMap();
-_rootServiceImplementations = new WeakMap();
-_resolveFactory = new WeakSet();
-resolveFactory_fn = function(ref, pluginId) {
-  if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-    return Promise.resolve(
-      toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
-    );
-  }
-  let resolvedFactory = __privateGet$2(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);
-    if (!loadedFactory) {
-      loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
-        (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
-      );
-      __privateGet$2(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
-    }
-    resolvedFactory = loadedFactory.catch((error) => {
-      throw new Error(
-        `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
-          error
-        )}`
-      );
-    });
-  }
-  return Promise.resolve(resolvedFactory);
-};
-_checkForMissingDeps = new WeakSet();
-checkForMissingDeps_fn = function(factory, pluginId) {
-  const missingDeps = Object.values(factory.deps).filter((ref) => {
-    if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-      return false;
-    }
-    if (__privateGet$2(this, _providedFactories).get(ref.id)) {
-      return false;
-    }
-    return !ref.__defaultFactory;
-  });
-  if (missingDeps.length) {
-    const missing = missingDeps.map((r) => `'${r.id}'`).join(", ");
-    throw new Error(
-      `Failed to instantiate service '${factory.service.id}' for '${pluginId}' because the following dependent services are missing: ${missing}`
-    );
-  }
-};
 
 var __accessCheck$1 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -1535,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();
@@ -1553,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();