@dxos/app-framework 0.7.5-main.499c70c → 0.7.5-main.5ae2ba8

package/src/{plugins/plugin-intent → plugin-intent}/intent-dispatcher.ts

@@ -2,13 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, Ref } from 'effect';
+import { Effect, Option, pipe, Ref } from 'effect';
+import { type Simplify } from 'effect/Types';
 
-import { type MaybePromise, pick } 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';
 import {
   createIntent,
-  IntentAction,
   type AnyIntent,
   type AnyIntentChain,
   type Intent,
@@ -19,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;
@@ -26,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.
@@ -46,13 +52,15 @@ 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>;
   };
 
   /**
    * An error that occurred while performing the action.
    *
    * If the intent is apart of a chain of intents and an error occurs, the chain will be aborted.
+   *
+   * Return caught error instead of throwing to trigger other intent to be triggered prior to returning the error.
    */
   error?: Error;
 
@@ -62,42 +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'>;
-
-/**
- * Determines the priority of the effect when multiple intent resolvers are matched.
- *
- * - `static` - The effect is selected in the order it was resolved.
- * - `hoist` - The effect is selected before `static` effects.
- * - `fallback` - The effect is selected after `static` effects.
- */
-export type IntentDisposition = 'static' | 'hoist' | 'fallback';
+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> = {
-  action: Tag;
-  disposition?: IntentDisposition;
-  // 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.
@@ -106,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<IntentDispatcherResult<Fields>>;
+) => Promise<Simplify<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>>;
 
 /**
  * Creates an effect for intents.
@@ -129,23 +121,29 @@ export type PromiseIntentDispatcher = <Fields extends IntentParams>(
 export type IntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
   depth?: number,
-) => Effect.Effect<IntentDispatcherResult<Fields>, 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>;
 };
 
-type AnyIntentResult = IntentResult<any, any>;
+export type AnyIntentResult = IntentResult<any, any>;
 
 /**
  * Invokes the most recent undoable intent with undo flags.
  */
-export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any> | undefined>;
+export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any, any>>;
 
 /**
  * Creates an effect which undoes the last intent.
  */
