@dxos/plugin-markdown 0.8.4-main.7996785055 → 0.8.4-main.8baae0fced

package/src/capabilities/{operation-handler/index.ts → node.ts}

@@ -3,7 +3,9 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 
 export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
   'OperationHandler',

package/src/capabilities/{operation-handler/operation-handler.ts → operation-handler.ts}

@@ -5,9 +5,9 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import type { OperationHandlerSet } from '@dxos/operation';
+import type { OperationHandlerSet } from '@dxos/compute';
 
-import { MarkdownOperationHandlerSet } from '../../operations';
+import { MarkdownOperationHandlerSet } from '#operations';
 
 export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
   Effect.fnUntraced(function* () {

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,127 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React, { forwardRef, useCallback, useMemo } from 'react';
+
+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 { AttentionCapabilities } from '@dxos/plugin-attention';
+import { Text } from '@dxos/schema';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
+
+import { MarkdownSettings } from '#components';
+import { MarkdownCard, EditableMarkdownCard, MarkdownArticle, type MarkdownArticleProps } from '#containers';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
+
+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: '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} />,
+      }),
+    ]),
+  ),
+);
+
+/**
+ * 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]);
+
+  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 (
+    <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/settings.ts → settings.ts}

@@ -8,8 +8,8 @@ import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
-import { meta } from '../../meta';
-import { Markdown, MarkdownCapabilities } from '../../types';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {

package/src/capabilities/{state/state.ts → state.ts}

@@ -8,11 +8,11 @@ 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';
+import { meta } from '#meta';
+import { MarkdownCapabilities } from '#types';
 
-const createEditorViewRegistry = (): EditorViewRegistry => {
-  const views = new Map<string, EditorViewEntry>();
+const createEditorViewRegistry = (): MarkdownCapabilities.EditorViewRegistry => {
+  const views = new Map<string, MarkdownCapabilities.EditorViewEntry>();
   return {
     register: (attendableId, view, documentId) => {
       views.set(attendableId, { view, documentId });
@@ -29,7 +29,7 @@ export default Capability.makeModule(
     // Persisted state using KVS store.
     const stateAtom = createKvsStore({
       key: `${meta.id}.state`,
-      schema: MarkdownStateSchema,
+      schema: MarkdownCapabilities.StateSchema,
       defaultValue: () => ({ viewMode: {} }),
     });
 

package/src/components/MarkdownEditor/MarkdownEditor.stories.tsx

@@ -8,25 +8,26 @@ import React from 'react';
 
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Filter, Obj } from '@dxos/echo';
-import { ClientPlugin } from '@dxos/plugin-client';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
 import { initializeIdentity } from '@dxos/plugin-client/testing';
 import { corePlugins } from '@dxos/plugin-testing';
-import { useQuery, useSpace } from '@dxos/react-client/echo';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
 import { Panel } from '@dxos/react-ui';
-import { Loading, withLayout } from '@dxos/react-ui/testing';
 import { AttendableContainer } from '@dxos/react-ui-attention';
-import { translations as editorTranslations } from '@dxos/react-ui-editor';
+import { Editor } from '@dxos/react-ui-editor';
+import { translations as editorTranslations } from '@dxos/react-ui-editor/translations';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
 import { Text } from '@dxos/schema';
 
-import { translations } from '../../translations';
-import { Markdown } from '../../types';
+import { translations } from '#translations';
+import { Markdown } from '#types';
 
-import { MarkdownEditor, type MarkdownEditorRootProps } from './MarkdownEditor';
+import { MarkdownEditor, MarkdownEditorProvider, type MarkdownEditorProviderProps } from './MarkdownEditor';
 
-type DefaultStoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
+type DefaultStoryProps = Omit<MarkdownEditorProviderProps, 'id' | 'extensions' | 'children'>;
 
 const DefaultStory = (props: DefaultStoryProps) => {
-  const space = useSpace();
+  const [space] = useSpaces();
   const [doc] = useQuery(space?.db, Filter.type(Markdown.Document));
   const id = doc && Obj.getDXN(doc).toString();
   if (!id) {
@@ -35,16 +36,20 @@ const DefaultStory = (props: DefaultStoryProps) => {
 
   return (
     <AttendableContainer id={id} tabIndex={0} classNames='dx-container'>
-      <MarkdownEditor.Root id={id} object={doc} {...props}>
-        <Panel.Root>
-          <Panel.Toolbar asChild>
-            <MarkdownEditor.Toolbar />
-          </Panel.Toolbar>
-          <Panel.Content asChild>
-            <MarkdownEditor.Content />
-          </Panel.Content>
-        </Panel.Root>
-      </MarkdownEditor.Root>
+      <MarkdownEditorProvider id={id} object={doc} {...props}>
+        {(editorRootProps) => (
+          <Editor.Root {...editorRootProps}>
+            <Panel.Root>
+              <Panel.Toolbar asChild>
+                <MarkdownEditor.Toolbar />
+              </Panel.Toolbar>
+              <Panel.Content asChild>
+                <MarkdownEditor.Content />
+              </Panel.Content>
+            </Panel.Root>
+          </Editor.Root>
+        )}
+      </MarkdownEditorProvider>
     </AttendableContainer>
   );
 };

package/src/components/MarkdownEditor/MarkdownEditor.tsx

@@ -6,20 +6,20 @@ import { type Extension } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
 import { type Atom } from '@effect-atom/atom-react';
 import { createContext } from '@radix-ui/react-context';
-import React, { type PropsWithChildren, useMemo, useState } from 'react';
+import React, { type ReactNode, useCallback, useMemo, useState } from 'react';
 import { createPortal } from 'react-dom';
 
 import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 import { Obj } from '@dxos/echo';
 import { DXN } from '@dxos/keys';
 import { useClient } from '@dxos/react-client';
 import { type ThemedClassName } from '@dxos/react-ui';
 import {
-  EditorMenuProvider,
+  type EditorRootProps,
   type EditorToolbarState,
-  type UseEditorMenu,
-  useEditorMenu,
-  useEditorToolbar,
+  createEditorController,
+  useEditorContext,
 } from '@dxos/react-ui-editor';
 import { type PreviewBlock, type PreviewOptions } from '@dxos/ui-editor';
 import { composable, composableProps } from '@dxos/ui-theme';
@@ -31,7 +31,7 @@ import {
   type UseEditorMenuOptionsProps,
   useEditorMenuOptions,
   useExtensions,
-} from '../../hooks';
+} from '#hooks';
 
 import {
   MarkdownEditorContent as NaturalMarkdownEditorContent,
@@ -49,34 +49,34 @@ import {
 type MarkdownEditorContextValue = {
   id: string;
   attendableId?: string;
-  setEditorView: (view: EditorView) => void;
-  extensions: Extension[];
   previewBlocks: PreviewBlock[];
-  toolbarState: Atom.Writable<EditorToolbarState>;
-  popoverMenu: Omit<UseEditorMenu, 'extension'>;
-} & (Pick<ExtensionsOptions, 'compact' | 'viewMode'> &
-  Pick<NaturalMarkdownToolbarProps, 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange'>);
+} & Pick<ExtensionsOptions, 'compact' | 'viewMode'> &
+  Pick<NaturalMarkdownToolbarProps, 'onAction' | 'onFileUpload' | 'onViewModeChange'>;
 
 const [MarkdownEditorContextProvider, useMarkdownEditorContext] =
   createContext<MarkdownEditorContextValue>('MarkdownEditor.Context');
 
+/**
+ * Props to spread onto `Editor.Root` from `MarkdownEditorProvider`'s render callback.
+ */
+export type MarkdownEditorEditorRootProps = Omit<EditorRootProps, 'children'>;
+
 //
