@aleph-alpha/chat-kit 5.5.0 → 5.7.0

package/dist/{useMessageHandler-N50Yj-NU.js → useMessageHandler-Tellov3w.js}

@@ -3,47 +3,98 @@ import { reactive, ref, computed, readonly } from "vue";
 function createEmptyTree() {
   return { nodes: {}, rootId: null };
 }
-function getLinearPath(tree) {
-  const { nodes, rootId } = tree;
-  if (!rootId || !nodes[rootId]) return [];
+function toBaseMessage(nodes, node) {
+  const base = {
+    id: node.id,
+    role: node.role,
+    content: node.content,
+    createdAt: node.createdAt,
+    status: node.status,
+    ...node.metadata !== void 0 ? { metadata: node.metadata } : {}
+  };
+  if (node.parentId !== null) {
+    const parent = nodes[node.parentId];
+    if (parent && parent.childrenIds.length > 1) {
+      base.siblingIds = [...parent.childrenIds];
+      base.siblingIndex = parent.childrenIds.indexOf(node.id);
+    }
+  }
+  return base;
+}
+function isActiveComparison(nodes, node) {
+  if (!node.comparing || node.childrenIds.length < 2) return false;
+  const winnerId = node.comparisonWinnerId;
+  if (winnerId == null) return true;
+  const winner = nodes[winnerId];
+  return !winner || winner.childrenIds.length === 0;
+}
+function laneWalk(nodes, headId) {
   const path = [];
+  let current = headId;
+  while (current !== null) {
+    const node = nodes[current];
+    if (!node) break;
+    path.push(toBaseMessage(nodes, node));
+    if (node.childrenIds.length === 0) break;
+    current = node.childrenIds[node.activeChildIndex];
+  }
+  return path;
+}
+function projectActivePath(tree) {
+  const { nodes, rootId } = tree;
+  const trunk = [];
+  if (!rootId || !nodes[rootId]) return { trunk, activeComparison: null };
   let current = rootId;
   while (current !== null) {
     const node = nodes[current];
     if (!node) break;
-    const base = {
-      id: node.id,
-      role: node.role,
-      content: node.content,
-      createdAt: node.createdAt,
-      status: node.status,
-      ...node.metadata !== void 0 ? { metadata: node.metadata } : {}
-    };
-    if (node.parentId !== null) {
-      const parent = nodes[node.parentId];
-      if (parent && parent.childrenIds.length > 1) {
-        base.siblingIds = [...parent.childrenIds];
-        base.siblingIndex = parent.childrenIds.indexOf(node.id);
-      }
+    trunk.push(toBaseMessage(nodes, node));
+    if (isActiveComparison(nodes, node)) {
+      const lanes = node.childrenIds.map((branchId) => ({
+        branchId,
+        path: laneWalk(nodes, branchId)
+      }));
+      const winnerBranchId = node.comparisonWinnerId ?? null;
+      return {
+        trunk,
+        activeComparison: {
+          forkParentId: node.id,
+          resolved: winnerBranchId !== null,
+          winnerBranchId,
+          lanes
+        }
+      };
     }
-    path.push(base);
     if (node.childrenIds.length === 0) break;
     current = node.childrenIds[node.activeChildIndex];
   }
-  return path;
+  return { trunk, activeComparison: null };
 }
-function addNode(tree, node) {
+function addNode(tree, node, opts = { activate: true }) {
   tree.nodes[node.id] = node;
   if (node.parentId !== null) {
     const parent = tree.nodes[node.parentId];
     if (parent && !parent.childrenIds.includes(node.id)) {
       parent.childrenIds.push(node.id);
-      parent.activeChildIndex = parent.childrenIds.length - 1;
+      if (opts.activate)
+        parent.activeChildIndex = parent.childrenIds.length - 1;
     }
   } else if (tree.rootId === null) {
     tree.rootId = node.id;
   }
 }
+function markComparison(tree, parentId) {
+  const parent = tree.nodes[parentId];
+  if (parent) parent.comparing = true;
+}
+function voteComparison(tree, parentId, winnerBranchId) {
+  const parent = tree.nodes[parentId];
+  if (!parent) return;
+  const idx = parent.childrenIds.indexOf(winnerBranchId);
+  if (idx === -1) return;
+  parent.comparisonWinnerId = winnerBranchId;
+  parent.activeChildIndex = idx;
+}
 function updateNode(tree, id, updates) {
   const node = tree.nodes[id];
   if (!node) return;
@@ -81,12 +132,18 @@ function deleteSubtrees(tree, ids) {
     delete tree.nodes[currentId];
   }
 }
-function cutBranchAfter(tree, id) {
+function cutBranchAfter(tree, id, keepChildId) {
   const node = tree.nodes[id];
-  if (!node) return;
-  deleteSubtrees(tree, node.childrenIds);
-  node.childrenIds = [];
+  if (!node || !Object.prototype.hasOwnProperty.call(tree.nodes, id)) return;
+  const kept = keepChildId !== void 0 && node.childrenIds.includes(keepChildId) ? keepChildId : null;
+  deleteSubtrees(
+    tree,
+    kept === null ? node.childrenIds : node.childrenIds.filter((childId) => childId !== kept)
+  );
+  node.childrenIds = kept === null ? [] : [kept];
   node.activeChildIndex = 0;
+  delete node.comparing;
+  delete node.comparisonWinnerId;
 }
 function cutBranchAt(tree, id) {
   const node = tree.nodes[id];
@@ -106,6 +163,14 @@ function cutBranchAt(tree, id) {
   if (parent.activeChildIndex >= parent.childrenIds.length) {
     parent.activeChildIndex = Math.max(0, parent.childrenIds.length - 1);
   }
+  if (parent.comparing) {
+    if (parent.childrenIds.length < 2) {
+      delete parent.comparing;
+      delete parent.comparisonWinnerId;
+    } else if (parent.comparisonWinnerId === id) {
+      delete parent.comparisonWinnerId;
+    }
+  }
 }
 function navigate(tree, targetId) {
   const node = tree.nodes[targetId];
@@ -119,9 +184,14 @@ function navigate(tree, targetId) {
 const useMessageHandler = () => {
   const tree = reactive(createEmptyTree());
   const currentUserMessage = ref("");
-  const messages = computed(() => getLinearPath(tree));
+  const projection = computed(() => projectActivePath(tree));
+  const messages = computed(() => projection.value.trunk);
+  const activeComparison = computed(
+    () => projection.value.activeComparison
+  );
   const currentLeafId = computed(() => {
-    const list = messages.value;
+    if (projection.value.activeComparison) return null;
+    const list = projection.value.trunk;
     return list.length > 0 ? list[list.length - 1].id : null;
   });
   function resolveParentId(parentId) {
@@ -171,6 +241,9 @@ const useMessageHandler = () => {
   function updateMessage(message) {
     const existing = tree.nodes[message.id];
     if (existing) {
+      if (message.comparing && existing.parentId) {
+        markComparison(tree, existing.parentId);
+      }
       updateNode(tree, message.id, {
         content: message.content,
         role: message.role,
@@ -178,9 +251,13 @@ const useMessageHandler = () => {
         ...message.metadata !== void 0 ? { metadata: message.metadata } : {}
       });
     } else {
+      const parentId = resolveParentId(message.parentId);
+      if (message.comparing && parentId) {
+        markComparison(tree, parentId);
+      }
       const node = {
         id: message.id,
-        parentId: resolveParentId(message.parentId),
+        parentId,
         childrenIds: [],
         activeChildIndex: 0,
         role: message.role,
@@ -218,8 +295,8 @@ const useMessageHandler = () => {
   function navigate$1(targetId) {
     navigate(tree, targetId);
   }
-  function cutBranchAfter$1(messageId) {
-    cutBranchAfter(tree, messageId);
+  function cutBranchAfter$1(messageId, keepChildId) {
+    cutBranchAfter(tree, messageId, keepChildId);
   }
   function cutBranchAt$1(messageId) {
     cutBranchAt(tree, messageId);
@@ -227,8 +304,12 @@ const useMessageHandler = () => {
   function getTree() {
     return readonly(tree);
   }
+  function voteComparison$1(parentId, winnerBranchId) {
+    voteComparison(tree, parentId, winnerBranchId);
+  }
   return {
     messages,
+    activeComparison,
     currentUserMessage: readonly(currentUserMessage),
     currentLeafId,
     updateMessage,
@@ -242,6 +323,7 @@ const useMessageHandler = () => {
     navigate: navigate$1,
     cutBranchAfter: cutBranchAfter$1,
     cutBranchAt: cutBranchAt$1,
+    voteComparison: voteComparison$1,
     getTree
   };
 };

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@aleph-alpha/chat-kit",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "description": "Chat kit package for building chat interfaces with Vue",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "style": "./dist/chat-kit.css",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./style.css": "./dist/chat-kit.css",
     "./services": {
       "import": "./dist/services/index.js",
       "types": "./dist/services/index.d.ts"
@@ -107,7 +109,7 @@
     "wait-on": "9.0.3",
     "@aleph-alpha/eslint-config-frontend": "0.7.0",
     "@aleph-alpha/prettier-config-frontend": "2.1.0",
-    "@aleph-alpha/tsconfig-frontend": "0.7.0"
+    "@aleph-alpha/tsconfig-frontend": "0.7.1"
   },
   "scripts": {
     "build": "vite build && vue-tsc --project tsconfig.build.json --declaration --emitDeclarationOnly --outDir dist",

package/src/adapters/arena.spec.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+
+import { responsesToTree, type StoredResponse } from './responses-api';
+
+function arenaResponse(
+  id: string,
+  matchupId: string,
+  slot: 'a' | 'b',
+  modelId: string,
+  answer: string,
+): StoredResponse {
+  return {
+    id,
+    object: 'response',
+    created_at: 1,
+    completed_at: 2,
+    status: 'completed',
+    model: modelId,
+    previous_response_id: null,
+    request_input: [{ role: 'user', content: 'prompt' }],
+    output: [
+      {
+        type: 'message',
+        id: `msg-${id}`,
+        status: 'completed',
+        role: 'assistant',
+        content: [{ type: 'output_text', text: answer }],
+      },
+    ],
+    metadata: {
+      arena: JSON.stringify({
+        matchup_id: matchupId,
+        slot,
+        model_id: modelId,
+        variant: 'king-of-the-hill',
+      }),
+    },
+  } as StoredResponse;
+}
+
+describe('responsesToTree arena collapse', () => {
+  it('folds an unvoted pair into one comparison node with two lanes', () => {
+    const tree = responsesToTree([
+      arenaResponse('respA', 'm1', 'a', 'phoenix-latest', 'A'),
+      arenaResponse('respB', 'm1', 'b', 'kimi-k2.6', 'B'),
+    ]);
+
+    // Single root user node, marked comparing, with two assistant children.
+    const root = tree.nodes[tree.rootId!]!;
+    expect(root.role).toBe('user');
+    expect(root.comparing).toBe(true);
+    expect(root.comparisonWinnerId).toBeUndefined();
+    expect(root.childrenIds).toHaveLength(2);
+
+    const children = root.childrenIds.map((id) => tree.nodes[id]!);
+    expect(children.every((c) => c.role === 'assistant')).toBe(true);
+    // Model id stamped for lane labels; ordered slot a then b.
+    const slots = children.map(
+      (c) => (c.metadata.arena as { slot?: string }).slot,
+    );
+    expect(slots).toEqual(['a', 'b']);
+  });
+
+  it('marks the recorded winner when arenaWinners is supplied', () => {
+    const tree = responsesToTree(
+      [
+        arenaResponse('respA', 'm1', 'a', 'phoenix-latest', 'A'),
+        arenaResponse('respB', 'm1', 'b', 'kimi-k2.6', 'B'),
+      ],
+      { arenaWinners: { m1: 'respB' } },
+    );
+    const root = tree.nodes[tree.rootId!]!;
+    // Winner is respB's assistant node (its wire message id).
+    expect(root.comparisonWinnerId).toBe('msg-respB');
+    expect(root.childrenIds[root.activeChildIndex]).toBe('msg-respB');
+  });
+
+  it('leaves a single surviving response as an ordinary linear turn', () => {
+    // 7-Discard: after continue, the BE dropped the loser — one response left.
+    const tree = responsesToTree([
+      arenaResponse('respA', 'm1', 'a', 'phoenix-latest', 'A'),
+    ]);
+    const root = tree.nodes[tree.rootId!]!;
+    expect(root.comparing).toBeUndefined();
+  });
+});

package/src/adapters/responses-api.ts

@@ -599,6 +599,10 @@ interface TreeBuildState {
   // point for any future child response that chains onto it. Empty responses
   // fall back to their parent's attachment point so the chain stays connected.
   tailMessageByResponse: Map<string, string | null>;
+  // For each response, the id of its first user node (if any). Lets the arena
+  // collapse pass resolve a response's echoed user turn in O(1) instead of
+  // scanning every node; responses with no user input have no entry.
+  userMessageByResponse: Map<string, string>;
   rootMessageId: string | null;
 }
 
@@ -606,7 +610,7 @@ interface TreeBuildState {
 // continuations fold onto the turn they extend; everything else appends under
 // the chain parent resolved from `previous_response_id`.
 function linkResponse(state: TreeBuildState, resp: StoredResponse): void {
-  const { treeNodes, tailMessageByResponse } = state;
+  const { treeNodes, tailMessageByResponse, userMessageByResponse } = state;
   const parentResponseId =
     resp.previous_response_id &&
     tailMessageByResponse.has(resp.previous_response_id)
@@ -636,6 +640,11 @@ function linkResponse(state: TreeBuildState, resp: StoredResponse): void {
   for (const node of messageNodes) {
     appendNode(treeNodes, node, chainParent);
     if (firstId === null) firstId = node.id;
+    // Record the first user node so the arena collapse pass can resolve this
+    // response's echoed user turn without scanning the node map.
+    if (node.role === 'user' && !userMessageByResponse.has(resp.id)) {
+      userMessageByResponse.set(resp.id, node.id);
+    }
     chainParent = node.id;
   }
 
@@ -667,6 +676,7 @@ function linkResponse(state: TreeBuildState, resp: StoredResponse): void {
  */
 export function responsesToTree(
   responses: StoredResponse[],
+  opts?: { arenaWinners?: Record<string, string> },
 ): ResponseConversationTree {
   if (responses.length === 0) {
     return { nodes: {}, rootId: null };
@@ -675,6 +685,7 @@ export function responsesToTree(
   const state: TreeBuildState = {
     treeNodes: {},
     tailMessageByResponse: new Map<string, string | null>(),
+    userMessageByResponse: new Map<string, string>(),
     rootMessageId: null,
   };
 
@@ -682,5 +693,268 @@ export function responsesToTree(
     linkResponse(state, resp);
   }
 
-  return { nodes: state.treeNodes, rootId: state.rootMessageId };
+  const rootId = collapseArenaComparisons(
+    state.treeNodes,
+    responses,
+    opts?.arenaWinners ?? {},
+    state.rootMessageId,
+    state.userMessageByResponse,
+  );
+
+  return { nodes: state.treeNodes, rootId };
+}
+
+interface ParsedArena {
+  matchupId: string;
+  modelId?: string;
+  slot?: string;
+  slotSeed?: string;
+  variant?: string;
+}
+
+/** Parse a stored response's `metadata.arena` (JSON string or dict). */
+function parseArenaMeta(resp: StoredResponse): ParsedArena | null {
+  const raw = resp.metadata?.arena;
+  let arena: unknown = raw;
+  if (typeof raw === 'string') {
+    try {
+      arena = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  if (!arena || typeof arena !== 'object') return null;
+  const a = arena as {
+    matchup_id?: unknown;
+    model_id?: unknown;
+    slot?: unknown;
+    slot_seed?: unknown;
+    variant?: unknown;
+  };
+  if (typeof a.matchup_id !== 'string') return null;
+  return {
+    matchupId: a.matchup_id,
+    modelId: typeof a.model_id === 'string' ? a.model_id : undefined,
+    slot: typeof a.slot === 'string' ? a.slot : undefined,
+    slotSeed: typeof a.slot_seed === 'string' ? a.slot_seed : undefined,
+    variant: typeof a.variant === 'string' ? a.variant : undefined,
+  };
+}
+
+/**
+ * Fold arena sibling responses (same `metadata.arena.matchup_id`) into one
+ * comparison node: a single user turn with the pair's assistant answers as
+ * children, marked `comparing`. Each stored arena response carries its own
+ * echoed user input, so the naive tree has one user node per response — this
+ * collapses those duplicates so reload matches the live shape (one prompt, N
+ * lanes) that {@link projectActivePath} renders.
+ *
+ * Only pairs still present as ≥2 responses are folded: once a comparison is
+ * voted-and-continued the backend drops the loser (Decision 7-Discard), so a
+ * single surviving response is left as an ordinary linear turn. `arenaWinners`
+ * (matchup id → winning response id) marks the resolved winner so the reloaded
+ * comparison renders revealed rather than blind.
+ *
+ * Returns the (possibly updated) root id. Best-effort per group.
+ */
+function collapseArenaComparisons(
+  nodes: Record<string, ResponseTreeMessage>,
+  responses: StoredResponse[],
+  arenaWinners: Record<string, string>,
+  rootMessageId: string | null,
+  userMessageByResponse: Map<string, string>,
+): string | null {
+  const userNodeFor = (responseId: string): ResponseTreeMessage | undefined => {
+    const id = userMessageByResponse.get(responseId);
+    return id ? nodes[id] : undefined;
+  };
+
+  let root = rootMessageId;
+  for (const [matchupId, group] of groupResponsesByMatchup(responses)) {
+    // Fewer than two survivors is no comparison: a lone response left after a
+    // vote-and-continue (7-Discard) stays an ordinary linear turn.
+    if (group.length < 2) continue;
+    try {
+      root = foldArenaGroup(
+        nodes,
+        group,
+        arenaWinners[matchupId],
+        userNodeFor,
+        root,
+      );
+    } catch {
+      // Leave this group as-is on any structural surprise.
+    }
+  }
+  return root;
+}
+
+/** Bucket the responses that carry arena metadata by their `matchup_id`. */
+function groupResponsesByMatchup(
+  responses: StoredResponse[],
+): Map<string, StoredResponse[]> {
+  const groups = new Map<string, StoredResponse[]>();
+  for (const resp of responses) {
+    const meta = parseArenaMeta(resp);
+    if (!meta) continue;
+    const group = groups.get(meta.matchupId) ?? [];
+    group.push(resp);
+    groups.set(meta.matchupId, group);
+  }
+  return groups;
+}
+
+/** The lane slot ('a' / 'b') stamped on an assistant node, or '' when absent. */
+function laneSlot(node: ResponseTreeMessage | undefined): string {
+  return (node?.metadata.arena as { slot?: string } | undefined)?.slot ?? '';
+}
+
+// Order comparison lanes by slot ('a' before 'b') for stable column placement.
+function compareLaneSlots(
+  nodes: Record<string, ResponseTreeMessage>,
+  x: string,
+  y: string,
+): number {
+  const sx = laneSlot(nodes[x]);
+  const sy = laneSlot(nodes[y]);
+  if (sx < sy) return -1;
+  if (sx > sy) return 1;
+  return 0;
+}
+
+// Stamp a lane's model/slot onto its assistant node so the FE can resolve a
+// column label. No-op when the assistant node or arena meta is missing.
+function stampLaneAssistant(
+  nodes: Record<string, ResponseTreeMessage>,
+  resp: StoredResponse,
+): void {
+  const meta = parseArenaMeta(resp);
+  const assistant = nodes[getAssistantNodeId(resp)];
+  if (assistant && meta) {
+    assistant.metadata.arena = { modelId: meta.modelId, slot: meta.slot };
+  }
+}
+
+// Re-parent a lane's assistant under the shared fork parent, without a duplicate
+// child link.
+function attachLane(
+  canonicalUser: ResponseTreeMessage,
+  assistant: ResponseTreeMessage,
+): void {
+  assistant.parentId = canonicalUser.id;
+  if (!canonicalUser.childrenIds.includes(assistant.id)) {
+    canonicalUser.childrenIds.push(assistant.id);
+  }
+}
+
+// Drop a lane's duplicate echoed-user node, splicing it out of its original
+// parent and clamping that parent's active index. Returns the root id, redirected
+// onto the canonical user when the removed duplicate was itself the root.
+function removeDuplicateUser(
+  nodes: Record<string, ResponseTreeMessage>,
+  dupUser: ResponseTreeMessage,
+  sharedParentId: string | null,
+  canonicalUserId: string,
+  root: string | null,
+): string | null {
+  const parent = sharedParentId !== null ? nodes[sharedParentId] : undefined;
+  if (parent) {
+    parent.childrenIds = parent.childrenIds.filter((c) => c !== dupUser.id);
+    if (parent.activeChildIndex >= parent.childrenIds.length) {
+      parent.activeChildIndex = Math.max(0, parent.childrenIds.length - 1);
+    }
+  }
+  delete nodes[dupUser.id];
+  return root === dupUser.id ? canonicalUserId : root;
+}
+
+// Put the collapsed comparison node on the active path: at the root it becomes
+// the new root, otherwise its parent's active child points at it. Returns the
+// (possibly updated) root id.
+function activateForkNode(
+  nodes: Record<string, ResponseTreeMessage>,
+  canonicalUser: ResponseTreeMessage,
+  sharedParentId: string | null,
+  root: string | null,
+): string | null {
+  if (sharedParentId === null) return canonicalUser.id;
+  const parent = nodes[sharedParentId];
+  if (parent) {
+    const idx = parent.childrenIds.indexOf(canonicalUser.id);
+    if (idx !== -1) parent.activeChildIndex = idx;
+  }
+  return root;
+}
+
+// Reveal the recorded winner lane: mark it and make it the active child. No-op
+// when no winner is recorded or its assistant is not among the lanes.
+function applyArenaWinner(
+  canonicalUser: ResponseTreeMessage,
+  group: StoredResponse[],
+  winnerRespId: string | undefined,
+): void {
+  if (!winnerRespId) return;
+  const winnerResp = group.find((r) => r.id === winnerRespId);
+  if (!winnerResp) return;
+  const winnerAssistantId = getAssistantNodeId(winnerResp);
+  const idx = canonicalUser.childrenIds.indexOf(winnerAssistantId);
+  if (idx === -1) return;
+  canonicalUser.comparisonWinnerId = winnerAssistantId;
+  canonicalUser.activeChildIndex = idx;
+}
+
+// Fold one matchup's sibling responses onto a single comparison node: the first
+// lane's user turn becomes the shared fork parent, every lane's assistant becomes
+// a child, and the duplicate echoed-user turns are dropped. The first lane's
+// assistant already sits under the canonical user, so only later lanes are
+// re-parented. Returns the (possibly updated) root id.
+function foldArenaGroup(
+  nodes: Record<string, ResponseTreeMessage>,
+  group: StoredResponse[],
+  winnerRespId: string | undefined,
+  userNodeFor: (responseId: string) => ResponseTreeMessage | undefined,
+  root: string | null,
+): string | null {
+  const first = group[0];
+  if (!first) return root;
+  const canonicalUser = userNodeFor(first.id);
+  if (!canonicalUser) return root;
+  const sharedParentId = canonicalUser.parentId;
+
+  // Stamp matchup context on the fork parent so a reloaded comparison can be
+  // voted on (the host reconstructs the preference payload from here).
+  const forkMeta = parseArenaMeta(first);
+  if (forkMeta) {
+    canonicalUser.metadata.arena = {
+      matchupId: forkMeta.matchupId,
+      slotSeed: forkMeta.slotSeed,
+      variant: forkMeta.variant,
+    };
+  }
+
+  let newRoot = root;
+  for (const [i, resp] of group.entries()) {
+    stampLaneAssistant(nodes, resp);
+    if (i === 0) continue;
+    const assistant = nodes[getAssistantNodeId(resp)];
+    if (!assistant) continue;
+    attachLane(canonicalUser, assistant);
+    const dupUser = userNodeFor(resp.id);
+    if (dupUser && dupUser.id !== canonicalUser.id) {
+      newRoot = removeDuplicateUser(
+        nodes,
+        dupUser,
+        sharedParentId,
+        canonicalUser.id,
+        newRoot,
+      );
+    }
+  }
+
+  canonicalUser.childrenIds.sort((x, y) => compareLaneSlots(nodes, x, y));
+
+  canonicalUser.comparing = true;
+  newRoot = activateForkNode(nodes, canonicalUser, sharedParentId, newRoot);
+  applyArenaWinner(canonicalUser, group, winnerRespId);
+  return newRoot;
 }