@dxos/plugin-markdown 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/capabilities/artifact-definition.ts

@@ -5,108 +5,106 @@
 // ISSUE(burdon): defineArtifact
 // @ts-nocheck
 
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, chain, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { ArtifactId, createArtifactElement } from '@dxos/assistant';
 import { defineArtifact } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, fullyQualifiedId } from '@dxos/react-client/echo';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { Filter } from '@dxos/react-client/echo';
 
-import { meta } from '../meta';
-import { Markdown, MarkdownAction } from '../types';
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`, // TODO(burdon): meta.id/artifact?
-    name: meta.name,
-    instructions: `
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const definition = defineArtifact({
+      id: `artifact:${meta.id}`, // TODO(burdon): meta.id/artifact?
+      name: meta.name,
+      instructions: `
       The markdown plugin allows you to work with text documents in the current space.
       Use these tools to interact with documents, including listing available documents and retrieving their content.
       Documents are stored in Markdown format.
     `,
-    schema: Markdown.Document,
-    tools: [
-      createTool(meta.id, {
-        name: 'create',
-        description: 'Create a new markdown document',
-        caption: 'Creating document...',
-        schema: Schema.Struct({
-          name: Schema.optional(Schema.String).annotations({
-            description: 'Optional name for the document.',
-          }),
-          content: Schema.String.annotations({
-            description: 'The content of the document.',
+      schema: Markdown.Document,
+      tools: [
+        createTool(meta.id, {
+          name: 'create',
+          description: 'Create a new markdown document',
+          caption: 'Creating document...',
+          schema: Schema.Struct({
+            name: Schema.optional(Schema.String).annotations({
+              description: 'Optional name for the document.',
+            }),
+            content: Schema.String.annotations({
+              description: 'The content of the document.',
+            }),
           }),
-        }),
-        execute: async ({ name, content }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          invariant(extensions?.dispatch, 'No intent dispatcher');
+          execute: async ({ name, content }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.invoke, 'No operation invoker');
 
-          const intent = Function.pipe(
-            createIntent(MarkdownAction.Create, {
-              spaceId: extensions.space.id,
-              name,
-              content,
-            }),
-            chain(SpaceAction.AddObject, { target: extensions.space }),
-          );
+            const document = Markdown.make({ name, content });
 
-          const { data, error } = await extensions.dispatch(intent);
-          if (!data || error) {
-            return ToolResult.Error(error?.message ?? 'Failed to create document');
-          }
+            const { error } = await extensions.invoke(SpaceOperation.AddObject, {
+              target: extensions.space,
+              object: document,
+            });
+            if (error) {
+              return ToolResult.Error(error?.message ?? 'Failed to add document to space');
+            }
 
-          return ToolResult.Success(createArtifactElement(data.id));
-        },
-      }),
-      createTool(meta.id, {
-        name: 'list',
-        description: 'List all markdown documents in the current space.',
-        caption: 'Listing markdown documents...',
-        schema: Schema.Struct({}),
-        execute: async (_input, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const space = extensions.space;
-          const { objects: documents } = await space.db.query(Filter.type(Markdown.Document)).run();
-          const documentInfo = documents.map((doc) => {
-            invariant(Obj.instanceOf(Markdown.Document, doc));
-            return {
-              id: fullyQualifiedId(doc),
-              name: doc.name || doc.fallbackName || 'Unnamed Document',
-              // TODO(ZaymonFC): Include updatedAt?
-            };
-          });
+            return ToolResult.Success(createArtifactElement(document.id));
+          },
+        }),
+        createTool(meta.id, {
+          name: 'list',
+          description: 'List all markdown documents in the current space.',
+          caption: 'Listing markdown documents...',
+          schema: Schema.Struct({}),
+          execute: async (_input, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const space = extensions.space;
+            const { objects: documents } = await space.db.query(Filter.type(Markdown.Document)).run();
+            const documentInfo = documents.map((doc) => {
+              invariant(Obj.instanceOf(Markdown.Document, doc));
+              return {
+                id: Obj.getDXN(doc).toString(),
+                name: doc.name || doc.fallbackName || 'Unnamed Document',
+                // TODO(ZaymonFC): Include updatedAt?
+              };
+            });
 
-          return ToolResult.Success(documentInfo);
-        },
-      }),
-      createTool(meta.id, {
-        name: 'inspect',
-        description: 'Read the content of a markdown document.',
-        caption: 'Inspecting markdown document...',
-        schema: Schema.Struct({
-          id: ArtifactId,
+            return ToolResult.Success(documentInfo);
+          },
         }),
-        execute: async ({ id }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const document = await extensions.space.db.query(Filter.ids(ArtifactId.toDXN(id).toString())).first();
-          assertArgument(Obj.instanceOf(Markdown.Document, document), 'document', 'Invalid type');
+        createTool(meta.id, {
+          name: 'inspect',
+          description: 'Read the content of a markdown document.',
+          caption: 'Inspecting markdown document...',
+          schema: Schema.Struct({
+            id: ArtifactId,
+          }),
+          execute: async ({ id }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const document = await extensions.space.db.query(Filter.id(ArtifactId.toDXN(id).toString())).first();
+            assertArgument(Obj.instanceOf(Markdown.Document, document), 'document', 'Invalid type');
 
-          const { content } = await document.content?.load();
-          return ToolResult.Success({
-            id: fullyQualifiedId(document),
-            name: document.name || document.fallbackName || 'Unnamed Document',
-            content,
-          });
-        },
-      }),
-    ],
-  });
+            const { content } = await document.content?.load();
+            return ToolResult.Success({
+              id: Obj.getDXN(document).toString(),
+              name: document.name || document.fallbackName || 'Unnamed Document',
+              content,
+            });
+          },
+        }),
+      ],
+    });
 
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -2,38 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import * as Effect from 'effect/Effect';
 
-import { diff, open } from '../functions';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-const functions: FunctionDefinition[] = [diff, open];
-const tools = ['add-proposals', 'create-document'];
+import { MarkdownBlueprint } from '#blueprints';
 
-export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/markdown';
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint)]));
 
