@dxos/app-framework 0.8.4-main.b97322e → 0.8.4-main.bc2380dfbc

package/dist/lib/browser/chunk-J43JDWAV.mjs

@@ -0,0 +1,1445 @@
+import {
+  eventKey,
+  getEvents,
+  isAllOf
+} from "./chunk-66IXTIVK.mjs";
+import {
+  LazyPluginError,
+  PluginDependencyError,
+  Service as Service2,
+  isLazy,
+  resolveLazy
+} from "./chunk-G6Q2M2M5.mjs";
+import {
+  Service
+} from "./chunk-3JWJXGLK.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/core/plugin-manager.ts
+var plugin_manager_exports = {};
+__export(plugin_manager_exports, {
+  ManagerTypeId: () => ManagerTypeId,
+  PluginInitializationError: () => PluginInitializationError,
+  PluginTimeoutError: () => PluginTimeoutError,
+  isManager: () => isManager,
+  make: () => make5
+});
+import { Atom as Atom3, Registry } from "@effect-atom/atom-react";
+import * as Array from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Deferred2 from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect3 from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Function from "effect/Function";
+import * as HashSet from "effect/HashSet";
+import * as PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
+import { runAndForwardErrors as runAndForwardErrors2 } from "@dxos/effect";
+import { Performance } from "@dxos/effect";
+import { BaseError } from "@dxos/errors";
+import { log as log3 } from "@dxos/log";
+
+// src/core/capability-manager.ts
+var capability_manager_exports = {};
+__export(capability_manager_exports, {
+  make: () => make2
+});
+import { Atom } from "@effect-atom/atom-react";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/capability-manager.ts";
+var CapabilityManagerImpl = class {
+  _registry;
+  _capabilityEntries = Atom.family(() => {
+    return Atom.make([]).pipe(Atom.keepAlive);
+  });
+  _capabilities = Atom.family((id) => {
+    return Atom.make((get2) => {
+      const current = get2(this._capabilityEntries(id));
+      return current.map((c) => c.implementation);
+    }).pipe(Atom.keepAlive);
+  });
+  _capabilitiesByModule = Atom.family((id) => {
+    return Atom.make((get2) => {
+      const entries = get2(this._capabilityEntries(id));
+      const result = {};
+      for (const entry of entries) {
+        (result[entry.moduleId] ??= []).push(entry.implementation);
+      }
+      return result;
+    }).pipe(Atom.keepAlive);
+  });
+  _capability = Atom.family((id) => {
+    return Atom.make((get2) => {
+      const current = get2(this._capabilities(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];
+    });
+  });
+  constructor({ registry }) {
+    this._registry = registry;
+  }
+  contribute({ module: moduleId, interface: interfaceDef, implementation }) {
+    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));
+    const isDuplicate = current.some((c) => c.moduleId === moduleId && c.implementation === implementation);
+    if (isDuplicate) {
+      log("capability already contributed, skipping", {
+        id: interfaceDef.identifier,
+        moduleId
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 46, S: this });
+      return;
+    }
+    const entry = {
+      moduleId,
+      implementation
+    };
+    this._registry.set(this._capabilityEntries(interfaceDef.identifier), [
+      ...current,
+      entry
+    ]);
+    log("capability contributed", {
+      id: interfaceDef.identifier,
+      moduleId,
+      count: current.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 60, S: this });
+  }
+  remove(interfaceDef, implementation) {
+    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));
+    if (current.length === 0) {
+      return;
+    }
+    const next = current.filter((c) => c.implementation !== implementation);
+    if (next.length !== current.length) {
+      this._registry.set(this._capabilityEntries(interfaceDef.identifier), next);
+      log("capability removed", {
+        id: interfaceDef.identifier,
+        count: current.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 74, S: this });
+    } else {
+      log.warn("capability not removed", {
+        id: interfaceDef.identifier
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 79, S: this });
+    }
+  }
+  atom(interfaceDef) {
+    return this._capabilities(interfaceDef.identifier);
+  }
+  getAll(interfaceDef) {
+    return this._registry.get(this.atom(interfaceDef));
+  }
+  get(interfaceDef) {
+    const capabilities = this.getAll(interfaceDef);
+    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) {
+    return Effect.gen(this, function* () {
+      const [capability] = this.getAll(interfaceDef);
+      if (capability) {
+        return capability;
+      }
+      const deferred = yield* Deferred.make();
+      const cancel = this._registry.subscribe(this.atom(interfaceDef), (capabilities) => {
+        if (capabilities.length > 0) {
+          Effect.runSync(Deferred.succeed(deferred, capabilities[0]));
+        }
+      });
+      const result = yield* Deferred.await(deferred);
+      cancel();
+      return result;
+    });
+  }
+  atomByModule(interfaceDef) {
+    return this._capabilitiesByModule(interfaceDef.identifier);
+  }
+};
+var make2 = (options) => new CapabilityManagerImpl(options);
+
+// src/core/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  Manager: () => Manager
+});
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import * as Effect2 from "effect/Effect";
+import { runAndForwardErrors } from "@dxos/effect";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/registry.ts";
+var NULL_PROVIDER = {
+  listPlugins: () => Effect2.succeed([]),
+  listVersions: () => Effect2.fail(new Error("No plugin registry provider configured")),
+  getPlugin: () => Effect2.fail(new Error("No plugin registry provider configured"))
+};
+var Manager = class {
+  plugins;
+  #provider;
+  constructor(provider, atomRegistry) {
+    this.#provider = provider ?? NULL_PROVIDER;
+    const initialLoading = provider !== void 0;
+    this.plugins = Atom2.make({
+      entries: [],
+      loading: initialLoading,
+      error: null
+    }).pipe(Atom2.keepAlive);
+    if (provider !== void 0) {
+      void runAndForwardErrors(provider.listPlugins().pipe(Effect2.match({
+        onSuccess: (entries) => atomRegistry.set(this.plugins, {
+          entries,
+          loading: false,
+          error: null
+        }),
+        onFailure: (error) => {
+          log2.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 49, S: this });
+          atomRegistry.set(this.plugins, {
+            entries: [],
+            loading: false,
+            error
+          });
+        }
+      })));
+    }
+  }
+  /** Forwards to the underlying provider. */
+  listPlugins() {
+    return this.#provider.listPlugins();
+  }
+  /** Forwards to the underlying provider. */
+  listVersions(repo) {
+    return this.#provider.listVersions(repo);
+  }
+  /** Forwards to the underlying provider. */
+  getPlugin(repo, version) {
+    return this.#provider.getPlugin(repo, version);
+  }
+};
+
+// src/core/plugin-manager.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin-manager.ts";
+var PluginInitializationError = class extends BaseError.extend("PluginInitializationError", "Plugin manager initialization failed") {
+};
+var PluginTimeoutError = class extends BaseError.extend("PluginTimeoutError", "Plugin operation timed out") {
+};
+var DEFAULT_LOAD_TIMEOUT = Duration.seconds(30);
+var DEFAULT_ACTIVATION_TIMEOUT = Duration.seconds(30);
+var ManagerTypeId = /* @__PURE__ */ Symbol.for("@dxos/app-framework/Manager");
+var isManager = (value) => {
+  return typeof value === "object" && value !== null && ManagerTypeId in value;
+};
+var ManagerImpl = class {
+  [ManagerTypeId] = ManagerTypeId;
+  activation = Effect3.runSync(PubSub.unbounded());
+  capabilities;
+  registry;
+  pluginRegistry;
+  _pluginsAtom;
+  _coreAtom;
+  _enabledAtom;
+  _modulesAtom;
+  _activeAtom;
+  _eventsFiredAtom;
+  _pendingResetAtom;
+  _failedAtom;
+  _pluginLoader;
+  _onRemove;
+  _loadTimeout;
+  _activationTimeout;
+  _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();
+  // Tracks dev-source plugins (loaded via a Vite dev server) keyed by id.
+  // When `shadow` is present, the entry has displaced an existing plugin —
+  // `remove` reinstates it and re-enables iff `wasEnabled`. Entries without a
+  // shadow are dev plugins with no underlying registry/builtin to restore.
+  // The atom mirrors the map's keys for UI subscribers (they don't need the
+  // shadow internals); the two stay in sync via {@link _markDev}/{@link _unmarkDev}.
+  _devPlugins = /* @__PURE__ */ new Map();
+  _devPluginIdsAtom;
+  _activatingEvents = Effect3.runSync(Ref.make([]));
+  _activatingModules = Effect3.runSync(Ref.make([]));
+  _inFlightFibers = Effect3.runSync(Ref.make([]));
+  _shutdownSemaphore = Effect3.runSync(Effect3.makeSemaphore(1));
+  _shuttingDown = Effect3.runSync(Ref.make(false));
+  // 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 = Effect3.runSync(Deferred2.make());
+  constructor({ pluginLoader, plugins = [], core = plugins.map(({ meta }) => meta.id), enabled = [], registry, pluginRegistryProvider, onRemove, loadTimeout = DEFAULT_LOAD_TIMEOUT, activationTimeout = DEFAULT_ACTIVATION_TIMEOUT }) {
+    this.registry = registry ?? Registry.make();
+    this.capabilities = make2({
+      registry: this.registry
+    });
+    this.pluginRegistry = new Manager(pluginRegistryProvider, this.registry);
+    this._pluginLoader = pluginLoader;
+    this._onRemove = onRemove;
+    this._loadTimeout = loadTimeout;
+    this._activationTimeout = activationTimeout;
+    this._pluginsAtom = Atom3.make(plugins).pipe(Atom3.keepAlive);
+    this._coreAtom = Atom3.make(core).pipe(Atom3.keepAlive);
+    this._enabledAtom = Atom3.make(enabled).pipe(Atom3.keepAlive);
+    this._modulesAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    this._activeAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    this._eventsFiredAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    this._pendingResetAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    this._failedAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    this._devPluginIdsAtom = Atom3.make([]).pipe(Atom3.keepAlive);
+    plugins.forEach((plugin) => this._addPlugin(plugin));
+    const initialIds = [
+      .../* @__PURE__ */ new Set([
+        ...core,
+        ...enabled
+      ])
+    ];
+    void Effect3.all(initialIds.map((id) => this.enable(id))).pipe(Effect3.mapError((cause) => new PluginInitializationError({
+      cause
+    })), Effect3.tap(() => Deferred2.succeed(this._initialization, void 0)), Effect3.tapErrorCause((cause) => Deferred2.failCause(this._initialization, cause))).pipe(runAndForwardErrors2);
+  }
+  get plugins() {
+    return this._pluginsAtom;
+  }
+  get core() {
+    return this._coreAtom;
+  }
+  /**
+  * Ids of plugins that are currently enabled.
+  */
+  get enabled() {
+    return this._enabledAtom;
+  }
+  /**
+  * Modules of plugins which are currently enabled.
+  */
+  get modules() {
+    return this._modulesAtom;
+  }
+  /**
+  * Ids of modules which are currently active.
+  */
+  get active() {
+    return this._activeAtom;
+  }
+  /**
+  * Ids of events which have been fired.
+  */
+  get eventsFired() {
+    return this._eventsFiredAtom;
+  }
+  /**
+  * Ids of modules which are pending reset.
+  */
+  get pendingReset() {
+    return this._pendingResetAtom;
+  }
+  /**
+  * Plugins that failed to load or activate.
+  */
+  get failed() {
+    return this._failedAtom;
+  }
+  /**
+  * Ids of currently-registered plugins that came from a dev source.
+  */
+  get devPluginIds() {
+    return this._devPluginIdsAtom;
+  }
+  getPlugins() {
+    return this._get(this._pluginsAtom);
+  }
+  getCore() {
+    return this._get(this._coreAtom);
+  }
+  getEnabled() {
+    return this._get(this._enabledAtom);
+  }
+  getModules() {
+    return this._get(this._modulesAtom);
+  }
+  getActive() {
+    return this._get(this._activeAtom);
+  }
+  getEventsFired() {
+    return this._get(this._eventsFiredAtom);
+  }
+  getPendingReset() {
+    return this._get(this._pendingResetAtom);
+  }
+  getFailed() {
+    return this._get(this._failedAtom);
+  }
+  getDevPluginIds() {
+    return this._get(this._devPluginIdsAtom);
+  }
+  /**
+  * Marks `id` as dev-sourced. If the plugin displaced an existing one, pass
+  * the shadow snapshot so `remove` can restore it. Repeat calls (e.g. a dev
+  * plugin reload) preserve the original shadow target — restoration always
+  * unwinds back to the real underlying plugin, never an intermediate dev build.
+  */
+  _markDev(id, shadow) {
+    if (this._devPlugins.has(id)) {
+      return;
+    }
+    this._devPlugins.set(id, {
+      shadow
+    });
+    this._update(this._devPluginIdsAtom, (ids) => ids.includes(id) ? ids : [
+      ...ids,
+      id
+    ]);
+  }
+  /** Drops the dev-plugin entry and returns its shadow data (if any) for restoration. */
+  _unmarkDev(id) {
+    const entry = this._devPlugins.get(id);
+    this._devPlugins.delete(id);
+    this._update(this._devPluginIdsAtom, (ids) => ids.filter((existing) => existing !== id));
+    return entry?.shadow;
+  }
+  getDependencies(id, opts) {
+    const transitive = opts?.transitive !== false;
+    if (!transitive) {
+      return this._directDependencies(id);
+    }
+    const walk = this._computeDependencyClosure(id);
+    return walk.order.filter((depId) => depId !== id);
+  }
+  getDependents(id, opts) {
+    return this._collectDependents(id, {
+      transitive: opts?.transitive !== false,
+      enabledOnly: opts?.enabledOnly === true
+    });
+  }
+  clearFailure(id) {
+    const current = this._get(this._failedAtom);
+    if (!current.some((failure) => failure.id === id)) {
+      return false;
+    }
+    this._set(this._failedAtom, current.filter((failure) => failure.id !== id));
+    return true;
+  }
+  /**
+  * 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 Effect3.gen(this, function* () {
+      log3("add plugin", {
+        id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 258, S: this });
+      const { plugin, dev = false } = yield* this._pluginLoader(id);
+      const pluginId = plugin.meta.id;
+      const existing = this._getPlugin(pluginId);
+      if (dev && existing && existing !== plugin) {
+        const wasEnabled = this._get(this._enabledAtom).includes(pluginId);
+        if (wasEnabled) {
+          yield* this.disable(pluginId);
+        }
+        this._markDev(pluginId, {
+          plugin: existing,
+          wasEnabled
+        });
+        this._update(this._pluginsAtom, (plugins) => plugins.map((p) => p.meta.id === pluginId ? plugin : p));
+      } else {
+        this._addPlugin(plugin);
+        if (dev) {
+          this._markDev(pluginId);
+        }
+      }
+      return plugin;
+    });
+  }
+  /**
+  * Enables a plugin.
+  * @param id The id of the plugin.
+  * @param opts See {@link PluginManager.enable}.
+  */
+  enable(id, opts) {
+    const resolveDependencies = opts?.resolveDependencies !== false;
+    return Effect3.gen(this, function* () {
+      log3("enable plugin", {
+        id,
+        resolveDependencies
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 297, S: this });
+      if (!resolveDependencies) {
+        return yield* this._enableOne(id);
+      }
+      if (!this._getPlugin(id) && !this._getCatalogEntry(id)) {
+        return yield* this._enableOne(id);
+      }
+      const walk = this._computeDependencyClosure(id);
+      if (walk.cycle) {
+        this._recordFailure(id, "load", new PluginDependencyError({
+          context: {
+            id,
+            reason: "cycle",
+            path: walk.cycle
+          }
+        }));
+        return false;
+      }
+      if (walk.missing.length > 0) {
+        this._recordFailure(id, "load", new PluginDependencyError({
+          context: {
+            id,
+            reason: "missing",
+            missing: walk.missing
+          }
+        }));
+        return false;
+      }
+      let queue = walk.toInstall.slice();
+      const installed = /* @__PURE__ */ new Set();
+      while (queue.length > 0) {
+        const next = queue.shift();
+        if (installed.has(next) || this._getPlugin(next)) {
+          continue;
+        }
+        const installResult = yield* this.add(next).pipe(Effect3.either);
+        if (installResult._tag === "Left") {
+          this._recordFailure(id, "load", new PluginDependencyError({
+            context: {
+              id,
+              reason: "install-failed",
+              dependency: next
+            },
+            cause: installResult.left
+          }));
+          return false;
+        }
+        installed.add(next);
+        const rewalk = this._computeDependencyClosure(id);
+        if (rewalk.cycle) {
+          this._recordFailure(id, "load", new PluginDependencyError({
+            context: {
+              id,
+              reason: "cycle",
+              path: rewalk.cycle
+            }
+          }));
+          return false;
+        }
+        if (rewalk.missing.length > 0) {
+          this._recordFailure(id, "load", new PluginDependencyError({
+            context: {
+              id,
+              reason: "missing",
+              missing: rewalk.missing
+            }
+          }));
+          return false;
+        }
+        queue = rewalk.toInstall.filter((depId) => !installed.has(depId));
+      }
+      const order = this._computeDependencyClosure(id).order;
+      let succeeded = false;
+      for (const depId of order) {
+        const ok = yield* this._enableOne(depId);
+        if (depId === id) {
+          succeeded = ok;
+        }
+      }
+      return succeeded;
+    });
+  }
+  /**
+  * Enables a single plugin without consulting its declared dependencies.
+  * Used by {@link enable} as the leaf step after closure resolution, and
+  * directly when callers pass `{ resolveDependencies: false }`.
+  *
+  * The underlying operations (`_addModule`, `_setPendingResetByModule`,
+  * `activate`) are all idempotent, so this method is safe to call multiple
+  * times for the same id. The constructor's bootstrap path relies on this:
+  * the persisted `enabled` ids are written into `_enabledAtom` up front, so
+  * the very first `enable(id)` for those plugins sees `alreadyEnabled`-style
+  * state but still needs to perform the module registration and activation.
+  */
+  _enableOne(id) {
+    return Effect3.gen(this, function* () {
+      const stub = this._getPlugin(id);
+      if (!stub) {
+        return false;
+      }
+      this.clearFailure(id);
+      const plugin = yield* this._resolveLazyPlugin(stub);
+      this._update(this._enabledAtom, (enabled) => enabled.includes(id) ? enabled : [
+        ...enabled,
+        id
+      ]);
+      plugin.modules.forEach((module) => {
+        this._addModule(module);
+        this._setPendingResetByModule(module);
+      });
+      log3("pending reset", {
+        events: [
+          ...this.getPendingReset()
+        ]
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 424, S: this });
+      yield* Effect3.all(this.getPendingReset().map((event) => this.activate(event)), {
+        concurrency: "unbounded"
+      });
+      return true;
+    });
+  }
+  /**
+  * 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 Effect3.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* Effect3.gen(this, function* () {
+        log3("resolving lazy plugin", {
+          id
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 461, S: this });
+        yield* PubSub.publish(this.activation, {
+          event: "",
+          state: "activating",
+          module: `lazy:${id}`
+        });
+        const resolvedPlugin = yield* resolveLazy(plugin).pipe(
+          // Cap how long a remote import can hang. Without this the host can
+          // sit on a pending dynamic `import()` indefinitely if the plugin's
+          // server is unreachable, which stalls every caller awaiting
+          // `enable(id)` and (transitively) the manager's initialization.
+          Effect3.timeoutFail({
+            duration: this._loadTimeout,
+            onTimeout: () => new LazyPluginError({
+              context: {
+                id,
+                reason: "load-failed"
+              },
+              cause: new PluginTimeoutError({
+                context: {
+                  id,
+                  phase: "load"
+                }
+              })
+            })
+          })
+        );
+        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(Effect3.tapError((error) => Effect3.gen(this, function* () {
+        yield* PubSub.publish(this.activation, {
+          event: "",
+          state: "error",
+          module: `lazy:${id}`,
+          error
+        });
+        this._recordFailure(id, "load", error);
+        this._scheduleAutoDisable(id);
+      })), Effect3.tap((value) => Deferred2.succeed(deferred, value)), Effect3.tapErrorCause((cause) => Deferred2.failCause(deferred, cause)), Effect3.ensuring(Effect3.sync(() => this._resolvingPlugins.delete(id))));
+    });
+  }
+  /**
+  * Removes a plugin from the manager.
+  * @param id The id of the plugin.
+  * @param opts See {@link PluginManager.remove}.
+  */
+  remove(id, opts) {
+    return Effect3.gen(this, function* () {
+      log3("remove plugin", {
+        id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 513, S: this });
+      const wasDev = this._devPlugins.has(id);
+      const disabled = yield* this.disable(id, opts);
+      if (!disabled) {
+        return false;
+      }
+      this._removePlugin(id);
+      if (this._onRemove) {
+        this._runForkedFiber(this._onRemove(id).pipe(Effect3.tapError((error) => Effect3.sync(() => log3.warn("plugin remove hook failed", {
+          id,
+          error
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 523, S: this }))), Effect3.ignore));
+      }
+      if (wasDev) {
+        const shadow = this._unmarkDev(id);
+        if (shadow) {
+          this._addPlugin(shadow.plugin);
+          if (shadow.wasEnabled) {
+            yield* this.enable(id);
+          }
+        }
+      }
+      return true;
+    });
+  }
+  /**
+  * Disables a plugin.
+  * @param id The id of the plugin.
+  * @param opts See {@link PluginManager.disable}.
+  */
+  disable(id, { cascade = true } = {}) {
+    return Effect3.gen(this, function* () {
+      log3("disable plugin", {
+        id,
+        cascade
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 551, S: this });
+      if (this._get(this._coreAtom).includes(id)) {
+        return false;
+      }
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      if (cascade) {
+        const enabledDependents = this._collectDependents(id, {
+          transitive: true,
+          enabledOnly: true
+        });
+        if (enabledDependents.length > 0) {
+          const coreDependent = enabledDependents.find((dependentId) => this._get(this._coreAtom).includes(dependentId));
+          if (coreDependent) {
+            return yield* Effect3.fail(new PluginDependencyError({
+              context: {
+                id,
+                reason: "core-dependent",
+                coreDependent
+              }
+            }));
+          }
+          for (const dependentId of enabledDependents) {
+            yield* this._disableOne(dependentId);
+          }
+        }
+      }
+      yield* this._disableOne(id);
+      return true;
+    });
+  }
+  /**
+  * Disables a single plugin without consulting its dependents. Used by
+  * {@link disable} after the dependents pass has run (or been skipped via
+  * `cascade: false`).
+  */
+  _disableOne(id) {
+    return Effect3.gen(this, function* () {
+      if (this._get(this._coreAtom).includes(id)) {
+        return false;
+      }
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      const enabledIndex = this._get(this._enabledAtom).findIndex((enabled) => enabled === id);
+      if (enabledIndex !== -1) {
+        this._update(this._enabledAtom, (enabled) => enabled.filter((item) => item !== id));
+        yield* this.deactivate(id);
+        plugin.modules.forEach((module) => {
+          this._removeModule(module.id);
+        });
+      }
+      return true;
+    });
+  }
+  /**
+  * Activates plugins based on the activation event.
+  * @param event The activation event.
+  * @returns Whether the activation was successful.
+  */
+  activate(event, params) {
+    const key = typeof event === "string" ? event : eventKey(event);
+    return Effect3.gen(this, function* () {
+      if (yield* this._isShuttingDown()) {
+        log3("skipping activation during shutdown", {
+          key,
+          ...params
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 622, S: this });
+        return false;
+      }
+      yield* Deferred2.await(this._initialization);
+      return yield* Effect3.withFiberRuntime((fiber) => this._activateEvent(key, params, fiber).pipe(together(Effect3.sleep(Duration.seconds(15)).pipe(Effect3.andThen(Effect3.sync(() => log3.warn("event activation is taking a long time", {
+        event: key
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 633, S: this }))))), Performance.addTrackEntry({
+        name: typeof event === "string" ? event : eventKey(event),
+        devtools: {
+          dataType: "track-entry",
+          track: "Event Activation",
+          trackGroup: "Composer",
+          color: "primary"
+        }
+      })));
+    });
+  }
+  /**
+  * Deactivates all of the modules for a plugin.
+  * @param id The id of the plugin.
+  * @returns Whether the deactivation was successful.
+  */
+  deactivate(id) {
+    return Effect3.gen(this, function* () {
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      const modules = plugin.modules;
+      const results = yield* Effect3.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
+      return results.every((result) => result);
+    });
+  }
+  /**
+  * Re-activates the modules that were activated by the event.
+  * @param event The activation event.
+  * @returns Whether the reset was successful.
+  */
+  reset(event) {
+    return Effect3.gen(this, function* () {
+      const key = typeof event === "string" ? event : eventKey(event);
+      log3("reset", {
+        key
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 670, S: this });
+      const modules = this._getActiveModulesByEvent(key);
+      const results = yield* Effect3.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
+      if (results.every((result) => result)) {
+        return yield* this.activate(key);
+      } else {
+        return false;
+      }
+    });
+  }
+  shutdown() {
+    return this._shutdownSemaphore.withPermits(1)(Effect3.gen(this, function* () {
+      yield* Ref.set(this._shuttingDown, true);
+      log3("shutdown", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 687, S: this });
+      yield* this._interruptInFlightActivations();
+      const activeIds = [
+        ...this._get(this._activeAtom)
+      ].reverse();
+      const allModules = this._get(this._modulesAtom);
+      const modulesToDeactivate = activeIds.map((id) => allModules.find((module) => module.id === id)).filter((module) => module != null);
+      for (const module of modulesToDeactivate) {
+        yield* this._deactivateModule(module);
+      }
+      this._set(this._eventsFiredAtom, []);
+      this._set(this._pendingResetAtom, []);
+      this._moduleMemoMap.clear();
+      yield* Ref.set(this._activatingEvents, []);
+      yield* Ref.set(this._activatingModules, []);
+      log3("shutdown complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 702, S: this });
+      return true;
+    }).pipe(Effect3.ensuring(Ref.set(this._shuttingDown, false))));
+  }
+  //
+  // State helpers
+  //
+  _get(atom) {
+    return this.registry.get(atom);
+  }
+  _set(atom, value) {
+    this.registry.set(atom, value);
+  }
+  _update(atom, updater) {
+    this._set(atom, updater(this._get(atom)));
+  }
+  _isShuttingDown() {
+    return Ref.get(this._shuttingDown);
+  }
+  _getPlugin(id) {
+    return this._get(this._pluginsAtom).find((plugin) => plugin.meta.id === id);
+  }
+  _getPluginIdForModule(moduleId) {
+    return this._get(this._pluginsAtom).find((plugin) => plugin.modules.some((module) => module.id === moduleId))?.meta.id;
+  }
+  /** Looks up an id in the cached registry catalog, returning the entry or `undefined`. */
+  _getCatalogEntry(id) {
+    return this._get(this.pluginRegistry.plugins).entries.find((entry) => entry.id === id);
+  }
+  /**
+  * Returns the direct `dependsOn` declarations for an id, drawing from the
+  * registered plugin's meta when available and falling back to the registry
+  * catalog entry. Unknown ids return an empty list (callers detect "missing"
+  * separately).
+  */
+  _directDependencies(id) {
+    const plugin = this._getPlugin(id);
+    if (plugin) {
+      return [
+        ...plugin.meta.dependsOn ?? []
+      ];
+    }
+    const catalog = this._getCatalogEntry(id);
+    return catalog?.dependsOn ? [
+      ...catalog.dependsOn
+    ] : [];
+  }
+  /**
+  * Computes the transitive dependency closure for an id.
+  *
+  * Walks {@link _directDependencies} (registered plugins ∪ catalog entries).
+  * Returns:
+  *  - `order`: closure including the root in dependency-first topological order.
+  *  - `missing`: ids in the closure that are neither registered nor in the catalog.
+  *  - `toInstall`: ids in the closure that are in the catalog but not yet registered.
+  *  - `cycle`: when a cycle is detected, the cycle path; otherwise `undefined`.
+  */
+  _computeDependencyClosure(id) {
+    const order = [];
+    const visited = /* @__PURE__ */ new Set();
+    const onStack = /* @__PURE__ */ new Set();
+    const stackPath = [];
+    const missing = [];
+    const toInstall = [];
+    let cycle;
+    const knownIds = /* @__PURE__ */ new Set([
+      ...this._get(this._pluginsAtom).map((plugin) => plugin.meta.id),
+      ...this._get(this.pluginRegistry.plugins).entries.map((entry) => entry.id)
+    ]);
+    const visit = (currentId) => {
+      if (cycle) {
+        return;
+      }
+      if (visited.has(currentId)) {
+        return;
+      }
+      if (onStack.has(currentId)) {
+        const cycleStart = stackPath.indexOf(currentId);
+        cycle = [
+          ...stackPath.slice(cycleStart),
+          currentId
+        ];
+        return;
+      }
+      onStack.add(currentId);
+      stackPath.push(currentId);
+      if (!knownIds.has(currentId)) {
+        missing.push(currentId);
+      } else if (!this._getPlugin(currentId)) {
+        toInstall.push(currentId);
+      }
+      for (const depId of this._directDependencies(currentId)) {
+        visit(depId);
+        if (cycle) {
+          break;
+        }
+      }
+      onStack.delete(currentId);
+      stackPath.pop();
+      if (!cycle) {
+        visited.add(currentId);
+        order.push(currentId);
+      }
+    };
+    visit(id);
+    return {
+      order,
+      missing,
+      toInstall,
+      cycle
+    };
+  }
+  /**
+  * Walks the reverse `dependsOn` edges across registered plugins. With
+  * `enabledOnly`, filters the result to currently-enabled ids. Returns
+  * dependents in dependents-before-deps order so callers (cascade-disable)
+  * can iterate and tear down leaves first.
+  */
+  _collectDependents(id, opts) {
+    const direct = this._get(this._pluginsAtom).filter((plugin) => plugin.meta.dependsOn?.includes(id)).map((plugin) => plugin.meta.id);
+    if (!opts.transitive) {
+      return opts.enabledOnly ? direct.filter((dependentId) => this._get(this._enabledAtom).includes(dependentId)) : direct;
+    }
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (currentId) => {
+      if (visited.has(currentId)) {
+        return;
+      }
+      visited.add(currentId);
+      const parents = this._get(this._pluginsAtom).filter((plugin) => plugin.meta.dependsOn?.includes(currentId)).map((plugin) => plugin.meta.id);
+      for (const parentId of parents) {
+        visit(parentId);
+        if (parentId !== id && !result.includes(parentId)) {
+          result.push(parentId);
+        }
+      }
+    };
+    visit(id);
+    return opts.enabledOnly ? result.filter((dependentId) => this._get(this._enabledAtom).includes(dependentId)) : result;
+  }
+  /**
+  * Records a failure for a plugin. Latest failure wins so the registry UI
+  * always sees the most recent reason. Walks the `cause` chain when checking
+  * for timeouts: lazy-load timeouts arrive wrapped in `LazyPluginError` (the
+  * timeout is the cause), but the operator-visible reason should still be
+  * `'timeout'`.
+  */
+  _recordFailure(id, phase, error) {
+    const reason = isTimeoutCause(error) ? "timeout" : "error";
+    const failure = {
+      id,
+      phase,
+      reason,
+      error,
+      timestamp: Date.now()
+    };
+    log3.warn("plugin failed", {
+      id,
+      phase,
+      reason,
+      error: error.message
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 854, S: this });
+    this._update(this._failedAtom, (current) => [
+      ...current.filter((entry) => entry.id !== id),
+      failure
+    ]);
+  }
+  /**
+  * Fire-and-forget disable of a failed plugin. Forked because a failure can
+  * happen mid-activation chain — yielding a `disable` inline would deadlock
+  * on the shared semaphores. Core plugins are skipped (the host opted into
+  * them being non-removable; the failure record is enough signal).
+  */
+  _scheduleAutoDisable(id) {
+    if (this._get(this._coreAtom).includes(id)) {
+      return;
+    }
+    if (!this._get(this._enabledAtom).includes(id)) {
+      return;
+    }
+    this._runForkedFiber(this.disable(id).pipe(Effect3.tapError((error) => Effect3.sync(() => log3.warn("auto-disable failed", {
+      id,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 877, S: this }))), Effect3.ignore));
+  }
+  _getActiveModules() {
+    const active = this._get(this._activeAtom);
+    return this._get(this._modulesAtom).filter((module) => active.includes(module.id));
+  }
+  _getInactiveModules() {
+    const active = this._get(this._activeAtom);
+    return this._get(this._modulesAtom).filter((module) => !active.includes(module.id));
+  }
+  _getActiveModulesByEvent(key) {
+    return this._getActiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
+  }
+  _getInactiveModulesByEvent(key) {
+    return this._getInactiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
+  }
+  _setPendingResetByModule(module) {
+    const activationEvents = getEvents(module.activatesOn).map(eventKey).filter((key) => this._get(this._eventsFiredAtom).includes(key));
+    const pendingReset = Array.fromIterable(new Set(activationEvents)).filter((event) => {
+      const pending = this._get(this._pendingResetAtom);
+      return !pending.includes(event);
+    });
+    if (pendingReset.length > 0) {
+      log3("pending reset", {
+        events: pendingReset
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 903, S: this });
+      this._update(this._pendingResetAtom, (current) => [
+        ...current,
+        ...pendingReset
+      ]);
+    }
+  }
+  _clearPendingReset(key) {
+    const pendingIndex = this._get(this._pendingResetAtom).findIndex((event) => event === key);
+    if (pendingIndex !== -1) {
+      this._update(this._pendingResetAtom, (pending) => pending.filter((event) => event !== key));
+    }
+  }
+  //
+  // Fiber helpers
+  //
+  _interruptInFlightActivations() {
+    return Effect3.gen(this, function* () {
+      const inFlightFibers = yield* Ref.get(this._inFlightFibers);
+      yield* Effect3.forEach(inFlightFibers, (fiber) => Fiber.interrupt(fiber), {
+        concurrency: "unbounded"
+      });
+    });
+  }
+  _trackFiber(ref, fiber) {
+    return Ref.update(ref, (fibers) => [
+      ...fibers,
+      fiber
+    ]);
+  }
+  _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 = Effect3.runFork(effect);
+    Effect3.runSync(this._trackFiber(this._inFlightFibers, fiber));
+    Effect3.runFork(Fiber.await(fiber).pipe(Effect3.andThen(() => this._untrackFiber(this._inFlightFibers, fiber))));
+  }
+  //
+  // Registration helpers
+  //
+  _addPlugin(plugin) {
+    log3("add plugin", {
+      id: plugin.meta.id
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 952, S: this });
+    this._update(this._pluginsAtom, (plugins) => plugins.includes(plugin) ? plugins : [
+      ...plugins,
+      plugin
+    ]);
+  }
+  _removePlugin(id) {
+    log3("remove plugin", {
+      id
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 962, S: this });
+    this._update(this._pluginsAtom, (plugins) => plugins.filter((plugin) => plugin.meta.id !== id));
+  }
+  _addModule(module) {
+    log3("add module", {
+      id: module.id
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 968, S: this });
+    this._update(this._modulesAtom, (modules) => modules.includes(module) ? modules : [
+      ...modules,
+      module
+    ]);
+  }
+  _removeModule(id) {
+    log3("remove module", {
+      id
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 978, S: this });
+    this._update(this._modulesAtom, (modules) => modules.filter((module) => module.id !== id));
+  }
+  //
+  // Activation helpers
+  //
+  _activateEvent(key, params, fiber) {
+    return Effect3.gen(this, function* () {
+      yield* this._trackFiber(this._inFlightFibers, fiber);
+      log3("activating", {
+        key,
+        ...params
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 989, S: this });
+      yield* Ref.update(this._activatingEvents, (activating) => Array.append(activating, key));
+      this._clearPendingReset(key);
+      const activatingEvents = yield* this._activatingEvents;
+      const activatingModules = yield* this._activatingModules;
+      const modules = this._getModulesForActivation(key, activatingEvents, activatingModules);
+      if (modules.length === 0) {
+        log3("no modules to activate", {
+          key
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 999, S: this });
+        if (!this._get(this._eventsFiredAtom).includes(key)) {
+          this._update(this._eventsFiredAtom, (events) => [
+            ...events,
+            key
+          ]);
+        }
+        return false;
+      }
+      return yield* this._activateModulesForEvent(key, modules, activatingEvents);
+    }).pipe(Effect3.ensuring(Effect3.all([
+      this._untrackFiber(this._inFlightFibers, fiber),
+      Ref.update(this._activatingEvents, (activating) => Array.filter(activating, (event) => event !== key))
+    ])));
+  }
+  _activateModulesForEvent(key, modules, activatingEvents) {
+    const activatingModuleIds = modules.map((module) => module.id);
+    return Effect3.gen(this, function* () {
+      yield* Ref.update(this._activatingModules, (activating) => Array.appendAll(activating, activatingModuleIds));
+      log3("activating modules", {
+        key,
+        modules: activatingModuleIds
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1020, S: this });
+      performance.mark(`event:${key}:start`);
+      yield* PubSub.publish(this.activation, {
+        event: key,
+        state: "activating"
+      });
+      yield* this._activateRelatedEvents(key, this._getBeforeEvents(modules, activatingEvents), "before");
+      const capabilities = yield* this._loadCapabilitiesForModules(key, modules);
+      yield* this._contributeCapabilitiesForModules(modules, capabilities);
+      yield* this._activateRelatedEvents(key, this._getAfterEvents(modules, activatingEvents), "after");
+      if (!this._get(this._eventsFiredAtom).includes(key)) {
+        this._update(this._eventsFiredAtom, (events) => [
+          ...events,
+          key
+        ]);
+      }
+      performance.mark(`event:${key}:end`);
+      performance.measure(`event:${key}`, `event:${key}:start`, `event:${key}:end`);
+      yield* PubSub.publish(this.activation, {
+        event: key,
+        state: "activated"
+      });
+      log3("activated", {
+        key
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1045, S: this });
+      return true;
+    }).pipe(Effect3.ensuring(Ref.update(this._activatingModules, (activating) => Array.filter(activating, (module) => !activatingModuleIds.includes(module)))));
+  }
+  _getModulesForActivation(key, activatingEvents, activatingModules) {
+    return this._getInactiveModulesByEvent(key).filter((module) => {
+      const allOf = isAllOf(module.activatesOn);
+      if (!allOf) {
+        return true;
+      }
+      const events = getEvents(module.activatesOn).filter((event) => eventKey(event) !== key);
+      return events.every((event) => this._get(this._eventsFiredAtom).includes(eventKey(event)) || activatingEvents.includes(eventKey(event))) && !activatingModules.includes(module.id);
+    });
+  }
+  _getBeforeEvents(modules, activatingEvents) {
+    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.firesAfterActivation ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event) => !activatingEvents.includes(eventKey(event))));
+  }
+  _activateRelatedEvents(key, events, phase) {
+    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
+    } : {
+      after: key
+    })), Effect3.allWith({
+      concurrency: "unbounded"
+    }), together(Effect3.sleep(Duration.seconds(10)).pipe(Effect3.andThen(Effect3.sync(() => log3.warn(`${logLabel} is taking a long time`, {
+      event: key,
+      [eventKey2]: events.map(eventKey)
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1078, S: this }))))), Effect3.asVoid);
+  }
+  //
+  // Module lifecycle helpers
+  //
+  _loadCapabilitiesForModules(key, modules) {
+    return Function.pipe(modules, Array.map((mod) => this._loadModule(mod, key)), Effect3.allWith({
+      concurrency: "unbounded"
+    }), Effect3.catchAll((error) => {
+      return Effect3.gen(this, function* () {
+        yield* PubSub.publish(this.activation, {
+          event: key,
+          state: "error",
+          error
+        });
+        return yield* Effect3.fail(error);
+      });
+    }));
+  }
+  _contributeCapabilitiesForModules(modules, capabilities) {
+    return Function.pipe(
+      modules,
+      Array.zip(capabilities),
+      Array.map(([module, capabilitySet]) => this._contributeCapabilities(module, capabilitySet)),
+      Effect3.all,
+      Effect3.asVoid
+    );
+  }
+  _getModuleSemaphore(moduleId) {
+    let semaphore = this._moduleSemaphores.get(moduleId);
+    if (!semaphore) {
+      semaphore = Effect3.runSync(Effect3.makeSemaphore(1));
+      this._moduleSemaphores.set(moduleId, semaphore);
+    }
+    return semaphore;
+  }
+  // `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) => Effect3.gen(this, function* () {
+    const semaphore = this._getModuleSemaphore(module.id);
+    const deferredToAwait = yield* Effect3.gen(this, function* () {
+      const existing = this._moduleMemoMap.get(module.id);
+      if (existing) {
+        return existing;
+      }
+      const deferred = yield* Deferred2.make();
+      this._moduleMemoMap.set(module.id, deferred);
+      const loadEffect = Effect3.gen(this, function* () {
+        log3("loading module", {
+          module: module.id,
+          parentEvent
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1136, S: this });
+        performance.mark(`module:${module.id}:start`);
+        yield* PubSub.publish(this.activation, {
+          event: parentEvent,
+          state: "activating",
+          module: module.id
+        });
+        const pluginId = this._getPluginIdForModule(module.id);
+        const [duration, capabilities] = yield* module.activate().pipe(
+          Effect3.provideService(Service, this.capabilities),
+          Effect3.provideService(Service2, this),
+          // Cap activation so a single misbehaving module can't hold the
+          // event chain open. On timeout the failure is recorded against
+          // the plugin and surfaced as `PluginTimeoutError`.
+          Effect3.timeoutFail({
+            duration: this._activationTimeout,
+            onTimeout: () => new PluginTimeoutError({
+              context: {
+                id: pluginId ?? module.id,
+                module: module.id,
+                phase: "activation"
+              }
+            })
+          }),
+          Effect3.timed
+        );
+        const normalized = capabilities == null ? [] : Array.isArray(capabilities) ? capabilities : [
+          capabilities
+        ];
+        const elapsed = Duration.toMillis(duration);
+        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: parentEvent,
+          state: "activated",
+          module: module.id
+        });
+        log3("loaded module", {
+          module: module.id,
+          parentEvent,
+          elapsed,
+          failed: false
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1171, S: this });
+        return normalized;
+      }).pipe(Effect3.withSpan("PluginManager._loadModule"), together(Effect3.sleep(Duration.seconds(10)).pipe(Effect3.andThen(Effect3.sync(() => log3.warn(`module is taking a long time to activate`, {
+        module: module.id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1178, S: this }))))), Performance.addTrackEntry({
+        name: module.id,
+        devtools: {
+          dataType: "track-entry",
+          track: "Module Activation",
+          trackGroup: "Composer",
+          color: "primary"
+        }
+      }));
+      const fiber = yield* Effect3.forkDaemon(loadEffect.pipe(Effect3.tap((result) => Deferred2.succeed(deferred, result)), Effect3.catchAllCause((cause) => {
+        const error = Cause.squash(cause);
+        log3.error("module failed to activate", {
+          module: module.id,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0,
+          isDefect: !Cause.isFailure(cause)
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1192, S: this });
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        const pluginId = this._getPluginIdForModule(module.id);
+        if (pluginId !== void 0) {
+          this._recordFailure(pluginId, "activation", normalizedError);
+          this._scheduleAutoDisable(pluginId);
+        }
+        return Deferred2.fail(deferred, normalizedError);
+      })));
+      yield* this._trackFiber(this._inFlightFibers, fiber);
+      yield* Effect3.forkDaemon(Fiber.await(fiber).pipe(Effect3.andThen(() => this._untrackFiber(this._inFlightFibers, fiber))));
+      return deferred;
+    }).pipe(semaphore.withPermits(1));
+    return yield* Deferred2.await(deferredToAwait);
+  });
+  _contributeCapabilities(module, capabilities) {
+    return Effect3.gen(this, function* () {
+      capabilities.forEach((capability) => {
+        this.capabilities.contribute({
+          module: module.id,
+          ...capability
+        });
+      });
+      this._update(this._activeAtom, (active) => [
+        ...active,
+        module.id
+      ]);
+      this._capabilities.set(module.id, capabilities);
+    });
+  }
+  _deactivateModule(module) {
+    return Effect3.gen(this, function* () {
+      const id = module.id;
+      log3("deactivating", {
+        id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1231, S: this });
+      this._moduleMemoMap.delete(id);
+      const capabilities = this._capabilities.get(id);
+      if (capabilities) {
+        for (const capability of capabilities) {
+          this.capabilities.remove(capability.interface, capability.implementation);
+          const program = capability.deactivate?.() ?? Effect3.succeed(void 0);
+          yield* program;
+        }
+        this._capabilities.delete(id);
+      }
+      const activeIndex = this._get(this._activeAtom).findIndex((event) => event === id);
+      if (activeIndex !== -1) {
+        this._update(this._activeAtom, (active) => active.filter((event) => event !== id));
+      }
+      log3("deactivated", {
+        id
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 1248, S: this });
+      return true;
+    });
+  }
+};
+var make5 = (options) => new ManagerImpl(options);
+var isTimeoutCause = (error, depth = 0) => {
+  if (depth > 5 || !(error instanceof Error)) {
+    return false;
+  }
+  if (PluginTimeoutError.is(error)) {
+    return true;
+  }
+  return isTimeoutCause(error.cause, depth + 1);
+};
+var together = (togetherEffect) => (effect) => Effect3.gen(function* () {
+  const togetherFiber = yield* Effect3.fork(togetherEffect);
+  const result = yield* effect;
+  yield* Fiber.interrupt(togetherFiber);
+  return result;
+});
+
+export {
+  capability_manager_exports,
+  registry_exports,
+  PluginInitializationError,
+  PluginTimeoutError,
+  ManagerTypeId,
+  isManager,
+  make5 as make,
+  plugin_manager_exports
+};
+//# sourceMappingURL=chunk-J43JDWAV.mjs.map