@dxos/plugin-chess 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/plugin-chess",
-  "version": "0.8.4-main.c4373fc",
+  "version": "0.8.4-main.c85a9c8dae",
   "description": "Chess for new plugin",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
   "sideEffects": true,
@@ -15,17 +19,23 @@
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
     },
+    "./blueprints": {
+      "source": "./src/blueprints/index.ts",
+      "types": "./dist/types/src/blueprints/index.d.ts",
+      "browser": "./dist/lib/browser/blueprints/index.mjs",
+      "node": "./dist/lib/node-esm/blueprints/index.mjs"
+    },
+    "./cli": {
+      "source": "./src/cli/index.ts",
+      "types": "./dist/types/src/cli/index.d.ts",
+      "browser": "./dist/lib/browser/cli/index.mjs",
+      "node": "./dist/lib/node-esm/cli/index.mjs"
+    },
     "./types": {
       "source": "./src/types/index.ts",
       "types": "./dist/types/src/types/index.d.ts",
       "browser": "./dist/lib/browser/types/index.mjs",
       "node": "./dist/lib/node-esm/types/index.mjs"
-    },
-    "./functions": {
-      "source": "./src/functions/index.ts",
-      "types": "./dist/types/src/functions/index.d.ts",
-      "browser": "./dist/lib/browser/functions/index.mjs",
-      "node": "./dist/lib/node-esm/functions/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -41,47 +51,53 @@
     "src"
   ],
   "dependencies": {
-    "@preact-signals/safe-react": "^0.9.0",
-    "@preact/signals-core": "^1.12.1",
+    "@automerge/automerge": "3.2.3",
+    "@effect-atom/atom-react": "^0.5.0",
     "chess.js": "^1.0.0",
-    "effect": "3.18.3",
-    "@dxos/ai": "0.8.4-main.c4373fc",
-    "@dxos/app-framework": "0.8.4-main.c4373fc",
-    "@dxos/blueprints": "0.8.4-main.c4373fc",
-    "@dxos/assistant": "0.8.4-main.c4373fc",
-    "@dxos/async": "0.8.4-main.c4373fc",
-    "@dxos/display-name": "0.8.4-main.c4373fc",
-    "@dxos/echo": "0.8.4-main.c4373fc",
-    "@dxos/functions": "0.8.4-main.c4373fc",
-    "@dxos/live-object": "0.8.4-main.c4373fc",
-    "@dxos/invariant": "0.8.4-main.c4373fc",
-    "@dxos/plugin-client": "0.8.4-main.c4373fc",
-    "@dxos/plugin-graph": "0.8.4-main.c4373fc",
-    "@dxos/plugin-space": "0.8.4-main.c4373fc",
-    "@dxos/react-client": "0.8.4-main.c4373fc",
-    "@dxos/log": "0.8.4-main.c4373fc",
-    "@dxos/react-ui-gameboard": "0.8.4-main.c4373fc",
-    "@dxos/react-ui-sfx": "0.8.4-main.c4373fc",
-    "@dxos/react-ui-stack": "0.8.4-main.c4373fc",
-    "@dxos/schema": "0.8.4-main.c4373fc",
-    "@dxos/util": "0.8.4-main.c4373fc"
+    "effect": "3.19.16",
+    "@dxos/ai": "0.8.4-main.c85a9c8dae",
+    "@dxos/app-framework": "0.8.4-main.c85a9c8dae",
+    "@dxos/app-toolkit": "0.8.4-main.c85a9c8dae",
+    "@dxos/async": "0.8.4-main.c85a9c8dae",
+    "@dxos/blueprints": "0.8.4-main.c85a9c8dae",
+    "@dxos/assistant": "0.8.4-main.c85a9c8dae",
+    "@dxos/display-name": "0.8.4-main.c85a9c8dae",
+    "@dxos/echo-db": "0.8.4-main.c85a9c8dae",
+    "@dxos/echo": "0.8.4-main.c85a9c8dae",
+    "@dxos/echo-react": "0.8.4-main.c85a9c8dae",
+    "@dxos/functions": "0.8.4-main.c85a9c8dae",
+    "@dxos/invariant": "0.8.4-main.c85a9c8dae",
+    "@dxos/operation": "0.8.4-main.c85a9c8dae",
+    "@dxos/log": "0.8.4-main.c85a9c8dae",
+    "@dxos/plugin-graph": "0.8.4-main.c85a9c8dae",
+    "@dxos/plugin-markdown": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-client": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-ui-gameboard": "0.8.4-main.c85a9c8dae",
+    "@dxos/plugin-space": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-ui-mosaic": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-ui-sfx": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-ui-stack": "0.8.4-main.c85a9c8dae",
+    "@dxos/schema": "0.8.4-main.c85a9c8dae",
+    "@dxos/types": "0.8.4-main.c85a9c8dae",
+    "@dxos/util": "0.8.4-main.c85a9c8dae",
+    "@dxos/plugin-client": "0.8.4-main.c85a9c8dae"
   },
   "devDependencies": {
-    "@types/react": "~19.2.2",
-    "@types/react-dom": "~19.2.1",
-    "react": "~19.2.0",
-    "react-dom": "~19.2.0",
-    "vite": "7.1.9",
-    "@dxos/plugin-theme": "0.8.4-main.c4373fc",
-    "@dxos/react-ui": "0.8.4-main.c4373fc",
-    "@dxos/react-ui-theme": "0.8.4-main.c4373fc",
-    "@dxos/storybook-utils": "0.8.4-main.c4373fc"
+    "@types/react": "~19.2.7",
+    "@types/react-dom": "~19.2.3",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "vite": "^7.1.11",
+    "@dxos/plugin-theme": "0.8.4-main.c85a9c8dae",
+    "@dxos/react-ui": "0.8.4-main.c85a9c8dae",
+    "@dxos/storybook-utils": "0.8.4-main.c85a9c8dae",
+    "@dxos/ui-theme": "0.8.4-main.c85a9c8dae"
   },
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "@dxos/react-ui": "0.8.4-main.c4373fc",
-    "@dxos/react-ui-theme": "0.8.4-main.c4373fc"
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.c85a9c8dae",
+    "@dxos/ui-theme": "0.8.4-main.c85a9c8dae"
   },
   "publishConfig": {
     "access": "public"

package/src/ChessPlugin.tsx

@@ -2,59 +2,34 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Capabilities, Events, contributes, createIntent, defineModule, definePlugin } from '@dxos/app-framework';
-import { ClientEvents } from '@dxos/plugin-client';
-import { SpaceCapabilities } from '@dxos/plugin-space';
-import { defineObjectForm } from '@dxos/plugin-space/types';
+import * as Effect from 'effect/Effect';
 
