@dxos/plugin-transcription 0.8.2-main.f11618f → 0.8.2-main.fbd8ed0

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

@@ -2,25 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Schema } from 'effect';
+import { Rx } from '@effect-rx/rx-react';
+import { Option, pipe, type Schema } from 'effect';
 
-import { Capabilities, contributes, createIntent, type PluginsContext } from '@dxos/app-framework';
+import { Capabilities, contributes, createIntent, type PluginContext } from '@dxos/app-framework';
 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 { Filter, fullyQualifiedId, getSpace, makeRef, Query, 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 { createExtension, rxFromSignal } from '@dxos/plugin-graph';
 import { DocumentType } from '@dxos/plugin-markdown/types';
 import { MeetingCapabilities, type CallState, type MediaState } from '@dxos/plugin-meeting';
 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 { type MessageType, Contact, Organization } from '@dxos/schema';
+import { DataType } from '@dxos/schema';
 
 import { TranscriptionCapabilities } from './capabilities';
 import { processTranscriptMessage } from '../entity-extraction';
@@ -33,10 +34,10 @@ import { TranscriptionAction, type TranscriptionSettingsProps, TranscriptType }
 type TranscriptionPayload = buf.MessageInitShape<typeof TranscriptionPayloadSchema>;
 
 const getMeetingTranscript = async (
-  context: PluginsContext,
+  context: PluginContext,
   meeting: MeetingType,
 ): Promise<TranscriptType | undefined> => {
-  const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
 
   const typename = getSchemaTypename(TranscriptType)!;
   const existing = await meeting.artifacts[typename]?.load();
@@ -52,123 +53,139 @@ const getMeetingTranscript = async (
 };
 
 // TODO(wittjosiah): Introduce a sound that plays when transcription is activated/deactivated.
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(Capabilities.AppGraphBuilder, [
     createExtension({
       id: `${TRANSCRIPTION_PLUGIN}/meeting-transcript`,
-      filter: (node): node is Node<MeetingType> => isInstanceOf(MeetingType, node.data),
-      actions: ({ node }) => {
-        const meeting = node.data;
-        const state = context.requestCapability(TranscriptionCapabilities.MeetingTranscriptionState);
-        return [
-          {
-            id: `${fullyQualifiedId(meeting)}/action/start-stop-transcription`,
-            data: async () => {
-              // 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 callManager = context.requestCapability(MeetingCapabilities.CallManager);
-              callManager.setActivity(getSchemaTypename(TranscriptType)!, {
-                queueDxn: transcript.queue.dxn.toString(),
-                enabled: !state.enabled,
+      actions: (node) =>
+        Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (isInstanceOf(MeetingType, node.data) ? Option.some(node.data) : Option.none())),
+            Option.map((meeting) => {
+              const state = context.getCapability(TranscriptionCapabilities.MeetingTranscriptionState);
+              const enabled = get(rxFromSignal(() => state.enabled));
+              return [
+                {
+                  id: `${fullyQualifiedId(meeting)}/action/start-stop-transcription`,
+                  data: async () => {
+                    // 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 callManager = context.getCapability(MeetingCapabilities.CallManager);
+                    callManager.setActivity(getSchemaTypename(TranscriptType)!, {
+                      queueDxn: transcript.queue.dxn.toString(),
+                      enabled: !enabled,
+                    });
+                  },
+                  properties: {
+                    label: enabled
+                      ? ['stop transcription label', { ns: TRANSCRIPTION_PLUGIN }]
+                      : ['start transcription label', { ns: TRANSCRIPTION_PLUGIN }],
+                    icon: 'ph--subtitles--regular',
+                    disposition: 'toolbar',
+                    classNames: enabled ? 'bg-callAlert' : '',
+                  },
+                },
+              ];
+            }),
+            Option.getOrElse(() => []),
+          ),
+        ),
+      connector: (node) =>
+        Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (isInstanceOf(MeetingType, node.data) ? Option.some(node.data) : Option.none())),
+            Option.map((meeting) => {
+              const client = context.getCapability(ClientCapabilities.Client);
+              const state = context.getCapability(TranscriptionCapabilities.MeetingTranscriptionState);
+              const settingsStore = get(context.capabilities(Capabilities.SettingsStore))[0];
+              const settings = get(
+                rxFromSignal(() => settingsStore?.getStore<TranscriptionSettingsProps>(TRANSCRIPTION_PLUGIN)!.value),
+              );
+
+              // TODO(dmaretskyi): Request via capability.
+              const aiClient: AIServiceClient | undefined = new AIServiceEdgeClient({
+                // TODO(burdon): Get from config.
+                endpoint: AI_SERVICE_ENDPOINT.REMOTE,
               });
-            },
-            properties: {
-              label: state.enabled
-                ? ['stop transcription label', { ns: TRANSCRIPTION_PLUGIN }]
-                : ['start transcription label', { ns: TRANSCRIPTION_PLUGIN }],
-              icon: 'ph--subtitles--regular',
-              disposition: 'toolbar',
-              classNames: state.enabled ? 'bg-callAlert' : '',
-            },
-          },
-        ];
-      },
-      connector: ({ node }) => {
-        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 [
-          {
-            id: `${fullyQualifiedId(meeting)}${ATTENDABLE_PATH_SEPARATOR}${getSchemaTypename(TranscriptType)}`,
-            type: PLANK_COMPANION_TYPE,
-            data: meeting.artifacts[getSchemaTypename(TranscriptType)!]?.target,
-            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 }),
-
-              // 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);
-                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, Contact, 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: async () => {
-                await state.transcriptionManager?.close();
-                state.transcriptionManager = undefined;
-                state.enabled = false;
-              },
-              onCallStateUpdated: async (callState: CallState) => {
-                const typename = getSchemaTypename(TranscriptType);
-                const transcription = typename ? callState.activities?.[typename] : undefined;
-                if (!transcription?.payload) {
-                  return;
-                }
-
-                const payload: TranscriptionPayload = transcription.payload;
-                state.enabled = !!payload.enabled;
-                if (payload.queueDxn) {
-                  // NOTE: Must set queue before enabling transcription.
-                  state.transcriptionManager?.setQueue(DXN.parse(payload.queueDxn));
-                }
-                await state.transcriptionManager?.setEnabled(payload.enabled);
-              },
-              onMediaStateUpdated: async ([mediaState, isSpeaking]: [MediaState, boolean]) => {
-                void state.transcriptionManager?.setAudioTrack(mediaState.audioTrack);
-                void state.transcriptionManager?.setRecording(isSpeaking);
-              },
-            } satisfies MeetingCallProperties,
-          },
-        ];
-      },
+
+              return [
+                {
+                  id: `${fullyQualifiedId(meeting)}${ATTENDABLE_PATH_SEPARATOR}${getSchemaTypename(TranscriptType)}`,
+                  type: PLANK_COMPANION_TYPE,
+                  data: get(rxFromSignal(() => meeting.artifacts[getSchemaTypename(TranscriptType)!]?.target)),
+                  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 }),
+
+                    // TODO(burdon): Is this the right place to inisitalize the state? Change to a capability?
+                    onJoin: async ({ meeting }: { meeting?: MeetingType }) => {
+                      const identity = client.halo.identity.get();
+                      invariant(identity);
+                      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: async () => {
+                      await state.transcriptionManager?.close();
+                      state.transcriptionManager = undefined;
+                      state.enabled = false;
+                    },
+                    onCallStateUpdated: async (callState: CallState) => {
+                      const typename = getSchemaTypename(TranscriptType);
+                      const transcription = typename ? callState.activities?.[typename] : undefined;
+                      if (!transcription?.payload) {
+                        return;
+                      }
+
+                      const payload: TranscriptionPayload = transcription.payload;
+                      state.enabled = !!payload.enabled;
+                      if (payload.queueDxn) {
+                        // NOTE: Must set queue before enabling transcription.
+                        state.transcriptionManager?.setQueue(DXN.parse(payload.queueDxn));
+                      }
+                      await state.transcriptionManager?.setEnabled(payload.enabled);
+                    },
+                    onMediaStateUpdated: async ([mediaState, isSpeaking]: [MediaState, boolean]) => {
+                      void state.transcriptionManager?.setAudioTrack(mediaState.audioTrack);
+                      void state.transcriptionManager?.setRecording(isSpeaking);
+                    },
+                  } satisfies MeetingCallProperties,
+                },
+              ];
+            }),
+            Option.getOrElse(() => []),
+          ),
+        ),
     }),
   ]);
 
