@dxos/app-framework 0.7.5-main.9d2a38b → 0.7.5-main.e9bb01b

package/src/core/capabilities.ts

@@ -79,17 +79,20 @@ export const contributes = <T>(
   return { interface: interfaceDef, implementation, deactivate } satisfies Capability<T>;
 };
 
-type LazyCapability<T, U> = () => Promise<{ default: (props: T) => MaybePromise<Capability<U>> }>;
+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[]>>;
 
 /**
  * Helper to define a lazily loaded implementation of a capability.
  */
 export const lazy =
-  <T, U>(c: LazyCapability<T, U>) =>
-  (props?: T): Promise<Capability<U>> =>
-    c().then(({ default: getCapability }) => {
-      return getCapability(props as T);
-    });
+  <T, U>(c: LoadCapability<T, U> | LoadCapabilities<T>): LazyCapability<T, U> =>
+  async (props?: T) => {
+    const { default: getCapability } = await c();
+    return async () => getCapability(props as T);
+  };
 
 /**
  * Context which is passed to plugins, allowing them to interact with each other.
@@ -136,7 +139,11 @@ export class PluginsContext {
     }
 
     current.push(new CapabilityImpl(moduleId, implementation));
-    log('capability contributed', { id: interfaceDef.identifier, count: untracked(() => current.length) });
+    log('capability contributed', {
+      id: interfaceDef.identifier,
+      moduleId,
+      count: untracked(() => current.length),
+    });
   }
 
   /**
@@ -152,6 +159,8 @@ export class PluginsContext {
     if (index !== -1) {
       current.splice(index, 1);
       log('capability removed', { id: interfaceDef.identifier, count: untracked(() => current.length) });
+    } else {
+      log.warn('capability not removed', { id: interfaceDef.identifier });
     }
   }
 

package/src/core/manager.test.ts

@@ -62,10 +62,10 @@ describe('PluginManager', () => {
     const Test = definePlugin(testMeta, [Hello]);
 
     const manager = new PluginManager({ plugins: [Test], core: [], pluginLoader });
-    manager.enable(testMeta.id);
+    await manager.enable(testMeta.id);
     expect(manager.enabled).toEqual([Test.meta.id]);
     expect(manager.modules).toEqual([Hello]);
-    manager.disable(testMeta.id);
+    await manager.disable(testMeta.id);
     expect(manager.enabled).toEqual([]);
     expect(manager.modules).toEqual([]);
   });
@@ -111,7 +111,8 @@ describe('PluginManager', () => {
     const Fail = defineModule({
       id: 'dxos.org/test/fail',
       activatesOn: FailEvent,
-      activate: async () => raise(new Error('test')),
+      // TODO(wittjosiah): Test and catch more failure modes.
+      activate: async () => async () => raise(new Error('test')),
     });
     plugins = [definePlugin(testMeta, [Hello, Fail])];
 
@@ -287,7 +288,7 @@ describe('PluginManager', () => {
         id: 'dxos.org/test/count',
         activatesOn: Events.Startup,
         activatesBefore: [CountEvent],
-        activate: (context) => {
+        activate: async (context) => async () => {
           computeTotal(context);
           return contributes(Total, state);
         },
@@ -328,57 +329,18 @@ describe('PluginManager', () => {
 
     {
       await manager.disable(Test.meta.id);
-      expect(manager.active).toEqual([...Test.modules.map((m) => m.id), Count.meta.id]);
-      expect(manager.pendingReset).toEqual([CountEvent.id, Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(6);
-    }
-
-    {
-      await manager.reset(CountEvent);
-      expect(manager.active).toEqual([Count.meta.id]);
-      expect(manager.pendingReset).toEqual([Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(6);
-    }
-
-    {
-      await manager.reset(Events.Startup);
       expect(manager.active).toEqual([Count.meta.id]);
       expect(manager.pendingReset).toEqual([]);
 
       const totals = manager.context.requestCapabilities(Total);
       expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
+      // Total doesn't change because it is not reactive.
+      expect(totals[0].total).toEqual(6);
     }
 
     {
       await manager.enable(Test.meta.id);
-      expect(manager.active).toEqual([Count.meta.id]);
-      expect(manager.pendingReset).toEqual([CountEvent.id, Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
-    }
-
-    {
-      await manager.reset(CountEvent);
       expect(manager.active).toEqual([Count.meta.id, ...Test.modules.map((m) => m.id)]);
-      expect(manager.pendingReset).toEqual([Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
-    }
-
-    {
-      await manager.reset(Events.Startup);
-      expect(manager.active).toEqual([...Test.modules.map((m) => m.id), Count.meta.id]);
       expect(manager.pendingReset).toEqual([]);
 
       const totals = manager.context.requestCapabilities(Total);
@@ -464,9 +426,6 @@ describe('PluginManager', () => {
     using activeUpdates = updateCounter(() => {
       const _ = manager.active.length;
     });
-    using pendingRemovalUpdates = updateCounter(() => {
-      const _ = manager.pendingRemoval.length;
-    });
     using eventsFiredUpdates = updateCounter(() => {
       const _ = manager.eventsFired.length;
     });
@@ -477,7 +436,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(0);
     expect(modulesUpdates.count).toEqual(0);
     expect(activeUpdates.count).toEqual(0);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(0);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -486,7 +444,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(1);
     expect(modulesUpdates.count).toEqual(1);
     expect(activeUpdates.count).toEqual(0);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(0);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -495,7 +452,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(1);
     expect(modulesUpdates.count).toEqual(1);
     expect(activeUpdates.count).toEqual(1);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -503,17 +459,15 @@ describe('PluginManager', () => {
     expect(pluginUpdates.count).toEqual(2);
     expect(enabledUpdates.count).toEqual(2);
     expect(modulesUpdates.count).toEqual(2);
-    expect(activeUpdates.count).toEqual(1);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    expect(activeUpdates.count).toEqual(2);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(1);
+    expect(pendingResetUpdates.count).toEqual(2);
 
     await manager.activate(CountEvent);
     expect(pluginUpdates.count).toEqual(2);
     expect(enabledUpdates.count).toEqual(2);
     expect(modulesUpdates.count).toEqual(2);
     expect(activeUpdates.count).toEqual(2);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(2);
 
@@ -521,47 +475,42 @@ describe('PluginManager', () => {
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(3);
     expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(2);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    expect(activeUpdates.count).toEqual(3);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(3);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.reset(CountEvent);
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(3);
     expect(modulesUpdates.count).toEqual(3);
-    // Starts at 2, plus deactivates 2, plus activates 3.
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    // Starts at 3, plus deactivates 3, plus activates 3.
+    expect(activeUpdates.count).toEqual(9);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.disable(One.meta.id);
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(4);
-    expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(1);
+    expect(modulesUpdates.count).toEqual(4);
+    expect(activeUpdates.count).toEqual(10);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(5);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.remove(One.meta.id);
     expect(pluginUpdates.count).toEqual(4);
     expect(enabledUpdates.count).toEqual(4);
-    expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(1);
+    expect(modulesUpdates.count).toEqual(4);
+    expect(activeUpdates.count).toEqual(10);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(5);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.reset(CountEvent);
     expect(pluginUpdates.count).toEqual(4);
     expect(enabledUpdates.count).toEqual(4);
     expect(modulesUpdates.count).toEqual(4);
-    // Starts at 7, plus deactivates 3, plus activates 2.
-    expect(activeUpdates.count).toEqual(12);
-    expect(pendingRemovalUpdates.count).toEqual(2);
+    // Starts at 10, plus deactivates 2, plus activates 2.
+    expect(activeUpdates.count).toEqual(14);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(6);
+    expect(pendingResetUpdates.count).toEqual(4);
   });
 });

package/src/core/manager.ts

@@ -3,7 +3,7 @@
 //
 
 import { untracked } from '@preact/signals-core';
-import { Effect, Either, Match } from 'effect';
+import { Array as A, Effect, Either, Match, pipe } from 'effect';
 
 import { Event } from '@dxos/async';
 import { create, type ReactiveObject } from '@dxos/live-object';
@@ -35,7 +35,6 @@ type PluginManagerState = {
   // Modules
   modules: PluginModule[];
   active: string[];
-  pendingRemoval: string[];
 
   // Events
   eventsFired: string[];
@@ -67,7 +66,6 @@ export class PluginManager {
       enabled,
       modules: [],
       active: [],
-      pendingRemoval: [],
       pendingReset: [],
       eventsFired: [],
     });
@@ -121,15 +119,6 @@ export class PluginManager {
     return this._state.active;
   }
 
-  /**
-   * Ids of modules which are pending removal.
-   *
-   * @reactive
-   */
-  get pendingRemoval(): ReactiveObject<readonly string[]> {
-    return this._state.pendingRemoval;
-  }
-
   /**
    * Ids of events which have been fired.
    *
@@ -165,8 +154,8 @@ export class PluginManager {
    * Enables a plugin.
    * @param id The id of the plugin.
    */
