@dxos/plugin-markdown 0.8.3 → 0.8.4-main.1c7ec43d41

package/src/capabilities/artifact-definition.ts

@@ -2,115 +2,109 @@
 // Copyright 2025 DXOS.org
 //
 
-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 } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { invariant, assertArgument } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, fullyQualifiedId, type Space } from '@dxos/react-client/echo';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-import { meta } from '../meta';
-import { DocumentType, MarkdownAction } from '../types';
+import { ToolResult, createTool } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { ArtifactId, createArtifactElement } from '@dxos/assistant';
+import { defineArtifact } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { Filter } from '@dxos/react-client/echo';
 
-// TODO(burdon): Factor out.
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`,
-    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.
+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: DocumentType,
-    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 = 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(DocumentType)).run();
-          const documentInfo = documents.map((doc) => {
-            invariant(Obj.instanceOf(DocumentType, 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(DocumentType, 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

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
+
+import { MarkdownBlueprint } from '#blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/comment-config.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Operation } from '@dxos/compute';
+import { createDocAccessor, getTextInRange } from '@dxos/echo-db';
+
+import { MarkdownOperation } from '#operations';
+import { Markdown } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const config: AppCapabilities.CommentConfig = {
+      id: Markdown.Document.typename,
+      comments: 'anchored',
+      selectionMode: 'multi-range',
+      getAnchorLabel: (doc: Markdown.Document, anchor: string): string | undefined => {
+        if (doc.content) {
+          const [start, end] = anchor.split(':');
+          return getTextInRange(createDocAccessor(doc.content.target!, ['content']), start, end);
+        }
+      },
+      scrollToAnchor: MarkdownOperation.ScrollToAnchor,
+    };
+    return Capability.contributes(AppCapabilities.CommentConfig, config);
+  }),
+);

package/src/capabilities/create-object.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { SpaceCapabilities } from '@dxos/plugin-space/types';
+
+import { Markdown } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Markdown.Document.typename,
+      createObject: (props, options) =>
+        Effect.gen(function* () {
+          const object = Markdown.make(props);
+          return yield* Operation.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId,
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,14 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, Operation, OperationHandlerSet } from '@dxos/compute';
 
-export const AnchorSort = lazy(() => import('./anchor-sort'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-export const ArtifactDefinition = lazy(() => import('./artifact-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 * from './capabilities';
+export const AnchorSort = Capability.lazy('AnchorSort', () => import('./anchor-sort'));
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+export const CommentConfig = Capability.lazy('CommentConfig', () => import('./comment-config'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+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,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+
+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/compute';
+
+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,112 +2,126 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import * as Effect from 'effect/Effect';
+import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { createSurface, contributes, Capabilities, useCapability } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import {
+  Surface,
+  useAtomCapability,
+  useAtomCapabilityState,
+  useCapability,
+  useSettingsState,
+} from '@dxos/app-framework/ui';
+import { AppSurface } 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/types';
 
-import { MarkdownCapabilities } from './capabilities';
-import { MarkdownContainer, MarkdownSettings, MarkdownPreview } from '../components';
-import { MARKDOWN_PLUGIN } from '../meta';
-import { DocumentType, isEditorModel, type MarkdownSettingsProps } from '../types';
+import { MarkdownSettings } from '#components';
+import { MarkdownCard, EditableMarkdownCard, MarkdownContainer, type MarkdownContainerProps } from '#containers';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${MARKDOWN_PLUGIN}/document`,
-      role: ['article', 'section', 'tabpanel'],
-      filter: (data): data is { subject: DocumentType; variant: undefined } =>
-        Obj.instanceOf(DocumentType, data.subject) && !data.variant,
-      component: ({ data, role }) => {
-        const selectionManager = useCapability(AttentionCapabilities.Selection);
-        const settingsStore = useCapability(Capabilities.SettingsStore);
-        const settings = settingsStore.getStore<MarkdownSettingsProps>(MARKDOWN_PLUGIN)!.value;
-        const { state, editorState, getViewMode, setViewMode } = useCapability(MarkdownCapabilities.State);
-        const viewMode = getViewMode(fullyQualifiedId(data.subject));
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'surface.document',
+        // TODO(wittjosiah): Split into multiple surfaces if this filter proves too strict for non-article roles.
+        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: 'surface.text',
+        // TODO(wittjosiah): Split into multiple surfaces if this filter proves too strict for non-article roles.
+        // TODO(burdon): Why is attendableId required? See EventArticle.tsx
+        filter: AppSurface.oneOf(
+          AppSurface.object(AppSurface.Article, Text.Text),
+          AppSurface.object(AppSurface.Section, Text.Text),
+          AppSurface.object(AppSurface.Tabpanel, Text.Text),
+        ),
+        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: 'surface.plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Markdown.Settings>(subject.atom);
+          return <MarkdownSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: 'surface.editable',
+        position: 'hoist',
+        filter: AppSurface.object(AppSurface.Card, [Markdown.Document, Text.Text], (data) => data.editable === true),
+        component: ({ data }) => <EditableMarkdownCard subject={data.subject} />,
+      }),
+      Surface.create({
+        id: 'surface.preview',
+        filter: AppSurface.object(AppSurface.Card, [Markdown.Document, Text.Text], (data) => data.editable !== true),
+        component: ({ data }) => <MarkdownCard {...data} />,
+      }),
+    ]),
+  ),
+);
 
