@dxos/plugin-markdown 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/src/components/MarkdownEditor/MarkdownEditorContent.tsx

@@ -0,0 +1,169 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import { type Atom, RegistryContext } from '@effect-atom/atom-react';
+import React, { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo } from 'react';
+
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { type ThemedClassName, useThemeContext, useTranslation } from '@dxos/react-ui';
+import {
+  type EditorMenuGroup,
+  type EditorToolbarState,
+  type UseTextEditorProps,
+  useTextEditor,
+} from '@dxos/react-ui-editor';
+import {
+  type EditorSelectionState,
+  type EditorStateStore,
+  type ThemeExtensionsOptions,
+  mobileSlots,
+  createBasicExtensions,
+  createMarkdownExtensions,
+  createThemeExtensions,
+  dropFile,
+  documentSlots,
+  formattingListener,
+  processEditorPayload,
+  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 { type MarkdownEditorToolbarProps } from './MarkdownEditorToolbar';
+
+export type MarkdownEditorContentProps = ThemedClassName<{
+  id: string;
+  attendableId?: string;
+  role?: string;
+  compact?: boolean;
+  viewMode?: EditorViewMode;
+  slashCommandGroups?: EditorMenuGroup[];
+  editorStateStore?: EditorStateStore;
+  toolbarState?: Atom.Writable<EditorToolbarState>;
+  onLinkQuery?: (query?: string) => Promise<EditorMenuGroup[]>;
+}> &
+  Pick<UseTextEditorProps, 'initialValue' | 'extensions'> &
+  Pick<MarkdownEditorToolbarProps, 'onFileUpload'> &
+  Pick<ThemeExtensionsOptions, 'slots'>;
+
+// TODO(burdon): Move controller to Root.
+export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEditorContentProps>(
+  (
+    {
+      classNames,
+      id,
+      attendableId,
+      role,
+      compact,
+      viewMode,
+      initialValue,
+      editorStateStore,
+      toolbarState,
+      extensions,
+      slots,
+      onFileUpload,
+    },
+    forwardedRef,
+  ) => {
+    const { t } = useTranslation(meta.id);
+    const { themeMode } = useThemeContext();
+    const registry = useContext(RegistryContext);
+
+    // Callback to update toolbar state atom.
+    const updateToolbarState = useCallback(
+      (formatting: EditorToolbarState) => {
+        if (toolbarState) {
+          registry.set(toolbarState, { ...registry.get(toolbarState), ...formatting });
+        }
+      },
+      [registry, toolbarState],
+    );
+
+    // Restore last selection and scroll point.
+    const { scrollTo, selection } = useMemo<EditorSelectionState>(() => editorStateStore?.getState(id) ?? {}, [id]);
+
+    const {
+      parentRef,
+      view: editorView,
+      focusAttributes,
+    } = useTextEditor(
+      () => ({
+        ...(role !== 'section' && {
+          id,
+          scrollTo,
+          selection,
+          selectionEnd: true,
+        }),
+        initialValue,
+        extensions: [
+          createBasicExtensions({
+            readOnly: viewMode === 'readonly',
+            placeholder: t('editor.placeholder'),
+            scrollPastEnd: !compact,
+            search: true,
+          }),
+          createThemeExtensions({
+            themeMode,
+            slots: slots ?? (compact ? mobileSlots : documentSlots),
+            syntaxHighlighting: true,
+          }),
+          createMarkdownExtensions(),
+          toolbarState && formattingListener(updateToolbarState),
+          role !== 'section' &&
+            onFileUpload &&
+            dropFile({
+              // TODO(wittjosiah): Factor out to file uploader plugin.
+              onDrop: async (view, { files }) => {
+                const file = files[0];
+                const info = file && onFileUpload ? await onFileUpload(file) : undefined;
+                if (info) {
+                  processEditorPayload(view, { type: 'image', data: info.url });
+                }
+              },
+            }),
+          extensions,
+        ].filter(isTruthy),
+      }),
+      [id, viewMode, themeMode, extensions, compact],
+    );
+
+    useImperativeHandle<EditorView | null, EditorView | null>(forwardedRef, () => editorView, [editorView]);
+
+    const [editorViewRegistry] = useCapabilities(MarkdownCapabilities.EditorViews);
+    useEffect(() => {
+      if (editorView && editorViewRegistry) {
+        editorViewRegistry.register(attendableId ?? id, editorView, id);
+        return () => editorViewRegistry.unregister(attendableId ?? id);
+      }
+    }, [editorView, editorViewRegistry, attendableId, id]);
+
+    useTest(editorView);
+
+    return (
+      <div
+        {...focusAttributes}
+        className={mx(editorClassNames(role), classNames)}
+        data-testid='composer.markdownRoot'
+        data-popover-collision-boundary={true}
+        ref={parentRef}
+      />
+    );
+  },
+);
+
+// Expose editor view for playwright tests.
+// TODO(wittjosiah): Find a better way to expose this or find a way to limit it to test runs.
+const useTest = (view: EditorView | null) => {
+  useEffect(() => {
+    const composer = (window as any).composer;
+    if (composer) {
+      composer.editorView = view;
+    }
+  }, [view]);
+};

package/src/components/MarkdownEditor/MarkdownEditorToolbar.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import React, { useCallback, useState } from 'react';
+
+import { type FileInfo } from '@dxos/app-toolkit';
+import { composable, composableProps } from '@dxos/react-ui';
+import { Editor, type EditorToolbarProps } from '@dxos/react-ui-editor';
+
+import { FileUpload, type FileUploadAction } from './FileUpload';
+
+export type MarkdownEditorToolbarProps = {
+  id: string;
+  editorView?: EditorView;
+  onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
+} & Pick<EditorToolbarProps, 'role' | 'customActions' | 'onAction' | 'onViewModeChange'>;
+
+export const MarkdownEditorToolbar = composable<HTMLDivElement, MarkdownEditorToolbarProps>(
+  ({ id, role, editorView, customActions, onAction, onFileUpload, onViewModeChange, ...props }, forwardedRef) => {
+    const { className, ...rest } = composableProps(props);
+    const [upload, setUpload] = useState<FileUploadAction | null>(null);
+    const uploadRef = useCallback((next: FileUploadAction) => setUpload(() => next), []);
+
+    if (!editorView) {
+      return <div className={className} {...rest} ref={forwardedRef} />;
+    }
+
+    return (
+      <div className='contents' ref={forwardedRef}>
+        <Editor.Toolbar
+          {...rest}
+          classNames={className}
+          attendableId={id}
+          role={role}
+          customActions={customActions}
+          onAction={onAction}
+          onImageUpload={upload ?? undefined}
+          onViewModeChange={onViewModeChange}
+        />
+
+        {onFileUpload && <FileUpload ref={uploadRef} editorView={editorView} onFileUpload={onFileUpload} />}
+      </div>
+    );
+  },
+);

package/src/components/MarkdownSettings/MarkdownSettings.stories.tsx

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { MarkdownSettings } from './MarkdownSettings';
+
+const meta = {
+  title: 'plugins/plugin-markdown/components/MarkdownSettings',
+  tags: ['settings'],
+  component: MarkdownSettings,
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof MarkdownSettings>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    settings: {
+      defaultViewMode: 'preview',
+      editorInputMode: 'default',
+      toolbar: true,
+      numberedHeadings: false,
+      folding: false,
+      experimental: false,
+      debug: false,
+    },
+  },
+};