-export type IntentUndo = () => Effect.Effect<IntentDispatcherResult<any> | undefined, Error>;
+export type IntentUndo = () => Effect.Effect<any, Error>;
 
 /**
  * Check if a chain of results is undoable.
@@ -158,51 +156,40 @@ export type IntentContext = {
   dispatchPromise: PromiseIntentDispatcher;
   undo: IntentUndo;
   undoPromise: PromiseIntentUndo;
-  registerResolver: (id: string, resolver: AnyIntentResolver) => () => void;
 };
 
 /**
  * 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.
  */
 export const createDispatcher = (
-  resolvers: Record<string, AnyIntentResolver[]>,
+  getResolvers: (module?: string) => AnyIntentResolver[],
   { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {},
 ): IntentContext => {
   const historyRef = Effect.runSync(Ref.make<AnyIntentResult[][]>([]));
 
-  const handleIntent = (intent: AnyIntent) => {
-    return Effect.gen(function* () {
-      const candidates = Object.entries(resolvers)
-        .filter(([id, _]) => (intent.plugin ? id === intent.plugin : true))
-        .flatMap(([_, resolvers]) => resolvers)
-        .filter((r) => r.action === intent.action)
+  const handleIntent = (intent: AnyIntent) =>
+    Effect.gen(function* () {
+      const candidates = getResolvers(intent.module)
+        .filter((r) => r.intent._tag === intent.id)
         .filter((r) => !r.filter || r.filter(intent.data))
-        .toSorted(({ disposition: a = 'static' }, { disposition: b = 'static' }) => {
-          return a === b ? 0 : a === 'hoist' || b === 'fallback' ? -1 : b === 'hoist' || a === 'fallback' ? 1 : 0;
-        });
+        .toSorted(byPosition);
       if (candidates.length === 0) {
-        return {
-          _intent: intent,
-          error: new Error(`No resolver found for action: ${intent.action}`),
-        } satisfies 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 } satisfies AnyIntentResult;
+      return { _intent: intent, ...result } as AnyIntentResult;
     });
-  };
 
   const dispatch: IntentDispatcher = (intentChain, depth = 0) => {
     return Effect.gen(function* () {
       if (depth > executionLimit) {
-        yield* Effect.fail(
-          new Error('Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.'),
-        );
+        yield* Effect.fail(new CycleDetectedError());
       }
 
       const resultsRef = yield* Ref.make<AnyIntentResult[]>([]);
@@ -210,9 +197,6 @@ export const createDispatcher = (
         const { data: prev } = (yield* resultsRef.get)[0] ?? {};
         const result = yield* handleIntent({ ...intent, data: { ...intent.data, ...prev } });
         yield* Ref.update(resultsRef, (results) => [result, ...results]);
-        if (result.error) {
-          break;
-        }
         if (result.intents) {
           for (const intent of result.intents) {
             // Returned intents are dispatched but not yielded into results,
@@ -221,34 +205,42 @@ export const createDispatcher = (
             yield* dispatch(intent, depth + 1);
           }
         }
+        if (result.error) {
+          yield* Effect.fail(result.error);
+        }
       }
 
       const results = yield* resultsRef.get;
       const result = results[0];
-      if (result) {
-        yield* Ref.update(historyRef, (history) => {
-          const next = [...history, results];
-          if (next.length > historyLimit) {
-            next.splice(0, next.length - historyLimit);
-          }
-          return next;
-        });
-
-        if (result.undoable && isUndoable(results)) {
-          // TODO(wittjosiah): Is there a better way to handle showing undo for chains?
-          yield* dispatch(createIntent(IntentAction.ShowUndo, { message: result.undoable.message }));
+      yield* Ref.update(historyRef, (history) => {
+        const next = [...history, results];
+        if (next.length > historyLimit) {
+          next.splice(0, next.length - historyLimit);
         }
-
-        return pick(result, ['data', 'error']);
-      } else {
-        return { data: {}, error: new Error('No results') };
+        return next;
+      });
+
+      if (result.undoable && isUndoable(results)) {
+        // TODO(wittjosiah): Is there a better way to handle showing undo for chains?
+        yield* pipe(
+          dispatch(createIntent(IntentAction.ShowUndo, { message: result.undoable.message })),
+          Effect.catchSome((err) =>
+            err instanceof NoResolversError ? Option.some(Effect.succeed(undefined)) : Option.none(),
+          ),
+        );
       }
+
+      return result.data;
     });
   };
 
   const dispatchPromise: PromiseIntentDispatcher = (intentChain) => {
-    const program = dispatch(intentChain);
-    return Effect.runPromise(program);
+    return Effect.runPromise(dispatch(intentChain))
+      .then((data) => ({ data }))
+      .catch((error) => {
+        log.catch(error);
+        return { error };
+      });
   };
 
   const undo: IntentUndo = () => {
@@ -270,16 +262,47 @@ export const createDispatcher = (
   };
 
   const undoPromise: PromiseIntentUndo = () => {
-    const program = undo();
-    return Effect.runPromise(program);
+    return Effect.runPromise(undo())
+      .then((data) => ({ data }))
+      .catch((error) => ({ error }));
   };
 
-  const registerResolver = (id: string, resolver: AnyIntentResolver) => {
-    resolvers[id] = [...(resolvers[id] ?? []), resolver];
-    return () => {
-      resolvers[id] = resolvers[id].filter((r) => r !== resolver);
-    };
+  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 { dispatch, dispatchPromise, undo, undoPromise, registerResolver };
+  return contributes(Capabilities.IntentDispatcher, state);
 };

package/src/{plugins/plugin-intent → plugin-intent}/intent.ts

@@ -2,9 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
-
-import { INTENT_PLUGIN } from './meta';
+import { Schema as S } from '@effect/schema';
 
 export type IntentParams = {
   readonly input: S.Schema.All;
@@ -27,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.
@@ -37,11 +35,11 @@ export type Intent<Tag extends string, Fields extends IntentParams> = {
   data: IntentData<Fields>;
 
   /**
-   * Plugin ID.
-   * If specified, the intent will be sent explicitly to the plugin.
+   * Module ID.
+   * If specified, the intent will be sent explicitly to the plugin module.
    * Otherwise, the intent will be sent to all plugins, in order and the first to resolve a non-null value will be used.
    */
-  plugin?: string;
+  module?: string;
 
   /**
    * Whether or not the intent is being undone.
@@ -78,7 +76,7 @@ export type AnyIntentChain = IntentChain<any, any, any, any>;
 export const createIntent = <Tag extends string, Fields extends IntentParams>(
   schema: IntentSchema<Tag, Fields>,
   data: IntentData<Fields> = {},
-  params: Pick<AnyIntent, 'plugin' | 'undo'> = {},
+  params: Pick<AnyIntent, 'module' | 'undo'> = {},
 ): IntentChain<Tag, Tag, Fields, Fields> => {
   // The output of validateSync breaks proxy objects so this is just used for validation.
   // TODO(wittjosiah): Is there a better way to make theses types align?
@@ -86,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>;
 
@@ -114,7 +112,7 @@ export const chain =
   >(
     schema: IntentSchema<NextTag, NextFields>,
     data: Omit<IntentData<NextFields>, keyof IntentResultData<LastFields>> = {},
-    params: Pick<AnyIntent, 'plugin' | 'undo'> = {},
+    params: Pick<AnyIntent, 'module' | 'undo'> = {},
   ) =>
   (
     intent: IntentChain<FirstTag, any, FirstFields, LastFields>,
@@ -124,7 +122,7 @@ export const chain =
     const last = {
       ...params,
       _schema: schema,
-      action: schema._tag,
+      id: schema._tag,
       data,
     } satisfies Intent<NextTag, NextFields>;
 
@@ -146,17 +144,3 @@ export const Label = S.Union(
   S.mutable(S.Tuple(S.String, S.mutable(S.Struct({ ns: S.String, count: S.optional(S.Number) })))),
 );
 export type Label = S.Schema.Type<typeof Label>;
-
-export const INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-
-export namespace IntentAction {
-  /**
-   * Fired after an intent is dispatched if the intent is undoable.
-   */
-  export class ShowUndo extends S.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
-    input: S.Struct({
-      message: Label,
-    }),
-    output: S.Void,
-  }) {}
-}

package/src/plugin-settings/SettingsPlugin.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SETTINGS_PLUGIN } from './actions';
+import translations from './translations';
+import { Capabilities, Events } from '../common';
+import { contributes, defineModule, definePlugin, lazy } from '../core';
+
+// TODO(wittjosiah): Add options to exclude some modules.
+export const SettingsPlugin = () =>
+  definePlugin({ id: SETTINGS_PLUGIN }, [
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/store`,
+      activatesOn: Events.Startup,
+      activatesBefore: [Events.SetupSettings],
+      activatesAfter: [Events.SettingsReady],
+      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

@@ -0,0 +1,27 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+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`, {
+    input: S.Struct({
+      plugin: S.optional(S.String),
+    }),
+    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/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './actions';
+export * from './SettingsPlugin';