-        return (
-          <MarkdownContainer
-            id={fullyQualifiedId(data.subject)}
-            object={data.subject}
-            role={role}
-            settings={settings}
-            selectionManager={selectionManager}
-            extensionProviders={state.extensionProviders}
-            viewMode={viewMode}
-            editorStateStore={editorState}
-            onViewModeChange={setViewMode}
-          />
-        );
-      },
-    }),
-    createSurface({
-      id: `${MARKDOWN_PLUGIN}/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 }) => {
-        const selectionManager = useCapability(AttentionCapabilities.Selection);
-        const settingsStore = useCapability(Capabilities.SettingsStore);
-        const settings = settingsStore.getStore<MarkdownSettingsProps>(MARKDOWN_PLUGIN)!.value;
-        const { state, editorState, getViewMode, setViewMode } = useCapability(MarkdownCapabilities.State);
+/**
+ * Common wrapper.
+ */
+const Container = forwardRef<
+  HTMLDivElement,
+  AppSurface.ObjectArticleProps<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]);
 
-        return (
-          <MarkdownContainer
-            id={data.id}
-            object={data.subject}
-            role={role}
-            settings={settings}
-            selectionManager={selectionManager}
-            extensionProviders={state.extensionProviders}
-            viewMode={getViewMode(data.id)}
-            editorStateStore={editorState}
-            onViewModeChange={setViewMode}
-          />
-        );
-      },
-    }),
-    createSurface({
-      id: `${MARKDOWN_PLUGIN}/editor`,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: { id: string; text: string } } => isEditorModel(data.subject),
-      component: ({ data, role }) => {
-        const selectionManager = useCapability(AttentionCapabilities.Selection);
-        const settingsStore = useCapability(Capabilities.SettingsStore);
-        const settings = settingsStore.getStore<MarkdownSettingsProps>(MARKDOWN_PLUGIN)!.value;
-        const { state, editorState, getViewMode, setViewMode } = useCapability(MarkdownCapabilities.State);
+  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={data.subject.id}
-            object={data.subject}
-            role={role}
-            settings={settings}
-            selectionManager={selectionManager}
-            extensionProviders={state.extensionProviders}
-            viewMode={getViewMode(data.subject.id)}
-            editorStateStore={editorState}
-            onViewModeChange={setViewMode}
-          />
-        );
-      },
-    }),
-    createSurface({
-      id: `${MARKDOWN_PLUGIN}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<MarkdownSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === MARKDOWN_PLUGIN,
-      component: ({ data: { subject } }) => <MarkdownSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${MARKDOWN_PLUGIN}/preview`,
-      role: ['popover', 'card--kanban', 'card--document', 'card'],
-      filter: (data): data is { subject: DocumentType | DataType.Text } =>
-        Obj.instanceOf(DocumentType, data.subject) || Obj.instanceOf(DataType.Text, data.subject),
-      component: ({ data, role }) => <MarkdownPreview {...data} role={role} />,
-    }),
-  ]);
+  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 { type MarkdownSettingsProps, MarkdownSettingsSchema } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<MarkdownSettingsProps>({
-    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: MarkdownSettingsSchema,
-    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,
+      }),
+    ];
+  }),
+);