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

package/src/calls/util/stub-media-streams.ts

@@ -3,8 +3,8 @@
 //
 //
 
-import { waitForCondition, scheduleTaskInterval } from '@dxos/async';
-import { cancelWithContext, type Context } from '@dxos/context';
+import { scheduleTaskInterval, waitForCondition } from '@dxos/async';
+import { type Context, cancelWithContext } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 
 /**
@@ -30,7 +30,7 @@ export const createBlackCanvasStreamTrack = async ({
     canvasCtx.fillStyle = 'black';
     canvasCtx.fillRect(0, 0, canvas.width, canvas.height);
   };
-  scheduleTaskInterval(ctx, async () => drawFrame(), 1_000);
+  scheduleTaskInterval(ctx, async () => drawFrame(), 200);
 
   const track = canvas.captureStream().getVideoTracks()[0];
   drawFrame();
@@ -40,6 +40,20 @@ export const createBlackCanvasStreamTrack = async ({
   return track;
 };
 
+let audioContextStartedPreviously = false;
+const userGestureEvents = [
+  'click',
+  'contextmenu',
+  'auxclick',
+  'dblclick',
+  'mousedown',
+  'mouseup',
+  'pointerup',
+  'touchend',
+  'keydown',
+  'keyup',
+];
+
 /**
  * Creates an inaudible audio stream track.
  * We need this to have audio track available when audio is disabled.
@@ -53,14 +67,57 @@ export const createInaudibleAudioStreamTrack = async ({ ctx }: { ctx: Context })
 
   const gainNode = audioContext.createGain();
   // even w/ gain at 0 some packets are sent
-  gainNode.gain.setValueAtTime(0.02, audioContext.currentTime);
+  gainNode.gain.setValueAtTime(0, audioContext.currentTime);
   oscillator.connect(gainNode);
 
   const destination = audioContext.createMediaStreamDestination();
   gainNode.connect(destination);
-  oscillator.start();
+
+  let oscillatorStarted = false;
+  const ensureOscillatorStarted = () => {
+    if (oscillatorStarted) return;
+    oscillator.start();
+    oscillatorStarted = true;
+  };
+
+  const stateChangeHandler = () => {
+    if (audioContext.state === 'running') {
+      audioContextStartedPreviously = true;
+      ensureOscillatorStarted();
+    }
+    if (audioContext.state === 'suspended' || (audioContext.state as string) === 'interrupted') {
+      resumeAudioContext();
+    }
+  };
+
+  audioContext.addEventListener('statechange', stateChangeHandler);
+
+  const resumeAudioContext = () => {
+    void audioContext.resume().then(() => {
+      cleanUpUserGestureListeners();
+    });
+  };
+
+  const cleanUpUserGestureListeners = () => {
+    userGestureEvents.forEach((gesture) => {
+      document.removeEventListener(gesture, resumeAudioContext, {
+        capture: true,
+      });
+    });
+  };
+
+  if (audioContextStartedPreviously) {
+    resumeAudioContext();
+  } else {
+    userGestureEvents.forEach((gesture) => {
+      document.addEventListener(gesture, resumeAudioContext, {
+        capture: true,
+      });
+    });
+  }
 
   ctx.onDispose(async () => {
+    cleanUpUserGestureListeners();
     oscillator.disconnect();
     oscillator.stop();
     await audioContext.close();

package/src/calls-service.stories.tsx

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

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

@@ -5,18 +5,21 @@
 import { Rx } from '@effect-rx/rx-react';
 import { Option, pipe } from 'effect';
 
-import { Capabilities, contributes, createIntent, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { Obj } from '@dxos/echo';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { PLANK_COMPANION_TYPE, ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { createExtension, ROOT_ID, rxFromSignal } from '@dxos/plugin-graph';
+import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { ROOT_ID, createExtension, rxFromSignal } from '@dxos/plugin-graph';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
 
-import { ThreadCapabilities } from './capabilities';
-import { meta, THREAD_PLUGIN } from '../meta';
+import { THREAD_PLUGIN, meta } from '../meta';
 import { ChannelType, ThreadAction } from '../types';
 import { getAnchor } from '../util';
 
+import { ThreadCapabilities } from './capabilities';
+
+// TODO(wittjosiah): Highlight active calls in L1.
+//  Track active meetings by subscribing to meetings query and polling the swarms of recent meetings in the space.
 export default (context: PluginContext) => {
   const resolve = (typename: string) =>
     context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};

package/src/capabilities/call-manager.ts

@@ -2,12 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { contributes, type PluginContext } from '@dxos/app-framework';
+import { type PluginContext, contributes } from '@dxos/app-framework';
 import { ClientCapabilities } from '@dxos/plugin-client';
 
-import { ThreadCapabilities } from './capabilities';
 import { CallManager } from '../calls';
 
+import { ThreadCapabilities } from './capabilities';
+
 export default async (context: PluginContext) => {
   const client = context.getCapability(ClientCapabilities.Client);
   const callManager = new CallManager(client);

package/src/capabilities/capabilities.ts

@@ -5,9 +5,9 @@
 import { defineCapability } from '@dxos/app-framework';
 import { type DeepReadonly } from '@dxos/util';
 
-import { type CallState, type MediaState, type CallManager } from '../calls';
+import { type CallManager, type CallState, type MediaState } from '../calls';
 import { THREAD_PLUGIN } from '../meta';
-import { type ViewState, type ThreadState, type ChannelType } from '../types';
+import { type ChannelType, type ThreadState, type ViewState } from '../types';
 
 export namespace ThreadCapabilities {
   export const CallManager = defineCapability<CallManager>(`${THREAD_PLUGIN}/capability/call-manager`);

package/src/capabilities/index.ts

@@ -12,5 +12,6 @@ export const ReactRoot = lazy(() => import('./react-root'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const ThreadSettings = lazy(() => import('./settings'));
 export const ThreadState = lazy(() => import('./state'));
+export const Toolkit = lazy(() => import('./toolkit'));
 
 export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -4,20 +4,21 @@
 
 import { Effect } from 'effect';
 
-import { Capabilities, contributes, createIntent, createResolver, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
 import { sleep } from '@dxos/async';
 import { Obj, Relation, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, Ref } from '@dxos/react-client/echo';
+import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
 import { AnchoredTo, DataType } from '@dxos/schema';
 
-import { ThreadCapabilities } from './capabilities';
 import { THREAD_PLUGIN } from '../meta';
 import { ChannelType, ThreadAction, ThreadType } from '../types';
 
+import { ThreadCapabilities } from './capabilities';
+
 export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
@@ -94,6 +95,39 @@ export default (context: PluginContext) =>
         };
       },
     }),
+    createResolver({
+      intent: ThreadAction.AddProposal,
+      resolve: ({ text, anchor, sender, subject }) => {
+        const space = getSpace(subject);
+        invariant(space, 'Space not found');
+
+        const subjectId = fullyQualifiedId(subject);
+        const proposal = Obj.make(DataType.Message, {
+          created: new Date().toISOString(),
+          sender,
+          blocks: [{ _tag: 'proposal', text }],
+        });
+        const thread = Obj.make(ThreadType, { name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
+
+        return {
+          intents: [
+            createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }),
+            createIntent(SpaceAction.AddRelation, {
+              space,
+              schema: AnchoredTo,
+              source: thread,
+              target: subject,
+              fields: { anchor },
+            }),
+            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+            createIntent(DeckAction.ChangeCompanion, {
+              primary: subjectId,
+              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
+            }),
+          ],
+        };
+      },
+    }),
     createResolver({
       intent: ThreadAction.Select,
       resolve: ({ current }) => {
@@ -197,7 +231,6 @@ export default (context: PluginContext) =>
         const subjectId = fullyQualifiedId(subject);
         const space = getSpace(subject);
         invariant(space, 'Space not found');
-        const intents = [];
 
         const message = Obj.make(DataType.Message, {
           created: new Date().toISOString(),
@@ -208,6 +241,7 @@ export default (context: PluginContext) =>
         });
         thread.messages.push(Ref.make(message));
 
+        const intents = [];
         const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
         if (draft) {
           // Move draft to document.

package/src/capabilities/markdown.ts

@@ -4,15 +4,16 @@
 
 import { EditorView } from '@codemirror/view';
 
-import { Capabilities, contributes, createIntent, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { commentClickedEffect, commentsState, type EditorState, overlap } from '@dxos/react-ui-editor';
+import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
 
-import { ThreadCapabilities } from './capabilities';
 import { threads } from '../extensions';
 
+import { ThreadCapabilities } from './capabilities';
+
 export default (context: PluginContext) =>
   contributes(MarkdownCapabilities.Extensions, [
     ({ document: doc }) => {

package/src/capabilities/react-surface.tsx

@@ -9,17 +9,18 @@ import { Obj, type Ref } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
 import { getSpace } from '@dxos/react-client/echo';
 
-import { ThreadCapabilities } from './capabilities';
 import {
-  CallSidebar,
   CallDebugPanel,
+  CallSidebar,
   ChannelContainer,
+  ChatContainer,
   ThreadComplementary,
   ThreadSettings,
-  ChatContainer,
 } from '../components';
 import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadType, type ThreadSettingsProps } from '../types';
+import { ChannelType, type ThreadSettingsProps, ThreadType } from '../types';
+
+import { ThreadCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [

package/src/capabilities/state.ts

@@ -5,9 +5,10 @@
 import { contributes } from '@dxos/app-framework';
 import { live } from '@dxos/live-object';
 
-import { ThreadCapabilities } from './capabilities';
 import { type ThreadState, type ViewStore } from '../types';
 
+import { ThreadCapabilities } from './capabilities';
+
 const initialViewState = { showResolvedThreads: false };
 
 export default () => {

package/src/capabilities/toolkit.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool, AiToolkit } from '@effect/ai';
+import { Array, Effect, Schema, pipe } from 'effect';
+
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { ArtifactId, computeDiffsWithCursors } from '@dxos/assistant';
+import { type SpaceId } from '@dxos/keys';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { type Markdown } from '@dxos/plugin-markdown/types';
+import { createDocAccessor } from '@dxos/react-client/echo';
+import { trim } from '@dxos/util';
+
+import { ThreadAction } from '../types';
+
+// TODO(wittjosiah): How to make this work for more than Documents?
+class Toolkit extends AiToolkit.make(
+  AiTool.make('add-proposals', {
+    description: trim`
+      Proposes a set of changes to a document.
+    `,
+    parameters: {
+      id: ArtifactId,
+      diffs: Schema.Array(Schema.String).annotations({
+        description: 'The diffs to propose for the document.',
+      }),
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+) {
+  static layer = (context: PluginContext) =>
+    Toolkit.toLayer({
+      'add-proposals': ({ id, diffs: _diffs }) =>
+        Effect.gen(function* () {
+          // TODO(wittjosiah): Get capabilities via layers.
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          const client = context.getCapability(ClientCapabilities.Client);
+          const state = context.getCapability(Capabilities.Layout);
+
+          const dxn = ArtifactId.toDXN(id, state.workspace as SpaceId);
+
+          const echoDxn = dxn.asEchoDXN();
+          if (!echoDxn) {
+            throw new Error(`Invalid object ID: ${id}`);
+          }
+
+          const space = client.spaces.get(echoDxn.spaceId!);
+          const object = space?.db.getObjectById<Markdown.Document>(echoDxn.echoId);
+          if (!object) {
+            throw new Error(`Object not found: ${id}`);
+          }
+
+          const content = yield* Effect.promise(() => object.content.load());
+          const accessor = createDocAccessor(content, ['content']);
+          yield* pipe(
+            computeDiffsWithCursors(accessor, _diffs),
+            Array.map(({ cursor, text }) =>
+              createIntent(ThreadAction.AddProposal, {
+                subject: object,
+                sender: { role: 'assistant' },
+                anchor: cursor,
+                text,
+              }),
+            ),
+            Array.map(dispatch),
+            Effect.allWith({ concurrency: 'unbounded' }),
+          );
+        }).pipe(Effect.orDie),
+    });
+}
+
+export default (context: PluginContext) => [
+  contributes(Capabilities.Toolkit, Toolkit),
+  contributes(Capabilities.ToolkitHandler, Toolkit.layer(context)),
+];

package/src/components/Call/Call.tsx

@@ -2,17 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type PropsWithChildren, type FC } from 'react';
+import React, { type FC, type PropsWithChildren } from 'react';
 
 import { useCapability } from '@dxos/app-framework';
 import { type ThemedClassName } from '@dxos/react-ui';
 
-import { Toolbar, type ToolbarProps } from './Toolbar';
 import { ThreadCapabilities } from '../../capabilities';
 import { useDebugMode } from '../../hooks';
 import { AudioStream } from '../Media';
 import { ParticipantGrid } from '../Participant';
 
+import { Toolbar, type ToolbarProps } from './Toolbar';
+
 //
 // Root
 //

package/src/components/Call/Toolbar.tsx

@@ -5,14 +5,14 @@
 import React from 'react';
 
 import { useAppGraph, useCapability } from '@dxos/app-framework';
-import { useNode, useActions } from '@dxos/plugin-graph';
+import { useActions, useNode } from '@dxos/plugin-graph';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
 import {
   Icon,
   IconButton,
   type IconButtonProps,
+  Toolbar as NaturalToolbar,
   type ThemedClassName,
-  Toolbar as NativeToolbar,
   toLocalizedString,
   useTranslation,
 } from '@dxos/react-ui';
@@ -56,7 +56,7 @@ export const Toolbar = ({
   // TODO(wittjosiah): In order to use toolbar, need to update to actually use the graph action callbacks directly.
   return (
     <div className={mx('z-20 flex justify-center m-8', autoHideControls && groupHoverControlItemWithTransition)}>
-      <NativeToolbar.Root classNames={['p-2 bg-modalSurface rounded-md shadow-md', classNames]}>
+      <NaturalToolbar.Root classNames={['p-2 bg-modalSurface rounded-md shadow-md', classNames]}>
         <ToggleButton
           active={call.media.audioEnabled}
           state={{
@@ -95,7 +95,7 @@ export const Toolbar = ({
             <Icon icon='ph--users--regular' size={4} />
             <div>{participants}</div>
           </div>
-        )) || <NativeToolbar.Separator variant='gap' />}
+        )) || <NaturalToolbar.Separator variant='gap' />}
 
         {call.joined && (
           <>
@@ -151,7 +151,7 @@ export const Toolbar = ({
         ) : (
           <IconButton variant='primary' icon='ph--phone-incoming--regular' label={t('join call')} onClick={onJoin} />
         )}
-      </NativeToolbar.Root>
+      </NaturalToolbar.Root>
     </div>
   );
 };