@dxos/plugin-thread 0.7.4 → 0.7.5-main.9cb18ac

package/dist/lib/browser/index.mjs

@@ -1,16 +1,14 @@
 import {
   ThreadAction
-} from "./chunk-XUHNZID5.mjs";
+} from "./chunk-6KTMQPL4.mjs";
 import {
-  ChatContainer,
-  ChatHeading,
   MessageContainer,
   command,
   getMessageMetadata,
   useAnalyticsCallback,
   useOnEditAnalytics,
   useStatus
-} from "./chunk-52HWDLBR.mjs";
+} from "./chunk-OD2IZKRP.mjs";
 import {
   THREAD_ITEM,
   THREAD_PLUGIN,
@@ -19,15 +17,16 @@ import {
 
 // packages/plugins/plugin-thread/src/ThreadPlugin.tsx
 import React5 from "react";
-import { isLayoutParts, LayoutAction as LayoutAction2, NavigationAction, parseIntentPlugin, parseMetadataResolverPlugin, parseNavigationPlugin, resolvePlugin } from "@dxos/app-framework";
+import { createIntent as createIntent3, createResolver, createSurface, isLayoutParts, LayoutAction as LayoutAction2, NavigationAction, parseIntentPlugin, parseMetadataResolverPlugin, parseNavigationPlugin, resolvePlugin } from "@dxos/app-framework";
+import { Ref as Ref2 } from "@dxos/echo-schema";
 import { LocalStorageStore } from "@dxos/local-storage";
 import { log } from "@dxos/log";
-import { parseClientPlugin } from "@dxos/plugin-client";
-import { createExtension, isActionGroup, toSignal } from "@dxos/plugin-graph";
-import { ObservabilityAction } from "@dxos/plugin-observability/meta";
-import { memoizeQuery, SpaceAction } from "@dxos/plugin-space";
+import { parseClientPlugin } from "@dxos/plugin-client/types";
+import { createExtension, toSignal } from "@dxos/plugin-graph";
+import { ObservabilityAction } from "@dxos/plugin-observability/types";
+import { memoizeQuery } from "@dxos/plugin-space";
 import { ChannelType as ChannelType2, MessageType as MessageType2, ThreadType as ThreadType2 } from "@dxos/plugin-space/types";
-import { create as create2, fullyQualifiedId as fullyQualifiedId5, getSpace as getSpace3, getTypename, loadObjectReferences, parseId, SpaceState } from "@dxos/react-client/echo";
+import { create as create2, fullyQualifiedId as fullyQualifiedId5, getSpace as getSpace3, getTypename, makeRef as makeRef2, parseId, RefArray as RefArray4, SpaceState } from "@dxos/react-client/echo";
 import { translations as threadTranslations } from "@dxos/react-ui-thread";
 
 // packages/plugins/plugin-thread/src/components/index.ts
@@ -36,7 +35,7 @@ import { lazy } from "react";
 // packages/plugins/plugin-thread/src/components/CommentContainer.tsx
 import { CheckCircle, X } from "@phosphor-icons/react";
 import React, { useCallback, useMemo, useRef, useState } from "react";
-import { create } from "@dxos/live-object";
+import { create, makeRef, RefArray } from "@dxos/live-object";
 import { MessageType } from "@dxos/plugin-space/types";
 import { fullyQualifiedId, getSpace, useMembers } from "@dxos/react-client/echo";
 import { useIdentity } from "@dxos/react-client/halo";
@@ -67,9 +66,7 @@ var ToggleResolvedButton = ({ isResolved, onResolve }) => {
     weight: "fill"
   }) : /* @__PURE__ */ React.createElement(CheckCircle, {
     className: sizeClass
-  }))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
-    classNames: "z-[21]"
-  }, label, /* @__PURE__ */ React.createElement(Tooltip.Arrow, null))));
+  }))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, null, label, /* @__PURE__ */ React.createElement(Tooltip.Arrow, null))));
 };
 var DeleteThreadButton = ({ onDelete }) => {
   const { t } = useTranslation(THREAD_PLUGIN);
@@ -89,7 +86,7 @@ var DeleteThreadButton = ({ onDelete }) => {
   }, label), /* @__PURE__ */ React.createElement(X, {
     className: sizeClass
   }))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
