@dxos/app-framework 0.10.0 → 0.11.1

package/dist/lib/chunk-plugin-manager.mjs

@@ -0,0 +1,1390 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { eventKey, getEvents, isAllOf } from "./core/activation-event.mjs";
+import { Service } from "./core/capability.mjs";
+import { LazyPluginError, PluginDependencyError, Service as Service$1, isLazy, resolveLazy } from "./core/plugin.mjs";
+import * as Effect from "effect/Effect";
+import { Atom, Registry } from "@effect-atom/atom";
+import * as Deferred from "effect/Deferred";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { BaseError } from "@dxos/errors";
+import * as Array from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+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 * as Scope from "effect/Scope";
+import { EffectEx, Performance } from "@dxos/effect";
+//#region src/core/capability-manager.ts
+var capability_manager_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/capability-manager.ts";
+/**
+* Internal implementation of CapabilityManager.
+*/
+var CapabilityManagerImpl = class {
+	_registry;
+	_registeredIdentifiers = /* @__PURE__ */ new Set();
+	_capabilityEntries = Atom.family(() => {
+		return Atom.make([]).pipe(Atom.keepAlive);
+	});
+	_capabilities = Atom.family((id) => {
+		return Atom.make((get) => {
+			return get(this._capabilityEntries(id)).map((c) => c.implementation);
+		}).pipe(Atom.keepAlive);
+	});
+	_capabilitiesByModule = Atom.family((id) => {
+		return Atom.make((get) => {
+			const entries = get(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((get) => {
+			const current = get(this._capabilities(id));
+			invariant(current.length > 0, `No capability found for ${id}`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 108,
+				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));
+		if (current.some((c) => c.moduleId === moduleId && c.implementation === implementation)) {
+			log("capability already contributed, skipping", {
+				id: interfaceDef.identifier,
+				moduleId
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 129,
+				S: this
+			});
+			return;
+		}
+		const entry = {
+			moduleId,
+			implementation
+		};
+		this._registry.set(this._capabilityEntries(interfaceDef.identifier), [...current, entry]);
+		this._registeredIdentifiers.add(interfaceDef.identifier);
+		log("capability contributed", {
+			id: interfaceDef.identifier,
+			moduleId,
+			count: current.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 136,
+			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);
+			if (next.length === 0) this._registeredIdentifiers.delete(interfaceDef.identifier);
+			log("capability removed", {
+				id: interfaceDef.identifier,
+				count: current.length
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 155,
+				S: this
+			});
+		} else log.warn("capability not removed", { id: interfaceDef.identifier }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 157,
+			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);
+		if (capabilities.length === 0) {
+			log("capability not available", {
+				requested: interfaceDef.identifier,
+				registered: this.listRegisteredIdentifiers()
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 173,
+				S: this
+			});
+			invariant(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 177,
+				S: this,
+				A: ["capabilities.length > 0", "`No capability found for ${interfaceDef.identifier}`"]
+			});
+		}
+		return capabilities[0];
+	}
+	listRegisteredIdentifiers() {
+		return [...this._registeredIdentifiers].sort();
+	}
+	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);
+	}
+};
+/**
+* Creates a new Capability Manager instance.
+*/
+var make$1 = (options) => new CapabilityManagerImpl(options);
+//#endregion
+//#region src/core/registry.ts
+var registry_exports = /* @__PURE__ */ __exportAll({ Manager: () => Manager });
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/registry.ts";
+/**
+* Default no-op provider used when no `PluginProvider` is supplied at construction
+* time (e.g. tests, stories, environments without an Edge connection).
+*
+* `listPlugins` returns an empty list (so `Manager.plugins` settles to a stable
+* empty state). `listVersions` and `getPlugin` fail with an explicit error so
+* callers know they need to configure a real provider.
+*/
+var NULL_PROVIDER = {
+	listPlugins: () => Effect.succeed([]),
+	listVersions: () => Effect.fail(/* @__PURE__ */ new Error("No plugin registry provider configured")),
+	getPlugin: () => Effect.fail(/* @__PURE__ */ new Error("No plugin registry provider configured"))
+};
+/**
+* Owns the cached registry catalog state and forwards `listVersions` / `getPlugin`
+* calls to the underlying {@link PluginProvider}. Lives on the `PluginManager`
+* (as `manager.pluginRegistry`) so consumers can reach it through the manager
+* without a separate capability lookup.
+*
+* On construction the manager kicks off a background fetch via `provider.listPlugins()`
+* and writes the result into the {@link plugins} atom. Subscribers see `loading: true`
+* during the fetch and `loading: false` once it settles.
+*/
+var Manager = class {
+	plugins;
+	#provider;
+	constructor(provider, atomRegistry) {
+		this.#provider = provider ?? NULL_PROVIDER;
+		const initialLoading = provider !== void 0;
+		this.plugins = Atom.make({
+			entries: [],
+			loading: initialLoading,
+			error: null
+		}).pipe(Atom.keepAlive);
+		if (provider !== void 0) EffectEx.runAndForwardErrors(provider.listPlugins().pipe(Effect.match({
+			onSuccess: (entries) => atomRegistry.set(this.plugins, {
+				entries,
+				loading: false,
+				error: null
+			}),
+			onFailure: (error) => {
+				log.catch(error, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 100,
+					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(id) {
+		return this.#provider.listVersions(id);
+	}
+	/** Forwards to the underlying provider. */
+	getPlugin(id, version) {
+		return this.#provider.getPlugin(id, version);
+	}
+};
+//#endregion
+//#region src/core/plugin-manager.ts
+var plugin_manager_exports = /* @__PURE__ */ __exportAll({
+	ManagerTypeId: () => ManagerTypeId,
+	PluginInitializationError: () => PluginInitializationError,
+	PluginTimeoutError: () => PluginTimeoutError,
+	isManager: () => isManager,
+	make: () => make
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin-manager.ts";
+/**
+* Tagged error for failures during the constructor-launched core/enabled
+* `enable()` chain. Surfaces via {@link PluginManager.activate}'s wait on
+* `_initialization` so a caller blocked on initialization gets a typed
+* failure (with the original error preserved as `cause`) instead of an
+* untyped `Error`.
+*/
+var PluginInitializationError = class extends BaseError.extend("PluginInitializationError", "Plugin manager initialization failed") {};
+/**
+* Tagged error raised when a plugin exceeds its configured load or activation
+* timeout. The plugin manager records the failure on the `failed` atom and
+* auto-disables the plugin so that one stuck remote does not stall app boot.
+* `context.id` is the plugin id, `context.phase` is `'load'` or `'activation'`.
+*/
+var PluginTimeoutError = class extends BaseError.extend("PluginTimeoutError", "Plugin operation timed out") {};
+/** Default deadline for resolving a lazy plugin's dynamic import. */
+var DEFAULT_LOAD_TIMEOUT = Duration.seconds(30);
+/** Default deadline for a single module's `activate()` body. */
+var DEFAULT_ACTIVATION_TIMEOUT = Duration.seconds(30);
+/**
+* Identifier denoting a Manager.
+*/
+var ManagerTypeId = Symbol.for("@dxos/app-framework/Manager");
+/**
+* Type guard to check if a value is a PluginManager.
+*/
+var isManager = (value) => {
+	return typeof value === "object" && value !== null && ManagerTypeId in value;
+};
+/**
+* Internal implementation of PluginManager.
+*/
+var ManagerImpl = class {
+	[ManagerTypeId] = ManagerTypeId;
+	activation = Effect.runSync(PubSub.unbounded());
+	capabilities;
+	registry;
+	pluginRegistry;
+	_pluginsAtom;
+	_coreAtom;
+	_enabledAtom;
+	_modulesAtom;
+	_activeAtom;
+	_eventsFiredAtom;
+	_pendingResetAtom;
+	_failedAtom;
+	_pluginLoader;
+	_onRemove;
+	_loadTimeout;
+	_activationTimeout;
+	_capabilities = /* @__PURE__ */ new Map();
+	_moduleScopes = /* @__PURE__ */ new Map();
+	_moduleMemoMap = /* @__PURE__ */ new Map();
+	_moduleSemaphores = /* @__PURE__ */ new Map();
+	_resolvingPlugins = /* @__PURE__ */ new Map();
+	_devPlugins = /* @__PURE__ */ new Map();
+	_devPluginIdsAtom;
+	_activatingEvents = Effect.runSync(Ref.make([]));
+	_activatingModules = Effect.runSync(Ref.make([]));
+	_inFlightFibers = Effect.runSync(Ref.make([]));
+	_shutdownSemaphore = Effect.runSync(Effect.makeSemaphore(1));
+	_shuttingDown = Effect.runSync(Ref.make(false));
+	_initialization = Effect.runSync(Deferred.make());
+	constructor({ pluginLoader, plugins = [], enabled = [], registry, pluginRegistryProvider, onRemove, loadTimeout = DEFAULT_LOAD_TIMEOUT, activationTimeout = DEFAULT_ACTIVATION_TIMEOUT }) {
+		const core = plugins.filter(({ meta }) => meta.profile.tags?.includes("system")).map(({ meta }) => meta.profile.key);
+		this.registry = registry ?? Registry.make();
+		this.capabilities = make$1({ registry: this.registry });
+		this.pluginRegistry = new Manager(pluginRegistryProvider, this.registry);
+		this._pluginLoader = pluginLoader;
+		this._onRemove = onRemove;
+		this._loadTimeout = loadTimeout;
+		this._activationTimeout = activationTimeout;
+		this._pluginsAtom = Atom.make(plugins).pipe(Atom.keepAlive);
+		this._coreAtom = Atom.make(core).pipe(Atom.keepAlive);
+		this._enabledAtom = Atom.make(enabled).pipe(Atom.keepAlive);
+		this._modulesAtom = Atom.make([]).pipe(Atom.keepAlive);
+		this._activeAtom = Atom.make([]).pipe(Atom.keepAlive);
+		this._eventsFiredAtom = Atom.make([]).pipe(Atom.keepAlive);
+		this._pendingResetAtom = Atom.make([]).pipe(Atom.keepAlive);
+		this._failedAtom = Atom.make([]).pipe(Atom.keepAlive);
+		this._devPluginIdsAtom = Atom.make([]).pipe(Atom.keepAlive);
+		plugins.forEach((plugin) => this._addPlugin(plugin));
+		const initialIds = [.../* @__PURE__ */ new Set([...core, ...enabled])];
+		Effect.all(initialIds.map((id) => this.enable(id))).pipe(Effect.mapError((cause) => new PluginInitializationError({ cause })), Effect.tap(() => Deferred.succeed(this._initialization, void 0)), Effect.tapErrorCause((cause) => Deferred.failCause(this._initialization, cause))).pipe(EffectEx.runAndForwardErrors);
+	}
+	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) {
+		if (!(opts?.transitive !== false)) return this._directDependencies(id);
+		return this._computeDependencyClosure(id).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 Effect.gen(this, function* () {
+			log("add plugin", { id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 537,
+				S: this
+			});
+			const { plugin, dev = false } = yield* this._pluginLoader(id);
+			const pluginId = plugin.meta.profile.key;
+			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.profile.key === 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 Effect.gen(this, function* () {
+			log("enable plugin", {
+				id,
+				resolveDependencies
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 577,
+				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(Effect.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 Effect.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);
+			});
+			log("pending reset", { events: [...this.getPendingReset()] }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 702,
+				S: this
+			});
+			yield* Effect.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 Effect.gen(this, function* () {
+			if (!isLazy(plugin)) return plugin;
+			const id = plugin.meta.profile.key;
+			const existing = this._resolvingPlugins.get(id);
+			if (existing) return yield* Deferred.await(existing);
+			const deferred = yield* Deferred.make();
+			this._resolvingPlugins.set(id, deferred);
+			return yield* Effect.gen(this, function* () {
+				log("resolving lazy plugin", { id }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 741,
+					S: this
+				});
+				yield* PubSub.publish(this.activation, {
+					event: "",
+					state: "activating",
+					module: `lazy:${id}`
+				});
+				const resolvedPlugin = yield* resolveLazy(plugin).pipe(Effect.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.profile.key === id ? resolvedPlugin : p));
+				yield* PubSub.publish(this.activation, {
+					event: "",
+					state: "activated",
+					module: `lazy:${id}`
+				});
+				return resolvedPlugin;
+			}).pipe(Effect.tapError((error) => Effect.gen(this, function* () {
+				yield* PubSub.publish(this.activation, {
+					event: "",
+					state: "error",
+					module: `lazy:${id}`,
+					error
+				});
+				this._recordFailure(id, "load", error);
+				this._scheduleAutoDisable(id);
+			})), Effect.tap((value) => Deferred.succeed(deferred, value)), Effect.tapErrorCause((cause) => Deferred.failCause(deferred, cause)), Effect.ensuring(Effect.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 Effect.gen(this, function* () {
+			log("remove plugin", { id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 784,
+				S: this
+			});
+			const wasDev = this._devPlugins.has(id);
+			if (!(yield* this.disable(id, opts))) return false;
+			this._removePlugin(id);
+			if (this._onRemove) this._runForkedFiber(this._onRemove(id).pipe(Effect.tapError((error) => Effect.sync(() => log.warn("plugin remove hook failed", {
+				id,
+				error
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 795,
+				S: this
+			}))), Effect.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 Effect.gen(this, function* () {
+			log("disable plugin", {
+				id,
+				cascade
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 826,
+				S: this
+			});
+			if (this._get(this._coreAtom).includes(id)) return false;
+			if (!this._getPlugin(id)) 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* Effect.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 Effect.gen(this, function* () {
+			if (this._get(this._coreAtom).includes(id)) return false;
+			const plugin = this._getPlugin(id);
+			if (!plugin) return false;
+			if (this._get(this._enabledAtom).findIndex((enabled) => enabled === id) !== -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 Effect.gen(this, function* () {
+			if (yield* this._isShuttingDown()) {
+				log("skipping activation during shutdown", {
+					key,
+					...params
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 901,
+					S: this
+				});
+				return false;
+			}
+			yield* Deferred.await(this._initialization);
+			return yield* Effect.withFiberRuntime((fiber) => this._activateEvent(key, params, fiber).pipe(together(Effect.sleep(Duration.seconds(15)).pipe(Effect.andThen(Effect.sync(() => log.warn("event activation is taking a long time", { event: key }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 915,
+				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 Effect.gen(this, function* () {
+			const plugin = this._getPlugin(id);
+			if (!plugin) return false;
+			const modules = plugin.modules;
+			return (yield* Effect.all(modules.map((module) => this._deactivateModule(module)), { concurrency: "unbounded" })).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 Effect.gen(this, function* () {
+			const key = typeof event === "string" ? event : eventKey(event);
+			log("reset", { key }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 961,
+				S: this
+			});
+			const modules = this._getActiveModulesByEvent(key);
+			if ((yield* Effect.all(modules.map((module) => this._deactivateModule(module)), { concurrency: "unbounded" })).every((result) => result)) return yield* this.activate(key);
+			else return false;
+		});
+	}
+	shutdown() {
+		return this._shutdownSemaphore.withPermits(1)(Effect.gen(this, function* () {
+			yield* Ref.set(this._shuttingDown, true);
+			log("shutdown", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 980,
+				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();
+			for (const scope of this._moduleScopes.values()) yield* Scope.close(scope, Exit.void);
+			this._moduleScopes.clear();
+			yield* Ref.set(this._activatingEvents, []);
+			yield* Ref.set(this._activatingModules, []);
+			log("shutdown complete", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1004,
+				S: this
+			});
+			return true;
+		}).pipe(Effect.ensuring(Ref.set(this._shuttingDown, false))));
+	}
+	_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.profile.key === id);
+	}
+	_getPluginIdForModule(moduleId) {
+		return this._get(this._pluginsAtom).find((plugin) => plugin.modules.some((module) => module.id === moduleId))?.meta.profile.key;
+	}
+	/** 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.profile.key === 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.profile.dependsOn ?? []];
+		const catalog = this._getCatalogEntry(id);
+		return catalog?.profile.dependsOn ? [...catalog.profile.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.profile.key), ...this._get(this.pluginRegistry.plugins).entries.map((entry) => entry.profile.key)]);
+		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.profile.dependsOn?.some((dep) => dep === id)).map((plugin) => plugin.meta.profile.key);
+		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.profile.dependsOn?.some((dep) => dep === currentId)).map((plugin) => plugin.meta.profile.key);
+			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()
+		};
+		log.warn("plugin failed to activate", {
+			id,
+			phase,
+			reason,
+			error: error.message
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1179,
+			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(Effect.tap(() => Effect.sync(() => log.error("plugin auto-disabled", { id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1202,
+			S: this
+		}))), Effect.tapError((error) => Effect.sync(() => log.warn("auto-disable failed", {
+			id,
+			error
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1203,
+			S: this
+		}))), Effect.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) => {
+			return !this._get(this._pendingResetAtom).includes(event);
+		});
+		if (pendingReset.length > 0) {
+			log("pending reset", { events: pendingReset }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1241,
+				S: this
+			});
+			this._update(this._pendingResetAtom, (current) => [...current, ...pendingReset]);
+		}
+	}
+	_clearPendingReset(key) {
+		if (this._get(this._pendingResetAtom).findIndex((event) => event === key) !== -1) this._update(this._pendingResetAtom, (pending) => pending.filter((event) => event !== key));
+	}
+	_interruptInFlightActivations() {
+		return Effect.gen(this, function* () {
+			const inFlightFibers = yield* Ref.get(this._inFlightFibers);
+			yield* Effect.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 = Effect.runFork(effect);
+		Effect.runSync(this._trackFiber(this._inFlightFibers, fiber));
+		Effect.runFork(Fiber.await(fiber).pipe(Effect.andThen(() => this._untrackFiber(this._inFlightFibers, fiber))));
+	}
+	_addPlugin(plugin) {
+		log("add plugin", { id: plugin.meta.profile.key }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1297,
+			S: this
+		});
+		this._update(this._pluginsAtom, (plugins) => plugins.includes(plugin) ? plugins : [...plugins, plugin]);
+	}
+	_removePlugin(id) {
+		log("remove plugin", { id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1303,
+			S: this
+		});
+		this._update(this._pluginsAtom, (plugins) => plugins.filter((plugin) => plugin.meta.profile.key !== id));
+	}
+	_addModule(module) {
+		log("add module", { id: module.id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1308,
+			S: this
+		});
+		this._update(this._modulesAtom, (modules) => modules.includes(module) ? modules : [...modules, module]);
+	}
+	_removeModule(id) {
+		log("remove module", { id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1314,
+			S: this
+		});
+		this._update(this._modulesAtom, (modules) => modules.filter((module) => module.id !== id));
+	}
+	_activateEvent(key, params, fiber) {
+		return Effect.gen(this, function* () {
+			yield* this._trackFiber(this._inFlightFibers, fiber);
+			log("activating", {
+				key,
+				...params
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1329,
+				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) {
+				log("no modules to activate", { key }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 1337,
+					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(Effect.ensuring(Effect.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 Effect.gen(this, function* () {
+			yield* Ref.update(this._activatingModules, (activating) => Array.appendAll(activating, activatingModuleIds));
+			log("activation wave", {
+				event: key,
+				modules: activatingModuleIds
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1364,
+				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"
+			});
+			log("activated", { key }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1382,
+				S: this
+			});
+			return true;
+		}).pipe(Effect.ensuring(Ref.update(this._activatingModules, (activating) => Array.filter(activating, (module) => !activatingModuleIds.includes(module)))));
+	}
+	_getModulesForActivation(key, activatingEvents, activatingModules) {
+		return this._getInactiveModulesByEvent(key).filter((module) => {
+			if (!isAllOf(module.activatesOn)) return true;
+			return getEvents(module.activatesOn).filter((event) => eventKey(event) !== key).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 eventKey$1 = phase === "before" ? "beforeEvents" : "afterEvents";
+		return Function.pipe(events, Array.map((event) => this.activate(event, phase === "before" ? { before: key } : { after: key })), Effect.allWith({ concurrency: "unbounded" }), together(Effect.sleep(Duration.seconds(10)).pipe(Effect.andThen(Effect.sync(() => log.warn(`${logLabel} is taking a long time`, {
+			event: key,
+			[eventKey$1]: events.map(eventKey)
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 1461,
+			S: this
+		}))))), Effect.asVoid);
+	}
+	_loadCapabilitiesForModules(key, modules) {
+		return Function.pipe(modules, Array.map((mod) => this._loadModule(mod, key)), Effect.allWith({ concurrency: "unbounded" }), Effect.catchAll((error) => {
+			return Effect.gen(this, function* () {
+				yield* PubSub.publish(this.activation, {
+					event: key,
+					state: "error",
+					error
+				});
+				return yield* Effect.fail(error);
+			});
+		}));
+	}
+	_contributeCapabilitiesForModules(modules, capabilities) {
+		return Function.pipe(modules, Array.zip(capabilities), Array.map(([module, capabilitySet]) => this._contributeCapabilities(module, capabilitySet)), Effect.all, Effect.asVoid);
+	}
+	_getModuleSemaphore(moduleId) {
+		let semaphore = this._moduleSemaphores.get(moduleId);
+		if (!semaphore) {
+			semaphore = Effect.runSync(Effect.makeSemaphore(1));
+			this._moduleSemaphores.set(moduleId, semaphore);
+		}
+		return semaphore;
+	}
+	_loadModule = (module, parentEvent) => Effect.gen(this, function* () {
+		const semaphore = this._getModuleSemaphore(module.id);
+		const deferredToAwait = yield* Effect.gen(this, function* () {
+			const existing = this._moduleMemoMap.get(module.id);
+			if (existing) return existing;
+			const deferred = yield* Deferred.make();
+			this._moduleMemoMap.set(module.id, deferred);
+			const scope = yield* Scope.make();
+			const loadEffect = Effect.gen(this, function* () {
+				log("loading module", {
+					module: module.id,
+					parentEvent
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 1546,
+					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(Effect.provideService(Service, this.capabilities), Effect.provideService(Service$1, this), Scope.extend(scope), Effect.timeoutFail({
+					duration: this._activationTimeout,
+					onTimeout: () => new PluginTimeoutError({ context: {
+						id: pluginId ?? module.id,
+						module: module.id,
+						phase: "activation"
+					} })
+				}), Effect.timed);
+				const normalized = capabilities == null ? [] : Array.isArray(capabilities) ? capabilities : [capabilities];
+				this._moduleScopes.set(module.id, scope);
+				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
+				});
+				log("loaded module", {
+					module: module.id,
+					parentEvent,
+					elapsed,
+					failed: false
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 1572,
+					S: this
+				});
+				return normalized;
+			}).pipe(Effect.tapErrorCause(() => Scope.close(scope, Exit.void)), Effect.withSpan("PluginManager._loadModule"), together(Effect.sleep(Duration.seconds(10)).pipe(Effect.andThen(Effect.sync(() => log.warn(`module is taking a long time to activate`, { module: module.id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1585,
+				S: this
+			}))))), Performance.addTrackEntry({
+				name: module.id,
+				devtools: {
+					dataType: "track-entry",
+					track: "Module Activation",
+					trackGroup: "Composer",
+					color: "primary"
+				}
+			}));
+			const fiber = yield* Effect.forkDaemon(loadEffect.pipe(Effect.tap((result) => Deferred.succeed(deferred, result)), Effect.catchAllCause((cause) => {
+				const error = Cause.squash(cause);
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				const missingCapability = errorMessage.match(/No capability found for ([^\s\[]+)/)?.[1];
+				log.error("module failed to activate", {
+					module: module.id,
+					parentEvent,
+					missingCapability,
+					registeredCapabilities: this.capabilities.listRegisteredIdentifiers(),
+					error: errorMessage,
+					stack: error instanceof Error ? error.stack : void 0,
+					isDefect: !Cause.isFailure(cause)
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 1608,
+					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 Deferred.fail(deferred, normalizedError);
+			})));
+			yield* this._trackFiber(this._inFlightFibers, fiber);
+			yield* Effect.forkDaemon(Fiber.await(fiber).pipe(Effect.andThen(() => this._untrackFiber(this._inFlightFibers, fiber))));
+			return deferred;
+		}).pipe(semaphore.withPermits(1));
+		return yield* Deferred.await(deferredToAwait);
+	});
+	_contributeCapabilities(module, capabilities) {
+		return Effect.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 Effect.gen(this, function* () {
+			const id = module.id;
+			log("deactivating", { id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1655,
+				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);
+					yield* capability.deactivate?.() ?? Effect.succeed(void 0);
+				}
+				this._capabilities.delete(id);
+			}
+			const scope = this._moduleScopes.get(id);
+			if (scope) {
+				yield* Scope.close(scope, Exit.void);
+				this._moduleScopes.delete(id);
+			}
+			if (this._get(this._activeAtom).findIndex((event) => event === id) !== -1) this._update(this._activeAtom, (active) => active.filter((event) => event !== id));
+			log("deactivated", { id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 1679,
+				S: this
+			});
+			return true;
+		});
+	}
+};
+/**
+* Creates a new Plugin Manager instance.
+*/
+var make = (options) => new ManagerImpl(options);
+/**
+* True when `error` (or anything along its `cause` chain) is a
+* {@link PluginTimeoutError}. Lazy-load timeouts wrap the timeout inside
+* `LazyPluginError`, so a shallow check on the outer error misses them.
+* Bounded depth so a circular chain can't loop forever.
+*/
+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);
+};
+/**
+* Runs an effect concurrently with another effect.
+* If the first effect completes, the second effect is interrupted.
+*/
+var together = (togetherEffect) => (effect) => Effect.gen(function* () {
+	const togetherFiber = yield* Effect.fork(togetherEffect);
+	const result = yield* effect;
+	yield* Fiber.interrupt(togetherFiber);
+	return result;
+});
+//#endregion
+export { make as a, capability_manager_exports as c, isManager as i, PluginInitializationError as n, plugin_manager_exports as o, PluginTimeoutError as r, registry_exports as s, ManagerTypeId as t };
+
+//# sourceMappingURL=chunk-plugin-manager.mjs.map