@dxos/app-framework 0.8.4-main.67995b8 → 0.8.4-main.72ec0f3

package/src/playground/debug/Debug.tsx

@@ -22,7 +22,7 @@ export const Debug = () => {
   };
 
   return (
-    <SyntaxHighlighter language='json' classNames='flex w-full text-xs opacity-75 rounded'>
+    <SyntaxHighlighter language='json' classNames='text-xs opacity-75 rounded'>
       {JSON.stringify(object, undefined, 2)}
     </SyntaxHighlighter>
   );

package/src/playground/debug/plugin.ts

@@ -7,11 +7,10 @@ import { defineModule, definePlugin, lazy } from '../../core';
 
 const Debug = lazy(() => import('./Debug'));
 
-export const DebugPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/plugin-debug', name: 'Debug' }, [
-    defineModule({
-      id: 'dxos.org/test/debug/main',
-      activatesOn: Events.Startup,
-      activate: Debug,
-    }),
-  ]);
+export const DebugPlugin = definePlugin({ id: 'dxos.org/test/plugin-debug', name: 'Debug' }, () => [
+  defineModule({
+    id: 'dxos.org/test/debug/main',
+    activatesOn: Events.Startup,
+    activate: Debug,
+  }),
+]);

package/src/playground/generator/Main.tsx

