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

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,9 @@
 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 { log } from '@dxos/log';
+import { byPosition, type MaybePromise, type Position, type GuardedType } from '@dxos/util';
 
 import { IntentAction } from './actions';
 import { CycleDetectedError, NoResolversError } from './errors';
@@ -21,6 +23,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 +32,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 +52,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 +70,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 +104,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 +121,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 +138,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 +161,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 +171,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* () {
@@ -238,7 +237,10 @@ export const createDispatcher = (
   const dispatchPromise: PromiseIntentDispatcher = (intentChain) => {
     return Effect.runPromise(dispatch(intentChain))
       .then((data) => ({ data }))
-      .catch((error) => ({ error }));
+      .catch((error) => {
+        log.catch(error);
+        return { error };
+      });
   };
 
   const undo: IntentUndo = () => {
@@ -267,3 +269,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.SetupIntentResolver);
+      return yield* dispatch(intentChain, depth);
+    });
+  };
+  state.dispatchPromise = async (intentChain) => {
+    await manager.activate(Events.SetupIntentResolver);
+    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.SetupIntentResolver,
+      activate: lazy(() => import('./intent-resolver')),
+    }),
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/app-graph-builder`,
+      activatesOn: Events.SetupAppGraph,
+      activate: lazy(() => import('./app-graph-builder')),
     }),
   ]);

package/src/plugin-settings/actions.ts

@@ -2,10 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema as S } from '@effect/schema';
 
 export const SETTINGS_PLUGIN = 'dxos.org/plugin/settings';
 export const SETTINGS_ACTION = `${SETTINGS_PLUGIN}/action`;
+export const SETTINGS_ID = '!dxos:settings';
+export const SETTINGS_KEY = 'settings';
 
 export namespace SettingsAction {
   export class Open extends S.TaggedClass<Open>()(`${SETTINGS_ACTION}/open`, {
@@ -14,4 +16,12 @@ export namespace SettingsAction {
     }),
     output: S.Void,
   }) {}
+
+  export class OpenPluginRegistry extends S.TaggedClass<OpenPluginRegistry>()(
+    `${SETTINGS_ACTION}/open-plugin-registry`,
+    {
+      input: S.Void,
+      output: S.Void,
+    },
+  ) {}
 }

package/src/plugin-settings/app-graph-builder.ts

@@ -0,0 +1,122 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createExtension, type Node } from '@dxos/app-graph';
+import { type SettingsStore, type SettingsValue } from '@dxos/local-storage';
+import { isNonNullable } from '@dxos/util';
+
+import { SETTINGS_ID, SETTINGS_KEY, SETTINGS_PLUGIN, SettingsAction } from './actions';
+import { Capabilities } from '../common';
+import { contributes, type PluginMeta, type PluginsContext } from '../core';
+import { createIntent } from '../plugin-intent';
+
+export default (context: PluginsContext) =>
+  contributes(Capabilities.AppGraphBuilder, [
+    createExtension({
+      id: `${SETTINGS_PLUGIN}/action`,
+      filter: (node): node is Node<null> => node.id === 'root',
+      actions: () => [
+        {
+          id: SETTINGS_PLUGIN,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+            await dispatch(createIntent(SettingsAction.Open));
+          },
+          properties: {
+            label: ['open settings label', { ns: SETTINGS_PLUGIN }],
+            icon: 'ph--gear--regular',
+            keyBinding: {
+              macos: 'meta+,',
+              windows: 'alt+,',
+            },
+          },
+        },
+      ],
+    }),
+    createExtension({
+      id: `${SETTINGS_PLUGIN}/core`,
+      filter: (node): node is Node<null> => node.id === 'root',
+      connector: () => [
+        {
+          id: SETTINGS_ID,
+          type: SETTINGS_PLUGIN,
+          properties: {
+            label: ['app settings label', { ns: SETTINGS_PLUGIN }],
+            icon: 'ph--gear--regular',
+            disposition: 'pin-end',
+            position: 'hoist',
+            testId: 'treeView.appSettings',
+          },
+        },
+      ],
+    }),
+    createExtension({
+      id: `${SETTINGS_PLUGIN}/core-plugins`,
+      filter: (node): node is Node<null> => node.id === SETTINGS_ID,
+      connector: () => {
+        const manager = context.requestCapability(Capabilities.PluginManager);
+        const [settingsStore] = context.requestCapabilities(Capabilities.SettingsStore);
+        return [
+          ...manager.plugins
+            .filter((plugin) => manager.core.includes(plugin.meta.id))
+            .map((plugin): [PluginMeta, SettingsStore<SettingsValue>] | null => {
+              const settings = settingsStore?.getStore(plugin.meta.id);
+              if (!settings) {
+                return null;
+              }
+
+              return [plugin.meta, settings];
+            })
+            .filter(isNonNullable)
+            .map(([meta, settings]) => ({
+              id: `${SETTINGS_KEY}:${meta.id.replaceAll('/', ':')}`,
+              type: 'category',
+              data: settings,
+              properties: {
+                label: meta.name ?? meta.id,
+                icon: meta.icon ?? 'ph--circle--regular',
+              },
+            })),
+
+          {
+            id: `${SETTINGS_KEY}:custom-plugins`,
+            type: 'collection',
+            properties: {
+              label: ['custom plugins label', { ns: SETTINGS_PLUGIN }],
+              icon: 'ph--squares-four--regular',
+              role: 'branch',
+            },
+          },
+        ];
+      },
+    }),
+    createExtension({
+      id: `${SETTINGS_PLUGIN}/custom-plugins`,
+      filter: (node): node is Node<null> => node.id === `${SETTINGS_KEY}:custom-plugins`,
+      connector: () => {
+        const manager = context.requestCapability(Capabilities.PluginManager);
+        const [settingsStore] = context.requestCapabilities(Capabilities.SettingsStore);
+        return manager.plugins
+          .filter((plugin) => !manager.core.includes(plugin.meta.id))
+          .map((plugin): [PluginMeta, SettingsStore<SettingsValue>] | null => {
+            const settings = settingsStore?.getStore(plugin.meta.id);
+            if (!settings) {
+              return null;
+            }
+
+            return [plugin.meta, settings];
+          })
+          .filter(isNonNullable)
+          .map(([meta, settings]) => ({
+            id: `${SETTINGS_KEY}:${meta.id.replaceAll('/', ':')}`,
+            type: 'category',
+            data: settings,
+            properties: {
+              label: meta.name ?? meta.id,
+              icon: meta.icon ?? 'ph--circle--regular',
+            },
+          }));
+      },
+    }),
+  ]);

package/src/plugin-settings/intent-resolver.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { pipe } from 'effect';
+
+import { SETTINGS_ID, SETTINGS_KEY, SettingsAction } from './actions';
+import { Capabilities, LayoutAction } from '../common';
+import { contributes } from '../core';
+import { createResolver, createIntent, chain } from '../plugin-intent';
+
+export default () =>
+  contributes(
+    Capabilities.IntentResolver,
+    createResolver({
+      intent: SettingsAction.Open,
+      resolve: ({ plugin }) => {
+        const openSettings = createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: SETTINGS_ID });
+        return {
+          intents: [
+            plugin
+              ? pipe(
+                  openSettings,
+                  chain(LayoutAction.Open, {
+                    part: 'main',
+                    subject: [`${SETTINGS_KEY}:${plugin.replaceAll('/', ':')}`],
+                  }),
+                )
+              : openSettings,
+          ],
+        };
+      },
+    }),
+  );