-// MarkdownEditor.Root
+// MarkdownEditorProvider
 //
 
-type MarkdownEditorRootProps = PropsWithChildren<
-  {
-    object?: DocumentType;
-    extensions?: Extension[];
-  } & Pick<
-    MarkdownEditorContextValue,
-    'id' | 'attendableId' | 'viewMode' | 'compact' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
-  > &
-    Pick<UseEditorMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
-    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings' | 'onSelectObject'>
->;
-
-const MarkdownEditorRoot = ({
+export type MarkdownEditorProviderProps = {
+  object?: DocumentType;
+  extensions?: Extension[];
+  children: (editorRootProps: MarkdownEditorEditorRootProps) => ReactNode;
+} & Pick<
+  MarkdownEditorContextValue,
+  'id' | 'attendableId' | 'viewMode' | 'compact' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
+> &
+  Pick<UseEditorMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
+  Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings' | 'onSelectObject'>;
+
+export const MarkdownEditorProvider = ({
   children,
   id,
   attendableId,
@@ -90,10 +90,10 @@ const MarkdownEditorRoot = ({
   slashCommandGroups,
   onLinkQuery,
   onSelectObject,
-  ...props
-}: MarkdownEditorRootProps) => {
-  const [editorView, setEditorView] = useState<EditorView>();
-
+  onAction,
+  onFileUpload,
+  onViewModeChange,
+}: MarkdownEditorProviderProps) => {
   // Preview blocks.
   const [previewBlocks, setPreviewBlocks] = useState<PreviewBlock[]>([]);
   const previewOptions = useMemo<PreviewOptions>(
@@ -109,14 +109,10 @@ const MarkdownEditorRoot = ({
     [object],
   );
 
-  // Toolbar state.
-  const toolbarState = useEditorToolbar({ viewMode });
-
-  // Context menu.
-  const menuOptions = useEditorMenuOptions({ editorView, slashCommandGroups, onLinkQuery });
-  const { extension: menuExtension, ...menuProps } = useEditorMenu(menuOptions);
+  // Context menu options (Editor.Root calls useEditorMenu with these props).
+  const menuOptions = useEditorMenuOptions({ slashCommandGroups, onLinkQuery });
 
-  // Extensions.
+  // Core markdown extensions (popover/menu extension is added by Editor.Root).
   const coreExtensions = useExtensions({
     id,
     object,
@@ -130,67 +126,85 @@ const MarkdownEditorRoot = ({
   });
 
   const extensions = useMemo(
-    () => [coreExtensions, menuExtension, extensionsProp].filter(isNonNullable),
-    [coreExtensions, menuExtension, extensionsProp],
+    () => [coreExtensions, extensionsProp].filter(isNonNullable).flat(),
+    [coreExtensions, extensionsProp],
+  );
+
+  const editorRootProps = useMemo<MarkdownEditorEditorRootProps>(
+    () => ({
+      extensions,
+      viewMode,
+      getMenu: menuOptions.getMenu,
+      trigger: menuOptions.trigger,
+      placeholder: menuOptions.placeholder,
+      ...(menuOptions.filter !== undefined ? { filter: menuOptions.filter } : {}),
+      ...(menuOptions.triggerKey !== undefined ? { triggerKey: menuOptions.triggerKey } : {}),
+    }),
+    [extensions, viewMode, menuOptions],
+  );
+
+  const markdownContextValue = useMemo<MarkdownEditorContextValue>(
+    () => ({
+      id,
+      attendableId,
+      compact,
+      viewMode,
+      previewBlocks,
+      onAction,
+      onFileUpload,
+      onViewModeChange,
+    }),
+    [id, attendableId, compact, viewMode, previewBlocks, onAction, onFileUpload, onViewModeChange],
   );
 
   return (
-    <MarkdownEditorContextProvider
-      id={id}
-      attendableId={attendableId}
-      compact={compact}
-      editorView={editorView}
-      setEditorView={setEditorView}
-      extensions={extensions}
-      previewBlocks={previewBlocks}
-      toolbarState={toolbarState}
-      popoverMenu={menuProps}
-      viewMode={viewMode}
-      {...props}
-    >
-      {children}
-    </MarkdownEditorContextProvider>
+    <MarkdownEditorContextProvider {...markdownContextValue}>{children(editorRootProps)}</MarkdownEditorContextProvider>
   );
 };
 
-MarkdownEditorRoot.displayName = 'MarkdownEditor.Root';
+MarkdownEditorProvider.displayName = 'MarkdownEditor.Provider';
 
 //
-// MarkdownEditor.Main
+// MarkdownEditor.Content
 //
 
 const MARKDOWN_EDITOR_CONTENT_NAME = 'MarkdownEditor.Content';
 
 type MarkdownEditorContentProps = Omit<NaturalMarkdownEditorContentProps, 'id' | 'extensions' | 'toolbarState'>;
 
-const MarkdownEditorContent = composable<HTMLDivElement, MarkdownEditorContentProps>(({ ...props }, _forwardedRef) => {
-  const {
-    id,
-    attendableId,
-    compact,
-    editorView,
-    setEditorView,
-    viewMode,
-    toolbarState,
-    extensions,
-    popoverMenu: { groupsRef, ...menuProps },
-  } = useMarkdownEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
+const MarkdownEditorContent = composable<HTMLDivElement, MarkdownEditorContentProps>(
+  ({ compact: compactProp, ...props }, _forwardedRef) => {
+    const {
+      id,
+      attendableId,
+      compact = compactProp,
+      viewMode,
+      onFileUpload,
+    } = useMarkdownEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
+    const { extensions, setController, state } = useEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
+
+    const handleRef = useCallback(
+      (view: EditorView | null) => {
+        setController(createEditorController(view));
+      },
+      [setController],
+    );
 
-  return (
-    <EditorMenuProvider view={editorView} groups={groupsRef.current} {...menuProps}>
+    return (
       <NaturalMarkdownEditorContent
         {...composableProps(props)}
         id={id}
         attendableId={attendableId}
         compact={compact}
         viewMode={viewMode}
-        toolbarState={toolbarState}
+        toolbarState={state as Atom.Writable<EditorToolbarState>}
         extensions={extensions}
-        ref={setEditorView}
+        onFileUpload={onFileUpload}
+        ref={handleRef}
       />
-    </EditorMenuProvider>
-  );
-});
+    );
+  },
+);
 
 MarkdownEditorContent.displayName = MARKDOWN_EDITOR_CONTENT_NAME;
 
@@ -201,19 +215,20 @@ MarkdownEditorContent.displayName = MARKDOWN_EDITOR_CONTENT_NAME;
 const MARKDOWN_EDITOR_TOOLBAR_NAME = 'MarkdownEditor.Toolbar';
 
 type MarkdownEditorToolbarProps = ThemedClassName<
-  Omit<NaturalMarkdownToolbarProps, 'state' | 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'id'>
+  Omit<NaturalMarkdownToolbarProps, 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'id'>
 >;
 
 const MarkdownEditorToolbar = (props: MarkdownEditorToolbarProps) => {
-  const { id, attendableId, editorView, toolbarState, onAction, onFileUpload, onViewModeChange } =
+  const { id, attendableId, onAction, onFileUpload, onViewModeChange } =
     useMarkdownEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
 
+  const { controller } = useEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
+
   return (
     <NaturalMarkdownToolbar
       {...props}
       id={attendableId ?? id}
-      editorView={editorView}
-      state={toolbarState}
+      editorView={controller?.view ?? undefined}
       onAction={onAction}
       onFileUpload={onFileUpload}
       onViewModeChange={onViewModeChange}
@@ -251,23 +266,21 @@ const PreviewBlock = ({ el, link }: PreviewBlock) => {
   const subject = client.graph.makeRef(dxn).target;
   const data = useMemo(() => ({ subject }), [subject]);
 
-  return createPortal(<Surface.Surface role='card--content' data={data} limit={1} />, el);
+  return createPortal(<Surface.Surface type={AppSurface.Card} data={data} limit={1} />, el);
 };
 
 //
 // MarkdownEditor
 //
 
+/** @private */
 export const MarkdownEditor = {
-  Root: MarkdownEditorRoot,
   Content: MarkdownEditorContent,
   Toolbar: MarkdownEditorToolbar,
   Blocks: MarkdownEditorBlocks,
 };
 
-export type {
-  MarkdownEditorRootProps,
-  MarkdownEditorContentProps,
-  MarkdownEditorToolbarProps,
-  MarkdownEditorBlocksProps,
-};
+export type { MarkdownEditorContentProps, MarkdownEditorToolbarProps, MarkdownEditorBlocksProps };
+
+/** @deprecated Use `MarkdownEditorProviderProps`. */
+export type MarkdownEditorRootProps = MarkdownEditorProviderProps;

package/src/components/MarkdownEditor/MarkdownEditorContent.tsx

@@ -17,9 +17,8 @@ import {
 import {
   type EditorSelectionState,
   type EditorStateStore,
-  type EditorViewMode,
   type ThemeExtensionsOptions,
-  compactSlots,
+  mobileSlots,
   createBasicExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
@@ -27,13 +26,14 @@ import {
   documentSlots,
   formattingListener,
   processEditorPayload,
-  stackItemContentEditorClassNames,
+  editorClassNames,
 } from '@dxos/ui-editor';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
 import { mx } from '@dxos/ui-theme';
 import { isTruthy } from '@dxos/util';
 
-import { meta } from '../../meta';
-import { MarkdownCapabilities } from '../../types';
+import { meta } from '#meta';
+import { MarkdownCapabilities } from '#types';
 
 import { type MarkdownEditorToolbarProps } from './MarkdownEditorToolbar';
 
@@ -52,6 +52,7 @@ export type MarkdownEditorContentProps = ThemedClassName<{
   Pick<MarkdownEditorToolbarProps, 'onFileUpload'> &
   Pick<ThemeExtensionsOptions, 'slots'>;
 
+// TODO(burdon): Move controller to Root.
 export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEditorContentProps>(
   (
     {
@@ -87,8 +88,6 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
     // Restore last selection and scroll point.
     const { scrollTo, selection } = useMemo<EditorSelectionState>(() => editorStateStore?.getState(id) ?? {}, [id]);
 
-    console.log(slots, compact, compactSlots);
-
     const {
       parentRef,
       view: editorView,
@@ -99,21 +98,19 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
           id,
           scrollTo,
           selection,
-          // TODO(wittjosiah): Autofocus based on layout is racy.
-          // autoFocus: layoutPlugin?.provides.layout ? layoutPlugin?.provides.layout.scrollIntoView === id : true,
           selectionEnd: true,
         }),
         initialValue,
         extensions: [
           createBasicExtensions({
             readOnly: viewMode === 'readonly',
-            placeholder: t('editor placeholder'),
+            placeholder: t('editor.placeholder'),
             scrollPastEnd: !compact,
             search: true,
           }),
           createThemeExtensions({
             themeMode,
-            slots: slots ?? (compact ? compactSlots : documentSlots),
+            slots: slots ?? (compact ? mobileSlots : documentSlots),
             syntaxHighlighting: true,
           }),
           createMarkdownExtensions(),
@@ -133,7 +130,7 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
           extensions,
         ].filter(isTruthy),
       }),
-      [id, viewMode, themeMode, extensions],
+      [id, viewMode, themeMode, extensions, compact],
     );
 
     useImperativeHandle<EditorView | null, EditorView | null>(forwardedRef, () => editorView, [editorView]);
@@ -151,10 +148,9 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
     return (
       <div
         {...focusAttributes}
-        role='none'
+        className={mx(editorClassNames(role), classNames)}
         data-testid='composer.markdownRoot'
         data-popover-collision-boundary={true}
-        className={mx(stackItemContentEditorClassNames(role), classNames)}
         ref={parentRef}
       />
     );