@dxos/plugin-thread 0.8.4-main.28f8d3d → 0.8.4-main.2c6827d

package/src/calls-service.stories.tsx

@@ -2,8 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { scheduleTask, sleep } from '@dxos/async';
@@ -13,14 +12,15 @@ import { log } from '@dxos/log';
 import { Config, useConfig } from '@dxos/react-client';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { Button } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
 import { Json } from '@dxos/react-ui-syntax-highlighter';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
 
-import video from '../testing/video.mp4?raw';
+const testVideo = new URL('../testing/video.mp4', import.meta.url).href;
 
 import { CALLS_URL, CallsServicePeer, type TrackObject } from './calls';
-import { useInaudibleAudioStreamTrack, useVideoStreamTrack } from './hooks';
+import { useBlackCanvasStreamTrack, useInaudibleAudioStreamTrack, useVideoStreamTrack } from './hooks';
 
+// TODO(burdon): THIS IS TOO COMPLEX FOR A TEST SETUP.
 const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
   const config = useConfig();
   const callsConfig = {
@@ -35,16 +35,18 @@ const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
   const [pulledTrack, setPulledTrack] = useState<MediaStreamTrack | undefined>(undefined);
   const hadRun = useRef(false);
 
+  const deps: any[] = [];
   // Push/pull video stream track to cloudflare.
   useEffect(() => {
     if (hadRun.current || !mediaStreamTrack || !peerPush || !peerPull) {
-      log.info('not running', { hadRun: hadRun.current, mediaStreamTrack, peerPush, peerPull });
       return;
     }
     hadRun.current = true;
     const ctx = Context.default();
+    log.info('setting up ctx', { ctx, mediaStreamTrack, peerPush, peerPull });
+    deps.push([ctx, mediaStreamTrack, peerPush, peerPull]);
     ctx.onDispose(() => {
-      log.info('disposing ctx', { ctx });
+      log.info('disposing ctx', {});
     });
     scheduleTask(
       ctx,
@@ -60,15 +62,12 @@ const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
         // Push track to cloudflare.
         performance.mark('push:begin');
         log.info('pushing track', { track: mediaStreamTrack });
-        trackInfo.current = await peerPush.pushTrack({ track: mediaStreamTrack });
+        trackInfo.current = await peerPush.pushTrack({ track: mediaStreamTrack, ctx: Context.default() });
         performance.mark('push:end');
         const pushTime = performance.measure('push', 'push:begin', 'push:end').duration;
         log.info('successfully pushed track', { pushTime, trackInfo: trackInfo.current });
         setMetrics((prev) => ({ ...prev, 'time to push track [ms]': Math.round(pushTime) }));
 
-        // Wait for cloudflare to process the track.
-        await sleep(1000);
-
         // Pull track from cloudflare.
         performance.mark('pullTrack:begin');
         pullCtx.current = Context.default();
@@ -104,7 +103,10 @@ const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
 
   const rePullTrack = useCallback(async () => {
     performance.mark('rePullVideo:begin');
-    invariant(pulledTrack);
+    if (!pulledTrack) {
+      log.info('no pulled track, skipping re-pull', { pulledTrack });
+      return;
+    }
     pulledTrack.stop();
     await pullCtx.current!.dispose();
     pullCtx.current = Context.default();
@@ -123,12 +125,57 @@ const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
     pulledTrack,
     rePullTrack,
     metrics,
+    pushService: peerPush,
+    pullService: peerPull,
   };
 };
 
+type StoryProps = { source: string };
+
+const DefaultStory = ({ source }: StoryProps) => {
+  const pushVideoElement = useRef<HTMLVideoElement>(null);
+  const pullVideoElement = useRef<HTMLVideoElement>(null);
+  // Get video stream track.
+  const videoStreamTrack = useVideoStreamTrack(pushVideoElement, source);
+  const { pulledTrack, rePullTrack, metrics } = pushAndPullTrack(videoStreamTrack);
+  const hadRun = useRef(false);
+
+  // Push/pull video stream track to cloudflare.
+  useEffect(() => {
+    if (!pulledTrack || hadRun.current) {
+      return;
+    }
+    hadRun.current = true;
+    const ctx = Context.default();
+    scheduleTask(ctx, async () => {
+      pullVideoElement.current!.srcObject = new MediaStream([pulledTrack]);
+      await pullVideoElement.current!.play();
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [pulledTrack]);
+
+  return (
+    <div className='grid grid-rows-3 gap-4 items-center'>
+      <video ref={pushVideoElement} muted autoPlay loop />
+      <div className='flex flex-col gap-4'>
+        <video ref={pullVideoElement} muted />
+        <Button disabled={!pulledTrack} onClick={rePullTrack}>
+          Re-pull video
+        </Button>
+      </div>
+      <Json data={metrics} />
+    </div>
+  );
+};
+
 const meta = {
   title: 'plugins/plugin-thread/calls-service',
+  render: DefaultStory,
   decorators: [
+    withTheme,
     withClientProvider({
       config: new Config({
         runtime: {
@@ -138,72 +185,25 @@ const meta = {
         },
       }),
     }),
-    withTheme,
-    withLayout(),
   ],
   parameters: {
     layout: 'centered',
   },
-};
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
 
-export const Default = {
-  render: ({ videoSrc }: { videoSrc: string }) => {
-    const pushVideoElement = useRef<HTMLVideoElement>(null);
-    const pullVideoElement = useRef<HTMLVideoElement>(null);
-    // Get video stream track.
-    const videoStreamTrack = useVideoStreamTrack(pushVideoElement, videoSrc);
-    const { pulledTrack, rePullTrack, metrics } = pushAndPullTrack(videoStreamTrack);
-    const hadRun = useRef(false);
-
-    // Push/pull video stream track to cloudflare.
-    useEffect(() => {
-      if (!pulledTrack || hadRun.current) {
-        return;
-      }
-      hadRun.current = true;
-      const ctx = Context.default();
-      scheduleTask(ctx, async () => {
-        pullVideoElement.current!.srcObject = new MediaStream([pulledTrack]);
-        await pullVideoElement.current!.play();
-      });
-
-      return () => {
-        void ctx.dispose();
-      };
-    }, [pulledTrack]);
+type Story = StoryObj<typeof meta>;
 
-    return (
-      <div className='grid grid-rows-3 gap-4 items-center'>
-        <video ref={pushVideoElement} muted autoPlay loop />
-        <div className='flex flex-col gap-4'>
-          <video ref={pullVideoElement} muted />
-          <Button
-            disabled={
-              !(
-                pullVideoElement?.current?.srcObject instanceof MediaStream &&
-                pullVideoElement.current.srcObject.getTracks()[0]
-              )
-            }
-            onClick={rePullTrack}
-          >
-            Re-pull video
-          </Button>
-        </div>
-        <Json data={metrics} />
-      </div>
-    );
-  },
+export const Default: Story = {
   args: {
-    videoSrc: video,
+    source: testVideo,
   },
 };
 
 export const InaudibleAudioStreamTrack = {
   render: () => {
     const audioStreamTrack = useInaudibleAudioStreamTrack();
-
     const { rePullTrack, metrics } = pushAndPullTrack(audioStreamTrack);
 
     return (
@@ -214,3 +214,16 @@ export const InaudibleAudioStreamTrack = {
     );
   },
 };
+
+export const BlackVideoStreamTrack = {
+  render: () => {
+    const videoStreamTrack = useBlackCanvasStreamTrack();
+    const { rePullTrack, metrics } = pushAndPullTrack(videoStreamTrack);
+    return (
+      <div className='flex flex-col gap-4 items-center'>
+        <Json data={metrics} />
+        <Button onClick={rePullTrack}>Re-pull audio</Button>
+      </div>
+    );
+  },
+};

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

@@ -2,38 +2,40 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
+import { Atom } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { Obj } from '@dxos/echo';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, createExtension, rxFromSignal } from '@dxos/plugin-graph';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { ROOT_ID, atomFromSignal, createExtension } from '@dxos/plugin-graph';
 
-import { THREAD_PLUGIN, meta } from '../meta';
-import { ChannelType, ThreadAction } from '../types';
+import { meta } from '../meta';
+import { Channel, ThreadAction } from '../types';
 import { getAnchor } from '../util';
 
 import { ThreadCapabilities } from './capabilities';
 
+// TODO(wittjosiah): Highlight active calls in L1.
+//  Track active meetings by subscribing to meetings query and polling the swarms of recent meetings in the space.
 export default (context: PluginContext) => {
   const resolve = (typename: string) =>
     context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
 
   return contributes(Capabilities.AppGraphBuilder, [
     createExtension({
-      id: `${THREAD_PLUGIN}/active-call`,
+      id: `${meta.id}/active-call`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
             Option.map((node) => {
               const [call] = get(context.capabilities(ThreadCapabilities.CallManager));
               return get(
-                rxFromSignal(() =>
+                atomFromSignal(() =>
                   call?.joined
                     ? [
                         {
@@ -41,7 +43,7 @@ export default (context: PluginContext) => {
                           type: DECK_COMPANION_TYPE,
                           data: null,
                           properties: {
-                            label: ['call panel label', { ns: THREAD_PLUGIN }],
+                            label: ['call panel label', { ns: meta.id }],
                             icon: 'ph--video-conference--regular',
                             position: 'hoist',
                             disposition: 'hidden',
@@ -59,16 +61,18 @@ export default (context: PluginContext) => {
     // TODO(wittjosiah): The channel shouldn't become the companion during a call.
     //   Alternative: the call/meeting/thread should be a child node of the channel and that should be opened.
     createExtension({
-      id: `${THREAD_PLUGIN}/channel-chat-companion`,
+      id: `${meta.id}/channel-chat-companion`,
       connector: (node) => {
-        return Rx.make((get) => {
-          return pipe(
+        return Atom.make((get) => {
+          return Function.pipe(
             get(node),
-            Option.flatMap((node) => (Obj.instanceOf(ChannelType, node.data) ? Option.some(node.data) : Option.none())),
+            Option.flatMap((node) =>
+              Obj.instanceOf(Channel.Channel, node.data) ? Option.some(node.data) : Option.none(),
+            ),
             Option.map((channel) => {
               const callManager = context.getCapability(ThreadCapabilities.CallManager);
               const joined = get(
-                rxFromSignal(() => callManager.joined && callManager.roomId === fullyQualifiedId(channel)),
+                atomFromSignal(() => callManager.joined && callManager.roomId === Obj.getDXN(channel).toString()),
               );
               if (!joined) {
                 return [];
@@ -76,11 +80,11 @@ export default (context: PluginContext) => {
 
               return [
                 {
-                  id: `${fullyQualifiedId(channel)}${ATTENDABLE_PATH_SEPARATOR}chat`,
+                  id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
                   type: PLANK_COMPANION_TYPE,
                   data: 'chat',
                   properties: {
-                    label: ['channel companion label', { ns: THREAD_PLUGIN }],
+                    label: ['channel companion label', { ns: meta.id }],
                     icon: 'ph--hash--regular',
                     position: 'hoist',
                     disposition: 'hidden',
@@ -96,11 +100,11 @@ export default (context: PluginContext) => {
     createExtension({
       id: `${meta.id}/comments-companion`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
+              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
                 return Option.none();
               }
               const metadata = resolve(Obj.getTypename(node.data)!);
@@ -126,11 +130,11 @@ export default (context: PluginContext) => {
     createExtension({
       id: `${meta.id}/comment-toolbar`,
       actions: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
+              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
                 return Option.none();
               }
               const metadata = resolve(Obj.getTypename(node.data)!);
@@ -140,28 +144,37 @@ export default (context: PluginContext) => {
               const selectionManager = context.getCapability(AttentionCapabilities.Selection);
               const toolbar = get(context.capabilities(ThreadCapabilities.State))[0]?.state.toolbar ?? {};
               const disabled = get(
-                rxFromSignal(() => {
+                atomFromSignal(() => {
                   const metadata = resolve(Obj.getTypename(object)!);
-                  const selection = selectionManager.getSelection(fullyQualifiedId(object), metadata.selectionMode);
+                  const selection = selectionManager.getSelection(
+                    Obj.getDXN(object).toString(),
+                    metadata.selectionMode,
+                  );
                   const anchor = getAnchor(selection);
                   const invalidSelection = !anchor;
-                  const overlappingComment = toolbar[fullyQualifiedId(object)];
+                  const overlappingComment = toolbar[Obj.getDXN(object).toString()];
                   return (metadata.comments === 'anchored' && invalidSelection) || overlappingComment;
                 }),
               );
 
               return [
                 {
-                  id: `${fullyQualifiedId(object)}/comment`,
+                  id: `${Obj.getDXN(object).toString()}/comment`,
                   data: () => {
                     const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
                     const metadata = resolve(Obj.getTypename(object)!);
-                    const selection = selectionManager.getSelection(fullyQualifiedId(object));
+                    const selection = selectionManager.getSelection(Obj.getDXN(object).toString());
                     // TODO(wittjosiah): Use presence of selection to determine if the comment should be anchored.
                     // Requires all components which support selection (e.g. table/kanban) to support anchored comments.
                     const anchor = metadata.comments === 'anchored' ? getAnchor(selection) : Date.now().toString();
                     const name = metadata.getAnchorLabel?.(object, anchor);
-                    void dispatch(createIntent(ThreadAction.Create, { anchor, name, subject: object }));
+                    void dispatch(
+                      createIntent(ThreadAction.Create, {
+                        anchor,
+                        name,
+                        subject: object,
+                      }),
+                    );
                   },
                   properties: {
                     label: ['add comment label', { ns: meta.id }],

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { type FunctionDefinition } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+import { createProposals } from '../functions';
+
+const functions: FunctionDefinition[] = [createProposals];
+
+export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/thread';
+
+export default (): Capability<any>[] => [
+  contributes(Capabilities.Functions, functions),
+  contributes(
+    Capabilities.BlueprintDefinition,
+    Blueprint.make({
+      key: ASSISTANT_BLUEPRINT_KEY,
+      name: 'Thread',
+      tools: Blueprint.toolDefinitions({ functions }),
+      instructions: Template.make({
+        // TODO(wittjosiah): Move example to function input schema annotation.
+        source: trim`
+            You can update markdown documents via proposals.
+            For each diff, respond with the smallest possible matching span.
+            For example:
+              - "There is a tyop in this sentence."
+              + "There is a typo in this sentence."
+              - "This id goof."
+              + "This is good."
+          `,
+      }),
+    }),
+  ),
+];

package/src/capabilities/capabilities.ts

@@ -6,28 +6,28 @@ import { defineCapability } from '@dxos/app-framework';
 import { type DeepReadonly } from '@dxos/util';
 
 import { type CallManager, type CallState, type MediaState } from '../calls';
-import { THREAD_PLUGIN } from '../meta';
-import { type ChannelType, type ThreadState, type ViewState } from '../types';
+import { meta } from '../meta';
+import { type Channel, type ThreadState, type ViewState } from '../types';
 
 export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${THREAD_PLUGIN}/capability/call-manager`);
+  export const CallManager = defineCapability<CallManager>(`${meta.id}/capability/call-manager`);
 
   // TODO(burdon): Better way to define specific extensions for meeting companions.
   // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
   // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
   export type CallProperties = {
-    onJoin: (state: { channel?: ChannelType; roomId?: string }) => Promise<void>;
+    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;
     onLeave: (roomId?: string) => Promise<void>;
     onCallStateUpdated: (callState: CallState) => Promise<void>;
     onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
   };
-  export const CallExtension = defineCapability<CallProperties>(`${THREAD_PLUGIN}/capability/call-extension`);
+  export const CallExtension = defineCapability<CallProperties>(`${meta.id}/capability/call-extension`);
 
   type GetViewState = (subjectId: string) => ViewState;
   export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
+    `${meta.id}/capability/state`,
   );
   export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
+    `${meta.id}/capability/state`,
   );
 }

package/src/capabilities/index.ts

@@ -5,6 +5,7 @@
 import { lazy } from '@dxos/app-framework';
 
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
 export const CallManager = lazy(() => import('./call-manager'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const Markdown = lazy(() => import('./markdown'));

package/src/capabilities/intent-resolver.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
 import { sleep } from '@dxos/async';
@@ -11,23 +11,23 @@ import { invariant } from '@dxos/invariant';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
+import { Ref, getSpace } from '@dxos/react-client/echo';
+import { AnchoredTo, Message, Thread } from '@dxos/types';
 
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadAction, ThreadType } from '../types';
+import { meta } from '../meta';
+import { Channel, ThreadAction } from '../types';
 
 import { ThreadCapabilities } from './capabilities';
 
 export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: ThreadAction.OnSpaceCreated,
+      intent: ThreadAction.onCreateSpace,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
           const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(ChannelType) }),
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(Channel.Channel) }),
           );
           rootCollection.objects.push(Ref.make(collection));
 
@@ -41,18 +41,14 @@ export default (context: PluginContext) =>
       intent: ThreadAction.CreateChannel,
       resolve: ({ name }) => ({
         data: {
-          object: Obj.make(ChannelType, {
-            name,
-            defaultThread: Ref.make(Obj.make(ThreadType, { messages: [], status: 'active' })),
-            threads: [],
-          }),
+          object: Channel.make({ name }),
         },
       }),
     }),
     createResolver({
       intent: ThreadAction.CreateChannelThread,
       resolve: ({ channel }) => {
-        const thread = Obj.make(ThreadType, { messages: [], status: 'active' });
+        const thread = Thread.make({ status: 'active' });
         channel.threads.push(Ref.make(thread));
         return {
           data: {
@@ -65,13 +61,10 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.Create,
       resolve: ({ name, anchor: _anchor, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = Obj.make(ThreadType, { name, messages: [], status: 'staged' });
-        const anchor = Relation.make(AnchoredTo, {
+        const subjectId = Obj.getDXN(subject).toString();
+        const thread = Thread.make({ name });
+        const anchor = Relation.make(AnchoredTo.AnchoredTo, {
           [Relation.Source]: thread,
           [Relation.Target]: subject,
           anchor: _anchor,
@@ -86,7 +79,7 @@ export default (context: PluginContext) =>
 
         return {
           intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+            createIntent(ThreadAction.Select, { current: Obj.getDXN(thread).toString() }),
             createIntent(DeckAction.ChangeCompanion, {
               primary: subjectId,
               companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
@@ -131,9 +124,9 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.Delete,
       resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as ThreadType);
+        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        const subjectId = Obj.getDXN(subject).toString();
         const draft = state.drafts[subjectId];
         if (draft) {
           // Check if we're deleting a draft; if so, remo ve it.
@@ -157,7 +150,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
+              message: ['thread deleted label', { ns: meta.id }],
               data: { thread, anchor },
             },
             intents: [
@@ -193,14 +186,13 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.AddMessage,
       resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        const subjectId = Obj.getDXN(subject).toString();
         const space = getSpace(subject);
         invariant(space, 'Space not found');
-        const intents = [];
 
-        const message = Obj.make(DataType.Message, {
+        const message = Obj.make(Message.Message, {
           created: new Date().toISOString(),
           sender,
           blocks: [{ _tag: 'text', text }],
@@ -209,6 +201,7 @@ export default (context: PluginContext) =>
         });
         thread.messages.push(Ref.make(message));
 
+        const intents = [];
         const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
         if (draft) {
           // Move draft to document.
@@ -219,7 +212,7 @@ export default (context: PluginContext) =>
           intents.push(
             createIntent(SpaceAction.AddRelation, {
               space,
-              schema: AnchoredTo,
+              schema: AnchoredTo.AnchoredTo,
               source: thread,
               target: subject,
               fields: { anchor: draft.anchor },
@@ -255,7 +248,7 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.DeleteMessage,
       resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const space = getSpace(subject);
         invariant(space, 'Space not found');
 
@@ -277,7 +270,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['message deleted label', { ns: THREAD_PLUGIN }],
+              message: ['message deleted label', { ns: meta.id }],
               data: { message, messageIndex },
             },
             intents: [

package/src/capabilities/markdown.ts

@@ -5,9 +5,9 @@
 import { EditorView } from '@codemirror/view';
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
 import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
 
 import { threads } from '../extensions';
@@ -22,17 +22,19 @@ export default (context: PluginContext) =>
       return threads(state, doc, dispatch);
     },
     ({ document: doc }) => {
+      if (!doc) return [];
       const { state } = context.getCapability(ThreadCapabilities.MutableState);
 
       return EditorView.updateListener.of((update) => {
         if (update.docChanged || update.selectionSet) {
-          state.toolbar[fullyQualifiedId(doc)] = selectionOverlapsComment(update.state);
+          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
         }
       });
     },
     ({ document: doc }) => {
+      if (!doc) return [];
       const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = fullyQualifiedId(doc);
+      const id = Obj.getDXN(doc).toString();
 
       return EditorView.updateListener.of((update) => {
         update.transactions.forEach((transaction) => {