@dxos/plugin-transcription 0.8.2-main.12df754 → 0.8.2-main.30e4dbb

package/src/capabilities/app-graph-builder.ts

@@ -2,24 +2,31 @@
 // Copyright 2025 DXOS.org
 //
 
+import type { Schema } from 'effect';
+
 import { Capabilities, contributes, createIntent, type PluginsContext } from '@dxos/app-framework';
-import { fullyQualifiedId, getSpace, makeRef, type Space } from '@dxos/client/echo';
-import { generateName } from '@dxos/display-name';
-import { getSchemaTypename, isInstanceOf } from '@dxos/echo-schema';
+import { AIServiceEdgeClient, type AIServiceClient } from '@dxos/assistant';
+import { AI_SERVICE_ENDPOINT } from '@dxos/assistant/testing';
+import { Filter, fullyQualifiedId, getSpace, makeRef, type Space } from '@dxos/client/echo';
+import { getSchemaTypename, isInstanceOf, type BaseEchoObject } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { PLANK_COMPANION_TYPE, ATTENDABLE_PATH_SEPARATOR } from '@dxos/plugin-deck/types';
 import { createExtension, type Node } from '@dxos/plugin-graph';
+import { DocumentType } from '@dxos/plugin-markdown/types';
 import { MeetingCapabilities, type CallState, type MediaState } from '@dxos/plugin-meeting';
-import { MeetingType } from '@dxos/plugin-meeting/types';
+import { MeetingType, type MeetingCallProperties } from '@dxos/plugin-meeting/types';
 import { type buf } from '@dxos/protocols/buf';
 import { type TranscriptionPayloadSchema } from '@dxos/protocols/buf/dxos/edge/calls_pb';
-import { keyToFallback } from '@dxos/util';
+import { DataType } from '@dxos/schema';
 
 import { TranscriptionCapabilities } from './capabilities';
+import { processTranscriptMessage } from '../entity-extraction';
 import { TRANSCRIPTION_PLUGIN } from '../meta';
 import { TranscriptionManager } from '../transcriber';
-import { TranscriptionAction, TranscriptType } from '../types';
+import { TranscriptionAction, type TranscriptionSettingsProps, TranscriptType } from '../types';
 
 // TODO(wittjosiah): Factor out.
 // TODO(wittjosiah): Can we stop using protobuf for this?
