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

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.SetupIntents,
+      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

@@ -19,8 +19,11 @@ export const LoggerPlugin = () =>
       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/index.ts

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

package/src/plugin-intent/intent-dispatcher.test.ts

@@ -2,11 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Schema as S } from '@effect/schema';
 import { Effect, Fiber, pipe } from 'effect';
 import { describe, expect, test } from 'vitest';
 
-import { S } from '@dxos/echo-schema';
-
 import { chain, createIntent } from './intent';
 import { type AnyIntentResolver, createDispatcher, createResolver } from './intent-dispatcher';
 
@@ -108,8 +107,8 @@ describe('Intent dispatcher', () => {
     const { dispatch } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
     const intent = pipe(createIntent(Compute, { value: 1 }), chain(ToString, {}), chain(Concat, { plus: '!' }));
 
-    expect(intent.first.action).toBe(Compute._tag);
-    expect(intent.last.action).toBe(Concat._tag);
+    expect(intent.first.id).toBe(Compute._tag);
+    expect(intent.last.id).toBe(Concat._tag);
     expect(intent.all.length).toBe(3);
 
     const program = Effect.gen(function* () {
@@ -137,7 +136,10 @@ describe('Intent dispatcher', () => {
   });
 
   test('filter resolvers by plugin', async () => {
-    const otherComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }));
+    const otherComputeResolver = createResolver({
+      intent: Compute,
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
+    });
     const { dispatch } = createDispatcher((module) => (module === 'test' ? [computeResolver] : [otherComputeResolver]));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
@@ -153,8 +155,10 @@ describe('Intent dispatcher', () => {
   });
 
   test('filter resolvers by predicate', async () => {
-    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+    const conditionalComputeResolver = createResolver({
+      intent: Compute,
       filter: (data): data is { value: number } => data?.value > 1,
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
     const { dispatch } = createDispatcher(() => [conditionalComputeResolver, computeResolver]);
     const program = Effect.gen(function* () {
@@ -171,8 +175,10 @@ describe('Intent dispatcher', () => {
   });
 
   test('hoist resolvers', async () => {
-    const hoistedComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
-      disposition: 'hoist',
+    const hoistedComputeResolver = createResolver({
+      intent: Compute,
+      position: 'hoist',
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
     const { dispatchPromise } = createDispatcher(() => [computeResolver, hoistedComputeResolver]);
     const { data } = await dispatchPromise(createIntent(Compute, { value: 1 }));
@@ -180,13 +186,17 @@ describe('Intent dispatcher', () => {
   });
 
   test('fallback resolvers', async () => {
-    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 2 } }), {
+    const conditionalComputeResolver = createResolver({
+      intent: Compute,
       filter: (data): data is { value: number } => data?.value === 1,
+      resolve: async (data) => ({ data: { value: data?.value * 2 } }),
     });
-    const fallbackComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
-      disposition: 'fallback',
+    const fallbackComputeResolver = createResolver({
+      intent: Compute,
+      position: 'fallback',
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
-    const { dispatch } = createDispatcher(() => [fallbackComputeResolver, conditionalComputeResolver]);
+    const { dispatch } = createDispatcher(() => [conditionalComputeResolver, fallbackComputeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
@@ -224,8 +234,9 @@ class ToString extends S.TaggedClass<ToString>()('ToString', {
   }),
 }) {}
 
-const toStringResolver = createResolver(ToString, async (data) => {
-  return { data: { string: data.value.toString() } };
+const toStringResolver = createResolver({
+  intent: ToString,
+  resolve: async (data) => ({ data: { string: data.value.toString() } }),
 });
 
 class Compute extends S.TaggedClass<Compute>()('Compute', {
@@ -237,16 +248,19 @@ class Compute extends S.TaggedClass<Compute>()('Compute', {
   }),
 }) {}
 
-const computeResolver = createResolver(Compute, (data, undo) => {
-  return Effect.gen(function* () {
-    if (undo) {
-      return { data: { value: data.value / 2 } };
-    }
-
-    yield* Effect.sleep(data.value * 10);
-    const value = data.value * 2;
-    return { data: { value }, undoable: { message: 'test', data: { value } } };
-  });
+const computeResolver = createResolver({
+  intent: Compute,
+  resolve: (data, undo) => {
+    return Effect.gen(function* () {
+      if (undo) {
+        return { data: { value: data.value / 2 } };
+      }
+
+      yield* Effect.sleep(data.value * 10);
+      const value = data.value * 2;
+      return { data: { value }, undoable: { message: 'test', data: { value } } };
+    });
+  },
 });
 
 class Concat extends S.TaggedClass<Concat>()('Concat', {
@@ -259,8 +273,9 @@ class Concat extends S.TaggedClass<Concat>()('Concat', {
   }),
 }) {}
 
-const concatResolver = createResolver(Concat, async (data) => {
-  return { data: { string: data.string + data.plus } };
+const concatResolver = createResolver({
+  intent: Concat,
+  resolve: async (data) => ({ data: { string: data.string + data.plus } }),
 });
 
 class Add extends S.TaggedClass<Add>()('Add', {
@@ -268,8 +283,9 @@ class Add extends S.TaggedClass<Add>()('Add', {
   output: S.Number,
 }) {}
 
-const addResolver = createResolver(Add, async (data) => {
-  return { data: data[0] + data[1] };
+const addResolver = createResolver({
+  intent: Add,
+  resolve: async (data) => ({ data: data[0] + data[1] }),
 });
 
 class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
@@ -277,4 +293,7 @@ class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
   output: S.Void,
 }) {}
 
-const sideEffectResolver = createResolver(SideEffect, async () => {});
+const sideEffectResolver = createResolver({
+  intent: SideEffect,
+  resolve: async () => {},
+});

package/src/plugin-intent/intent-dispatcher.ts

@@ -5,7 +5,8 @@
 import { Effect, Option, pipe, Ref } from 'effect';
 import { type Simplify } from 'effect/Types';
 
-import { type MaybePromise, byDisposition, type Disposition } from '@dxos/util';
+import { create } from '@dxos/live-object';
+import { byPosition, type MaybePromise, type Position, type GuardedType } from '@dxos/util';
 
 import { IntentAction } from './actions';
 import { CycleDetectedError, NoResolversError } from './errors';
@@ -21,6 +22,8 @@ import {
   type IntentSchema,
   type Label,
 } from './intent';
+import { Events, Capabilities } from '../common';
+import { contributes, type PluginsContext } from '../core';
 
 const EXECUTION_LIMIT = 100;
 const HISTORY_LIMIT = 100;
@@ -28,13 +31,13 @@ const HISTORY_LIMIT = 100;
 /**
  * The return value of an intent effect.
  */
-export type IntentEffectResult<Fields extends IntentParams> = {
+export type IntentEffectResult<Input, Output> = {
   /**
    * The output of the action that was performed.
    *
    * If the intent is apart of a chain of intents, the data will be passed to the next intent.
    */
-  data?: IntentResultData<Fields>;
+  data?: Output;
 
   /**
    * If provided, the action will be undoable.
@@ -48,7 +51,7 @@ export type IntentEffectResult<Fields extends IntentParams> = {
     /**
      * Will be merged with the original intent data when firing the undo intent.
      */
-    data?: Partial<IntentData<Fields>>;
+    data?: Partial<Input>;
   };
 
   /**
@@ -66,33 +69,32 @@ export type IntentEffectResult<Fields extends IntentParams> = {
   intents?: AnyIntentChain[];
 };
 
-export type AnyIntentEffectResult = IntentEffectResult<any>;
+export type AnyIntentEffectResult = IntentEffectResult<any, any>;
 
 /**
  * The result of an intent dispatcher.
  */
-export type IntentDispatcherResult<Fields extends IntentParams> = Pick<IntentEffectResult<Fields>, 'data' | 'error'>;
+export type IntentDispatcherResult<Input, Output> = Pick<IntentEffectResult<Input, Output>, 'data' | 'error'>;
 
 /**
  * The implementation of an intent effect.
  */
-export type IntentEffectDefinition<Fields extends IntentParams> = (
-  data: IntentData<Fields>,
+export type IntentEffectDefinition<Input, Output> = (
+  data: Input,
   undo: boolean,
-) => MaybePromise<IntentEffectResult<Fields> | void> | Effect.Effect<IntentEffectResult<Fields> | void>;
+) => MaybePromise<IntentEffectResult<Input, Output> | void> | Effect.Effect<IntentEffectResult<Input, Output> | void>;
 
 /**
  * Intent resolver to match intents to their effects.
  */
-export type IntentResolver<Tag extends string, Fields extends IntentParams> = Readonly<{
-  action: Tag;
-  disposition?: Disposition;
-  // TODO(wittjosiah): Would be nice to make this a guard for intents with optional data.
-  filter?: (data: IntentData<Fields>) => boolean;
-  effect: IntentEffectDefinition<Fields>;
+export type IntentResolver<Tag extends string, Fields extends IntentParams, Data = IntentData<Fields>> = Readonly<{
+  intent: IntentSchema<Tag, Fields>;
+  position?: Position;
+  filter?: (data: IntentData<Fields>) => data is Data;
+  resolve: IntentEffectDefinition<GuardedType<IntentResolver<Tag, Fields, Data>['filter']>, IntentResultData<Fields>>;
 }>;
 
-export type AnyIntentResolver = IntentResolver<any, any>;
+export type AnyIntentResolver = IntentResolver<any, any, any>;
 
 /**
  * Creates an intent resolver to match intents to their effects.
@@ -101,22 +103,16 @@ export type AnyIntentResolver = IntentResolver<any, any>;
  * @param params.disposition Determines the priority of the resolver when multiple are resolved.
  * @param params.filter Optional filter to determine if the resolver should be used.
  */
-export const createResolver = <Tag extends string, Fields extends IntentParams>(
-  schema: IntentSchema<Tag, Fields>,
-  effect: IntentEffectDefinition<Fields>,
-  params: Pick<IntentResolver<Tag, Fields>, 'disposition' | 'filter'> = {},
-): IntentResolver<Tag, Fields> => ({
-  action: schema._tag,
-  effect,
-  ...params,
-});
+export const createResolver = <Tag extends string, Fields extends IntentParams, Data = IntentData<Fields>>(
+  resolver: IntentResolver<Tag, Fields, Data>,
+) => resolver;
 
 /**
  * Invokes intents and returns the result.
  */
 export type PromiseIntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
-) => Promise<Simplify<IntentDispatcherResult<Fields>>>;
+) => Promise<Simplify<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>>;
 
 /**
  * Creates an effect for intents.
@@ -124,9 +120,15 @@ export type PromiseIntentDispatcher = <Fields extends IntentParams>(
 export type IntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
   depth?: number,
-) => Effect.Effect<Simplify<Required<IntentDispatcherResult<Fields>>['data']>, Error>;
-
-type IntentResult<Tag extends string, Fields extends IntentParams> = IntentEffectResult<Fields> & {
+) => Effect.Effect<
+  Simplify<Required<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>['data']>,
+  Error
+>;
+
+type IntentResult<Tag extends string, Fields extends IntentParams> = IntentEffectResult<
+  IntentData<Fields>,
+  IntentResultData<Fields>
+> & {
   _intent: Intent<Tag, Fields>;
 };
 
@@ -135,7 +137,7 @@ export type AnyIntentResult = IntentResult<any, any>;
 /**
  * Invokes the most recent undoable intent with undo flags.
  */
-export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any>>;
+export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any, any>>;
 
 /**
  * Creates an effect which undoes the last intent.
@@ -158,7 +160,7 @@ export type IntentContext = {
 /**
  * Sets of an intent dispatcher.
  *
- * @param resolvers An array of available intent resolvers.
+ * @param getResolvers A function that returns an array of available intent resolvers.
  * @param params.historyLimit The maximum number of intent results to keep in history.
  * @param params.executionLimit The maximum recursion depth of intent chains.
  */
@@ -168,24 +170,20 @@ export const createDispatcher = (
 ): IntentContext => {
   const historyRef = Effect.runSync(Ref.make<AnyIntentResult[][]>([]));
 
-  const handleIntent = (intent: AnyIntent) => {
-    return Effect.gen(function* () {
+  const handleIntent = (intent: AnyIntent) =>
+    Effect.gen(function* () {
       const candidates = getResolvers(intent.module)
-        .filter((r) => r.action === intent.action)
+        .filter((r) => r.intent._tag === intent.id)
         .filter((r) => !r.filter || r.filter(intent.data))
-        .toSorted(byDisposition);
+        .toSorted(byPosition);
       if (candidates.length === 0) {
-        return {
-          _intent: intent,
-          error: new NoResolversError(intent.action),
-        } as AnyIntentResult;
+        yield* Effect.fail(new NoResolversError(intent.id));
       }
 
-      const effect = candidates[0].effect(intent.data, intent.undo ?? false);
+      const effect = candidates[0].resolve(intent.data, intent.undo ?? false);
       const result = Effect.isEffect(effect) ? yield* effect : yield* Effect.promise(async () => effect);
       return { _intent: intent, ...result } as AnyIntentResult;
     });
-  };
 
   const dispatch: IntentDispatcher = (intentChain, depth = 0) => {
     return Effect.gen(function* () {
@@ -267,3 +265,40 @@ export const createDispatcher = (
 
   return { dispatch, dispatchPromise, undo, undoPromise };
 };
+
+const defaultEffect = () => Effect.fail(new Error('Intent runtime not ready'));
+const defaultPromise = () => Effect.runPromise(defaultEffect());
+
+export default (context: PluginsContext) => {
+  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(),
+  );
+
+  const manager = context.requestCapability(Capabilities.PluginManager);
+  state.dispatch = (intentChain, depth) => {
+    return Effect.gen(function* () {
+      yield* manager._activate(Events.SetupIntents);
+      return yield* dispatch(intentChain, depth);
+    });
+  };
+  state.dispatchPromise = async (intentChain) => {
+    await manager.activate(Events.SetupIntents);
+    return await dispatchPromise(intentChain);
+  };
+  state.undo = undo;
+  state.undoPromise = undoPromise;
+
+  return contributes(Capabilities.IntentDispatcher, state);
+};

package/src/plugin-intent/intent.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema as S } from '@effect/schema';
 
 export type IntentParams = {
   readonly input: S.Schema.All;
@@ -25,9 +25,9 @@ export type Intent<Tag extends string, Fields extends IntentParams> = {
   _schema: IntentSchema<Tag, Fields>;
 
   /**
-   * The action to perform.
+   * The id of the intent.
    */
-  action: Tag;
+  id: Tag;
 
   /**
    * Any data needed to perform the desired action.
@@ -84,7 +84,7 @@ export const createIntent = <Tag extends string, Fields extends IntentParams>(
   const intent = {
     ...params,
     _schema: schema,
-    action: schema._tag,
+    id: schema._tag,
     data,
   } satisfies Intent<Tag, Fields>;
 
@@ -122,7 +122,7 @@ export const chain =
     const last = {
       ...params,
       _schema: schema,
-      action: schema._tag,
+      id: schema._tag,
       data,
     } satisfies Intent<NextTag, NextFields>;
 

package/src/plugin-settings/SettingsPlugin.ts

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { RootSettingsStore } from '@dxos/local-storage';
-
 import { SETTINGS_PLUGIN } from './actions';
+import translations from './translations';
 import { Capabilities, Events } from '../common';
-import { contributes, defineModule, definePlugin } from '../core';
+import { contributes, defineModule, definePlugin, lazy } from '../core';
 
+// TODO(wittjosiah): Add options to exclude some modules.
 export const SettingsPlugin = () =>
   definePlugin({ id: SETTINGS_PLUGIN }, [
     defineModule({
@@ -15,15 +15,21 @@ export const SettingsPlugin = () =>
       activatesOn: Events.Startup,
       activatesBefore: [Events.SetupSettings],
       activatesAfter: [Events.SettingsReady],
-      activate: (context) => {
-        const allSettings = context.requestCapabilities(Capabilities.Settings);
-        const settingsStore = new RootSettingsStore();
-
-        allSettings.forEach((setting) => {
-          settingsStore.createStore(setting as any);
-        });
-
-        return contributes(Capabilities.SettingsStore, settingsStore);
-      },
+      activate: lazy(() => import('./store')),
+    }),
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/translations`,
+      activatesOn: Events.SetupTranslations,
+      activate: () => contributes(Capabilities.Translations, translations),
+    }),
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/intent-resolver`,
+      activatesOn: Events.SetupIntents,
+      activate: lazy(() => import('./intent-resolver')),
+    }),
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/app-graph-builder`,
+      activatesOn: Events.SetupAppGraph,
+      activate: lazy(() => import('./app-graph-builder')),
     }),
   ]);