@dxos/plugin-thread 0.8.2-main.f11618f → 0.8.2-staging.42af850

package/src/peers.stories.tsx

@@ -0,0 +1,189 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type StoryObj, type Meta } from '@storybook/react';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+
+import { scheduleTask, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { Config, useConfig } from '@dxos/react-client';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { Button } from '@dxos/react-ui';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { withLayout, withTheme } from '@dxos/storybook-utils';
+
+import { type TrackObject, CallsServicePeer, CALLS_URL } from './calls';
+// @ts-ignore
+import video from '../testing/video.mp4';
+
+const useVideoStreamTrack = (videoElement: HTMLVideoElement | null) => {
+  // Get video stream track.
+  const [videoStreamTrack, setVideoStreamTrack] = useState<MediaStreamTrack | undefined>(undefined);
+  const hadRun = useRef(false);
+  useEffect(() => {
+    // This is done to capture only one video stream.
+    if (!videoElement || hadRun.current || !video) {
+      return;
+    }
+    hadRun.current = true;
+
+    videoElement.src = video;
+    videoElement.addEventListener('playing', () => {
+      const stream = (videoElement as any).captureStream();
+      log.info('captured stream', { stream });
+      stream.onaddtrack = (event: MediaStreamTrackEvent) => {
+        if (event.track.kind === 'video') {
+          log.info('video stream track state', { state: event.track.readyState });
+          setVideoStreamTrack(event.track);
+        }
+      };
+    });
+  }, [videoElement]);
+
+  return videoStreamTrack;
+};
+
+const DefaultStory = ({ videoSrc }: { videoSrc: string }) => {
+  const config = useConfig();
+  const callsConfig = {
+    iceServers: config.get('runtime.services.ice'),
+    apiBase: `${CALLS_URL}/api/calls`,
+  };
+  const peerPush = useMemo(() => new CallsServicePeer(callsConfig), []);
+  const peerPull = useMemo(() => new CallsServicePeer(callsConfig), []);
+  const pushVideoElement = useRef<HTMLVideoElement>(null);
+  const pullVideoElement = useRef<HTMLVideoElement>(null);
+  const [metrics, setMetrics] = useState<Record<string, any>>({});
+  // Get video stream track.
+  const videoStreamTrack = useVideoStreamTrack(pushVideoElement.current);
+  const pullCtx = useRef<Context | undefined>(undefined);
+  const trackInfo = useRef<TrackObject | undefined>(undefined);
+  const hadRun = useRef(false);
+
+  // Push/pull video stream track to cloudflare.
+  useEffect(() => {
+    if (hadRun.current || !videoStreamTrack || !peerPush || !peerPull) {
+      return;
+    }
+    hadRun.current = true;
+    const ctx = new Context();
+    scheduleTask(ctx, async () => {
+      log.info('starting push/pull', { videoStreamTrack });
+      await peerPush.open();
+      await peerPull.open();
+      ctx.onDispose(() => {
+        void peerPush.close();
+        void peerPull.close();
+      });
+
+      // Push track to cloudflare.
+      performance.mark('push:begin');
+      const pushedTrack = await peerPush.pushTrack({ track: videoStreamTrack });
+      trackInfo.current = pushedTrack;
+      performance.mark('push:end');
+      const pushTime = performance.measure('push', 'push:begin', 'push:end').duration;
+      log.info('successfully pushed track', { pushTime, pushedTrack });
+      setMetrics((prev) => ({ ...prev, 'time to push track [ms]': Math.round(pushTime) }));
+
+      // Wait for cloudflare to process the track.
+      await sleep(500);
+
+      // Pull track from cloudflare.
+      performance.mark('pullTrack:begin');
+      pullCtx.current = new Context();
+      const pulledTrack = await peerPull.pullTrack({
+        trackData: { ...pushedTrack, mid: undefined },
+        ctx: pullCtx.current,
+      });
+      performance.mark('pullTrack:end');
+      const pullTime = performance.measure('pullTrack', 'pullTrack:begin', 'pullTrack:end').duration;
+      setMetrics((prev) => ({ ...prev, 'time to pull track [ms]': Math.round(pullTime) }));
+      log.info('successfully pulled track', { pullTime, pulledTrack });
+
+      invariant(pulledTrack);
+      invariant(pullVideoElement.current);
+      performance.mark('playVideo:begin');
+      pullVideoElement.current.srcObject = new MediaStream([pulledTrack]);
+      await pullVideoElement.current.play();
+      performance.mark('playVideo:end');
+      const playTime = performance.measure('playVideo', 'playVideo:begin', 'playVideo:end').duration;
+      setMetrics((prev) => ({ ...prev, 'time to play pulled video [ms]': Math.round(playTime) }));
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [videoStreamTrack, peerPush, peerPull]);
+
+  const handleRePullVideo = async () => {
+    performance.mark('rePullVideo:begin');
+    invariant(pullVideoElement.current);
+    invariant(pullVideoElement.current.srcObject instanceof MediaStream);
+    const pulledTrack = pullVideoElement.current.srcObject.getTracks()[0];
+    invariant(pulledTrack);
+    pullVideoElement.current.srcObject.removeTrack(pulledTrack);
+    await pullCtx.current!.dispose();
+    pulledTrack.stop();
+    pullCtx.current = new Context();
+    const newPulledTrack = await peerPull.pullTrack({
+      trackData: { ...trackInfo.current!, mid: undefined },
+      ctx: pullCtx.current,
+    });
+    invariant(newPulledTrack);
+    pullVideoElement.current.srcObject.addTrack(newPulledTrack);
+    performance.mark('rePullVideo:end');
+    const rePullTime = performance.measure('rePullVideo', 'rePullVideo:begin', 'rePullVideo:end').duration;
+    setMetrics((prev) => ({ ...prev, 'time to re-pull video [ms]': Math.round(rePullTime) }));
+  };
+
+  return (
+    <div className='grid grid-cols-3 gap-4 items-center'>
+      <video ref={pushVideoElement} muted autoPlay src={video} loop />
+      <Json data={metrics} />
+      <div className='flex flex-col gap-4'>
+        <video ref={pullVideoElement} muted />
+        <Button
+          disabled={
+            !(
+              pullVideoElement?.current?.srcObject instanceof MediaStream &&
+              pullVideoElement.current.srcObject.getTracks()[0]
+            )
+          }
+          onClick={handleRePullVideo}
+        >
+          Re-pull video
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+const meta: Meta<typeof DefaultStory> = {
+  title: 'plugins/plugin-thread/peers',
+  render: DefaultStory,
+  decorators: [
+    withClientProvider({
+      config: new Config({ runtime: { services: { iceProviders: [{ urls: 'https://edge.dxos.workers.dev/ice' }] } } }),
+    }),
+    withTheme,
+    withLayout(),
+  ],
+  parameters: {
+    layout: 'centered',
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof DefaultStory>;
+
+export const Default: Story = {
+  args: {
+    videoSrc: video,
+  },
+};

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './stories';

package/src/testing/stories.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
+import { live } from '@dxos/live-object';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { GraphPlugin } from '@dxos/plugin-graph';
+import { SpacePlugin } from '@dxos/plugin-space';
+import { ThemePlugin } from '@dxos/plugin-theme';
+import { Config } from '@dxos/react-client';
+import { Ref } from '@dxos/react-client/echo';
+import { defaultTx } from '@dxos/react-ui-theme';
+
+import { ThreadPlugin } from '../ThreadPlugin';
+import { ChannelType, ThreadType } from '../types';
+
+export const createThreadPlugins = async () => [
+  ThemePlugin({ tx: defaultTx }),
+  ClientPlugin({
+    onClientInitialized: async (_, client) => {
+      await client.halo.createIdentity({ displayName: 'Test User' });
+    },
+    onSpacesReady: async (_, client) => {
+      await client.spaces.default.waitUntilReady();
+      const thread = live(ThreadType, { messages: [] });
+      client.spaces.default.db.add(live(ChannelType, { defaultThread: Ref.make(thread), threads: [] }));
+    },
+    config: new Config({
+      runtime: {
+        client: { edgeFeatures: { signaling: true } },
+        services: {
+          edge: {
+            url: 'https://edge.dxos.workers.dev/',
+          },
+          iceProviders: [
+            {
+              urls: 'https://edge.dxos.workers.dev/ice',
+            },
+          ],
+        },
+      },
+    }),
+  }),
+  SpacePlugin(),
+  IntentPlugin(),
+  SettingsPlugin(),
+  GraphPlugin(),
+  ThreadPlugin(),
+];

package/src/translations.ts

@@ -2,9 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ChannelType } from '@dxos/plugin-space/types';
-
 import { THREAD_PLUGIN } from './meta';
+import { ChannelType } from './types';
 
 export default [
   {
@@ -14,7 +13,7 @@ export default [
         'object name placeholder': 'New channel',
       },
       [THREAD_PLUGIN]: {
-        'plugin name': 'Threads',
+        'plugin name': 'Chat',
         'channel title label': 'Title',
         'message placeholder': 'Reply…',
         'activity message': 'Processing…',
@@ -27,9 +26,9 @@ export default [
         'comments heading': 'Comments',
         'chat heading': 'Chat',
         'draft button': 'DRAFT',
-        'no comments title': 'No comments (yet)',
+        'no comments title': 'Comments',
         'no comments message':
-          'To start a comment thread, select a range of text in a document and click the <commentIcon></commentIcon> Create comment button in the toolbar.',
+          'Click on the <commentIcon></commentIcon> button in the document toolbar to create a comment thread on the selected text.',
         'toggle show resolved': 'Show resolved',
         'unnamed object threads label': 'Threads',
         'mark as resolved label': 'Mark as resolved',
@@ -41,6 +40,48 @@ export default [
         'comments label': 'Comments',
         'show all label': 'All comments',
         'show unresolved label': 'Unresolved only',
+
+        'channel companion label': 'Channel',
+        'call panel label': 'Active Call',
+
+        'display name label': 'Display name',
+        'display name description': 'Set your display name before joining a meeting.',
+        'display name input placeholder': 'Enter your name',
+        'set display name label': 'Continue',
+
+        'call tab label': 'Call',
+        'meeting status title': 'Meeting',
+        'share meeting link label': 'Share meeting',
+        'show webrtc stats title': 'Detailed WebRTC Stats',
+
+        'meeting summary label': 'Summary',
+        'summarize label': 'Summarize',
+        'summarizing label': 'Creating summary...',
+        'create summary message': 'A summary doesn’t exist for this meeting yet. Create one now?',
+
+        'join call': 'Join',
+        'leave call': 'Leave',
+
+        'lobby participants_zero': 'No participants',
+        'lobby participants_one': '1 participant',
+        'lobby participants_other': '{{count}} participants',
+
+        'icon pin': 'Pin video',
+        'icon unpin': 'Unpin video',
+        'icon wave': 'Waving',
+        'icon muted': 'Muted',
+        'icon speaking': 'Speaking',
+
+        'mic on': 'Unmute',
+        'mic off': 'Mute',
+        'camera on': 'Turn camera on',
+        'camera off': 'Turn camera off',
+        'camera off label': 'Camera off',
+
+        'raise hand': 'Raise hand',
+        'lower hand': 'Lower hand',
+        'screenshare on': 'Share screen',
+        'screenshare off': 'Stop streaming',
       },
     },
   },

package/src/types/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './schema';
+export * from './types';

package/src/types/schema.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Type } from '@dxos/echo';
+import { DataType } from '@dxos/schema';
+
+export const ThreadStatus = Schema.Union(
+  Schema.Literal('staged'),
+  Schema.Literal('active'),
+  Schema.Literal('resolved'),
+);
+
+export const ThreadType = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  status: Schema.optional(ThreadStatus),
+  messages: Schema.mutable(Schema.Array(Type.Ref(DataType.Message))),
+}).pipe(Type.Obj({ typename: 'dxos.org/type/Thread', version: '0.1.0' }));
+export type ThreadType = Schema.Schema.Type<typeof ThreadType>;
+
+export const ChannelType = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  defaultThread: Type.Ref(ThreadType),
+  // TODO(wittjosiah): Should be an "ordered collection".
+  threads: Schema.mutable(Schema.Array(Type.Ref(ThreadType))),
+}).pipe(Type.Obj({ typename: 'dxos.org/type/Channel', version: '0.1.0' }));
+export type ChannelType = Schema.Schema.Type<typeof ChannelType>;

package/src/types/types.ts

@@ -0,0 +1,110 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Type } from '@dxos/echo';
+import { EchoObjectSchema } from '@dxos/react-client/echo';
+import { AnchoredTo, DataType } from '@dxos/schema';
+
+import { ChannelType, ThreadType } from './schema';
+import { THREAD_PLUGIN } from '../meta';
+
+export namespace ThreadAction {
+  const THREAD_ACTION = `${THREAD_PLUGIN}/action`;
+
+  export class CreateChannel extends Schema.TaggedClass<CreateChannel>()(`${THREAD_ACTION}/create-channel`, {
+    input: Schema.Struct({
+      spaceId: Type.SpaceId,
+      name: Schema.optional(Schema.String),
+    }),
+    output: Schema.Struct({
+      object: ChannelType,
+    }),
+  }) {}
+
+  export class CreateChannelThread extends Schema.TaggedClass<CreateChannelThread>()(
+    `${THREAD_ACTION}/create-channel-thread`,
+    {
+      input: Schema.Struct({
+        channel: ChannelType,
+      }),
+      output: Schema.Struct({
+        object: ThreadType,
+      }),
+    },
+  ) {}
+
+  export class Create extends Schema.TaggedClass<Create>()(`${THREAD_ACTION}/create`, {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
+      anchor: Schema.optional(Schema.String),
+      subject: EchoObjectSchema,
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class Delete extends Schema.TaggedClass<Delete>()(`${THREAD_ACTION}/delete`, {
+    input: Schema.Struct({
+      anchor: AnchoredTo,
+      subject: EchoObjectSchema,
+      thread: Schema.optional(ThreadType),
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class Select extends Schema.TaggedClass<Select>()(`${THREAD_ACTION}/select`, {
+    input: Schema.Struct({
+      current: Schema.String,
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class ToggleResolved extends Schema.TaggedClass<ToggleResolved>()(`${THREAD_ACTION}/toggle-resolved`, {
+    input: Schema.Struct({
+      thread: ThreadType,
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class AddMessage extends Schema.TaggedClass<AddMessage>()(`${THREAD_ACTION}/add-message`, {
+    input: Schema.Struct({
+      subject: EchoObjectSchema,
+      anchor: AnchoredTo,
+      sender: DataType.Actor,
+      text: Schema.String,
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class DeleteMessage extends Schema.TaggedClass<DeleteMessage>()(`${THREAD_ACTION}/delete-message`, {
+    input: Schema.Struct({
+      anchor: AnchoredTo,
+      subject: EchoObjectSchema,
+      messageId: Schema.String,
+      message: Schema.optional(DataType.Message),
+      messageIndex: Schema.optional(Schema.Number),
+    }),
+    output: Schema.Void,
+  }) {}
+}
+
+export const ThreadSettingsSchema = Schema.mutable(Schema.Struct({}));
+export type ThreadSettingsProps = Schema.Schema.Type<typeof ThreadSettingsSchema>;
+
+export interface ThreadModel {
+  root: ThreadType;
+}
+
+type SubjectId = string;
+export type ViewState = { showResolvedThreads: boolean };
+export type ViewStore = Record<SubjectId, ViewState>;
+
+export type ThreadState = {
+  /** Object toolbar state. */
+  toolbar: Record<string, boolean>;
+  /** In-memory draft threads. */
+  drafts: Record<string, AnchoredTo[]>;
+  current?: string | undefined;
+};

package/src/typings/peermetrics-webrtc-stats.d.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+declare module '@peermetrics/webrtc-stats' {
+  import { EventEmitter } from 'events';
+
+  export interface WebRTCStatsConstructorOptions {
+    getStatsInterval?: number;
+    rawStats?: boolean;
+    statsObject?: boolean;
+    filteredStats?: boolean;
+    wrapGetUserMedia?: boolean;
+    debug?: boolean;
+    remote?: boolean;
+    logLevel?: LogLevel;
+  }
+
+  export interface ConnectionInfo {
+    pc: RTCPeerConnection;
+    peerId: number | string;
+    connectionId: string;
+  }
+
+  export class WebRTCStats extends EventEmitter {
+    constructor(options: WebRTCStatsConstructorOptions);
+    addConnection(info: ConnectionInfo): void;
+    removeConnection(info: Pick<ConnectionInfo, 'pc'>): void;
+  }
+}

package/src/util.ts

@@ -2,7 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Match } from 'effect';
+
 import { generateName } from '@dxos/display-name';
+import { type Selection } from '@dxos/plugin-attention';
 import { type PublicKey } from '@dxos/react-client';
 import { type Identity } from '@dxos/react-client/halo';
 import { type MessageMetadata } from '@dxos/react-ui-thread';
@@ -24,3 +27,12 @@ export const getMessageMetadata = (id: string, identity?: Identity): MessageMeta
     },
   };
 };
+
+export const getAnchor = Match.type<Selection | undefined>().pipe(
+  Match.when({ mode: 'single' }, (s) => s.id),
+  Match.when({ mode: 'multi' }, (s) => (s.ids.length > 0 ? s.ids.join(',') : undefined)),
+  Match.when({ mode: 'range' }, (s) => (s.from && s.to ? `${s.from}:${s.to}` : undefined)),
+  Match.when({ mode: 'multi-range' }, (s) => s.ranges[0] && `${s.ranges[0].from}:${s.ranges[0].to}`),
+  Match.when(undefined, () => undefined),
+  Match.exhaustive,
+);

package/dist/lib/browser/ChatContainer-WC6KQDDU.mjs

@@ -1,138 +0,0 @@
-import {
-  MessageContainer,
-  command,
-  getMessageMetadata
-} from "./chunk-FY5OCUP6.mjs";
-import {
-  useStatus
-} from "./chunk-AYNXYEKP.mjs";
-import {
-  THREAD_PLUGIN
-} from "./chunk-WBJLUUOK.mjs";
-
-// packages/plugins/plugin-thread/src/components/ChatContainer.tsx
-import React, { useLayoutEffect, useMemo, useRef, useState } from "react";
-import { create } from "@dxos/echo-schema";
-import { makeRef } from "@dxos/live-object";
-import { useMembers, useQueue } from "@dxos/react-client/echo";
-import { useIdentity } from "@dxos/react-client/halo";
-import { Icon, ScrollArea, useThemeContext, useTranslation } from "@dxos/react-ui";
-import { createBasicExtensions, createThemeExtensions, listener } from "@dxos/react-ui-editor";
-import { StackItem } from "@dxos/react-ui-stack";
-import { mx } from "@dxos/react-ui-theme";
-import { MessageTextbox, Thread, ThreadFooter, threadLayout } from "@dxos/react-ui-thread";
-import { MessageType } from "@dxos/schema";
-var ChatHeading = ({ attendableId }) => {
-  const { t } = useTranslation(THREAD_PLUGIN);
-  return /* @__PURE__ */ React.createElement("div", {
-    role: "none",
-    className: "flex items-center"
-  }, /* @__PURE__ */ React.createElement(StackItem.SigilButton, {
-    attendableId
-  }, /* @__PURE__ */ React.createElement(Icon, {
-    icon: "ph--chat--regular",
-    size: 5
-  })), /* @__PURE__ */ React.createElement(StackItem.HeadingLabel, {
-    attendableId
-  }, t("chat heading")));
-};
-var ChatContainer = ({ space, dxn, context, current, autoFocusTextbox }) => {
-  const id = dxn.toString();
-  const identity = useIdentity();
-  const members = useMembers(space?.key);
-  const queue = useQueue(dxn, {
-    pollInterval: 1e3
-  });
-  const activity = useStatus(space, id);
-  const { t } = useTranslation(THREAD_PLUGIN);
-  const [_count, _setCount] = useState(0);
-  const rerenderEditor = () => _setCount((count) => count + 1);
-  const [autoFocus, setAutoFocus] = useState(autoFocusTextbox);
-  const threadScrollRef = useRef(null);
-  const { themeMode } = useThemeContext();
-  const textboxMetadata = getMessageMetadata(id, identity);
-  const messageRef = useRef("");
-  const extensions = useMemo(() => [
-    createBasicExtensions({
-      placeholder: t("message placeholder")
-    }),
-    createThemeExtensions({
-      themeMode
-    }),
-    listener({
-      onChange: (text) => messageRef.current = text
-    }),
-    command
-  ], [
-    themeMode,
-    _count
-  ]);
-  const scrollToEnd = (behavior) => setTimeout(() => threadScrollRef.current?.scrollIntoView({
-    behavior,
-    block: "end"
-  }), 10);
-  useLayoutEffect(() => {
-    scrollToEnd("instant");
-  }, []);
-  const handleCreate = () => {
-    if (!messageRef.current?.length || !queue) {
-      return false;
-    }
-    queue.append([
-      create(MessageType, {
-        sender: {
-          identityDid: identity.did
-        },
-        created: (/* @__PURE__ */ new Date()).toISOString(),
-        blocks: [
-          {
-            type: "text",
-            text: messageRef.current
-          }
-        ],
-        properties: context ? {
-          context: makeRef(context)
-        } : void 0
-      })
-    ]);
-    messageRef.current = "";
-    setAutoFocus(true);
-    scrollToEnd("smooth");
-    rerenderEditor();
-    return true;
-  };
-  return /* @__PURE__ */ React.createElement(Thread, {
-    current,
-    id,
-    classNames: "bs-full grid-rows-[1fr_min-content_min-content] overflow-hidden transition-[padding-block-end] [[data-sidebar-inline-start-state=open]_&]:lg:pbe-0"
-  }, /* @__PURE__ */ React.createElement(ScrollArea.Root, {
-    classNames: "col-span-2"
-  }, /* @__PURE__ */ React.createElement(ScrollArea.Viewport, {
-    classNames: "overflow-anchored after:overflow-anchor after:block after:bs-px after:-mbs-px [&>div]:min-bs-full [&>div]:!grid [&>div]:grid-rows-[1fr_0]"
-  }, /* @__PURE__ */ React.createElement("div", {
-    role: "none",
-    className: mx(threadLayout, "place-self-end")
-  }, (queue?.items ?? []).map((message) => /* @__PURE__ */ React.createElement(MessageContainer, {
-    key: message.id,
-    message,
-    members
-  }))), /* @__PURE__ */ React.createElement("div", {
-    role: "none",
-    className: "bs-px -mbs-px",
-    ref: threadScrollRef
-  }), /* @__PURE__ */ React.createElement(ScrollArea.Scrollbar, null, /* @__PURE__ */ React.createElement(ScrollArea.Thumb, null)))), /* @__PURE__ */ React.createElement(MessageTextbox, {
-    extensions,
-    autoFocus,
-    onSend: handleCreate,
-    ...textboxMetadata
-  }), /* @__PURE__ */ React.createElement(ThreadFooter, {
-    activity
-  }, t("activity message")));
-};
-var ChatContainer_default = ChatContainer;
-export {
-  ChatContainer,
-  ChatHeading,
-  ChatContainer_default as default
-};
-//# sourceMappingURL=ChatContainer-WC6KQDDU.mjs.map