package/src/components/MarkdownSettings/MarkdownSettings.tsx

@@ -4,105 +4,32 @@
 
 import React from 'react';
 
-import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { type EditorInputMode, EditorInputModes, type EditorViewMode, EditorViewModes } from '@dxos/react-ui-editor';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Input } from '@dxos/react-ui';
+import { Settings as SettingsForm, type SettingsFieldProps } from '@dxos/react-ui-form';
 
-import { meta } from '../../meta';
-import { type Markdown } from '../../types';
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
-export const MarkdownSettings = ({ settings }: { settings: Markdown.Settings }) => {
-  const { t } = useTranslation(meta.id);
+export type MarkdownSettingsProps = AppSurface.SettingsArticleProps<Markdown.Settings>;
 
-  // TODO(wittjosiah): Add skill test confirmation for entering vim mode.
-  return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
-          <ControlItemInput title={t('default view mode label')}>
-            <Select.Root
-              value={settings.defaultViewMode}
-              onValueChange={(value) => {
-                settings.defaultViewMode = value as EditorViewMode;
-              }}
-            >
-              <Select.TriggerButton />
-              <Select.Portal>
-                <Select.Content>
-                  <Select.Viewport>
-                    {EditorViewModes.map((mode) => (
-                      <Select.Option key={mode} value={mode}>
-                        {t(`${mode} mode label`, { ns: 'react-ui-editor' })}
-                      </Select.Option>
-                    ))}
-                  </Select.Viewport>
-                  <Select.Arrow />
-                </Select.Content>
-              </Select.Portal>
-            </Select.Root>
-          </ControlItemInput>
-
-          <ControlItemInput title={t('editor input mode label')}>
-            <Select.Root
-              value={settings.editorInputMode ?? 'default'}
-              onValueChange={(value) => {
-                settings.editorInputMode = value as EditorInputMode;
-              }}
-            >
-              <Select.TriggerButton placeholder={t('select editor input mode placeholder')} />
-              <Select.Portal>
-                <Select.Content>
-                  <Select.Viewport>
-                    {EditorInputModes.map((mode) => (
-                      <Select.Option key={mode} value={mode}>
-                        {t(`settings editor input mode ${mode} label`)}
-                      </Select.Option>
-                    ))}
-                  </Select.Viewport>
-                  <Select.Arrow />
-                </Select.Content>
-              </Select.Portal>
-            </Select.Root>
-          </ControlItemInput>
-
-          <ControlItemInput title={t('settings toolbar label')}>
-            <Input.Switch checked={settings.toolbar} onCheckedChange={(checked) => (settings.toolbar = !!checked)} />
-          </ControlItemInput>
-
-          <ControlItemInput title={t('settings numbered headings label')}>
-            <Input.Switch
-              checked={settings.numberedHeadings}
-              onCheckedChange={(checked) => (settings.numberedHeadings = !!checked)}
-            />
-          </ControlItemInput>
+const SnippetsField = ({ value, onChange, readonly }: SettingsFieldProps<string | undefined>) => (
+  <Input.TextArea disabled={readonly} rows={5} value={value ?? ''} onChange={(event) => onChange(event.target.value)} />
+);
 
-          <ControlItemInput title={t('settings folding label')}>
-            <Input.Switch checked={settings.folding} onCheckedChange={(checked) => (settings.folding = !!checked)} />
-          </ControlItemInput>
-
-          <ControlItemInput title={t('settings experimental label')}>
-            <Input.Switch
-              checked={settings.experimental}
-              onCheckedChange={(checked) => (settings.experimental = !!checked)}
-            />
-          </ControlItemInput>
-
-          <ControlItemInput title={t('settings debug label')}>
-            <Input.Switch checked={settings.debug} onCheckedChange={(checked) => (settings.debug = !!checked)} />
-          </ControlItemInput>
-
-          {settings.debug && (
-            <ControlItemInput title={t('settings debug textarea label', { ns: meta.id })}>
-              <Input.TextArea
-                rows={5}
-                value={settings.typewriter}
-                onChange={({ target: { value } }) => (settings.typewriter = value)}
-                placeholder={t('settings debug placeholder')}
-              />
-            </ControlItemInput>
-          )}
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+export const MarkdownSettings = ({ settings, onSettingsChange }: MarkdownSettingsProps) => {
+  return (
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={meta.name ?? 'Editor'}>
+        <SettingsForm.FieldSet
+          readonly={!onSettingsChange}
+          schema={Markdown.Settings}
+          visible={(path, values) => path !== 'snippets' || !!values.debug}
+          fieldMap={{ snippets: SnippetsField }}
+          values={settings}
+          onValuesChanged={(values) => onSettingsChange?.(() => values)}
+        />
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
   );
 };

package/src/components/MarkdownSettings/index.ts

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

package/src/components/index.ts

@@ -1,10 +1,9 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-import { lazy } from 'react';
+import { type ComponentType, lazy } from 'react';
 
-export * from './MarkdownSettings';
+export * from './MarkdownEditor';
 
-export const MarkdownContainer = lazy(() => import('./MarkdownContainer'));
-export const MarkdownCard = lazy(() => import('./MarkdownCard'));
+export const MarkdownSettings: ComponentType<any> = lazy(() => import('./MarkdownSettings'));

package/src/containers/EditableMarkdownCard/EditableMarkdownCard.stories.tsx

@@ -0,0 +1,86 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { ProcessManagerPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Filter, Obj } from '@dxos/echo';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Card } from '@dxos/react-ui';
+import { translations as editorTranslations } from '@dxos/react-ui-editor/translations';
+import { CardContainer } from '@dxos/react-ui-mosaic/testing';
+import { Loading, withTheme } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+
+import { translations } from '#translations';
+import { Markdown } from '#types';
+
+import { EditableMarkdownCard, type EditableMarkdownCardProps } from './EditableMarkdownCard';
+
+random.seed(1234);
+
+const EditableMarkdownCardStory = ({ ...args }: Omit<EditableMarkdownCardProps, 'subject'>) => {
+  const [space] = useSpaces();
+  const [doc] = useQuery(space?.db, Filter.type(Markdown.Document));
+  if (!doc) {
+    return <Loading data={{ space: !!space }} />;
+  }
+
+  return (
+    <CardContainer icon='ph--text-aa--regular'>
+      <Card.Root border={false}>
+        <Card.Header>
+          <Card.DragHandle />
+          <Card.Title>{Obj.getLabel(doc)}</Card.Title>
+          <Card.Menu />
+        </Card.Header>
+        <EditableMarkdownCard subject={doc} {...args} />
+      </Card.Root>
+    </CardContainer>
+  );
+};
+
+const meta: Meta<typeof EditableMarkdownCardStory> = {
+  title: 'plugins/plugin-markdown/containers/EditableMarkdownCard',
+  component: EditableMarkdownCardStory,
+  decorators: [
+    withTheme(),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ProcessManagerPlugin(),
+        ClientPlugin({
+          types: [Markdown.Document, Text.Text],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+              personalSpace.db.add(
+                Markdown.make({
+                  name: random.lorem.words(3),
+                  content: '# Title\n' + random.lorem.paragraphs(3),
+                }),
+              );
+            }),
+        }),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+    translations: [...translations, ...editorTranslations],
+  },
+  tags: ['cards'],
+};
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/EditableMarkdownCard/EditableMarkdownCard.tsx