@@ -179,14 +196,18 @@ type EntityExtractionEnricherFactoryOptions = {
 };
 
 const createEntityExtractionEnricher = ({ aiClient, contextTypes, space }: EntityExtractionEnricherFactoryOptions) => {
-  return async (message: MessageType) => {
-    const { objects } = await space.db.query(Filter.or(...contextTypes.map((s) => Filter.schema(s)))).run();
+  return async (message: DataType.Message) => {
+    const { objects } = await space.db
+      .query(Query.select(Filter.or(...contextTypes.map((s) => Filter.type(s as Schema.Schema<BaseEchoObject>)))))
+      .run();
     log.info('context', { objects });
 
     const { message: enhancedMessage, timeElapsed } = await processTranscriptMessage({
       aiService: aiClient,
       message,
-      context: { objects: await Promise.all(objects.map(processContextObject)) },
+      context: {
+        objects: await Promise.all(objects.map((o) => processContextObject(o))),
+      },
       options: { timeout: ENTITY_EXTRACTOR_TIMEOUT, fallbackToRaw: true },
     });
 
@@ -195,6 +216,7 @@ const createEntityExtractionEnricher = ({ aiClient, contextTypes, space }: Entit
   };
 };
 
+// TODO(dmaretskyi): Use Type.Any
 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.

package/src/capabilities/intent-resolver.ts

@@ -2,14 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, createResolver, type PluginsContext } from '@dxos/app-framework';
+import { Capabilities, contributes, createResolver, type PluginContext } from '@dxos/app-framework';
+import { createQueueDxn } from '@dxos/echo-schema';
+import { type SpaceId } from '@dxos/keys';
 import { live, refFromDXN } from '@dxos/live-object';
-import { type SpaceId, createQueueDxn } from '@dxos/react-client/echo';
 
 import { TranscriptionAction, TranscriptType } from '../types';
 import { getTimeStr } from '../util';
 
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
       intent: TranscriptionAction.Create,

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

@@ -20,7 +20,7 @@ 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 { Contact, Organization, type MessageType } from '@dxos/schema';
+import { DataType } from '@dxos/schema';
 import { Testing } from '@dxos/schema/testing';
 import { withLayout } from '@dxos/storybook-utils';
 
@@ -69,7 +69,7 @@ const TranscriptContainer: FC<
   );
 };
 
