From 836f43ed67a8810f4ca7f278e7d1710dd729eca4 Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 16:23:51 -0700
Subject: [PATCH 1/6] Remove an updated activity from its previous part
 grouping

An update with the same ID that leaves, joins, or moves between HowTo groupings
stayed in its previous grouping and was inserted again, so it was rendered twice.
---
 .../activities/sort/upsert.howTo.spec.ts      | 202 ++++++++++++++++++
 .../src/reducers/activities/sort/upsert.ts    |  13 ++
 2 files changed, 215 insertions(+)

diff --git a/packages/core/src/reducers/activities/sort/upsert.howTo.spec.ts b/packages/core/src/reducers/activities/sort/upsert.howTo.spec.ts
index 85f69cf3df..d15c55653e 100644
--- a/packages/core/src/reducers/activities/sort/upsert.howTo.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.howTo.spec.ts
@@ -366,3 +366,205 @@ scenario('upserting plain activity in two different grouping', bdd => {
       ]);
     });
 });
+
+scenario('updating an activity out of its grouping', bdd => {
+  const activity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World!', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha!', timestamp: new Date(2_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 2 }
+  );
+
+  const activity3 = buildActivity(
+    { id: 'a-00003', text: 'Bonjour!', timestamp: new Date(3_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 3 }
+  );
+
+  // Same ID as activity2, without `isPartOf`.
+  const nextActivity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha! (updated)', timestamp: new Date(2_000).toISOString() },
+    undefined
+  );
+
+  bdd
+    .given('3 activities in a grouping', () =>
+      [activity1, activity2, activity3].reduce((state, activity) => upsert({ Date }, state, activity), INITIAL_STATE)
+    )
+    .when('the second activity is updated without `isPartOf`', state => upsert({ Date }, state, nextActivity2))
+    .then('should remove it from the grouping', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 3_000,
+              partList: [
+                { activityLocalId: '_:a-00001' as LocalId, logicalTimestamp: 1_000, position: 1, type: 'activity' },
+                { activityLocalId: '_:a-00003' as LocalId, logicalTimestamp: 3_000, position: 3, type: 'activity' }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .and('should appear in `sortedChatHistoryList` on its own, before the grouping', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        { activityLocalId: '_:a-00002' as LocalId, logicalTimestamp: 2_000, type: 'activity' },
+        { howToGroupingId: '_:how-to:00001' as HowToGroupingId, logicalTimestamp: 3_000, type: 'how to grouping' }
+      ] satisfies SortedChatHistory);
+    })
+    .and('`sortedActivities` should have every activity once', (_, state) => {
+      expect(state.sortedActivities).toEqual([
+        activityToExpectation(nextActivity2),
+        activityToExpectation(activity1),
+        activityToExpectation(activity3)
+      ]);
+    });
+});
+
+scenario('updating an activity into another grouping', bdd => {
+  const activity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World!', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha!', timestamp: new Date(2_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00002', '@type': 'HowTo' }], position: 1 }
+  );
+
+  // Same ID as activity1, moved to the second grouping.
+  const nextActivity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World! (updated)', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00002', '@type': 'HowTo' }], position: 2 }
+  );
+
+  bdd
+    .given('2 groupings with an activity each', () =>
+      [activity1, activity2].reduce((state, activity) => upsert({ Date }, state, activity), INITIAL_STATE)
+    )
+    .when('the first activity is updated into the second grouping', state => upsert({ Date }, state, nextActivity1))
+    .then('should drop the emptied grouping and add it to the second grouping', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00002' as HowToGroupingId,
+            {
+              logicalTimestamp: 2_000,
+              partList: [
+                { activityLocalId: '_:a-00002' as LocalId, logicalTimestamp: 2_000, position: 1, type: 'activity' },
+                { activityLocalId: '_:a-00001' as LocalId, logicalTimestamp: 1_000, position: 2, type: 'activity' }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .and('should only have the second grouping in `sortedChatHistoryList`', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        { howToGroupingId: '_:how-to:00002' as HowToGroupingId, logicalTimestamp: 2_000, type: 'how to grouping' }
+      ] satisfies SortedChatHistory);
+    })
+    .and('`sortedActivities` should have every activity once', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(activity2), activityToExpectation(nextActivity1)]);
+    });
+});
+
+scenario('updating an activity into a grouping', bdd => {
+  const activity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World!', timestamp: new Date(1_000).toISOString() },
+    undefined
+  );
+
+  const activity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha!', timestamp: new Date(2_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 2 }
+  );
+
+  // Same ID as activity1, joining the grouping before activity2.
+  const nextActivity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World! (updated)', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  bdd
+    .given('an activity and a grouping', () =>
+      [activity1, activity2].reduce((state, activity) => upsert({ Date }, state, activity), INITIAL_STATE)
+    )
+    .when('the activity is updated into the grouping', state => upsert({ Date }, state, nextActivity1))
+    .then('should add it to the grouping', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 2_000,
+              partList: [
+                { activityLocalId: '_:a-00001' as LocalId, logicalTimestamp: 1_000, position: 1, type: 'activity' },
+                { activityLocalId: '_:a-00002' as LocalId, logicalTimestamp: 2_000, position: 2, type: 'activity' }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .and('should no longer appear in `sortedChatHistoryList` on its own', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        { howToGroupingId: '_:how-to:00001' as HowToGroupingId, logicalTimestamp: 2_000, type: 'how to grouping' }
+      ] satisfies SortedChatHistory);
+    })
+    .and('`sortedActivities` should have every activity once', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(nextActivity1), activityToExpectation(activity2)]);
+    });
+});
+
+scenario('updating an activity in the same grouping', bdd => {
+  const activity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World!', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha!', timestamp: new Date(2_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 2 }
+  );
+
+  // Same ID and grouping as activity1.
+  const nextActivity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World! (updated)', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  bdd
+    .given('2 activities in a grouping', () =>
+      [activity1, activity2].reduce((state, activity) => upsert({ Date }, state, activity), INITIAL_STATE)
+    )
+    .when('the first activity is updated', state => upsert({ Date }, state, nextActivity1))
+    .then('should keep the grouping as-is', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 2_000,
+              partList: [
+                { activityLocalId: '_:a-00001' as LocalId, logicalTimestamp: 1_000, position: 1, type: 'activity' },
+                { activityLocalId: '_:a-00002' as LocalId, logicalTimestamp: 2_000, position: 2, type: 'activity' }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .and('`sortedChatHistoryList` should have the grouping once', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        { howToGroupingId: '_:how-to:00001' as HowToGroupingId, logicalTimestamp: 2_000, type: 'how to grouping' }
+      ] satisfies SortedChatHistory);
+    })
+    .and('`sortedActivities` should have the updated activity in place', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(nextActivity1), activityToExpectation(activity2)]);
+    });
+});
diff --git a/packages/core/src/reducers/activities/sort/upsert.ts b/packages/core/src/reducers/activities/sort/upsert.ts
index a0ee2d8ded..f7bc58a3fa 100644
--- a/packages/core/src/reducers/activities/sort/upsert.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.ts
@@ -1,6 +1,7 @@
 /* eslint-disable complexity */
 import type { GlobalScopePonyfill } from '../../../types/GlobalScopePonyfill';
 import getActivityLivestreamingMetadata from '../../../utils/getActivityLivestreamingMetadata';