-import { BLUEPRINT_KEY, BlueprintDefinition, IntentResolver, ReactSurface } from './capabilities';
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { type CreateObject } from '@dxos/plugin-space/types';
+
+import { ChessBlueprint } from './blueprints';
+import { BlueprintDefinition, ReactSurface } from './capabilities';
 import { meta } from './meta';
 import { translations } from './translations';
-import { Chess, ChessAction } from './types';
+import { Chess } from './types';
 
-export const ChessPlugin = definePlugin(meta, () => [
-  defineModule({
-    id: `${meta.id}/module/translations`,
-    activatesOn: Events.SetupTranslations,
-    activate: () => contributes(Capabilities.Translations, translations),
-  }),
-  defineModule({
-    id: `${meta.id}/module/metadata`,
-    activatesOn: Events.SetupMetadata,
-    activate: () =>
-      contributes(Capabilities.Metadata, {
-        id: Chess.Game.typename,
-        metadata: {
-          icon: 'ph--shield-chevron--regular',
-          blueprints: [BLUEPRINT_KEY],
-        },
-      }),
-  }),
-  defineModule({
-    id: `${meta.id}/module/object-form`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () =>
-      contributes(
-        SpaceCapabilities.ObjectForm,
-        defineObjectForm({
-          objectSchema: Chess.Game,
-          getIntent: () => createIntent(ChessAction.Create),
-        }),
-      ),
-  }),
-  defineModule({
-    id: `${meta.id}/module/react-surface`,
-    activatesOn: Events.SetupReactSurface,
-    activate: ReactSurface,
-  }),
-  defineModule({
-    id: `${meta.id}/module/intent-resolver`,
-    activatesOn: Events.SetupIntentResolver,
-    activate: IntentResolver,
-  }),
-  defineModule({
-    id: `${meta.id}/module/blueprint`,
-    activatesOn: Events.SetupArtifactDefinition,
-    activate: BlueprintDefinition,
+export const ChessPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Chess.Game.typename,
+      metadata: {
+        icon: 'ph--shield-chevron--regular',
+        iconHue: 'amber',
+        blueprints: [ChessBlueprint.key],
+        createObject: ((props) => Effect.sync(() => Chess.make(props))) satisfies CreateObject,
+        addToCollectionOnCreate: true,
+      },
+    },
   }),
-]);
+  AppPlugin.addSchemaModule({ schema: [Chess.Game] }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.make,
+);

