@dxos/plugin-markdown 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/capabilities/app-graph-builder.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, createTypeSectionExtension } from '@dxos/app-toolkit';
+import { isSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { GraphBuilder, Node } from '@dxos/plugin-graph';
+import { SpaceOperation } from '@dxos/plugin-space';
+
+import { Markdown } from '#types';
+
+import { getDocumentsPath } from '../paths';
+
+const documentTypename = Type.getTypename(Markdown.Document);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const extensions = yield* Effect.all([
+      createTypeSectionExtension(Markdown.Document),
+
+      GraphBuilder.createExtension({
+        id: 'documentsSectionActions',
+        match: (node) => {
+          const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+          return node.type === documentTypename && space ? Option.some(space) : Option.none();
+        },
+        actions: (space) =>
+          Effect.succeed([
+            Node.makeAction({
+              id: 'create-document',
+              data: () =>
+                Effect.gen(function* () {
+                  const doc = Markdown.make({});
+                  const { subject } = yield* Operation.invoke(
+                    SpaceOperation.AddObject,
+                    { object: doc, target: space.db, hidden: true, targetNodeId: getDocumentsPath(space.db.spaceId) },
+                    { spaceId: space.db.spaceId },
+                  );
+                  yield* Operation.invoke(
+                    LayoutOperation.Open,
+                    { subject: [...subject] },
+                    { spaceId: space.db.spaceId },
+                  );
+                }),
+              properties: {
+                label: ['add-object.label', { ns: documentTypename }],
+                icon: 'ph--plus--regular',
+                disposition: 'list-item-primary',
+              },
+            }),
+          ]),
+      }),
+    ]);
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/app-graph-serializer.ts

@@ -2,53 +2,63 @@
 // Copyright 2025 DXOS.org
 //
 
-import { pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
-import { Capabilities, type PluginContext, chain, contributes, createIntent } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { Annotation, Collection, Obj, Type } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
 import { isSpace } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
 
-import { translations } from '../translations';
-import { Markdown, MarkdownAction } from '../types';
+import { translations } from '#translations';
+import { MarkdownOperation } from '#types';
+import { Markdown } from '#types';
 
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphSerializer, [
-    {
-      inputType: Markdown.Document.typename,
-      outputType: 'text/markdown',
-      // Reconcile with metadata serializers.
-      serialize: async (node) => {
-        const doc = node.data;
-        const content = await doc.content.load();
-        return {
-          name:
-            doc.name ||
-            doc.fallbackName ||
-            translations[0]['en-US'][Markdown.Document.typename]['object name placeholder'],
-          data: content.content,
-          type: 'text/markdown',
-        };
-      },
-      deserialize: async (data, ancestors) => {
-        const space = ancestors.find(isSpace);
-        const target =
-          ancestors.findLast((ancestor) => Obj.instanceOf(DataType.Collection, ancestor)) ??
-          space?.properties[DataType.Collection.typename]?.target;
-        if (!space || !target) {
-          return;
-        }
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(AppCapabilities.AppGraphSerializer, [
+      {
+        inputType: Type.getTypename(Markdown.Document),
+        outputType: 'text/markdown',
+        // Reconcile with metadata serializers.
+        serialize: async (node) => {
+          const doc = node.data;
+          const content = await doc.content.load();
+          return {
+            name:
+              doc.name ||
+              doc.fallbackName ||
+              translations[0]['en-US'][Type.getTypename(Markdown.Document)]['object-name.placeholder'],
+            data: content.content,
+            type: 'text/markdown',
+          };
+        },
+        deserialize: async (data, ancestors) => {
+          const space = ancestors.find(isSpace);
+          const target =
+            ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
+            (space && Annotation.get(space.properties, RootCollectionAnnotation).pipe(Option.getOrUndefined)?.target);
+          if (!space || !target) {
+            return;
+          }
 
-        const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const result = await dispatch(
-          pipe(
-            createIntent(MarkdownAction.Create, { spaceId: space.id, name: data.name, content: data.data }),
-            chain(SpaceAction.AddObject, { target }),
-          ),
-        );
+          const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+          const createResult = await invokePromise(MarkdownOperation.CreateMarkdown, {
+            name: data.name,
+            content: data.data,
+          });
+          if (!createResult.data?.object) {
+            return undefined;
+          }
+          await invokePromise(SpaceOperation.AddObject, { target, object: createResult.data.object });
 
-        return result.data?.object;
+          return createResult.data.object;
+        },
       },
-    },
-  ]);
+    ]);
+  }),
+);

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';
+
+import { MarkdownBlueprint } from '#blueprints';
+
+// NOTE: Explicit annotation required: d.ts emit cannot portably name the inferred @dxos/compute types (TS2883).
+const blueprintDefinition: () => Effect.Effect<
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[],
+  never,
+  Capability.Service
+> = () => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint)]);
+
+export default blueprintDefinition;