-export default (): Capability<any>[] => [
-  contributes(Capabilities.Functions, functions),
-  contributes(
-    Capabilities.BlueprintDefinition,
-    Blueprint.make({
-      key: ASSISTANT_BLUEPRINT_KEY,
-      name: 'Markdown',
-      tools: Blueprint.toolDefinitions({ functions, tools }),
-      instructions: Template.make({
-        source: trim`
-            You can create and update markdown documents.
-            When asked to edit or update documents return updates as a set of compact diff string pairs.
-            For each diff, respond with the smallest possible matching span.
-            For example:
-            - "There is a tyop in this sentence."
-            + "There is a typo in this sentence."
-            - "This id goof."
-            + "This is good."
-          `,
-      }),
-    }),
-  ),
-];
+export default blueprintDefinition;

package/src/capabilities/index.ts

@@ -2,16 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
 
-export const AnchorSort = lazy(() => import('./anchor-sort'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const MarkdownSettings = lazy(() => import('./settings'));
-export const MarkdownState = lazy(() => import('./state'));
-export const Toolkit = lazy(() => import('./toolkit'));
-
-export * from './blueprint-definition';
-export * from './capabilities';
+export const AnchorSort = Capability.lazy('AnchorSort', () => import('./anchor-sort'));
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+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'));
+export const MarkdownSettings = Capability.lazy('MarkdownSettings', () => import('./settings'));
+export const MarkdownState = Capability.lazy('MarkdownState', () => import('./state'));

package/src/capabilities/node.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
+
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);

package/src/capabilities/operation-handler.ts

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

package/src/capabilities/react-surface.tsx

@@ -2,92 +2,120 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import {
+  Surface,
+  useAtomCapability,
+  useAtomCapabilityState,
+  useCapability,
+  useSettingsState,
+} from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
 import { Obj } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
+import { AttentionCapabilities } from '@dxos/plugin-attention/types';
+import { Text } from '@dxos/schema';
+import { type EditorViewMode } from '@dxos/ui-editor';
 
-import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps, MarkdownSettings } from '../components';
-import { meta } from '../meta';
-import { Markdown } from '../types';
-import { isEditorModel } from '../util';
+import { MarkdownSettings } from '#components';
+import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps } from '#containers';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
-import { MarkdownCapabilities } from './capabilities';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/surface/document`,
-      role: ['article', 'section', 'tabpanel'],
-      filter: (data): data is { subject: Markdown.Document; variant: undefined } =>
-        Obj.instanceOf(Markdown.Document, data.subject) && !data.variant,
-      component: ({ data, role }) => {
-        return <Container id={fullyQualifiedId(data.subject)} subject={data.subject} role={role} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/surface/text`,
-      role: ['article', 'section', 'tabpanel'],
-      filter: (data): data is { id: string; subject: DataType.Text } =>
-        typeof data.id === 'string' && Obj.instanceOf(DataType.Text, data.subject),
-      component: ({ data, role }) => {
-        return <Container id={data.id} subject={data.subject} role={role} />;
-      },
-    }),
-    // TODO(burdon): Remove this variant and conform to DataType.Text.
-    createSurface({
-      id: `${meta.id}/surface/editor`,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: { id: string; text: string } } => isEditorModel(data.subject),
-      component: ({ data, role }) => {
-        return <Container id={data.subject.id} subject={data.subject} role={role} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/surface/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<Markdown.Settings> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <MarkdownSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${meta.id}/surface/preview`,
-      role: ['card--popover', 'card--intrinsic', 'card--extrinsic', 'card--transclusion', 'card'],
-      filter: (data): data is { subject: Markdown.Document | DataType.Text } =>
-        Obj.instanceOf(Markdown.Document, data.subject) || Obj.instanceOf(DataType.Text, data.subject),
-      component: ({ data, role }) => <MarkdownCard {...data} role={role} />,
-    }),
-  ]);
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.surface.document`,
+        role: ['article', 'section', 'tabpanel'],
+        filter: (data): data is { subject: Markdown.Document; attendableId: string; variant: undefined } =>
+          typeof data.attendableId === 'string' && Obj.instanceOf(Markdown.Document, data.subject) && !data.variant,
+        component: ({ data, role, ref }) => {
+          return (
+            <Container
+              id={Obj.getDXN(data.subject).toString()}
+              attendableId={data.attendableId}
+              subject={data.subject}
+              role={role}
+              ref={ref}
+            />
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.surface.text`,
+        role: ['article', 'section', 'tabpanel'],
+        // TODO(burdon): Why is attendableId required? See EventArticle.tsx
+        filter: (data): data is { attendableId: string; subject: Text.Text } =>
+          typeof data.attendableId === 'string' && Obj.instanceOf(Text.Text, data.subject),
+        component: ({ data, role, ref }) => {
+          return (
+            <Container
+              id={Obj.getDXN(data.subject).toString()}
+              attendableId={data.attendableId}
+              subject={data.subject}
+              role={role}
+              ref={ref}
+            />
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.surface.plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Markdown.Settings>(subject.atom);
+          return <MarkdownSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.surface.preview`,
+        role: 'card--content',
+        filter: (data): data is { subject: Markdown.Document | Text.Text } =>
+          Obj.instanceOf(Markdown.Document, data.subject) || Obj.instanceOf(Text.Text, data.subject),
+        component: ({ data }) => <MarkdownCard {...data} />,
+      }),
+    ]),
+  ),
+);
 
 /**
  * Common wrapper.
  */