-  enable(id: string): boolean {
-    return untracked(() => {
+  enable(id: string): Promise<boolean> {
+    return untracked(async () => {
       log('enable plugin', { id });
       const plugin = this._getPlugin(id);
       if (!plugin) {
@@ -181,6 +170,15 @@ export class PluginManager {
         this._addModule(module);
         this._setPendingResetByModule(module);
       });
+
+      log('pending reset', { events: [...this.pendingReset] });
+      await Effect.runPromise(
+        Effect.all(
+          this.pendingReset.map((event) => this._activate(event)),
+          { concurrency: 'unbounded' },
+        ),
+      );
+
       return true;
     });
   }
@@ -206,8 +204,8 @@ export class PluginManager {
    * Disables a plugin.
    * @param id The id of the plugin.
    */
-  disable(id: string): boolean {
-    return untracked(() => {
+  disable(id: string): Promise<boolean> {
+    return untracked(async () => {
       log('disable plugin', { id });
       if (this._state.core.includes(id)) {
         return false;
@@ -221,16 +219,10 @@ export class PluginManager {
       const enabledIndex = this._state.enabled.findIndex((enabled) => enabled === id);
       if (enabledIndex !== -1) {
         this._state.enabled.splice(enabledIndex, 1);
+        await Effect.runPromise(this._deactivate(id));
 
         plugin.modules.forEach((module) => {
-          if (this._state.active.includes(module.id)) {
-            this._setPendingResetByModule(module);
-            if (!this._state.pendingRemoval.includes(module.id)) {
-              this._state.pendingRemoval.push(module.id);
-            }
-          } else {
-            this._removeModule(module.id);
-          }
+          this._removeModule(module.id);
         });
       }
 
@@ -328,14 +320,8 @@ export class PluginManager {
       const activationEvents = getEvents(module.activatesOn)
         .map(eventKey)
         .filter((key) => this._state.eventsFired.includes(key));
-      const parentEvents = activationEvents.flatMap((event) => {
-        const modules = this._getActiveModules().filter((module) =>
-          module.activatesBefore?.map(eventKey).includes(event),
-        );
-        return modules.flatMap((module) => getEvents(module.activatesOn)).map(eventKey);
-      });
 
-      const pendingReset = Array.from(new Set([...activationEvents, ...parentEvents])).filter(
+      const pendingReset = Array.from(new Set(activationEvents)).filter(
         (event) => !this._state.pendingReset.includes(event),
       );
       if (pendingReset.length > 0) {
@@ -345,64 +331,91 @@ export class PluginManager {
     });
   }
 
+  /**
+   * @internal
+   */
   // TODO(wittjosiah): Improve error typing.
-  private _activate(event: ActivationEvent | string): Effect.Effect<boolean, Error> {
-    const self = this;
-    return Effect.gen(function* () {
+  _activate(event: ActivationEvent | string): Effect.Effect<boolean, Error> {
+    return Effect.gen(this, function* () {
       const key = typeof event === 'string' ? event : eventKey(event);
       log('activating', { key });
-      const pendingIndex = self._state.pendingReset.findIndex((event) => event === key);
+      const pendingIndex = this._state.pendingReset.findIndex((event) => event === key);
       if (pendingIndex !== -1) {
-        self._state.pendingReset.splice(pendingIndex, 1);
+        this._state.pendingReset.splice(pendingIndex, 1);
       }
 
-      const modules = self._getInactiveModulesByEvent(key);
+      const modules = this._getInactiveModulesByEvent(key).filter((module) => {
+        const allOf = isAllOf(module.activatesOn);
+        if (!allOf) {
+          return true;
+        }
+
+        const events = module.activatesOn.events.filter((event) => eventKey(event) !== key);
+        return events.every((event) => this._state.eventsFired.includes(eventKey(event)));
+      });
       if (modules.length === 0) {
         log('no modules to activate', { key });
+        if (!this._state.eventsFired.includes(key)) {
+          this._state.eventsFired.push(key);
+        }
         return false;
       }
 
-      self.activation.emit({ event: key, state: 'activating' });
-
-      for (const module of modules) {
-        if (
-          isAllOf(module.activatesOn) &&
-          !module.activatesOn.events
-            .filter((event) => eventKey(event) !== key)
-            .every((event) => self._state.eventsFired.includes(eventKey(event)))
-        ) {
-          continue;
-        }
+      log('activating modules', { key, modules: modules.map((module) => module.id) });
+      this.activation.emit({ event: key, state: 'activating' });
 
-        yield* Effect.all(module.activatesBefore?.map((event) => self._activate(event)) ?? []);
+      // 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 result = yield* self._activateModule(module).pipe(Effect.either);
-        if (Either.isLeft(result)) {
-          self.activation.emit({ event: key, state: 'error', error: result.left });
-          yield* Effect.fail(result.left);
-        }
+      const result = yield* pipe(
+        modules,
+        A.zip(getCapabilities),
+        A.map(([module, getCapabilities]) => this._activateModule(module, getCapabilities)),
+        // TODO(wittjosiah): This currently can't be run in parallel.
+        //   Running this with concurrency causes races with `allOf` activation events.
+        Effect.all,
+        Effect.either,
+      );
 
-        yield* Effect.all(module.activatesAfter?.map((event) => self._activate(event)) ?? []);
+      if (Either.isLeft(result)) {
+        this.activation.emit({ event: key, state: 'error', error: result.left });
+        yield* Effect.fail(result.left);
       }
 
-      if (!self._state.eventsFired.includes(key)) {
-        self._state.eventsFired.push(key);
+      if (!this._state.eventsFired.includes(key)) {
+        this._state.eventsFired.push(key);
       }
 
-      self.activation.emit({ event: key, state: 'activated' });
+      this.activation.emit({ event: key, state: 'activated' });
       log('activated', { key });
 
       return true;
     });
   }
 
-  private _activateModule(module: PluginModule): Effect.Effect<void, Error> {
-    const self = this;
-    return Effect.gen(function* () {
+  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',
+      });
+
+      log('activating module...', { module: module.id });
       // TODO(wittjosiah): This is not handling errors thrown if this is synchronous.
-      const program = module.activate(self.context);
-      const maybeCapabilities = yield* Match.value(program).pipe(
-        Match.when(Effect.isEffect, (effect) => effect),
+      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,
@@ -411,42 +424,48 @@ export class PluginManager {
         ),
         Match.orElse((program) => Effect.succeed(program)),
       );
-      const capabilities = Match.value(maybeCapabilities).pipe(
+      const capabilities = Match.value(resolvedCapabilities).pipe(
         Match.when(Array.isArray, (array) => array),
         Match.orElse((value) => [value]),
       );
       capabilities.forEach((capability) => {
-        self.context.contributeCapability({ module: module.id, ...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',
       });
-      self._state.active.push(module.id);
-      self._capabilities.set(module.id, capabilities);
     });
   }
 
   private _deactivate(id: string): Effect.Effect<boolean, Error> {
-    const self = this;
-    return Effect.gen(function* () {
-      const plugin = self._getPlugin(id);
+    return Effect.gen(this, function* () {
+      const plugin = this._getPlugin(id);
       if (!plugin) {
         return false;
       }
 
       const modules = plugin.modules;
-      const results = yield* Effect.all(modules.map((module) => self._deactivateModule(module)));
+      const results = yield* Effect.all(
+        modules.map((module) => this._deactivateModule(module)),
+        { concurrency: 'unbounded' },
+      );
       return results.every((result) => result);
     });
   }
 
   private _deactivateModule(module: PluginModule): Effect.Effect<boolean, Error> {
-    const self = this;
-    return Effect.gen(function* () {
+    return Effect.gen(this, function* () {
       const id = module.id;
       log('deactivating', { id });
 
-      const capabilities = self._capabilities.get(id);
+      const capabilities = this._capabilities.get(id);
       if (capabilities) {
         for (const capability of capabilities) {
-          self.context.removeCapability(capability.interface, capability.implementation);
+          this.context.removeCapability(capability.interface, capability.implementation);
           const program = capability.deactivate?.();
           yield* Match.value(program).pipe(
             Match.when(Effect.isEffect, (effect) => effect),
@@ -459,12 +478,12 @@ export class PluginManager {
             Match.orElse((program) => Effect.succeed(program)),
           );
         }
-        self._capabilities.delete(id);
+        this._capabilities.delete(id);
       }
 
-      const activeIndex = self._state.active.findIndex((event) => event === id);
+      const activeIndex = this._state.active.findIndex((event) => event === id);
       if (activeIndex !== -1) {
-        self._state.active.splice(activeIndex, 1);
+        this._state.active.splice(activeIndex, 1);
       }
 
       log('deactivated', { id });
@@ -473,22 +492,17 @@ export class PluginManager {
   }
 
   private _reset(event: ActivationEvent | string): Effect.Effect<boolean, Error> {
-    const self = this;
-    return Effect.gen(function* () {
+    return Effect.gen(this, function* () {
       const key = typeof event === 'string' ? event : eventKey(event);
       log('reset', { key });
-      const modules = self._getActiveModulesByEvent(key);
-      const results = yield* Effect.all(modules.map((module) => self._deactivateModule(module)));
-
-      if (self._state.pendingRemoval.length > 0) {
-        self._state.pendingRemoval.forEach((id) => {
-          self._removeModule(id);
-        });
-        self._state.pendingRemoval.splice(0, self._state.pendingRemoval.length);
-      }
+      const modules = this._getActiveModulesByEvent(key);
+      const results = yield* Effect.all(
+        modules.map((module) => this._deactivateModule(module)),
+        { concurrency: 'unbounded' },
+      );
 
       if (results.every((result) => result)) {
-        return yield* self._activate(key);
+        return yield* this._activate(key);
       } else {
         return false;
       }

package/src/core/plugin.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Effect } from 'effect';
-
 import { type MaybePromise } from '@dxos/util';
 
 import { type AnyCapability, type PluginsContext } from './capabilities';
@@ -39,7 +37,7 @@ interface PluginModuleInterface {
    */
   activate: (
     context: PluginsContext,
-  ) => MaybePromise<AnyCapability | AnyCapability[]> | Effect.Effect<AnyCapability | AnyCapability[], Error>;
+  ) => MaybePromise<AnyCapability | AnyCapability[]> | Promise<() => Promise<AnyCapability | AnyCapability[]>>;
 }
 
 /**
@@ -98,6 +96,11 @@ export type PluginMeta = {
    */
   source?: string;
 
+  /**
+   * URL of screenshot.
+   */
+  screenshots?: string[];
+
   /**
    * Tags to help categorize the plugin.
    */

package/src/playground/debug/plugin.ts

@@ -12,6 +12,6 @@ export const DebugPlugin = () =>
     defineModule({
       id: 'dxos.org/test/debug/main',
       activatesOn: Events.Startup,
-      activate: () => Debug(),
+      activate: Debug,
     }),
   ]);

package/src/playground/generator/Toolbar.tsx

@@ -6,34 +6,34 @@ import React, { useCallback } from 'react';
 
 import { Button } from '@dxos/react-ui';
 
-import { CountEvent, createPluginId, Number } from './generator';
+import { createGeneratorIntent, createPluginId, Number } from './generator';
 import { Capabilities } from '../../common';
 import { contributes } from '../../core';
-import { usePluginManager } from '../../react';
+import { createIntent } from '../../plugin-intent';
+import { useCapabilities, useIntentDispatcher, usePluginManager } from '../../react';
 
 export const Toolbar = () => {
   const manager = usePluginManager();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   const handleAdd = useCallback(async () => {
     const id = createPluginId(Math.random().toString(16).substring(2, 8));
     await manager.add(id);
   }, [manager]);
 
-  const handleCount = useCallback(async () => {
-    if (manager.pendingReset.includes(CountEvent.id)) {
-      await manager.reset(CountEvent);
-    } else {
-      await manager.activate(CountEvent);
-    }
-  }, [manager]);
+  const count = useCapabilities(Number).reduce((acc, curr) => acc + curr, 0);
 
-  const count = manager.context.requestCapabilities(Number).reduce((acc, curr) => acc + curr, 0);
+  const generatorPlugins = manager.plugins.filter((plugin) => plugin.meta.id.startsWith('dxos.org/test/generator/'));
 
   return (
     <>
       <Button onClick={handleAdd}>Add</Button>
-      <Button onClick={handleCount}>Count</Button>
       <div className='flex items-center'>Count: {count}</div>
+      {generatorPlugins.map((plugin) => (
+        <Button key={plugin.meta.id} onClick={() => dispatch(createIntent(createGeneratorIntent(plugin.meta.id)))}>
+          {plugin.meta.id.replace('dxos.org/test/generator/', '')}
+        </Button>
+      ))}
     </>
   );
 };