@@ -49,8 +56,7 @@ export default (context: PluginsContext) =>
   contributes(Capabilities.AppGraphBuilder, [
     createExtension({
       id: `${TRANSCRIPTION_PLUGIN}/meeting-transcript`,
-      filter: (node): node is Node<MeetingType> =>
-        isInstanceOf(MeetingType, node.data) && node.type !== PLANK_COMPANION_TYPE,
+      filter: (node): node is Node<MeetingType> => isInstanceOf(MeetingType, node.data),
       actions: ({ node }) => {
         const meeting = node.data;
         const state = context.requestCapability(TranscriptionCapabilities.MeetingTranscriptionState);
@@ -61,14 +67,13 @@ export default (context: PluginsContext) =>
               // NOTE: We are not saving the state of the transcription manager here.
               // We expect the state to be updated through `onCallStateUpdated` once it is propagated through Swarm.
               // This is done to avoid race conditions and to not handle optimistic updates.
-
               const transcript = await getMeetingTranscript(context, meeting);
               invariant(transcript, 'Failed to create transcript');
 
-              const call = context.requestCapability(MeetingCapabilities.CallManager);
-              call.setActivity(getSchemaTypename(TranscriptType)!, {
-                enabled: !state.enabled,
+              const callManager = context.requestCapability(MeetingCapabilities.CallManager);
+              callManager.setActivity(getSchemaTypename(TranscriptType)!, {
                 queueDxn: transcript.queue.dxn.toString(),
+                enabled: !state.enabled,
               });
             },
             properties: {
@@ -86,6 +91,14 @@ export default (context: PluginsContext) =>
         const meeting = node.data;
         const client = context.requestCapability(ClientCapabilities.Client);
         const state = context.requestCapability(TranscriptionCapabilities.MeetingTranscriptionState);
+        const settings = context
+          .requestCapability(Capabilities.SettingsStore)
+          .getStore<TranscriptionSettingsProps>(TRANSCRIPTION_PLUGIN)!.value;
+
+        // TODO(dmaretskyi): Request via capability.
+        const aiClient: AIServiceClient | undefined = new AIServiceEdgeClient({
+          endpoint: AI_SERVICE_ENDPOINT.REMOTE,
+        });
 
         return [
           {
@@ -95,29 +108,45 @@ export default (context: PluginsContext) =>
             properties: {
               label: ['transcript companion label', { ns: TRANSCRIPTION_PLUGIN }],
               icon: 'ph--subtitles--regular',
+              position: 'hoist',
               disposition: 'hidden',
               schema: TranscriptType,
               getIntent: ({ space }: { space: Space }) =>
                 createIntent(TranscriptionAction.Create, { spaceId: space.id }),
-              onJoin: () => {
-                const transcriptionManager = new TranscriptionManager(client.edge);
+
+              // TODO(burdon): Is this the right place to inisitalize the state? Change to a capability?
+              onJoin: async ({ meeting }: { meeting: MeetingType; roomId: string }) => {
                 const identity = client.halo.identity.get();
                 invariant(identity);
-                transcriptionManager.setName(
-                  identity.profile?.displayName ?? generateName(identity.identityKey.toHex()),
-                );
-                const fallbackValue = keyToFallback(identity!.identityKey);
-                const userHue = identity!.profile?.data?.hue || fallbackValue.hue;
-                transcriptionManager.setHue(userHue);
-                void transcriptionManager.open();
-                state.transcriptionManager = transcriptionManager;
+                const space = getSpace(meeting);
+                invariant(space);
+
+                let messageEnricher;
+                if (aiClient && settings.entityExtraction) {
+                  messageEnricher = createEntityExtractionEnricher({
+                    aiClient,
+                    // TODO(dmaretskyi): Have those be discovered from the schema graph or contributed by capabilities?
+                    //  This forced me to add a dependency on markdown plugin.
+                    //  This will be replaced with a vector search index anyway, so its not a big deal.
+                    contextTypes: [DocumentType, DataType.Person, DataType.Organization],
+                    space,
+                  });
+                }
+
+                // TODO(burdon): The TranscriptionManager singleton is part of the state and should just be updated here.
+                state.transcriptionManager = await new TranscriptionManager({
+                  edgeClient: client.edge,
+                  messageEnricher,
+                })
+                  .setIdentityDid(identity.did)
+                  .open();
               },
-              onLeave: () => {
-                void state.transcriptionManager?.close();
+              onLeave: async () => {
+                await state.transcriptionManager?.close();
                 state.transcriptionManager = undefined;
                 state.enabled = false;
               },
-              onCallStateUpdated: (callState: CallState) => {
+              onCallStateUpdated: async (callState: CallState) => {
                 const typename = getSchemaTypename(TranscriptType);
                 const transcription = typename ? callState.activities?.[typename] : undefined;
                 if (!transcription?.payload) {
@@ -126,16 +155,57 @@ export default (context: PluginsContext) =>
 
                 const payload: TranscriptionPayload = transcription.payload;
                 state.enabled = !!payload.enabled;
-                void state.transcriptionManager?.setEnabled(payload.enabled);
-                void state.transcriptionManager?.setQueue(payload.queueDxn);
+                if (payload.queueDxn) {
+                  // NOTE: Must set queue before enabling transcription.
+                  state.transcriptionManager?.setQueue(DXN.parse(payload.queueDxn));
+                }
+                await state.transcriptionManager?.setEnabled(payload.enabled);
               },
-              onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => {
+              onMediaStateUpdated: async ([mediaState, isSpeaking]: [MediaState, boolean]) => {
                 void state.transcriptionManager?.setAudioTrack(mediaState.audioTrack);
                 void state.transcriptionManager?.setRecording(isSpeaking);
               },
-            },
+            } satisfies MeetingCallProperties,
           },
         ];
       },
     }),
   ]);
+
+type EntityExtractionEnricherFactoryOptions = {
+  aiClient: AIServiceClient;
+  contextTypes: Schema.Schema.AnyNoContext[];
+  space: Space;
+};
+
+const createEntityExtractionEnricher = ({ aiClient, contextTypes, space }: EntityExtractionEnricherFactoryOptions) => {
+  return async (message: DataType.Message) => {
+    const { objects } = await space.db.query(Filter.or(...contextTypes.map((s) => Filter.schema(s)))).run();
+    log.info('context', { objects });
+
+    const { message: enhancedMessage, timeElapsed } = await processTranscriptMessage({
+      aiService: aiClient,
+      message,
+      context: { objects: await Promise.all(objects.map(processContextObject)) },
+      options: { timeout: ENTITY_EXTRACTOR_TIMEOUT, fallbackToRaw: true },
+    });
+
+    log.info('entity extraction time', { timeElapsed });
+    return enhancedMessage;
+  };
+};
+
+const processContextObject = async (object: BaseEchoObject): Promise<any> => {
+  // TODO(dmaretskyi): Documents need special processing is the content is behind a ref.
+  // TODO(dmaretskyi): Think about a way to handle this serialization with a decorator.
+  // if (isInstanceOf(DocumentType, object)) {
+  //   return {
+  //     ...object,
+  //     content: await object.content.load(),
+  //   };
+  // }
+
+  return object;
+};
+
+const ENTITY_EXTRACTOR_TIMEOUT = 25_000;

package/src/capabilities/capabilities.ts

@@ -18,8 +18,8 @@ export namespace TranscriptionCapabilities {
   export const Transcriber = defineCapability<GetTranscriber>(`${TRANSCRIPTION_PLUGIN}/capability/transcriber`);
 
   export type MeetingTranscriptionState = Live<{
-    enabled: boolean;
     transcriptionManager?: TranscriptionManager;
+    enabled: boolean; // TODO(burdon): Move state into TranscriptionManager.
   }>;
   export const MeetingTranscriptionState = defineCapability<MeetingTranscriptionState>(
     `${TRANSCRIPTION_PLUGIN}/capability/meeting-transcription-state`,

package/src/capabilities/index.ts

@@ -9,5 +9,6 @@ export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const MeetingTranscriptionState = lazy(() => import('./meeting-transcription-state'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const Transcriber = lazy(() => import('./transcriber'));
+export const Settings = lazy(() => import('./settings'));
 
 export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -4,7 +4,7 @@
 
 import { Capabilities, contributes, createResolver, type PluginsContext } from '@dxos/app-framework';
 import { live, refFromDXN } from '@dxos/live-object';
-import { type SpaceId, randomQueueDxn } from '@dxos/react-client/echo';
+import { type SpaceId, createQueueDxn } from '@dxos/react-client/echo';
 
 import { TranscriptionAction, TranscriptType } from '../types';
 import { getTimeStr } from '../util';
@@ -15,7 +15,7 @@ export default (context: PluginsContext) =>
       intent: TranscriptionAction.Create,
       resolve: ({ name, spaceId }) => {
         const transcript = live(TranscriptType, {
-          queue: refFromDXN(randomQueueDxn(spaceId as SpaceId)),
+          queue: refFromDXN(createQueueDxn(spaceId as SpaceId)),
           name: name ?? `Transcript ${getTimeStr(Date.now())}`,
         });
 

package/src/capabilities/react-surface.tsx

@@ -5,15 +5,23 @@
 import React from 'react';
 
 import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { SettingsStore } from '@dxos/local-storage';
 
-import { TranscriptionContainer } from '../components';
-import { TRANSCRIPTION_PLUGIN } from '../meta';
-import { isTranscript, type TranscriptType } from '../types';
+import { TranscriptionContainer, TranscriptionSettings } from '../components';
+import { meta } from '../meta';
+import { isTranscript, type TranscriptionSettingsProps, type TranscriptType } from '../types';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${TRANSCRIPTION_PLUGIN}/article/transcript`,
+      id: `${meta.id}/plugin-settings`,
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<TranscriptionSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
+      component: ({ data: { subject } }) => <TranscriptionSettings settings={subject.value} />,
+    }),
+    createSurface({
+      id: `${meta.id}/article/transcript`,
       role: ['article', 'section'],
       filter: (data): data is { subject: TranscriptType } => isTranscript(data.subject),
       component: ({ data, role }) => <TranscriptionContainer transcript={data.subject} role={role} />,

package/src/capabilities/settings.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { live } from '@dxos/live-object';
+
+import { TRANSCRIPTION_PLUGIN } from '../meta';
+import { TranscriptionSettingsSchema } from '../types';
+
+export default () => {
+  // TODO(wittjosiah): `live` currently doesn't handle schema default values.
+  const settings = live(TranscriptionSettingsSchema, { entityExtraction: true });
+
+  return contributes(Capabilities.Settings, {
+    schema: TranscriptionSettingsSchema,
+    prefix: TRANSCRIPTION_PLUGIN,
+    value: settings,
+  });
+};

package/src/components/Transcript/Transcript.stories.tsx

@@ -5,33 +5,35 @@
 import '@dxos-theme';
 
 import { type Meta, type StoryObj } from '@storybook/react';
-import React, { useEffect, useMemo, useState, type FC } from 'react';
+import React, { type FC, useEffect, useMemo, useState } from 'react';
 
 import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
+import { ObjectId } from '@dxos/echo-schema';
 import { ClientPlugin } from '@dxos/plugin-client';
 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 { faker } from '@dxos/random';
-import { useSpace } from '@dxos/react-client/echo';
+import { useMembers, useSpace } from '@dxos/react-client/echo';
 import { IconButton, Toolbar } from '@dxos/react-ui';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
 import { defaultTx } from '@dxos/react-ui-theme';
+import { DataType } from '@dxos/schema';
+import { Testing } from '@dxos/schema/testing';
 import { withLayout } from '@dxos/storybook-utils';
 
 import { renderMarkdown, Transcript, type TranscriptProps } from './Transcript';
+import { useQueueModelAdapter } from '../../hooks';
+import { SerializationModel } from '../../model';
 import {
-  BlockBuilder,
+  MessageBuilder,
   TestItem,
   useTestTranscriptionQueue,
   useTestTranscriptionQueueWithEntityExtraction,
-} from './testings';
-import { useQueueModelAdapter } from '../../hooks';
-import { BlockModel } from '../../model';
+} from '../../testing';
 import translations from '../../translations';
-import { type TranscriptBlock } from '../../types';
 
 faker.seed(1);
 
@@ -67,45 +69,49 @@ const TranscriptContainer: FC<
   );
 };
 
-type StoryProps = { blocks?: TranscriptBlock[] } & Pick<TranscriptProps, 'ignoreAttention' | 'attendableId'>;
+type StoryProps = { messages?: DataType.Message[] } & Pick<TranscriptProps, 'ignoreAttention' | 'attendableId'>;
 
 /**
- * Basic story mutates array of blocks.
+ * Basic story mutates array of messages.
  */
-const BasicStory = ({ blocks: initialBlocks = [], ...props }: StoryProps) => {
+const BasicStory = ({ messages: initialMessages = [], ...props }: StoryProps) => {
   const [reset, setReset] = useState({});
-  const builder = useMemo(() => new BlockBuilder(), []);
-  const model = useMemo(() => new BlockModel<TranscriptBlock>(renderMarkdown, initialBlocks), [initialBlocks, reset]);
+  const builder = useMemo(() => new MessageBuilder(), []);
+  const model = useMemo(
+    () => new SerializationModel<DataType.Message>(renderMarkdown([]), initialMessages),
+    [initialMessages, reset],
+  );
   const [running, setRunning] = useState(true);
-  const [currentBlock, setCurrentBlock] = useState<TranscriptBlock | null>(null);
+  const [currentMessage, setCurrentMessage] = useState<DataType.Message | null>(null);
   useEffect(() => {
     if (!running) {
       return;
     }
 
-    if (!currentBlock) {
-      const block = builder.createBlock();
-      model.appendBlock(block);
-      setCurrentBlock(block);
+    if (!currentMessage) {
+      void builder.createMessage().then((message) => {
+        model.appendChunk(message);
+        setCurrentMessage(message);
+      });
       return;
     }
 
     const i = setInterval(() => {
-      if (currentBlock?.segments.length && currentBlock.segments.length >= 3) {
-        setCurrentBlock(null);
+      if (currentMessage?.blocks.length && currentMessage.blocks.length >= 3) {
+        setCurrentMessage(null);
         clearInterval(i);
         return;
       }
 
-      currentBlock.segments.push(builder.createSegment());
-      model.updateBlock(currentBlock);
+      currentMessage.blocks.push(builder.createBlock());
+      model.updateChunk(currentMessage);
     }, 3_000);
 
     return () => clearInterval(i);
-  }, [model, currentBlock, running]);
+  }, [model, currentMessage, running]);
 
   const handleReset = () => {
-    setCurrentBlock(null);
+    setCurrentMessage(null);
     setRunning(false);
     setReset({});
   };
@@ -124,24 +130,54 @@ const BasicStory = ({ blocks: initialBlocks = [], ...props }: StoryProps) => {
 /**
  * Queue story mutates queue with model adapter.
  */
-const QueueStory = ({ blocks: initialBlocks = [], ...props }: StoryProps) => {
+const QueueStory = ({
+  messages: initialMessages = [],
+  queueId,
+  onReset,
+  ...props
+}: StoryProps & { queueId: ObjectId; onReset: () => void }) => {
   const [running, setRunning] = useState(true);
   const space = useSpace();
-  const queue = useTestTranscriptionQueue(space, running, 2_000);
-  const model = useQueueModelAdapter(renderMarkdown, queue, initialBlocks);
+  const members = useMembers(space?.key).map((member) => member.identity);
+  const queue = useTestTranscriptionQueue(space, queueId, running, 2_000);
+  const model = useQueueModelAdapter(renderMarkdown(members), queue, initialMessages);
 
-  return <TranscriptContainer space={space} model={model} running={running} onRunningChange={setRunning} {...props} />;
+  return (
+    <TranscriptContainer
+      space={space}
+      model={model}
+      running={running}
+      onRunningChange={setRunning}
+      onReset={onReset}
+      {...props}
+    />
+  );
 };
 
+// TODO(burdon): Reconcile with QueueStory.
 const EntityExtractionQueueStory = () => {
   const [running, setRunning] = useState(true);
   const space = useSpace();
-  const queue = useTestTranscriptionQueueWithEntityExtraction(space, running, 2_000);
-  const model = useQueueModelAdapter(renderMarkdown, queue, []);
+  const members = useMembers(space?.key).map((member) => member.identity);
+  const queue = useTestTranscriptionQueueWithEntityExtraction(space, undefined, running, 2_000);
+  const model = useQueueModelAdapter(renderMarkdown(members), queue, []);
 
   return <TranscriptContainer space={space} model={model} running={running} onRunningChange={setRunning} />;
 };
 
+/**
+ * Wrapper remounts on refresh to reload queue.
+ */
+const QueueStoryWrapper = () => {
+  const [queueId] = useState(ObjectId.random());
+  const [key, setKey] = useState(ObjectId.random().toString());
+  const handleReset = () => {
+    setKey(ObjectId.random().toString());
+  };
+
+  return <QueueStory key={key} queueId={queueId} onReset={handleReset} />;
+};
+
 const meta: Meta<typeof QueueStory> = {
   title: 'plugins/plugin-transcription/Transcript',
   decorators: [
@@ -150,7 +186,7 @@ const meta: Meta<typeof QueueStory> = {
         ThemePlugin({ tx: defaultTx }),
         StorybookLayoutPlugin(),
         ClientPlugin({
-          types: [TestItem],
+          types: [TestItem, Testing.DocumentType, DataType.Person, DataType.Organization],
           onClientInitialized: async (_, client) => {
             await client.halo.createIdentity();
           },
@@ -161,7 +197,7 @@ const meta: Meta<typeof QueueStory> = {
         IntentPlugin(),
       ],
     }),
-    withLayout({ tooltips: true, fullscreen: true }),
+    withLayout({ fullscreen: true }),
   ],
   parameters: {
     translations,
@@ -170,14 +206,14 @@ const meta: Meta<typeof QueueStory> = {
 
 export default meta;
 
-type Story = StoryObj<StoryProps>;
+type Story = StoryObj<typeof QueueStory>;
 
 export const Default: Story = {
   render: BasicStory,
   args: {
     ignoreAttention: true,
     attendableId: 'story',
-    blocks: Array.from({ length: 10 }, () => BlockBuilder.singleton.createBlock()),
+    messages: await Promise.all(Array.from({ length: 10 }, () => MessageBuilder.singleton.createMessage())),
   },
 };
 
@@ -190,7 +226,7 @@ export const Empty: Story = {
 };
 
 export const WithQueue: Story = {
-  render: QueueStory,
+  render: QueueStoryWrapper,
   args: {
     ignoreAttention: true,
     attendableId: 'story',
@@ -200,7 +236,7 @@ export const WithQueue: Story = {
 export const WithEntityExtractionQueue: Story = {
   render: EntityExtractionQueueStory,
   args: {
-    // ignoreAttention: true,
-    // attendableId: 'story',
+    ignoreAttention: true,
+    attendableId: 'story',
   },
 };

package/src/components/Transcript/Transcript.tsx

@@ -4,10 +4,8 @@
 
 import React from 'react';
 
-import { DXN } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { resolveRef, useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
+import { type Identity } from '@dxos/react-client/halo';
 import { IconButton, type ThemedClassName, useThemeContext } from '@dxos/react-ui';
 import {
   createBasicExtensions,
@@ -20,26 +18,42 @@ import {
   useTextEditor,
 } from '@dxos/react-ui-editor';
 import { mx } from '@dxos/react-ui-theme';
+import { type DataType } from '@dxos/schema';
 import { isNotFalsy } from '@dxos/util';
 
 import { transcript } from './transcript-extension';
-import { type BlockModel } from '../../model';
-import { type TranscriptType, type TranscriptBlock } from '../../types';
+import { type SerializationModel } from '../../model';
+import { type TranscriptType } from '../../types';
 
-export const renderMarkdown = (block: TranscriptBlock, debug = false): string[] => {
-  // TODO(burdon): Use link/reference markup for users (with popover).
-  // TODO(burdon): Color and avatar.
-  return [
-    `###### ${block.authorName}` + (debug ? ` (${block.id})` : ''),
-    block.segments.map((segment) => segment.text.trim()).join(' '),
-    '',
-  ];
-};
+export const renderMarkdown =
+  (identities: Identity[]) =>
+  (message: DataType.Message, index: number, debug = false): string[] => {
+    if (message.sender.role === 'assistant') {
+      // Start/stop block.
+      return [message.blocks.find((block) => block.type === 'transcription')?.text ?? '', ''];
+    }
+
+    // TODO(burdon): Use link/reference markup for users (with popover).
+    // TODO(burdon): Color and avatar.
+    const identity = identities.find((identity) => identity.did === message.sender.identityDid);
+    const name =
+      identity?.profile?.displayName ??
+      message.sender.contact?.target?.fullName ??
+      message.sender.name ??
+      message.sender.email ??
+      message.sender.identityDid;
+    const blocks = message.blocks.filter((block) => block.type === 'transcription');
+    return [
+      `###### ${name}` + (debug ? ` [${index}]:${message.id}` : ''),
+      blocks.map((block) => block.text.trim()).join(' '),
+      '',
+    ];
+  };
 
 export type TranscriptProps = ThemedClassName<{
   transcript?: TranscriptType;
   space?: Space;
-  model: BlockModel<TranscriptBlock>;
+  model: SerializationModel<DataType.Message>;
   // TODO(wittjosiah): Move to container.
   attendableId?: string;
   ignoreAttention?: boolean;
@@ -56,7 +70,6 @@ export const Transcript = ({
   attendableId,
   ignoreAttention,
 }: TranscriptProps) => {
-  const client = useClient();
   const { themeMode } = useThemeContext();
   const { parentRef } = useTextEditor(() => {
     return {
@@ -65,19 +78,7 @@ export const Transcript = ({
         createMarkdownExtensions({ themeMode }),
         createThemeExtensions({ themeMode }),
         decorateMarkdown(),
-        space &&
-          preview({
-            onLookup: async ({ label, ref }) => {
-              log.info('onLookup', { label, ref });
-              const dxn = DXN.parse(ref);
-              if (!dxn) {
-                return null;
-              }
-
-              const object = await resolveRef(client, dxn, space);
-              return { label, object };
-            },
-          }),
+        space && preview(),
         transcript({
           model,
           started: object?.started ? new Date(object.started) : undefined,
@@ -89,5 +90,11 @@ export const Transcript = ({
     };
   }, [space, model]);
 
-  return <div ref={parentRef} className={mx('flex grow overflow-hidden', editorWidth, classNames)} />;
+  return (
+    <div
+      ref={parentRef}
+      className={mx('flex grow overflow-hidden', editorWidth, classNames)}
+      data-popover-collision-boundary={true}
+    />
+  );
 };

package/src/components/Transcript/deprecated/{Transcript.tsx → OldTranscript.tsx}

@@ -3,10 +3,12 @@
 //
 
 import { intervalToDuration } from 'date-fns/intervalToDuration';
+import { Schema } from 'effect';
 import { yieldOrContinue } from 'main-thread-scheduling';
 import React, { type FC, useCallback, useEffect, useMemo, useRef, useState, type WheelEvent } from 'react';
 import { type OnResizeCallback, useResizeDetector } from 'react-resize-detector';
 
+import { Type } from '@dxos/echo';
 import { IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 import {
@@ -20,7 +22,34 @@ import {
 import { mx } from '@dxos/react-ui-theme';
 
 import { TRANSCRIPTION_PLUGIN } from '../../../meta';
-import { type TranscriptBlock } from '../../../types';
+
+/**
+ * Transcription fragment.
+ */
+const TranscriptSegment = Schema.Struct({
+  // TODO(burdon): TS from service is not Unix TS (x1000).
+  started: Schema.String,
+  text: Schema.String,
+});
+
+type TranscriptSegment = Schema.Schema.Type<typeof TranscriptSegment>;
+
+/**
+ * Transcription block (from single speaker).
+ */
+const TranscriptBlock = Schema.Struct({
+  id: Schema.String,
+  authorName: Schema.optional(Schema.String), // TODO(burdon): Replace with identityDid.
+  authorHue: Schema.optional(Schema.String), // TOOD(burdon): Remove.
+  segments: Schema.Array(TranscriptSegment),
+}).pipe(
+  Type.def({
+    typename: 'dxos.org/type/TranscriptBlock',
+    version: '0.1.0',
+  }),
+);
+
+type TranscriptBlock = Schema.Schema.Type<typeof TranscriptBlock>;
 
 // TODO(burdon): Actions (e.g., mark, summarize, translate, label, delete).