@@ -30,7 +30,6 @@ const Item = ({
           variant='ghost'
           icon='ph--x--regular'
           label='Remove'
-          size={5}
           disabled={disabled}
           onClick={handleRemove}
         />

package/src/playground/generator/Toolbar.tsx

@@ -6,12 +6,13 @@ import React, { useCallback } from 'react';
 
 import { Button } from '@dxos/react-ui';
 
-import { createGeneratorIntent, createPluginId, Number } from './generator';
 import { Capabilities } from '../../common';
 import { contributes } from '../../core';
 import { createIntent } from '../../plugin-intent';
 import { useCapabilities, useIntentDispatcher, usePluginManager } from '../../react';
 
+import { Number, createGeneratorIntent, createPluginId } from './generator';
+
 export const Toolbar = () => {
   const manager = usePluginManager();
   const { dispatchPromise: dispatch } = useIntentDispatcher();

package/src/playground/generator/generator.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { Capabilities, Events } from '../../common';
-import { contributes, defineEvent, defineCapability, defineModule, definePlugin } from '../../core';
-import { createResolver, type IntentSchema } from '../../plugin-intent';
+import { contributes, defineCapability, defineEvent, defineModule, definePlugin } from '../../core';
+import { type IntentSchema, createResolver } from '../../plugin-intent';
 
 export const Number = defineCapability<number>('dxos.org/test/generator/number');
 
@@ -26,7 +26,7 @@ export const createGeneratorIntent = (id: string) => {
 export const createNumberPlugin = (id: string) => {
   const number = Math.floor(Math.random() * 100);
 
-  return definePlugin({ id, name: `Plugin ${id}` }, [
+  return definePlugin({ id, name: `Plugin ${id}` }, () => [
     defineModule({
       id: `${id}/main`,
       activatesOn: CountEvent,

package/src/playground/generator/plugin.ts

@@ -8,16 +8,15 @@ import { defineModule, definePlugin, lazy } from '../../core';
 const Main = lazy(() => import('./Main'));
 const Toolbar = lazy(() => import('./Toolbar'));
 
-export const GeneratorPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/generator', name: 'Generator' }, [
-    defineModule({
-      id: 'dxos.org/test/generator/main',
-      activatesOn: Events.Startup,
-      activate: Main,
-    }),
-    defineModule({
-      id: 'dxos.org/test/generator/toolbar',
-      activatesOn: Events.Startup,
-      activate: Toolbar,
-    }),
-  ]);
+export const GeneratorPlugin = definePlugin({ id: 'dxos.org/test/generator', name: 'Generator' }, () => [
+  defineModule({
+    id: 'dxos.org/test/generator/main',
+    activatesOn: Events.Startup,
+    activate: Main,
+  }),
+  defineModule({
+    id: 'dxos.org/test/generator/toolbar',
+    activatesOn: Events.Startup,
+    activate: Toolbar,
+  }),
+]);

package/src/playground/layout/plugin.ts

@@ -3,15 +3,16 @@
 //
 
 import { Events } from '../../common';
-import { definePlugin, lazy, defineModule } from '../../core';
+import { defineModule, definePlugin, lazy } from '../../core';
 
 const Layout = lazy(() => import('./Layout'));
 
-export const LayoutPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/layout', name: 'Layout' }, [
-    defineModule({
-      id: 'dxos.org/test/layout/root',
-      activatesOn: Events.Startup,
-      activate: Layout,
-    }),
-  ]);
+const meta = { id: 'dxos.org/test/layout', name: 'Layout' };
+
+export const LayoutPlugin = definePlugin(meta, () => [
+  defineModule({
+    id: 'dxos.org/test/layout/root',
+    activatesOn: Events.Startup,
+    activate: Layout,
+  }),
+]);

package/src/playground/logger/Toolbar.tsx

@@ -6,12 +6,13 @@ import React, { useCallback } from 'react';
 
 import { Button } from '@dxos/react-ui';
 
-import { Log } from './schema';
 import { Capabilities, createSurface } from '../../common';
 import { contributes } from '../../core';
 import { createIntent } from '../../plugin-intent';
 import { useIntentDispatcher } from '../../react';
 
+import { Log } from './schema';
+
 export const Logger = () => {
   const { dispatchPromise } = useIntentDispatcher();
   const handleClick = useCallback(() => dispatchPromise(createIntent(Log, { message: 'Hello, world!' })), []);

package/src/playground/logger/plugin.ts

@@ -4,33 +4,38 @@
 
 import { log } from '@dxos/log';
 
-import { Log } from './schema';
 import { Capabilities, Events } from '../../common';
-import { contributes, defineModule, lazy, definePlugin } from '../../core';
+import { contributes, defineModule, definePlugin, lazy } from '../../core';
 import { createResolver } from '../../plugin-intent';
 
+import { Log } from './schema';
+
 const Toolbar = lazy(() => import('./Toolbar'));
 
-export const LoggerPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/logger', name: 'Logger' }, [
-    defineModule({
-      id: 'dxos.org/test/logger/intents',
-      activatesOn: Events.SetupIntentResolver,
-      activate: () => [
-        contributes(
-          Capabilities.IntentResolver,
-          createResolver({
-            intent: Log,
-            resolve: ({ message }) => {
-              log.info(message);
-            },
-          }),
-        ),
-      ],
-    }),
-    defineModule({
-      id: 'dxos.org/test/logger/surfaces',
-      activatesOn: Events.Startup,
-      activate: Toolbar,
-    }),
-  ]);
+const meta = {
+  id: 'dxos.org/test/logger',
+  name: 'Logger',
+};
+
+export const LoggerPlugin = definePlugin(meta, () => [
+  defineModule({
+    id: 'dxos.org/test/logger/intents',
+    activatesOn: Events.SetupIntentResolver,
+    activate: () => [
+      contributes(
+        Capabilities.IntentResolver,
+        createResolver({
+          intent: Log,
+          resolve: ({ message }) => {
+            log.info(message);
+          },
+        }),
+      ),
+    ],
+  }),
+  defineModule({
+    id: 'dxos.org/test/logger/surfaces',
+    activatesOn: Events.Startup,
+    activate: Toolbar,
+  }),
+]);

package/src/playground/logger/schema.ts

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

package/src/playground/playground.stories.tsx

@@ -2,41 +2,45 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withTheme } from '@dxos/react-ui/testing';
+
+import { IntentPlugin } from '../plugin-intent';
+import { useApp } from '../react';
 
 import { DebugPlugin } from './debug';
-import { createNumberPlugin, GeneratorPlugin } from './generator';
+import { GeneratorPlugin, createNumberPlugin } from './generator';
 import { LayoutPlugin } from './layout';
 import { LoggerPlugin } from './logger';
-import { useApp } from '../App';
-import { IntentPlugin } from '../plugin-intent';
 
-const plugins = [IntentPlugin(), LayoutPlugin(), DebugPlugin(), LoggerPlugin(), GeneratorPlugin()];
+const pluginFactories = [IntentPlugin, LayoutPlugin, DebugPlugin(), LoggerPlugin(), GeneratorPlugin()];
+const plugins = pluginFactories.map((factory) => (typeof factory === 'function' ? factory() : factory));
 
 const Placeholder = () => {
   return <div>Loading...</div>;
 };
 
-const Story = () => {
+const DefaultStory = () => {
   const App = useApp({
-    pluginLoader: (id) => createNumberPlugin(id),
+    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 {
+const meta = {
   title: 'sdk/app-framework/playground',
-  render: Story,
-  decorators: [withTheme, withLayout()],
-};
+  render: DefaultStory,
+  decorators: [withTheme],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Playground: Story = {};

package/src/plugin-intent/IntentPlugin.ts

@@ -2,19 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { INTENT_PLUGIN } from './actions';
 import { Events } from '../common';
 import { defineModule, definePlugin, lazy } from '../core';
 
-export const IntentPlugin = () =>
-  definePlugin({ id: INTENT_PLUGIN, name: 'Intent' }, [
-    defineModule({
-      id: `${INTENT_PLUGIN}/module/dispatcher`,
-      // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
-      //   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,
-      activatesAfter: [Events.DispatcherReady],
-      activate: lazy(() => import('./intent-dispatcher')),
-    }),
-  ]);
+import { meta } from './meta';
+
+export const IntentPlugin = definePlugin(meta, () => [
+  defineModule({
+    id: `${meta.id}/module/dispatcher`,
+    // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
+    //   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,
+    activatesAfter: [Events.DispatcherReady],
+    activate: lazy(() => import('./intent-dispatcher')),
+  }),
+]);

package/src/plugin-intent/actions.ts

@@ -2,18 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { Label } from './intent';
-
-export const INTENT_PLUGIN = 'dxos.org/plugin/intent';
-export const INTENT_ACTION = `${INTENT_PLUGIN}/action`;
+import { meta } from './meta';
 
 export namespace IntentAction {
   /**
    * Log an intent.
    */
-  export class Track extends Schema.TaggedClass<Track>()(`${INTENT_ACTION}/track`, {
+  export class Track extends Schema.TaggedClass<Track>()(`${meta.id}/action/track`, {
     input: Schema.Struct({
       intents: Schema.Array(Schema.String),
       error: Schema.optional(Schema.String),
@@ -24,7 +22,7 @@ export namespace IntentAction {
   /**
    * Fired after an intent is dispatched if the intent is undoable.
    */
-  export class ShowUndo extends Schema.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
+  export class ShowUndo extends Schema.TaggedClass<ShowUndo>()(`${meta.id}/action/show-undo`, {
     input: Schema.Struct({
       message: Label,
     }),

package/src/plugin-intent/errors.ts

@@ -24,10 +24,11 @@ export class BaseError extends Error {
 
 export class NoResolversError extends BaseError {
   constructor(action: string) {
-    super('NO_RESOLVERS', 'No resolvers were found for the action', { action });
+    super('NO_RESOLVERS', `No resolvers were found for the action: ${action}`, { action });
   }
 }
 
+// TODO(burdon): Detect loops.
 export class CycleDetectedError extends BaseError {
   constructor(context?: Record<string, any>) {
     super(

package/src/plugin-intent/index.ts

@@ -3,6 +3,7 @@
 //
 
 export * from './actions';
+export * from './errors';
 export * from './intent';
 export * from './intent-dispatcher';
 export * from './IntentPlugin';

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

@@ -2,7 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema, Effect, Fiber, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Function from 'effect/Function';
+import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
 import { chain, createIntent } from './intent';
@@ -104,7 +107,11 @@ describe('Intent dispatcher', () => {
 
   test('chain intents', async () => {
     const { dispatch } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
-    const intent = pipe(createIntent(Compute, { value: 1 }), chain(ToString, {}), chain(Concat, { plus: '!' }));
+    const intent = Function.pipe(
+      createIntent(Compute, { value: 1 }),
+      chain(ToString, {}),
+      chain(Concat, { plus: '!' }),
+    );
 
     expect(intent.first.id).toBe(Compute._tag);
     expect(intent.last.id).toBe(Concat._tag);
@@ -120,7 +127,7 @@ describe('Intent dispatcher', () => {
 
   test('undo chained intent', async () => {
     const { dispatch, undo } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
-    const intent = pipe(createIntent(Compute, { value: 1 }), chain(Compute, {}), chain(Compute, {}));
+    const intent = Function.pipe(createIntent(Compute, { value: 1 }), chain(Compute, {}), chain(Compute, {}));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(intent);
 

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

@@ -2,17 +2,22 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, Option, pipe, Ref } from 'effect';
-import { type Simplify } from 'effect/Types';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Ref from 'effect/Ref';
+import type * as Types from 'effect/Types';
 
 import { live } from '@dxos/live-object';
 import { log } from '@dxos/log';
-import { byPosition, type MaybePromise, type Position, type GuardedType } from '@dxos/util';
+import { type GuardedType, type MaybePromise, type Position, byPosition } from '@dxos/util';
+
+import { Capabilities, Events } from '../common';
+import { type PluginContext, contributes } from '../core';
 
 import { IntentAction } from './actions';
 import { CycleDetectedError, NoResolversError } from './errors';
 import {
-  createIntent,
   type AnyIntent,
   type AnyIntentChain,
   type Intent,
@@ -22,9 +27,8 @@ import {
   type IntentResultData,
   type IntentSchema,
   type Label,
+  createIntent,
 } from './intent';
-import { Events, Capabilities } from '../common';
-import { contributes, type PluginContext } from '../core';
 
 const EXECUTION_LIMIT = 100;
 const HISTORY_LIMIT = 100;
@@ -131,7 +135,7 @@ export const createResolver = <Tag extends string, Fields extends IntentParams,
  */
 export type PromiseIntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
-) => Promise<Simplify<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>>;
+) => Promise<Types.Simplify<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>>;
 
 /**
  * Creates an effect for intents.
@@ -140,7 +144,7 @@ export type IntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
   depth?: number,
 ) => Effect.Effect<
-  Simplify<Required<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>['data']>,
+  Types.Simplify<Required<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>['data']>,
   Error
 >;
 
@@ -196,7 +200,7 @@ export const createDispatcher = (
         .filter((resolver) => !resolver.filter || resolver.filter(intent.data))
         .toSorted(byPosition);
       if (candidates.length === 0) {
-        yield* Effect.fail(new NoResolversError(intent.id));
+        return yield* Effect.fail(new NoResolversError(intent.id));
       }
 
       const effect = candidates[0].resolve(intent.data, intent.undo ?? false);
@@ -205,15 +209,18 @@ export const createDispatcher = (
     });
 
   const dispatch: IntentDispatcher = (intentChain, depth = 0) => {
+    log('dispatch', { intentChain: intentChain.all.map((i) => i.id), depth });
     return Effect.gen(function* () {
       if (depth > executionLimit) {
-        yield* Effect.fail(new CycleDetectedError());
+        return yield* Effect.fail(new CycleDetectedError());
       }
 
       const resultsRef = yield* Ref.make<AnyIntentResult[]>([]);
       for (const intent of intentChain.all) {
+        log('processing', { intent });
         const { data: prev } = (yield* resultsRef.get)[0] ?? {};
         const result = yield* handleIntent({ ...intent, data: { ...intent.data, ...prev } });
+        log('ok', { intent: intent.id, result });
         yield* Ref.update(resultsRef, (results) => [result, ...results]);
         if (result.intents) {
           for (const intent of result.intents) {
@@ -230,7 +237,8 @@ export const createDispatcher = (
           //     error: result.error.message,
           //   }),
           // );
-          yield* Effect.fail(result.error);
+          log.error('failed', { intent: intent.id, error: result.error });
+          return yield* Effect.fail(result.error);
         }
       }
 
@@ -251,7 +259,7 @@ export const createDispatcher = (
 
       if (result.undoable && isUndoable(results)) {
         // TODO(wittjosiah): Is there a better way to handle showing undo for chains?
-        yield* pipe(
+        yield* Function.pipe(
           dispatch(createIntent(IntentAction.ShowUndo, { message: result.undoable.message })),
           Effect.catchSome((err) =>
             err instanceof NoResolversError ? Option.some(Effect.succeed(undefined)) : Option.none(),
@@ -259,6 +267,7 @@ export const createDispatcher = (
         );
       }
 
+      log('done', { intent: intentChain.all.map((i) => i.id), result: result.data });
       return result.data;
     });
   };

package/src/plugin-intent/intent.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 export type IntentParams = {
   readonly input: Schema.Schema.All;

package/src/plugin-intent/meta.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type PluginMeta } from '@dxos/app-framework';
+
+export const meta: PluginMeta = {
+  id: 'dxos.org/plugin/intent',
+  name: 'Intent',
+};

package/src/plugin-settings/SettingsPlugin.ts

@@ -2,34 +2,33 @@
 // 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, name: 'Settings' }, [
-    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')),
-    }),
-  ]);
+import { meta } from './meta';
+import { translations } from './translations';
+
+export const SettingsPlugin = definePlugin(meta, () => [
+  defineModule({
+    id: `${meta.id}/module/store`,
+    activatesOn: Events.Startup,
+    activatesBefore: [Events.SetupSettings],
+    activatesAfter: [Events.SettingsReady],
+    activate: lazy(() => import('./store')),
+  }),
+  defineModule({
+    id: `${meta.id}/module/translations`,
+    activatesOn: Events.SetupTranslations,
+    activate: () => contributes(Capabilities.Translations, translations),
+  }),
+  defineModule({
+    id: `${meta.id}/module/intent-resolver`,
+    activatesOn: Events.SetupIntentResolver,
+    activate: lazy(() => import('./intent-resolver')),
+  }),
+  defineModule({
+    id: `${meta.id}/module/app-graph-builder`,
+    activatesOn: Events.SetupAppGraph,
+    activate: lazy(() => import('./app-graph-builder')),
+  }),
+]);

package/src/plugin-settings/actions.ts

@@ -2,28 +2,24 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-export const SETTINGS_PLUGIN = 'dxos.org/plugin/settings';
-export const SETTINGS_ACTION = `${SETTINGS_PLUGIN}/action`;
-// TODO(wittjosiah): This is a hack to prevent the previous deck from being set for pinned items.
-//  Ideally this should be worked into the data model in a generic way.
+import { meta } from './meta';
+
+// TODO(burdon): Document.
 export const SETTINGS_ID = '!dxos:settings';
 export const SETTINGS_KEY = 'settings';
 
 export namespace SettingsAction {
-  export class Open extends Schema.TaggedClass<Open>()(`${SETTINGS_ACTION}/open`, {
+  export class Open extends Schema.TaggedClass<Open>()(`${meta.id}/open`, {
     input: Schema.Struct({
       plugin: Schema.optional(Schema.String),
     }),
     output: Schema.Void,
   }) {}
 
-  export class OpenPluginRegistry extends Schema.TaggedClass<OpenPluginRegistry>()(
-    `${SETTINGS_ACTION}/open-plugin-registry`,
-    {
-      input: Schema.Void,
-      output: Schema.Void,
-    },
-  ) {}
+  export class OpenPluginRegistry extends Schema.TaggedClass<OpenPluginRegistry>()(`${meta.id}/open-plugin-registry`, {
+    input: Schema.Void,
+    output: Schema.Void,
+  }) {}
 }