+import deleteActivityByLocalId from './deleteActivityByLocalId';
 import computePartListTimestamp from './private/computePartListTimestamp';
 import computeSortedActivities from './private/computeSortedActivities';
 import getLogicalTimestamp from './private/getLogicalTimestamp';
@@ -62,6 +63,18 @@ const INITIAL_STATE = Object.freeze({
 
 function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activity: Activity): State {
   const activityLocalId = getLocalIdFromActivity(activity);
+  const existingActivity = state.activityMap.get(activityLocalId)?.activity;
+
+  // An update can leave, join, or move between HowTo groupings.
+  // Remove the previous revision first, otherwise it stays in its previous grouping and is shown twice.
+  if (
+    existingActivity &&
+    getPartGroupingMetadataMap(existingActivity).get('HowTo')?.groupingId !==
+      getPartGroupingMetadataMap(activity).get('HowTo')?.groupingId
+  ) {
+    return upsert(ponyfill, deleteActivityByLocalId(state, activityLocalId), activity);
+  }
+
   const logicalTimestamp = getLogicalTimestamp(activity, ponyfill);
   const activityLivestreamingMetadata = getActivityLivestreamingMetadata(activity);
 

From 398404cf612cb1ded0d54a9196e6959593f5944e Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 16:51:34 -0700
Subject: [PATCH 2/6] Keep livestream revisions out of the part grouping
 removal on update

---
 .../sort/upsert.howToWithLivestream.spec.ts   | 131 ++++++++++++++++++
 .../src/reducers/activities/sort/upsert.ts    |   7 +-
 2 files changed, 135 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
index e8a20641d1..682f33afe5 100644
--- a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
@@ -382,3 +382,134 @@ scenario('upserting plain activity in the same grouping', bdd => {
       expect(state.sortedActivities).toEqual([activityToExpectation(activity3, 1_000)]);
     });
 });
