@dxos/plugin-markdown 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/src/blueprints/functions/update.test.ts

@@ -6,59 +6,33 @@ import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService, ConsolePrinter } from '@dxos/ai';
-import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  GenerationObserver,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AiContextService, AiConversationService } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Blueprint } from '@dxos/blueprints';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { Obj, Query, Ref } from '@dxos/echo';
-import { Database } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
+import { Database, Obj, Query, Ref } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { FunctionInvocationService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
 import { Markdown } from '@dxos/plugin-markdown/types';
-import { Collection } from '@dxos/schema';
-import { HasSubject, type Message } from '@dxos/types';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
 
-import { WithProperties, testToolkit } from '../../testing';
-import * as MarkdownBlueprint from '../markdown-blueprint';
+import { WithProperties } from '../../testing';
+import MarkdownBlueprint from '../markdown-blueprint';
 
 import update from './update';
 
 ObjectId.dangerouslyDisableRandomness();
 
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions(MarkdownBlueprint.functions, testToolkit),
-  makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-).pipe(
-  Layer.provideMerge(
-    FunctionInvocationServiceLayerTest({
-      functions: MarkdownBlueprint.functions,
-    }),
-  ),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestAiService(),
-      TestDatabaseLayer({
-        spaceKey: 'fixed',
-        indexing: { vector: true },
-        types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  functions: [...MarkdownBlueprint.functions],
+  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
+  tracing: 'pretty',
+});
 
 describe('update', () => {
   it.effect(
@@ -69,16 +43,16 @@ describe('update', () => {
           name: 'BlueYard',
           content: 'Founders and portfolio of BlueYard.',
         });
-        yield* Database.Service.add(doc);
+        yield* Database.add(doc);
 
         yield* FunctionInvocationService.invokeFunction(update, {
-          id: doc.id,
-          diffs: ['- Founders', '+ # Founders'],
+          doc: Ref.make(doc),
+          edits: [{ oldString: 'Founders', newString: '# Founders' }],
         });
 
-        const updatedDoc = yield* Database.Service.resolve(Obj.getDXN(doc), Markdown.Document);
+        const updatedDoc = yield* Database.resolve(Obj.getDXN(doc), Markdown.Document);
         expect(updatedDoc.name).toBe(doc.name);
-        const text = yield* Database.Service.load(updatedDoc.content);
+        const text = yield* Database.load(updatedDoc.content);
         expect(text.content).toBe('# Founders and portfolio of BlueYard.');
       },
       WithProperties,
@@ -91,25 +65,16 @@ describe('update', () => {
     'create and update a markdown document',
     Effect.fnUntraced(
       function* (_) {
-        const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
-
-        yield* Database.Service.flush({ indexes: true });
-        const markdownBlueprint = yield* Database.Service.add(Obj.clone(MarkdownBlueprint.make()));
-        yield* Effect.promise(() =>
-          conversation.context.bind({
-            blueprints: [Ref.make(markdownBlueprint)],
-          }),
-        );
-
-        const observer = GenerationObserver.fromPrinter(new ConsolePrinter());
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+        });
 
-        yield* conversation.createRequest({
-          observer,
+        yield* AiConversationService.run({
           prompt: `Create a document with a cookie recipe.`,
         });
         {
-          const docs = yield* Database.Service.runQuery(Query.type(Markdown.Document));
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
           if (docs.length !== 1) {
             throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
           }
@@ -118,16 +83,15 @@ describe('update', () => {
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
 
-        yield* conversation.createRequest({
-          observer,
+        yield* AiConversationService.run({
           prompt: 'Add a section with a holiday-themed variation.',
         });
         {
-          const docs = yield* Database.Service.runQuery(Query.type(Markdown.Document));
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
           if (docs.length !== 1) {
             throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
           }
@@ -136,12 +100,114 @@ describe('update', () => {
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
       },
       WithProperties,
-      Effect.provide(TestLayer),
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+
+  it.scoped(
+    'update existing document',
+    Effect.fnUntraced(
+      function* (_) {
+        const document = yield* Database.add(
+          Markdown.make({
+            name: 'Cookie Recipe',
+            content: trim`
+                Ingredients: 
+                  - 2 cups of ???
+                  - 1 cup of sugar
+                  - 1 cup of butter
+                  - 1 cup of eggs
+          `,
+          }),
+        );
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+          objects: [Ref.make(document)],
+        });
+
+        yield* AiConversationService.run({
+          prompt: 'Add the missing ingredient (its flour).',
+        });
+
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          const content = yield* Database.load(doc.content).pipe(Effect.map((_) => _.content));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+          expect(content.toLowerCase()).toContain('flour');
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+
+  it.scoped(
+    'add lines to document one by one',
+    Effect.fnUntraced(
+      function* (_) {
+        const document = yield* Database.add(
+          Markdown.make({
+            name: 'Shopping list',
+            content: trim`
+              # Shopping list
+            `,
+          }),
+        );
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+          objects: [Ref.make(document)],
+        });
+
+        yield* AiConversationService.run({
+          prompt: 'Add milk to the shopping list.',
+        });
+        yield* AiConversationService.run({
+          prompt: 'Add bread to the shopping list.',
+        });
+        yield* AiConversationService.run({
+          prompt: 'Add eggs to the shopping list.',
+        });
+
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          const content = yield* Database.load(doc.content).pipe(Effect.map((_) => _.content));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+          expect(content.toLowerCase()).toContain('milk');
+          expect(content.toLowerCase()).toContain('bread');
+          expect(content.toLowerCase()).toContain('eggs');
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,

package/src/blueprints/functions/update.ts

@@ -2,37 +2,78 @@
 // Copyright 2025 DXOS.org
 //
 
+import { next as A, type Doc } from '@automerge/automerge';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId, applyDiffs } from '@dxos/assistant';
-import { Database } from '@dxos/echo';
-import { createDocAccessor } from '@dxos/echo-db';
+import { Database, Ref } from '@dxos/echo';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
 import { defineFunction } from '@dxos/functions';
 import { trim } from '@dxos/util';
 
 import { Markdown } from '../../types';
 
+const Edit = Schema.Struct({
+  oldString: Schema.String.annotations({
+    description: 'The text to find in the document.',
+  }),
+  newString: Schema.String.annotations({
+    description: 'The text to replace it with.',
+  }),
+  replaceAll: Schema.optional(Schema.Boolean).annotations({
+    description: 'If true, replaces all occurrences. Defaults to false (first occurrence only).',
+  }),
+});
+
 // TODO(wittjosiah): Reconcile with ThreadAction.AddProposal.
+// Based on opencode's MutilEdit tool: https://deepwiki.com/search/how-does-text-edit-tool-work_a159bc76-5401-424e-b29f-f087d1ea4f78
 export default defineFunction({
-  key: 'dxos.org/function/markdown/update',
+  key: 'org.dxos.function.markdown.update',
   name: 'Update',
   description: trim`
-    Applies a set of diffs to the markdown document.
+    Applies a set of edits to the markdown document.
   `,
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    doc: Ref.Ref(Markdown.Document).annotations({
       description: 'The ID of the markdown document.',
     }),
-    diffs: Schema.Array(Schema.String).annotations({
-      description: 'The diffs to apply to the document.',
+    edits: Schema.Array(Edit).annotations({
+      description: 'The edits to apply to the document. Each edit finds oldString and replaces it with newString.',
     }),
   }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { id, diffs } }) {
-    const object = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const content = yield* Effect.promise(() => object.content.load());
+  outputSchema: Schema.Struct({
+    newContent: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { doc, edits } }) {
+    const content = yield* doc.pipe(
+      Database.load,
+      Effect.map((_) => _.content),
+      Effect.flatMap(Database.load),
+    );
     const accessor = createDocAccessor(content, ['content']);
-    applyDiffs(accessor, diffs);
+
+    for (const edit of edits) {
+      accessor.handle.change((doc: Doc<typeof content>) => {
+        const text = DocAccessor.getValue<string>(accessor);
+        if (edit.replaceAll) {
+          let idx = text.indexOf(edit.oldString);
+          while (idx !== -1) {
+            A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+            const updated = DocAccessor.getValue<string>(accessor);
+            idx = updated.indexOf(edit.oldString, idx + edit.newString.length);
+          }
+        } else {
+          const idx = text.indexOf(edit.oldString);
+          if (idx === -1) {
+            throw new Error(`Edit not found: ${JSON.stringify(edit.oldString)}`);
+          }
+          A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+        }
+      });
+    }
+
+    return {
+      newContent: DocAccessor.getValue<string>(accessor),
+    };
   }),
 });

package/src/blueprints/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * as MarkdownBlueprint from './markdown-blueprint';
+export { default as MarkdownBlueprint } from './markdown-blueprint';

package/src/blueprints/markdown-blueprint.ts

@@ -2,19 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
+import { type AppCapabilities } from '@dxos/app-toolkit';
 import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
 import { trim } from '@dxos/util';
 
-import { create, open, update } from './functions';
+import { MarkdownFunctions } from './functions';
 
-export const functions: FunctionDefinition[] = [create, open, update];
+const BLUEPRINT_KEY = 'org.dxos.blueprint.markdown';
 
-export const Key = 'dxos.org/blueprint/markdown';
+const functions = Object.values(MarkdownFunctions);
 
-export const make = () =>
+const make = () =>
   Blueprint.make({
-    key: Key,
+    key: BLUEPRINT_KEY,
     name: 'Markdown',
     tools: Blueprint.toolDefinitions({ functions }),
     instructions: Template.make({
@@ -36,3 +36,11 @@ export const make = () =>
       `,
     }),
   });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

package/src/capabilities/anchor-sort/anchor-sort.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { Relation } from '@dxos/echo';
 import { createDocAccessor, getRangeFromCursor } from '@dxos/echo-db';
 import { type AnchoredTo } from '@dxos/types';
@@ -13,7 +14,7 @@ import { Markdown } from '../../types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.AnchorSort, {
+    Capability.contributes(AppCapabilities.AnchorSort, {
       key: Markdown.Document.typename,
       sort: (anchorA: AnchoredTo.AnchoredTo, anchorB: AnchoredTo.AnchoredTo) => {
         const doc = Relation.getTarget(anchorA) as Markdown.Document;

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

@@ -4,11 +4,12 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 import { SpaceOperation } from '@dxos/plugin-space/types';
 import { isSpace } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
 
 import { translations } from '../../translations';
 import { Markdown, MarkdownOperation } from '../../types';
@@ -18,7 +19,7 @@ export default Capability.makeModule(
     // Get context for lazy capability access in callbacks.
     const capabilities = yield* Capability.Service;
 
-    return Capability.contributes(Common.Capability.AppGraphSerializer, [
+    return Capability.contributes(AppCapabilities.AppGraphSerializer, [
       {
         inputType: Markdown.Document.typename,
         outputType: 'text/markdown',
@@ -44,7 +45,7 @@ export default Capability.makeModule(
             return;
           }
 
-          const { invokePromise } = capabilities.get(Common.Capability.OperationInvoker);
+          const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
           const createResult = await invokePromise(MarkdownOperation.Create, { name: data.name, content: data.data });
           if (!createResult.data?.object) {
             return undefined;

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

@@ -9,7 +9,7 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ToolResult, createTool } from '@dxos/ai';
-import { Capability, Common } 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';
@@ -105,6 +105,6 @@ export default Capability.makeModule(() =>
       ],
     });
 
-    return Capability.contributes(Common.Capability.ArtifactDefinition, definition);
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
   }),
 );

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

@@ -4,22 +4,14 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
 import { MarkdownBlueprint } from '../../blueprints';
 
-export const functions = MarkdownBlueprint.functions;
-
-export type BlueprintCapabilities = [
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-];
-
-const blueprintDefinition = Capability.makeModule<[], BlueprintCapabilities>(() =>
-  Effect.succeed([
-    Capability.contributes(Common.Capability.Functions, functions),
-    Capability.contributes(Common.Capability.BlueprintDefinition, MarkdownBlueprint.make()),
-  ]),
-);
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint)]));
 
 export default blueprintDefinition;

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -4,25 +4,14 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { Obj, Ref, Type } from '@dxos/echo';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { OperationResolver } from '@dxos/operation';
-import { Collection } from '@dxos/schema';
 
 import { Markdown, MarkdownCapabilities, MarkdownOperation } from '../../types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    return Capability.contributes(Common.Capability.OperationResolver, [
-      OperationResolver.make({
-        operation: MarkdownOperation.OnCreateSpace,
-        handler: Effect.fnUntraced(function* ({ rootCollection }) {
-          const collection = Collection.makeManaged({ key: Type.getTypename(Markdown.Document) });
-          Obj.change(rootCollection, (c) => {
-            c.objects.push(Ref.make(collection));
-          });
-        }),
-      }),
+    return Capability.contributes(Capabilities.OperationResolver, [
       OperationResolver.make({
         operation: MarkdownOperation.Create,
         handler: ({ name, content }) =>
@@ -34,7 +23,7 @@ export default Capability.makeModule(
       OperationResolver.make({
         operation: MarkdownOperation.SetViewMode,
         handler: Effect.fnUntraced(function* ({ id, viewMode }) {
-          yield* Common.Capability.updateAtomValue(MarkdownCapabilities.State, (current) => ({
+          yield* Capabilities.updateAtomValue(MarkdownCapabilities.State, (current) => ({
             ...current,
             viewMode: { ...current.viewMode, [id]: viewMode },
           }));

package/src/capabilities/react-surface/react-surface.tsx

@@ -5,37 +5,47 @@
 import * as Effect from 'effect/Effect';
 import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import {
-  type SurfaceComponentProps,
+  Surface,
   useAtomCapability,
   useAtomCapabilityState,
   useCapability,
   useSettingsState,
-} from '@dxos/app-framework/react';
+} from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { Obj } from '@dxos/echo';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { Text } from '@dxos/schema';
 import { type EditorViewMode } from '@dxos/ui-editor';
 
-import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps, MarkdownSettings } from '../../components';
+import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps, MarkdownSettings } from '../../containers';
 import { meta } from '../../meta';
 import { Markdown, MarkdownCapabilities } from '../../types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.ReactSurface, [
-      Common.createSurface({
-        id: `${meta.id}/surface/document`,
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        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,
+        filter: (data): data is { attendableId: string; subject: Markdown.Document; 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()} subject={data.subject} role={role} ref={ref} />;
+          return (
+            <Container
+              id={Obj.getDXN(data.subject).toString()}
+              attendableId={data.attendableId}
+              subject={data.subject}
+              role={role}
+              ref={ref}
+            />
+          );
         },
       }),
-      Common.createSurface({
-        id: `${meta.id}/surface/text`,
+      Surface.create({
+        id: `${meta.id}.surface.text`,
         role: ['article', 'section', 'tabpanel'],
         filter: (data): data is { id: string; subject: Text.Text } =>
           typeof data.id === 'string' && Obj.instanceOf(Text.Text, data.subject),
@@ -43,18 +53,18 @@ export default Capability.makeModule(() =>
           return <Container id={data.id} subject={data.subject} role={role} />;
         },
       }),
-      Common.createSurface({
-        id: `${meta.id}/surface/plugin-settings`,
+      Surface.create({
+        id: `${meta.id}.surface.plugin-settings`,
         role: 'article',
-        filter: (data): data is { subject: Common.Capability.Settings } =>
-          Common.Capability.isSettings(data.subject) && data.subject.prefix === meta.id,
+        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} />;
         },
       }),
-      Common.createSurface({
-        id: `${meta.id}/surface/preview`,
+      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),
@@ -68,7 +78,7 @@ export default Capability.makeModule(() =>
  * Common wrapper.
  */
 const Container = forwardRef<HTMLDivElement, SurfaceComponentProps<Markdown.Document | Text.Text, { id: string }>>(
-  ({ id, subject, role }, forwardedRef) => {
+  ({ id, attendableId, subject, role }, forwardedRef) => {
     const selectionManager = useCapability(AttentionCapabilities.Selection);
     const settings = useAtomCapability(MarkdownCapabilities.Settings);
     const [state, setState] = useAtomCapabilityState(MarkdownCapabilities.State);
@@ -87,6 +97,7 @@ const Container = forwardRef<HTMLDivElement, SurfaceComponentProps<Markdown.Docu
         role={role}
         subject={subject}
         id={id}
+        attendableId={attendableId}
         settings={settings}
         selectionManager={selectionManager}
         extensionProviders={extensionProviders}

package/src/capabilities/settings/settings.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
 import { meta } from '../../meta';
@@ -26,7 +27,7 @@ export default Capability.makeModule(() =>
 
     return [
       Capability.contributes(MarkdownCapabilities.Settings, settingsAtom),
-      Capability.contributes(Common.Capability.Settings, {
+      Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
         schema: Markdown.Settings,
         atom: settingsAtom,