package/src/blueprints/chess-blueprint.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { trim } from '@dxos/util';
+
+import { ChessFunctions } from './functions';
+
+const BLUEPRINT_KEY = 'dxos.org/blueprint/chess';
+
+const functions = Object.values(ChessFunctions);
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Chess',
+    tools: Blueprint.toolDefinitions({ functions }),
+    instructions: Template.make({
+      source: trim`
+        You are an expert chess player.
+        To analyze a game you can access the "pgn" property by loading the context object that represents the current game.
+        You could suggest a good next move or offer to play a move.
+        Don't actually make a move unless you are asked to.
+      `,
+    }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

package/src/{functions → blueprints/functions}/create.ts

@@ -5,15 +5,21 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 
-import { Chess } from '../types';
+import { Chess } from '../../types';
 
 export default defineFunction({
   key: 'dxos.org/function/chess/create',
   name: 'Create Chess',
   description: 'Creates a new chess game.',
   inputSchema: Schema.Struct({
+    name: Schema.optional(
+      Schema.String.annotations({
+        description: 'Name of the game.',
+      }),
+    ),
     pgn: Schema.optional(
       Schema.String.annotations({
         description: 'Portable Game Notation.',
@@ -26,7 +32,7 @@ export default defineFunction({
     ),
   }),
   outputSchema: Chess.Game,
-  handler: Effect.fn(function* ({ data: { pgn, fen } }) {
-    return yield* DatabaseService.add(Chess.makeGame({ pgn, fen }));
+  handler: Effect.fn(function* ({ data: { name, pgn, fen } }) {
+    return yield* Database.add(Chess.make({ name, pgn, fen }));
   }),
 });

package/src/blueprints/functions/index.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import Create from './create';
+import Move from './move';
+import Play from './play';
+import Print from './print';
+
+export { Create, Move, Play, Print };
+
+export const ChessFunctions = {
+  Create,
+  Move,
+  Play,
+  Print,
+};

package/src/{functions → blueprints/functions}/move.ts

@@ -6,17 +6,17 @@ import { Chess as ChessJS } from 'chess.js';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 
-import { Chess } from '../types';
+import { Chess } from '../../types';
 
 export default defineFunction({
   key: 'dxos.org/function/chess/move',
   name: 'Move',
   description: 'Makes a move in the given chess game.',
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    game: Ref.Ref(Chess.Game).annotations({
       description: 'The ID of the chess object.',
     }),
     move: Schema.String.annotations({
@@ -29,17 +29,20 @@ export default defineFunction({
       description: 'The PGN of the game after the move was played.',
     }),
   }),
-  handler: Effect.fn(function* ({ data: { id, move } }) {
-    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Chess.Game);
+  handler: Effect.fn(function* ({ data: { game, move } }) {
+    const obj = yield* Database.load(game);
     const chess = new ChessJS();
-    if (object.pgn) {
-      chess.loadPgn(object.pgn);
-    } else if (object.fen) {
-      chess.load(object.fen);
+    if (obj.pgn) {
+      chess.loadPgn(obj.pgn);
+    } else if (obj.fen) {
+      chess.load(obj.fen);
     }
 
     chess.move(move, { strict: false });
-    object.pgn = chess.pgn();
-    return { pgn: object.pgn };
+    const pgn = chess.pgn();
+    Obj.change(obj, (obj) => {
+      obj.pgn = pgn;
+    });
+    return { pgn };
   }),
 });

package/src/{functions → blueprints/functions}/play.ts

@@ -6,17 +6,17 @@ import { Chess as ChessJS } from 'chess.js';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 
-import { Chess } from '../types';
+import { Chess } from '../../types';
 
 export default defineFunction({
   key: 'dxos.org/function/chess/play',
   name: 'Play',
   description: 'Uses the chess engine to play the next move.',
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    game: Ref.Ref(Chess.Game).annotations({
       description: 'The ID of the chess object.',
     }),
     side: Schema.optional(Schema.Literal('white', 'black', 'any')).annotations({
@@ -32,8 +32,8 @@ export default defineFunction({
       description: 'The move that was played.',
     }),
   }),
-  handler: Effect.fn(function* ({ data: { id, side = 'any' } }) {
-    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Chess.Game);
+  handler: Effect.fn(function* ({ data: { game, side = 'any' } }) {
+    const object = yield* Database.load(game);
     const chess = new ChessJS();
     if (object.pgn) {
       chess.loadPgn(object.pgn);
@@ -49,7 +49,10 @@ export default defineFunction({
     const move = moves[Math.floor(Math.random() * moves.length)];
 
     chess.move(move, { strict: false });
-    object.pgn = chess.pgn();
-    return { move, pgn: object.pgn };
+    const pgn = chess.pgn();
+    Obj.change(object, (o) => {
+      o.pgn = pgn;
+    });
+    return { move, pgn };
   }),
 });

package/src/blueprints/functions/print.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/function/chess/print',
+  name: 'Print game',
+  description: 'Prints the chess game to ASCII.',
+  inputSchema: Schema.Struct({
+    pgn: Schema.optional(
+      Schema.String.annotations({
+        description: 'Portable Game Notation.',
+      }),
+    ),
+    fen: Schema.optional(
+      Schema.String.annotations({
+        description: 'Forsyth-Edwards Notation.',
+      }),
+    ),
+  }),
+  outputSchema: Schema.Struct({
+    ascii: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { pgn, fen } }) {
+    try {
+      const chess = new ChessJS(fen);
+      if (pgn) {
+        chess.loadPgn(pgn);
+      }
+      return { ascii: chess.ascii() };
+    } catch {
+      // TODO(burdon): Error handling?
+      return { ascii: '' };
+    }
+  }),
+});

package/src/blueprints/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as ChessBlueprint } from './chess-blueprint';
+export * as ChessFunctions from './functions';

package/src/capabilities/artifact-definition/artifact-definition.ts

@@ -0,0 +1,135 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// ISSUE(burdon): defineArtifact
+// @ts-nocheck
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ToolResult, createTool } from '@dxos/ai';
+import { Capabilities, Capability, type PromiseIntentDispatcher } from '@dxos/app-framework';
+import { ArtifactId, VersionPin, createArtifactElement } from '@dxos/assistant';
+import { defineArtifact } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { Filter, type Space } from '@dxos/react-client/echo';
+import { trim } from '@dxos/util';
+
+import { meta } from '../../meta';
+import { Chess } from '../../types';
+
+// TODO(burdon): Factor out.
+declare global {
+  interface ToolContextExtensions {
+    space?: Space;
+    dispatch?: PromiseIntentDispatcher;
+  }
+}
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const definition = defineArtifact({
+      id: `artifact:${meta.id}`,
+      name: meta.name,
+      description: 'Provides a simple chess engine.',
+      instructions: trim`
+      - If the user's message relates to a chess game, you must return the chess game inside the artifact tag as a valid FEN string with no additional text.
+      - Always inspect the chess game at the start of every prompt realting to a chess game, as it might have changed since the interaction.
+   `,
+      schema: Chess.Game,
+      tools: [
+        createTool(meta.id, {
+          name: 'create',
+          description: 'Create a new chess game. Returns the artifact definition for the game.',
+          caption: 'Creating chess game...',
+          schema: Schema.Struct({
+            pgn: Schema.String.annotations({ description: 'The state of the chess game in the PGN format.' }),
+          }),
+          execute: async ({ pgn }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.invoke, 'No operation invoker');
+
+            const game = Chess.make({ pgn });
+
+            const { data, error } = await extensions.invoke(SpaceOperation.AddObject, {
+              target: extensions.space,
+              object: game,
+            });
+            if (error) {
+              return ToolResult.Error(error?.message ?? 'Failed to add chess game to space');
+            }
+
+            return ToolResult.Success(createArtifactElement(game.id), [
+              VersionPin.createBlock(VersionPin.fromObject(game)),
+            ]);
+          },
+        }),
+        createTool(meta.id, {
+          name: 'list',
+          description: 'Query all active chess games.',
+          caption: 'Getting games...',
+          schema: Schema.Struct({}),
+          execute: async (_, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const { objects: games } = await extensions.space.db.query(Filter.type(Chess.Game)).run();
+            invariant(games.length > 0, 'No chess games found');
+
+            return ToolResult.Success(games);
+          },
+        }),
+        createTool(meta.id, {
+          name: 'inspect',
+          description: 'Get the current state of the chess game.',
+          caption: 'Inspecting game...',
+          schema: Schema.Struct({ id: ArtifactId }),
+          execute: async ({ id }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const game = await extensions.space.db
+              .query(Filter.id(ArtifactId.toDXN(id, extensions.space.id).toString()))
+              .first();
+            invariant(Obj.instanceOf(Chess.Game, game));
+
+            return ToolResult.Success(game.pgn);
+          },
+        }),
+        createTool(meta.id, {
+          name: 'move',
+          description: 'Make a move in the chess game.',
+          caption: 'Making chess move...',
+          schema: Schema.Struct({
+            id: ArtifactId,
+            move: Schema.String.annotations({
+              description: 'The move to make in the chess game.',
+              examples: ['e4', 'Bf3'],
+            }),
+          }),
+          execute: async ({ id, move }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const game = await extensions.space.db
+              .query(Filter.id(ArtifactId.toDXN(id, extensions.space.id).toString()))
+              .first();
+            invariant(Obj.instanceOf(Chess.Game, game));
+
+            const chess = new ChessJS(game.pgn);
+            try {
+              chess.move(move);
+            } catch (error: any) {
+              return ToolResult.Error(error.message);
+            }
+
+            Obj.change(game, (g) => {
+              g.pgn = chess.pgn();
+            });
+            return ToolResult.Success(game.pgn);
+          },
+        }),
+      ],
+    });
+
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/artifact-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ArtifactDefinition = Capability.lazy('ArtifactDefinition', () => import('./artifact-definition'));

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+
+import { ChessBlueprint } from '../../blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ChessBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/index.ts

@@ -2,10 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-
 export * from './blueprint-definition';
+export * from './react-surface';

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));