@@ -0,0 +1,44 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React from 'react';
+
+import { Obj } from '@dxos/echo';
+import { useObject } from '@dxos/react-client/echo';
+import { Card } from '@dxos/react-ui';
+import { Editor } from '@dxos/react-ui-editor';
+import { Text } from '@dxos/schema';
+
+import { MarkdownEditor, MarkdownEditorProvider } from '#components';
+import { Markdown } from '#types';
+
+export type EditableMarkdownCardProps = { subject: Markdown.Document | Text.Text };
+
+/**
+ * Full-bleed editable variant of {@link MarkdownCard}. Activated by the host
+ * passing `editable: true` on the card surface data (e.g. plugin-board cells).
+ * Renders a plain editor (no app-graph toolbar / file upload / link queries)
+ * so it stays self-contained inside the card; the regular MarkdownArticle
+ * remains the canonical surface for full article views.
+ */
+export const EditableMarkdownCard = ({ subject }: EditableMarkdownCardProps) => {
+  const id = Obj.getURI(subject);
+  const [docContent] = useObject(Obj.instanceOf(Markdown.Document, subject) ? subject.content : undefined, 'content');
+  const [textContent] = useObject(Obj.instanceOf(Text.Text, subject) ? subject : undefined, 'content');
+  const initialValue = docContent ?? textContent;
+
+  return (
+    <Card.Section classNames='overflow-hidden'>
+      <Card.Row fullWidth>
+        <MarkdownEditorProvider id={id} object={subject} viewMode='source'>
+          {(editorRootProps) => (
+            <Editor.Root {...editorRootProps}>
+              <MarkdownEditor.Content compact initialValue={initialValue} />
+            </Editor.Root>
+          )}
+        </MarkdownEditorProvider>
+      </Card.Row>
+    </Card.Section>
+  );
+};