-    classNames: "z-[21]"
+    classNames: "z-30"
   }, label, /* @__PURE__ */ React.createElement(Tooltip.Arrow, null))));
 };
 var CommentContainer = ({ thread, detached, context, current, onAttend, onThreadDelete, onMessageDelete, onResolve, onComment }) => {
@@ -126,14 +123,14 @@ var CommentContainer = ({ thread, detached, context, current, onAttend, onThread
     if (!messageRef.current) {
       return false;
     }
-    thread.messages.push(create(MessageType, {
+    thread.messages.push(makeRef(create(MessageType, {
       sender: {
         identityKey: identity.identityKey.toHex()
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       text: messageRef.current,
-      context
-    }));
+      context: context ? makeRef(context) : void 0
+    })));
     onComment?.(thread);
     messageRef.current = "";
     scrollToEnd("instant");
@@ -156,7 +153,7 @@ var CommentContainer = ({ thread, detached, context, current, onAttend, onThread
   }, /* @__PURE__ */ React.createElement(ThreadHeading, {
     detached: true
   }, thread.name)), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
-    classNames: "z-[21]",
+    classNames: "z-30",
     side: "top"
   }, t("detached thread label"), /* @__PURE__ */ React.createElement(Tooltip.Arrow, null)))) : /* @__PURE__ */ React.createElement(ThreadHeading, null, thread.name), /* @__PURE__ */ React.createElement("div", {
     className: "flex flex-row items-center pli-1"
@@ -167,7 +164,7 @@ var CommentContainer = ({ thread, detached, context, current, onAttend, onThread
     onResolve
   }), onThreadDelete && /* @__PURE__ */ React.createElement(DeleteThreadButton, {
     onDelete: onThreadDelete
-  }))), thread.messages.filter(nonNullable).map((message) => /* @__PURE__ */ React.createElement(MessageContainer, {
+  }))), RefArray.allResolvedTargets(thread.messages?.filter(nonNullable) ?? []).map((message) => /* @__PURE__ */ React.createElement(MessageContainer, {
     key: message.id,
     message,
     members,
@@ -243,13 +240,13 @@ var CommentsContainer = ({ threads: threads2, detached = [], currentId, showReso
 
 // packages/plugins/plugin-thread/src/components/ThreadComplementary.tsx
 import React3, { useEffect as useEffect2, useMemo as useMemo2 } from "react";
-import { LayoutAction, useIntentDispatcher, useResolvePlugins } from "@dxos/app-framework";
-import { fullyQualifiedId as fullyQualifiedId3 } from "@dxos/react-client/echo";
+import { createIntent, LayoutAction, useIntentDispatcher, useResolvePlugins } from "@dxos/app-framework";
+import { fullyQualifiedId as fullyQualifiedId3, RefArray as RefArray2 } from "@dxos/react-client/echo";
 import { useAttended } from "@dxos/react-ui-attention";
 import { nonNullable as nonNullable2 } from "@dxos/util";
 var providesThreadsConfig = (plugin) => "thread" in plugin.provides ? plugin : void 0;
-var ThreadComplementary = ({ role, subject, drafts, current, showResolvedThreads }) => {
-  const dispatch = useIntentDispatcher();
+var ThreadComplementary = ({ subject, drafts, current, showResolvedThreads }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
   const threadsIntegrators = useResolvePlugins(providesThreadsConfig);
   const threadProvides = useMemo2(() => threadsIntegrators.map((p) => p.provides.thread), [
     threadsIntegrators
@@ -262,10 +259,11 @@ var ThreadComplementary = ({ role, subject, drafts, current, showResolvedThreads
     createSort,
     subject
   ]);
+  const threadObjects = RefArray2.allResolvedTargets(subject.threads ?? []);
   const threads2 = useMemo2(() => {
-    return subject.threads.concat(drafts ?? []).filter(nonNullable2);
+    return threadObjects.concat(drafts ?? []).filter(nonNullable2);
   }, [
-    JSON.stringify(subject.threads),
+    JSON.stringify(threadObjects),
     JSON.stringify(drafts)
   ]);
   const detachedIds = useMemo2(() => {
@@ -293,53 +291,29 @@ var ThreadComplementary = ({ role, subject, drafts, current, showResolvedThreads
       const threadId = fullyQualifiedId3(thread);
       if (current !== threadId) {
         current = threadId;
-        void dispatch?.([
-          {
-            action: LayoutAction.SCROLL_INTO_VIEW,
-            data: {
-              id: fullyQualifiedId3(subject),
-              thread: threadId,
-              cursor: thread.anchor
-            }
-          }
-        ]);
+        void dispatch?.(createIntent(LayoutAction.ScrollIntoView, {
+          id: fullyQualifiedId3(subject),
+          cursor: thread.anchor,
+          ref: threadId
+        }));
       }
     },
-    onThreadDelete: (thread) => {
-      return dispatch({
-        plugin: THREAD_PLUGIN,
-        action: ThreadAction.DELETE,
-        data: {
-          subject,
-          thread
-        }
-      });
-    },
-    onMessageDelete: (thread, messageId) => dispatch({
-      plugin: THREAD_PLUGIN,
-      action: ThreadAction.DELETE_MESSAGE,
-      data: {
-        subject,
-        thread,
-        messageId
-      }
-    }),
-    onThreadToggleResolved: (thread) => dispatch({
-      plugin: THREAD_PLUGIN,
-      action: ThreadAction.TOGGLE_RESOLVED,
-      data: {
-        thread
-      }
-    }),
-    onComment: (thread) => {
-      void dispatch({
-        action: ThreadAction.ON_MESSAGE_ADD,
-        data: {
-          thread,
-          subject
-        }
-      });
-    }
+    onThreadDelete: (thread) => dispatch(createIntent(ThreadAction.Delete, {
+      thread,
+      subject
+    })),
+    onMessageDelete: (thread, messageId) => dispatch(createIntent(ThreadAction.DeleteMessage, {
+      thread,
+      subject,
+      messageId
+    })),
+    onThreadToggleResolved: (thread) => dispatch(createIntent(ThreadAction.ToggleResolved, {
+      thread
+    })),
+    onComment: (thread) => dispatch(createIntent(ThreadAction.OnMessageAdd, {
+      thread,
+      subject
+    }))
   });
 };
 
@@ -358,20 +332,22 @@ var ThreadSettings = ({ settings }) => {
 };
 
 // packages/plugins/plugin-thread/src/components/index.ts
-var ThreadMain = lazy(() => import("./ThreadMain-4IAS67KE.mjs"));
-var ThreadArticle = lazy(() => import("./ThreadArticle-6IXTL7CH.mjs"));
+var ThreadMain = lazy(() => import("./ThreadMain-ABEDFWHC.mjs"));
+var ThreadArticle = lazy(() => import("./ThreadArticle-EWLTNU6Z.mjs"));
 
 // packages/plugins/plugin-thread/src/extensions/threads.ts
 import { EditorView } from "@codemirror/view";
 import { computed, effect } from "@preact/signals-core";
+import { createIntent as createIntent2 } from "@dxos/app-framework";
+import { Ref } from "@dxos/echo-schema";
+import { RefArray as RefArray3 } from "@dxos/live-object";
 import { ThreadType } from "@dxos/plugin-space/types";
 import { getSpace as getSpace2, getTextInRange, createDocAccessor, fullyQualifiedId as fullyQualifiedId4 } from "@dxos/react-client/echo";
 import { comments, createExternalCommentSync } from "@dxos/react-ui-editor";
-import { nonNullable as nonNullable3 } from "@dxos/util";
 var getName = (doc, anchor) => {
   if (doc.content) {
     const [start, end] = anchor.split(":");
-    return getTextInRange(createDocAccessor(doc.content, [
+    return getTextInRange(createDocAccessor(doc.content.target, [
       "content"
     ]), start, end);
   }
@@ -384,14 +360,14 @@ var threads = (state, doc, dispatch) => {
     ];
   }
   const threads2 = computed(() => [
-    ...doc.threads.filter(nonNullable3),
+    ...RefArray3.allResolvedTargets(doc.threads),
     ...state.drafts[fullyQualifiedId4(doc)] ?? []
   ].filter((thread) => !(thread?.status === "resolved")));
   return [
     EditorView.updateListener.of((update) => {
       if (update.docChanged) {
-        doc.threads.forEach((thread) => {
-          if (thread?.anchor) {
+        RefArray3.allResolvedTargets(doc.threads).forEach((thread) => {
+          if (thread.anchor) {
             const name = getName(doc, thread.anchor);
             if (name && name !== thread.name) {
               thread.name = name;
@@ -408,14 +384,11 @@ var threads = (state, doc, dispatch) => {
       id: fullyQualifiedId4(doc),
       onCreate: ({ cursor }) => {
         const name = getName(doc, cursor);
-        void dispatch({
-          action: ThreadAction.CREATE,
-          data: {
-            cursor,
-            name,
-            subject: doc
-          }
-        });
+        void dispatch(createIntent2(ThreadAction.Create, {
+          cursor,
+          name,
+          subject: doc
+        }));
       },
       onDelete: ({ id }) => {
         const draft = state.drafts[fullyQualifiedId4(doc)];
@@ -425,26 +398,26 @@ var threads = (state, doc, dispatch) => {
             draft.splice(index, 1);
           }
         }
-        const thread = doc.threads.find((thread2) => thread2?.id === id);
+        const thread = doc.threads.find(Ref.hasObjectId(id))?.target;
         if (thread) {
           thread.anchor = void 0;
         }
       },
       onUpdate: ({ id, cursor }) => {
-        const thread = state.drafts[fullyQualifiedId4(doc)]?.find((thread2) => fullyQualifiedId4(thread2) === id) ?? doc.threads.find((thread2) => thread2?.id === id);
+        const thread = state.drafts[fullyQualifiedId4(doc)]?.find((thread2) => fullyQualifiedId4(thread2) === id) ?? doc.threads.find(Ref.hasObjectId(id))?.target;
         if (thread instanceof ThreadType && thread.anchor) {
           thread.name = getName(doc, thread.anchor);
           thread.anchor = cursor;
         }
       },
-      onSelect: ({ selection: { current, closest } }) => {
-        void dispatch({
-          action: ThreadAction.SELECT,
-          data: {
-            current: current ?? closest,
+      onSelect: ({ selection }) => {
+        const current = selection.current ?? selection.closest;
+        if (current) {
+          void dispatch(createIntent2(ThreadAction.Select, {
+            current,
             skipOpen: true
-          }
-        });
+          }));
+        }
       }
     })
   ];
@@ -510,7 +483,6 @@ var ThreadPlugin = () => {
     }
     return viewStore[subjectId];
   };
-  let navigationPlugin;
   let intentPlugin;
   const unsubscribeCallbacks = [];
   return {
@@ -537,8 +509,7 @@ var ThreadPlugin = () => {
         }
       };
     },
-    ready: async (plugins) => {
-      navigationPlugin = resolvePlugin(plugins, parseNavigationPlugin);
+    ready: async ({ plugins }) => {
       intentPlugin = resolvePlugin(plugins, parseIntentPlugin);
     },
     unload: async () => {
@@ -549,7 +520,7 @@ var ThreadPlugin = () => {
       metadata: {
         records: {
           [ChannelType2.typename]: {
-            createObject: ThreadAction.CREATE,
+            createObject: (props) => createIntent3(ThreadAction.Create, props),
             placeholder: [
               "channel name placeholder",
               {
@@ -558,11 +529,11 @@ var ThreadPlugin = () => {
             ],
             icon: "ph--chat--regular",
             // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (channel) => loadObjectReferences(channel, (channel2) => channel2.threads)
+            loadReferences: async (channel) => await RefArray4.loadAll(channel.threads ?? [])
           },
           [ThreadType2.typename]: {
             // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (thread) => loadObjectReferences(thread, (thread2) => thread2.messages)
+            loadReferences: async (thread) => await RefArray4.loadAll(thread.messages ?? [])
           },
           [MessageType2.typename]: {
             // TODO(wittjosiah): Move out of metadata.
@@ -610,7 +581,7 @@ var ThreadPlugin = () => {
       graph: {
         builder: (plugins) => {
           const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
-          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatch;
+          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatchPromise;
           const metadataResolver = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
           if (!client || !dispatch || !metadataResolver) {
             return [];
@@ -680,20 +651,17 @@ var ThreadPlugin = () => {
                 }
                 const [spaceId, objectId] = dataId.split(":");
                 const viewState = getViewState(dataId);
-                const toggle = () => {
+                const toggle = async () => {
                   const newToggleState = !viewState.showResolvedThreads;
                   viewState.showResolvedThreads = newToggleState;
-                  void dispatch({
-                    action: ObservabilityAction.SEND_EVENT,
-                    data: {
-                      name: "threads.toggle-show-resolved",
-                      properties: {
-                        spaceId,
-                        threadId: objectId,
-                        showResolved: newToggleState
-                      }
+                  await dispatch(createIntent3(ObservabilityAction.SendEvent, {
+                    name: "threads.toggle-show-resolved",
+                    properties: {
+                      spaceId,
+                      threadId: objectId,
+                      showResolved: newToggleState
                     }
-                  });
+                  }));
                 };
                 return [
                   {
@@ -714,440 +682,315 @@ var ThreadPlugin = () => {
                   }
                 ];
               }
-            }),
-            createExtension({
-              id: ThreadAction.CREATE,
-              filter: (node) => !!settings.values.standalone && isActionGroup(node) && node.id.startsWith(SpaceAction.ADD_OBJECT),
-              actions: ({ node }) => {
-                const id = node.id.split("/").at(-1);
-                const [spaceId, objectId] = id?.split(":") ?? [];
-                const space = client.spaces.get().find((space2) => space2.id === spaceId);
-                const object = objectId && space?.db.getObjectById(objectId);
-                const target = objectId ? object : space;
-                if (!target) {
-                  return;
-                }
-                return [
-                  {
-                    id: `${THREAD_PLUGIN}/create/${node.id}`,
-                    data: async () => {
-                      await dispatch([
-                        {
-                          plugin: THREAD_PLUGIN,
-                          action: ThreadAction.CREATE
-                        },
-                        {
-                          action: SpaceAction.ADD_OBJECT,
-                          data: {
-                            target
-                          }
-                        },
-                        {
-                          action: NavigationAction.OPEN
-                        }
-                      ]);
-                    },
-                    properties: {
-                      label: [
-                        "create channel label",
-                        {
-                          ns: THREAD_PLUGIN
-                        }
-                      ],
-                      icon: "ph--chat--regular",
-                      testId: "threadPlugin.createObject"
-                    }
-                  }
-                ];
-              }
             })
           ];
         }
       },
       surface: {
-        component: ({ data, role }) => {
-          switch (role) {
-            case "main": {
-              return data.active instanceof ChannelType2 && data.active.threads[0] ? /* @__PURE__ */ React5.createElement(ThreadMain, {
-                thread: data.active.threads[0]
-              }) : null;
-            }
-            case "settings": {
-              return data.plugin === meta_default.id ? /* @__PURE__ */ React5.createElement(ThreadSettings, {
-                settings: settings.values
-              }) : null;
-            }
-            case "article": {
-              const location = navigationPlugin?.provides.location;
-              if (data.object instanceof ChannelType2 && data.object.threads[0]) {
-                const channel = data.object;
+        definitions: ({ plugins }) => {
+          const location = resolvePlugin(plugins, parseNavigationPlugin)?.provides.location;
+          return [
+            createSurface({
+              id: `${THREAD_PLUGIN}/channel`,
+              role: "article",
+              filter: (data) => data.subject instanceof ChannelType2 && !!data.subject.threads[0],
+              component: ({ data }) => {
+                const channel = data.subject;
+                const thread = channel.threads[0].target;
                 if (isLayoutParts(location?.active) && location.active.main) {
                   const layoutEntries = location.active.main;
                   const currentPosition = layoutEntries.findIndex((entry) => channel.id === entry.id);
                   if (currentPosition > 0) {
                     const objectToTheLeft = layoutEntries[currentPosition - 1];
-                    const context = getSpace3(data.object)?.db.getObjectById(objectToTheLeft.id);
+                    const context = getSpace3(channel)?.db.getObjectById(objectToTheLeft.id);
                     return /* @__PURE__ */ React5.createElement(ThreadArticle, {
-                      thread: data.object.threads[0],
+                      thread,
                       context
                     });
                   }
                 }
                 return /* @__PURE__ */ React5.createElement(ThreadArticle, {
-                  thread: data.object.threads[0]
+                  thread
                 });
               }
-              if (data.subject instanceof ThreadType2) {
-                return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(ChatHeading, {
-                  attendableId: data.subject.id
-                }), /* @__PURE__ */ React5.createElement(ChatContainer, {
-                  thread: data.subject
-                }));
-              }
-              break;
-            }
-            case "complementary--comments": {
-              if (data.subject && typeof data.subject === "object" && "threads" in data.subject && Array.isArray(data.subject.threads) && !(data.subject instanceof ChannelType2)) {
+            }),
+            createSurface({
+              id: `${THREAD_PLUGIN}/thread`,
+              role: "complementary--comments",
+              filter: (data) => !!data.subject && typeof data.subject === "object" && "threads" in data.subject && Array.isArray(data.subject.threads) && !(data.subject instanceof ChannelType2),
+              component: ({ data }) => {
                 const { showResolvedThreads } = getViewState(fullyQualifiedId5(data.subject));
                 return /* @__PURE__ */ React5.createElement(ThreadComplementary, {
-                  role,
                   subject: data.subject,
                   drafts: state.drafts[fullyQualifiedId5(data.subject)],
                   current: state.current,
                   showResolvedThreads
                 });
               }
-              break;
-            }
-          }
-          return null;
+            }),
+            createSurface({
+              id: `${THREAD_PLUGIN}/settings`,
+              role: "settings",
+              filter: (data) => data.plugin === THREAD_PLUGIN,
+              component: () => /* @__PURE__ */ React5.createElement(ThreadSettings, {
+                settings: settings.values
+              })
+            })
+          ];
         }
       },
       intent: {
-        resolver: async (intent) => {
-          switch (intent.action) {
-            case ThreadAction.CREATE: {
-              if (intent.data && intent.data.cursor !== void 0) {
-                const { cursor, name, subject } = intent.data;
-                if (subject?.threads === void 0) {
-                  try {
-                    subject.threads = [];
-                  } catch (err) {
-                    log.error("Subject does not support threads array", subject?.typename, {
-                      F: __dxlog_file,
-                      L: 371,
-                      S: void 0,
-                      C: (f, a) => f(...a)
-                    });
-                    return;
-                  }
-                }
-                const subjectId = fullyQualifiedId5(subject);
-                const thread = create2(ThreadType2, {
-                  name,
-                  anchor: cursor,
-                  messages: [],
-                  status: "staged"
-                });
-                const draft = state.drafts[subjectId];
-                if (draft) {
-                  draft.push(thread);
-                } else {
-                  state.drafts[subjectId] = [
-                    thread
-                  ];
+        resolvers: () => [
+          createResolver(ThreadAction.Create, ({ name, cursor, subject }) => {
+            if (cursor && subject) {
+              if (subject?.threads === void 0) {
+                try {
+                  subject.threads = [];
+                } catch (err) {
+                  log.error("Subject does not support threads array", subject?.typename, {
+                    F: __dxlog_file,
+                    L: 314,
+                    S: void 0,
+                    C: (f, a) => f(...a)
+                  });
+                  return;
                 }
-                return {
-                  data: thread,
-                  intents: [
-                    [
-                      {
-                        action: ThreadAction.SELECT,
-                        data: {
-                          current: fullyQualifiedId5(thread)
-                        }
-                      }
-                    ],
-                    [
-                      {
-                        action: NavigationAction.OPEN,
-                        data: {
-                          activeParts: {
-                            complementary: "comments"
-                          }
-                        }
-                      }
-                    ],
-                    [
-                      {
-                        action: LayoutAction2.SET_LAYOUT,
-                        data: {
-                          element: "complementary",
-                          state: true
-                        }
-                      }
-                    ]
-                  ]
-                };
+              }
+              const subjectId = fullyQualifiedId5(subject);
+              const thread = create2(ThreadType2, {
+                name,
+                anchor: cursor,
+                messages: [],
+                status: "staged"
+              });
+              const draft = state.drafts[subjectId];
+              if (draft) {
+                draft.push(thread);
               } else {
-                return {
-                  data: create2(ChannelType2, {
+                state.drafts[subjectId] = [
+                  thread
+                ];
+              }
+              return {
+                data: {
+                  object: thread
+                },
+                intents: [
+                  createIntent3(ThreadAction.Select, {
+                    current: fullyQualifiedId5(thread)
+                  }),
+                  createIntent3(NavigationAction.Open, {
+                    activeParts: {
+                      complementary: "comments"
+                    }
+                  }),
+                  createIntent3(LayoutAction2.SetLayout, {
+                    element: "complementary",
+                    state: true
+                  })
+                ]
+              };
+            } else {
+              return {
+                data: {
+                  object: create2(ChannelType2, {
                     threads: [
-                      create2(ThreadType2, {
+                      makeRef2(create2(ThreadType2, {
                         messages: []
-                      })
+                      }))
                     ]
                   })
-                };
+                }
+              };
+            }
+          }),
+          createResolver(ThreadAction.Select, ({ current, skipOpen }) => {
+            state.current = current;
+            return {
+              intents: !skipOpen ? [
+                createIntent3(NavigationAction.Open, {
+                  activeParts: {
+                    complementary: "comments"
+                  }
+                })
+              ] : void 0
+            };
+          }),
+          createResolver(ThreadAction.ToggleResolved, ({ thread }) => {
+            if (thread.status === "active" || thread.status === void 0) {
+              thread.status = "resolved";
+            } else if (thread.status === "resolved") {
+              thread.status = "active";
+            }
+            const space = getSpace3(thread);
+            const spaceId = space?.id;
+            return {
+              intents: [
+                createIntent3(ObservabilityAction.SendEvent, {
+                  name: "threads.toggle-resolved",
+                  properties: {
+                    threadId: thread.id,
+                    spaceId
+                  }
+                })
+              ]
+            };
+          }),
+          createResolver(ThreadAction.Delete, ({ subject, thread }, undo) => {
+            const subjectId = fullyQualifiedId5(subject);
+            const draft = state.drafts[subjectId];
+            if (draft) {
+              const index = draft.findIndex((t) => t.id === thread.id);
+              if (index !== -1) {
+                draft.splice(index, 1);
+                return;
               }
             }
-            case ThreadAction.SELECT: {
-              state.current = intent.data?.current;
+            const space = getSpace3(thread);
+            if (!space || !subject.threads) {
+              return;
+            }
+            if (!undo) {
+              const index = subject.threads.findIndex((t) => t?.id === thread.id);
+              const cursor = subject.threads[index]?.anchor;
+              if (index !== -1) {
+                subject.threads?.splice(index, 1);
+              }
+              space.db.remove(thread);
               return {
-                data: true,
-                intents: !intent.data?.skipOpen ? [
-                  [
+                undoable: {
+                  message: [
+                    "thread deleted label",
                     {
-                      action: NavigationAction.OPEN,
-                      data: {
-                        activeParts: {
-                          complementary: "comments"
-                        }
-                      }
+                      ns: THREAD_PLUGIN
                     }
-                  ]
-                ] : []
+                  ],
+                  data: {
+                    cursor
+                  }
+                },
+                intents: [
+                  createIntent3(ObservabilityAction.SendEvent, {
+                    name: "threads.delete",
+                    properties: {
+                      threadId: thread.id,
+                      spaceId: space.id
+                    }
+                  })
+                ]
               };
-            }
-            case ThreadAction.TOGGLE_RESOLVED: {
-              const { thread } = intent.data ?? {};
-              if (!(thread instanceof ThreadType2)) {
-                return;
-              }
-              if (thread.status === "active" || thread.status === void 0) {
-                thread.status = "resolved";
-              } else if (thread.status === "resolved") {
-                thread.status = "active";
-              }
-              const space = getSpace3(thread);
-              const spaceId = space?.id;
+            } else {
+              const savedThread = space.db.add(thread);
+              subject.threads.push(savedThread);
               return {
-                data: true,
                 intents: [
-                  [
-                    {
-                      action: ObservabilityAction.SEND_EVENT,
-                      data: {
-                        name: "threads.toggle-resolved",
-                        properties: {
-                          threadId: thread.id,
-                          spaceId
-                        }
-                      }
+                  createIntent3(ObservabilityAction.SendEvent, {
+                    name: "threads.undo-delete",
+                    properties: {
+                      threadId: thread.id,
+                      spaceId: space.id
                     }
-                  ]
+                  })
                 ]
               };
             }
-            case ThreadAction.DELETE: {
-              const { subject, thread } = intent.data ?? {};
-              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject)) {
-                return;
-              }
-              const subjectId = fullyQualifiedId5(subject);
-              const draft = state.drafts[subjectId];
-              if (draft) {
-                const index = draft.findIndex((t) => t.id === thread.id);
-                if (index !== -1) {
-                  draft.splice(index, 1);
-                  return {
-                    data: true
-                  };
-                }
+          }),
+          createResolver(ThreadAction.OnMessageAdd, ({ thread, subject }) => {
+            const subjectId = fullyQualifiedId5(subject);
+            const space = getSpace3(subject);
+            const intents = [];
+            const analyticsProperties = {
+              threadId: thread.id,
+              spaceId: space?.id
+            };
+            if (state.drafts[subjectId]?.find((t) => t === thread)) {
+              thread.status = "active";
+              subject.threads ? subject.threads.push(makeRef2(thread)) : subject.threads = [
+                makeRef2(thread)
+              ];
+              state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
+              intents.push(createIntent3(ObservabilityAction.SendEvent, {
+                name: "threads.thread-created",
+                properties: analyticsProperties
+              }));
+            }
+            intents.push(createIntent3(ObservabilityAction.SendEvent, {
+              name: "threads.message-added",
+              properties: {
+                ...analyticsProperties,
+                threadLength: thread.messages.length
               }
-              const space = getSpace3(thread);
-              if (!space || !subject.threads) {
+            }));
+            return {
+              intents
+            };
+          }),
+          createResolver(ThreadAction.DeleteMessage, ({ subject, thread, messageId, message, messageIndex }, undo) => {
+            const space = getSpace3(subject);
+            if (!undo) {
+              const messageIndex2 = thread.messages.findIndex(Ref2.hasObjectId(messageId));
+              const message2 = thread.messages[messageIndex2]?.target;
+              if (!message2) {
                 return;
               }
-              if (!intent.undo) {
-                const index = subject.threads.findIndex((t) => t?.id === thread.id);
-                const cursor = subject.threads[index]?.anchor;
-                if (index !== -1) {
-                  subject.threads?.splice(index, 1);
-                }
-                space.db.remove(thread);
-                return {
-                  undoable: {
-                    message: translations_default[0]["en-US"][THREAD_PLUGIN]["thread deleted label"],
-                    data: {
-                      cursor
-                    }
-                  },
-                  intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: "threads.delete",
-                          properties: {
-                            threadId: thread.id,
-                            spaceId: space.id
-                          }
-                        }
-                      }
-                    ]
-                  ]
-                };
-              } else if (intent.undo) {
-                const savedThread = space.db.add(thread);
-                subject.threads.push(savedThread);
+              if (messageIndex2 === 0 && thread.messages.length === 1) {
                 return {
-                  data: true,
                   intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: "threads.undo-delete",
-                          properties: {
-                            threadId: thread.id,
-                            spaceId: space.id
-                          }
-                        }
-                      }
-                    ]
+                    createIntent3(ThreadAction.Delete, {
+                      subject,
+                      thread
+                    })
                   ]
                 };
+              } else {
+                thread.messages.splice(messageIndex2, 1);
               }
-              break;
-            }
-            case ThreadAction.ON_MESSAGE_ADD: {
-              const { thread, subject } = intent.data ?? {};
-              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject && Array.isArray(subject.threads))) {
-                return;
-              }
-              const subjectId = fullyQualifiedId5(subject);
-              const space = getSpace3(subject);
-              const intents = [];
-              const analyticsProperties = {
-                threadId: thread.id,
-                spaceId: space?.id
-              };
-              if (state.drafts[subjectId]?.find((t) => t === thread)) {
-                thread.status = "active";
-                subject.threads ? subject.threads.push(thread) : subject.threads = [
-                  thread
-                ];
-                state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
-                intents.push({
-                  action: ObservabilityAction.SEND_EVENT,
+              return {
+                undoable: {
+                  message: [
+                    "message deleted label",
+                    {
+                      ns: THREAD_PLUGIN
+                    }
+                  ],
                   data: {
-                    name: "threads.thread-created",
-                    properties: analyticsProperties
-                  }
-                });
-              }
-              intents.push({
-                action: ObservabilityAction.SEND_EVENT,
-                data: {
-                  name: "threads.message-added",
-                  properties: {
-                    ...analyticsProperties,
-                    threadLength: thread.messages.length
+                    message: message2,
+                    messageIndex: messageIndex2
                   }
-                }
-              });
-              return {
-                data: thread,
+                },
                 intents: [
-                  intents
+                  createIntent3(ObservabilityAction.SendEvent, {
+                    name: "threads.message.delete",
+                    properties: {
+                      threadId: thread.id,
+                      spaceId: space?.id
+                    }
+                  })
                 ]
               };
-            }
-            case ThreadAction.DELETE_MESSAGE: {
-              const { subject, thread, messageId } = intent.data ?? {};
-              const space = getSpace3(subject);
-              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject)) {
+            } else {
+              if (!messageIndex || !message) {
                 return;
               }
-              if (!intent.undo) {
-                const message = thread.messages.find((m) => m?.id === messageId);
-                const messageIndex = thread.messages.findIndex((m) => m?.id === messageId);
-                if (messageIndex === -1 || !message) {
-                  return void 0;
-                }
-                if (messageIndex === 0 && thread.messages.length === 1) {
-                  return {
-                    intents: [
-                      [
-                        {
-                          action: ThreadAction.DELETE,
-                          data: {
-                            subject,
-                            thread
-                          }
-                        }
-                      ]
-                    ]
-                  };
-                } else {
-                  thread.messages.splice(messageIndex, 1);
-                }
-                return {
-                  undoable: {
-                    message: translations_default[0]["en-US"][THREAD_PLUGIN]["message deleted label"],
-                    data: {
-                      message,
-                      messageIndex
+              thread.messages.splice(messageIndex, 0, makeRef2(message));
+              return {
+                intents: [
+                  createIntent3(ObservabilityAction.SendEvent, {
+                    name: "threads.message.undo-delete",
+                    properties: {
+                      threadId: thread.id,
+                      spaceId: space?.id
                     }
-                  },
-                  intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: "threads.message.delete",
-                          properties: {
-                            threadId: thread.id,
-                            spaceId: space?.id
-                          }
-                        }
-                      }
-                    ]
-                  ]
-                };
-              } else if (intent.undo) {
-                const message = intent.data?.message;
-                const messageIndex = intent.data?.messageIndex;
-                if (!(message instanceof MessageType2) || !(typeof messageIndex === "number")) {
-                  return;
-                }
-                thread.messages.splice(messageIndex, 0, message);
-                return {
-                  data: true,
-                  intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: "threads.message.undo-delete",
-                          properties: {
-                            threadId: thread.id,
-                            spaceId: space?.id
-                          }
-                        }
-                      }
-                    ]
-                  ]
-                };
-              }
+                  })
+                ]
+              };
             }
-          }
-        }
+          })
+        ]
       },
       markdown: {
         extensions: ({ document: doc }) => {
-          return threads(state, doc, intentPlugin?.provides.intent.dispatch);
+          return threads(state, doc, intentPlugin?.provides.intent.dispatchPromise);
         }
       }
     }