@dxos/plugin-thread 0.8.4-main.9735255 → 0.8.4-main.abd8ff62ef

package/src/calls-service.stories.tsx

@@ -12,13 +12,14 @@ 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 { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
 import { withTheme } from '@dxos/react-ui/testing';
-import { Json } from '@dxos/react-ui-syntax-highlighter';
 
 const testVideo = new URL('../testing/video.mp4', import.meta.url).href;
 
+import { useBlackCanvasStreamTrack, useInaudibleAudioStreamTrack, useVideoStreamTrack } from '#hooks';
+
 import { CALLS_URL, CallsServicePeer, type TrackObject } from './calls';
-import { useBlackCanvasStreamTrack, useInaudibleAudioStreamTrack, useVideoStreamTrack } from './hooks';
 
 // TODO(burdon): THIS IS TOO COMPLEX FOR A TEST SETUP.
 const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
@@ -130,9 +131,9 @@ const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
   };
 };
 
-type StoryProps = { source: string };
+type DefaultStoryProps = { source: string };
 
-const DefaultStory = ({ source }: StoryProps) => {
+const DefaultStory = ({ source }: DefaultStoryProps) => {
   const pushVideoElement = useRef<HTMLVideoElement>(null);
   const pullVideoElement = useRef<HTMLVideoElement>(null);
   // Get video stream track.
@@ -166,16 +167,16 @@ const DefaultStory = ({ source }: StoryProps) => {
           Re-pull video
         </Button>
       </div>
-      <Json data={metrics} />
+      <JsonHighlighter data={metrics} />
     </div>
   );
 };
 
 const meta = {
-  title: 'plugins/plugin-thread/calls-service',
+  title: 'plugins/plugin-thread/experimental/Calls',
   render: DefaultStory,
   decorators: [
-    withTheme,
+    withTheme(),
     withClientProvider({
       config: new Config({
         runtime: {
@@ -208,7 +209,7 @@ export const InaudibleAudioStreamTrack = {
 
     return (
       <div className='flex flex-col gap-4 items-center'>
-        <Json data={metrics} />
+        <JsonHighlighter data={metrics} />
         <Button onClick={rePullTrack}>Re-pull audio</Button>
       </div>
     );
@@ -221,7 +222,7 @@ export const BlackVideoStreamTrack = {
     const { rePullTrack, metrics } = pushAndPullTrack(videoStreamTrack);
     return (
       <div className='flex flex-col gap-4 items-center'>
-        <Json data={metrics} />
+        <JsonHighlighter data={metrics} />
         <Button onClick={rePullTrack}>Re-pull audio</Button>
       </div>
     );

package/src/capabilities/{app-graph-builder/app-graph-builder.ts → app-graph-builder.ts}

@@ -6,17 +6,21 @@ import { Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, AppNode } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { AttentionCapabilities } from '@dxos/plugin-attention/types';
 import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
 import { type SelectionManager, type SelectionMode, defaultSelection } from '@dxos/react-ui-attention';
+import { Channel } from '@dxos/types';
 
-import { meta } from '../../meta';
-import { Channel, ThreadCapabilities, ThreadOperation, type ThreadState } from '../../types';
-import { getAnchor } from '../../util';
+import { meta } from '#meta';
+import { ThreadOperation } from '#operations';
+import { ThreadCapabilities, type ThreadState } from '#types';
+
+import { getAnchor } from '../util';
 
 type CommentDisabledParams = {
   stateAtom: Atom.Atom<Atom.Writable<ThreadState>[]>;
@@ -59,11 +63,11 @@ export default Capability.makeModule(
     const capabilities = yield* Capability.Service;
 
     const resolve = (typename: string) =>
-      capabilities.getAll(Common.Capability.Metadata).find(({ id }: { id: string }) => id === typename)?.metadata ?? {};
+      capabilities.getAll(AppCapabilities.Metadata).find(({ id }: { id: string }) => id === typename)?.metadata ?? {};
 
     const extensions = yield* Effect.all([
       GraphBuilder.createExtension({
-        id: `${meta.id}/active-call`,
+        id: 'active-call',
         match: NodeMatcher.whenRoot,
         connector: (node, get) => {
           const callManagerAtom = capabilities.atom(ThreadCapabilities.CallManager);
@@ -76,24 +80,20 @@ export default Capability.makeModule(
           return Effect.succeed(
             joined
               ? [
-                  {
-                    id: `${node.id}${ATTENDABLE_PATH_SEPARATOR}active-call`,
-                    type: DECK_COMPANION_TYPE,
+                  AppNode.makeDeckCompanion({
+                    id: 'active-call',
+                    label: ['call-panel.label', { ns: meta.id }],
+                    icon: 'ph--video-conference--regular',
                     data: null,
-                    properties: {
-                      label: ['call panel label', { ns: meta.id }],
-                      icon: 'ph--video-conference--regular',
-                      position: 'hoist',
-                      disposition: 'hidden',
-                    },
-                  },
+                    position: 'hoist',
+                  }),
                 ]
               : [],
           );
         },
       }),
       GraphBuilder.createTypeExtension({
-        id: `${meta.id}/channel-chat-companion`,
+        id: 'channel-chat-companion',
         type: Channel.Channel,
         connector: (channel, get) => {
           const callManager = capabilities.get(ThreadCapabilities.CallManager);
@@ -106,22 +106,18 @@ export default Capability.makeModule(
           }
 
           return Effect.succeed([
-            {
-              id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
-              type: PLANK_COMPANION_TYPE,
+            AppNode.makeCompanion({
+              id: 'chat',
+              label: ['channel-companion.label', { ns: meta.id }],
+              icon: 'ph--hash--regular',
               data: 'chat',
-              properties: {
-                label: ['channel companion label', { ns: meta.id }],
-                icon: 'ph--hash--regular',
-                position: 'hoist',
-                disposition: 'hidden',
-              },
-            },
+              position: 'hoist',
+            }),
           ]);
         },
       }),
       GraphBuilder.createExtension({
-        id: `${meta.id}/comments-companion`,
+        id: 'comments-companion',
         match: (node) => {
           if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
             return Option.none();
@@ -129,41 +125,38 @@ export default Capability.makeModule(
           const metadata = resolve(Obj.getTypename(node.data)!);
           return typeof metadata.comments === 'string' ? Option.some(node) : Option.none();
         },
-        connector: (node) =>
+        connector: () =>
           Effect.succeed([
-            {
-              id: [node.id, 'comments'].join(ATTENDABLE_PATH_SEPARATOR),
-              type: PLANK_COMPANION_TYPE,
+            AppNode.makeCompanion({
+              id: linkedSegment('comments'),
+              label: ['comments.label', { ns: meta.id }],
+              icon: 'ph--chat-text--regular',
               data: 'comments',
-              properties: {
-                label: ['comments label', { ns: meta.id }],
-                icon: 'ph--chat-text--regular',
-                disposition: 'hidden',
-                position: 'hoist',
-              },
-            },
+              position: 'hoist',
+            }),
           ]),
       }),
       GraphBuilder.createExtension({
-        id: `${meta.id}/comment-toolbar`,
+        id: 'comment-toolbar',
         match: (node) => {
           if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
             return Option.none();
           }
           const metadata = resolve(Obj.getTypename(node.data)!);
-          return typeof metadata.comments === 'string' ? Option.some(node.data) : Option.none();
+          return typeof metadata.comments === 'string' ? Option.some(node) : Option.none();
         },
-        actions: (object, get) => {
+        actions: (matched, get) => {
+          const object = matched.data;
+          const objectDxn = Obj.getDXN(object).toString();
           const stateAtom = capabilities.atom(ThreadCapabilities.State);
           const selectionManager = capabilities.get(AttentionCapabilities.Selection);
-          const objectId = Obj.getDXN(object).toString();
           const metadata = resolve(Obj.getTypename(object)!);
 
           const disabled = get(
             commentDisabledFamily({
               stateAtom,
               selectionManager,
-              objectId,
+              objectId: objectDxn,
               commentsType: metadata.comments as string,
               selectionMode: metadata.selectionMode,
             }),
@@ -171,10 +164,10 @@ export default Capability.makeModule(
 
           return Effect.succeed([
             {
-              id: `${Obj.getDXN(object).toString()}/comment`,
+              id: 'comment',
               data: Effect.fnUntraced(function* () {
                 const metadata = resolve(Obj.getTypename(object)!);
-                const selection = selectionManager.getSelection(Obj.getDXN(object).toString());
+                const selection = selectionManager.getSelection(objectDxn);
                 const anchor = metadata.comments === 'anchored' ? getAnchor(selection) : Date.now().toString();
                 const name = metadata.getAnchorLabel?.(object, anchor);
                 yield* Operation.invoke(ThreadOperation.Create, {
@@ -184,7 +177,7 @@ export default Capability.makeModule(
                 });
               }),
               properties: {
-                label: ['add comment label', { ns: meta.id }],
+                label: ['add-comment.label', { ns: meta.id }],
                 icon: 'ph--chat-text--regular',
                 disposition: 'toolbar',
                 disabled,
@@ -196,6 +189,6 @@ export default Capability.makeModule(
       }),
     ]);
 
-    return Capability.contributes(Common.Capability.AppGraphBuilder, extensions);
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
   }),
 );

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
+
+import { ThreadBlueprint } from '#blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ThreadBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/{call-manager/call-manager.ts → call-manager.ts}

@@ -4,16 +4,17 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { ClientCapabilities } from '@dxos/plugin-client';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
 
-import { CallManager } from '../../calls';
-import { ThreadCapabilities } from '../../types';
+import { ThreadCapabilities } from '#types';
+
+import { CallManager } from '../calls';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const client = yield* Capability.get(ClientCapabilities.Client);
-    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
     const callManager = new CallManager(client, registry);
     yield* Effect.tryPromise(() => callManager.open());
 

package/src/capabilities/index.ts

@@ -2,13 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './app-graph-builder';
-export * from './blueprint-definition';
-export * from './call-manager';
-export * from './markdown';
-export * from './operation-resolver';
-export * from './react-root';
-export * from './react-surface';
-export * from './repair';
-export * from './settings';
-export * from './state';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const CallManager = Capability.lazy('CallManager', () => import('./call-manager'));
+export const Markdown = Capability.lazy('Markdown', () => import('./markdown'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const ThreadSettings = Capability.lazy('ThreadSettings', () => import('./settings'));
+export const ThreadState = Capability.lazy('ThreadState', () => import('./state'));
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/{markdown/markdown.ts → markdown.ts}

@@ -5,14 +5,15 @@
 import { EditorView } from '@codemirror/view';
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
-import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/ui-editor';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown/types';
+import { linkedSegment } from '@dxos/react-ui-attention';
+import { type EditorState, commentClickedEffect, commentsState, documentId, overlap } from '@dxos/ui-editor';
 
-import { threads } from '../../extensions';
-import { ThreadCapabilities } from '../../types';
+import { ThreadCapabilities } from '#types';
+
+import { threads } from '../extensions';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
@@ -21,40 +22,42 @@ export default Capability.makeModule(
 
     return Capability.contributes(MarkdownCapabilities.Extensions, [
       ({ document: doc }) => {
-        const { invokePromise } = capabilities.get(Common.Capability.OperationInvoker);
-        const registry = capabilities.get(Common.Capability.AtomRegistry);
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+        const registry = capabilities.get(Capabilities.AtomRegistry);
         const stateAtom = capabilities.get(ThreadCapabilities.State);
         return threads({ registry, stateAtom }, doc, invokePromise);
       },
       ({ document: doc }) => {
-        if (!doc) return [];
-        const registry = capabilities.get(Common.Capability.AtomRegistry);
+        if (!doc) {
+          return [];
+        }
+        const registry = capabilities.get(Capabilities.AtomRegistry);
         const stateAtom = capabilities.get(ThreadCapabilities.State);
 
         return EditorView.updateListener.of((update) => {
           if (update.docChanged || update.selectionSet) {
-            const objectId = Obj.getDXN(doc).toString();
+            const id = update.state.facet(documentId);
             const overlaps = selectionOverlapsComment(update.state);
             const current = registry.get(stateAtom);
             registry.set(stateAtom, {
               ...current,
-              toolbar: { ...current.toolbar, [objectId]: overlaps },
+              toolbar: { ...current.toolbar, [id]: overlaps },
             });
           }
         });
       },
       ({ document: doc }) => {
-        if (!doc) return [];
-        const { invokePromise } = capabilities.get(Common.Capability.OperationInvoker);
-        const id = Obj.getDXN(doc).toString();
+        if (!doc) {
+          return [];
+        }
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
 
         return EditorView.updateListener.of((update) => {
           update.transactions.forEach((transaction) => {
             transaction.effects.forEach(async (effect) => {
               if (effect.is(commentClickedEffect)) {
-                void invokePromise(DeckOperation.ChangeCompanion, {
-                  primary: id,
-                  companion: `${id}${ATTENDABLE_PATH_SEPARATOR}comments`,
+                void invokePromise(LayoutOperation.UpdateCompanion, {
+                  subject: linkedSegment('comments'),
                 });
               }
             });

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { ThreadOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ThreadOperationHandlerSet);
+  }),
+);

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

@@ -5,14 +5,14 @@
 import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 
-import { Call } from '../../components';
-import { meta } from '../../meta';
+import { Call } from '#components';
+import { meta } from '#meta';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {
-    return Capability.contributes(Common.Capability.ReactRoot, {
+    return Capability.contributes(Capabilities.ReactRoot, {
       id: meta.id,
       root: () => <Call.Audio />,
     });

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,97 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useCapability, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/react-client/echo';
+import { Channel, Thread } from '@dxos/types';
+
+import { ThreadSettings } from '#components';
+import {
+  CallDebugPanel,
+  CallSidebar,
+  ChannelChat,
+  ChannelContainer,
+  ThreadCompanion,
+  ThreadContainer,
+} from '#containers';
+import { meta } from '#meta';
+import { ThreadCapabilities, type Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'channel',
+        filter: AppSurface.object(AppSurface.Article, Channel.Channel),
+        component: ({ data: { subject, attendableId }, role }) => (
+          <ChannelContainer role={role} subject={subject} attendableId={attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'chat-companion',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'chat'),
+          AppSurface.companion(AppSurface.Article, Channel.Channel),
+        ),
+        component: ({ data: { companionTo: channel } }) => {
+          const space = getSpace(channel);
+          if (!space) {
+            return null;
+          }
+
+          return <ChannelChat channel={channel} space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'thread',
+        filter: AppSurface.object(AppSurface.Article, Thread.Thread),
+        component: ({ data: { subject } }) => {
+          const space = getSpace(subject);
+          if (!space || !subject) {
+            return null;
+          }
+
+          return <ThreadContainer thread={subject} space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'comments',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'comments'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        // TODO(wittjosiah): This isn't scrolling properly in a plank.
+        component: ({ data }) => <ThreadCompanion attendableId={data.attendableId} subject={data.companionTo} />,
+      }),
+      Surface.create({
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          return <ThreadSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: 'assistant',
+        role: 'deck-companion--active-call',
+        component: () => <CallSidebar />,
+      }),
+      Surface.create({
+        id: 'devtools-overview',
+        role: 'devtools-overview',
+        component: () => {
+          const call = useCapability(ThreadCapabilities.CallManager);
+          const state = useAtomValue(call.stateAtom);
+          return <CallDebugPanel state={state} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/{settings/settings.ts → settings.ts}

@@ -4,18 +4,20 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
-import { meta } from '../../meta';
-import { ThreadSettingsSchema } from '../../types';
-import { ThreadCapabilities } from '../../types/capabilities';
+import { meta } from '#meta';
+import { Settings } from '#types';
+
+import { ThreadCapabilities } from '../types/capabilities';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {
     const settingsAtom = createKvsStore({
       key: meta.id,
-      schema: ThreadSettingsSchema,
+      schema: Settings.Settings,
       defaultValue: () => ({}),
     });
 
@@ -23,9 +25,9 @@ export default Capability.makeModule(() =>
       // Expose atom directly for programmatic access.
       Capability.contributes(ThreadCapabilities.Settings, settingsAtom),
       // Contribute to common settings for UI discovery.
-      Capability.contributes(Common.Capability.Settings, {
+      Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
-        schema: ThreadSettingsSchema,
+        schema: Settings.Settings,
         atom: settingsAtom,
       }),
     ];

package/src/capabilities/{state/state.ts → state.ts}

@@ -7,7 +7,7 @@ import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
 
-import { ThreadCapabilities, type ThreadState, type ViewStore } from '../../types';
+import { ThreadCapabilities, type ThreadState, type ViewStore } from '#types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+
+import { meta } from '#meta';
+import { ThreadOperation } from '#operations';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.UndoMapping, [
+      UndoMapping.make({
+        operation: ThreadOperation.Delete,
+        inverse: ThreadOperation.Restore,
+        deriveContext: (_input, output) => {
+          if (!output.thread || !output.anchor) {
+            return;
+          }
+          return {
+            thread: output.thread,
+            anchor: output.anchor,
+          };
+        },
+        message: ['thread-deleted.label', { ns: meta.id }],
+      }),
+      UndoMapping.make({
+        operation: ThreadOperation.DeleteMessage,
+        inverse: ThreadOperation.RestoreMessage,
+        deriveContext: (input, output) => {
+          if (!output.message || output.messageIndex === undefined) {
+            return;
+          }
+          return {
+            anchor: input.anchor,
+            message: output.message,
+            messageIndex: output.messageIndex,
+          };
+        },
+        message: ['message-deleted.label', { ns: meta.id }],
+      }),
+    ]);
+  }),
+);