package/src/containers/EditableMarkdownCard/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { EditableMarkdownCard, type EditableMarkdownCardProps } from './EditableMarkdownCard';
+export { EditableMarkdownCard as default } from './EditableMarkdownCard';

package/src/containers/MarkdownArticle/MarkdownArticle.stories.tsx

@@ -0,0 +1,135 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React, { useMemo } from 'react';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Surface, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppActivationEvents, LayoutOperation } from '@dxos/app-toolkit';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj, Query } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { useAttentionAttributes } from '@dxos/react-ui-attention';
+import { withLayout } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { type ValueGenerator, createObjectFactory } from '@dxos/schema/testing';
+import { Organization, Person } from '@dxos/types';
+
+import { translations } from '#translations';
+import { Markdown, MarkdownCapabilities, MarkdownEvents } from '#types';
+
+import { MarkdownPlugin } from '../../MarkdownPlugin';
+
+random.seed(1);
+
+const generator: ValueGenerator = random as any;
+
+/** Minimal plugin that contributes an empty Extensions capability for stories. */
+const MarkdownExtensionsPlugin = Plugin.define({ id: 'story-markdown-extensions', name: 'Story Extensions' }).pipe(
+  Plugin.addModule({
+    id: 'extensions',
+    activatesOn: MarkdownEvents.SetupExtensions,
+    activate: () => Effect.succeed(Capability.contributes(MarkdownCapabilities.Extensions, [])),
+  }),
+  Plugin.make,
+);
+
+const DefaultStory = () => {
+  const { invokePromise } = useOperationInvoker();
+  const [space] = useSpaces();
+  const [doc] = useQuery(space?.db, Query.type(Markdown.Document));
+  const id = doc && Obj.getURI(doc);
+  const data = useMemo(() => ({ subject: doc, attendableId: id ?? 'story' }), [doc, id]);
+  const attentionAttrs = useAttentionAttributes(id);
+
+  useAsyncEffect(async () => {
+    if (space) {
+      await invokePromise(LayoutOperation.SwitchWorkspace, { subject: space.id });
+    }
+  }, [space, invokePromise]);
+
+  return (
+    <div className='contents' {...attentionAttrs}>
+      <Surface.Surface type={AppSurface.Article} data={data} limit={1} />
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-markdown/containers/MarkdownArticle',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'column' }),
+    withPluginManager<{ title?: string; content?: string }>((context) => ({
+      setupEvents: [AppActivationEvents.SetupSettings, MarkdownEvents.SetupExtensions],
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        MarkdownExtensionsPlugin(),
+        ClientPlugin({
+          types: [Markdown.Document, Text.Text, Person.Person, Organization.Organization],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+
+              const createObjects = createObjectFactory(personalSpace.db, generator);
+              yield* Effect.promise(() => createObjects([{ type: Organization.Organization, count: 10 }]));
+
+              const queue = personalSpace.queues.create();
+              const kai = Obj.make(Person.Person, { fullName: 'Kai' });
+              const dxos = Obj.make(Organization.Organization, { name: 'DXOS' });
+              yield* Effect.promise(() => queue.append([kai, dxos]));
+
+              personalSpace.db.add(
+                Markdown.make({
+                  name: context.args.title ?? 'Testing',
+                  content: [
+                    `# ${context.args.title ?? 'Testing'}`,
+                    context.args.content ?? '',
+                    // TODO(burdon): Popovers not currently working.
+                    '## Here are some objects',
+                    `![Alice](${Obj.getURI(kai)})`,
+                    `![DXOS](${Obj.getURI(dxos)})`,
+                    '',
+                    'END',
+                    '',
+                  ].join('\n\n'),
+                }),
+              );
+
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
+            }),
+        }),
+
+        MarkdownPlugin(),
+        PreviewPlugin(),
+      ],
+    })),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    controls: { disable: true },
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    title: 'Testing',
+    content: ['This is a line with **some** formatting.'].join('\n\n'),
+  },
+};