-type StoryProps = { messages?: MessageType[] } & Pick<TranscriptProps, 'ignoreAttention' | 'attendableId'>;
+type StoryProps = { messages?: DataType.Message[] } & Pick<TranscriptProps, 'ignoreAttention' | 'attendableId'>;
 
 /**
  * Basic story mutates array of messages.
@@ -78,11 +78,11 @@ const BasicStory = ({ messages: initialMessages = [], ...props }: StoryProps) =>
   const [reset, setReset] = useState({});
   const builder = useMemo(() => new MessageBuilder(), []);
   const model = useMemo(
-    () => new SerializationModel<MessageType>(renderMarkdown([]), initialMessages),
+    () => new SerializationModel<DataType.Message>(renderMarkdown([]), initialMessages),
     [initialMessages, reset],
   );
   const [running, setRunning] = useState(true);
-  const [currentMessage, setCurrentMessage] = useState<MessageType | null>(null);
+  const [currentMessage, setCurrentMessage] = useState<DataType.Message | null>(null);
   useEffect(() => {
     if (!running) {
       return;
@@ -186,7 +186,7 @@ const meta: Meta<typeof QueueStory> = {
         ThemePlugin({ tx: defaultTx }),
         StorybookLayoutPlugin(),
         ClientPlugin({
-          types: [TestItem, Testing.DocumentType, Contact, Organization],
+          types: [TestItem, Testing.DocumentType, DataType.Person, DataType.Organization],
           onClientInitialized: async (_, client) => {
             await client.halo.createIdentity();
           },
@@ -197,7 +197,7 @@ const meta: Meta<typeof QueueStory> = {
         IntentPlugin(),
       ],
     }),
-    withLayout({ tooltips: true, fullscreen: true }),
+    withLayout({ fullscreen: true }),
   ],
   parameters: {
     translations,

package/src/components/Transcript/Transcript.tsx

@@ -18,7 +18,7 @@ import {
   useTextEditor,
 } from '@dxos/react-ui-editor';
 import { mx } from '@dxos/react-ui-theme';
-import { type MessageType } from '@dxos/schema';
+import { type DataType } from '@dxos/schema';
 import { isNotFalsy } from '@dxos/util';
 
 import { transcript } from './transcript-extension';
@@ -27,7 +27,7 @@ import { type TranscriptType } from '../../types';
 
 export const renderMarkdown =
   (identities: Identity[]) =>
-  (message: MessageType, index: number, debug = false): string[] => {
+  (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 ?? '', ''];
@@ -53,7 +53,7 @@ export const renderMarkdown =
 export type TranscriptProps = ThemedClassName<{
   transcript?: TranscriptType;
   space?: Space;
-  model: SerializationModel<MessageType>;
+  model: SerializationModel<DataType.Message>;
   // TODO(wittjosiah): Move to container.
   attendableId?: string;
   ignoreAttention?: boolean;

package/src/components/Transcript/deprecated/OldTranscript.tsx

@@ -3,11 +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 { EchoObject, S } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
 import { IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 import {
@@ -25,25 +26,30 @@ import { TRANSCRIPTION_PLUGIN } from '../../../meta';
 /**
  * Transcription fragment.
  */
