@dxos/plugin-markdown 0.8.4-main.3c1ae3b → 0.8.4-main.3eb6e50203

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

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Obj, Ref, Type } from '@dxos/echo';
+import { OperationResolver } from '@dxos/operation';
+import { Collection } from '@dxos/schema';
+
+import { Markdown, MarkdownCapabilities, MarkdownOperation } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationResolver, [
+      OperationResolver.make({
+        operation: MarkdownOperation.OnCreateSpace,
+        handler: Effect.fnUntraced(function* ({ rootCollection }) {
+          const collection = Collection.makeManaged({ key: Type.getTypename(Markdown.Document) });
+          Obj.change(rootCollection, (c) => {
+            c.objects.push(Ref.make(collection));
+          });
+        }),
+      }),
+      OperationResolver.make({
+        operation: MarkdownOperation.Create,
+        handler: ({ name, content }) =>
+          Effect.succeed({
+            object: Markdown.make({ name, content }),
+          }),
+      }),
+      // TODO(wittjosiah): This appears to be unused.
+      OperationResolver.make({
+        operation: MarkdownOperation.SetViewMode,
+        handler: Effect.fnUntraced(function* ({ id, viewMode }) {
+          yield* Capabilities.updateAtomValue(MarkdownCapabilities.State, (current) => ({
+            ...current,
+            viewMode: { ...current.viewMode, [id]: viewMode },
+          }));
+        }),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

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

@@ -0,0 +1,102 @@
+//
+// 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 { AppCapabilities } from '@dxos/app-toolkit';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { Text } from '@dxos/schema';
+import { type EditorViewMode } from '@dxos/ui-editor';
+
+import { MarkdownCard, MarkdownContainer, type MarkdownContainerProps, MarkdownSettings } from '../../components';
+import { meta } from '../../meta';
+import { Markdown, MarkdownCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    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,
+        component: ({ data, role, ref }) => {
+          return <Container id={Obj.getDXN(data.subject).toString()} subject={data.subject} role={role} ref={ref} />;
+        },
+      }),
+      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} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}/surface/plugin-settings`,
+        role: 'article',
+        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} />;
+        },
+      }),
+      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),
+        component: ({ data }) => <MarkdownCard {...data} />,
+      }),
+    ]),
+  ),
+);
+
+/**
+ * Common wrapper.
+ */
+const Container = forwardRef<HTMLDivElement, SurfaceComponentProps<Markdown.Document | Text.Text, { id: string }>>(
+  ({ id, 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<MarkdownContainerProps['onViewModeChange']>>(
+      (mode) => setState((current) => ({ ...current, viewMode: { ...current.viewMode, [id]: mode } })),
+      [id, setState],
+    );
+
+    return (
+      <MarkdownContainer
+        role={role}
+        subject={subject}
+        id={id}
+        settings={settings}
+        selectionManager={selectionManager}
+        extensionProviders={extensionProviders}
+        editorStateStore={editorState}
+        viewMode={viewMode}
+        onViewModeChange={handleViewModeChange}
+        ref={forwardedRef}
+      />
+    );
+  },
+);

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const MarkdownSettings = Capability.lazy('MarkdownSettings', () => import('./settings'));

package/src/capabilities/settings/settings.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+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';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Markdown.Settings,
+      defaultValue: () => ({
+        defaultViewMode: 'preview' as const,
+        toolbar: true,
+        numberedHeadings: true,
+        folding: true,
+        experimental: false,
+      }),
+    });
+
+    return [
+      Capability.contributes(MarkdownCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Markdown.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const MarkdownState = Capability.lazy('MarkdownState', () => import('./state'));

package/src/capabilities/state/state.ts

@@ -0,0 +1,31 @@
+//
+// 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 { MarkdownCapabilities, MarkdownStateSchema } from '../../types';
+
+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`);
+
+    return [
+      Capability.contributes(MarkdownCapabilities.State, stateAtom),
+      Capability.contributes(MarkdownCapabilities.EditorState, editorState),
+    ];
+  }),
+);

package/src/cli/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './plugin';

