@copilotkit/shared 1.73.0 → 1.73.2-canary.1790068297

package/src/utils/__tests__/row-render-keys.test.ts

@@ -0,0 +1,388 @@
+import { describe, expect, it } from "vitest";
+import type { Message, ToolCall } from "@ag-ui/core";
+import {
+  commitRowKeyStore,
+  createRowKeyStore,
+  pruneRowKeyStore,
+  resolveRowRenderKeys,
+  resolveRowRenderKeysById,
+} from "../row-render-keys";
+
+function toolCall(id: string, name = "approve"): ToolCall {
+  return { id, type: "function", function: { name, arguments: "{}" } };
+}
+
+function assistant(id: string, toolCalls?: ToolCall[]): Message {
+  return { id, role: "assistant", content: "…", toolCalls } as Message;
+}
+
+function user(id: string): Message {
+  return { id, role: "user", content: "hi" } as Message;
+}
+
+/**
+ * One render that reaches the screen: resolve keys, then record anchors the way
+ * each framework's post-render phase does. Anchors only exist after a render,
+ * so a test that spans renders has to commit between them.
+ */
+function renderPass(
+  store: ReturnType<typeof createRowKeyStore>,
+  messages: Message[],
+) {
+  const keys = resolveRowRenderKeysById(store, messages);
+  commitRowKeyStore(store, messages);
+  return keys;
+}
+
+/** The same, for callers that key rows by position rather than by id. */
+function renderPassByPosition(
+  store: ReturnType<typeof createRowKeyStore>,
+  messages: readonly (Message | undefined)[],
+) {
+  const keys = resolveRowRenderKeys(store, messages);
+  commitRowKeyStore(store, messages);
+  return keys;
+}
+
+/** The row key a message resolves to for a given list. */
+function keyOf(
+  store: ReturnType<typeof createRowKeyStore>,
+  messages: Message[],
+  id: string,
+) {
+  return renderPass(store, messages).get(id);
+}
+
+describe("resolveRowRenderKeys", () => {
+  it("keys by message.id when there are no tool calls, leaving the store empty", () => {
+    const store = createRowKeyStore();
+    const messages = [user("u1"), assistant("a1")];
+
+    const keys = resolveRowRenderKeysById(store, messages);
+
+    expect(keys.get("u1")).toBe("u1");
+    expect(keys.get("a1")).toBe("a1");
+    // The whole point of the override-table design: unaffected conversations
+    // carry no state and behave exactly like plain id keying.
+    expect(store.overrides.size).toBe(0);
+  });
+
+  it("holds the key steady when a tool call appears on an already-streaming message", () => {
+    // Real sequence: TEXT_MESSAGE_START creates the message, TOOL_CALL_START
+    // then mutates that SAME message. Deriving the key from the tool call
+    // would change it here and remount the row.
+    const store = createRowKeyStore();
+
+    const streaming = keyOf(store, [assistant("lc_run--1")], "lc_run--1");
+    const withTool = keyOf(
+      store,
+      [assistant("lc_run--1", [toolCall("call_A")])],
+      "lc_run--1",
+    );
+
+    expect(streaming).toBe("lc_run--1");
+    expect(withTool).toBe("lc_run--1");
+  });
+
+  it("holds the key steady when the snapshot re-keys the message id", () => {
+    const store = createRowKeyStore();
+
+    renderPass(store, [assistant("lc_run--1", [toolCall("call_A")])]);
+    const afterRekey = keyOf(
+      store,
+      [assistant("resp_1", [toolCall("call_A")])],
+      "resp_1",
+    );
+
+    expect(afterRekey).toBe("lc_run--1");
+  });
+
+  it("holds the key steady across the full streaming sequence", () => {
+    const store = createRowKeyStore();
+
+    const k1 = keyOf(store, [assistant("lc_run--1")], "lc_run--1");
+    const k2 = keyOf(
+      store,
+      [assistant("lc_run--1", [toolCall("call_A")])],
+      "lc_run--1",
+    );
+    const k3 = keyOf(
+      store,
+      [assistant("resp_1", [toolCall("call_A")])],
+      "resp_1",
+    );
+
+    expect(new Set([k1, k2, k3]).size).toBe(1);
+  });
+
+  it("resolves through a surviving anchor when tool calls are reordered", () => {
+    const store = createRowKeyStore();
+
+    renderPass(store, [
+      assistant("lc_run--1", [toolCall("call_A"), toolCall("call_B")]),
+    ]);
+    // Snapshot re-keys the message AND presents the tool calls in the other
+    // order — anchoring on every tool call (not just the first) survives it.
+    const afterRekey = keyOf(
+      store,
+      [assistant("resp_1", [toolCall("call_B"), toolCall("call_A")])],
+      "resp_1",
+    );
+
+    expect(afterRekey).toBe("lc_run--1");
+  });
+
+  it("keeps a later tool call from stealing an established key", () => {
+    const store = createRowKeyStore();
+
+    renderPass(store, [assistant("lc_run--1", [toolCall("call_A")])]);
+    // A second tool call arrives on the same row; call_A already owns the key.
+    const keys = renderPass(store, [
+      assistant("lc_run--1", [toolCall("call_A"), toolCall("call_B")]),
+    ]);
+
+    expect(keys.get("lc_run--1")).toBe("lc_run--1");
+    expect(store.overrides.get("tc:call_B")).toBe("lc_run--1");
+  });
+
+  it("falls back to message.id when two messages share a tool-call id", () => {
+    const store = createRowKeyStore();
+    const messages = [
+      assistant("a-1", [toolCall("call_X")]),
+      assistant("a-2", [toolCall("call_X")]),
+    ];
+
+    const keys = resolveRowRenderKeysById(store, messages);
+
+    expect(keys.get("a-1")).toBe("a-1");
+    expect(keys.get("a-2")).toBe("a-2");
+    expect(new Set(keys.values()).size).toBe(2);
+  });
+
+  it("keeps a shared-anchor fallback stable across renders", () => {
+    // The loser of a shared anchor must not drift between renders, or it
+    // remounts on every update.
+    const store = createRowKeyStore();
+    const messages = [
+      assistant("a-1", [toolCall("call_X")]),
+      assistant("a-2", [toolCall("call_X")]),
+    ];
+
+    const first = renderPass(store, messages);
+    const second = renderPass(store, messages);
+
+    expect(second.get("a-1")).toBe(first.get("a-1"));
+    expect(second.get("a-2")).toBe(first.get("a-2"));
+  });
+
+  it("disambiguates when an override vends a key equal to a later message's id", () => {
+    // Pathological: the store vends "ghost" for one row, and another message
+    // literally has id "ghost". Keys must still be unique.
+    const store = createRowKeyStore();
+    renderPass(store, [assistant("ghost", [toolCall("call_X")])]);
+
+    const keys = resolveRowRenderKeysById(store, [
+      assistant("live", [toolCall("call_X")]),
+      assistant("ghost"),
+    ]);
+
+    expect(keys.get("live")).toBe("ghost");
+    expect(keys.get("ghost")).not.toBe("ghost");
+    expect(new Set(keys.values()).size).toBe(2);
+  });
+
+  it("is idempotent, so a repeated or abandoned render yields the same keys", () => {
+    const store = createRowKeyStore();
+    const messages = [
+      assistant("a-1", [toolCall("call_A")]),
+      assistant("a-2", [toolCall("call_B")]),
+      user("u-1"),
+    ];
+
+    const first = renderPass(store, messages);
+    const snapshot = new Map(store.overrides);
+    const second = renderPass(store, messages);
+
+    expect([...second.entries()]).toEqual([...first.entries()]);
+    expect([...store.overrides.entries()]).toEqual([...snapshot.entries()]);
+  });
+
+  it("leaves the store untouched, so a render is safe to discard", () => {
+    const store = createRowKeyStore();
+
+    resolveRowRenderKeys(store, [assistant("lc_run--1", [toolCall("call_A")])]);
+
+    expect(store.overrides.size).toBe(0);
+  });
+
+  it("does not let a discarded render's key reach the rendered rows", () => {
+    // Every framework here can evaluate a render pass and then throw it away.
+    // If resolving had recorded tc:call_A -> resp_1, the row the user is
+    // actually looking at (still lc_run--1) would re-key and be torn down on
+    // its next render — the flash this module exists to prevent.
+    const store = createRowKeyStore();
+
+    resolveRowRenderKeys(store, [assistant("resp_1", [toolCall("call_A")])]);
+    const committed = keyOf(
+      store,
+      [assistant("lc_run--1", [toolCall("call_A")])],
+      "lc_run--1",
+    );
+
+    expect(committed).toBe("lc_run--1");
+  });
+
+  it("records anchors once the render reaches the DOM", () => {
+    const store = createRowKeyStore();
+    const messages = [assistant("lc_run--1", [toolCall("call_A")])];
+
+    resolveRowRenderKeys(store, messages);
+    commitRowKeyStore(store, messages);
+
+    expect(store.overrides.get("tc:call_A")).toBe("lc_run--1");
+  });
+
+  it("does not hand a shared anchor's key to the survivor when the other row leaves", () => {
+    // Two rows carrying one tool-call id make that anchor useless as an
+    // identity: whichever row outlives the other would inherit the first
+    // row's key, and with it the first row's DOM and component state.
+    const store = createRowKeyStore();
+    renderPass(store, [
+      assistant("a-1", [toolCall("call_X")]),
+      assistant("a-2", [toolCall("call_X")]),
+    ]);
+
+    const survivor = keyOf(
+      store,
+      [assistant("a-2", [toolCall("call_X")])],
+      "a-2",
+    );
+
+    expect(survivor).toBe("a-2");
+  });
+
+  it("does not register anchors for non-assistant roles", () => {
+    const store = createRowKeyStore();
+    const toolMessage = {
+      id: "t-1",
+      role: "tool",
+      content: "ok",
+      toolCallId: "call_A",
+    } as unknown as Message;
+
+    renderPass(store, [toolMessage]);
+
+    expect(store.overrides.size).toBe(0);
+  });
+
+  it("ignores an empty toolCalls array", () => {
+    const store = createRowKeyStore();
+
+    const keys = renderPass(store, [assistant("a-1", [])]);
+
+    expect(keys.get("a-1")).toBe("a-1");
+    expect(store.overrides.size).toBe(0);
+  });
+
+  it("still re-keys a text-only message (documented limitation)", () => {
+    // No anchor exists for a text-only message, so nothing can correlate it
+    // across a rename. Recorded so a future change that fixes it is a
+    // deliberate update rather than an accident.
+    const store = createRowKeyStore();
+
+    const before = keyOf(store, [assistant("lc_run--1")], "lc_run--1");
+    const after = keyOf(store, [assistant("resp_1")], "resp_1");
+
+    expect(before).toBe("lc_run--1");
+    expect(after).toBe("resp_1");
+  });
+});
+
+describe("resolveRowRenderKeys by position", () => {
+  it("keeps keys unique when the list contains duplicate message ids", () => {
+    // A caller that does not deduplicate lets duplicate ids reach the view, and
+    // Angular reports duplicated track values as an error, so uniqueness has to
+    // be structural.
+    const store = createRowKeyStore();
+
+    const keys = renderPassByPosition(store, [
+      assistant("dup"),
+      assistant("dup"),
+      assistant("dup"),
+    ]);
+
+    expect(new Set(keys).size).toBe(3);
+    expect(keys[0]).toBe("dup");
+  });
+
+  it("falls back to the index for a message with no id", () => {
+    const store = createRowKeyStore();
+    const idless = { role: "assistant", content: "x" } as unknown as Message;
+
+    const keys = renderPassByPosition(store, [assistant("a-1"), idless]);
+
+    expect(keys).toEqual(["a-1", "index-1"]);
+  });
+
+  it("tolerates a sparse list without throwing", () => {
+    const store = createRowKeyStore();
+
+    const keys = renderPassByPosition(store, [undefined, assistant("a-1")]);
+
+    expect(keys).toEqual(["index-0", "a-1"]);
+  });
+
+  it("agrees with the id-keyed shape on a deduplicated list", () => {
+    const messages = [
+      assistant("lc_run--1", [toolCall("call_A")]),
+      user("u-1"),
+    ];
+
+    const byPosition = renderPassByPosition(createRowKeyStore(), messages);
+    const byId = renderPass(createRowKeyStore(), messages);
+
+    expect(byPosition).toEqual(messages.map((m) => byId.get(m.id)));
+  });
+});
+
+describe("pruneRowKeyStore", () => {
+  it("drops anchors whose messages are gone and keeps live ones", () => {
+    const store = createRowKeyStore();
+    renderPass(store, [
+      assistant("a-1", [toolCall("call_A")]),
+      assistant("a-2", [toolCall("call_B")]),
+    ]);
+    expect(store.overrides.size).toBe(2);
+
+    pruneRowKeyStore(store, [assistant("a-2", [toolCall("call_B")])]);
+
+    expect([...store.overrides.keys()]).toEqual(["tc:call_B"]);
+  });
+
+  it("bounds the store to the visible list rather than the conversation", () => {
+    const store = createRowKeyStore();
+    for (let i = 0; i < 50; i++) {
+      const live = [assistant(`a-${i}`, [toolCall(`call_${i}`)])];
+      renderPass(store, live);
+      pruneRowKeyStore(store, live);
+    }
+
+    expect(store.overrides.size).toBe(1);
+  });
+
+  it("preserves the key of a row that survives a prune", () => {
+    const store = createRowKeyStore();
+    const live = [assistant("lc_run--1", [toolCall("call_A")])];
+    renderPass(store, live);
+    pruneRowKeyStore(store, live);
+
+    // The re-key must still resolve after an intervening prune.
+    const afterRekey = keyOf(
+      store,
+      [assistant("resp_1", [toolCall("call_A")])],
+      "resp_1",
+    );
+
+    expect(afterRekey).toBe("lc_run--1");
+  });
+});

