@dxos/plugin-chess 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/package.json

@@ -1,20 +1,53 @@
 {
   "name": "@dxos/plugin-chess",
-  "version": "0.8.4-main.f9ba587",
+  "version": "0.8.4-main.fcfe5033a5",
   "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,
   "type": "module",
+  "imports": {
+    "#blueprints": "./src/blueprints/index.ts",
+    "#capabilities": "./src/capabilities/index.ts",
+    "#components": "./src/components/index.ts",
+    "#containers": "./src/containers/index.ts",
+    "#meta": "./src/meta.ts",
+    "#operations": "./src/operations/index.ts",
+    "#types": "./src/types/index.ts"
+  },
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "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"
+    },
+    "./operations": {
+      "source": "./src/operations/index.ts",
+      "types": "./dist/types/src/operations/index.d.ts",
+      "browser": "./dist/lib/browser/operations/index.mjs",
+      "node": "./dist/lib/node-esm/operations/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"
@@ -33,45 +66,54 @@
     "src"
   ],
   "dependencies": {
-    "@preact-signals/safe-react": "^0.9.0",
-    "@preact/signals-core": "^1.9.0",
+    "@automerge/automerge": "3.2.3",
+    "@effect-atom/atom-react": "^0.5.0",
     "chess.js": "^1.0.0",
-    "effect": "3.16.13",
-    "@dxos/ai": "0.8.4-main.f9ba587",
-    "@dxos/app-framework": "0.8.4-main.f9ba587",
-    "@dxos/artifact": "0.8.4-main.f9ba587",
-    "@dxos/assistant": "0.8.4-main.f9ba587",
-    "@dxos/async": "0.8.4-main.f9ba587",
-    "@dxos/display-name": "0.8.4-main.f9ba587",
-    "@dxos/echo": "0.8.4-main.f9ba587",
-    "@dxos/echo-schema": "0.8.4-main.f9ba587",
-    "@dxos/invariant": "0.8.4-main.f9ba587",
-    "@dxos/live-object": "0.8.4-main.f9ba587",
-    "@dxos/log": "0.8.4-main.f9ba587",
-    "@dxos/plugin-client": "0.8.4-main.f9ba587",
-    "@dxos/plugin-graph": "0.8.4-main.f9ba587",
-    "@dxos/plugin-space": "0.8.4-main.f9ba587",
-    "@dxos/react-client": "0.8.4-main.f9ba587",
-    "@dxos/react-ui-gameboard": "0.8.4-main.f9ba587",
-    "@dxos/react-ui-stack": "0.8.4-main.f9ba587"
+    "effect": "3.20.0",
+    "@dxos/ai": "0.8.4-main.fcfe5033a5",
+    "@dxos/app-framework": "0.8.4-main.fcfe5033a5",
+    "@dxos/app-toolkit": "0.8.4-main.fcfe5033a5",
+    "@dxos/assistant": "0.8.4-main.fcfe5033a5",
+    "@dxos/blueprints": "0.8.4-main.fcfe5033a5",
+    "@dxos/async": "0.8.4-main.fcfe5033a5",
+    "@dxos/echo": "0.8.4-main.fcfe5033a5",
+    "@dxos/display-name": "0.8.4-main.fcfe5033a5",
+    "@dxos/echo-react": "0.8.4-main.fcfe5033a5",
+    "@dxos/echo-db": "0.8.4-main.fcfe5033a5",
+    "@dxos/functions": "0.8.4-main.fcfe5033a5",
+    "@dxos/invariant": "0.8.4-main.fcfe5033a5",
+    "@dxos/operation": "0.8.4-main.fcfe5033a5",
+    "@dxos/log": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-graph": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-markdown": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-client": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-ui-gameboard": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-space": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-ui-mosaic": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-ui-sfx": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-ui-stack": "0.8.4-main.fcfe5033a5",
+    "@dxos/schema": "0.8.4-main.fcfe5033a5",
+    "@dxos/types": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-client": "0.8.4-main.fcfe5033a5",
+    "@dxos/util": "0.8.4-main.fcfe5033a5"
   },
   "devDependencies": {
-    "@phosphor-icons/react": "^2.1.5",
-    "@types/react": "~18.2.0",
-    "@types/react-dom": "~18.2.0",
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "vite": "5.4.7",
-    "@dxos/react-ui": "0.8.4-main.f9ba587",
-    "@dxos/react-ui-theme": "0.8.4-main.f9ba587",
-    "@dxos/storybook-utils": "0.8.4-main.f9ba587"
+    "@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-testing": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-theme": "0.8.4-main.fcfe5033a5",
+    "@dxos/react-ui": "0.8.4-main.fcfe5033a5",
+    "@dxos/storybook-utils": "0.8.4-main.fcfe5033a5",
+    "@dxos/ui-theme": "0.8.4-main.fcfe5033a5"
   },
   "peerDependencies": {
-    "@phosphor-icons/react": "^2.1.5",
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "@dxos/react-ui": "0.8.4-main.f9ba587",
-    "@dxos/react-ui-theme": "0.8.4-main.f9ba587"
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.fcfe5033a5",
+    "@dxos/ui-theme": "0.8.4-main.fcfe5033a5"
   },
   "publishConfig": {
     "access": "public"

package/src/ChessPlugin.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { ActivationEvents, Capabilities } from '@dxos/app-framework';
+import { createTestApp } from '@dxos/app-framework/testing';
+import { AppActivationEvents, AppCapabilities } from '@dxos/app-toolkit';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+
+import { ChessPlugin } from './ChessPlugin';
+import { Print } from './operations';
+
+describe('ChessPlugin', () => {
+  test('activates and contributes expected capabilities', async ({ expect }) => {
+    await using harness = await createTestApp({ plugins: [ChessPlugin()] });
+    const surfaces = harness.getAll(Capabilities.ReactSurface).flat();
+    expect(surfaces.length).toBeGreaterThan(0);
+  });
+
+  test('fires activation events explicitly with autoStart: false', async ({ expect }) => {
+    await using harness = await createTestApp({ plugins: [ChessPlugin()], autoStart: false });
+
+    // No modules have activated yet; schema/surface capabilities are absent.
+    expect(harness.getAll(AppCapabilities.Schema)).toHaveLength(0);
+    expect(harness.getAll(Capabilities.ReactSurface)).toHaveLength(0);
+
+    // Fire SetupSchema — the schema module activates and contributes the Chess.Game type.
+    await harness.fire(AppActivationEvents.SetupSchema);
+    const schemas = harness.getAll(AppCapabilities.Schema).flat();
+    expect(schemas.length).toBeGreaterThan(0);
+
+    // ReactSurface is gated on a different event; still absent.
+    expect(harness.getAll(Capabilities.ReactSurface)).toHaveLength(0);
+
+    // Fire SetupReactSurface; the surface module contributes.
+    await harness.fire(ActivationEvents.SetupReactSurface);
+    expect(harness.getAll(Capabilities.ReactSurface).flat().length).toBeGreaterThan(0);
+  });
+
+  test('waitForEvent resolves once the event has been fired', async ({ expect }) => {
+    await using harness = await createTestApp({ plugins: [ChessPlugin()], autoStart: false });
+
+    // Fire and wait concurrently — waitForEvent resolves regardless of ordering.
+    await Promise.all([
+      harness.fire(AppActivationEvents.SetupTranslations),
+      harness.waitForEvent(AppActivationEvents.SetupTranslations),
+    ]);
+    expect(harness.getAll(AppCapabilities.Translations).flat().length).toBeGreaterThan(0);
+  });
+
+  test('invokes the Print operation via the invoker capability', async ({ expect }) => {
+    await using harness = await createComposerTestApp({ plugins: [ChessPlugin()] });
+    const result = await harness.invoke(Print, {});
+    // Empty input returns empty ASCII (handler swallows errors for malformed FEN).
+    expect(typeof result.ascii).toBe('string');
+  });
+
+  test('Print renders a PGN to ASCII board', async ({ expect }) => {
+    await using harness = await createComposerTestApp({ plugins: [ChessPlugin()] });
+    const { ascii } = await harness.invoke(Print, { pgn: '1. e4 e5' });
+    expect(ascii).toContain('a  b  c  d  e  f  g  h');
+  });
+});

package/src/ChessPlugin.tsx

@@ -2,59 +2,48 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Capabilities, contributes, createIntent, defineModule, definePlugin, Events } 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 * as Option from 'effect/Option';
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { Annotation } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { type CreateObject } from '@dxos/plugin-space/types';
+
+import { ChessBlueprint } from '#blueprints';
+import { BlueprintDefinition, OperationHandler, ReactSurface } from '#capabilities';
+import { meta } from '#meta';
+import { Chess } from '#types';
 