-const Container = ({ id, subject, role }: { id: string; subject: MarkdownContainerProps['object']; role: string }) => {
-  const selectionManager = useCapability(AttentionCapabilities.Selection);
-  const settingsStore = useCapability(Capabilities.SettingsStore);
-  const settings = settingsStore.getStore<Markdown.Settings>(meta.id)!.value;
-  const { state, editorState, getViewMode, setViewMode } = useCapability(MarkdownCapabilities.State);
-  const viewMode = getViewMode(id);
-  const handleViewModeChange = useCallback<NonNullable<MarkdownContainerProps['onViewModeChange']>>(
-    (mode) => setViewMode(id, mode),
-    [id, setViewMode],
-  );
+const Container = forwardRef<HTMLDivElement, ObjectSurfaceProps<Markdown.Document | Text.Text, { id: string }>>(
+  ({ id, attendableId, subject, role }, forwardedRef) => {
+    const selectionManager = useCapability(AttentionCapabilities.Selection);
+    const settings = useAtomCapability(MarkdownCapabilities.Settings);
+    const [state, setState] = useAtomCapabilityState(MarkdownCapabilities.State);
+    const editorState = useCapability(MarkdownCapabilities.EditorState);
+    const extensions = useCapability(MarkdownCapabilities.Extensions);
+    const extensionProviders = useMemo(() => extensions.flat(), [extensions]);
+
+    const viewMode: EditorViewMode = (id && state.viewMode[id]) || settings?.defaultViewMode || 'source';
+    const handleViewModeChange = useCallback<NonNullable<MarkdownContainerProps['onViewModeChange']>>(
+      (mode) => setState((current) => ({ ...current, viewMode: { ...current.viewMode, [id]: mode } })),
+      [id, setState],
+    );
 
-  return (
-    <MarkdownContainer
-      id={id}
-      object={subject}
-      role={role}
-      settings={settings}
-      selectionManager={selectionManager}
-      extensionProviders={state.extensionProviders}
-      editorStateStore={editorState}
-      viewMode={viewMode}
-      onViewModeChange={handleViewModeChange}
-    />
-  );
-};
+    return (
+      <MarkdownContainer
+        role={role}
+        subject={subject}
+        id={id}
+        attendableId={attendableId}
+        settings={settings}
+        selectionManager={selectionManager}
+        extensionProviders={extensionProviders}
+        editorStateStore={editorState}
+        viewMode={viewMode}
+        onViewModeChange={handleViewModeChange}
+        ref={forwardedRef}
+      />
+    );
+  },
+);

