botframework-webchat-api 4.18.2 → 4.19.1-main.20260526.b9ad8fa

package/src/providers/ActivityKeyer/ActivityKeyerComposer.tsx

@@ -1,8 +1,9 @@
-import type { WebChatActivity } from 'botframework-webchat-core';
-import React, { useCallback, useMemo, useRef, type ReactNode } from 'react';
+import { getActivityLivestreamingMetadata, type WebChatActivity } from 'botframework-webchat-core';
+import React, { useCallback, useEffect, useMemo, useRef, type ReactNode } from 'react';
 
 import reduceIterable from '../../hooks/private/reduceIterable';
 import useActivities from '../../hooks/useActivities';
+import usePonyfill from '../Ponyfill/usePonyfill';
 import type { ActivityKeyerContextType } from './private/Context';
 import ActivityKeyerContext from './private/Context';
 import getActivityId from './private/getActivityId';
@@ -17,19 +18,11 @@ type ActivityToKeyMap = Map<WebChatActivity, string>;
 type ClientActivityIdToKeyMap = Map<string, string>;
 type KeyToActivitiesMap = Map<string, readonly WebChatActivity[]>;
 
-function getTypingActivityId(activity: WebChatActivity): string | undefined {
-  const { type } = activity;
+/** After this many ms of no activity changes, verify that the frozen portion was not modified. */
+const FROZEN_CHECK_TIMEOUT = 10_000;
 
-  if (
-    (type === 'message' || type === 'typing') &&
-    'text' in activity &&
-    typeof activity.text === 'string' &&
-    'streamId' in activity.channelData &&
-    activity.channelData.streamId
-  ) {
-    return activity.channelData.streamId;
-  }
-}
+/** Only the last N activities are compared reference-by-reference on each render. */
+const MUTABLE_ACTIVITY_WINDOW = 1_000;
 
 /**
  * React context composer component to assign a perma-key to every activity.
@@ -46,6 +39,7 @@ function getTypingActivityId(activity: WebChatActivity): string | undefined {
  * Local key are only persisted in memory. On refresh, they will be a new random key.
  */
 const ActivityKeyerComposer = ({ children }: Readonly<{ children?: ReactNode | undefined }>) => {
+  const [{ cancelIdleCallback, clearTimeout, requestIdleCallback, setTimeout }] = usePonyfill();
   const existingContext = useActivityKeyerContext(false);
 
   if (existingContext) {
@@ -53,13 +47,118 @@ const ActivityKeyerComposer = ({ children }: Readonly<{ children?: ReactNode | u
   }
 
   const [activities] = useActivities();
-  const activityIdToKeyMapRef = useRef<Readonly<ActivityIdToKeyMap>>(Object.freeze(new Map()));
-  const activityToKeyMapRef = useRef<Readonly<ActivityToKeyMap>>(Object.freeze(new Map()));
-  const clientActivityIdToKeyMapRef = useRef<Readonly<ClientActivityIdToKeyMap>>(Object.freeze(new Map()));
-  const keyToActivitiesMapRef = useRef<Readonly<KeyToActivitiesMap>>(Object.freeze(new Map()));
 
-  // TODO: [P1] `useMemoWithPrevious` to check and cache the resulting array if it hasn't changed.
+  // TODO: [P0]  We should remove the mapping in favor of `localId`,
+  // the id should represent the latest available activity in the stream
+  //
+  // Maps are intentionally mutable so the incremental fast path can append to them in-place.
+  const activityIdToKeyMapRef = useRef<ActivityIdToKeyMap>(new Map());
+  const activityToKeyMapRef = useRef<ActivityToKeyMap>(new Map());
+  const clientActivityIdToKeyMapRef = useRef<ClientActivityIdToKeyMap>(new Map());
+  const keyToActivitiesMapRef = useRef<KeyToActivitiesMap>(new Map());
+  const prevActivitiesRef = useRef<readonly WebChatActivity[]>(Object.freeze([]));
+  const prevActivityKeysStateRef = useRef<readonly [readonly string[]]>(
+    Object.freeze([Object.freeze([])]) as readonly [readonly string[]]
+  );
+  const pendingFrozenCheckRef = useRef<
+    | {
+        readonly current: readonly WebChatActivity[];
+        readonly frozenBoundary: number;
+        readonly prev: readonly WebChatActivity[];
+      }
+    | undefined
+  >();
+  const warnedPositionsRef = useRef<Set<number>>(new Set());
+
+  // Incremental keying: the fast path only processes newly-appended activities (O(delta) per render)
+  // instead of re-iterating all activities (O(n) per render, O(n²) total for n streaming pushes).
   const activityKeysState = useMemo<readonly [readonly string[]]>(() => {
+    const prevActivities = prevActivitiesRef.current;
+
+    // Only the last MUTABLE_ACTIVITY_WINDOW activities are compared each render.
+    // Activities before the frozen boundary are assumed unchanged — O(1) instead of O(n).
+    const frozenBoundary = Math.max(0, Math.min(prevActivities.length, activities.length) - MUTABLE_ACTIVITY_WINDOW);
+    let commonPrefixLength = frozenBoundary;
+    const maxPrefix = Math.min(prevActivities.length, activities.length);
+
+    // eslint-disable-next-line security/detect-object-injection
+    while (commonPrefixLength < maxPrefix && prevActivities[commonPrefixLength] === activities[commonPrefixLength]) {
+      commonPrefixLength++;
+    }
+
+    const isAppendOnly = commonPrefixLength === prevActivities.length;
+
+    if (isAppendOnly) {
+      // Fast path: only new activities were appended — process them incrementally.
+      if (commonPrefixLength === activities.length) {
+        // Array reference changed but content is identical.
+        prevActivitiesRef.current = activities;
+
+        return prevActivityKeysStateRef.current;
+      }
+
+      // Schedule deferred verification of the frozen portion only now that we know:
+      // (1) the update is append-only and (2) there are actual content changes.
+      if (frozenBoundary) {
+        pendingFrozenCheckRef.current = Object.freeze({ current: activities, frozenBoundary, prev: prevActivities });
+      }
+
+      const { current: activityIdToKeyMap } = activityIdToKeyMapRef;
+      const { current: activityToKeyMap } = activityToKeyMapRef;
+      const { current: clientActivityIdToKeyMap } = clientActivityIdToKeyMapRef;
+      const { current: keyToActivitiesMap } = keyToActivitiesMapRef;
+
+      const newKeys: string[] = [];
+
+      for (let i = commonPrefixLength; i < activities.length; i++) {
+        // eslint-disable-next-line security/detect-object-injection
+        const activity = activities[i];
+        const activityId = getActivityId(activity);
+        const clientActivityId = getClientActivityId(activity);
+        const typingActivityId = getActivityLivestreamingMetadata(activity)?.sessionId;
+
+        // Since we mutate maps in-place, a single lookup covers both "previous" and
+        // "current-iteration" entries — equivalent to the slow path's dual-map check.
+        const key =
+          (clientActivityId && clientActivityIdToKeyMap.get(clientActivityId)) ||
+          (typingActivityId && activityIdToKeyMap.get(typingActivityId)) ||
+          (activityId && activityIdToKeyMap.get(activityId)) ||
+          activityToKeyMap.get(activity) ||
+          uniqueId();
+
+        activityId && activityIdToKeyMap.set(activityId, key);
+        typingActivityId && activityIdToKeyMap.set(typingActivityId, key);
+        clientActivityId && clientActivityIdToKeyMap.set(clientActivityId, key);
+        activityToKeyMap.set(activity, key);
+
+        const activitiesForKey = keyToActivitiesMap.get(key);
+
+        keyToActivitiesMap.set(
+          key,
+          activitiesForKey ? Object.freeze([...activitiesForKey, activity]) : Object.freeze([activity])
+        );
+
+        !activitiesForKey && newKeys.push(key);
+      }
+
+      prevActivitiesRef.current = activities;
+
+      if (!newKeys.length) {
+        // New activities might be added to existing keys — no new keys, but the keyToActivitiesMap
+        // was mutated. Return a new tuple reference so context consumers re-render and see the
+        // updated activities-per-key via getActivitiesByKey.
+        return Object.freeze([prevActivityKeysStateRef.current[0]]) as readonly [readonly string[]];
+      }
+
+      const nextKeys = Object.freeze([...prevActivityKeysStateRef.current[0], ...newKeys]);
+      const result = Object.freeze([nextKeys]) as readonly [readonly string[]];
+
+      prevActivityKeysStateRef.current = result;
+
+      return result;
+    }
+
+    // Slow path: activities were removed or reordered — full recalculation.
     const { current: activityIdToKeyMap } = activityIdToKeyMapRef;
     const { current: activityToKeyMap } = activityToKeyMapRef;
     const { current: clientActivityIdToKeyMap } = clientActivityIdToKeyMapRef;
@@ -72,34 +171,98 @@ const ActivityKeyerComposer = ({ children }: Readonly<{ children?: ReactNode | u
     activities.forEach(activity => {
       const activityId = getActivityId(activity);
       const clientActivityId = getClientActivityId(activity);
-      const typingActivityId = getTypingActivityId(activity);
+      const typingActivityId = getActivityLivestreamingMetadata(activity)?.sessionId;
 
       const key =
-        (clientActivityId && clientActivityIdToKeyMap.get(clientActivityId)) ||
-        (typingActivityId && activityIdToKeyMap.get(typingActivityId)) ||
-        (activityId && activityIdToKeyMap.get(activityId)) ||
+        (clientActivityId &&
+          (clientActivityIdToKeyMap.get(clientActivityId) || nextClientActivityIdToKeyMap.get(clientActivityId))) ||
+        (typingActivityId &&
+          (activityIdToKeyMap.get(typingActivityId) || nextActivityIdToKeyMap.get(typingActivityId))) ||
+        (activityId && (activityIdToKeyMap.get(activityId) || nextActivityIdToKeyMap.get(activityId))) ||
         activityToKeyMap.get(activity) ||
+        nextActivityToKeyMap.get(activity) ||
         uniqueId();
 
       activityId && nextActivityIdToKeyMap.set(activityId, key);
+      typingActivityId && nextActivityIdToKeyMap.set(typingActivityId, key);
       clientActivityId && nextClientActivityIdToKeyMap.set(clientActivityId, key);
       nextActivityToKeyMap.set(activity, key);
       nextActivityKeys.add(key);
 
-      const activities = nextKeyToActivitiesMap.has(key) ? [...nextKeyToActivitiesMap.get(key)] : [];
+      const activitiesForKey = nextKeyToActivitiesMap.has(key) ? [...nextKeyToActivitiesMap.get(key)] : [];
 
-      activities.push(activity);
-      nextKeyToActivitiesMap.set(key, Object.freeze(activities));
+      activitiesForKey.push(activity);
+      nextKeyToActivitiesMap.set(key, Object.freeze(activitiesForKey));
     });
 
-    activityIdToKeyMapRef.current = Object.freeze(nextActivityIdToKeyMap);
-    activityToKeyMapRef.current = Object.freeze(nextActivityToKeyMap);
-    clientActivityIdToKeyMapRef.current = Object.freeze(nextClientActivityIdToKeyMap);
-    keyToActivitiesMapRef.current = Object.freeze(nextKeyToActivitiesMap);
+    activityIdToKeyMapRef.current = nextActivityIdToKeyMap;
+    activityToKeyMapRef.current = nextActivityToKeyMap;
+    clientActivityIdToKeyMapRef.current = nextClientActivityIdToKeyMap;
+    keyToActivitiesMapRef.current = nextKeyToActivitiesMap;
+    prevActivitiesRef.current = activities;
+
+    // Slow path did a full recalculation — no frozen check needed, reset warnings.
+    pendingFrozenCheckRef.current = undefined;
+    warnedPositionsRef.current.clear();
+
+    const nextKeys = Object.freeze([...nextActivityKeys.values()]);
+    const result = Object.freeze([nextKeys]) as readonly [readonly string[]];
+
+    prevActivityKeysStateRef.current = result;
+
+    return result;
+  }, [
+    activities,
+    activityIdToKeyMapRef,
+    activityToKeyMapRef,
+    clientActivityIdToKeyMapRef,
+    keyToActivitiesMapRef,
+    pendingFrozenCheckRef,
+    prevActivitiesRef,
+    prevActivityKeysStateRef,
+    warnedPositionsRef
+  ]);
+
+  // Deferred verification: after FROZEN_CHECK_TIMEOUT of quiet, validate that activities
+  // inside the frozen portion have not actually changed. Warn once per position if they did.
+  // Uses requestIdleCallback inside the timeout to avoid contending with the first post-stream repaint.
+  useEffect(() => {
+    const pending = pendingFrozenCheckRef.current;
+
+    if (!pending) {
+      return;
+    }
+
+    let idleHandle: ReturnType<NonNullable<typeof requestIdleCallback>> | undefined;
+
+    const runCheck = () => {
+      const { current: currentActivities, frozenBoundary, prev: prevFrozenActivities } = pending;
+
+      for (let i = 0; i < frozenBoundary; i++) {
+        // eslint-disable-next-line security/detect-object-injection
+        if (prevFrozenActivities[i] !== currentActivities[i] && !warnedPositionsRef.current.has(i)) {
+          warnedPositionsRef.current.add(i);
+
+          console.warn(
+            `botframework-webchat internal: change in activity at position ${i} was not applied because it is outside the mutable window of ${MUTABLE_ACTIVITY_WINDOW}.`
+          );
+        }
+      }
+    };
+
+    const timer = setTimeout(() => {
+      if (requestIdleCallback) {
+        idleHandle = requestIdleCallback(runCheck);
+      } else {
+        runCheck();
+      }
+    }, FROZEN_CHECK_TIMEOUT);
 
-    // `nextActivityKeys` could potentially same as `prevActivityKeys` despite reference differences, we should memoize it.
-    return Object.freeze([Object.freeze([...nextActivityKeys.values()])]) as readonly [readonly string[]];
-  }, [activities, activityIdToKeyMapRef, activityToKeyMapRef, clientActivityIdToKeyMapRef, keyToActivitiesMapRef]);
+    return () => {
+      clearTimeout(timer);
+      idleHandle !== undefined && cancelIdleCallback?.(idleHandle);
+    };
+  }, [activities, cancelIdleCallback, clearTimeout, requestIdleCallback, setTimeout]);
 
   const getActivitiesByKey: (key?: string | undefined) => readonly WebChatActivity[] | undefined = useCallback(
     (key?: string | undefined): readonly WebChatActivity[] | undefined => key && keyToActivitiesMapRef.current.get(key),
@@ -122,13 +285,7 @@ const ActivityKeyerComposer = ({ children }: Readonly<{ children?: ReactNode | u
   );
 
   const contextValue = useMemo<ActivityKeyerContextType>(
-    () => ({
-      activityKeysState,
-      getActivityByKey,
-      getActivitiesByKey,
-      getKeyByActivity,
-      getKeyByActivityId
-    }),
+    () => ({ activityKeysState, getActivityByKey, getActivitiesByKey, getKeyByActivity, getKeyByActivityId }),
     [activityKeysState, getActivitiesByKey, getActivityByKey, getKeyByActivity, getKeyByActivityId]
   );
 

package/src/providers/ActivityKeyer/private/someIterable.spec.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-magic-numbers */
-
 import someIterable from './someIterable';
 
 describe('when predicate return true should return true', () => {

package/src/providers/ActivityListener/ActivityListenerComposer.tsx

@@ -8,7 +8,7 @@ type Props = Readonly<{ children?: ReactNode | undefined }>;
 
 const ActivityListenerComposer = memo(({ children }: Props) => {
   const [activities] = useActivities();
-  const prevActivities = usePrevious<WebChatActivity[]>(activities, []);
+  const prevActivities = usePrevious<readonly WebChatActivity[]>(activities, Object.freeze([]));
 
   const upsertedActivitiesState = useMemo<readonly [readonly WebChatActivity[]]>(() => {
     const upserts: WebChatActivity[] = [];

package/src/providers/ActivitySendStatus/ActivitySendStatusComposer.tsx

@@ -1,4 +1,5 @@
-import React, { useEffect, useMemo, useRef, type FC, type PropsWithChildren } from 'react';
+import React, { useEffect, useMemo, useRef, type ReactNode } from 'react';
+import { querySendStatusFromOutgoingActivity } from 'botframework-webchat-core/activity.js';
 
 import { useActivities, usePonyfill } from '../../hooks/index';
 import useForceRender from '../../hooks/internal/useForceRender';
@@ -14,7 +15,7 @@ import isMapEqual from './private/isMapEqual';
 const EXPIRY_SEND_FAILED = -Infinity;
 const EXPIRY_SENT = Infinity;
 
-const ActivitySendStatusComposer: FC<PropsWithChildren<{}>> = ({ children }) => {
+const ActivitySendStatusComposer = ({ children }: Readonly<{ children?: ReactNode | undefined }>) => {
   const [activities] = useActivities();
   const [{ clearTimeout, Date, setTimeout }] = usePonyfill();
   const forceRender = useForceRender();
@@ -43,9 +44,11 @@ const ActivitySendStatusComposer: FC<PropsWithChildren<{}>> = ({ children }) =>
 
             if (key) {
               const {
-                channelData: { state, 'webchat:send-status': sendStatus }
+                channelData: { state }
               } = activity;
 
+              const sendStatus = querySendStatusFromOutgoingActivity(activity);
+
               // `channelData.state` is being deprecated in favor of `channelData['webchat:send-status']`.
               // Please refer to #4362 for details. Remove on or after 2024-07-31.
               const rectifiedSendStatus = sendStatus || (state === 'sent' ? 'sent' : 'sending');

package/src/providers/ActivityTyping/ActivityTypingComposer.tsx

@@ -1,80 +1,166 @@
-import type { WebChatActivity } from 'botframework-webchat-core';
-import React, { memo, useMemo, type ReactNode } from 'react';
-import { useRefFrom } from 'use-ref-from';
+import { getActivityLivestreamingMetadata, type WebChatActivity } from 'botframework-webchat-core';
+import { queryReceivedAtFromActivity } from 'botframework-webchat-core/activity.js';
+import { iteratorFind } from 'iter-fest';
+import React, { memo, useCallback, useMemo, type ReactNode } from 'react';
 
 import numberWithInfinity from '../../hooks/private/numberWithInfinity';
-import useActivities from '../../hooks/useActivities';
 import usePonyfill from '../../hooks/usePonyfill';
-import useUpsertedActivities from '../../providers/ActivityListener/useUpsertedActivities';
 import ActivityTypingContext, { ActivityTypingContextType } from './private/Context';
-import useMemoWithPrevious from './private/useMemoWithPrevious';
+import useReduceActivities from './private/useReduceActivities';
 import { type AllTyping } from './types/AllTyping';
 
-const INITIAL_ALL_TYPING_STATE = Object.freeze([Object.freeze(new Map())] as const);
+type Entry = {
+  livestreamActivities: Map<
+    string,
+    {
+      activity: WebChatActivity;
+      contentful: boolean;
+      firstReceivedAt: number;
+      lastReceivedAt: number;
+    }
+  >;
+  name: string | undefined;
+  role: 'bot' | 'user';
+  typingIndicator:
+    | {
+        activity: WebChatActivity;
+        duration: number;
+        firstReceivedAt: number;
+        lastReceivedAt: number;
+      }
+    | undefined;
+};
 
 type Props = Readonly<{ children?: ReactNode | undefined }>;
 
-function isLivestreamChunk(activity: WebChatActivity): boolean {
-  return (
-    activity.type === 'typing' &&
-    'text' in activity &&
-    typeof activity.text === 'string' &&
-    activity.channelData.streamType !== 'informative'
-  );
-}
-
 const ActivityTypingComposer = ({ children }: Props) => {
   const [{ Date }] = usePonyfill();
-  const [activities] = useActivities();
-  const [upsertedActivities] = useUpsertedActivities();
-  const activitiesRef = useRefFrom(activities);
-
-  const allTypingState = useMemoWithPrevious<readonly [ReadonlyMap<string, AllTyping>]>(
-    (prevAllTypingState = INITIAL_ALL_TYPING_STATE) => {
-      const { current: activities } = activitiesRef;
-      const nextTyping = new Map(prevAllTypingState[0]);
-      let changed = false;
-
-      const firstIndex = upsertedActivities.reduce(
-        (firstIndex, upsertedActivity) => Math.min(firstIndex, activities.indexOf(upsertedActivity)),
-        Infinity
-      );
 
-      for (const activity of activities.slice(firstIndex)) {
-        const {
-          from,
-          from: { id, role },
-          type
-        } = activity;
-
-        if (type === 'typing' && (role === 'bot' || role === 'user')) {
-          const currentTyping = nextTyping.get(id);
-          // TODO: When we rework on types of DLActivity, we will make sure all activities has "webChat.receivedAt", this coalesces can be removed.
-          const receivedAt = activity.channelData.webChat?.receivedAt || Date.now();
-
-          nextTyping.set(id, {
-            firstReceivedAt: currentTyping?.firstReceivedAt || receivedAt,
-            lastActivityDuration: numberWithInfinity(
-              activity.channelData.webChat?.styleOptions?.typingAnimationDuration
-            ),
-            lastReceivedAt: receivedAt,
-            name: from.name,
-            role,
-            type: isLivestreamChunk(activity) ? 'livestream' : 'busy' // Informative message means the bot is busy.
-          });
-
-          changed = true;
-        } else if (type === 'message') {
-          nextTyping.delete(id);
-          changed = true;
+  const reducer = useCallback(
+    (
+      prevTypingState: ReadonlyMap<string, Readonly<Entry>> | undefined,
+      activity: WebChatActivity
+    ): ReadonlyMap<string, Readonly<Entry>> | undefined => {
+      const {
+        from: { id, name, role },
+        type
+      } = activity;
+
+      if (role === 'channel') {
+        return prevTypingState;
+      }
+
+      // A normal message activity, or final activity (which could be "message" or "typing"), will remove the typing indicator.
+      const receivedAt = queryReceivedAtFromActivity(activity) ?? Date.now();
+
+      const livestreamingMetadata = getActivityLivestreamingMetadata(activity);
+      const typingState = new Map(prevTypingState);
+      const existingEntry = typingState.get(id);
+      const mutableEntry: Entry = {
+        typingIndicator: undefined,
+        ...existingEntry,
+        livestreamActivities: new Map(existingEntry?.livestreamActivities),
+        name,
+        role
+      };
+
+      if (livestreamingMetadata) {
+        mutableEntry.typingIndicator = undefined;
+
+        const { sessionId } = livestreamingMetadata;
+
+        if (livestreamingMetadata.type === 'final activity') {
+          mutableEntry.livestreamActivities.delete(sessionId);
+        } else {
+          mutableEntry.livestreamActivities.set(
+            sessionId,
+            Object.freeze({
+              firstReceivedAt: mutableEntry.livestreamActivities.get(sessionId)?.firstReceivedAt ?? receivedAt,
+              ...mutableEntry.livestreamActivities.get(sessionId),
+              activity,
+              contentful: livestreamingMetadata.type !== 'contentless',
+              lastReceivedAt: receivedAt
+            })
+          );
         }
+      } else if (type === 'message') {
+        mutableEntry.typingIndicator = undefined;
+      } else if (type === 'typing') {
+        mutableEntry.typingIndicator = Object.freeze({
+          activity,
+          duration: numberWithInfinity(activity.channelData.webChat?.styleOptions?.typingAnimationDuration),
+          firstReceivedAt: mutableEntry.typingIndicator?.firstReceivedAt ?? receivedAt,
+          lastReceivedAt: receivedAt
+        });
       }
 
-      return changed ? Object.freeze([nextTyping]) : prevAllTypingState;
+      typingState.set(id, Object.freeze(mutableEntry));
+
+      return Object.freeze(typingState);
     },
-    [activitiesRef, upsertedActivities]
+    [Date]
   );
 
+  const state: ReadonlyMap<string, Entry> = useReduceActivities(reducer) || Object.freeze(new Map());
+
+  const allTyping = useMemo(() => {
+    const map = new Map<string, AllTyping>();
+
+    for (const [id, entry] of state.entries()) {
+      const firstContentfulLivestream = iteratorFind(
+        entry.livestreamActivities.values(),
+        ({ contentful }) => contentful
+      );
+
+      const firstContentlessLivestream = iteratorFind(
+        entry.livestreamActivities.values(),
+        ({ contentful }) => !contentful
+      );
+
+      if (firstContentfulLivestream) {
+        map.set(
+          id,
+          Object.freeze({
+            firstReceivedAt: firstContentfulLivestream.firstReceivedAt,
+            lastActivityDuration: Infinity,
+            lastReceivedAt: firstContentfulLivestream.lastReceivedAt,
+            name: entry.name,
+            role: entry.role,
+            type: 'livestream'
+          } satisfies AllTyping)
+        );
+      } else if (firstContentlessLivestream) {
+        map.set(
+          id,
+          Object.freeze({
+            firstReceivedAt: firstContentlessLivestream.firstReceivedAt,
+            lastActivityDuration: Infinity,
+            lastReceivedAt: firstContentlessLivestream.lastReceivedAt,
+            name: entry.name,
+            role: entry.role,
+            type: 'busy'
+          } satisfies AllTyping)
+        );
+      } else if (entry.typingIndicator) {
+        map.set(
+          id,
+          Object.freeze({
+            firstReceivedAt: entry.typingIndicator.firstReceivedAt,
+            lastActivityDuration: entry.typingIndicator.duration,
+            lastReceivedAt: entry.typingIndicator.lastReceivedAt,
+            name: entry.name,
+            role: entry.role,
+            type: 'busy'
+          } satisfies AllTyping)
+        );
+      }
+    }
+
+    return map;
+  }, [state]);
+
+  const allTypingState = useMemo(() => Object.freeze([allTyping] as const), [allTyping]);
+
   const context = useMemo<ActivityTypingContextType>(() => ({ allTypingState }), [allTypingState]);
 
   return <ActivityTypingContext.Provider value={context}>{children}</ActivityTypingContext.Provider>;