-import { ArtifactDefinition, IntentResolver, ReactSurface } from './capabilities';
-import { meta } from './meta';
 import { translations } from './translations';
-import { ChessAction, ChessType } 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: ChessType.typename,
-          metadata: {
-            icon: 'ph--shield-chevron--regular',
-          },
-        }),
-    }),
-    defineModule({
-      id: `${meta.id}/module/object-form`,
-      activatesOn: ClientEvents.SetupSchema,
-      activate: () =>
-        contributes(
-          SpaceCapabilities.ObjectForm,
-          defineObjectForm({
-            objectSchema: ChessType,
-            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/artifact-definition`,
-      activatesOn: Events.SetupArtifactDefinition,
-      activate: ArtifactDefinition,
-    }),
-  ]);
+export const ChessPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Chess.Game.typename,
+      metadata: {
+        icon: Annotation.IconAnnotation.get(Chess.Game).pipe(Option.getOrThrow).icon,
+        iconHue: Annotation.IconAnnotation.get(Chess.Game).pipe(Option.getOrThrow).hue ?? 'white',
+        blueprints: [ChessBlueprint.key],
+        createObject: ((props, options) =>
+          Effect.gen(function* () {
+            const object = Chess.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          })) satisfies CreateObject,
+      },
+    },
+  }),
+  AppPlugin.addSchemaModule({ schema: [Chess.Game] }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.make,
+);

package/src/blueprints/chess-blueprint.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { trim } from '@dxos/util';
+
+import { Create, Move, Play, Print } from '#operations';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.chess';
+
+const operations = [Create, Move, Play, Print];
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Chess',
+    tools: Blueprint.toolDefinitions({ operations }),
+    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,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/index.ts

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

package/src/capabilities/artifact-definition.ts

@@ -2,20 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Chess } from 'chess.js';
-import { pipe, Schema } from 'effect';
+// ISSUE(burdon): defineArtifact
+// @ts-nocheck
 
-import { createTool, ToolResult } from '@dxos/ai';
-import { Capabilities, chain, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { ArtifactId, defineArtifact } from '@dxos/artifact';
-import { createArtifactElement, VersionPin } from '@dxos/assistant';
+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 { SpaceAction } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { Filter, type Space } from '@dxos/react-client/echo';
+import { trim } from '@dxos/util';
 
-import { meta } from '../meta';
-import { ChessAction, ChessType } from '../types';
+import { meta } from '#meta';
+import { Chess } from '#types';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -25,100 +30,106 @@ declare global {
   }
 }
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`,
-    name: meta.name,
-    description: 'Provides a simple chess engine.',
-    instructions: `
+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: ChessType,
-    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({
-          fen: Schema.String.annotations({ description: 'The state of the chess game in the FEN format.' }),
-        }),
-        execute: async ({ fen }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          invariant(extensions?.dispatch, 'No intent dispatcher');
-          const intent = pipe(
-            createIntent(ChessAction.Create, { fen }),
-            chain(SpaceAction.AddObject, { target: extensions.space }),
-          );
-          const { data, error } = await extensions.dispatch(intent);
-          if (!data || error) {
-            return ToolResult.Error(error?.message ?? 'Failed to create chess game');
-          }
+      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');
 
-          return ToolResult.Success(createArtifactElement(data.id), [
-            VersionPin.createBlock(VersionPin.fromObject(data.object)),
-          ]);
-        },
-      }),
-      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(ChessType)).run();
-          invariant(games.length > 0, 'No chess games found');
+            const game = Chess.make({ pgn });
 
-          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.ids(ArtifactId.toDXN(id, extensions.space.id).toString()))
-            .first();
-          invariant(Obj.instanceOf(ChessType, game));
+            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(game.fen);
-        },
-      }),
-      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'],
-          }),
+            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);
+          },
         }),
-        execute: async ({ id, move }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const game = await extensions.space.db
-            .query(Filter.ids(ArtifactId.toDXN(id, extensions.space.id).toString()))
-            .first();
-          invariant(Obj.instanceOf(ChessType, game));
+        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));
 
-          const board = new Chess(game.fen);
-          try {
-            board.move(move);
-          } catch (error: any) {
-            return ToolResult.Error(error.message);
-          }
-          game.pgn = board.pgn();
-          game.fen = board.fen();
-          return ToolResult.Success(game.fen);
-        },
-      }),
-    ],
-  });
+            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, (game) => {
+              game.pgn = chess.pgn();
+            });
+            return ToolResult.Success(game.pgn);
+          },
+        }),
+      ],
+    });
 
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/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/index.ts

@@ -2,8 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
 
-export const ArtifactDefinition = lazy(() => import('./artifact-definition'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,14 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/operation';
+
+import { ChessHandlers } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ChessHandlers);
+  }),
+);