package/src/capabilities/settings.ts

@@ -2,24 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import * as Effect from 'effect/Effect';
 
-import { meta } from '../meta';
-import { Markdown } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<Markdown.Settings>({
-    defaultViewMode: 'preview',
-    toolbar: true,
-    numberedHeadings: true,
-    folding: true,
-    experimental: false,
-  });
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: Markdown.Settings,
-    value: settings,
-  });
-};
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Markdown.Settings,
+      defaultValue: () => ({
+        defaultViewMode: 'preview' as const,
+        toolbar: true,
+        numberedHeadings: true,
+        folding: true,
+        experimental: false,
+      }),
+    });
+
+    return [
+      Capability.contributes(MarkdownCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Markdown.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state.ts

@@ -2,30 +2,46 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { LocalStorageStore } from '@dxos/local-storage';
-import { type EditorViewMode, createEditorStateStore } from '@dxos/react-ui-editor';
-
-import { meta } from '../meta';
-import { type Markdown, type MarkdownPluginState } from '../types';
-
-import { MarkdownCapabilities } from './capabilities';
-
-export default (context: PluginContext) => {
-  const state = new LocalStorageStore<MarkdownPluginState>(meta.id, { extensionProviders: [], viewMode: {} });
-  state.prop({ key: 'viewMode', type: LocalStorageStore.json<{ [key: string]: EditorViewMode }>() });
-
-  // TODO(wittjosiah): Fold into state.
-  const editorState = createEditorStateStore(`${meta.id}/editor`);
-
-  const getViewMode = (id: string) => {
-    const defaultViewMode = context.getCapability(Capabilities.SettingsStore).getStore<Markdown.Settings>(meta.id)!
-      .value.defaultViewMode;
-    return (id && state.values.viewMode[id]) || defaultViewMode;
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { createKvsStore } from '@dxos/effect';
+import { createEditorStateStore } from '@dxos/ui-editor';
+
+import { meta } from '#meta';
+import { type EditorViewEntry, type EditorViewRegistry, MarkdownCapabilities, MarkdownStateSchema } from '#types';
+
+const createEditorViewRegistry = (): EditorViewRegistry => {
+  const views = new Map<string, EditorViewEntry>();
+  return {
+    register: (attendableId, view, documentId) => {
+      views.set(attendableId, { view, documentId });
+    },
+    unregister: (attendableId) => {
+      views.delete(attendableId);
+    },
+    get: (attendableId) => views.get(attendableId),
   };
-
-  const setViewMode = (id: string, viewMode: EditorViewMode) => (state.values.viewMode[id] = viewMode);
-
-  // Return object with methods.
-  return contributes(MarkdownCapabilities.State, { state: state.values, editorState, getViewMode, setViewMode });
 };
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Persisted state using KVS store.
+    const stateAtom = createKvsStore({
+      key: `${meta.id}.state`,
+      schema: MarkdownStateSchema,
+      defaultValue: () => ({ viewMode: {} }),
+    });
+
+    // TODO(wittjosiah): Fold into state.
+    const editorState = createEditorStateStore(`${meta.id}.editor`);
+
+    const editorViews = createEditorViewRegistry();
+
+    return [
+      Capability.contributes(MarkdownCapabilities.State, stateAtom),
+      Capability.contributes(MarkdownCapabilities.EditorState, editorState),
+      Capability.contributes(MarkdownCapabilities.EditorViews, editorViews),
+    ];
+  }),
+);

package/src/cli/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './plugin';