@dxos/app-framework 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

package/src/core/capabilities.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Registry, Rx } from '@effect-rx/rx-react';
-import { Effect } from 'effect';
+import { Atom, type Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
 
 import { Trigger } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
@@ -22,6 +22,10 @@ export type InterfaceDef<T> = {
   identifier: string;
 };
 
+export namespace InterfaceDef {
+  export type Implementation<I extends InterfaceDef<any>> = I extends InterfaceDef<infer T> ? T : never;
+}
+
 /**
  * Helper to define the interface of a capability.
  */
@@ -37,17 +41,17 @@ export type Capability<T> = {
   /**
    * The interface definition of the capability.
    */
-  interface: InterfaceDef<T>;
+  readonly interface: InterfaceDef<T>;
 
   /**
    * The implementation of the capability.
    */
-  implementation: T;
+  readonly implementation: T;
 
   /**
    * Called when the capability is deactivated.
    */
-  deactivate?: () => MaybePromise<void> | Effect.Effect<void, Error>;
+  readonly deactivate?: () => MaybePromise<void> | Effect.Effect<void, Error>;
 };
 
 export type AnyCapability = Capability<any>;
@@ -69,16 +73,21 @@ class CapabilityImpl<T> {
 /**
  * Helper to define the implementation of a capability.
  */
-export const contributes = <T>(
-  interfaceDef: Capability<T>['interface'],
-  implementation: Capability<T>['implementation'],
-  deactivate?: Capability<T>['deactivate'],
-): Capability<T> => {
-  return { interface: interfaceDef, implementation, deactivate } satisfies Capability<T>;
+export const contributes = <I extends InterfaceDef<any>>(
+  interfaceDef: I,
+  implementation: Capability<InterfaceDef.Implementation<I>>['implementation'],
+  deactivate?: Capability<InterfaceDef.Implementation<I>>['deactivate'],
+): Capability<I> => {
+  return {
+    interface: interfaceDef,
+    implementation,
+    deactivate,
+  } satisfies Capability<I>;
 };
 
 type LoadCapability<T, U> = () => Promise<{ default: (props: T) => MaybePromise<Capability<U>> }>;
 type LoadCapabilities<T> = () => Promise<{ default: (props: T) => MaybePromise<AnyCapability[]> }>;
+
 // TODO(wittjosiah): Not having the array be `any` causes type errors when using the lazy capability.
 type LazyCapability<T, U> = (props?: T) => Promise<() => Promise<Capability<U> | AnyCapability[]>>;
 
@@ -100,19 +109,19 @@ export const lazy =
 export class PluginContext {
   private readonly _registry: Registry.Registry;
 
-  private readonly _capabilityImpls = Rx.family<string, Rx.Writable<CapabilityImpl<unknown>[]>>(() => {
-    return Rx.make<CapabilityImpl<unknown>[]>([]).pipe(Rx.keepAlive);
+  private readonly _capabilityImpls = Atom.family<string, Atom.Writable<CapabilityImpl<unknown>[]>>(() => {
+    return Atom.make<CapabilityImpl<unknown>[]>([]).pipe(Atom.keepAlive);
   });
 
-  readonly _capabilities = Rx.family<string, Rx.Rx<unknown[]>>((id: string) => {
-    return Rx.make((get) => {
+  readonly _capabilities = Atom.family<string, Atom.Atom<unknown[]>>((id: string) => {
+    return Atom.make((get) => {
       const current = get(this._capabilityImpls(id));
       return current.map((c) => c.implementation);
     });
   });
 
-  readonly _capability = Rx.family<string, Rx.Rx<unknown>>((id: string) => {
-    return Rx.make((get) => {
+  readonly _capability = Atom.family<string, Atom.Atom<unknown>>((id: string) => {
+    return Atom.make((get) => {
       const current = get(this._capabilities(id));
       invariant(current.length > 0, `No capability found for ${id}`);
       return current[0];
@@ -184,26 +193,26 @@ export class PluginContext {
   }
 
   /**
-   * Get the Rx reference to the available capabilities for a given interface.
-   * Primarily useful for deriving other Rx values based on the capabilities or
+   * Get the Atom reference to the available capabilities for a given interface.
+   * Primarily useful for deriving other Atom values based on the capabilities or
    * for subscribing to changes in the capabilities.
-   * @returns An Rx reference to the available capabilities.
+   * @returns An atom reference to the available capabilities.
    */
-  capabilities<T>(interfaceDef: InterfaceDef<T>): Rx.Rx<T[]> {
+  capabilities<T>(interfaceDef: InterfaceDef<T>): Atom.Atom<T[]> {
     // NOTE: This the type-checking for capabilities is done at the time of contribution.
-    return this._capabilities(interfaceDef.identifier) as Rx.Rx<T[]>;
+    return this._capabilities(interfaceDef.identifier) as Atom.Atom<T[]>;
   }
 
   /**
-   * Get the Rx reference to the available capabilities for a given interface.
-   * Primarily useful for deriving other Rx values based on the capability or
+   * Get the Atom reference to the available capabilities for a given interface.
+   * Primarily useful for deriving other Atom values based on the capability or
    * for subscribing to changes in the capability.
-   * @returns An Rx reference to the available capability.
+   * @returns An atom reference to the available capability.
    * @throws If no capability is found.
    */
-  capability<T>(interfaceDef: InterfaceDef<T>): Rx.Rx<T> {
+  capability<T>(interfaceDef: InterfaceDef<T>): Atom.Atom<T> {
     // NOTE: This the type-checking for capabilities is done at the time of contribution.
-    return this._capability(interfaceDef.identifier) as Rx.Rx<T>;
+    return this._capability(interfaceDef.identifier) as Atom.Atom<T>;
   }
 
   /**

package/src/core/manager.test.ts

@@ -7,16 +7,17 @@ import { afterEach, describe, expect, it } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
-import { updateCounter } from '@dxos/echo-schema/testing';
+import { updateCounter } from '@dxos/echo/testing';
 import { registerSignalsRuntime } from '@dxos/echo-signals';
 import { invariant } from '@dxos/invariant';
 import { live } from '@dxos/live-object';
 
-import { contributes, defineCapability, type PluginContext } from './capabilities';
+import { Events } from '../common';
+
+import { type PluginContext, contributes, defineCapability } from './capabilities';
 import { allOf, defineEvent, oneOf } from './events';
 import { PluginManager } from './manager';
-import { definePlugin, defineModule, type Plugin } from './plugin';
-import { Events } from '../common';
+import { Plugin, defineModule } from './plugin';
 
 registerSignalsRuntime();
 
@@ -42,7 +43,7 @@ describe('PluginManager', () => {
   });
 
   it('should be able to add and remove plugins', async () => {
-    const Test = definePlugin(testMeta, []);
+    const Test = new Plugin(testMeta, []);
     plugins = [Test];
 
     const manager = new PluginManager({ pluginLoader });
@@ -58,7 +59,7 @@ describe('PluginManager', () => {
       activatesOn: Events.Startup,
       activate: () => contributes(String, { string: 'hello' }),
     });
-    const Test = definePlugin(testMeta, [Hello]);
+    const Test = new Plugin(testMeta, [Hello]);
 
     const manager = new PluginManager({ plugins: [Test], core: [], pluginLoader });
     await manager.enable(testMeta.id);
@@ -75,7 +76,7 @@ describe('PluginManager', () => {
       activatesOn: Events.Startup,
       activate: () => contributes(String, { string: 'hello' }),
     });
-    const Test = definePlugin(testMeta, [Hello]);
+    const Test = new Plugin(testMeta, [Hello]);
 
     const manager = new PluginManager({ plugins: [Test], enabled: [Test.meta.id], pluginLoader });
     expect(manager.plugins).toEqual([Test]);
@@ -94,7 +95,7 @@ describe('PluginManager', () => {
       activatesOn: FailEvent,
       activate: async () => raise(new Error('test')),
     });
-    plugins = [definePlugin(testMeta, [Fail])];
+    plugins = [new Plugin(testMeta, [Fail])];
 
     const manager = new PluginManager({ pluginLoader });
     await manager.add(testMeta.id);
@@ -113,7 +114,7 @@ describe('PluginManager', () => {
       // TODO(wittjosiah): Test and catch more failure modes.
       activate: async () => async () => raise(new Error('test')),
     });
-    plugins = [definePlugin(testMeta, [Hello, Fail])];
+    plugins = [new Plugin(testMeta, [Hello, Fail])];
 
     const manager = new PluginManager({ pluginLoader });
     const activating = new Trigger<boolean>();
@@ -148,7 +149,7 @@ describe('PluginManager', () => {
         return contributes(String, { string: 'hello' });
       },
     });
-    plugins = [definePlugin(testMeta, [Hello])];
+    plugins = [new Plugin(testMeta, [Hello])];
 
     const manager = new PluginManager({ pluginLoader });
 
@@ -179,21 +180,21 @@ describe('PluginManager', () => {
   });
 
   it('should be able to fire custom activation events', async () => {
-    const Plugin1 = definePlugin({ id: 'dxos.org/test/plugin-1', name: 'Plugin 1' }, [
+    const Plugin1 = new Plugin({ id: 'dxos.org/test/plugin-1', name: 'Plugin 1' }, [
       defineModule({
         id: 'dxos.org/test/plugin-1',
         activatesOn: CountEvent,
         activate: () => [contributes(Number, { number: 1 })],
       }),
     ]);
-    const Plugin2 = definePlugin({ id: 'dxos.org/test/plugin-2', name: 'Plugin 2' }, [
+    const Plugin2 = new Plugin({ id: 'dxos.org/test/plugin-2', name: 'Plugin 2' }, [
       defineModule({
         id: 'dxos.org/test/plugin-2',
         activatesOn: CountEvent,
         activate: () => [contributes(Number, { number: 2 })],
       }),
     ]);
-    const Plugin3 = definePlugin({ id: 'dxos.org/test/plugin-3', name: 'Plugin 3' }, [
+    const Plugin3 = new Plugin({ id: 'dxos.org/test/plugin-3', name: 'Plugin 3' }, [
       defineModule({
         id: 'dxos.org/test/plugin-3',
         activatesOn: CountEvent,
@@ -230,7 +231,7 @@ describe('PluginManager', () => {
         return contributes(String, { string: 'hello' });
       },
     });
-    plugins = [definePlugin(testMeta, [Hello])];
+    plugins = [new Plugin(testMeta, [Hello])];
 
     const manager = new PluginManager({ pluginLoader });
     expect(manager.active).toEqual([]);
@@ -256,7 +257,7 @@ describe('PluginManager', () => {
         return contributes(String, { string: 'hello' });
       },
     });
-    plugins = [definePlugin(testMeta, [Hello])];
+    plugins = [new Plugin(testMeta, [Hello])];
 
     const manager = new PluginManager({ pluginLoader });
     expect(manager.active).toEqual([]);
@@ -282,7 +283,7 @@ describe('PluginManager', () => {
       state.total = numbers.reduce((acc, n) => acc + n.number, 0);
     };
 
-    const Count = definePlugin({ id: 'dxos.org/test/count', name: 'Count' }, [
+    const Count = new Plugin({ id: 'dxos.org/test/count', name: 'Count' }, [
       defineModule({
         id: 'dxos.org/test/count',
         activatesOn: Events.Startup,
@@ -294,7 +295,7 @@ describe('PluginManager', () => {
       }),
     ]);
 
-    const Test = definePlugin(testMeta, [
+    const Test = new Plugin(testMeta, [
       defineModule({
         id: 'dxos.org/test/plugin-1',
         activatesOn: CountEvent,
@@ -352,7 +353,7 @@ describe('PluginManager', () => {
     const id = 'dxos.org/test/counter';
     const stateEvent = Events.createStateEvent(id);
 
-    const Test = definePlugin(testMeta, [
+    const Test = new Plugin(testMeta, [
       defineModule({
         id,
         activatesOn: Events.Startup,
@@ -389,21 +390,21 @@ describe('PluginManager', () => {
   });
 
   it('should be reactive', async () => {
-    const Plugin1 = definePlugin({ id: 'dxos.org/test/plugin-1', name: 'Plugin 1' }, [
+    const Plugin1 = new Plugin({ id: 'dxos.org/test/plugin-1', name: 'Plugin 1' }, [
       defineModule({
         id: 'dxos.org/test/plugin-1',
         activatesOn: CountEvent,
         activate: () => [contributes(Number, { number: 1 })],
       }),
     ]);
-    const Plugin2 = definePlugin({ id: 'dxos.org/test/plugin-2', name: 'Plugin 2' }, [
+    const Plugin2 = new Plugin({ id: 'dxos.org/test/plugin-2', name: 'Plugin 2' }, [
       defineModule({
         id: 'dxos.org/test/plugin-2',
         activatesOn: CountEvent,
         activate: () => [contributes(Number, { number: 2 })],
       }),
     ]);
-    const Plugin3 = definePlugin({ id: 'dxos.org/test/plugin-3', name: 'Plugin 3' }, [
+    const Plugin3 = new Plugin({ id: 'dxos.org/test/plugin-3', name: 'Plugin 3' }, [
       defineModule({
         id: 'dxos.org/test/plugin-3',
         activatesOn: CountEvent,

package/src/core/manager.ts

@@ -2,18 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Registry } from '@effect-rx/rx-react';
+import { Registry } from '@effect-atom/atom-react';
 import { untracked } from '@preact/signals-core';
-import { Array as A, Effect, Either, Match, pipe } from 'effect';
+import * as Array from 'effect/Array';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Function from 'effect/Function';
+import * as HashSet from 'effect/HashSet';
+import * as Match from 'effect/Match';
+import * as Ref from 'effect/Ref';
 
 import { Event } from '@dxos/async';
-import { live, type Live } from '@dxos/live-object';
+import { type Live, live } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { type MaybePromise } from '@dxos/util';
 
 import { type AnyCapability, PluginContext } from './capabilities';
 import { type ActivationEvent, eventKey, getEvents, isAllOf } from './events';
-import { type PluginModule, type Plugin } from './plugin';
+import { type Plugin, type PluginModule } from './plugin';
 
 // TODO(wittjosiah): Factor out?
 const isPromise = (value: unknown): value is Promise<unknown> => {
@@ -48,10 +55,13 @@ export class PluginManager {
   readonly context: PluginContext;
   readonly registry: Registry.Registry;
 
-  // TODO(wittjosiah): Replace with Rx.
+  // TODO(wittjosiah): Replace with Atom.
   private readonly _state: Live<PluginManagerState>;
   private readonly _pluginLoader: PluginManagerOptions['pluginLoader'];
   private readonly _capabilities = new Map<string, AnyCapability[]>();
+  private readonly _moduleMemoMap = new Map<PluginModule['id'], Promise<AnyCapability[]>>();
+  private readonly _activatingEvents = Effect.runSync(Ref.make<string[]>([]));
+  private readonly _activatingModules = Effect.runSync(Ref.make<string[]>([]));
 
   constructor({
     pluginLoader,
@@ -74,8 +84,8 @@ export class PluginManager {
       enabled,
       modules: [],
       active: [],
-      pendingReset: [],
       eventsFired: [],
+      pendingReset: [],
     });
     plugins.forEach((plugin) => this._addPlugin(plugin));
     core.forEach((id) => this.enable(id));
@@ -268,6 +278,7 @@ export class PluginManager {
   private _addPlugin(plugin: Plugin): void {
     untracked(() => {
       log('add plugin', { id: plugin.meta.id });
+      // TODO(wittjosiah): Find a way to add a warning for duplicate plugins that doesn't cause log spam.
       if (!this._state.plugins.includes(plugin)) {
         this._state.plugins.push(plugin);
       }
@@ -287,6 +298,7 @@ export class PluginManager {
   private _addModule(module: PluginModule): void {
     untracked(() => {
       log('add module', { id: module.id });
+      // TODO(wittjosiah): Find a way to add a warning for duplicate modules that doesn't cause log spam.
       if (!this._state.modules.includes(module)) {
         this._state.modules.push(module);
       }
@@ -329,7 +341,7 @@ export class PluginManager {
         .map(eventKey)
         .filter((key) => this._state.eventsFired.includes(key));
 
-      const pendingReset = Array.from(new Set(activationEvents)).filter(
+      const pendingReset = Array.fromIterable(new Set(activationEvents)).filter(
         (event) => !this._state.pendingReset.includes(event),
       );
       if (pendingReset.length > 0) {
@@ -343,24 +355,42 @@ export class PluginManager {
    * @internal
    */
   // TODO(wittjosiah): Improve error typing.
-  _activate(event: ActivationEvent | string): Effect.Effect<boolean, Error> {
+  _activate(
+    event: ActivationEvent | string,
+    params?: { before?: string; after?: string },
+  ): Effect.Effect<boolean, Error> {
     return Effect.gen(this, function* () {
       const key = typeof event === 'string' ? event : eventKey(event);
-      log('activating', { key });
+      log('activating', { key, ...params });
+      yield* Ref.update(this._activatingEvents, (activating) => Array.append(activating, key));
       const pendingIndex = this._state.pendingReset.findIndex((event) => event === key);
       if (pendingIndex !== -1) {
         this._state.pendingReset.splice(pendingIndex, 1);
       }
 
+      const activatingEvents = yield* this._activatingEvents;
+      const activatingModules = yield* this._activatingModules;
       const modules = this._getInactiveModulesByEvent(key).filter((module) => {
         const allOf = isAllOf(module.activatesOn);
         if (!allOf) {
           return true;
         }
 
+        // Check to see if all of the events in the `allOf` have been fired.
+        // An event can be considered "fired" if it is in the `eventsFired` list or if it is currently being activated.
         const events = module.activatesOn.events.filter((event) => eventKey(event) !== key);
-        return events.every((event) => this._state.eventsFired.includes(eventKey(event)));
+        return (
+          events.every(
+            (event) => this._state.eventsFired.includes(eventKey(event)) || activatingEvents.includes(eventKey(event)),
+          ) && !activatingModules.includes(module.id)
+        );
       });
+      yield* Ref.update(this._activatingModules, (activating) =>
+        Array.appendAll(
+          activating,
+          modules.map((module) => module.id),
+        ),
+      );
       if (modules.length === 0) {
         log('no modules to activate', { key });
         if (!this._state.eventsFired.includes(key)) {
@@ -372,31 +402,53 @@ export class PluginManager {
       log('activating modules', { key, modules: modules.map((module) => module.id) });
       this.activation.emit({ event: key, state: 'activating' });
 
+      // Fire activatesBefore events.
+      yield* Function.pipe(
+        modules,
+        Array.flatMap((module) => module.activatesBefore ?? []),
+        HashSet.fromIterable,
+        HashSet.toValues,
+        Array.filter((event) => !activatingEvents.includes(eventKey(event))),
+        Array.map((event) => this._activate(event, { before: key })),
+        Effect.allWith({ concurrency: 'unbounded' }),
+      );
+
       // Concurrently triggers loading of lazy capabilities.
-      const getCapabilities = yield* Effect.all(
-        modules.map(({ activate }) =>
-          Effect.tryPromise({
-            try: async () => activate(this.context),
-            catch: (error) => error as Error,
-          }),
-        ),
-        { concurrency: 'unbounded' },
+      const getCapabilities = yield* Function.pipe(
+        modules,
+        Array.map((mod) => this._loadModule(mod)),
+        Effect.allWith({ concurrency: 'unbounded' }),
+        Effect.catchAll((error) => {
+          this.activation.emit({ event: key, state: 'error', error });
+          return Effect.fail(error);
+        }),
       );
 
-      const result = yield* pipe(
+      // Contribute the capabilities from the activated modules.
+      yield* Function.pipe(
         modules,
-        A.zip(getCapabilities),
-        A.map(([module, getCapabilities]) => this._activateModule(module, getCapabilities)),
+        Array.zip(getCapabilities),
+        Array.map(([module, capabilities]) => this._contributeCapabilities(module, capabilities)),
         // TODO(wittjosiah): This currently can't be run in parallel.
         //   Running this with concurrency causes races with `allOf` activation events.
         Effect.all,
-        Effect.either,
       );
 
-      if (Either.isLeft(result)) {
-        this.activation.emit({ event: key, state: 'error', error: result.left });
-        yield* Effect.fail(result.left);
-      }
+      // Fire activatesAfter events.
+      yield* Function.pipe(
+        modules,
+        Array.flatMap((module) => module.activatesAfter ?? []),
+        HashSet.fromIterable,
+        HashSet.toValues,
+        Array.filter((event) => !activatingEvents.includes(eventKey(event))),
+        Array.map((event) => this._activate(event, { after: key })),
+        Effect.allWith({ concurrency: 'unbounded' }),
+      );
+
+      yield* Ref.update(this._activatingEvents, (activating) => Array.filter(activating, (event) => event !== key));
+      yield* Ref.update(this._activatingModules, (activating) =>
+        Array.filter(activating, (module) => !modules.map((module) => module.id).includes(module)),
+      );
 
       if (!this._state.eventsFired.includes(key)) {
         this._state.eventsFired.push(key);
@@ -409,43 +461,60 @@ export class PluginManager {
     });
   }
 
-  private _activateModule(
-    module: PluginModule,
-    getCapabilities: AnyCapability | AnyCapability[] | (() => Promise<AnyCapability | AnyCapability[]>),
-  ): Effect.Effect<void, Error> {
-    return Effect.gen(this, function* () {
-      yield* Effect.all(module.activatesBefore?.map((event) => this._activate(event)) ?? [], {
-        concurrency: 'unbounded',
-      });
+  // Memoized with _moduleMemoMap
+  private _loadModule = (mod: PluginModule): Effect.Effect<AnyCapability[], Error> =>
+    Effect.tryPromise({
+      try: async () => {
+        const entry = this._moduleMemoMap.get(mod.id);
+        if (entry) {
+          return entry;
+        }
 
-      log('activating module...', { module: module.id });
-      // TODO(wittjosiah): This is not handling errors thrown if this is synchronous.
-      const maybeCapabilities = typeof getCapabilities === 'function' ? getCapabilities() : getCapabilities;
-      const resolvedCapabilities = yield* Match.value(maybeCapabilities).pipe(
-        // TODO(wittjosiah): Activate with an effect?
-        // Match.when(Effect.isEffect, (effect) => effect),
-        Match.when(isPromise, (promise) =>
-          Effect.tryPromise({
-            try: () => promise,
-            catch: (error) => error as Error,
-          }),
+        const promise = (async () => {
+          const start = performance.now();
+          let failed = false;
+          try {
+            log('loading module', { module: mod.id });
+            // TODO(wittjosiah): Support activation with an effect.
+            let activationResult = await mod.activate(this.context);
+            if (typeof activationResult === 'function') {
+              activationResult = await activationResult();
+            }
+            return Array.isArray(activationResult) ? activationResult : [activationResult];
+          } catch (error) {
+            failed = true;
+            throw error;
+          } finally {
+            performance.measure('activate-module', {
+              start,
+              end: performance.now(),
+              detail: {
+                module: mod.id,
+              },
+            });
+            log('loaded module', { module: mod.id, elapsed: performance.now() - start, failed });
+          }
+        })();
+        this._moduleMemoMap.set(mod.id, promise);
+        return promise;
+      },
+      catch: (error) => error as Error,
+    }).pipe(
+      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: mod.id }))),
         ),
-        Match.orElse((program) => Effect.succeed(program)),
-      );
-      const capabilities = Match.value(resolvedCapabilities).pipe(
-        Match.when(Array.isArray, (array) => array),
-        Match.orElse((value) => [value]),
-      );
+      ),
+    );
+
+  private _contributeCapabilities(module: PluginModule, capabilities: AnyCapability[]): Effect.Effect<void, Error> {
+    return Effect.gen(this, function* () {
       capabilities.forEach((capability) => {
         this.context.contributeCapability({ module: module.id, ...capability });
       });
       this._state.active.push(module.id);
       this._capabilities.set(module.id, capabilities);
-      log('activated module', { module: module.id });
-
-      yield* Effect.all(module.activatesAfter?.map((event) => this._activate(event)) ?? [], {
-        concurrency: 'unbounded',
-      });
     });
   }
 
@@ -469,6 +538,7 @@ export class PluginManager {
     return Effect.gen(this, function* () {
       const id = module.id;
       log('deactivating', { id });
+      this._moduleMemoMap.delete(id);
 
       const capabilities = this._capabilities.get(id);
       if (capabilities) {
@@ -517,3 +587,18 @@ export class PluginManager {
     });
   }
 }
+
+/**
+ * Runs an effect concurrently with another effect.
+ * If the first effect completes, the second effect is interrupted.
+ */
+// TODO(dmaretskyi): Effect.race > Effect.asVoid
+const together =
+  <R1>(togetherEffect: Effect.Effect<void, never, R1>) =>
+  <A, E, R2>(effect: Effect.Effect<A, E, R2>): Effect.Effect<A, E, R1 | R2> =>
+    Effect.gen(function* () {
+      const togetherFiber = yield* Effect.fork(togetherEffect);
+      const result = yield* effect;
+      yield* Fiber.interrupt(togetherFiber);
+      return result;
+    });

package/src/core/plugin.ts

@@ -110,6 +110,11 @@ export type PluginMeta = {
    * A grep-able symbol string which can be resolved to an icon asset by @ch-ui/icons, via @ch-ui/vite-plugin-icons.
    */
   icon?: string;
+
+  /**
+   * Icon hue (ChromaticPalette).
+   */
+  iconHue?: string;
 };
 
 /**
@@ -124,9 +129,15 @@ export class Plugin {
   ) {}
 }
 
+export type PluginFactory<T = void> = ((args: T) => Plugin) & { meta: PluginMeta };
+
 /**
  * Helper to define a plugin.
  */
-export const definePlugin = (meta: PluginMeta, modules: PluginModule[]) => {
-  return new Plugin(meta, modules);
+export const definePlugin = <T = void>(meta: PluginMeta, provider: (args: T) => PluginModule[]): PluginFactory<T> => {
+  const factory = (args: T) => {
+    return new Plugin(meta, provider(args));
+  };
+
+  return Object.assign(factory, { meta });
 };

package/src/helpers.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import { topologicalSort } from './helpers';
 

package/src/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './App';
 export * from './common';
 export * from './core';
 export * from './plugin-intent';
 export * from './plugin-settings';
-export * from './react';