@dxos/app-framework 0.8.2-staging.7ac8446 → 0.8.2

package/src/core/manager.ts

@@ -2,15 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Registry } from '@effect-rx/rx-react';
 import { untracked } from '@preact/signals-core';
 import { Array as A, Effect, Either, Match, pipe } from 'effect';
 
 import { Event } from '@dxos/async';
-import { create, type ReactiveObject } from '@dxos/live-object';
+import { live, type Live } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { type MaybePromise } from '@dxos/util';
 
-import { type AnyCapability, PluginsContext } from './capabilities';
+import { type AnyCapability, PluginContext } from './capabilities';
 import { type ActivationEvent, eventKey, getEvents, isAllOf } from './events';
 import { type PluginModule, type Plugin } from './plugin';
 
@@ -24,6 +25,7 @@ export type PluginManagerOptions = {
   plugins?: Plugin[];
   core?: string[];
   enabled?: string[];
+  registry?: Registry.Registry;
 };
 
 type PluginManagerState = {
@@ -43,13 +45,11 @@ type PluginManagerState = {
 
 export class PluginManager {
   readonly activation = new Event<{ event: string; state: 'activating' | 'activated' | 'error'; error?: any }>();
+  readonly context: PluginContext;
+  readonly registry: Registry.Registry;
 
-  readonly context = new PluginsContext({
-    activate: (event) => this._activate(event),
-    reset: (id) => this._reset(id),
-  });
-
-  private readonly _state: ReactiveObject<PluginManagerState>;
+  // TODO(wittjosiah): Replace with Rx.
+  private readonly _state: Live<PluginManagerState>;
   private readonly _pluginLoader: PluginManagerOptions['pluginLoader'];
   private readonly _capabilities = new Map<string, AnyCapability[]>();
 
@@ -58,9 +58,17 @@ export class PluginManager {
     plugins = [],
     core = plugins.map(({ meta }) => meta.id),
     enabled = [],
+    registry,
   }: PluginManagerOptions) {
+    this.registry = registry ?? Registry.make();
+    this.context = new PluginContext({
+      registry: this.registry,
+      activate: (event) => this._activate(event),
+      reset: (id) => this._reset(id),
+    });
+
     this._pluginLoader = pluginLoader;
-    this._state = create({
+    this._state = live({
       plugins,
       core,
       enabled,
@@ -79,7 +87,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get plugins(): ReactiveObject<readonly Plugin[]> {
+  get plugins(): Live<readonly Plugin[]> {
     return this._state.plugins;
   }
 
@@ -88,7 +96,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get core(): ReactiveObject<readonly string[]> {
+  get core(): Live<readonly string[]> {
     return this._state.core;
   }
 
@@ -97,7 +105,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get enabled(): ReactiveObject<readonly string[]> {
+  get enabled(): Live<readonly string[]> {
     return this._state.enabled;
   }
 
@@ -106,7 +114,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get modules(): ReactiveObject<readonly PluginModule[]> {
+  get modules(): Live<readonly PluginModule[]> {
     return this._state.modules;
   }
 
@@ -115,7 +123,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get active(): ReactiveObject<readonly string[]> {
+  get active(): Live<readonly string[]> {
     return this._state.active;
   }
 
@@ -124,7 +132,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get eventsFired(): ReactiveObject<readonly string[]> {
+  get eventsFired(): Live<readonly string[]> {
     return this._state.eventsFired;
   }
 
@@ -133,7 +141,7 @@ export class PluginManager {
    *
    * @reactive
    */
-  get pendingReset(): ReactiveObject<readonly string[]> {
+  get pendingReset(): Live<readonly string[]> {
     return this._state.pendingReset;
   }
 
@@ -257,7 +265,7 @@ export class PluginManager {
     return untracked(() => Effect.runPromise(this._reset(event)));
   }
 
-  private _addPlugin(plugin: Plugin) {
+  private _addPlugin(plugin: Plugin): void {
     untracked(() => {
       log('add plugin', { id: plugin.meta.id });
       if (!this._state.plugins.includes(plugin)) {
@@ -266,7 +274,7 @@ export class PluginManager {
     });
   }
 
-  private _removePlugin(id: string) {
+  private _removePlugin(id: string): void {
     untracked(() => {
       log('remove plugin', { id });
       const pluginIndex = this._state.plugins.findIndex((plugin) => plugin.meta.id === id);
@@ -276,7 +284,7 @@ export class PluginManager {
     });
   }
 
-  private _addModule(module: PluginModule) {
+  private _addModule(module: PluginModule): void {
     untracked(() => {
       log('add module', { id: module.id });
       if (!this._state.modules.includes(module)) {
@@ -285,7 +293,7 @@ export class PluginManager {
     });
   }
 
-  private _removeModule(id: string) {
+  private _removeModule(id: string): void {
     untracked(() => {
       log('remove module', { id });
       const moduleIndex = this._state.modules.findIndex((module) => module.id === id);
@@ -295,27 +303,27 @@ export class PluginManager {
     });
   }
 
-  private _getPlugin(id: string) {
+  private _getPlugin(id: string): Plugin | undefined {
     return this._state.plugins.find((plugin) => plugin.meta.id === id);
   }
 
-  private _getActiveModules() {
+  private _getActiveModules(): PluginModule[] {
     return this._state.modules.filter((module) => this._state.active.includes(module.id));
   }
 
-  private _getInactiveModules() {
+  private _getInactiveModules(): PluginModule[] {
     return this._state.modules.filter((module) => !this._state.active.includes(module.id));
   }
 
-  private _getActiveModulesByEvent(key: string) {
+  private _getActiveModulesByEvent(key: string): PluginModule[] {
     return this._getActiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
   }
 
-  private _getInactiveModulesByEvent(key: string) {
+  private _getInactiveModulesByEvent(key: string): PluginModule[] {
     return this._getInactiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
   }
 
-  private _setPendingResetByModule(module: PluginModule) {
+  private _setPendingResetByModule(module: PluginModule): void {
     return untracked(() => {
       const activationEvents = getEvents(module.activatesOn)
         .map(eventKey)

package/src/core/plugin.ts

@@ -4,7 +4,7 @@
 
 import { type MaybePromise } from '@dxos/util';
 
-import { type AnyCapability, type PluginsContext } from './capabilities';
+import { type AnyCapability, type PluginContext } from './capabilities';
 import { type ActivationEvent, type ActivationEvents } from './events';
 
 interface PluginModuleInterface {
@@ -36,13 +36,13 @@ interface PluginModuleInterface {
    * @returns The capabilities of the module.
    */
   activate: (
-    context: PluginsContext,
+    context: PluginContext,
   ) => MaybePromise<AnyCapability | AnyCapability[]> | Promise<() => Promise<AnyCapability | AnyCapability[]>>;
 }
 
 /**
  * A unit of containment of modular functionality that can be provided to an application.
- * Plugins provide things like components, state, actions, etc. to the application.
+ * Activation of a module is async allowing for code to split and loaded lazily.
  */
 // NOTE: This is implemented as a class to prevent it from being proxied by PluginManager state.
 export class PluginModule implements PluginModuleInterface {
@@ -114,6 +114,7 @@ export type PluginMeta = {
 
 /**
  * A collection of modules that are be enabled/disabled as a unit.
+ * Plugins provide things such as components, state, actions, etc. to the application.
  */
 // NOTE: This is implemented as a class to prevent it from being proxied by PluginManager state.
 export class Plugin {

package/src/playground/generator/generator.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { Capabilities, Events } from '../../common';
 import { contributes, defineEvent, defineCapability, defineModule, definePlugin } from '../../core';
@@ -15,9 +15,9 @@ 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,
+  class Alert extends Schema.TaggedClass<Alert>()(`${createPluginId(id)}/action/alert`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
   return Alert as unknown as IntentSchema<any, any>;

package/src/playground/logger/schema.ts

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

package/src/playground/playground.stories.tsx

@@ -12,7 +12,7 @@ import { DebugPlugin } from './debug';
 import { createNumberPlugin, GeneratorPlugin } from './generator';
 import { LayoutPlugin } from './layout';
 import { LoggerPlugin } from './logger';
-import { createApp } from '../App';
+import { useApp } from '../App';
 import { IntentPlugin } from '../plugin-intent';
 
 const plugins = [IntentPlugin(), LayoutPlugin(), DebugPlugin(), LoggerPlugin(), GeneratorPlugin()];
@@ -21,18 +21,22 @@ const Placeholder = () => {
   return <div>Loading...</div>;
 };
 
-const Story = createApp({
-  pluginLoader: (id) => createNumberPlugin(id),
-  plugins,
-  core: plugins.map((plugin) => plugin.meta.id),
-  // Having a non-empty placeholder makes it clear if it's taking a while to load.
-  placeholder: Placeholder,
-});
+const Story = () => {
+  const App = useApp({
+    pluginLoader: (id) => createNumberPlugin(id),
+    plugins,
+    core: plugins.map((plugin) => plugin.meta.id),
+    // Having a non-empty placeholder makes it clear if it's taking a while to load.
+    placeholder: Placeholder,
+  });
+
+  return <App />;
+};
 
 export const Playground = {};
 
 export default {
   title: 'sdk/app-framework/playground',
   render: Story,
-  decorators: [withTheme, withLayout({ tooltips: true })],
+  decorators: [withTheme, withLayout()],
 };

package/src/plugin-intent/actions.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { Label } from './intent';
 
@@ -13,21 +13,21 @@ export namespace IntentAction {
   /**
    * Log an intent.
    */
-  export class Track extends S.TaggedClass<Track>()(`${INTENT_ACTION}/track`, {
-    input: S.Struct({
-      intents: S.Array(S.String),
-      error: S.optional(S.String),
+  export class Track extends Schema.TaggedClass<Track>()(`${INTENT_ACTION}/track`, {
+    input: Schema.Struct({
+      intents: Schema.Array(Schema.String),
+      error: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
   /**
    * 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({
+  export class ShowUndo extends Schema.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
+    input: Schema.Struct({
       message: Label,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }

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

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S, Effect, Fiber, pipe } from 'effect';
+import { Schema, Effect, Fiber, pipe } from 'effect';
 import { describe, expect, test } from 'vitest';
 
 import { chain, createIntent } from './intent';
@@ -134,25 +134,6 @@ describe('Intent dispatcher', () => {
     await Effect.runPromise(program);
   });
 
-  test('filter resolvers by plugin', async () => {
-    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 }));
-
-      expect(a.value).toBe(3);
-
-      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { module: 'test' }));
-
-      expect(b.value).toBe(2);
-    });
-
-    await Effect.runPromise(program);
-  });
-
   test('filter resolvers by predicate', async () => {
     const conditionalComputeResolver = createResolver({
       intent: Compute,
@@ -224,12 +205,12 @@ describe('Intent dispatcher', () => {
   test.todo('follow up intents');
 });
 
-class ToString extends S.TaggedClass<ToString>()('ToString', {
-  input: S.Struct({
-    value: S.Number,
+class ToString extends Schema.TaggedClass<ToString>()('ToString', {
+  input: Schema.Struct({
+    value: Schema.Number,
   }),
-  output: S.Struct({
-    string: S.String,
+  output: Schema.Struct({
+    string: Schema.String,
   }),
 }) {}
 
@@ -238,12 +219,12 @@ const toStringResolver = createResolver({
   resolve: async (data) => ({ data: { string: data.value.toString() } }),
 });
 
-class Compute extends S.TaggedClass<Compute>()('Compute', {
-  input: S.Struct({
-    value: S.Number,
+class Compute extends Schema.TaggedClass<Compute>()('Compute', {
+  input: Schema.Struct({
+    value: Schema.Number,
   }),
-  output: S.Struct({
-    value: S.Number,
+  output: Schema.Struct({
+    value: Schema.Number,
   }),
 }) {}
 
@@ -262,13 +243,13 @@ const computeResolver = createResolver({
   },
 });
 
-class Concat extends S.TaggedClass<Concat>()('Concat', {
-  input: S.Struct({
-    string: S.String,
-    plus: S.String,
+class Concat extends Schema.TaggedClass<Concat>()('Concat', {
+  input: Schema.Struct({
+    string: Schema.String,
+    plus: Schema.String,
   }),
-  output: S.Struct({
-    string: S.String,
+  output: Schema.Struct({
+    string: Schema.String,
   }),
 }) {}
 
@@ -277,9 +258,9 @@ const concatResolver = createResolver({
   resolve: async (data) => ({ data: { string: data.string + data.plus } }),
 });
 
-class Add extends S.TaggedClass<Add>()('Add', {
-  input: S.Tuple(S.Number, S.Number),
-  output: S.Number,
+class Add extends Schema.TaggedClass<Add>()('Add', {
+  input: Schema.Tuple(Schema.Number, Schema.Number),
+  output: Schema.Number,
 }) {}
 
 const addResolver = createResolver({
@@ -287,9 +268,9 @@ const addResolver = createResolver({
   resolve: async (data) => ({ data: data[0] + data[1] }),
 });
 
-class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
-  input: S.Void,
-  output: S.Void,
+class SideEffect extends Schema.TaggedClass<SideEffect>()('SideEffect', {
+  input: Schema.Void,
+  output: Schema.Void,
 }) {}
 
 const sideEffectResolver = createResolver({

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

@@ -5,7 +5,7 @@
 import { Effect, Option, pipe, Ref } from 'effect';
 import { type Simplify } from 'effect/Types';
 
-import { create } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { byPosition, type MaybePromise, type Position, type GuardedType } from '@dxos/util';
 
@@ -24,7 +24,7 @@ import {
   type Label,
 } from './intent';
 import { Events, Capabilities } from '../common';
-import { contributes, type PluginsContext } from '../core';
+import { contributes, type PluginContext } from '../core';
 
 const EXECUTION_LIMIT = 100;
 const HISTORY_LIMIT = 100;
@@ -91,9 +91,25 @@ export type IntentEffectDefinition<Input, Output> = (
  * Intent resolver to match intents to their effects.
  */
 export type IntentResolver<Tag extends string, Fields extends IntentParams, Data = IntentData<Fields>> = Readonly<{
+  /**
+   * The schema of the intent to be resolved.
+   */
   intent: IntentSchema<Tag, Fields>;
+
+  /**
+   * Hint to determine the order the resolvers are processed if multiple resolvers are defined for the same intent.
+   * Only one resolver will be used.
+   */
   position?: Position;
+
+  /**
+   * Optional filter to determine if the resolver should be used.
+   */
   filter?: (data: IntentData<Fields>) => data is Data;
+
+  /**
+   * The effect to be performed when the intent is resolved.
+   */
   resolve: IntentEffectDefinition<GuardedType<IntentResolver<Tag, Fields, Data>['filter']>, IntentResultData<Fields>>;
 }>;
 
@@ -168,14 +184,14 @@ export type IntentContext = {
  * @param params.executionLimit The maximum recursion depth of intent chains.
  */
 export const createDispatcher = (
-  getResolvers: (module?: string) => AnyIntentResolver[],
+  getResolvers: () => AnyIntentResolver[],
   { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {},
 ): IntentContext => {
   const historyRef = Effect.runSync(Ref.make<AnyIntentResult[][]>([]));
 
   const handleIntent = (intent: AnyIntent) =>
     Effect.gen(function* () {
-      const candidates = getResolvers(intent.module)
+      const candidates = getResolvers()
         .filter((resolver) => resolver.intent._tag === intent.id)
         .filter((resolver) => !resolver.filter || resolver.filter(intent.data))
         .toSorted(byPosition);
@@ -286,8 +302,8 @@ export const createDispatcher = (
 const defaultEffect = () => Effect.fail(new Error('Intent runtime not ready'));
 const defaultPromise = () => Effect.runPromise(defaultEffect());
 
-export default (context: PluginsContext) => {
-  const state = create<IntentContext>({
+export default (context: PluginContext) => {
+  const state = live<IntentContext>({
     dispatch: defaultEffect,
     dispatchPromise: defaultPromise,
     undo: defaultEffect,
@@ -295,15 +311,11 @@ export default (context: PluginsContext) => {
   });
 
   // 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 { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher(() =>
+    context.getCapabilities(Capabilities.IntentResolver).flat(),
   );
 
-  const manager = context.requestCapability(Capabilities.PluginManager);
+  const manager = context.getCapability(Capabilities.PluginManager);
   state.dispatch = (intentChain, depth) => {
     return Effect.gen(function* () {
       yield* manager._activate(Events.SetupIntentResolver);

package/src/plugin-intent/intent.ts

@@ -2,20 +2,24 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 export type IntentParams = {
-  readonly input: S.Schema.All;
-  readonly output: S.Schema.All;
+  readonly input: Schema.Schema.All;
+  readonly output: Schema.Schema.All;
 };
 
 export type IntentData<Fields extends IntentParams> =
-  S.Schema.Type<S.Struct<Fields>> extends { readonly input: any } ? S.Schema.Type<S.Struct<Fields>>['input'] : any;
+  Schema.Schema.Type<Schema.Struct<Fields>> extends { readonly input: any }
+    ? Schema.Schema.Type<Schema.Struct<Fields>>['input']
+    : any;
 
 export type IntentResultData<Fields extends IntentParams> =
-  S.Schema.Type<S.Struct<Fields>> extends { readonly output: any } ? S.Schema.Type<S.Struct<Fields>>['output'] : any;
+  Schema.Schema.Type<Schema.Struct<Fields>> extends { readonly output: any }
+    ? Schema.Schema.Type<Schema.Struct<Fields>>['output']
+    : any;
 
-export type IntentSchema<Tag extends string, Fields extends IntentParams> = S.TaggedClass<any, Tag, Fields>;
+export type IntentSchema<Tag extends string, Fields extends IntentParams> = Schema.TaggedClass<any, Tag, Fields>;
 
 /**
  * An intent is an abstract description of an operation to be performed.
@@ -34,13 +38,6 @@ export type Intent<Tag extends string, Fields extends IntentParams> = {
    */
   data: IntentData<Fields>;
 
-  /**
-   * 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.
-   */
-  module?: string;
-
   /**
    * Whether or not the intent is being undone.
    */
@@ -76,11 +73,11 @@ 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, 'module' | 'undo'> = {},
+  params: Pick<AnyIntent, '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?
-  const _ = S.validateSync(schema.fields.input as S.Schema<any, any, unknown>)(data);
+  const _ = Schema.validateSync(schema.fields.input as Schema.Schema<any, any, unknown>)(data);
   const intent = {
     ...params,
     _schema: schema,
@@ -112,7 +109,7 @@ export const chain =
   >(
     schema: IntentSchema<NextTag, NextFields>,
     data: Omit<IntentData<NextFields>, keyof IntentResultData<LastFields>> = {},
-    params: Pick<AnyIntent, 'module' | 'undo'> = {},
+    params: Pick<AnyIntent, 'undo'> = {},
   ) =>
   (
     intent: IntentChain<FirstTag, any, FirstFields, LastFields>,
@@ -139,8 +136,13 @@ export const chain =
 
 // NOTE: Should maintain compatibility with `i18next` (and @dxos/react-ui).
 // TODO(wittjosiah): Making this immutable breaks type compatibility.
-export const Label = S.Union(
-  S.String,
-  S.mutable(S.Tuple(S.String, S.mutable(S.Struct({ ns: S.String, count: S.optional(S.Number) })))),
+export const Label = Schema.Union(
+  Schema.String,
+  Schema.mutable(
+    Schema.Tuple(
+      Schema.String,
+      Schema.mutable(Schema.Struct({ ns: Schema.String, count: Schema.optional(Schema.Number) })),
+    ),
+  ),
 );
-export type Label = S.Schema.Type<typeof Label>;
+export type Label = Schema.Schema.Type<typeof Label>;

package/src/plugin-settings/actions.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 export const SETTINGS_PLUGIN = 'dxos.org/plugin/settings';
 export const SETTINGS_ACTION = `${SETTINGS_PLUGIN}/action`;
@@ -12,18 +12,18 @@ 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),
+  export class Open extends Schema.TaggedClass<Open>()(`${SETTINGS_ACTION}/open`, {
+    input: Schema.Struct({
+      plugin: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class OpenPluginRegistry extends S.TaggedClass<OpenPluginRegistry>()(
+  export class OpenPluginRegistry extends Schema.TaggedClass<OpenPluginRegistry>()(
     `${SETTINGS_ACTION}/open-plugin-registry`,
     {
-      input: S.Void,
-      output: S.Void,
+      input: Schema.Void,
+      output: Schema.Void,
     },
   ) {}
 }