@dxos/plugin-markdown 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

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/{MarkdownContainer/MarkdownContainer.stories.tsx → MarkdownArticle/MarkdownArticle.stories.tsx}

@@ -10,29 +10,38 @@ 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';
-import { PreviewPlugin } from '@dxos/plugin-preview';
+import { DXN } from '@dxos/keys';
+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 { faker } from '@dxos/random';
-import { useQuery, useSpace } from '@dxos/react-client/echo';
+import { random } from '@dxos/random';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
-import { withLayout, withTheme } from '@dxos/react-ui/testing';
 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';
-import { translations } from '../../translations';
-import { Markdown, MarkdownCapabilities, MarkdownEvents } from '../../types';
 
-faker.seed(1);
+random.seed(1);
 
-const generator: ValueGenerator = faker as any;
+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(
+const MarkdownExtensionsPlugin = Plugin.define(
+  Plugin.makeMeta({
+    key: DXN.make('org.dxos.plugin.markdown.story.markdownExtensions'),
+    name: 'Story Extensions',
+  }),
+).pipe(
   Plugin.addModule({
     id: 'extensions',
     activatesOn: MarkdownEvents.SetupExtensions,
@@ -43,10 +52,10 @@ const MarkdownExtensionsPlugin = Plugin.define({ id: 'story-markdown-extensions'
 
 const DefaultStory = () => {
   const { invokePromise } = useOperationInvoker();
-  const space = useSpace();
+  const [space] = useSpaces();
   const [doc] = useQuery(space?.db, Query.type(Markdown.Document));
-  const data = useMemo(() => ({ subject: doc }), [doc]);
-  const id = doc && Obj.getDXN(doc).toString();
+  const id = doc && Obj.getURI(doc);
+  const data = useMemo(() => ({ subject: doc, attendableId: id ?? 'story' }), [doc, id]);
   const attentionAttrs = useAttentionAttributes(id);
 
   useAsyncEffect(async () => {
@@ -57,16 +66,15 @@ const DefaultStory = () => {
 
   return (
     <div className='contents' {...attentionAttrs}>
-      <Surface.Surface role='article' data={data} limit={1} />
+      <Surface.Surface type={AppSurface.Article} data={data} limit={1} />
     </div>
   );
 };
 
 const meta = {
-  title: 'plugins/plugin-markdown/containers/MarkdownContainer',
+  title: 'plugins/plugin-markdown/containers/MarkdownArticle',
   render: DefaultStory,
   decorators: [
-    withTheme(),
     withLayout({ layout: 'column' }),
     withPluginManager<{ title?: string; content?: string }>((context) => ({
       setupEvents: [AppActivationEvents.SetupSettings, MarkdownEvents.SetupExtensions],
@@ -78,20 +86,17 @@ const meta = {
           types: [Markdown.Document, Text.Text, Person.Person, Organization.Organization],
           onClientInitialized: ({ client }) =>
             Effect.gen(function* () {
-              yield* Effect.promise(() => client.halo.createIdentity());
-              yield* Effect.promise(() => client.spaces.waitUntilReady());
-              yield* Effect.promise(() => client.spaces.default.waitUntilReady());
+              const { personalSpace } = yield* initializeIdentity(client);
 
-              const space = client.spaces.default;
-              const createObjects = createObjectFactory(space.db, generator);
+              const createObjects = createObjectFactory(personalSpace.db, generator);
               yield* Effect.promise(() => createObjects([{ type: Organization.Organization, count: 10 }]));
 
-              const queue = space.queues.create();
+              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]));
 
-              space.db.add(
+              personalSpace.db.add(
                 Markdown.make({
                   name: context.args.title ?? 'Testing',
                   content: [
@@ -99,8 +104,8 @@ const meta = {
                     context.args.content ?? '',
                     // TODO(burdon): Popovers not currently working.
                     '## Here are some objects',
-                    `![Alice](${Obj.getDXN(kai)})`,
-                    `![DXOS](${Obj.getDXN(dxos)})`,
+                    `![Alice](${Obj.getURI(kai)})`,
+                    `![DXOS](${Obj.getURI(dxos)})`,
                     '',
                     'END',
                     '',
@@ -108,7 +113,7 @@ const meta = {
                 }),
               );
 
-              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
             }),
         }),
 

package/src/containers/MarkdownArticle/MarkdownArticle.tsx

@@ -0,0 +1,146 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import { Atom } from '@effect-atom/atom-react';
+import React, { forwardRef, useCallback, useMemo } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { AppSurface, useAppGraph } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { useActionRunner } from '@dxos/plugin-graph';
+import { useObject } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { type SelectionManager } from '@dxos/react-ui-attention';
+import { Editor } from '@dxos/react-ui-editor';
+import { Text } from '@dxos/schema';
+
+import {
+  MarkdownEditor,
+  MarkdownEditorProvider,
+  type MarkdownEditorContentProps,
+  type MarkdownEditorProviderProps,
+} from '#components';
+import { useLinkQuery } from '#hooks';
+import { Markdown, MarkdownCapabilities, type MarkdownPluginState } from '#types';
+
+export type MarkdownArticleProps = AppSurface.ObjectArticleProps<
+  Markdown.Document | Text.Text,
+  {
+    id: string;
+    settings: Markdown.Settings;
+    selectionManager?: SelectionManager;
+  } & Pick<MarkdownPluginState, 'extensionProviders'> &
+    Pick<MarkdownEditorProviderProps, 'viewMode' | 'onSelectObject' | 'onViewModeChange'> &
+    Pick<MarkdownEditorContentProps, 'editorStateStore'>
+>;
+
+export const MarkdownArticle = forwardRef<HTMLDivElement, MarkdownArticleProps>(
+  (
+    { role, subject: object, id, attendableId, settings, extensionProviders, onSelectObject, viewMode, ...props },
+    forwardedRef,
+  ) => {
+    const db = Obj.isObject(object) ? Obj.getDatabase(object) : undefined;
+    const [docContent] = useObject(Obj.instanceOf(Markdown.Document, object) ? object.content : undefined, 'content');
+    const [textContent] = useObject(Obj.instanceOf(Text.Text, object) ? object : undefined, 'content');
+    const initialValue = docContent ?? textContent;
+
+    // Extensions from other plugins.
+    const otherExtensionProviders = useCapabilities(MarkdownCapabilities.Extensions);
+    const extensions = useMemo<Extension[]>(() => {
+      if (!Obj.instanceOf(Markdown.Document, object) && !Obj.instanceOf(Text.Text, object)) {
+        return [];
+      }
+
+      const document = Obj.instanceOf(Markdown.Document, object) ? object : undefined;
+      return [...(otherExtensionProviders ?? []), ...(extensionProviders ?? [])]
+        .flat()
+        .reduce((acc: Extension[], provider) => {
+          const extension = typeof provider === 'function' ? provider({ document, viewMode }) : provider;
+          if (extension) {
+            acc.push(extension);
+          }
+
+          return acc;
+        }, []);
+    }, [extensionProviders, otherExtensionProviders, object, viewMode]);
+
+    // Toolbar actions from app graph.
+    const { graph } = useAppGraph();
+    const runAction = useActionRunner();
+    const customActions = useMemo(() => {
+      return Atom.make((get) => {
+        const actions = get(graph.actions(attendableId ?? id));
+        const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
+        const edges = nodes.map((node) => ({ source: 'root', target: node.id, relation: 'child' }));
+        return { nodes, edges };
+      });
+    }, [graph]);
+
+    // File upload.
+    const [upload] = useCapabilities(AppCapabilities.FileUploader);
+    const handleFileUpload = useMemo(() => {
+      if (!db || !upload) {
+        return undefined;
+      }
+
+      return async (file: File) => upload(db, file);
+    }, [db, upload]);
+
+    // Query for @ refs.
+    const handleLinkQuery = useLinkQuery(db);
+
+    // Open linked objects.
+    const { invokePromise } = useOperationInvoker();
+    const handleSelectObject = useCallback(
+      (targetId: string) => {
+        if (onSelectObject) {
+          onSelectObject(targetId);
+        } else {
+          void invokePromise?.(LayoutOperation.Open, {
+            subject: [targetId],
+            pivotId: attendableId,
+            // TODO(wittjosiah): This should probably pre-validate.
+            navigation: 'immediate',
+          });
+        }
+      },
+      [onSelectObject, invokePromise, attendableId],
+    );
+
+    return (
+      <MarkdownEditorProvider
+        id={id}
+        attendableId={attendableId}
+        object={object}
+        compact={role !== 'article'}
+        extensions={extensions}
+        settings={settings}
+        viewMode={viewMode}
+        onAction={runAction}
+        onFileUpload={handleFileUpload}
+        onLinkQuery={handleLinkQuery}
+        onSelectObject={handleSelectObject}
+        {...props}
+      >
+        {(editorRootProps) => (
+          <Editor.Root {...editorRootProps}>
+            <Panel.Root role={role} ref={forwardedRef}>
+              {settings.toolbar && (
+                <Panel.Toolbar classNames='bg-toolbar-surface'>
+                  <MarkdownEditor.Toolbar classNames='dx-document' customActions={customActions} />
+                </Panel.Toolbar>
+              )}
+              <Panel.Content>
+                <MarkdownEditor.Content initialValue={initialValue} />
+                <MarkdownEditor.Blocks />
+              </Panel.Content>
+            </Panel.Root>
+          </Editor.Root>
+        )}
+      </MarkdownEditorProvider>
+    );
+  },
+);

package/src/containers/MarkdownArticle/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { MarkdownArticle, type MarkdownArticleProps } from './MarkdownArticle';
+export { MarkdownArticle as default } from './MarkdownArticle';

package/src/containers/MarkdownCard/MarkdownCard.stories.tsx

@@ -5,28 +5,28 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useMemo } from 'react';
 
-import { OperationPlugin, RuntimePlugin } from '@dxos/app-framework';
+import { ProcessManagerPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Obj } from '@dxos/echo';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { Markdown } from '@dxos/plugin-markdown/types';
-import { faker } from '@dxos/random';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { Markdown } from '@dxos/plugin-markdown';
+import { random } from '@dxos/random';
 import { Card } from '@dxos/react-ui';
-import { withTheme } from '@dxos/react-ui/testing';
 import { CardContainer } from '@dxos/react-ui-mosaic/testing';
+import { withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { translations } from '#translations';
 
 import { MarkdownCard, type MarkdownCardProps } from './MarkdownCard';
 
-faker.seed(1234);
+random.seed(1234);
 
 const MarkdownCardStory = ({ ...args }: Omit<MarkdownCardProps, 'subject'>) => {
   const subject = useMemo(
     () =>
       Markdown.make({
-        name: faker.lorem.words(3),
-        content: faker.lorem.paragraphs(5),
+        name: random.lorem.words(3),
+        content: '# Title\n' + random.lorem.paragraphs(5),
       }),
     [],
   );
@@ -34,11 +34,11 @@ const MarkdownCardStory = ({ ...args }: Omit<MarkdownCardProps, 'subject'>) => {
   return (
     <CardContainer icon='ph--text-aa--regular'>
       <Card.Root border={false}>
-        <Card.Toolbar>
+        <Card.Header>
           <Card.DragHandle />
           <Card.Title>{Obj.getLabel(subject)}</Card.Title>
           <Card.Menu />
-        </Card.Toolbar>
+        </Card.Header>
         <MarkdownCard subject={subject} {...args} />
       </Card.Root>
     </CardContainer>
@@ -51,7 +51,7 @@ const meta: Meta<typeof MarkdownCardStory> = {
   decorators: [
     withTheme(),
     withPluginManager({
-      plugins: [OperationPlugin(), RuntimePlugin(), ClientPlugin({})],
+      plugins: [ProcessManagerPlugin(), ClientPlugin({})],
     }),
   ],
   parameters: {

package/src/containers/MarkdownCard/MarkdownCard.tsx

@@ -5,53 +5,67 @@
 import React, { useMemo } from 'react';
 
 import { Obj } from '@dxos/echo';
-import { useTranslation } from '@dxos/react-ui';
-import { Card } from '@dxos/react-ui';
+import { Card, useTranslation } from '@dxos/react-ui';
+import { Editor } from '@dxos/react-ui-editor';
 import { Text } from '@dxos/schema';
+import { mx } from '@dxos/ui-theme';
+
+import { MarkdownEditor, MarkdownEditorProvider } from '#components';
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
-import { MarkdownEditor } from '../../components';
-import { meta } from '../../meta';
-import { Markdown } from '../../types';
 import { getContentSnippet } from '../../util';
+import { snippet as snippetExtension } from './snippet';
 
 export type MarkdownCardProps = { subject: Markdown.Document | Text.Text };
 
 export const MarkdownCard = ({ subject }: MarkdownCardProps) => {
   const { t } = useTranslation(meta.id);
   const snippet = useMemo(() => getSnippet(subject), [subject]);
+  const extensions = useMemo(() => [snippetExtension({ height: 300, scale: 0.8 })], []);
   const info = getInfo(subject);
 
   return (
-    <Card.Content>
+    <Card.Body>
       {snippet && (
-        <Card.Section>
-          <MarkdownEditor.Root id={subject.id} viewMode='readonly'>
-            <MarkdownEditor.Content
-              initialValue={snippet}
-              classNames='bg-transparent'
-              slots={{
-                editor: { className: 'max-h-[240px]' },
-              }}
-            />
-          </MarkdownEditor.Root>
+        <Card.Section className='relative'>
+          <Card.Row fullWidth>
+            <MarkdownEditorProvider id={subject.id} viewMode='readonly' extensions={extensions}>
+              {(editorRootProps) => (
+                <Editor.Root {...editorRootProps}>
+                  <MarkdownEditor.Content initialValue={snippet} slots={{ content: { className: 'px-2!' } }} />
+                </Editor.Root>
+              )}
+            </MarkdownEditorProvider>
+            <Fade />
+          </Card.Row>
         </Card.Section>
       )}
       <Card.Section>
-        <Card.Text classNames='text-xs text-description'>
-          {info.words} {t('words label', { count: info.words })}
-        </Card.Text>
+        <Card.Row fullWidth>
+          <Card.Text classNames='px-2 text-xs text-description'>
+            {info.words} {t('words.label', { count: info.words })}
+          </Card.Text>
+        </Card.Row>
       </Card.Section>
-    </Card.Content>
+    </Card.Body>
   );
 };
 
-const MAX_LINES = 5;
+const Fade = () => (
+  <div
+    className={mx(
+      'z-10 absolute bottom-0 inset-x-0 h-12 w-full',
+      'bg-gradient-to-b from-transparent to-(--surface-bg) pointer-events-none',
+    )}
+  />
+);
 
-const getSnippet = (subject: Markdown.Document | Text.Text, fallback?: string) => {
+const getSnippet = (subject: Markdown.Document | Text.Text, fallback?: string, maxLines = 16) => {
   if (Obj.instanceOf(Markdown.Document, subject)) {
-    return Obj.getDescription(subject) || getContentSnippet(subject.content?.target?.content ?? fallback, MAX_LINES);
+    return Obj.getDescription(subject) || getContentSnippet(subject.content?.target?.content ?? fallback, maxLines);
   } else if (Obj.instanceOf(Text.Text, subject)) {
-    return getContentSnippet(subject.content ?? fallback, MAX_LINES);
+    return getContentSnippet(subject.content ?? fallback, maxLines);
   }
 };
 

package/src/containers/MarkdownCard/index.ts

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

package/src/containers/MarkdownCard/snippet.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+
+export type SnippetOptions = {
+  /** Maximum height of the editor in pixels. Overflowing content is hidden. */
+  height: number;
+  /** Zoom factor applied to the editor (e.g. 0.5 renders at 50%). @default 1 */
+  scale?: number;
+};
+
+/**
+ * CodeMirror extension for rendering a non-scrollable snippet of editor content.
+ * Constrains the editor to the given height via CSS `max-height`, wraps long
+ * lines (`pre-wrap`), and disables scrolling entirely.
+ *
+ * NOTE: Uses CSS `zoom` rather than `transform: scale` because `zoom` affects
+ * layout, so line wrapping fills the full visual width of the container.
+ * `transform: scale` only scales paint output, leaving empty space on the right.
+ */
+export const snippet = ({ height, scale = 1 }: SnippetOptions) => {
+  return [
+    EditorState.readOnly.of(true),
+    EditorView.editable.of(false),
+    EditorState.transactionFilter.of((tr) => {
+      if (tr.selection) {
+        return [];
+      } // Drop any selection changes.
+      return tr;
+    }),
+    EditorView.theme({
+      // Outer editor element: clip to the caller-specified height.
+      '&': {
+        maxHeight: `${height}px`,
+        overflow: 'hidden',
+      },
+      '.cm-scroller': {
+        // Prevent scroll; scale up the inner clip so the final pixel height matches `height`.
+        maxHeight: `${height / scale}px`,
+        overflow: 'hidden !important',
+        padding: '0',
+      },
+      '.cm-content': {
+        // zoom (unlike transform: scale) affects layout, so line-wrapping fills the full visual width of the container.
+        zoom: scale,
+        margin: '0',
+        padding: '0',
+      },
+    }),
+  ];
+};

package/src/containers/index.ts

@@ -4,8 +4,8 @@
 
 import { type ComponentType, lazy } from 'react';
 
-export type { MarkdownContainerProps } from './MarkdownContainer/MarkdownContainer';
+export type { MarkdownArticleProps } from './MarkdownArticle';
 
 export const MarkdownCard: ComponentType<any> = lazy(() => import('./MarkdownCard'));
-export const MarkdownContainer: ComponentType<any> = lazy(() => import('./MarkdownContainer'));
-export const MarkdownSettings: ComponentType<any> = lazy(() => import('./MarkdownSettings'));
+export const EditableMarkdownCard: ComponentType<any> = lazy(() => import('./EditableMarkdownCard'));
+export const MarkdownArticle: ComponentType<any> = lazy(() => import('./MarkdownArticle'));

package/src/hooks/index.ts

@@ -5,4 +5,3 @@
 export * from './useEditorMenuOptions';
 export * from './useExtensions';
 export * from './useLinkQuery';
-export * from './useSelectCurrentThread';