+
+scenario('re-sending the final revision of a livestream in a grouping without `isPartOf`', bdd => {
+  const activity1 = buildActivity(
+    {
+      channelData: { streamSequence: 1, streamType: 'streaming' },
+      id: 'a-00001',
+      text: 'A quick',
+      timestamp: new Date(1_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamType: 'final' },
+      id: 'a-00002',
+      text: 'A quick brown fox jumped over the lazy dogs.',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'message'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  // Same ID as the final revision, without `isPartOf`.
+  const activity2WithoutGrouping = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamType: 'final' },
+      id: 'a-00002',
+      text: 'A quick brown fox jumped over the lazy dogs.',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'message'
+    },
+    undefined
+  );
+
+  bdd
+    .given('a finalized livestream session in a part grouping', () =>
+      upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2)
+    )
+    .when('the final revision is re-sent without `isPartOf`', state =>
+      upsert({ Date }, state, activity2WithoutGrouping)
+    )
+    .then('the livestream session should stay finalized', (_, state) => {
+      expect(state.livestreamSessionMap.get('a-00001' as LivestreamSessionId)).toHaveProperty('finalized', true);
+    })
+    .and('`sortedChatHistoryList` should only have the part grouping', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        {
+          howToGroupingId: '_:how-to:00001' as HowToGroupingId,
+          logicalTimestamp: 2_000,
+          type: 'how to grouping'
+        }
+      ] satisfies SortedChatHistory);
+    })
+    .and('the final revision should be rendered once', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(activity2, 1_000)]);
+    });
+});
+
+scenario('re-sending an older revision of a finalized livestream in a grouping without `isPartOf`', bdd => {
+  const activity1 = buildActivity(
+    {
+      channelData: { streamSequence: 1, streamType: 'streaming' },
+      id: 'a-00001',
+      text: 'A quick',
+      timestamp: new Date(1_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'A quick brown fox',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity3 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamType: 'final' },
+      id: 'a-00003',
+      text: 'A quick brown fox jumped over the lazy dogs.',
+      timestamp: new Date(3_000).toISOString(),
+      type: 'message'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  // Same ID as the second revision, without `isPartOf`.
+  const activity2WithoutGrouping = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'A quick brown fox',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    undefined
+  );
+
+  bdd
+    .given('a finalized livestream session in a part grouping', () =>
+      upsert({ Date }, upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2), activity3)
+    )
+    .when('the second revision is re-sent without `isPartOf`', state =>
+      upsert({ Date }, state, activity2WithoutGrouping)
+    )
+    .then('should keep the second revision in `activityMap`', (_, state) => {
+      expect(state.activityMap.get('_:a-00002' as LocalId)?.activity).toEqual(activityToExpectation(activity2));
+    })
+    .and('should keep the livestream session finalized with all revisions', (_, state) => {
+      expect(state.livestreamSessionMap.get('a-00001' as LivestreamSessionId)).toEqual({
+        activities: [
+          expect.objectContaining({ activityLocalId: '_:a-00001' as LocalId }),
+          expect.objectContaining({ activityLocalId: '_:a-00002' as LocalId }),
+          expect.objectContaining({ activityLocalId: '_:a-00003' as LocalId })
+        ],
+        finalized: true,
+        logicalTimestamp: 3_000
+      } satisfies LivestreamSessionMapEntry);
+    })
+    .and('the final revision should be rendered once', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(activity3, 1_000)]);
+    });
+});
diff --git a/packages/core/src/reducers/activities/sort/upsert.ts b/packages/core/src/reducers/activities/sort/upsert.ts
index f7bc58a3fa..61e9d616e3 100644
--- a/packages/core/src/reducers/activities/sort/upsert.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.ts
@@ -64,10 +64,14 @@ const INITIAL_STATE = Object.freeze({
 function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activity: Activity): State {
   const activityLocalId = getLocalIdFromActivity(activity);
   const existingActivity = state.activityMap.get(activityLocalId)?.activity;
+  const logicalTimestamp = getLogicalTimestamp(activity, ponyfill);
+  const activityLivestreamingMetadata = getActivityLivestreamingMetadata(activity);
 
   // An update can leave, join, or move between HowTo groupings.
   // Remove the previous revision first, otherwise it stays in its previous grouping and is shown twice.
+  // Livestream revisions are excluded: their grouping belongs to the session, deleting one revision would break it.
   if (
+    !activityLivestreamingMetadata &&
     existingActivity &&
     getPartGroupingMetadataMap(existingActivity).get('HowTo')?.groupingId !==
       getPartGroupingMetadataMap(activity).get('HowTo')?.groupingId
@@ -75,9 +79,6 @@ function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activ
     return upsert(ponyfill, deleteActivityByLocalId(state, activityLocalId), activity);
   }
 
-  const logicalTimestamp = getLogicalTimestamp(activity, ponyfill);
-  const activityLivestreamingMetadata = getActivityLivestreamingMetadata(activity);
-
   // #region Streaming fast path
   //
   // For revision 2..N-1 of an existing, non-finalized livestream session without HowTo grouping:

From 1704d37a35746256670c96415be5569779d87868 Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 16:57:37 -0700
Subject: [PATCH 3/6] Add the changelog fragment

---
 .changelog/5967-fix-activity-leaving-part-group.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .changelog/5967-fix-activity-leaving-part-group.md

diff --git a/.changelog/5967-fix-activity-leaving-part-group.md b/.changelog/5967-fix-activity-leaving-part-group.md
new file mode 100644
index 0000000000..95432f5579
--- /dev/null
+++ b/.changelog/5967-fix-activity-leaving-part-group.md
@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed activities updated into, out of, or between part groupings rendered twice, in PR [#5967](https://github.com/microsoft/BotFramework-WebChat/pull/5967), by [@OEvgeny](https://github.com/OEvgeny)

From 44e46d6026545caf5f492ca8f6ceb50d676875cf Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 17:45:37 -0700
Subject: [PATCH 4/6] Replace a re-sent livestream revision instead of adding
 it again

A revision received again with the same ID (e.g. after a reconnect) was
inserted into its livestream session a second time, so it appeared twice in
the sorted activities (and the development build threw "Activities from graph
and Redux are of different size"). The fast path now skips known activities,
and the slow path removes the previous entry before inserting.
---
 .../livestream/resentRevision.entity.html     |  10 ++
 .../resentRevision.entity.html.snap-1.png     | Bin 0 -> 6128 bytes
 .../html2/livestream/resentRevision.html      | 142 ++++++++++++++++++
 .../livestream/resentRevision.html.snap-1.png | Bin 0 -> 6128 bytes
 .../sort/upsert.howToWithLivestream.spec.ts   |  47 ++++++
 .../activities/sort/upsert.livestream.spec.ts |  58 +++++++
 .../src/reducers/activities/sort/upsert.ts    |   7 +-
 7 files changed, 263 insertions(+), 1 deletion(-)
 create mode 100644 __tests__/html2/livestream/resentRevision.entity.html
 create mode 100644 __tests__/html2/livestream/resentRevision.entity.html.snap-1.png
 create mode 100644 __tests__/html2/livestream/resentRevision.html
 create mode 100644 __tests__/html2/livestream/resentRevision.html.snap-1.png

diff --git a/__tests__/html2/livestream/resentRevision.entity.html b/__tests__/html2/livestream/resentRevision.entity.html
new file mode 100644
index 0000000000..65b27bd06c
--- /dev/null
+++ b/__tests__/html2/livestream/resentRevision.entity.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+  <head>
+    <title>resentRevision (entity): redirects to ?streamingFormat=entity</title>
+    <script>
+      location = './resentRevision?streamingFormat=entity';
+    </script>
+  </head>
+  <body></body>
+</html>
diff --git a/__tests__/html2/livestream/resentRevision.entity.html.snap-1.png b/__tests__/html2/livestream/resentRevision.entity.html.snap-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c66fcaefb14454b4988d89f9556cec2ad143504
GIT binary patch
literal 6128
zcmeI0c{rQt*T=PHYC5${+o`3fA6mPnl9t3e9aYs@#%QZrq}JHRlC&a-m@ZTW6>BWf
zmNFewQA>)bY7vR(s$xq+5=Cr@C5YsG{Qq9>`~Ll2{qMf+=ef?kopZjQbJG5BbyWEI
z@Xs<bG73)T&ipAOvnxbKW_R*WyMY<oxSLBdGQY?;ojH9mu7p31eh?VcwZ`6~eDs{+
z;{(SG{db=+OE$Q_*L}ak#aDM=Rp5YsbP65h4UF#pY@m8>_mcy^K9@QDLte$>A9fWO
zoW8?t3wOo(2<J^`6a04mKGx0c`p+Lfe#G)tV4cE}X*z@6I+ba4RwhGDH<=JEbBZk!
z_IlT+JF@@mmHXqM;zK=+-&~-{Mc+Sszmo6H@I4H^XNK=N@&ADu#Hz3hPlXTBiIAwa
z`R4s&#RG+A0dEg^ddIQvIy$G`T>vzZoVfXK^|Pz-Gf!0DiOax0<4BsR#aMKAzj2+l
zzvY-iGGyovg$3CLHFc<)F6w{P$)*|c;H|p2x5mm>Lmt)Pw&%)2S6|85MrYZq71CrW
zVlD{OJnUb-kwi)u4l3|z?pCxi=~(%Yu-LI4A}K*JU|zyb$!eXWG+aCfm-g#u#(#UH
zyO3UKs`14KJ?@qy$jPvn5Xsqzx<amY%=s+FPaZ6Tz8r*oO_t5HSsSiP<QiK6=L(V3
zH1r#3NkzS1t^{Q4AJeUzzsPm8+k8*BaGW@>P9DTAz$Jo$RBMiQd8l9k-I;I$egn9g
znns2t2)99V6q>R{OR09&w-WkaWIz?ImtLt*mhKKF@*p|*MeJe%dhNMV;#b+~I?AT(
zk)`CnTE^E>?Zkd(8<{wybe|qxD<9EUCD~rYWl2~b_<f-ErBJto5djS({pM(AsVg3h
z>clor584bStu<PVgp`LrBL~k`gBtpD;M=pFWlMMTYhHXf4`U#pHe=F<ayABzl6A^@
z2hFr)tm%tyaYClGps&|XvJA`WqjbzYYxBi$^T?>_QZ&N?n$+xQGwbfvyqpU2NRSB2
zq*Zp?h8H9>xCES@y$yqteBx(8HketDvdz1oL^d5VNWY!xktZCqvvVW;NJH^@LaR#6
zi$qO(vf|$8>M1#qR%;M{H8X=7x0RNuRYqmoe1y;kZ+DY=tbpUO5sS3S?*BarFn2Yo
zV|D0icx}6i1uIcF=ez#0T~{e->9(C9J4+r8Hu>zAs+oV6?xDbX9d}7Or6ujF_q)Pq
z51P8Eim~5ux=Wrut4(#-dCnFhr)4z{c+HXUy3)_Z>;A)6BU{-i$MUcE*LAENc8NFk
zyyACP3H!~yJdIVE&81i7fiQxcGVv%&5*z0{(PSc~>X((=BxKLrOXy#@GqvN2%e`9C
zhJp^01fHwa{7P*UHat@ac!%wVAU=7Tq~aZY+MKf9K5bK;R*E?SKQ=n#K@#LTBlw+C
zNmP=sxbeOG;0Z7DItT+gbx$|*oOh*dw?*g109-t&vY5cynpn<6i}?sU^{B9P5G9Tz
ztSpY~pFm2tSaw;M2_b3yu}X(Q!uV-9&D?pgLtl6ENLcmQk=RGo&t4iGqGcq4x^qfy
zd~iw|d7OT{Xw>WZmv-JM6`vdKgmtQ05|{=VB~+M1C5(<95f=7V81B9NI(J)pi^@cl
zVfziM#uk&-X&wV5FjNm-jR@&iB=$~MBf)X6_v&*r^w+cEH~wXbc@{vB$M{YHE|HjT
zI-Lyb+5kLM`aUaZ<zSiU49QwaopP6BqI6DA@U%S~^L~tYDVHlA#7Ts0tnK6Jx$1*)
zJ&@pmqEkipJSR49%<p`;0N?y@W{sh&YYbU*zkHJ<o^iv)BV*}iy%j%=0%75X+x$qa
zHdw_`FZhCs?g`#IYHb6H+Et&drFw49N8xDOUhdRC@|S?&mioj}%Kr7-nZ1r{FBQy(
zzdE_a{~6i2`MJ*3(banS%~PdOGz*KupNHpr1rzyf=I*l@QHfLP%s+ABDJ?`u&bS~z
zYil?{sV{}3me2Qrl`xjokl?)16YAe~QbtQV*A&*#e^9aPd=_Qp35cs&+!4M$jvlNe
zdQ<?}XstdA8$mKp7@4UmqpS{H)AwcC3q%?dJKoISU><TjX#a@+fH|6qNMN8yId|!d
zrAd`e(IdbQpH`79i>moOGwzfwJhoxUkPqZ3D8E`w6zI-csk8`EqUvx1m;96xhQBSm
z+?=h3O!mcTCoJj}M-ajgmyTWmGV~~rb4#`{;y!%gk@ePI?zMBffuJk4SA-o!SNeyJ
zp((;rj$V3ptiGjFv~Av_vHQl)3d?`rW9XHkRyh!}D+!48DjM@Z!>pjMJx#5Z8!mi0
z-@>w;gH^}G1?mub17GFs|6}55&EuN;@{@uC)wRtd!1mv={nWH84~GuDoO@<9Ndhad
z`^+Ha13t0LAkm3YY$n}f@Uq}JA6Xpvaz;ebJ}Epd`zc~>ighku!LnO0b|vKZW<I{7
zb8CDt7)NPD^d$!+S~>JBLki4OlpsTzI3ufW<!cdUlIX&sfxl0dPs+cAd{cG7g9N`b
zn^Kex_T$%t%%_9-^=>_i<z&nCF;rvlhbDG+NxzMltz@^@E(FX3Q?J;R4k!v4XbS42
zRzu4){(AfMxw=k?$m1!M!=+2CDWx988nY-}t61fL#9Ph0qHtbvb_Fl?$OAM&we}6?
z5Y(&r@4G6#ae`}Qqh2lK?9(BZc?(&3&G~QqRU-oxs(2gxB~kkqjDVU!YdbMXI;Fsd
z0!jjoq`S7glde|7w~g9jnpdexw0g^c5&Ws1b^3CI|MBCUVgW44$-LoORL7}u=9q8T
z(<eNEd`@R#tIfnEaI0!0=M~AJ)Y|2NEK;Ib2}7D_rYNb!1im9x2EzMO)zHo)iRxmB
z&_Lg|5evi|`;aceZ6{kv0r}zd*_CxhqMLtIU!3;H@H`iYV;soTo4AEnQ7$@)vLr*w
z`a|DxEYMd%J-8TfSf5JfBGtmy+CKlU#Ad=Oky<D3nyNBT;>tMR1KI=<>tEjDLUC}+
zU|~wNk(xK>VK#)bY$FB25%O+8`Gkhqo^Fs0MY1{9yH1ahAWvMov4^QVEjXs;fcSOk
zU(b$NKptN<vYf0oXsM$fEsOjo%v~vlA5N#Nm#4YE3h^(R0!-m13GPmr9k2tu5aMP9
zNhq|}@%qZ7G_{8?VtQI2&4b>*ot;t3nTFaGA&3%<anqa`o=&=qj2v;N7x3k`NQ5=m
z1abB+qDP^)kL|&f>UWa6&lejFo=}|p4=c{~UCJoYvmbVmke#6q%H2P-bPVID=Z3@U
z@xsrVK!sM5eNW?p$qlFMf(XvPaF&YaOmeh{vJSy-Q~l=uv$Y|LZ2)`Qs|9|uU2Q_@
zJlHiGcUh<LkQzl1f`TD=^kY?B7}B!S$BQ|*Ge)3ndv6A)(w3i{mB=}PGE=RTM>W_K
zL77x;7QPB>;^t3yjn9G96EGBdGJfG%Nujf3=s18gCKIAJ`c?X{w|!p2J?c^79t%p$
zf?FQer0V(<?RYnyK7InD5coVN+?bqAyF~VG;O1Y;WX-LdL>QN+d3;LTH<b=Tm2eJ|
zw4<2ONft?glx=owrUlV}`jGeawi09IT{L1Sk&x@D)*0e!T=044;Od#qHxQ74GhZXt
z5s!^MxZR>ylinPAC7Y8TSul;D7chB&9Fx@GiBQ&c?DNj0{yOsMOMlQkXTRVHv#0%c
zyfej(+fVQ%Re@TJ;DTH9m{7>Kfo~RwsqUt<h$1x^H|&-CrQv|A0qzHlP>3JV7&>!3
z3|yr8C@^g5W0_<{g!lkn7zV@$Y;Pv-v_NuR<X)p)qSw^dwD9d<c*M%dqCyvE9f$&~
zs4$t{l)}7kU0g%Oi@@)Tw;@VL+;p0e#|%)$FcHFmTdTGw%Zt%I?xjtXGPo7aHM}uX
zqPj~v854auG}uD;61^t-#w*7#f~0NVEI-sxT5%pT!fu4g1is1syalKd#0@$|Ea-E1
zrcr`Sv%K9F0mJM|DQbL3kAgPrpZ@dpC#;_O8OgwDq@a|nSX8Y|{vk)xHZ?aQcFK+W
z`n2BK!H3Sj1jn0vQ9OIlQ=pH-Ffvew37XIXcj3hyx_oZsl8+Jb*ND-?_=<tXAlZS1
zT(vF}UvtV1AeO_Z=v-O`rq&wlc?>=5mrC6V%Z!87Yrzln3j^iBn32`UzLtE=(9f4V
zU9vu;YfM1ga`(GrzVHgz2u{`dhvsgfLO|7`k2ltmR~}Fjw?<ivLpc@ZR_u`eq7oId
zh;V`LC5r(eyW&)PgUq$V^`hWw9Ou@+NMpn=-KT15UeGT|m$Pv6RAM%j{5fP&Dc%Lk
zE6=nvI`}8qHP?`Xha=?+#W`KfJxH}<ZnhhVkb)0_ScDl^U@2be7WQyOX8v8|bi2M>
z`xQ=EOp&h|mh%rGfFDhukH@Yt5z{*7dVc&UXxs>mWGEtan7(V9@CDqB0EraPp@a^3
z9FhyR;6dTC(t~%Ve4|A53_NF%-#c-A#I(=jP^&((uqu21|J-+rRgu;v0VIPG2YE*?
z5(b7r3dLv9%eYHB^nv2hnUec*V{;XU8@EUFdA&Y&WUm|Dw)pSbcmp0#S19`qaQd*5
z%ZSz;=6Y{!HHC+m1JDhVG@bl95l%{a5V-@^;dLEDz6ta0Glc<}YEqkvUu^@j#{u9t
zq7}b6Q&k7>IJI||oW==YeRkFX60+aW@d$<kP+t6d2NlgE5xa^MKkJ1ky$Kkrp={2|
zY2J9p(lcopLmEG8om@KV3CFII5*9GMnrIF5SWNGc1imP$ffYBEA$KJ1YnnbOPC(U%
z$Gkm+5!_a?6#;eG;jpIli3B)MopqP#P2i;4Kp|(2OZ-XsVQBFbbn>2V^F;g{f3z`p
z;5?Xc8_;?Q0P|y*>Cys#kCwZYedE~p(}4KakH?PAr>I8)@oQraz|5t~UdPO?0z2K|
z3qZJTvastm648{!@b%j#4dBS}n_o=p-yGPX#mFkC;d{~Ge%XC*UTl|@y;XsWUwm|J
z;}9+oQc7b-Lhl~B+}h|EJiT)aRKU!W0$+d|>d3qzK%H%UhW*n`k%%I~Ag{YZU&`wO
zAiFDmuC`!H_?&jUEn<UPFzA_){3BxItVY|y%Wwu*(Te}PIEsP+c7W~L=X;_+t_s|p
zaaZ}Ofo|@v+AWY8)dg=rVF47W6c?jPXrNB<>wTcHz#JFw0cu9cdk)p{)$W@rx|wuu
zF(5`-k%(ZwR$GGETaolrChnS}ZQj1)QP{a_Xl77>kYNSVH!R1Pm(VJp-KkHzqumZK
z7wiqMZMv*yl``60^3!vfaR(?e?7`_Xid)kqDA&lk`kupNh(`snQ^Td?MhQ-`L5|s)
zZ<%hm5bTUf00MeoSUcdpgR<ArG-3gZo9)aYx>?Rtyg!o$-e>j6Z+rF2;2aMh4EW1{
z{JCHYutSl$?)AT4rhDYky(?7!ORSv&wK41S<!h$sNZ@sdoz8{=Ht=+D3*_m_{X0Yr
z5OitUAmFUA1E;=dJWJ-VfNB;s8rk+2C2#?h3;P5BV_+F}jV$Ol&Pib}1F-SoB<;bd
zSMrT8Zk{J29Jug)kYHC>5=Z0z(Epy70_}RK^l$WIBVe#+N2FzCo<lD`qF)h312ZyC
N4z6dO{eJz{e*u<bQh5LX

literal 0
HcmV?d00001

diff --git a/__tests__/html2/livestream/resentRevision.html b/__tests__/html2/livestream/resentRevision.html
new file mode 100644
index 0000000000..e6433b2535
--- /dev/null
+++ b/__tests__/html2/livestream/resentRevision.html
@@ -0,0 +1,142 @@
+<!doctype html>
+<html lang="en-US">
+  <head>
+    <link href="/assets/index.css" rel="stylesheet" type="text/css" />
+    <link href="./css/pauseAnimation.css" rel="stylesheet" type="text/css" />
+    <script crossorigin="anonymous" src="https://unpkg.com/react@16.8.6/umd/react.production.min.js"></script>
+    <script crossorigin="anonymous" src="https://unpkg.com/react-dom@16.8.6/umd/react-dom.production.min.js"></script>
+    <script crossorigin="anonymous" src="/test-harness.js"></script>
+    <script crossorigin="anonymous" src="/test-page-object.js"></script>
+    <script crossorigin="anonymous" src="/__dist__/webchat-es5.js"></script>
+  </head>
+  <body>
+    <main id="webchat"></main>
+    <script type="importmap">
+      {
+        "imports": {
+          "@testduet/wait-for": "https://esm.sh/@testduet/wait-for"
+        }
+      }
+    </script>
+    <script type="module">
+      import { waitFor } from '@testduet/wait-for';
+
+      const streamingFormat = new URL(window.location.href).searchParams.get('streamingFormat') ?? 'channelData'; // can be entity or channelData
+
+      function addLivestreamingMetadata(activity, livestreamingMetadata) {
+        return streamingFormat === 'entity'
+          ? {
+              ...activity,
+              entities: [...(activity.entities ?? []), { ...livestreamingMetadata, type: 'streaminfo' }]
+            }
+          : {
+              ...activity,
+              channelData: { ...activity.channelData, ...livestreamingMetadata }
+            };
+      }
+
+      run(async function () {
+        const {
+          React: { createElement },
+          ReactDOM: { render },
+          WebChat: {
+            Components: { BasicWebChat, Composer },
+            decorator: { WebChatDecorator },
+            hooks: { useActivityKeys, useGetActivitiesByKey }
+          }
+        } = window; // Imports in UMD fashion.
+
+        const { directLine, store } = testHelpers.createDirectLineEmulator();
+        let currentActivityKeysWithId = [];
+
+        const Monitor = () => {
+          const [activityKeys] = useActivityKeys();
+          const getActivitiesByKey = useGetActivitiesByKey();
+
+          currentActivityKeysWithId = Object.freeze(
+            activityKeys.map(key => [key, getActivitiesByKey(key).map(({ id }) => id)])
+          );
+
+          return false;
+        };
+
+        render(
+          createElement(
+            WebChatDecorator,
+            {},
+            createElement(
+              Composer,
+              {
+                directLine,
+                store,
+                styleOptions: { hideSendBox: true }
+              },
+              createElement(BasicWebChat),
+              createElement(Monitor)
+            )
+          ),
+          document.getElementById('webchat')
+        );
+
+        await pageConditions.uiConnected();
+
+        // GIVEN: Bot is streaming a message with 2 revisions.
+        const firstRevision = addLivestreamingMetadata(
+          {
+            from: { id: 'u-00001', name: 'Bot', role: 'bot' },
+            id: 't-00001',
+            text: 'A quick',
+            timestamp: 1,
+            type: 'typing'
+          },
+          { streamSequence: 1, streamType: 'streaming' }
+        );
+
+        const secondRevision = addLivestreamingMetadata(
+          {
+            from: { id: 'u-00001', name: 'Bot', role: 'bot' },
+            id: 't-00002',
+            text: 'A quick brown fox',
+            timestamp: 2,
+            type: 'typing'
+          },
+          { streamId: 't-00001', streamSequence: 2, streamType: 'streaming' }
+        );
+
+        await directLine.emulateIncomingActivity(firstRevision);
+        await directLine.emulateIncomingActivity(secondRevision);
+
+        // WHEN: The second revision is received again (same ID), e.g. after a reconnect.
+        await directLine.emulateIncomingActivity(secondRevision);
+
+        // WHEN: Bot continues with the third revision.
+        // The store processes activities in order, so the re-sent revision is processed once this one appears.
+        await directLine.emulateIncomingActivity(
+          addLivestreamingMetadata(
+            {
+              from: { id: 'u-00001', name: 'Bot', role: 'bot' },
+              id: 't-00003',
+              text: 'A quick brown fox jumped over',
+              timestamp: 3,
+              type: 'typing'
+            },
+            { streamId: 't-00001', streamSequence: 3, streamType: 'streaming' }
+          )
+        );
+
+        // THEN: Should keep each revision once in the store.
+        expect(store.getState().activities.map(({ id }) => id)).toEqual(['t-00001', 't-00002', 't-00003']);
+
+        // THEN: Should have 1 activity key with each revision once.
+        await waitFor(() =>
+          expect(currentActivityKeysWithId).toEqual([[expect.any(String), ['t-00001', 't-00002', 't-00003']]])
+        );
+
+        // THEN: Should display 1 message with the third revision.
+        await pageConditions.numActivitiesShown(1);
+        expect(pageElements.activityContents()[0]).toHaveProperty('textContent', 'A quick brown fox jumped over');
+        await host.snapshot('local');
+      });
+    </script>
+  </body>
+</html>
diff --git a/__tests__/html2/livestream/resentRevision.html.snap-1.png b/__tests__/html2/livestream/resentRevision.html.snap-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c66fcaefb14454b4988d89f9556cec2ad143504
GIT binary patch
literal 6128
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
N4z6dO{eJz{e*u<bQh5LX

literal 0
HcmV?d00001

diff --git a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
index 682f33afe5..f21f0330e5 100644
--- a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
@@ -513,3 +513,50 @@ scenario('re-sending an older revision of a finalized livestream in a grouping w
       expect(state.sortedActivities).toEqual([activityToExpectation(activity3, 1_000)]);
     });
 });
+
+scenario('re-sending a revision of an ongoing livestream in a grouping', bdd => {
+  const activity1 = buildActivity(
+    {
+      channelData: { streamSequence: 1, streamType: 'streaming' },
+      id: 'a-00001',
+      text: 'A quick',
+      timestamp: new Date(1_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'A quick brown fox',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  bdd
+    .given('an ongoing livestream session with 2 revisions in a part grouping', () =>
+      upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2)
+    )
+    // Same ID, e.g. delivered again after a reconnect.
+    .when('the second revision is re-sent', state => upsert({ Date }, state, activity2))
+    .then('should keep 2 revisions in the livestream session', (_, state) => {
+      expect(state.livestreamSessionMap.get('a-00001' as LivestreamSessionId)).toEqual({
+        activities: [
+          expect.objectContaining({ activityLocalId: '_:a-00001' as LocalId }),
+          expect.objectContaining({ activityLocalId: '_:a-00002' as LocalId })
+        ],
+        finalized: false,
+        logicalTimestamp: 1_000
+      } satisfies LivestreamSessionMapEntry);
+    })
+    .and('`sortedActivities` should have each revision once', (_, state) => {
+      expect(state.sortedActivities).toEqual([
+        activityToExpectation(activity1, 1_000),
+        activityToExpectation(activity2, 2_000)
+      ]);
+    });
+});
diff --git a/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts b/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
index 9d9cc9524b..18a57b9cef 100644
--- a/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
@@ -416,3 +416,61 @@ scenario('upserting a livestream session', bdd => {
       expect(state.sortedActivities).toEqual([activityToExpectation(activity4, 1_000)]);
     });
 });
+
+scenario('re-sending a revision of an ongoing livestream session', bdd => {
+  const activity1 = buildActivity({
+    channelData: { streamSequence: 1, streamType: 'streaming' },
+    id: 'a-00001',
+    text: 'A quick',
+    timestamp: new Date(1_000).toISOString(),
+    type: 'typing'
+  });
+
+  const activity2 = buildActivity({
+    channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+    id: 'a-00002',
+    text: 'A quick brown fox',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'typing'
+  });
+
+  bdd
+    .given('an ongoing livestream session with 2 revisions', () =>
+      upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2)
+    )
+    // Same ID, e.g. delivered again after a reconnect.
+    .when('the second revision is re-sent', state => upsert({ Date }, state, activity2))
+    .then('should keep 2 revisions in the livestream session', (_, state) => {
+      expect(state.livestreamSessionMap).toEqual(
+        new Map<LivestreamSessionId, LivestreamSessionMapEntry>([
+          [
+            'a-00001' as LivestreamSessionId,
+            {
+              activities: [
+                {
+                  activityLocalId: '_:a-00001' as LocalId,
+                  logicalTimestamp: 1_000,
+                  sequenceNumber: 1,
+                  type: 'activity'
+                },
+                {
+                  activityLocalId: '_:a-00002' as LocalId,
+                  logicalTimestamp: 2_000,
+                  sequenceNumber: 2,
+                  type: 'activity'
+                }
+              ],
+              finalized: false,
+              logicalTimestamp: 1_000
+            }
+          ]
+        ])
+      );
+    })
+    .and('`sortedActivities` should have each revision once', (_, state) => {
+      expect(state.sortedActivities).toEqual([
+        activityToExpectation(activity1, 1_000),
+        activityToExpectation(activity2, 2_000)
+      ]);
+    });
+});
diff --git a/packages/core/src/reducers/activities/sort/upsert.ts b/packages/core/src/reducers/activities/sort/upsert.ts
index 61e9d616e3..9d4d43f505 100644
--- a/packages/core/src/reducers/activities/sort/upsert.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.ts
@@ -91,9 +91,11 @@ function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activ
     const existingSession = state.livestreamSessionMap.get(sessionId);
     const finalized = activityLivestreamingMetadata.type === 'final activity';
 
+    // A re-sent revision (same local ID) takes the slow path, which replaces its previous entry.
     if (
       existingSession &&
       !existingSession.finalized &&
+      !existingActivity &&
       !finalized &&
       !getPartGroupingMetadataMap(activity).has('HowTo')
     ) {
@@ -292,7 +294,10 @@ function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activ
     const nextLivestreamSessionMapEntry = {
       activities: Object.freeze(
         insertSorted<LivestreamSessionMapEntryActivityEntry>(
-          livestreamSessionMapEntry ? livestreamSessionMapEntry.activities : [],
+          // Remove the previous entry of a re-sent revision, otherwise it is shown twice.
+          livestreamSessionMapEntry
+            ? livestreamSessionMapEntry.activities.filter(entry => entry.activityLocalId !== activityLocalId)
+            : [],
           Object.freeze({
             activityLocalId,
             logicalTimestamp,

From 8a476a894b98ff2dc66fc28dd9e5b633ae4c8bb1 Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 17:59:58 -0700
Subject: [PATCH 5/6] Assert re-sent livestream revisions carry the changed
 text, and clarify fast path comments

---
 .../sort/upsert.howToWithLivestream.spec.ts   | 98 ++++++++++++++++++-
 .../activities/sort/upsert.livestream.spec.ts | 83 +++++++++++++++-
 .../src/reducers/activities/sort/upsert.ts    |  5 +-
 3 files changed, 174 insertions(+), 12 deletions(-)

diff --git a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
index f21f0330e5..e5616eacf8 100644
--- a/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.howToWithLivestream.spec.ts
@@ -537,13 +537,32 @@ scenario('re-sending a revision of an ongoing livestream in a grouping', bdd =>
     { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
   );
 
+  // Same ID with a changed text, e.g. delivered again after a reconnect.
+  const activity2Changed = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'a-00002:CHANGED',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
   bdd
     .given('an ongoing livestream session with 2 revisions in a part grouping', () =>
       upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2)
     )
-    // Same ID, e.g. delivered again after a reconnect.
-    .when('the second revision is re-sent', state => upsert({ Date }, state, activity2))
-    .then('should keep 2 revisions in the livestream session', (_, state) => {
+    .when('the second revision is re-sent with a changed text', state => upsert({ Date }, state, activity2Changed))
+    .then('`activityMap` should have the changed revision', (_, state) => {
+      expect(state.activityMap.get('_:a-00002' as LocalId)).toEqual({
+        activity: activityToExpectation(activity2Changed),
+        activityLocalId: '_:a-00002' as LocalId,
+        logicalTimestamp: 2_000,
+        type: 'activity'
+      } satisfies ActivityMapEntry);
+    })
+    .and('should keep 2 revisions in the livestream session', (_, state) => {
       expect(state.livestreamSessionMap.get('a-00001' as LivestreamSessionId)).toEqual({
         activities: [
           expect.objectContaining({ activityLocalId: '_:a-00001' as LocalId }),
@@ -553,10 +572,79 @@ scenario('re-sending a revision of an ongoing livestream in a grouping', bdd =>
         logicalTimestamp: 1_000
       } satisfies LivestreamSessionMapEntry);
     })
-    .and('`sortedActivities` should have each revision once', (_, state) => {
+    .and('`sortedActivities` should have the changed revision once', (_, state) => {
       expect(state.sortedActivities).toEqual([
         activityToExpectation(activity1, 1_000),
-        activityToExpectation(activity2, 2_000)
+        activityToExpectation(activity2Changed, 2_000)
+      ]);
+    });
+});
+
+scenario('re-sending a middle revision of an ongoing livestream in a grouping', bdd => {
+  const activity1 = buildActivity(
+    {
+      channelData: { streamSequence: 1, streamType: 'streaming' },
+      id: 'a-00001',
+      text: 'A quick',
+      timestamp: new Date(1_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'A quick brown fox',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity3 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 3, streamType: 'streaming' },
+      id: 'a-00003',
+      text: 'A quick brown fox jumped',
+      timestamp: new Date(3_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  // Same ID as the middle revision with a changed text, e.g. delivered again after a reconnect.
+  const activity2Changed = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'a-00002:CHANGED',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  bdd
+    .given('an ongoing livestream session with 3 revisions in a part grouping', () =>
+      upsert({ Date }, upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2), activity3)
+    )
+    .when('the second revision is re-sent with a changed text', state => upsert({ Date }, state, activity2Changed))
+    .then('`activityMap` should have the changed revision', (_, state) => {
+      expect(state.activityMap.get('_:a-00002' as LocalId)).toEqual({
+        activity: activityToExpectation(activity2Changed),
+        activityLocalId: '_:a-00002' as LocalId,
+        logicalTimestamp: 2_000,
+        type: 'activity'
+      } satisfies ActivityMapEntry);
+    })
+    .and('`sortedActivities` should have the changed revision once, before the third revision', (_, state) => {
+      expect(state.sortedActivities).toEqual([
+        // Positions are not asserted: the slow path may resequence them, only the order matters.
+        activityToExpectation(activity1),
+        activityToExpectation(activity2Changed),
+        activityToExpectation(activity3)
       ]);
     });
 });
diff --git a/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts b/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
index 18a57b9cef..edb69ec4d0 100644
--- a/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.livestream.spec.ts
@@ -434,13 +434,29 @@ scenario('re-sending a revision of an ongoing livestream session', bdd => {
     type: 'typing'
   });
 
+  // Same ID with a changed text, e.g. delivered again after a reconnect.
+  const activity2Changed = buildActivity({
+    channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+    id: 'a-00002',
+    text: 'a-00002:CHANGED',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'typing'
+  });
+
   bdd
     .given('an ongoing livestream session with 2 revisions', () =>
       upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2)
     )
-    // Same ID, e.g. delivered again after a reconnect.
-    .when('the second revision is re-sent', state => upsert({ Date }, state, activity2))
-    .then('should keep 2 revisions in the livestream session', (_, state) => {
+    .when('the second revision is re-sent with a changed text', state => upsert({ Date }, state, activity2Changed))
+    .then('`activityMap` should have the changed revision', (_, state) => {
+      expect(state.activityMap.get('_:a-00002' as LocalId)).toEqual({
+        activity: activityToExpectation(activity2Changed),
+        activityLocalId: '_:a-00002' as LocalId,
+        logicalTimestamp: 2_000,
+        type: 'activity'
+      } satisfies ActivityMapEntry);
+    })
+    .and('should keep 2 revisions in the livestream session', (_, state) => {
       expect(state.livestreamSessionMap).toEqual(
         new Map<LivestreamSessionId, LivestreamSessionMapEntry>([
           [
@@ -467,10 +483,67 @@ scenario('re-sending a revision of an ongoing livestream session', bdd => {
         ])
       );
     })
-    .and('`sortedActivities` should have each revision once', (_, state) => {
+    .and('`sortedActivities` should have the changed revision once', (_, state) => {
       expect(state.sortedActivities).toEqual([
         activityToExpectation(activity1, 1_000),
-        activityToExpectation(activity2, 2_000)
+        activityToExpectation(activity2Changed, 2_000)
+      ]);
+    });
+});
+
+scenario('re-sending a middle revision of an ongoing livestream session', bdd => {
+  const activity1 = buildActivity({
+    channelData: { streamSequence: 1, streamType: 'streaming' },
+    id: 'a-00001',
+    text: 'A quick',
+    timestamp: new Date(1_000).toISOString(),
+    type: 'typing'
+  });
+
+  const activity2 = buildActivity({
+    channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+    id: 'a-00002',
+    text: 'A quick brown fox',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'typing'
+  });
+
+  const activity3 = buildActivity({
+    channelData: { streamId: 'a-00001', streamSequence: 3, streamType: 'streaming' },
+    id: 'a-00003',
+    text: 'A quick brown fox jumped',
+    timestamp: new Date(3_000).toISOString(),
+    type: 'typing'
+  });
+
+  // Same ID as the middle revision with a changed text, e.g. delivered again after a reconnect.
+  const activity2Changed = buildActivity({
+    channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+    id: 'a-00002',
+    text: 'a-00002:CHANGED',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'typing'
+  });
+
+  bdd
+    .given('an ongoing livestream session with 3 revisions', () =>
+      upsert({ Date }, upsert({ Date }, upsert({ Date }, INITIAL_STATE, activity1), activity2), activity3)
+    )
+    .when('the second revision is re-sent with a changed text', state => upsert({ Date }, state, activity2Changed))
+    .then('`activityMap` should have the changed revision', (_, state) => {
+      expect(state.activityMap.get('_:a-00002' as LocalId)).toEqual({
+        activity: activityToExpectation(activity2Changed),
+        activityLocalId: '_:a-00002' as LocalId,
+        logicalTimestamp: 2_000,
+        type: 'activity'
+      } satisfies ActivityMapEntry);
+    })
+    .and('`sortedActivities` should have the changed revision once, before the third revision', (_, state) => {
+      expect(state.sortedActivities).toEqual([
+        // Positions are not asserted: the slow path may resequence them, only the order matters.
+        activityToExpectation(activity1),
+        activityToExpectation(activity2Changed),
+        activityToExpectation(activity3)
       ]);
     });
 });
diff --git a/packages/core/src/reducers/activities/sort/upsert.ts b/packages/core/src/reducers/activities/sort/upsert.ts
index 9d4d43f505..a424ffe771 100644
--- a/packages/core/src/reducers/activities/sort/upsert.ts
+++ b/packages/core/src/reducers/activities/sort/upsert.ts
@@ -81,7 +81,7 @@ function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activ
 
   // #region Streaming fast path
   //
-  // For revision 2..N-1 of an existing, non-finalized livestream session without HowTo grouping:
+  // For a new revision 2..N-1 of an existing, non-finalized livestream session without HowTo grouping:
   // avoid the heavier full rebuild path, including sortedChatHistoryList recomputation,
   // computeSortedActivities, and full position resequencing. This is still not constant-time:
   // the fast path continues to clone Maps and update sortedActivities, but it avoids the
@@ -233,7 +233,8 @@ function upsert(ponyfill: Pick<GlobalScopePonyfill, 'Date'>, state: State, activ
 
   // #endregion
 
-  // Slow path: full recalculation for non-streaming, first/final revisions, reorders, or HowTo grouping.
+  // Slow path: full recalculation for non-streaming, first/final revisions, re-sent revisions, reorders,
+  // or HowTo grouping.
   const nextActivityIdToLocalIdMap = new Map(state.activityIdToLocalIdMap);
   const nextActivityMap = new Map(state.activityMap);
   const nextClientActivityIdToLocalIdMap = new Map(state.clientActivityIdToLocalIdMap);

From 2d0c4ec83c3bb1686f9052a85aade81a35da2ead Mon Sep 17 00:00:00 2001
From: Eugene Olonov <eugeneolonov@microsoft.com>
Date: Thu, 22 Oct 2026 18:04:32 -0700
Subject: [PATCH 6/6] Add the changelog fragment

---
 .changelog/5969-fix-livestream-resent-revision.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .changelog/5969-fix-livestream-resent-revision.md

diff --git a/.changelog/5969-fix-livestream-resent-revision.md b/.changelog/5969-fix-livestream-resent-revision.md
new file mode 100644
index 0000000000..5e024a99ed
--- /dev/null
+++ b/.changelog/5969-fix-livestream-resent-revision.md
@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed livestream revisions re-sent with the same ID shown twice, in PR [#5969](https://github.com/microsoft/BotFramework-WebChat/pull/5969), by [@OEvgeny](https://github.com/OEvgeny)