-const TranscriptSegment = S.Struct({
+const TranscriptSegment = Schema.Struct({
   // TODO(burdon): TS from service is not Unix TS (x1000).
-  started: S.String,
-  text: S.String,
+  started: Schema.String,
+  text: Schema.String,
 });
 
-type TranscriptSegment = S.Schema.Type<typeof TranscriptSegment>;
+type TranscriptSegment = Schema.Schema.Type<typeof TranscriptSegment>;
 
 /**
  * Transcription block (from single speaker).
  */
-const TranscriptBlock = S.Struct({
-  id: S.String,
-  authorName: S.optional(S.String), // TODO(burdon): Replace with identityDid.
-  authorHue: S.optional(S.String), // TOOD(burdon): Remove.
-  segments: S.Array(TranscriptSegment),
-}).pipe(EchoObject({ typename: 'dxos.org/type/TranscriptBlock', version: '0.1.0' }));
-
-type TranscriptBlock = S.Schema.Type<typeof TranscriptBlock>;
+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).
 

package/src/components/Transcript/transcript-extension.ts

@@ -9,7 +9,7 @@ import { intervalToDuration } from 'date-fns/intervalToDuration';
 
 import { type CleanupFn, addEventListener, combine } from '@dxos/async';
 import { type RenderCallback } from '@dxos/react-ui-editor';
-import { type MessageType } from '@dxos/schema';
+import { type DataType } from '@dxos/schema';
 
 import { DocumentAdapter, type SerializationModel } from '../../model';
 
@@ -17,7 +17,7 @@ import { DocumentAdapter, type SerializationModel } from '../../model';
  * Data structure that maps Chunks queue to lines with transcript state.
  */
 export type TranscriptOptions = {
-  model: SerializationModel<MessageType>;
+  model: SerializationModel<DataType.Message>;
   started?: Date;
   renderButton?: RenderCallback<{ onClick: () => void }>;
 };
@@ -213,7 +213,7 @@ class TimestampMarker extends GutterMarker {
   }
 }
 
