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

package/src/capabilities/{react-surface/react-surface.tsx → react-surface.tsx}

@@ -5,56 +5,76 @@
 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 ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
 import { Obj } from '@dxos/echo';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { AttentionCapabilities } from '@dxos/plugin-attention/types';
 import { Text } from '@dxos/schema';
 import { type EditorViewMode } from '@dxos/ui-editor';
 
-import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps, MarkdownSettings } from '../../components';
-import { meta } from '../../meta';
-import { Markdown, MarkdownCapabilities } from '../../types';
+import { MarkdownSettings } from '#components';
+import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps } 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 { 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()} 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),
-        component: ({ data, role }) => {
-          return <Container id={data.id} subject={data.subject} role={role} />;
+        // TODO(burdon): Why is attendableId required? See EventArticle.tsx
+        filter: (data): data is { attendableId: string; subject: Text.Text } =>
+          typeof data.attendableId === 'string' && Obj.instanceOf(Text.Text, data.subject),
+        component: ({ data, role, 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/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),
@@ -67,8 +87,8 @@ export default Capability.makeModule(() =>
 /**
  * Common wrapper.
  */
-const Container = forwardRef<HTMLDivElement, SurfaceComponentProps<Markdown.Document | Text.Text, { id: string }>>(
-  ({ id, subject, role }, forwardedRef) => {
+const Container = forwardRef<HTMLDivElement, ObjectSurfaceProps<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);
@@ -87,6 +107,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 → settings.ts}

@@ -4,11 +4,12 @@
 
 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';
-import { Markdown, MarkdownCapabilities } from '../../types';
+import { meta } from '#meta';
+import { Markdown, MarkdownCapabilities } from '#types';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {
@@ -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,

package/src/capabilities/state.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+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';
+
+const createEditorViewRegistry = (): EditorViewRegistry => {
+  const views = new Map<string, EditorViewEntry>();
+  return {
+    register: (attendableId, view, documentId) => {
+      views.set(attendableId, { view, documentId });
+    },
+    unregister: (attendableId) => {
+      views.delete(attendableId);
+    },
+    get: (attendableId) => views.get(attendableId),
+  };
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Persisted state using KVS store.
+    const stateAtom = createKvsStore({
+      key: `${meta.id}.state`,
+      schema: MarkdownStateSchema,
+      defaultValue: () => ({ viewMode: {} }),
+    });
+
+    // TODO(wittjosiah): Fold into state.
+    const editorState = createEditorStateStore(`${meta.id}.editor`);
+
+    const editorViews = createEditorViewRegistry();
+
+    return [
+      Capability.contributes(MarkdownCapabilities.State, stateAtom),
+      Capability.contributes(MarkdownCapabilities.EditorState, editorState),
+      Capability.contributes(MarkdownCapabilities.EditorViews, editorViews),
+    ];
+  }),
+);

package/src/cli/plugin.ts

@@ -4,26 +4,37 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Common, Plugin } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
 import { type CreateObject } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { Text } from '@dxos/schema';
 
-// NOTE: Must not import from index to avoid pulling in react dependencies.
-import { OperationResolver } from '../capabilities/operation-resolver';
-import { meta } from '../meta';
-import { Markdown } from '../types';
+import { OperationHandler } from '#capabilities';
+
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
 export const MarkdownPlugin = Plugin.define(meta).pipe(
-  Common.Plugin.addSchemaModule({ schema: [Markdown.Document, Text.Text] }),
-  Common.Plugin.addMetadataModule({
+  AppPlugin.addMetadataModule({
     metadata: {
       id: Markdown.Document.typename,
       metadata: {
-        createObject: ((props) => Effect.sync(() => Markdown.make(props))) satisfies CreateObject,
-        addToCollectionOnCreate: true,
+        createObject: ((props, options) =>
+          Effect.gen(function* () {
+            const object = Markdown.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          })) satisfies CreateObject,
       },
     },
   }),
-  Common.Plugin.addOperationResolverModule({ activate: OperationResolver }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({ schema: [Markdown.Document, Text.Text] }),
   Plugin.make,
 );

package/src/components/MarkdownEditor/FileUpload.tsx

@@ -7,7 +7,7 @@ import React, { forwardRef, useEffect, useImperativeHandle } from 'react';
 import { createPortal } from 'react-dom';
 import { useDropzone } from 'react-dropzone';
 
-import { type Common } from '@dxos/app-framework';
+import { type FileInfo } from '@dxos/app-toolkit';
 import { addLink } from '@dxos/ui-editor';
 
 export const IMAGE_FILES = ['.jpg', '.jpeg', '.png', '.gif'];
@@ -16,7 +16,7 @@ export type FileUploadAction = () => void;
 
 export type FileUploadProps = {
   editorView?: EditorView;
-  onFileUpload?: (file: File) => Promise<Common.FileInfo | undefined>;
+  onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
 };
 
 // TODO(burdon): Factor out.

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

@@ -9,63 +9,63 @@ import React from 'react';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Filter, Obj } from '@dxos/echo';
 import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
 import { corePlugins } from '@dxos/plugin-testing';
 import { useQuery, useSpace } from '@dxos/react-client/echo';
-import { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { useAttentionAttributes } from '@dxos/react-ui-attention';
+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 { Layout } from '@dxos/react-ui-mosaic';
+import { Text } from '@dxos/schema';
 
 import { translations } from '../../translations';
-import { Markdown } from '../../types';
+import { Markdown } from '#types';
 
 import { MarkdownEditor, type MarkdownEditorRootProps } from './MarkdownEditor';
 
-const content = Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n');
+type DefaultStoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
 
-type StoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
-
-const DefaultStory = (props: StoryProps) => {
+const DefaultStory = (props: DefaultStoryProps) => {
   const space = useSpace();
   const [doc] = useQuery(space?.db, Filter.type(Markdown.Document));
   const id = doc && Obj.getDXN(doc).toString();
-  const attentionAttrs = useAttentionAttributes(id);
   if (!id) {
-    return null;
+    return <Loading data={{ id }} />;
   }
 
   return (
-    <div className='contents' {...attentionAttrs}>
-      <Layout.Main toolbar>
-        <MarkdownEditor.Root id={id} object={doc} {...props}>
-          <MarkdownEditor.Toolbar id={id} />
-          <MarkdownEditor.Content />
-        </MarkdownEditor.Root>
-      </Layout.Main>
-    </div>
+    <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>
+    </AttendableContainer>
   );
 };
 
 const meta: Meta<typeof DefaultStory> = {
-  title: 'plugins/plugin-markdown/MarkdownEditor',
-  component: DefaultStory,
-  render: DefaultStory as any,
+  title: 'plugins/plugin-markdown/components/MarkdownEditor',
+  render: DefaultStory,
   decorators: [
-    withTheme,
     withLayout({ layout: 'column' }),
     withPluginManager({
       plugins: [
         ...corePlugins(),
+        // TODO(burdon): Try to write story without ClientPlugin.
         ClientPlugin({
-          types: [Markdown.Document],
+          types: [Markdown.Document, Text.Text],
           onClientInitialized: ({ client }) =>
             Effect.gen(function* () {
-              yield* Effect.promise(() => client.halo.createIdentity());
-              yield* Effect.promise(() => client.spaces.waitUntilReady());
-              const space = client.spaces.default;
-              yield* Effect.promise(() => space.waitUntilReady());
-
-              space.db.add(Markdown.make({ content }));
+              const { personalSpace } = yield* initializeIdentity(client);
+              personalSpace.db.add(
+                Markdown.make({ content: Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n') }),
+              );
             }),
         }),
       ],

package/src/components/MarkdownEditor/MarkdownEditor.tsx

@@ -9,9 +9,11 @@ import { createContext } from '@radix-ui/react-context';
 import React, { type PropsWithChildren, useMemo, useState } from 'react';
 import { createPortal } from 'react-dom';
 
-import { Surface } from '@dxos/app-framework/react';
+import { Surface } from '@dxos/app-framework/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 EditorToolbarState,
@@ -20,6 +22,7 @@ import {
   useEditorToolbar,
 } from '@dxos/react-ui-editor';
 import { type PreviewBlock, type PreviewOptions } from '@dxos/ui-editor';
+import { composable, composableProps } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
 import {
@@ -28,7 +31,7 @@ import {
   type UseEditorMenuOptionsProps,
   useEditorMenuOptions,
   useExtensions,
-} from '../../hooks';
+} from '#hooks';
 
 import {
   MarkdownEditorContent as NaturalMarkdownEditorContent,
@@ -45,12 +48,13 @@ 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, 'viewMode'> &
+} & (Pick<ExtensionsOptions, 'compact' | 'viewMode'> &
   Pick<NaturalMarkdownToolbarProps, 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange'>);
 
 const [MarkdownEditorContextProvider, useMarkdownEditorContext] =
@@ -64,22 +68,28 @@ type MarkdownEditorRootProps = PropsWithChildren<
   {
     object?: DocumentType;
     extensions?: Extension[];
-  } & Pick<MarkdownEditorContextValue, 'id' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'viewMode'> &
+  } & Pick<
+    MarkdownEditorContextValue,
+    'id' | 'attendableId' | 'viewMode' | 'compact' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
+  > &
     Pick<UseEditorMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
-    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings'>
+    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings' | 'onSelectObject'>
 >;
 
 const MarkdownEditorRoot = ({
   children,
   id,
+  attendableId,
   object,
-  editorStateStore,
-  selectionManager,
   settings,
+  compact,
   viewMode,
+  selectionManager,
+  editorStateStore,
   extensions: extensionsProp,
   slashCommandGroups,
   onLinkQuery,
+  onSelectObject,
   ...props
 }: MarkdownEditorRootProps) => {
   const [editorView, setEditorView] = useState<EditorView>();
@@ -88,36 +98,35 @@ const MarkdownEditorRoot = ({
   const [previewBlocks, setPreviewBlocks] = useState<PreviewBlock[]>([]);
   const previewOptions = useMemo<PreviewOptions>(
     () => ({
+      db: Obj.isObject(object) ? Obj.getDatabase(object) : undefined,
       addBlockContainer: (block) => {
         setPreviewBlocks((prev) => [...prev, block]);
       },
       removeBlockContainer: ({ link }) => {
-        setPreviewBlocks((prev) => prev.filter(({ link: prevLink }) => prevLink.ref !== link.ref));
+        setPreviewBlocks((prev) => prev.filter(({ link: prevLink }) => prevLink.dxn !== link.dxn));
       },
     }),
-    [],
+    [object],
   );
 
   // Toolbar state.
   const toolbarState = useEditorToolbar({ viewMode });
 
   // Context menu.
-  const menuOptions = useEditorMenuOptions({
-    editorView,
-    slashCommandGroups,
-    onLinkQuery,
-  });
+  const menuOptions = useEditorMenuOptions({ editorView, slashCommandGroups, onLinkQuery });
   const { extension: menuExtension, ...menuProps } = useEditorMenu(menuOptions);
 
   // Extensions.
   const coreExtensions = useExtensions({
     id,
     object,
+    compact,
+    viewMode,
+    selectionManager,
     editorStateStore,
     previewOptions,
-    selectionManager,
     settings,
-    viewMode,
+    onSelectObject,
   });
 
   const extensions = useMemo(
@@ -128,6 +137,8 @@ const MarkdownEditorRoot = ({
   return (
     <MarkdownEditorContextProvider
       id={id}
+      attendableId={attendableId}
+      compact={compact}
       editorView={editorView}
       setEditorView={setEditorView}
       extensions={extensions}
@@ -148,24 +159,30 @@ MarkdownEditorRoot.displayName = 'MarkdownEditor.Root';
 // MarkdownEditor.Main
 //
 
+const MARKDOWN_EDITOR_CONTENT_NAME = 'MarkdownEditor.Content';
+
 type MarkdownEditorContentProps = Omit<NaturalMarkdownEditorContentProps, 'id' | 'extensions' | 'toolbarState'>;
 
-const MarkdownEditorContent = (props: MarkdownEditorContentProps) => {
+const MarkdownEditorContent = composable<HTMLDivElement, MarkdownEditorContentProps>(({ ...props }, _forwardedRef) => {
   const {
     id,
+    attendableId,
+    compact,
     editorView,
     setEditorView,
     viewMode,
     toolbarState,
     extensions,
     popoverMenu: { groupsRef, ...menuProps },
-  } = useMarkdownEditorContext(MarkdownEditorContent.displayName);
+  } = useMarkdownEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
 
   return (
     <EditorMenuProvider view={editorView} groups={groupsRef.current} {...menuProps}>
       <NaturalMarkdownEditorContent
-        {...props}
+        {...composableProps(props)}
         id={id}
+        attendableId={attendableId}
+        compact={compact}
         viewMode={viewMode}
         toolbarState={toolbarState}
         extensions={extensions}
@@ -173,54 +190,68 @@ const MarkdownEditorContent = (props: MarkdownEditorContentProps) => {
       />
     </EditorMenuProvider>
   );
-};
+});
 
-MarkdownEditorContent.displayName = 'MarkdownEditor.Content';
+MarkdownEditorContent.displayName = MARKDOWN_EDITOR_CONTENT_NAME;
 
 //
 // MarkdownEditor.Toolbar
 //
 
-type MarkdownEditorToolbarProps = Omit<
-  NaturalMarkdownToolbarProps,
-  'state' | 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
+const MARKDOWN_EDITOR_TOOLBAR_NAME = 'MarkdownEditor.Toolbar';
+
+type MarkdownEditorToolbarProps = ThemedClassName<
+  Omit<NaturalMarkdownToolbarProps, 'state' | 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'id'>
 >;
 
 const MarkdownEditorToolbar = (props: MarkdownEditorToolbarProps) => {
-  const { toolbarState, ...rootProps } = useMarkdownEditorContext(MarkdownEditorToolbar.displayName);
+  const { id, attendableId, editorView, toolbarState, onAction, onFileUpload, onViewModeChange } =
+    useMarkdownEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
 
-  return <NaturalMarkdownToolbar {...props} {...rootProps} state={toolbarState} />;
+  return (
+    <NaturalMarkdownToolbar
+      {...props}
+      id={attendableId ?? id}
+      editorView={editorView}
+      state={toolbarState}
+      onAction={onAction}
+      onFileUpload={onFileUpload}
+      onViewModeChange={onViewModeChange}
+    />
+  );
 };
 
-MarkdownEditorToolbar.displayName = 'MarkdownEditor.Toolbar';
+MarkdownEditorToolbar.displayName = MARKDOWN_EDITOR_TOOLBAR_NAME;
 
 //
 // MarkdownEditor.Blocks (embedded objects)
 //
 
+const MARKDOWN_EDITOR_BLOCKS_NAME = 'MarkdownEditor.Blocks';
+
 type MarkdownEditorBlocksProps = {};
 
 const MarkdownEditorBlocks = (_props: MarkdownEditorBlocksProps) => {
-  const { previewBlocks } = useMarkdownEditorContext(MarkdownEditorBlocks.displayName);
+  const { previewBlocks } = useMarkdownEditorContext(MARKDOWN_EDITOR_BLOCKS_NAME);
 
   return (
     <>
       {previewBlocks.map(({ link, el }) => (
-        <PreviewBlock key={link.ref} link={link} el={el} />
+        <PreviewBlock key={link.dxn} link={link} el={el} />
       ))}
     </>
   );
 };
 
-MarkdownEditorBlocks.displayName = 'MarkdownEditor.Blocks';
+MarkdownEditorBlocks.displayName = MARKDOWN_EDITOR_BLOCKS_NAME;
 
 const PreviewBlock = ({ el, link }: PreviewBlock) => {
   const client = useClient();
-  const dxn = DXN.parse(link.ref);
+  const dxn = DXN.parse(link.dxn);
   const subject = client.graph.makeRef(dxn).target;
   const data = useMemo(() => ({ subject }), [subject]);
 
-  return createPortal(<Surface role='card--transclusion' data={data} limit={1} />, el);
+  return createPortal(<Surface.Surface role='card--content' data={data} limit={1} />, el);
 };
 
 //