@dxos/plugin-thread 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

package/dist/lib/browser/operation-resolver-EP7FAYEB.mjs

@@ -0,0 +1,442 @@
+import {
+  Channel_exports,
+  ThreadCapabilities,
+  ThreadOperation
+} from "./chunk-U32R23JO.mjs";
+import {
+  meta
+} from "./chunk-LUK4UNFA.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/operation-resolver/operation-resolver.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability, UndoMapping } from "@dxos/app-framework";
+import { sleep } from "@dxos/async";
+import { Obj, Relation, Type } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { OperationResolver } from "@dxos/operation";
+import { Operation } from "@dxos/operation";
+import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from "@dxos/plugin-deck/types";
+import { ObservabilityOperation } from "@dxos/plugin-observability/types";
+import { SpaceOperation } from "@dxos/plugin-space/types";
+import { Ref } from "@dxos/react-client/echo";
+import { ManagedCollection } from "@dxos/schema";
+import { AnchoredTo, Message, Thread } from "@dxos/types";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/capabilities/operation-resolver/operation-resolver.ts";
+var operation_resolver_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 === void 0) {
+            return;
+          }
+          return {
+            anchor: input.anchor,
+            message: output.message,
+            messageIndex: output.messageIndex
+          };
+        },
+        message: [
+          "message deleted label",
+          {
+            ns: meta.id
+          }
+        ]
+      })
+    ]),
+    Capability.contributes(Capabilities.OperationResolver, [
+      //
+      // CreateChannel
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.CreateChannel,
+        handler: (input) => Effect.sync(() => ({
+          object: Channel_exports.make({
+            name: input.name
+          })
+        }))
+      }),
+      //
+      // CreateChannelThread
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.CreateChannelThread,
+        handler: (input) => Effect.sync(() => {
+          const thread = Thread.make({
+            status: "active"
+          });
+          const threadRef = Ref.make(thread);
+          Obj.change(input.channel, (c) => {
+            c.threads.push(threadRef);
+          });
+          return {
+            object: thread
+          };
+        })
+      }),
+      //
+      // Select
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.Select,
+        handler: Effect.fnUntraced(function* (input) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+          const current = registry.get(stateAtom);
+          registry.set(stateAtom, {
+            ...current,
+            current: input.current
+          });
+        })
+      }),
+      //
+      // ToggleResolved
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.ToggleResolved,
+        handler: Effect.fnUntraced(function* (input) {
+          const thread = input.thread;
+          Obj.change(thread, (t) => {
+            if (t.status === "active" || t.status === void 0) {
+              t.status = "resolved";
+            } else if (t.status === "resolved") {
+              t.status = "active";
+            }
+          });
+          const db = Obj.getDatabase(thread);
+          invariant(db, "Database not found", {
+            F: __dxlog_file,
+            L: 117,
+            S: this,
+            A: [
+              "db",
+              "'Database not found'"
+            ]
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.toggle-resolved",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id
+            }
+          });
+        })
+      }),
+      //
+      // OnCreateSpace
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.OnCreateSpace,
+        handler: Effect.fnUntraced(function* ({ space, isDefault, rootCollection }) {
+          if (isDefault) {
+            return;
+          }
+          const collection = ManagedCollection.makeManagedCollection({
+            key: Type.getTypename(Channel_exports.Channel)
+          });
+          Obj.change(rootCollection, (c) => {
+            c.objects.push(Ref.make(collection));
+          });
+          const { object: channel } = yield* Operation.invoke(ThreadOperation.CreateChannel, {
+            name: "General",
+            spaceId: space.id
+          });
+          space.db.add(channel);
+        })
+      }),
+      //
+      // Create
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.Create,
+        handler: Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+          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
+          });
+          const state = registry.get(stateAtom);
+          const existingDrafts = state.drafts[subjectId];
+          registry.set(stateAtom, {
+            ...state,
+            drafts: {
+              ...state.drafts,
+              [subjectId]: existingDrafts ? [
+                ...existingDrafts,
+                anchor
+              ] : [
+                anchor
+              ]
+            }
+          });
+          yield* Operation.invoke(ThreadOperation.Select, {
+            current: Obj.getDXN(thread).toString()
+          });
+          yield* Operation.invoke(DeckOperation.ChangeCompanion, {
+            companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`
+          });
+        })
+      }),
+      //
+      // Delete
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.Delete,
+        handler: Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+          const thread = _thread ?? Relation.getSource(anchor);
+          const subjectId = Obj.getDXN(subject).toString();
+          const state = registry.get(stateAtom);
+          const draft = state.drafts[subjectId];
+          if (draft) {
+            const index = draft.findIndex((a) => a.id === anchor.id);
+            if (index !== -1) {
+              registry.set(stateAtom, {
+                ...state,
+                drafts: {
+                  ...state.drafts,
+                  [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index)
+                }
+              });
+              return {};
+            }
+          }
+          const db = Obj.getDatabase(thread);
+          if (!db) {
+            return {};
+          }
+          db.remove(anchor);
+          yield* Effect.promise(() => sleep(100));
+          db.remove(thread);
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.delete",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id
+            }
+          });
+          return {
+            thread,
+            anchor
+          };
+        })
+      }),
+      //
+      // AddMessage
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.AddMessage,
+        handler: Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+          const thread = Relation.getSource(anchor);
+          const subjectId = Obj.getDXN(subject).toString();
+          const db = Obj.getDatabase(subject);
+          invariant(db, "Database not found", {
+            F: __dxlog_file,
+            L: 249,
+            S: this,
+            A: [
+              "db",
+              "'Database not found'"
+            ]
+          });
+          const message = Obj.make(Message.Message, {
+            created: (/* @__PURE__ */ new Date()).toISOString(),
+            sender,
+            blocks: [
+              {
+                _tag: "text",
+                text
+              }
+            ]
+          });
+          Obj.change(thread, (t) => {
+            t.messages.push(Ref.make(message));
+          });
+          const state = registry.get(stateAtom);
+          const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
+          if (draft) {
+            Obj.change(thread, (t) => {
+              t.status = "active";
+            });
+            registry.set(stateAtom, {
+              ...state,
+              drafts: {
+                ...state.drafts,
+                [subjectId]: state.drafts[subjectId]?.filter((a) => a.id !== anchor.id)
+              }
+            });
+            yield* Operation.invoke(SpaceOperation.AddObject, {
+              object: thread,
+              target: db,
+              hidden: true
+            });
+            yield* Operation.invoke(SpaceOperation.AddRelation, {
+              db,
+              schema: AnchoredTo.AnchoredTo,
+              source: thread,
+              target: subject,
+              fields: {
+                anchor: draft.anchor
+              }
+            });
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: "threads.create",
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id
+              }
+            });
+          }
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.message.add",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id,
+              threadLength: thread.messages.length,
+              messageId: message.id,
+              messageLength: text.length
+            }
+          });
+        })
+      }),
+      //
+      // DeleteMessage
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.DeleteMessage,
+        handler: Effect.fnUntraced(function* ({ subject, anchor, messageId }) {
+          const thread = Relation.getSource(anchor);
+          const db = Obj.getDatabase(subject);
+          invariant(db, "Database not found", {
+            F: __dxlog_file,
+            L: 312,
+            S: this,
+            A: [
+              "db",
+              "'Database not found'"
+            ]
+          });
+          const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);
+          const msg = thread.messages[msgIndex]?.target;
+          if (!msg) {
+            return {
+              messageIndex: -1
+            };
+          }
+          if (msgIndex === 0 && thread.messages.length === 1) {
+            yield* Operation.invoke(ThreadOperation.Delete, {
+              subject,
+              anchor
+            });
+            return {
+              messageIndex: -1
+            };
+          }
+          Obj.change(thread, (t) => {
+            t.messages.splice(msgIndex, 1);
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.message.delete",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id,
+              threadLength: thread.messages.length,
+              messageId
+            }
+          });
+          return {
+            message: msg,
+            messageIndex: msgIndex
+          };
+        })
+      }),
+      //
+      // Restore (inverse of Delete)
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.Restore,
+        handler: Effect.fnUntraced(function* ({ thread, anchor }) {
+          const db = Obj.getDatabase(thread);
+          if (!db) {
+            return;
+          }
+          db.add(thread);
+          yield* Effect.promise(() => sleep(100));
+          db.add(anchor);
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.undo-delete",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id
+            }
+          });
+        })
+      }),
+      //
+      // RestoreMessage (inverse of DeleteMessage)
+      //
+      OperationResolver.make({
+        operation: ThreadOperation.RestoreMessage,
+        handler: Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {
+          const thread = Relation.getSource(anchor);
+          const db = Obj.getDatabase(thread);
+          invariant(db, "Database not found", {
+            F: __dxlog_file,
+            L: 380,
+            S: this,
+            A: [
+              "db",
+              "'Database not found'"
+            ]
+          });
+          Obj.change(thread, (t) => {
+            t.messages.splice(messageIndex, 0, Ref.make(message));
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "threads.message.undo-delete",
+            properties: {
+              spaceId: db.spaceId,
+              threadId: thread.id,
+              messageId: message.id
+            }
+          });
+        })
+      })
+    ])
+  ];
+}));
+export {
+  operation_resolver_default as default
+};
+//# sourceMappingURL=operation-resolver-EP7FAYEB.mjs.map

package/dist/lib/browser/operation-resolver-EP7FAYEB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/operation-resolver/operation-resolver.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';\nimport { sleep } from '@dxos/async';\nimport { Obj, Relation, Type } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\nimport { OperationResolver } from '@dxos/operation';\nimport { Operation } from '@dxos/operation';\nimport { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';\nimport { ObservabilityOperation } from '@dxos/plugin-observability/types';\nimport { SpaceOperation } from '@dxos/plugin-space/types';\nimport { Ref } from '@dxos/react-client/echo';\nimport { ManagedCollection } from '@dxos/schema';\nimport { AnchoredTo, Message, Thread } from '@dxos/types';\n\nimport { meta } from '../../meta';\nimport { Channel, ThreadCapabilities, ThreadOperation } from '../../types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    return [\n      Capability.contributes(Capabilities.UndoMapping, [\n        UndoMapping.make({\n          operation: ThreadOperation.Delete,\n          inverse: ThreadOperation.Restore,\n          deriveContext: (_input, output) => {\n            // Return undefined if not undoable (e.g., draft deletion or no db).\n            if (!output.thread || !output.anchor) {\n              return;\n            }\n            return {\n              thread: output.thread,\n              anchor: output.anchor,\n            };\n          },\n          message: ['thread deleted label', { ns: meta.id }],\n        }),\n        UndoMapping.make({\n          operation: ThreadOperation.DeleteMessage,\n          inverse: ThreadOperation.RestoreMessage,\n          deriveContext: (input, output) => {\n            // Return undefined if not undoable (e.g., message not found or thread deleted).\n            if (!output.message || output.messageIndex === undefined) {\n              return;\n            }\n            return {\n              anchor: input.anchor,\n              message: output.message,\n              messageIndex: output.messageIndex,\n            };\n          },\n          message: ['message deleted label', { ns: meta.id }],\n        }),\n      ]),\n      Capability.contributes(Capabilities.OperationResolver, [\n        //\n        // CreateChannel\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.CreateChannel,\n          handler: (input) =>\n            Effect.sync(() => ({\n              object: Channel.make({ name: input.name }),\n            })),\n        }),\n\n        //\n        // CreateChannelThread\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.CreateChannelThread,\n          handler: (input) =>\n            Effect.sync(() => {\n              const thread = Thread.make({ status: 'active' });\n              const threadRef = Ref.make(thread);\n              Obj.change(input.channel, (c) => {\n                c.threads.push(threadRef);\n              });\n              return { object: thread };\n            }),\n        }),\n\n        //\n        // Select\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.Select,\n          handler: Effect.fnUntraced(function* (input) {\n            const registry = yield* Capability.get(Capabilities.AtomRegistry);\n            const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n            const current = registry.get(stateAtom);\n            registry.set(stateAtom, { ...current, current: input.current });\n          }),\n        }),\n\n        //\n        // ToggleResolved\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.ToggleResolved,\n          handler: Effect.fnUntraced(function* (input) {\n            const thread = input.thread;\n\n            Obj.change(thread, (t) => {\n              if (t.status === 'active' || t.status === undefined) {\n                t.status = 'resolved';\n              } else if (t.status === 'resolved') {\n                t.status = 'active';\n              }\n            });\n\n            const db = Obj.getDatabase(thread);\n            invariant(db, 'Database not found');\n\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.toggle-resolved',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n              },\n            });\n          }),\n        }),\n\n        //\n        // OnCreateSpace\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.OnCreateSpace,\n          handler: Effect.fnUntraced(function* ({ space, isDefault, rootCollection }) {\n            if (isDefault) {\n              return;\n            }\n\n            const collection = ManagedCollection.makeManagedCollection({ key: Type.getTypename(Channel.Channel) });\n            Obj.change(rootCollection, (c) => {\n              c.objects.push(Ref.make(collection));\n            });\n\n            const { object: channel } = yield* Operation.invoke(ThreadOperation.CreateChannel, {\n              name: 'General',\n              spaceId: space.id,\n            });\n            space.db.add(channel);\n          }),\n        }),\n\n        //\n        // Create\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.Create,\n          handler: Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {\n            const registry = yield* Capability.get(Capabilities.AtomRegistry);\n            const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n            const subjectId = Obj.getDXN(subject).toString();\n            const thread = Thread.make({ name });\n            const anchor = Relation.make(AnchoredTo.AnchoredTo, {\n              [Relation.Source]: thread,\n              [Relation.Target]: subject,\n              anchor: _anchor,\n            });\n\n            const state = registry.get(stateAtom);\n            const existingDrafts = state.drafts[subjectId];\n            registry.set(stateAtom, {\n              ...state,\n              drafts: {\n                ...state.drafts,\n                [subjectId]: existingDrafts ? [...existingDrafts, anchor] : [anchor],\n              },\n            });\n\n            // Follow-up operations.\n            yield* Operation.invoke(ThreadOperation.Select, { current: Obj.getDXN(thread).toString() });\n            yield* Operation.invoke(DeckOperation.ChangeCompanion, {\n              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,\n            });\n          }),\n        }),\n\n        //\n        // Delete\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.Delete,\n          handler: Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {\n            const registry = yield* Capability.get(Capabilities.AtomRegistry);\n            const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n            const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);\n            const subjectId = Obj.getDXN(subject).toString();\n            const state = registry.get(stateAtom);\n            const draft = state.drafts[subjectId];\n            if (draft) {\n              // Check if we're deleting a draft; if so, remove it.\n              const index = draft.findIndex((a: { id: string }) => a.id === anchor.id);\n              if (index !== -1) {\n                registry.set(stateAtom, {\n                  ...state,\n                  drafts: {\n                    ...state.drafts,\n                    [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index),\n                  },\n                });\n                // Draft deletion is not undoable.\n                return {};\n              }\n            }\n\n            const db = Obj.getDatabase(thread);\n            if (!db) {\n              return {};\n            }\n\n            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.\n            db.remove(anchor);\n            yield* Effect.promise(() => sleep(100));\n            db.remove(thread);\n\n            // Schedule analytics event as followup (doesn't block return).\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.delete',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n              },\n            });\n\n            // Return data needed for undo.\n            return { thread, anchor };\n          }),\n        }),\n\n        //\n        // AddMessage\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.AddMessage,\n          handler: Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {\n            const registry = yield* Capability.get(Capabilities.AtomRegistry);\n            const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n            const thread = Relation.getSource(anchor) as Thread.Thread;\n            const subjectId = Obj.getDXN(subject).toString();\n            const db = Obj.getDatabase(subject);\n            invariant(db, 'Database not found');\n\n            const message = Obj.make(Message.Message, {\n              created: new Date().toISOString(),\n              sender,\n              blocks: [{ _tag: 'text', text }],\n            });\n            Obj.change(thread, (t) => {\n              t.messages.push(Ref.make(message));\n            });\n\n            const state = registry.get(stateAtom);\n            const draft = state.drafts[subjectId]?.find((a: { id: string }) => a.id === anchor.id);\n            if (draft) {\n              // Move draft to document.\n              Obj.change(thread, (t) => {\n                t.status = 'active';\n              });\n              registry.set(stateAtom, {\n                ...state,\n                drafts: {\n                  ...state.drafts,\n                  [subjectId]: state.drafts[subjectId]?.filter((a: { id: string }) => a.id !== anchor.id),\n                },\n              });\n              yield* Operation.invoke(SpaceOperation.AddObject, { object: thread, target: db, hidden: true });\n              yield* Operation.invoke(SpaceOperation.AddRelation, {\n                db,\n                schema: AnchoredTo.AnchoredTo,\n                source: thread,\n                target: subject,\n                fields: { anchor: draft.anchor },\n              });\n              yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n                name: 'threads.create',\n                properties: {\n                  spaceId: db.spaceId,\n                  threadId: thread.id,\n                },\n              });\n            }\n\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.message.add',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n                threadLength: thread.messages.length,\n                messageId: message.id,\n                messageLength: text.length,\n              },\n            });\n          }),\n        }),\n\n        //\n        // DeleteMessage\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.DeleteMessage,\n          handler: Effect.fnUntraced(function* ({ subject, anchor, messageId }) {\n            const thread = Relation.getSource(anchor) as Thread.Thread;\n            const db = Obj.getDatabase(subject);\n            invariant(db, 'Database not found');\n\n            const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);\n            const msg = thread.messages[msgIndex]?.target;\n            if (!msg) {\n              return { messageIndex: -1 };\n            }\n\n            if (msgIndex === 0 && thread.messages.length === 1) {\n              // TODO(wittjosiah): This doesn't support restoring the thread.\n              yield* Operation.invoke(ThreadOperation.Delete, { subject, anchor });\n              return { messageIndex: -1 };\n            }\n\n            Obj.change(thread, (t) => {\n              t.messages.splice(msgIndex, 1);\n            });\n\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.message.delete',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n                threadLength: thread.messages.length,\n                messageId,\n              },\n            });\n\n            // Return data needed for undo.\n            return { message: msg, messageIndex: msgIndex };\n          }),\n        }),\n\n        //\n        // Restore (inverse of Delete)\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.Restore,\n          handler: Effect.fnUntraced(function* ({ thread, anchor }) {\n            const db = Obj.getDatabase(thread);\n            if (!db) {\n              return;\n            }\n\n            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.\n            db.add(thread);\n            yield* Effect.promise(() => sleep(100));\n            db.add(anchor);\n\n            // Schedule analytics event as followup (doesn't block return).\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.undo-delete',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n              },\n            });\n          }),\n        }),\n\n        //\n        // RestoreMessage (inverse of DeleteMessage)\n        //\n        OperationResolver.make({\n          operation: ThreadOperation.RestoreMessage,\n          handler: Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {\n            const thread = Relation.getSource(anchor) as Thread.Thread;\n            const db = Obj.getDatabase(thread);\n            invariant(db, 'Database not found');\n\n            Obj.change(thread, (t) => {\n              t.messages.splice(messageIndex, 0, Ref.make(message));\n            });\n\n            yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n              name: 'threads.message.undo-delete',\n              properties: {\n                spaceId: db.spaceId,\n                threadId: thread.id,\n                messageId: message.id,\n              },\n            });\n          }),\n        }),\n      ]),\n    ];\n  }),\n);\n"],
+  "mappings": "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",
+  "names": ["Effect", "Capabilities", "Capability", "UndoMapping", "sleep", "Obj", "Relation", "Type", "invariant", "OperationResolver", "Operation", "ATTENDABLE_PATH_SEPARATOR", "DeckOperation", "ObservabilityOperation", "SpaceOperation", "Ref", "ManagedCollection", "AnchoredTo", "Message", "Thread", "Capability", "makeModule", "fnUntraced", "contributes", "Capabilities", "UndoMapping", "make", "operation", "ThreadOperation", "Delete", "inverse", "Restore", "deriveContext", "_input", "output", "thread", "anchor", "message", "ns", "meta", "id", "DeleteMessage", "RestoreMessage", "input", "messageIndex", "undefined", "OperationResolver", "CreateChannel", "handler", "sync", "object", "Channel", "name", "CreateChannelThread", "Thread", "status", "threadRef", "Ref", "Obj", "change", "channel", "c", "threads", "push", "Select", "registry", "get", "AtomRegistry", "stateAtom", "ThreadCapabilities", "State", "current", "set", "ToggleResolved", "t", "db", "getDatabase", "invariant", "Operation", "schedule", "ObservabilityOperation", "SendEvent", "properties", "spaceId", "threadId", "OnCreateSpace", "space", "isDefault", "rootCollection", "collection", "ManagedCollection", "makeManagedCollection", "key", "Type", "getTypename", "objects", "invoke", "add", "Create", "_anchor", "subject", "subjectId", "getDXN", "toString", "Relation", "AnchoredTo", "Source", "Target", "state", "existingDrafts", "drafts", "DeckOperation", "ChangeCompanion", "companion", "ATTENDABLE_PATH_SEPARATOR", "_thread", "getSource", "draft", "index", "findIndex", "a", "filter", "_", "i", "remove", "promise", "sleep", "AddMessage", "sender", "text", "Message", "created", "Date", "toISOString", "blocks", "_tag", "messages", "find", "SpaceOperation", "AddObject", "target", "hidden", "AddRelation", "schema", "source", "fields", "threadLength", "length", "messageId", "messageLength", "msgIndex", "ref", "msg", "splice"]
+}

package/dist/lib/browser/react-root-7UFFPPRD.mjs

@@ -0,0 +1,26 @@
+import {
+  Call
+} from "./chunk-G6FJBSXX.mjs";
+import "./chunk-HDLDMR54.mjs";
+import "./chunk-CP7E2HRE.mjs";
+import "./chunk-ISCHODBV.mjs";
+import "./chunk-U32R23JO.mjs";
+import {
+  meta
+} from "./chunk-LUK4UNFA.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/react-root/react-root.tsx
+import * as Effect from "effect/Effect";
+import React from "react";
+import { Capabilities, Capability } from "@dxos/app-framework";
+var react_root_default = Capability.makeModule(() => Effect.sync(() => {
+  return Capability.contributes(Capabilities.ReactRoot, {
+    id: meta.id,
+    root: () => /* @__PURE__ */ React.createElement(Call.Audio, null)
+  });
+}));
+export {
+  react_root_default as default
+};
+//# sourceMappingURL=react-root-7UFFPPRD.mjs.map

package/dist/lib/browser/react-root-7UFFPPRD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/react-root/react-root.tsx"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport React from 'react';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\n\nimport { Call } from '../../components';\nimport { meta } from '../../meta';\n\nexport default Capability.makeModule(() =>\n  Effect.sync(() => {\n    return Capability.contributes(Capabilities.ReactRoot, {\n      id: meta.id,\n      root: () => <Call.Audio />,\n    });\n  }),\n);\n"],
+  "mappings": ";;;;;;;;;;;;;AAIA,YAAYA,YAAY;AACxB,OAAOC,WAAW;AAElB,SAASC,cAAcC,kBAAkB;AAKzC,IAAA,qBAAeC,WAAWC,WAAW,MAC5BC,YAAK,MAAA;AACV,SAAOF,WAAWG,YAAYC,aAAaC,WAAW;IACpDC,IAAIC,KAAKD;IACTE,MAAM,MAAM,sBAAA,cAACC,KAAKC,OAAK,IAAA;EACzB,CAAA;AACF,CAAA,CAAA;",
+  "names": ["Effect", "React", "Capabilities", "Capability", "Capability", "makeModule", "sync", "contributes", "Capabilities", "ReactRoot", "id", "meta", "root", "Call", "Audio"]
+}

package/dist/lib/browser/react-surface-TIHBSZPD.mjs

@@ -0,0 +1,113 @@
+import {
+  Channel_exports,
+  ThreadCapabilities
+} from "./chunk-U32R23JO.mjs";
+import {
+  meta
+} from "./chunk-LUK4UNFA.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/react-surface/react-surface.tsx
+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 { AppCapabilities } from "@dxos/app-toolkit";
+import { Obj } from "@dxos/echo";
+import { getSpace } from "@dxos/react-client/echo";
+import { Thread } from "@dxos/types";
+
+// src/containers/index.ts
+import { lazy } from "react";
+var CallDebugPanel = lazy(() => import("./CallDebugPanel-FGCTY7Q4.mjs"));
+var CallSidebar = lazy(() => import("./CallSidebar-PJCMNDIF.mjs"));
+var ChannelContainer = lazy(() => import("./ChannelContainer-EPYG4QAC.mjs"));
+var ChatContainer = lazy(() => import("./ChatContainer-2243UD2M.mjs"));
+var ThreadCompanion = lazy(() => import("./ThreadCompanion-2CMLJH76.mjs"));
+var ThreadSettings = lazy(() => import("./ThreadSettings-S55YVOGA.mjs"));
+
+// src/capabilities/react-surface/react-surface.tsx
+var react_surface_default = Capability.makeModule(() => Effect.succeed(Capability.contributes(Capabilities.ReactSurface, [
+  Surface.create({
+    id: `${meta.id}/channel`,
+    role: "article",
+    filter: (data) => Obj.instanceOf(Channel_exports.Channel, data.subject),
+    component: ({ data: { subject }, role }) => /* @__PURE__ */ React.createElement(ChannelContainer, {
+      role,
+      subject
+    })
+  }),
+  Surface.create({
+    id: `${meta.id}/chat-companion`,
+    role: "article",
+    filter: (data) => Obj.instanceOf(Channel_exports.Channel, data.companionTo) && data.subject === "chat",
+    component: ({ data: { companionTo: channel } }) => {
+      const space = getSpace(channel);
+      const thread = channel.defaultThread.target;
+      if (!space || !thread) {
+        return null;
+      }
+      return /* @__PURE__ */ React.createElement(ChatContainer, {
+        thread,
+        space
+      });
+    }
+  }),
+  Surface.create({
+    id: `${meta.id}/thread`,
+    role: "article",
+    filter: (data) => Obj.instanceOf(Thread.Thread, data.subject),
+    component: ({ data: { subject } }) => {
+      const space = getSpace(subject);
+      if (!space || !subject) {
+        return null;
+      }
+      return /* @__PURE__ */ React.createElement(ChatContainer, {
+        thread: subject,
+        space
+      });
+    }
+  }),
+  Surface.create({
+    id: `${meta.id}/comments`,
+    role: "article",
+    filter: (data) => data.subject === "comments" && Obj.isObject(data.companionTo),
+    // TODO(wittjosiah): This isn't scrolling properly in a plank.
+    component: ({ data }) => /* @__PURE__ */ React.createElement(ThreadCompanion, {
+      subject: data.companionTo
+    })
+  }),
+  Surface.create({
+    id: `${meta.id}/plugin-settings`,
+    role: "article",
+    filter: (data) => AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+    component: ({ data: { subject } }) => {
+      const { settings, updateSettings } = useSettingsState(subject.atom);
+      return /* @__PURE__ */ React.createElement(ThreadSettings, {
+        settings,
+        onSettingsChange: updateSettings
+      });
+    }
+  }),
+  Surface.create({
+    id: `${meta.id}/assistant`,
+    role: "deck-companion--active-call",
+    component: () => /* @__PURE__ */ React.createElement(CallSidebar, null)
+  }),
+  Surface.create({
+    id: `${meta.id}/devtools-overview`,
+    role: "devtools-overview",
+    component: () => {
+      const call = useCapability(ThreadCapabilities.CallManager);
+      const state = useAtomValue(call.stateAtom);
+      return /* @__PURE__ */ React.createElement(CallDebugPanel, {
+        state
+      });
+    }
+  })
+])));
+export {
+  react_surface_default as default
+};
+//# sourceMappingURL=react-surface-TIHBSZPD.mjs.map