-const getStartTime = (started?: Date, message?: MessageType): Date | undefined => {
+const getStartTime = (started?: Date, message?: DataType.Message): Date | undefined => {
   if (started) {
     return started;
   }

package/src/components/TranscriptContainer.tsx

@@ -7,7 +7,7 @@ import React, { type FC } from 'react';
 import { fullyQualifiedId, getSpace } from '@dxos/client/echo';
 import { useMembers, useQueue } from '@dxos/react-client/echo';
 import { StackItem } from '@dxos/react-ui-stack';
-import { type MessageType } from '@dxos/schema';
+import { type DataType } from '@dxos/schema';
 
 import { Transcript, renderMarkdown } from './Transcript';
 import { useQueueModelAdapter } from '../hooks';
@@ -17,7 +17,7 @@ export const TranscriptionContainer: FC<{ role: string; transcript: TranscriptTy
   const attendableId = fullyQualifiedId(transcript);
   const space = getSpace(transcript);
   const members = useMembers(space?.key).map((member) => member.identity);
-  const queue = useQueue<MessageType>(transcript.queue.dxn, { pollInterval: 1_000 });
+  const queue = useQueue<DataType.Message>(transcript.queue.dxn, { pollInterval: 1_000 });
   const model = useQueueModelAdapter(renderMarkdown(members), queue);
 
   return (

package/src/components/transcription.stories.tsx

@@ -21,7 +21,7 @@ import { withPluginManager } from '@dxos/app-framework/testing';
 import { AIServiceEdgeClient } from '@dxos/assistant';
 import { AI_SERVICE_ENDPOINT } from '@dxos/assistant/testing';
 import { Filter, MemoryQueue } from '@dxos/echo-db';
-import { create } from '@dxos/echo-schema';
+import { create, createQueueDxn } from '@dxos/echo-schema';
 import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ClientPlugin } from '@dxos/plugin-client';
@@ -29,11 +29,11 @@ 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 { createQueueDxn, useQueue, useSpace } from '@dxos/react-client/echo';
+import { useQueue, useSpace } from '@dxos/react-client/echo';
 import { IconButton, Toolbar } from '@dxos/react-ui';
 import { ScrollContainer } from '@dxos/react-ui-components';
 import { defaultTx } from '@dxos/react-ui-theme';
-import { Contact, MessageType, Organization } from '@dxos/schema';
+import { DataType } from '@dxos/schema';
 import { seedTestData, Testing } from '@dxos/schema/testing';
 import { withLayout, withTheme } from '@dxos/storybook-utils';
 
@@ -46,7 +46,7 @@ import { TestItem } from '../testing';
 import { type TranscriberParams } from '../transcriber';
 
 const TranscriptionStory: FC<{
-  model: SerializationModel<MessageType>;
+  model: SerializationModel<DataType.Message>;
   running: boolean;
   onRunningChange: Dispatch<SetStateAction<boolean>>;
 }> = ({ model, running, onRunningChange }) => {
@@ -81,14 +81,14 @@ const Microphone = ({ entityExtraction }: { entityExtraction?: boolean }) => {
 
   // Queue.
   const queueDxn = useMemo(() => createQueueDxn(), []);
-  const queue = useMemo(() => new MemoryQueue<MessageType>(queueDxn), [queueDxn]);
+  const queue = useMemo(() => new MemoryQueue<DataType.Message>(queueDxn), [queueDxn]);
   const model = useQueueModelAdapter(renderMarkdown([]), queue);
   const space = useSpace();
 
   // Transcriber.
   const handleSegments = useCallback<TranscriberParams['onSegments']>(
     async (blocks) => {
-      const message = create(MessageType, { sender: { name: 'You' }, created: new Date().toISOString(), blocks });
+      const message = create(DataType.Message, { sender: { name: 'You' }, created: new Date().toISOString(), blocks });
 
       if (entityExtraction) {
         if (!space) {
@@ -97,7 +97,13 @@ const Microphone = ({ entityExtraction }: { entityExtraction?: boolean }) => {
         }
         // TODO(dmaretskyi): Move to vector search index.
         const { objects } = await space.db
-          .query(Filter.or(Filter.schema(Contact), Filter.schema(Organization), Filter.schema(Testing.DocumentType)))
+          .query(
+            Filter.or(
+              Filter.type(DataType.Person),
+              Filter.type(DataType.Organization),
+              Filter.type(Testing.DocumentType),
+            ),
+          )
           .run();
 
         log.info('context', { objects });
@@ -176,11 +182,11 @@ const AudioFile = ({ queueDxn, audioUrl }: { queueDxn: DXN; audioUrl: string; tr
   }, [audio, running]);
 
   // Transcriber.
-  const queue = useQueue<MessageType>(queueDxn, { pollInterval: 500 });
+  const queue = useQueue<DataType.Message>(queueDxn, { pollInterval: 500 });
   const model = useQueueModelAdapter(renderMarkdown([]), queue);
   const handleSegments = useCallback<TranscriberParams['onSegments']>(
     async (blocks) => {
-      const message = create(MessageType, { sender: { name: 'You' }, created: new Date().toISOString(), blocks });
+      const message = create(DataType.Message, { sender: { name: 'You' }, created: new Date().toISOString(), blocks });
       void queue?.append([message]);
     },
     [queue],
@@ -224,7 +230,7 @@ const meta: Meta<typeof AudioFile> = {
         ThemePlugin({ tx: defaultTx }),
         StorybookLayoutPlugin(),
         ClientPlugin({
-          types: [TestItem, Contact, Organization, Testing.DocumentType],
+          types: [TestItem, DataType.Person, DataType.Organization, Testing.DocumentType],
           onClientInitialized: async (_, client) => {
             await client.halo.createIdentity();
             await client.spaces.waitUntilReady();
@@ -258,11 +264,7 @@ const meta: Meta<typeof AudioFile> = {
       // ],
     }),
     withTheme,
-    withLayout({
-      tooltips: true,
-      fullscreen: true,
-      classNames: 'justify-center',
-    }),
+    withLayout({ fullscreen: true, classNames: 'justify-center' }),
   ],
 };