@dxos/app-framework 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/dist/lib/node-esm/{chunk-BCEOLX47.mjs → chunk-Q7XBFII4.mjs}

@@ -3,13 +3,15 @@ import {
   eventKey,
   getEvents,
   isAllOf
-} from "./chunk-ZZ7CKK6W.mjs";
+} from "./chunk-XOCUANHO.mjs";
 import {
-  Service as Service2
-} from "./chunk-ULUEXB7Q.mjs";
+  Service as Service2,
+  isLazy,
+  resolveLazy
+} from "./chunk-HTBJU5FX.mjs";
 import {
   Service
-} from "./chunk-42KBWDE4.mjs";
+} from "./chunk-SDJ4B2LU.mjs";
 import {
   __export
 } from "./chunk-HSLMI22Q.mjs";
@@ -18,6 +20,7 @@ import {
 var plugin_manager_exports = {};
 __export(plugin_manager_exports, {
   ManagerTypeId: () => ManagerTypeId,
+  PluginInitializationError: () => PluginInitializationError,
   isManager: () => isManager,
   make: () => make5
 });
@@ -34,6 +37,7 @@ import * as PubSub from "effect/PubSub";
 import * as Ref from "effect/Ref";
 import { runAndForwardErrors } from "@dxos/effect";
 import { Performance } from "@dxos/effect";
+import { BaseError } from "@dxos/errors";
 import { log as log2 } from "@dxos/log";
 
 // src/core/capability-manager.ts
@@ -71,15 +75,7 @@ var CapabilityManagerImpl = class {
   _capability = Atom.family((id) => {
     return Atom.make((get2) => {
       const current = get2(this._capabilities(id));
-      invariant(current.length > 0, `No capability found for ${id}`, {
-        F: __dxlog_file,
-        L: 101,
-        S: this,
-        A: [
-          "current.length > 0",
-          "`No capability found for ${id}`"
-        ]
-      });
+      invariant(current.length > 0, `No capability found for ${id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 35, S: this, A: ["current.length > 0", "`No capability found for ${id}`"] });
       return current[0];
     });
   });
@@ -93,12 +89,7 @@ var CapabilityManagerImpl = class {
       log("capability already contributed, skipping", {
         id: interfaceDef.identifier,
         moduleId
-      }, {
-        F: __dxlog_file,
-        L: 122,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 46, S: this });
       return;
     }
     const entry = {
@@ -113,12 +104,7 @@ var CapabilityManagerImpl = class {
       id: interfaceDef.identifier,
       moduleId,
       count: current.length
-    }, {
-      F: __dxlog_file,
-      L: 128,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 60, S: this });
   }
   remove(interfaceDef, implementation) {
     const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));
@@ -131,21 +117,11 @@ var CapabilityManagerImpl = class {
       log("capability removed", {
         id: interfaceDef.identifier,
         count: current.length
-      }, {
-        F: __dxlog_file,
-        L: 144,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 74, S: this });
     } else {
       log.warn("capability not removed", {
         id: interfaceDef.identifier
-      }, {
-        F: __dxlog_file,
-        L: 146,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 79, S: this });
     }
   }
   atom(interfaceDef) {
@@ -156,15 +132,7 @@ var CapabilityManagerImpl = class {
   }
   get(interfaceDef) {
     const capabilities = this.getAll(interfaceDef);
-    invariant(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`, {
-      F: __dxlog_file,
-      L: 161,
-      S: this,
-      A: [
-        "capabilities.length > 0",
-        "`No capability found for ${interfaceDef.identifier}`"
-      ]
-    });
+    invariant(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 93, S: this, A: ["capabilities.length > 0", "`No capability found for ${interfaceDef.identifier}`"] });
     return capabilities[0];
   }
   waitFor(interfaceDef) {
@@ -192,6 +160,8 @@ var make2 = (options) => new CapabilityManagerImpl(options);
 
 // src/core/plugin-manager.ts
 var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin-manager.ts";
+var PluginInitializationError = class extends BaseError.extend("PluginInitializationError", "Plugin manager initialization failed") {
+};
 var ManagerTypeId = /* @__PURE__ */ Symbol.for("@dxos/app-framework/Manager");
 var isManager = (value) => {
   return typeof value === "object" && value !== null && ManagerTypeId in value;
@@ -209,20 +179,36 @@ var ManagerImpl = class {
   _eventsFiredAtom;
   _pendingResetAtom;
   _pluginLoader;
+  _onRemove;
   _capabilities = /* @__PURE__ */ new Map();
   _moduleMemoMap = /* @__PURE__ */ new Map();
   _moduleSemaphores = /* @__PURE__ */ new Map();
+  // Coalesces concurrent `_resolveLazyPlugin` calls per plugin id. Without
+  // this, two callers entering `enable(id)` before the swap completes would
+  // each invoke `mod.default(options)` and produce distinct module objects,
+  // defeating `_addModule`'s reference-equality dedupe and racing the
+  // `_pluginsAtom` swap.
+  _resolvingPlugins = /* @__PURE__ */ new Map();
   _activatingEvents = Effect2.runSync(Ref.make([]));
   _activatingModules = Effect2.runSync(Ref.make([]));
   _inFlightFibers = Effect2.runSync(Ref.make([]));
   _shutdownSemaphore = Effect2.runSync(Effect2.makeSemaphore(1));
   _shuttingDown = Effect2.runSync(Ref.make(false));
-  constructor({ pluginLoader, plugins = [], core = plugins.map(({ meta }) => meta.id), enabled = [], registry }) {
+  // Tracks the constructor-launched core/enabled `enable()` calls so that
+  // `activate` can wait for module registration before dispatching events.
+  // Lazy plugins make `enable` asynchronous (a dynamic `import()` happens
+  // inside it), so without this synchronization an `activate` triggered
+  // immediately after `make` could fire on an empty module set. Failures
+  // are wrapped in `PluginInitializationError` so awaiters get a tagged
+  // error rather than the wide `Error` produced by the underlying chain.
+  _initialization = Effect2.runSync(Deferred2.make());
+  constructor({ pluginLoader, plugins = [], core = plugins.map(({ meta }) => meta.id), enabled = [], registry, onRemove }) {
     this.registry = registry ?? Registry.make();
     this.capabilities = make2({
       registry: this.registry
     });
     this._pluginLoader = pluginLoader;
+    this._onRemove = onRemove;
     this._pluginsAtom = Atom2.make(plugins).pipe(Atom2.keepAlive);
     this._coreAtom = Atom2.make(core).pipe(Atom2.keepAlive);
     this._enabledAtom = Atom2.make(enabled).pipe(Atom2.keepAlive);
@@ -231,10 +217,15 @@ var ManagerImpl = class {
     this._eventsFiredAtom = Atom2.make([]).pipe(Atom2.keepAlive);
     this._pendingResetAtom = Atom2.make([]).pipe(Atom2.keepAlive);
     plugins.forEach((plugin) => this._addPlugin(plugin));
-    void Effect2.all([
-      ...core,
-      ...enabled
-    ].map((id) => this.enable(id))).pipe(runAndForwardErrors);
+    const initialIds = [
+      .../* @__PURE__ */ new Set([
+        ...core,
+        ...enabled
+      ])
+    ];
+    void Effect2.all(initialIds.map((id) => this.enable(id))).pipe(Effect2.mapError((cause) => new PluginInitializationError({
+      cause
+    })), Effect2.tap(() => Deferred2.succeed(this._initialization, void 0)), Effect2.tapErrorCause((cause) => Deferred2.failCause(this._initialization, cause))).pipe(runAndForwardErrors);
   }
   get plugins() {
     return this._pluginsAtom;
@@ -295,21 +286,17 @@ var ManagerImpl = class {
   }
   /**
   * Adds a plugin to the manager via the plugin loader.
+  * The plugin is registered but not enabled; call `enable` separately to activate it.
   * @param id The id of the plugin.
   */
   add(id) {
     return Effect2.gen(this, function* () {
       log2("add plugin", {
         id
-      }, {
-        F: __dxlog_file2,
-        L: 227,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 165, S: this });
       const plugin = yield* this._pluginLoader(id);
       this._addPlugin(plugin);
-      return yield* this.enable(plugin.meta.id);
+      return plugin;
     });
   }
   /**
@@ -320,16 +307,12 @@ var ManagerImpl = class {
     return Effect2.gen(this, function* () {
       log2("enable plugin", {
         id
-      }, {
-        F: __dxlog_file2,
-        L: 240,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const plugin = this._getPlugin(id);
-      if (!plugin) {
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 178, S: this });
+      const stub = this._getPlugin(id);
+      if (!stub) {
         return false;
       }
+      const plugin = yield* this._resolveLazyPlugin(stub);
       this._update(this._enabledAtom, (enabled) => enabled.includes(id) ? enabled : [
         ...enabled,
         id
@@ -342,12 +325,7 @@ var ManagerImpl = class {
         events: [
           ...this.getPendingReset()
         ]
-      }, {
-        F: __dxlog_file2,
-        L: 253,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 194, S: this });
       yield* Effect2.all(this.getPendingReset().map((event) => this.activate(event)), {
         concurrency: "unbounded"
       });
@@ -355,24 +333,78 @@ var ManagerImpl = class {
     });
   }
   /**
+  * Resolves a lazy plugin stub (returned by {@link Plugin.lazy}) to its
+  * loaded form and swaps it into `_pluginsAtom`. Returns the input unchanged
+  * when the plugin is already resolved, so callers can `yield*` this
+  * unconditionally. The lazy stub carries `meta` synchronously but its
+  * `modules` list is empty until the loader resolves; the swap ensures
+  * subsequent enable/disable operations see the resolved plugin.
+  *
+  * Concurrent calls for the same id are coalesced via `_resolvingPlugins`:
+  * the first caller starts the resolution, every subsequent caller awaits
+  * the same `Deferred`. On failure we publish a `lazy:<id>` error message
+  * and skip the atom swap so the failure is observable to the activation
+  * subscriber and a retry can be attempted.
+  */
+  _resolveLazyPlugin(plugin) {
+    return Effect2.gen(this, function* () {
+      if (!isLazy(plugin)) {
+        return plugin;
+      }
+      const id = plugin.meta.id;
+      const existing = this._resolvingPlugins.get(id);
+      if (existing) {
+        return yield* Deferred2.await(existing);
+      }
+      const deferred = yield* Deferred2.make();
+      this._resolvingPlugins.set(id, deferred);
+      return yield* Effect2.gen(this, function* () {
+        log2("resolving lazy plugin", {
+          id
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 231, S: this });
+        yield* PubSub.publish(this.activation, {
+          event: "",
+          state: "activating",
+          module: `lazy:${id}`
+        });
+        const resolvedPlugin = yield* resolveLazy(plugin);
+        this._update(this._pluginsAtom, (plugins) => plugins.map((p) => p.meta.id === id ? resolvedPlugin : p));
+        yield* PubSub.publish(this.activation, {
+          event: "",
+          state: "activated",
+          module: `lazy:${id}`
+        });
+        return resolvedPlugin;
+      }).pipe(Effect2.tapError((error) => PubSub.publish(this.activation, {
+        event: "",
+        state: "error",
+        module: `lazy:${id}`,
+        error
+      })), Effect2.tap((value) => Deferred2.succeed(deferred, value)), Effect2.tapErrorCause((cause) => Deferred2.failCause(deferred, cause)), Effect2.ensuring(Effect2.sync(() => this._resolvingPlugins.delete(id))));
+    });
+  }
+  /**
   * Removes a plugin from the manager.
   * @param id The id of the plugin.
   */
   remove(id) {
-    log2("remove plugin", {
-      id
-    }, {
-      F: __dxlog_file2,
-      L: 268,
-      S: this,
-      C: (f, a) => f(...a)
+    return Effect2.gen(this, function* () {
+      log2("remove plugin", {
+        id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 260, S: this });
+      const disabled = yield* this.disable(id);
+      if (!disabled) {
+        return false;
+      }
+      this._removePlugin(id);
+      if (this._onRemove) {
+        this._runForkedFiber(this._onRemove(id).pipe(Effect2.tapError((error) => Effect2.sync(() => log2.warn("plugin remove hook failed", {
+          id,
+          error
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 269, S: this }))), Effect2.ignore));
+      }
+      return true;
     });
-    const result = this.disable(id);
-    if (!result) {
-      return false;
-    }
-    this._removePlugin(id);
-    return true;
   }
   /**
   * Disables a plugin.
@@ -382,12 +414,7 @@ var ManagerImpl = class {
     return Effect2.gen(this, function* () {
       log2("disable plugin", {
         id
-      }, {
-        F: __dxlog_file2,
-        L: 284,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 282, S: this });
       if (this._get(this._coreAtom).includes(id)) {
         return false;
       }
@@ -418,22 +445,13 @@ var ManagerImpl = class {
         log2("skipping activation during shutdown", {
           key,
           ...params
-        }, {
-          F: __dxlog_file2,
-          L: 320,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 311, S: this });
         return false;
       }
+      yield* Deferred2.await(this._initialization);
       return yield* Effect2.withFiberRuntime((fiber) => this._activateEvent(key, params, fiber).pipe(together(Effect2.sleep(Duration.seconds(15)).pipe(Effect2.andThen(Effect2.sync(() => log2.warn("event activation is taking a long time", {
         event: key
-      }, {
-        F: __dxlog_file2,
-        L: 328,
-        S: this,
-        C: (f, a) => f(...a)
-      }))))), Performance.addTrackEntry({
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 322, S: this }))))), Performance.addTrackEntry({
         name: typeof event === "string" ? event : eventKey(event),
         devtools: {
           dataType: "track-entry",
@@ -472,12 +490,7 @@ var ManagerImpl = class {
       const key = typeof event === "string" ? event : eventKey(event);
       log2("reset", {
         key
-      }, {
-        F: __dxlog_file2,
-        L: 374,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 359, S: this });
       const modules = this._getActiveModulesByEvent(key);
       const results = yield* Effect2.all(modules.map((module) => this._deactivateModule(module)), {
         concurrency: "unbounded"
@@ -492,12 +505,7 @@ var ManagerImpl = class {
   shutdown() {
     return this._shutdownSemaphore.withPermits(1)(Effect2.gen(this, function* () {
       yield* Ref.set(this._shuttingDown, true);
-      log2("shutdown", void 0, {
-        F: __dxlog_file2,
-        L: 393,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log2("shutdown", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 376, S: this });
       yield* this._interruptInFlightActivations();
       const activeIds = [
         ...this._get(this._activeAtom)
@@ -512,12 +520,7 @@ var ManagerImpl = class {
       this._moduleMemoMap.clear();
       yield* Ref.set(this._activatingEvents, []);
       yield* Ref.set(this._activatingModules, []);
-      log2("shutdown complete", void 0, {
-        F: __dxlog_file2,
-        L: 413,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log2("shutdown complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 391, S: this });
       return true;
     }).pipe(Effect2.ensuring(Ref.set(this._shuttingDown, false))));
   }
@@ -562,12 +565,7 @@ var ManagerImpl = class {
     if (pendingReset.length > 0) {
       log2("pending reset", {
         events: pendingReset
-      }, {
-        F: __dxlog_file2,
-        L: 475,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 434, S: this });
       this._update(this._pendingResetAtom, (current) => [
         ...current,
         ...pendingReset
@@ -600,18 +598,24 @@ var ManagerImpl = class {
   _untrackFiber(ref, fiber) {
     return Ref.update(ref, (fibers) => fibers.filter((trackedFiber) => trackedFiber !== fiber));
   }
+  /**
+  * Spawns an effect on the default runtime and registers the resulting fiber in
+  * `_inFlightFibers` so {@link shutdown} can interrupt it. Used from sync entry
+  * points like {@link remove} where there is no enclosing Effect to fork from;
+  * inside an Effect chain prefer the existing track/await/untrack pattern.
+  */
+  _runForkedFiber(effect) {
+    const fiber = Effect2.runFork(effect);
+    Effect2.runSync(this._trackFiber(this._inFlightFibers, fiber));
+    Effect2.runFork(Fiber.await(fiber).pipe(Effect2.andThen(() => this._untrackFiber(this._inFlightFibers, fiber))));
+  }
   //
   // Registration helpers
   //
   _addPlugin(plugin) {
     log2("add plugin", {
       id: plugin.meta.id
-    }, {
-      F: __dxlog_file2,
-      L: 519,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 483, S: this });
     this._update(this._pluginsAtom, (plugins) => plugins.includes(plugin) ? plugins : [
       ...plugins,
       plugin
@@ -620,23 +624,13 @@ var ManagerImpl = class {
   _removePlugin(id) {
     log2("remove plugin", {
       id
-    }, {
-      F: __dxlog_file2,
-      L: 525,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 493, S: this });
     this._update(this._pluginsAtom, (plugins) => plugins.filter((plugin) => plugin.meta.id !== id));
   }
   _addModule(module) {
     log2("add module", {
       id: module.id
-    }, {
-      F: __dxlog_file2,
-      L: 530,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 499, S: this });
     this._update(this._modulesAtom, (modules) => modules.includes(module) ? modules : [
       ...modules,
       module
@@ -645,12 +639,7 @@ var ManagerImpl = class {
   _removeModule(id) {
     log2("remove module", {
       id
-    }, {
-      F: __dxlog_file2,
-      L: 536,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 509, S: this });
     this._update(this._modulesAtom, (modules) => modules.filter((module) => module.id !== id));
   }
   //
@@ -662,12 +651,7 @@ var ManagerImpl = class {
       log2("activating", {
         key,
         ...params
-      }, {
-        F: __dxlog_file2,
-        L: 551,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 520, S: this });
       yield* Ref.update(this._activatingEvents, (activating) => Array.append(activating, key));
       this._clearPendingReset(key);
       const activatingEvents = yield* this._activatingEvents;
@@ -676,12 +660,7 @@ var ManagerImpl = class {
       if (modules.length === 0) {
         log2("no modules to activate", {
           key
-        }, {
-          F: __dxlog_file2,
-          L: 559,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 530, S: this });
         if (!this._get(this._eventsFiredAtom).includes(key)) {
           this._update(this._eventsFiredAtom, (events) => [
             ...events,
@@ -703,12 +682,7 @@ var ManagerImpl = class {
       log2("activating modules", {
         key,
         modules: activatingModuleIds
-      }, {
-        F: __dxlog_file2,
-        L: 586,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 551, S: this });
       performance.mark(`event:${key}:start`);
       yield* PubSub.publish(this.activation, {
         event: key,
@@ -732,12 +706,7 @@ var ManagerImpl = class {
       });
       log2("activated", {
         key
-      }, {
-        F: __dxlog_file2,
-        L: 604,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 576, S: this });
       return true;
     }).pipe(Effect2.ensuring(Ref.update(this._activatingModules, (activating) => Array.filter(activating, (module) => !activatingModuleIds.includes(module)))));
   }
@@ -752,13 +721,13 @@ var ManagerImpl = class {
     });
   }
   _getBeforeEvents(modules, activatingEvents) {
-    return Function.pipe(modules, Array.flatMap((module) => module.activatesBefore ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event) => !activatingEvents.includes(eventKey(event))));
+    return Function.pipe(modules, Array.flatMap((module) => module.firesBeforeActivation ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event) => !activatingEvents.includes(eventKey(event))));
   }
   _getAfterEvents(modules, activatingEvents) {
-    return Function.pipe(modules, Array.flatMap((module) => module.activatesAfter ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event) => !activatingEvents.includes(eventKey(event))));
+    return Function.pipe(modules, Array.flatMap((module) => module.firesAfterActivation ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event) => !activatingEvents.includes(eventKey(event))));
   }
   _activateRelatedEvents(key, events, phase) {
-    const logLabel = phase === "before" ? "activatesBefore" : "activatesAfter";
+    const logLabel = phase === "before" ? "firesBeforeActivation" : "firesAfterActivation";
     const eventKey2 = phase === "before" ? "beforeEvents" : "afterEvents";
     return Function.pipe(events, Array.map((event) => this.activate(event, phase === "before" ? {
       before: key
@@ -769,18 +738,13 @@ var ManagerImpl = class {
     }), together(Effect2.sleep(Duration.seconds(10)).pipe(Effect2.andThen(Effect2.sync(() => log2.warn(`${logLabel} is taking a long time`, {
       event: key,
       [eventKey2]: events.map(eventKey)
-    }, {
-      F: __dxlog_file2,
-      L: 683,
-      S: this,
-      C: (f, a) => f(...a)
-    }))))), Effect2.asVoid);
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 609, S: this }))))), Effect2.asVoid);
   }
   //
   // Module lifecycle helpers
   //
   _loadCapabilitiesForModules(key, modules) {
-    return Function.pipe(modules, Array.map((mod) => this._loadModule(mod)), Effect2.allWith({
+    return Function.pipe(modules, Array.map((mod) => this._loadModule(mod, key)), Effect2.allWith({
       concurrency: "unbounded"
     }), Effect2.catchAll((error) => {
       return Effect2.gen(this, function* () {
@@ -810,7 +774,14 @@ var ManagerImpl = class {
     }
     return semaphore;
   }
-  _loadModule = (module) => Effect2.gen(this, function* () {
+  // `parentEvent` is the activation event that first triggered this module
+  // load — included in `activating`/`activated` PubSub messages so subscribers
+  // (e.g. the boot loader's status listener) can associate a module with its
+  // triggering event in the trace. The same module may be referenced by
+  // multiple events, but module loads are memoized via `_moduleMemoMap`, so
+  // only the first event to need it will appear here; later events await the
+  // cached deferred without re-publishing.
+  _loadModule = (module, parentEvent) => Effect2.gen(this, function* () {
     const semaphore = this._getModuleSemaphore(module.id);
     const deferredToAwait = yield* Effect2.gen(this, function* () {
       const existing = this._moduleMemoMap.get(module.id);
@@ -821,16 +792,12 @@ var ManagerImpl = class {
       this._moduleMemoMap.set(module.id, deferred);
       const loadEffect = Effect2.gen(this, function* () {
         log2("loading module", {
-          module: module.id
-        }, {
-          F: __dxlog_file2,
-          L: 756,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+          module: module.id,
+          parentEvent
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 667, S: this });
         performance.mark(`module:${module.id}:start`);
         yield* PubSub.publish(this.activation, {
-          event: "",
+          event: parentEvent,
           state: "activating",
           module: module.id
         });
@@ -842,29 +809,20 @@ var ManagerImpl = class {
         performance.mark(`module:${module.id}:end`);
         performance.measure(`module:${module.id}`, `module:${module.id}:start`, `module:${module.id}:end`);
         yield* PubSub.publish(this.activation, {
-          event: "",
+          event: parentEvent,
           state: "activated",
           module: module.id
         });
         log2("loaded module", {
           module: module.id,
+          parentEvent,
           elapsed,
           failed: false
-        }, {
-          F: __dxlog_file2,
-          L: 771,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 689, S: this });
         return normalized;
       }).pipe(Effect2.withSpan("PluginManager._loadModule"), together(Effect2.sleep(Duration.seconds(10)).pipe(Effect2.andThen(Effect2.sync(() => log2.warn(`module is taking a long time to activate`, {
         module: module.id
-      }, {
-        F: __dxlog_file2,
-        L: 782,
-        S: this,
-        C: (f, a) => f(...a)
-      }))))), Performance.addTrackEntry({
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 696, S: this }))))), Performance.addTrackEntry({
         name: module.id,
         devtools: {
           dataType: "track-entry",
@@ -880,12 +838,7 @@ var ManagerImpl = class {
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0,
           isDefect: !Cause.isFailure(cause)
-        }, {
-          F: __dxlog_file2,
-          L: 803,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 710, S: this });
         return Deferred2.fail(deferred, error instanceof Error ? error : new Error(String(error)));
       })));
       yield* this._trackFiber(this._inFlightFibers, fiber);
@@ -914,12 +867,7 @@ var ManagerImpl = class {
       const id = module.id;
       log2("deactivating", {
         id
-      }, {
-        F: __dxlog_file2,
-        L: 841,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 743, S: this });
       this._moduleMemoMap.delete(id);
       const capabilities = this._capabilities.get(id);
       if (capabilities) {
@@ -936,12 +884,7 @@ var ManagerImpl = class {
       }
       log2("deactivated", {
         id
-      }, {
-        F: __dxlog_file2,
-        L: 859,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 760, S: this });
       return true;
     });
   }
@@ -956,9 +899,10 @@ var together = (togetherEffect) => (effect) => Effect2.gen(function* () {
 
 export {
   capability_manager_exports,
+  PluginInitializationError,
   ManagerTypeId,
   isManager,
   make5 as make,
   plugin_manager_exports
 };
-//# sourceMappingURL=chunk-BCEOLX47.mjs.map
+//# sourceMappingURL=chunk-Q7XBFII4.mjs.map