@dxos/plugin-thread 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/src/containers/ChannelArticle/ChannelArticle.tsx

@@ -3,18 +3,19 @@
 //
 
 import { useAtomValue } from '@effect/atom-react/Hooks';
-import * as Atom from 'effect/unstable/reactivity/Atom';
+import * as Atom from 'effect/reactivity/Atom';
 import React, { useCallback } from 'react';
 
-import { Surface, useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
-import { AppSurface } from '@dxos/app-toolkit/ui';
+import * as Hooks from '@dxos/app-framework/Hooks';
+import * as Surface from '@dxos/app-framework/Surface';
+import * as AppSurface from '@dxos/app-toolkit/AppSurface';
 import { Obj } from '@dxos/echo';
 import { useIdentity, useMembers } from '@dxos/halo-react';
 import { log } from '@dxos/log';
 import * as CallsCapabilities from '@dxos/plugin-calls/CallsCapabilities';
 import { getSpace } from '@dxos/react-client/echo';
-import { Panel } from '@dxos/react-ui';
-import { Menu, MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
+import { ActionToolbar, MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
+import * as Panel from '@dxos/react-ui/Panel';
 import { type Channel } from '@dxos/types';
 
 import { MessageThread } from '#components';
@@ -50,15 +51,15 @@ export const ChannelArticle = ({ role, subject: channel, attendableId, chatOnly
   const members = useMembers(space?.id);
   const id = channel ? Obj.getURI(channel) : undefined;
   const activity = useStatus(space, id);
-  const { invokePromise } = useOperationInvoker();
+  const { invokePromise } = Hooks.useOperationInvoker();
 
-  const providers = useCapabilities(ThreadCapabilities.ChannelBackend);
+  const providers = Hooks.useCapabilities(ThreadCapabilities.ChannelBackend);
   const provider = channel ? ChannelBackend.resolveProvider(providers, channel.backend.kind) : undefined;
   const messages = useMessages(channel);
   const readOnly = channel ? (provider?.readOnly?.(channel) ?? Obj.getMeta(channel).keys.length > 0) : false;
 
-  const callProvider = useCapabilities(CallsCapabilities.CallTransportProvider)[0];
-  const callManager = useCapabilities(CallsCapabilities.Manager)[0];
+  const callProvider = Hooks.useCapabilities(CallsCapabilities.CallTransportProvider)[0];
+  const callManager = Hooks.useCapabilities(CallsCapabilities.Manager)[0];
   const joined = useAtomValue(callManager?.joinedAtom ?? NOT_JOINED);
   const currentRoomId = useAtomValue(callManager?.roomIdAtom ?? NO_ROOM);
   // `chatOnly` (the in-call chat companion) keeps showing messages so the call lives only in the primary.
@@ -114,20 +115,16 @@ export const ChannelArticle = ({ role, subject: channel, attendableId, chatOnly
   return (
     <Panel.Root role={role}>
       {canStartCall && (
-        <Menu.Root {...menuActions} attendableId={attendableId}>
-          <Panel.Toolbar asChild>
-            <Menu.Toolbar>
-              <Menu.Items />
-            </Menu.Toolbar>
-          </Panel.Toolbar>
-        </Menu.Root>
+        <Panel.Header>
+          <ActionToolbar {...menuActions} attendableId={attendableId} />
+        </Panel.Header>
       )}
       {showCall ? (
-        <Panel.Content>
+        <Panel.Body>
           <Surface.Surface type={AppSurface.Article} data={{ subject: { roomId: id }, attendableId }} limit={1} />
-        </Panel.Content>
+        </Panel.Body>
       ) : (
-        <Panel.Content asChild>
+        <Panel.Body asChild>
           <MessageThread
             id={id}
             classNames='dx-document'
@@ -138,7 +135,7 @@ export const ChannelArticle = ({ role, subject: channel, attendableId, chatOnly
             onSend={handleSend}
             readOnly={readOnly}
           />
-        </Panel.Content>
+        </Panel.Body>
       )}
     </Panel.Root>
   );

package/src/containers/ChannelArticle/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export { ChannelArticle as default } from './ChannelArticle';
+export { ChannelArticle as default } from './ChannelArticle.tsx';

package/src/containers/ChannelCreatePanel/ChannelCreatePanel.tsx

@@ -4,7 +4,7 @@
 
 import React, { useCallback, useMemo } from 'react';
 
-import { useCapabilities } from '@dxos/app-framework/ui';
+import * as Hooks from '@dxos/app-framework/Hooks';
 import { Obj } from '@dxos/echo';
 import type * as SpaceCapabilities from '@dxos/plugin-space/SpaceCapabilities';
 import { Form } from '@dxos/react-ui-form';
@@ -18,8 +18,12 @@ import { ChannelBackend, ThreadCapabilities } from '#types';
  * selected provider's create fields (just a name field when there is a single
  * field-less provider).
  */
-export const ChannelCreatePanel = ({ target, onCreateObject }: SpaceCapabilities.CreateObjectCustomPanelProps) => {
-  const providers = useCapabilities(ThreadCapabilities.ChannelBackend);
+export const ChannelCreatePanel = ({
+  target,
+  onCreateObject,
+  onCancel,
+}: SpaceCapabilities.CreateObjectCustomPanelProps) => {
+  const providers = Hooks.useCapabilities(ThreadCapabilities.ChannelBackend);
   const schema = useMemo(() => ChannelBackend.buildChannelFormSchema(providers), [providers]);
 
   const handleSave = useCallback(
@@ -38,12 +42,13 @@ export const ChannelCreatePanel = ({ target, onCreateObject }: SpaceCapabilities
       schema={schema}
       defaultValues={{}}
       onSave={handleSave}
+      onCancel={onCancel}
       testId='create-channel-form'
     >
       <Form.Viewport>
         <Form.Content>
-          <Form.FieldSet />
-          <Form.Submit />
+          <Form.Fields />
+          <Form.Actions />
         </Form.Content>
       </Form.Viewport>
     </Form.Root>

package/src/containers/ChannelCreatePanel/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export { ChannelCreatePanel as default } from './ChannelCreatePanel';
+export { ChannelCreatePanel as default } from './ChannelCreatePanel.tsx';

package/src/containers/ThreadArticle/ThreadArticle.stories.tsx

@@ -7,24 +7,24 @@ import React, { useState } from 'react';
 
 import * as Capabilities from '@dxos/app-framework/Capabilities';
 import * as Capability from '@dxos/app-framework/Capability';
+import * as Surface from '@dxos/app-framework/Surface';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { Surface } from '@dxos/app-framework/ui';
-import { AppSurface } from '@dxos/app-toolkit/ui';
-import { corePlugins } from '@dxos/plugin-testing';
+import * as AppSurface from '@dxos/app-toolkit/AppSurface';
+import * as CorePlugins from '@dxos/plugin-testing/CorePlugins';
 import { random } from '@dxos/random';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { withClientProvider } from '@dxos/react-client/testing';
-import { useAsyncEffect } from '@dxos/react-ui';
 import { withMosaic } from '@dxos/react-ui-mosaic/testing';
 import { Thread as ThreadComponent } from '@dxos/react-ui-thread';
+import * as Hooks from '@dxos/react-ui/Hooks';
 import { Loading, withLayout } from '@dxos/react-ui/testing';
 import { Message, Thread } from '@dxos/types';
 
 import { translations } from '#translations';
 
-import { ThreadArticle } from './ThreadArticle';
+import { ThreadArticle } from './ThreadArticle.tsx';
 
 random.seed(1);
 
@@ -34,7 +34,7 @@ const DefaultStory = () => {
   const [space, setSpace] = useState<Space>();
   const [thread, setThread] = useState<Thread.Thread | null>();
 
-  useAsyncEffect(async () => {
+  Hooks.useAsyncEffect(async () => {
     if (identity) {
       const space = await client.spaces.create();
       const thread = space.db.add(Thread.make({ status: 'active' }));
@@ -60,7 +60,7 @@ const meta = {
     // TODO(wittjosiah): This shouldn't depend on app framework (use withClientProvider instead).
     //  Currently this is required because MessageThread renders an object tile via a Surface.
     withPluginManager({
-      plugins: corePlugins(),
+      plugins: CorePlugins.make(),
       capabilities: [
         Capability.contribute(
           Capabilities.ReactSurface,

package/src/containers/ThreadArticle/ThreadArticle.tsx

@@ -2,21 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
+import { useAtomValue } from '@effect/atom-react/Hooks';
+import * as Atom from 'effect/reactivity/Atom';
 import React, { useMemo } from 'react';
 
 import { Obj, Ref } from '@dxos/echo';
 import { useIdentity, useMembers } from '@dxos/halo-react';
 import { getSpace } from '@dxos/react-client/echo';
-import { Panel, type ThemedClassName } from '@dxos/react-ui';
-import { composable, composableProps } from '@dxos/react-ui';
 import { type ThreadContentProps } from '@dxos/react-ui-thread';
+import * as Panel from '@dxos/react-ui/Panel';
+import * as Util from '@dxos/react-ui/Util';
 import { Message, type Thread } from '@dxos/types';
-import { isNonNullable } from '@dxos/util';
 
 import { MessageThread } from '#components';
 import { useStatus } from '#hooks';
 
-export type ThreadArticleProps = ThemedClassName<
+export type ThreadArticleProps = Util.ThemedClassName<
   {
     thread: Thread.Thread;
     context?: Obj.Unknown;
@@ -28,7 +29,7 @@ export type ThreadArticleProps = ThemedClassName<
  * Renders an AutoMerge {@link Thread} as a chat: appends new messages by pushing
  * onto `thread.messages`. Used for comment threads and the meeting in-call chat.
  */
-export const ThreadArticle = composable<HTMLDivElement, ThreadArticleProps>(
+export const ThreadArticle = Util.composable<HTMLDivElement, ThreadArticleProps>(
   ({ thread, context, autoFocus, current, ...props }, forwardedRef) => {
     // Members and presence are space-scoped; a thread outside a space has nothing to resolve against.
     const space = getSpace(thread);
@@ -37,9 +38,17 @@ export const ThreadArticle = composable<HTMLDivElement, ThreadArticleProps>(
     const members = useMembers(space?.id);
     const activity = useStatus(space, id);
 
-    const messages = useMemo(
-      () => thread.messages.map((message) => message.target).filter(isNonNullable),
-      [thread.messages],
+    const messages = useAtomValue(
+      useMemo(
+        () =>
+          Atom.make((get) =>
+            (get(Obj.atomProperty(thread, 'messages')) ?? []).flatMap((message) => {
+              const value = get(message.atom);
+              return value ? [value] : [];
+            }),
+          ),
+        [thread],
+      ),
     );
 
     const handleSend = (text: string) => {
@@ -64,10 +73,10 @@ export const ThreadArticle = composable<HTMLDivElement, ThreadArticleProps>(
 
     return (
       <Panel.Root>
-        <Panel.Toolbar></Panel.Toolbar>
-        <Panel.Content asChild>
+        <Panel.Header></Panel.Header>
+        <Panel.Body asChild>
           <MessageThread
-            {...composableProps(props)}
+            {...Util.composableProps(props)}
             id={id}
             identity={identity}
             members={members}
@@ -78,7 +87,7 @@ export const ThreadArticle = composable<HTMLDivElement, ThreadArticleProps>(
             current={current}
             ref={forwardedRef}
           />
-        </Panel.Content>
+        </Panel.Body>
       </Panel.Root>
     );
   },

package/src/containers/ThreadArticle/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-export { ThreadArticle as default } from './ThreadArticle';
+export { ThreadArticle as default } from './ThreadArticle.tsx';

package/src/containers/index.ts

@@ -4,6 +4,6 @@
 
 import { type ComponentType, lazy } from 'react';
 
-export const ChannelCreatePanel: ComponentType<any> = lazy(() => import('./ChannelCreatePanel'));
-export const ChannelArticle: ComponentType<any> = lazy(() => import('./ChannelArticle'));
-export const ThreadArticle: ComponentType<any> = lazy(() => import('./ThreadArticle'));
+export const ChannelCreatePanel: ComponentType<any> = lazy(() => import('./ChannelCreatePanel/index.ts'));
+export const ChannelArticle: ComponentType<any> = lazy(() => import('./ChannelArticle/index.ts'));
+export const ThreadArticle: ComponentType<any> = lazy(() => import('./ThreadArticle/index.ts'));

package/src/hooks/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './useMessages';
-export * from './useStatus';
+export * from './useMessages.ts';
+export * from './useStatus.ts';

package/src/hooks/useMessages.ts

@@ -4,7 +4,7 @@
 
 import { useCallback, useMemo, useRef, useSyncExternalStore } from 'react';
 
-import { useCapabilities } from '@dxos/app-framework/ui';
+import * as Hooks from '@dxos/app-framework/Hooks';
 import { type Channel, type Message } from '@dxos/types';
 
 import { ChannelBackend, ThreadCapabilities } from '#types';
@@ -13,7 +13,7 @@ const EMPTY: readonly Message.Message[] = [];
 
 /** Reactive message list for a channel, resolved through its backend provider. */
 export const useMessages = (channel: Channel.Channel | undefined): readonly Message.Message[] => {
-  const providers = useCapabilities(ThreadCapabilities.ChannelBackend);
+  const providers = Hooks.useCapabilities(ThreadCapabilities.ChannelBackend);
   const provider = useMemo(
     () => (channel ? ChannelBackend.resolveProvider(providers, channel.backend.kind) : undefined),
     [providers, channel],

package/src/hooks/useStatus.ts

@@ -4,6 +4,7 @@
 
 import { useEffect, useState } from 'react';
 
+import { unpackJson } from '@dxos/protocols/buf';
 import { type Space } from '@dxos/react-client/echo';
 
 // TODO(burdon): Generalize and factor out.
@@ -15,7 +16,9 @@ export const useStatus = (space?: Space, channel?: string) => {
     }
 
     const unsubscribe = space.listen(`status/${channel}`, (status) => {
-      const { event } = status.payload ?? {};
+      // The status payload travels as a `google.protobuf.Struct` packed in an `Any`, so it arrives
+      // as opaque JSON that has to be narrowed rather than destructured as typed.
+      const { event } = unpackJson(status.payload) ?? {};
       setProcessing(event === 'processing');
     });
 

package/src/index.ts

@@ -5,8 +5,6 @@
 // TODO(wittjosiah): Hooks should not be exported from the plugin package at all.
 //   Either refactor callers to not need them or factor them out to a shared package.
 
-export * as ThreadPlugin from './ThreadPlugin';
-export * from '#hooks';
-export * from '#meta';
-export * from './paths';
+export * as ThreadPlugin from './ThreadPlugin.ts';
+export * from '#operations';
 export * from '#types';

package/src/meta.ts

@@ -4,7 +4,7 @@
 
 import * as Plugin from '@dxos/app-framework/Plugin';
 
-import config from '../dx.config';
+import config from '../dx.config.ts';
 
 export const meta = Plugin.getMetaFromConfig(config);
 

package/src/operations/ThreadOperationHandlerSet.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Operation from '@dxos/compute/Operation';
+import * as OperationHandlerSet from '@dxos/compute/OperationHandlerSet';
+
+import { ThreadOperation } from '#types';
+
+export const handlers = OperationHandlerSet.lazy([
+  ThreadOperation.AppendChannelMessage.pipe(Operation.lazyHandler(() => import('./append-channel-message.ts'))),
+  ThreadOperation.CreateChannel.pipe(Operation.lazyHandler(() => import('./create-channel.ts'))),
+  ThreadOperation.SendToChannel.pipe(Operation.lazyHandler(() => import('./send-to-channel.ts'))),
+  ThreadOperation.OpenDirect.pipe(Operation.lazyHandler(() => import('./open-direct.ts'))),
+  ThreadOperation.ConnectChannel.pipe(Operation.lazyHandler(() => import('./connect-channel.ts'))),
+  ThreadOperation.DisconnectChannel.pipe(Operation.lazyHandler(() => import('./disconnect-channel.ts'))),
+  ThreadOperation.GetChannelStatus.pipe(Operation.lazyHandler(() => import('./get-channel-status.ts'))),
+]);

package/src/operations/append-channel-message.ts

@@ -4,20 +4,16 @@
 
 import * as Effect from 'effect/Effect';
 
-import * as Capability from '@dxos/app-framework/Capability';
 import * as Operation from '@dxos/compute/Operation';
-import { invariant } from '@dxos/invariant';
 import { Message } from '@dxos/types';
 
-import { ChannelBackend, ThreadCapabilities, ThreadOperation } from '#types';
+import { ChannelBackend, ThreadOperation } from '#types';
 
 const handler: Operation.WithHandler<typeof ThreadOperation.AppendChannelMessage> =
   ThreadOperation.AppendChannelMessage.pipe(
     Operation.withHandler(
       Effect.fnUntraced(function* ({ channel, sender, text }) {
-        const providers = yield* Capability.getAll(ThreadCapabilities.ChannelBackend);
-        const provider = ChannelBackend.resolveProvider(providers, channel.backend.kind);
-        invariant(provider, `No channel backend for kind: ${channel.backend.kind}`);
+        const provider = yield* ChannelBackend.getProvider(channel);
 
         const message = Message.make({
           sender,

package/src/operations/channel-operations.test.ts

@@ -0,0 +1,185 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Registry from 'effect/reactivity/AtomRegistry';
+import * as Schema from 'effect/Schema';
+
+import * as Capability from '@dxos/app-framework/Capability';
+import * as CapabilityManager from '@dxos/app-framework/CapabilityManager';
+import { Database, Feed, Filter, Ref } from '@dxos/echo';
+import { TestDatabaseLayer } from '@dxos/echo-client/testing';
+import { BaseError } from '@dxos/errors';
+import { Channel, Message, Person } from '@dxos/types';
+
+import { ChannelBackend, ThreadCapabilities, type ThreadOperation } from '#types';
+
+import { feedChannelBackend } from '../capabilities/channel-backend-feed.ts';
+import connectChannel from './connect-channel.ts';
+import disconnectChannel from './disconnect-channel.ts';
+import getChannelStatus from './get-channel-status.ts';
+import openDirect from './open-direct.ts';
+import sendToChannel from './send-to-channel.ts';
+
+const FAKE_KIND = 'org.dxos.channel.backend.fake';
+
+class RefusedError extends BaseError.extend('RefusedError', 'The backend refused the post.') {}
+
+/** A backend with every optional member, recording what it was asked to do. */
+const makeFakeBackend = () => {
+  const sent: { thread?: string; text: string }[] = [];
+  let running = false;
+  const status = (): ThreadOperation.ConnectionStatus => ({ running, state: running ? 'ready' : 'idle' });
+  const record = (message: Message.Message, thread?: string) =>
+    Effect.sync(() => {
+      const text = Message.extractText(message);
+      if (text === 'refuse') {
+        return Effect.fail(new RefusedError());
+      }
+      sent.push({ thread, text });
+      return Effect.succeed({ messageIds: [`m${sent.length}`], properties: { fake: { thread } } });
+    }).pipe(Effect.flatten);
+
+  const provider: ThreadCapabilities.ChannelBackendProvider = {
+    kind: FAKE_KIND,
+    label: 'Fake',
+    createFields: Schema.Struct({}),
+    makeConfig: () => Feed.make(),
+    subscribe: () => () => {},
+    send: (_channel, message) => record(message),
+    openDirect: (_channel, person) =>
+      Effect.succeed(person.identities?.find((identity) => identity.label === 'fake')?.value),
+    threads: { send: (_channel, thread, message) => record(message, thread) },
+    connection: {
+      start: () => Effect.sync(() => ((running = true), status())),
+      stop: () => Effect.sync(() => ((running = false), status())),
+      status: () => Effect.sync(status),
+    },
+  };
+  return { provider, sent };
+};
+
+/** Capability manager holding the given channel backends, as plugin-thread and backend plugins contribute them. */
+const capabilities = (...providers: ThreadCapabilities.ChannelBackendProvider[]) => {
+  const manager = CapabilityManager.make({ registry: Registry.make() });
+  for (const provider of providers) {
+    manager.contribute({
+      interface: ThreadCapabilities.ChannelBackend,
+      implementation: provider,
+      module: provider.kind,
+    });
+  }
+  return manager;
+};
+
+/** The printed cause of a failed exit, or undefined when it succeeded. */
+const failureOf = <A, E>(exit: Exit.Exit<A, E>): string | undefined =>
+  Exit.isFailure(exit) ? String(exit.cause) : undefined;
+
+const testLayer = () => TestDatabaseLayer({ types: [Channel.Channel, Feed.Feed, Message.Message, Person.Person] });
+
+describe('channel operations', () => {
+  it.effect('sendToChannel appends to a feed-backed channel', () =>
+    Effect.gen(function* () {
+      const channel = yield* Database.add(Channel.make({ name: 'general' }));
+      yield* Database.flush();
+
+      const result = yield* sendToChannel
+        .handler({ channel: Ref.make(channel), text: 'hello' })
+        .pipe(Effect.provideService(Capability.Service, capabilities(feedChannelBackend)));
+      expect(result).toEqual({ delivered: true });
+
+      const feed = Channel.getFeed(channel);
+      expect(feed).toBeDefined();
+      if (feed) {
+        const messages = yield* Feed.query(feed, Filter.type(Message.Message)).run;
+        expect(messages.map(Message.extractText)).toEqual(['hello']);
+      }
+    }).pipe(Effect.provide(testLayer())),
+  );
+
+  it.effect('sendToChannel with a thread fails on a backend without threads', () =>
+    Effect.gen(function* () {
+      const channel = yield* Database.add(Channel.make({ name: 'general' }));
+      const exit = yield* sendToChannel
+        .handler({ channel: Ref.make(channel), thread: 't1', text: 'hello' })
+        .pipe(Effect.provideService(Capability.Service, capabilities(feedChannelBackend)), Effect.exit);
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit)) {
+        expect(String(exit.cause)).toContain('does not support threads');
+      }
+    }).pipe(Effect.provide(testLayer())),
+  );
+
+  it.effect('fails with a typed error when no backend handles the channel', () =>
+    Effect.gen(function* () {
+      const channel = yield* Database.add(Channel.make({ backend: { kind: FAKE_KIND, config: Feed.make() } }));
+      const exit = yield* getChannelStatus
+        .handler({ channel: Ref.make(channel) })
+        .pipe(Effect.provideService(Capability.Service, capabilities(feedChannelBackend)), Effect.exit);
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit)) {
+        expect(String(exit.cause)).toContain(ChannelBackend.ChannelBackendNotFoundError.name);
+      }
+    }).pipe(Effect.provide(testLayer())),
+  );
+
+  it.effect('dispatches threads, direct conversations and the connection to the backend', () =>
+    Effect.gen(function* () {
+      const { provider, sent } = makeFakeBackend();
+      const channel = yield* Database.add(Channel.make({ backend: { kind: FAKE_KIND, config: Feed.make() } }));
+      const dima = yield* Database.add(Person.make({ fullName: 'Dima', identities: [{ label: 'fake', value: 'd1' }] }));
+      const nobody = yield* Database.add(Person.make({ fullName: 'Nobody' }));
+      const withBackend = Effect.provideService(Capability.Service, capabilities(feedChannelBackend, provider));
+
+      const direct = yield* openDirect
+        .handler({ channel: Ref.make(channel), person: Ref.make(dima) })
+        .pipe(withBackend);
+      expect(direct).toEqual({ thread: 'd1' });
+      const unreachable = yield* openDirect
+        .handler({ channel: Ref.make(channel), person: Ref.make(nobody) })
+        .pipe(withBackend);
+      expect(unreachable.thread).toBeUndefined();
+      expect(unreachable.reason).toContain('Fake');
+
+      const posted = yield* sendToChannel
+        .handler({ channel: Ref.make(channel), thread: 'd1', text: 'hi' })
+        .pipe(withBackend);
+      expect(posted).toEqual({ delivered: true, messageIds: ['m1'], properties: { fake: { thread: 'd1' } } });
+      const refused = yield* sendToChannel.handler({ channel: Ref.make(channel), text: 'refuse' }).pipe(withBackend);
+      expect(refused).toEqual({ delivered: false, reason: 'The backend refused the post.' });
+      expect(sent).toEqual([{ thread: 'd1', text: 'hi' }]);
+
+      expect((yield* getChannelStatus.handler({ channel: Ref.make(channel) }).pipe(withBackend)).status.running).toBe(
+        false,
+      );
+      expect((yield* connectChannel.handler({ channel: Ref.make(channel) }).pipe(withBackend)).status).toEqual({
+        running: true,
+        state: 'ready',
+      });
+      expect((yield* disconnectChannel.handler({ channel: Ref.make(channel) }).pipe(withBackend)).status.running).toBe(
+        false,
+      );
+    }).pipe(Effect.provide(testLayer())),
+  );
+
+  it.effect('openDirect and the connection fail with a typed error on a backend without them', () =>
+    Effect.gen(function* () {
+      const channel = yield* Database.add(Channel.make({ name: 'general' }));
+      const person = yield* Database.add(Person.make({ fullName: 'Dima' }));
+      const withFeed = Effect.provideService(Capability.Service, capabilities(feedChannelBackend));
+
+      const direct = yield* openDirect
+        .handler({ channel: Ref.make(channel), person: Ref.make(person) })
+        .pipe(withFeed, Effect.exit);
+      const connect = yield* connectChannel.handler({ channel: Ref.make(channel) }).pipe(withFeed, Effect.exit);
+      expect([failureOf(direct), failureOf(connect)]).toEqual([
+        expect.stringContaining(ChannelBackend.ChannelBackendUnsupportedError.name),
+        expect.stringContaining(ChannelBackend.ChannelBackendUnsupportedError.name),
+      ]);
+    }).pipe(Effect.provide(testLayer())),
+  );
+});

package/src/operations/connect-channel.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '@dxos/compute/Operation';
+import { Database } from '@dxos/echo';
+
+import { ChannelBackend, ThreadOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof ThreadOperation.ConnectChannel> = ThreadOperation.ConnectChannel.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ channel: channelRef }) {
+      const channel = yield* Database.load(channelRef);
+      const provider = yield* ChannelBackend.getProvider(channel);
+      const connection = yield* ChannelBackend.requireMember(provider, 'connection');
+      return { status: yield* connection.start(channel) };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/disconnect-channel.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '@dxos/compute/Operation';
+import { Database } from '@dxos/echo';
+
+import { ChannelBackend, ThreadOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof ThreadOperation.DisconnectChannel> = ThreadOperation.DisconnectChannel.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ channel: channelRef }) {
+      const channel = yield* Database.load(channelRef);
+      const provider = yield* ChannelBackend.getProvider(channel);
+      const connection = yield* ChannelBackend.requireMember(provider, 'connection');
+      return { status: yield* connection.stop(channel) };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/get-channel-status.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '@dxos/compute/Operation';
+import { Database } from '@dxos/echo';
+
+import { ChannelBackend, ThreadOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof ThreadOperation.GetChannelStatus> = ThreadOperation.GetChannelStatus.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ channel: channelRef }) {
+      const channel = yield* Database.load(channelRef);
+      const provider = yield* ChannelBackend.getProvider(channel);
+      const connection = yield* ChannelBackend.requireMember(provider, 'connection');
+      return { status: yield* connection.status(channel) };
+    }),
+  ),
+);
+
+export default handler;