package/src/capabilities/comment-config.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Type } from '@dxos/echo';
+import { createDocAccessor, getTextInRange } from '@dxos/echo-client';
+
+import { MarkdownOperation } from '#types';
+import { Markdown } from '#types';
+
+// NOTE: Explicit annotation required: d.ts emit cannot portably name the inferred @dxos/compute types (TS2883).
+const activate: () => Effect.Effect<
+  Capability.Capability<typeof AppCapabilities.CommentConfig>,
+  never,
+  Capability.Service
+> = Effect.fnUntraced(function* () {
+  const config: AppCapabilities.CommentConfig = {
+    id: Type.getTypename(Markdown.Document),
+    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);
+});
+
+export default activate;

package/src/capabilities/create-object.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { SpaceCapabilities } from '@dxos/plugin-space';
+
+import { Markdown } from '#types';
+
+import { getDocumentsPath } from '../paths';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Type.getTypename(Markdown.Document),
+      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 ?? getDocumentsPath(options.db.spaceId),
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,13 +2,31 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import type { OperationHandlerSet } from '@dxos/compute';
 
-export const AnchorSort = lazy(() => import('./anchor-sort'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-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 AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));
+export const AnchorSort = Capability.lazy('AnchorSort', () => import('./anchor-sort'));
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+// The contributed capability type references Operation types from @dxos/compute, so the lazy
+// wrapper needs an explicit annotation to keep the inferred type portable (TS2883).
+export const CommentConfig: Capability.LazyCapability<
+  void,
+  Capability.Capability<typeof AppCapabilities.CommentConfig>
+> = Capability.lazy('CommentConfig', () => import('./comment-config'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+// The contributed capability type references Blueprint types from @dxos/compute, so the lazy
+// wrapper needs an explicit annotation to keep the inferred type portable (TS2883).
+export const BlueprintDefinition: Capability.LazyCapability<
+  void,
+  Capability.Capability<typeof AppCapabilities.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/navigation-resolver.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, createTypeSectionPathResolver } from '@dxos/app-toolkit';
+
+import { Markdown } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(
+      AppCapabilities.NavigationPathResolver,
+      createTypeSectionPathResolver(Markdown.Document),
+    );
+  }),
+);

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,114 +2,127 @@
 // Copyright 2025 DXOS.org
 //
 
-import React 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,
+  useCapabilities,
+  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 { Text } from '@dxos/schema';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
 
-import { MarkdownCard, MarkdownContainer, MarkdownSettings } from '../components';
-import { meta } from '../meta';
-import { Markdown } from '../types';
-import { isEditorModel } from '../util';
+import { MarkdownSettings } from '#components';
+import { MarkdownCard, EditableMarkdownCard, MarkdownArticle, type MarkdownArticleProps } from '#containers';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
-import { MarkdownCapabilities } from './capabilities';
+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.getURI(data.subject)}
+              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.getURI(data.subject)}
+              attendableId={data.attendableId}
+              subject={data.subject}
+              role={role}
+              ref={ref}
+            />
+          );
+        },
+      }),
+      Surface.create({
+        id: 'surface.pluginSettings',
+        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: 'first',
+        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} />,
+      }),
+    ]),
+  ),
+);
 
-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 }) => {
-        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(fullyQualifiedId(data.subject));
+/**
+ * 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 = useCapabilities(MarkdownCapabilities.ExtensionProvider);
+  const extensionProviders = useMemo(() => extensions.flat(), [extensions]);
 
-        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: `${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 }) => {
-        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: EditorViewMode = (id && state.viewMode[id]) || settings?.defaultViewMode || 'source';
+  const handleViewModeChange = useCallback<NonNullable<MarkdownArticleProps['onViewModeChange']>>(
+    (mode) => setState((current) => ({ ...current, viewMode: { ...current.viewMode, [id]: mode } })),
+    [id, setState],
+  );
 
-        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: `${meta.id}/surface/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<Markdown.Settings>(meta.id)!.value;
-        const { state, editorState, getViewMode, setViewMode } = useCapability(MarkdownCapabilities.State);
-
-        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: `${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} />,
-    }),
-  ]);
+  return (
+    <MarkdownArticle
+      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,
+      }),
+    ];
+  }),
+);