package/src/utils/index.ts

@@ -9,6 +9,7 @@ export * from "./inspector-visibility";
 export * from "./types";
 export * from "./random-id";
 export * from "./requests";
+export * from "./row-render-keys";
 
 import * as PartialJSON from "partial-json";
 

package/src/utils/row-render-keys.ts

@@ -0,0 +1,263 @@
+import type { AssistantMessage, Message } from "@ag-ui/core";
+
+/**
+ * Stable per-row view keys for chat transcripts, across backends that re-key a
+ * message mid-stream. Shared by every frontend package, because the defect and
+ * the correlation signal are in the message stream, not in any one framework.
+ *
+ * ## The problem
+ *
+ * A message's canonical `id` is not stable within a turn. LangChain stamps a
+ * placeholder id on the first streamed chunk when the provider didn't supply
+ * one (`chat_models.py`: `if chunk.message.id is None: chunk.message.id =
+ * "lc_run-" + "-" + run_id`), then prefers any provider-assigned id it sees
+ * while merging chunks (`messages/ai.py`, "Ranks are defined by the order of
+ * preference"). The `MESSAGES_SNAPSHOT` therefore carries the provider's final
+ * id (e.g. `resp_…`) for a message the client already knows as `lc_run--…`.
+ *
+ * Every framework destroys and recreates a row whose key changes, so keying
+ * rows by `id` turned that swap into the visible HITL chat flash, where a
+ * rendered approval card appears to reset during a tool's
+ * `executing → complete` transition.
+ *
+ * This is provider-conditional: providers that stamp an id on every chunk (so
+ * `chunk.message.id is None` never holds) never trigger a rename.
+ *
+ * ## The approach
+ *
+ * Tool-call ids survive the rename, so they are used as *anchors*: the first
+ * message seen carrying a given tool call records the key it was assigned, and
+ * any later message carrying that same tool call reuses it. The store is an
+ * override table consulted before falling back to `message.id`. Resolving only
+ * reads it; each render that reaches the DOM then records what it rendered:
+ *
+ * ```text
+ * render 1  id=lc_run--1  no tools    key = message.id = lc_run--1
+ *   commit 1                                                           store {}
+ * render 2  id=lc_run--1  tc call_A   key = message.id = lc_run--1
+ *   commit 2                                           store { tc:call_A -> lc_run--1 }
+ * render 3  id=resp_1     tc call_A   key = store[tc:call_A]
+ *                                         = lc_run--1  (row survives)
+ *   commit 3                                                    store unchanged
+ * ```
+ *
+ * Recording the anchor at commit 2 — while the id is still stable — is what
+ * makes render 3 resolvable. Note the fix does not depend on render 2
+ * existing: a message born already carrying a tool call anchors on the first
+ * render that commits it, under whatever id it holds then.
+ *
+ * ## Why an override table rather than keying rows by tool-call id
+ *
+ * Deriving the key from the tool call directly (`tc:<id>` whenever a tool call
+ * is present) needs no state, but changes the key the moment a tool call
+ * *appears* — so an assistant message that streams text and then calls a tool
+ * is torn down on that transition, for every provider, whether or not it
+ * renames. That trades a conditional flash for an unconditional one. Recording
+ * an override keeps the key the row already had.
+ *
+ * ## Cost
+ *
+ * The store holds only `tc:<toolCallId>` entries, so a conversation with no
+ * tool calls keeps an empty store and behaviour byte-identical to keying by
+ * `id`. Size is bounded to the tool calls of the currently-rendered messages
+ * (see `pruneRowKeyStore`), not the conversation length. Deleting the store
+ * reverts to plain `id` keying.
+ *
+ * ## Known gaps
+ *
+ * - A text-only assistant message has no anchor, so it still re-keys. No
+ *   client-side correlation signal exists for it; the fix is stable ids
+ *   upstream.
+ * - If the tool call's arrival and the id swap land in the same update, the
+ *   intermediate state never renders, the anchor is never recorded, and the
+ *   row is recreated as before. Correlating in the event-apply layer (i.e. in
+ *   the AG-UI client, which observes every intermediate state) would be immune.
+ */
+
+const TOOL_ANCHOR_PREFIX = "tc:";
+
+export interface RowKeyStore {
+  /**
+   * `tc:<toolCallId>` → the row key first assigned to a message carrying that
+   * tool call. Populated only for assistant messages that carry tool calls.
+   */
+  overrides: Map<string, string>;
+  /**
+   * Anchors carried by more than one message in the last rendered list. Such
+   * an anchor identifies no single row, so it is never used to vend a key.
+   */
+  ambiguous: Set<string>;
+}
+
+export function createRowKeyStore(): RowKeyStore {
+  return { overrides: new Map(), ambiguous: new Set() };
+}
+
+/**
+ * Anchors a message contributes. Only assistant tool calls qualify: LangChain's
+ * id preference applies when merging `AIMessageChunk`s, so user message ids are
+ * not renamed, and `role: "tool"` messages are not rendered as rows. Every tool
+ * call is used (not just the first) so the anchor survives tool-call reordering
+ * between snapshots.
+ */
+function toolAnchorsOf(message: Message | undefined): string[] {
+  if (message?.role !== "assistant") return [];
+  const toolCalls = (message as AssistantMessage).toolCalls;
+  if (!toolCalls?.length) return [];
+
+  const anchors: string[] = [];
+  for (const toolCall of toolCalls) {
+    if (toolCall?.id) anchors.push(`${TOOL_ANCHOR_PREFIX}${toolCall.id}`);
+  }
+  return anchors;
+}
+
+/**
+ * Resolves the row key for every message, returned by position.
+ *
+ * Pure: it reads `store` and never writes to it. Every framework here may
+ * evaluate a render pass whose result never reaches the DOM — an abandoned
+ * concurrent render in React, a discarded `computed` evaluation in Vue or
+ * Angular. An anchor recorded by such a pass would vend its key to the pass
+ * that does render, re-keying the row the user is looking at, which is the
+ * teardown this module exists to prevent. Anchors are recorded by
+ * `commitRowKeyStore`, from whichever phase each framework runs after the DOM
+ * is updated.
+ *
+ * Uniqueness is structural rather than assumed: a caller that does not
+ * deduplicate can pass two rows with the same id, and an override can vend a
+ * key equal to a later message's own id.
+ */
+export function resolveRowRenderKeys(
+  store: RowKeyStore,
+  messages: readonly (Message | undefined)[],
+): string[] {
+  const keys: string[] = [];
+  const claimed = new Set<string>();
+
+  messages.forEach((message, index) => {
+    const anchors = toolAnchorsOf(message);
+
+    // Reuse the key recorded for any of this message's anchors. An override
+    // pointing at a key another row already claimed this pass is skipped: two
+    // messages can share a tool-call id (upstream bug, or replayed state), and
+    // the later one falls back to its own id instead.
+    let key: string | undefined;
+    for (const anchor of anchors) {
+      if (store.ambiguous.has(anchor)) continue;
+      const recorded = store.overrides.get(anchor);
+      if (recorded !== undefined && !claimed.has(recorded)) {
+        key = recorded;
+        break;
+      }
+    }
+
+    // The index fallback covers a message with no usable id.
+    key ??= message?.id || `index-${index}`;
+
+    if (claimed.has(key)) {
+      let suffix = 2;
+      while (claimed.has(`${key}:${suffix}`)) suffix += 1;
+      key = `${key}:${suffix}`;
+    }
+
+    keys.push(key);
+    claimed.add(key);
+  });
+
+  return keys;
+}
+
+/**
+ * `message.id` → row key, for callers that render by message rather than by
+ * position. `messages` must be deduplicated: duplicate ids would overwrite
+ * each other in the returned map.
+ */
+export function resolveRowRenderKeysById(
+  store: RowKeyStore,
+  messages: readonly Message[],
+): Map<string, string> {
+  const keys = resolveRowRenderKeys(store, messages);
+  const byId = new Map<string, string>();
+  messages.forEach((message, index) => {
+    const key = keys[index];
+    if (key !== undefined) byId.set(message.id, key);
+  });
+  return byId;
+}
+
+/**
+ * Records the anchors of a rendered list, then bounds the store to it. Call
+ * from the phase that runs after the DOM is updated, never while resolving —
+ * see `resolveRowRenderKeys`.
+ *
+ * Re-resolving here reproduces the keys the rows were rendered with, because
+ * the store cannot change between a render and its own post-render phase.
+ *
+ * An anchor carried by two rows in the same list is marked ambiguous rather
+ * than recorded. Recording it would give the first row's key to whichever row
+ * outlived the other, and with it that row's DOM and component state.
+ */
+export function commitRowKeyStore(
+  store: RowKeyStore,
+  messages: readonly (Message | undefined)[],
+): void {
+  const keys = resolveRowRenderKeys(store, messages);
+
+  const anchorCounts = new Map<string, number>();
+  for (const message of messages) {
+    for (const anchor of toolAnchorsOf(message)) {
+      anchorCounts.set(anchor, (anchorCounts.get(anchor) ?? 0) + 1);
+    }
+  }
+
+  // Ambiguity is a property of the rendered list, so it is recomputed rather
+  // than accumulated: an anchor left alone by the row that shadowed it becomes
+  // usable again.
+  store.ambiguous.clear();
+  for (const [anchor, count] of anchorCounts) {
+    if (count > 1) {
+      store.ambiguous.add(anchor);
+      store.overrides.delete(anchor);
+    }
+  }
+
+  // First claimant of an anchor owns it, so a re-keyed message resolves to the
+  // key the row already had rather than overwriting it.
+  messages.forEach((message, index) => {
+    const key = keys[index];
+    if (key === undefined) return;
+    for (const anchor of toolAnchorsOf(message)) {
+      if (store.ambiguous.has(anchor)) continue;
+      if (!store.overrides.has(anchor)) store.overrides.set(anchor, key);
+    }
+  });
+
+  pruneRowKeyStore(store, messages);
+}
+
+/**
+ * Drops anchors no longer present in `messages`, bounding the store to the
+ * tool calls of the currently-rendered messages. Called by
+ * `commitRowKeyStore`; like it, this writes to the store and so belongs after
+ * the DOM is updated, never while resolving.
+ *
+ * Pruned entries are unreachable by construction: `resolveRowRenderKeys` only
+ * looks up anchors belonging to messages in the list it is given.
+ */
+export function pruneRowKeyStore(
+  store: RowKeyStore,
+  messages: readonly (Message | undefined)[],
+): void {
+  const live = new Set<string>();
+  for (const message of messages) {
+    for (const anchor of toolAnchorsOf(message)) live.add(anchor);
+  }
+
+  for (const anchor of store.overrides.keys()) {
+    if (!live.has(anchor)) store.overrides.delete(anchor);
+  }
+  for (const anchor of store.ambiguous) {
+    if (!live.has(anchor)) store.ambiguous.delete(anchor);
+  }
+}

package/tsdown.config.ts

@@ -2,10 +2,13 @@ import { defineConfig } from "tsdown";
 
 export default defineConfig([
   {
-    // `src/telemetry/index.ts` is a second entry so that the Node-only
-    // telemetry client is reachable as `@copilotkit/shared/telemetry`. The
-    // root entry deliberately does not re-export it (#4151).
-    entry: ["src/index.ts", "src/telemetry/index.ts"],
+    // Node-only telemetry and event transforms have separate entries.
+    // The browser-facing root must not re-export either (#4151).
+    entry: [
+      "src/index.ts",
+      "src/telemetry/index.ts",
+      "src/event-transforms/index.ts",
+    ],
     format: ["esm", "cjs"],
     dts: true,
     sourcemap: true,