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

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>
+      ))}
     </>
   );
 };

package/src/playground/generator/generator.ts

@@ -2,7 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema as S } from '@effect/schema';
+
+import { Capabilities, Events } from '../../common';
 import { contributes, defineEvent, defineCapability, defineModule, definePlugin } from '../../core';
+import { createResolver, type IntentSchema } from '../../plugin-intent';
 
 export const Number = defineCapability<number>('dxos.org/test/generator/number');
 
@@ -10,6 +14,15 @@ export const CountEvent = defineEvent('dxos.org/test/generator/count');
 
 export const createPluginId = (id: string) => `dxos.org/test/generator/${id}`;
 
+export const createGeneratorIntent = (id: string) => {
+  class Alert extends S.TaggedClass<Alert>()(`${createPluginId(id)}/action/alert`, {
+    input: S.Void,
+    output: S.Void,
+  }) {}
+
+  return Alert as unknown as IntentSchema<any, any>;
+};
+
 export const createNumberPlugin = (id: string) => {
   const number = Math.floor(Math.random() * 100);
 
@@ -19,5 +32,17 @@ export const createNumberPlugin = (id: string) => {
       activatesOn: CountEvent,
       activate: () => contributes(Number, number),
     }),
+    defineModule({
+      id: `${id}/intent-resolver`,
+      activatesOn: Events.SetupIntentResolver,
+      activate: () =>
+        contributes(
+          Capabilities.IntentResolver,
+          createResolver({
+            intent: createGeneratorIntent(id),
+            resolve: () => window.alert(JSON.stringify({ number })),
+          }),
+        ),
+    }),
   ]);
 };

package/src/playground/generator/plugin.ts

@@ -13,6 +13,11 @@ export const GeneratorPlugin = () =>
     defineModule({
       id: 'dxos.org/test/generator/main',
       activatesOn: Events.Startup,
-      activate: async () => [await Main(), await Toolbar()],
+      activate: Main,
+    }),
+    defineModule({
+      id: 'dxos.org/test/generator/toolbar',
+      activatesOn: Events.Startup,
+      activate: Toolbar,
     }),
   ]);

package/src/playground/layout/plugin.ts

@@ -12,6 +12,6 @@ export const LayoutPlugin = () =>
     defineModule({
       id: 'dxos.org/test/layout/root',
       activatesOn: Events.Startup,
-      activate: () => Layout(),
+      activate: Layout,
     }),
   ]);

package/src/playground/logger/Toolbar.tsx

@@ -9,7 +9,8 @@ import { Button } from '@dxos/react-ui';
 import { Log } from './schema';
 import { Capabilities, createSurface } from '../../common';
 import { contributes } from '../../core';
-import { createIntent, useIntentDispatcher } from '../../plugin-intent';
+import { createIntent } from '../../plugin-intent';
+import { useIntentDispatcher } from '../../react';
 
 export const Logger = () => {
   const { dispatchPromise } = useIntentDispatcher();

package/src/playground/logger/plugin.ts

@@ -15,12 +15,15 @@ export const LoggerPlugin = () =>
   definePlugin({ id: 'dxos.org/test/logger' }, [
     defineModule({
       id: 'dxos.org/test/logger/intents',
-      activatesOn: Events.SetupIntents,
+      activatesOn: Events.SetupIntentResolver,
       activate: () => [
         contributes(
           Capabilities.IntentResolver,
-          createResolver(Log, ({ message }) => {
-            log.info(message);
+          createResolver({
+            intent: Log,
+            resolve: ({ message }) => {
+              log.info(message);
+            },
           }),
         ),
       ],
@@ -28,6 +31,6 @@ export const LoggerPlugin = () =>
     defineModule({
       id: 'dxos.org/test/logger/surfaces',
       activatesOn: Events.Startup,
-      activate: () => Toolbar(),
+      activate: Toolbar,
     }),
   ]);

package/src/playground/logger/schema.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema as S } from '@effect/schema';
 
 export class Log extends S.TaggedClass<Log>()('dxos.org/test/logger/log', {
   input: S.Struct({

package/src/plugin-intent/IntentPlugin.tsx

@@ -2,19 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
-import React from 'react';
-
-import { create } from '@dxos/live-object';
-
-import { IntentProvider } from './IntentContext';
 import { INTENT_PLUGIN } from './actions';
-import { type AnyIntentResolver, createDispatcher, type IntentContext } from './intent-dispatcher';
-import { Capabilities, Events } from '../common';
-import { contributes, defineModule, definePlugin } from '../core';
-
-const defaultEffect = () => Effect.fail(new Error('Intent runtime not ready'));
-const defaultPromise = () => Effect.runPromise(defaultEffect());
+import { Events } from '../common';
+import { defineModule, definePlugin, lazy } from '../core';
 
 export const IntentPlugin = () =>
   definePlugin({ id: INTENT_PLUGIN }, [
@@ -24,37 +14,7 @@ export const IntentPlugin = () =>
       //   This is fine for now because it's how it worked prior to capabilities api anyways.
       //   In the future, the intent dispatcher should be able to be reset without resetting the entire app.
       activatesOn: Events.Startup,
-      activatesBefore: [Events.SetupIntents],
       activatesAfter: [Events.DispatcherReady],
-      activate: (context) => {
-        const state = create<IntentContext>({
-          dispatch: defaultEffect,
-          dispatchPromise: defaultPromise,
-          undo: defaultEffect,
-          undoPromise: defaultPromise,
-        });
-
-        // TODO(wittjosiah): Make getResolver callback async and allow resolvers to be requested on demand.
-        const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module) =>
-          context
-            .requestCapabilities(Capabilities.IntentResolver, (c, moduleId): c is AnyIntentResolver => {
-              return module ? moduleId === module : true;
-            })
-            .flat(),
-        );
-
-        state.dispatch = dispatch;
-        state.dispatchPromise = dispatchPromise;
-        state.undo = undo;
-        state.undoPromise = undoPromise;
-
-        return [
-          contributes(Capabilities.IntentDispatcher, state),
-          contributes(Capabilities.ReactContext, {
-            id: INTENT_PLUGIN,
-            context: ({ children }) => <IntentProvider value={state}>{children}</IntentProvider>,
-          }),
-        ];
-      },
+      activate: lazy(() => import('./intent-dispatcher')),
     }),
   ]);

package/src/plugin-intent/actions.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema as S } from '@effect/schema';
 
 import { Label } from './intent';
 

package/src/plugin-intent/errors.ts

@@ -15,7 +15,7 @@ export class BaseError extends Error {
     readonly context?: Record<string, any>,
   ) {
     // TODO(dmaretskyi): Error.cause.
-    super(message ?? code);
+    super(message ?? code, { cause: context });
     this.name = code;
     // NOTE: Restores prototype chain (https://stackoverflow.com/a/48342359).
     Object.setPrototypeOf(this, new.target.prototype);

package/src/plugin-intent/index.ts

@@ -5,5 +5,4 @@
 export * from './actions';
 export * from './intent';
 export * from './intent-dispatcher';
-export * from './IntentContext';
 export * from './IntentPlugin';