package/src/cli/plugin.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { type CreateObject } from '@dxos/plugin-space/types';
+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';
+
+export const MarkdownPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Markdown.Document.typename,
+      metadata: {
+        createObject: ((props) => Effect.sync(() => Markdown.make(props))) satisfies CreateObject,
+        addToCollectionOnCreate: true,
+      },
+    },
+  }),
+  AppPlugin.addOperationResolverModule({ activate: OperationResolver }),
+  AppPlugin.addSchemaModule({ schema: [Markdown.Document, Text.Text] }),
+  Plugin.make,
+);

package/src/components/MarkdownCard/MarkdownCard.stories.tsx

@@ -3,35 +3,45 @@
 //
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React from 'react';
+import React, { useMemo } from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
+import { OperationPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { faker } from '@dxos/random';
 import { withTheme } from '@dxos/react-ui/testing';
-import { CardContainer } from '@dxos/react-ui-stack/testing';
+import { CardContainer } from '@dxos/react-ui-mosaic/testing';
 
 import { translations } from '../../translations';
 
-import { MarkdownCard } from './MarkdownCard';
+import { MarkdownCard, type MarkdownCardProps } from './MarkdownCard';
 
 faker.seed(1234);
 
-const meta: Meta<typeof MarkdownCard> = {
+// TODO(wittjosiah): ECHO objects don't work when passed via Storybook args.
+const MarkdownCardStory = ({ ...args }: Omit<MarkdownCardProps, 'subject'>) => {
+  const subject = useMemo(
+    () =>
+      Markdown.make({
+        name: faker.lorem.words(3),
+        content: faker.lorem.paragraphs(3),
+      }),
+    [],
+  );
+  return (
+    <CardContainer icon='ph--text-aa--regular'>
+      <MarkdownCard subject={subject} {...args} />
+    </CardContainer>
+  );
+};
+
+const meta: Meta<typeof MarkdownCardStory> = {
   title: 'plugins/plugin-markdown/Card',
-  component: MarkdownCard,
-  render: ({ role, subject, ...args }) => {
-    return (
-      <CardContainer icon='ph--text-aa--regular' role={role}>
-        <MarkdownCard role={role} subject={subject} {...args} />
-      </CardContainer>
-    );
-  },
+  component: MarkdownCardStory,
   decorators: [
-    withTheme,
+    withTheme(),
     withPluginManager({
-      plugins: [IntentPlugin()],
+      plugins: [OperationPlugin()],
     }),
   ],
   parameters: {
@@ -45,32 +55,4 @@ export default meta;
 
 type Story = StoryObj<typeof meta>;
 
-export const Popover: Story = {
-  args: {
-    role: 'card--popover',
-    subject: Markdown.make({
-      name: faker.lorem.words(3),
-      content: faker.lorem.paragraphs(3),
-    }),
-  },
-};
-
-export const Intrinsic: Story = {
-  args: {
-    role: 'card--intrinsic',
-    subject: Markdown.make({
-      name: faker.lorem.words(3),
-      content: faker.lorem.paragraphs(3),
-    }),
-  },
-};
-
-export const Extrinsic: Story = {
-  args: {
-    role: 'card--extrinsic',
-    subject: Markdown.make({
-      name: faker.lorem.words(3),
-      content: faker.lorem.paragraphs(3),
-    }),
-  },
-};
+export const Default: Story = {};

package/src/components/MarkdownCard/MarkdownCard.tsx

@@ -2,15 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Function from 'effect/Function';
-import React, { forwardRef, useCallback, useMemo } from 'react';
+import React, { useMemo } from 'react';
 
-import { LayoutAction, chain, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
 import { Obj } from '@dxos/echo';
-import { type CardPreviewProps } from '@dxos/plugin-preview';
-import { IconButton, useTranslation } from '@dxos/react-ui';
-import { Card } from '@dxos/react-ui-stack';
+import { useTranslation } from '@dxos/react-ui';
+import { Card } from '@dxos/react-ui-mosaic';
 import { Text } from '@dxos/schema';
 
 import { meta } from '../../meta';
@@ -18,58 +14,30 @@ import { Markdown } from '../../types';
 import { getContentSnippet, getFallbackName } from '../../util';
 import { MarkdownEditor } from '../MarkdownEditor';
 
-export type MarkdownCardProps = CardPreviewProps<Markdown.Document | Text.Text>;
+export type MarkdownCardProps = { subject: Markdown.Document | Text.Text };
 
-export const MarkdownCard = forwardRef<HTMLDivElement, MarkdownCardProps>(
-  ({ subject, role }: MarkdownCardProps, forwardedRef) => {
-    const { dispatchPromise: dispatch } = useIntentDispatcher();
-    const { t } = useTranslation(meta.id);
-    const snippet = useMemo(() => getSnippet(subject, t('fallback abstract')), [subject]);
-    const info = getInfo(subject);
+export const MarkdownCard = ({ subject }: MarkdownCardProps) => {
+  const { t } = useTranslation(meta.id);
+  const snippet = useMemo(() => getSnippet(subject), [subject]);
+  const info = getInfo(subject);
 
-    // TODO(wittjosiah): Factor out so this component isn't dependent on the app framework.
-    const handleNavigate = useCallback(() => {
-      void dispatch(
-        Function.pipe(
-          createIntent(LayoutAction.UpdatePopover, {
-            part: 'popover',
-            subject: null,
-            options: { state: false, anchorId: '' },
-          }),
-          chain(LayoutAction.Open, {
-            part: 'main',
-            subject: [Obj.getDXN(subject).toString()],
-          }),
-        ),
-      );
-    }, [dispatch, subject]);
-
-    return (
-      <Card.SurfaceRoot role={role} ref={forwardedRef}>
-        <Card.Heading classNames='flex items-center'>
-          {getTitle(subject, t('fallback title'))}
-          <span className='grow' />
-          <IconButton
-            iconOnly
-            icon='ph--arrow-right--regular'
-            label={t('navigate to document label')}
-            onClick={handleNavigate}
-          />
-        </Card.Heading>
-        {snippet && (
-          <Card.Text classNames='flex max-h-[300px] overflow-hidden'>
-            <MarkdownEditor.Root id={subject.id} viewMode='readonly'>
-              <MarkdownEditor.Content initialValue={snippet} slots={{}} classNames='!bg-transparent' />
-            </MarkdownEditor.Root>
-          </Card.Text>
-        )}
+  return (
+    <Card.Content>
+      {snippet && (
+        <Card.Row className='max-h-[300px] overflow-hidden'>
+          <MarkdownEditor.Root id={subject.id} viewMode='readonly'>
+            <MarkdownEditor.Content initialValue={snippet} slots={{}} classNames='!bg-transparent' />
+          </MarkdownEditor.Root>
+        </Card.Row>
+      )}
+      <Card.Row>
         <Card.Text classNames='text-xs text-description'>
           {info.words} {t('words label', { count: info.words })}
         </Card.Text>
-      </Card.SurfaceRoot>
-    );
-  },
-);
+      </Card.Row>
+    </Card.Content>
+  );
+};
 
 const getInfo = (subject: Markdown.Document | Text.Text) => {
   const text = (Obj.instanceOf(Markdown.Document, subject) ? subject.content?.target?.content : subject.content) ?? '';
@@ -87,7 +55,7 @@ const getTitle = (subject: Markdown.Document | Text.Text, fallback: string) => {
 };
 
 // TODO(burdon): Factor out.
-const getSnippet = (subject: Markdown.Document | Text.Text, fallback: string) => {
+const getSnippet = (subject: Markdown.Document | Text.Text, fallback?: string) => {
   if (Obj.instanceOf(Markdown.Document, subject)) {
     return Obj.getDescription(subject) || getContentSnippet(subject.content?.target?.content ?? fallback);
   } else if (Obj.instanceOf(Text.Text, subject)) {

package/src/components/MarkdownContainer.stories.tsx

@@ -3,25 +3,21 @@
 //
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
 import React, { useMemo } from 'react';
 
-import { type Capabilities, IntentPlugin, LayoutAction, SettingsPlugin, createIntent } from '@dxos/app-framework';
-import { Surface, useIntentDispatcher } from '@dxos/app-framework/react';
 import { withPluginManager } from '@dxos/app-framework/testing';
+import { Surface, useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { Obj, Query } from '@dxos/echo';
-import { AttentionPlugin } from '@dxos/plugin-attention';
 import { ClientPlugin } from '@dxos/plugin-client';
-import { GraphPlugin } from '@dxos/plugin-graph';
 import { PreviewPlugin } from '@dxos/plugin-preview';
-import { SpacePlugin } from '@dxos/plugin-space';
-import { StorybookLayoutPlugin } from '@dxos/plugin-storybook-layout';
-import { ThemePlugin } from '@dxos/plugin-theme';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
 import { faker } from '@dxos/random';
 import { useQuery, useSpace } 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 { defaultTx } from '@dxos/react-ui-theme';
 import { Text } from '@dxos/schema';
 import { type ValueGenerator, createObjectFactory } from '@dxos/schema/testing';
 import { Organization, Person } from '@dxos/types';
@@ -35,27 +31,22 @@ faker.seed(1);
 const generator: ValueGenerator = faker as any;
 
 const DefaultStory = () => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const space = useSpace();
-  const [doc] = useQuery(space, Query.type(Markdown.Document));
+  const [doc] = useQuery(space?.db, Query.type(Markdown.Document));
   const data = useMemo(() => ({ subject: doc }), [doc]);
   const id = doc && Obj.getDXN(doc).toString();
   const attentionAttrs = useAttentionAttributes(id);
 
   useAsyncEffect(async () => {
     if (space) {
-      await dispatch(
-        createIntent(LayoutAction.SwitchWorkspace, {
-          part: 'workspace',
-          subject: space.id,
-        }),
-      );
+      await invokePromise(LayoutOperation.SwitchWorkspace, { subject: space.id });
     }
-  }, [space, dispatch]);
+  }, [space, invokePromise]);
 
   return (
     <div className='contents' {...attentionAttrs}>
-      <Surface role='article' data={data} limit={1} />
+      <Surface.Surface role='article' data={data} limit={1} />
     </div>
   );
 };
@@ -64,56 +55,52 @@ const meta = {
   title: 'plugins/plugin-markdown/MarkdownContainer',
   render: DefaultStory,
   decorators: [
-    withTheme,
-    withLayout({ container: 'column' }),
+    withTheme(),
+    withLayout({ layout: 'column' }),
     withPluginManager<{ title?: string; content?: string }>((context) => ({
       plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
         ClientPlugin({
           types: [Markdown.Document, Text.Text, Person.Person, Organization.Organization],
-          onClientInitialized: async ({ client }) => {
-            await client.halo.createIdentity();
-            await client.spaces.waitUntilReady();
-            await client.spaces.default.waitUntilReady();
-
-            const space = client.spaces.default;
-            const createObjects = createObjectFactory(space.db, generator);
-            await createObjects([{ type: Organization.Organization, count: 10 }]);
-
-            const queue = space.queues.create();
-            const kai = Obj.make(Person.Person, { fullName: 'Kai' });
-            const dxos = Obj.make(Organization.Organization, { name: 'DXOS' });
-            await queue.append([kai, dxos]);
-
-            space.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.getDXN(kai)})`,
-                  `![DXOS](${Obj.getDXN(dxos)})`,
-                  '',
-                  'END',
-                  '',
-                ].join('\n\n'),
-              }),
-            );
-
-            await space.db.flush({ indexes: true });
-          },
+          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 space = client.spaces.default;
+              const createObjects = createObjectFactory(space.db, generator);
+              yield* Effect.promise(() => createObjects([{ type: Organization.Organization, count: 10 }]));
+
+              const queue = space.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(
+                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.getDXN(kai)})`,
+                    `![DXOS](${Obj.getDXN(dxos)})`,
+                    '',
+                    'END',
+                    '',
+                  ].join('\n\n'),
+                }),
+              );
+
+              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+            }),
         }),
-        SpacePlugin({}),
-        GraphPlugin(),
-        IntentPlugin(),
-        SettingsPlugin(),
-        // UI
-        ThemePlugin({ tx: defaultTx }),
-        AttentionPlugin(),
+
         MarkdownPlugin(),
         PreviewPlugin(),
-        StorybookLayoutPlugin({}),
       ],
     })),
   ],
@@ -122,7 +109,7 @@ const meta = {
     controls: { disable: true },
     translations,
   },
-} satisfies Meta<typeof Capabilities>;
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;