@assistant-ui/core 0.1.16 → 0.2.0

package/src/tests/RemoteThreadListThreadListRuntimeCore-loadMore.test.ts

@@ -0,0 +1,448 @@
+import { afterEach, describe, it, expect, vi } from "vitest";
+import type {
+  RemoteThreadListPageOptions,
+  RemoteThreadListResponse,
+} from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+type ListFn = (
+  params?: RemoteThreadListPageOptions,
+) => Promise<RemoteThreadListResponse>;
+
+describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("initial list response with nextCursor sets hasMore=true", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "First",
+          },
+        ],
+        nextCursor: "cursor-1",
+      })),
+    });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.threadIds).toEqual(["t-1"]);
+    expect(core.hasMore).toBe(true);
+  });
+
+  it("absent nextCursor leaves hasMore=false", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "Only",
+          },
+        ],
+      })),
+    });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.hasMore).toBe(false);
+  });
+
+  it("loadMore appends the next page and advances the cursor", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "p1-a", externalId: "p1-a" },
+          { status: "regular", remoteId: "p1-b", externalId: "p1-b" },
+        ],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "p2-a", externalId: "p2-a" },
+          { status: "regular", remoteId: "p2-b", externalId: "p2-b" },
+        ],
+        nextCursor: "c2",
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.threadIds).toEqual(["p1-a", "p1-b"]);
+    expect(core.hasMore).toBe(true);
+
+    await core.loadMore();
+
+    expect(listFn).toHaveBeenNthCalledWith(2, { after: "c1" });
+    expect(core.threadIds).toEqual(["p1-a", "p1-b", "p2-a", "p2-b"]);
+    expect(core.hasMore).toBe(true);
+  });
+
+  it("loadMore without nextCursor flips hasMore to false", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "b", externalId: "b" }],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(core.hasMore).toBe(false);
+    expect(core.threadIds).toEqual(["a", "b"]);
+  });
+
+  it("loadMore is a no-op when hasMore is false", async () => {
+    const listFn = vi.fn<ListFn>().mockResolvedValueOnce({
+      threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+    });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.hasMore).toBe(false);
+
+    await core.loadMore();
+    expect(listFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("loadMore is a no-op while the initial list is in flight", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const listFn = vi.fn<ListFn>().mockReturnValueOnce(first.promise);
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(listFn).toHaveBeenCalledTimes(1);
+    first.resolve({ threads: [] });
+  });
+
+  it("concurrent loadMore calls dedupe to a single in-flight request", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockReturnValueOnce(first.promise);
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+
+    const p1 = core.loadMore();
+    const p2 = core.loadMore();
+    expect(listFn).toHaveBeenCalledTimes(2);
+
+    first.resolve({
+      threads: [{ status: "regular", remoteId: "b", externalId: "b" }],
+    });
+    await Promise.all([p1, p2]);
+
+    expect(listFn).toHaveBeenCalledTimes(2);
+    expect(core.threadIds).toEqual(["a", "b"]);
+  });
+
+  it("drops a stale loadMore when reload bumps the generation mid-flight", async () => {
+    const loadMoreCall = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockReturnValueOnce(loadMoreCall.promise)
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "fresh", externalId: "fresh" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+
+    const stale = core.loadMore();
+    const reloaded = core.reload();
+
+    loadMoreCall.resolve({
+      threads: [{ status: "regular", remoteId: "stale", externalId: "stale" }],
+      nextCursor: "stale-cursor",
+    });
+    await Promise.all([stale, reloaded]);
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.hasMore).toBe(false);
+  });
+
+  it("releases the dedup handle after a rejection so retries can proceed", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockRejectedValueOnce(new Error("network"))
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "b", externalId: "b" }],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+    expect(core.threadIds).toEqual(["a"]);
+    expect(core.isLoadingMore).toBe(false);
+
+    await core.loadMore();
+    expect(core.threadIds).toEqual(["a", "b"]);
+  });
+
+  it("dedupes thread ids that appear on more than one page", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "a", externalId: "a" },
+          { status: "regular", remoteId: "b", externalId: "b" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(core.threadIds).toEqual(["a", "b"]);
+  });
+
+  it("__internal_setOptions clears cursor and dedup handles on adapter swap, then refetches via the new adapter", async () => {
+    const firstAdapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular", remoteId: "old", externalId: "old" }],
+        nextCursor: "old-cursor",
+      })),
+    });
+    const core = createCore(firstAdapter);
+    await core.getLoadThreadsPromise();
+    expect(core.threadIds).toEqual(["old"]);
+    expect(core.hasMore).toBe(true);
+
+    const secondList = vi.fn(async () => ({
+      threads: [{ status: "regular", remoteId: "new", externalId: "new" }],
+    }));
+    const secondAdapter = makeAdapter({ list: secondList });
+    core.__internal_setOptions({
+      adapter: secondAdapter,
+      runtimeHook: () => ({}) as never,
+    });
+
+    expect(core.hasMore).toBe(false);
+    expect(core.threadIds).toEqual(["old"]);
+
+    await core.getLoadThreadsPromise();
+    expect(secondList).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual(["new"]);
+  });
+
+  it("ignores an in-flight loadMore response when the adapter swaps mid-flight", async () => {
+    const slow = deferred<RemoteThreadListResponse>();
+    const firstList = vi
+      .fn<
+        (
+          params?: RemoteThreadListPageOptions,
+        ) => Promise<RemoteThreadListResponse>
+      >()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "p1", externalId: "p1" }],
+        nextCursor: "c1",
+      })
+      .mockReturnValueOnce(slow.promise);
+    const firstAdapter = makeAdapter({ list: firstList });
+    const core = createCore(firstAdapter);
+
+    await core.getLoadThreadsPromise();
+    const stale = core.loadMore();
+
+    const secondAdapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular", remoteId: "ignored", externalId: "x" }],
+      })),
+    });
+    core.__internal_setOptions({
+      adapter: secondAdapter,
+      runtimeHook: () => ({}) as never,
+    });
+
+    slow.resolve({
+      threads: [{ status: "regular", remoteId: "stale", externalId: "stale" }],
+      nextCursor: "stale-cursor",
+    });
+    await stale;
+
+    expect(core.threadIds).toEqual(["p1"]);
+    expect(core.hasMore).toBe(false);
+    expect(core.isLoadingMore).toBe(false);
+  });
+
+  it("drops the in-flight initial list when the adapter swaps mid-flight", async () => {
+    const slow = deferred<RemoteThreadListResponse>();
+    const firstList = vi.fn<ListFn>().mockReturnValueOnce(slow.promise);
+    const firstAdapter = makeAdapter({ list: firstList });
+    const core = createCore(firstAdapter);
+
+    core.getLoadThreadsPromise();
+
+    const secondList = vi.fn<ListFn>().mockResolvedValueOnce({
+      threads: [{ status: "regular", remoteId: "fresh", externalId: "fresh" }],
+    });
+    const secondAdapter = makeAdapter({ list: secondList });
+    core.__internal_setOptions({
+      adapter: secondAdapter,
+      runtimeHook: () => ({}) as never,
+    });
+
+    slow.resolve({
+      threads: [{ status: "regular", remoteId: "stale", externalId: "stale" }],
+      nextCursor: "stale-cursor",
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(core.threadIds).toEqual([]);
+    expect(core.hasMore).toBe(false);
+
+    await core.getLoadThreadsPromise();
+    expect(secondList).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual(["fresh"]);
+  });
+
+  it("dedupes thread ids that appear twice within a single page", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "b", externalId: "b" },
+          { status: "regular", remoteId: "b", externalId: "b" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(core.threadIds).toEqual(["a", "b"]);
+  });
+
+  it("treats an empty-string nextCursor as no more pages", async () => {
+    const listFn = vi.fn<ListFn>().mockResolvedValueOnce({
+      threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+      nextCursor: "",
+    });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.hasMore).toBe(false);
+
+    await core.loadMore();
+    expect(listFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not advance the cursor when the reducer rejects an unknown thread status", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "weird" as unknown as "regular",
+            remoteId: "bad",
+            externalId: "bad",
+          },
+        ],
+        nextCursor: "c2",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "retry", externalId: "retry" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.hasMore).toBe(true);
+
+    await core.loadMore();
+
+    expect(core.threadIds).toEqual(["a"]);
+    expect(core.hasMore).toBe(true);
+    expect(core.isLoadingMore).toBe(false);
+
+    await core.loadMore();
+    expect(listFn).toHaveBeenNthCalledWith(2, { after: "c1" });
+    expect(listFn).toHaveBeenNthCalledWith(3, { after: "c1" });
+    expect(core.threadIds).toEqual(["a", "retry"]);
+  });
+
+  it("reload resets cursor and hasMore so loadMore becomes a no-op", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "fresh", externalId: "fresh" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.hasMore).toBe(true);
+
+    await core.reload();
+    expect(core.hasMore).toBe(false);
+    expect(core.threadIds).toEqual(["fresh"]);
+
+    await core.loadMore();
+    expect(listFn).toHaveBeenCalledTimes(2);
+  });
+});

package/src/tests/RemoteThreadListThreadListRuntimeCore-reload.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from "vitest";
+import { afterEach, describe, it, expect, vi } from "vitest";
 import type { RemoteThreadListResponse } from "../runtimes/remote-thread-list/types";
 import {
   createCore,
@@ -7,6 +7,10 @@ import {
 } from "./remote-thread-list-test-helpers";
 
 describe("RemoteThreadListThreadListRuntimeCore.reload", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it("refetches list() after a successful empty load", async () => {
     const listFn = vi
       .fn<() => Promise<RemoteThreadListResponse>>()
@@ -92,6 +96,7 @@ describe("RemoteThreadListThreadListRuntimeCore.reload", () => {
   });
 
   it("recovers after a failed initial load", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
     const listFn = vi
       .fn<() => Promise<RemoteThreadListResponse>>()
       .mockRejectedValueOnce(new Error("401"))

package/src/tests/base-composer-runtime-core-addAttachment.test.ts

@@ -48,6 +48,13 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     ).rejects.toThrow("Attachments are not supported");
 
     expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "no-adapter",
+        message: "Attachments are not supported",
+        error: expect.any(Error),
+      }),
+    );
     expect(onAdd).not.toHaveBeenCalled();
   });
 
@@ -63,6 +70,15 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     ).rejects.toThrow(/File type text\/plain is not accepted/);
 
     expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "not-accepted",
+        message: expect.stringContaining(
+          "File type text/plain is not accepted",
+        ),
+        error: expect.any(Error),
+      }),
+    );
     expect(onAdd).not.toHaveBeenCalled();
   });
 
@@ -84,6 +100,13 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     ).rejects.toThrow("upload failed");
 
     expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        message: "upload failed",
+        error: expect.any(Error),
+      }),
+    );
     expect(onAdd).not.toHaveBeenCalled();
   });
 
@@ -143,6 +166,14 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     ).rejects.toThrow("network error");
 
     expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        message: "network error",
+        attachmentId: "att-1",
+        error: expect.any(Error),
+      }),
+    );
     expect(onAdd).not.toHaveBeenCalled();
     expect(composer.attachments).toHaveLength(1);
     const att = composer.attachments[0]!;
@@ -151,4 +182,36 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
       expect(att.status.reason).toBe("error");
     }
   });
+
+  it("emits attachmentAddError with attachment id when adapter yields an errored attachment", async () => {
+    const composer = makeComposer(
+      makeAdapter({
+        add: async ({ file }) => ({
+          id: "att-2",
+          type: "image",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: { type: "incomplete", reason: "error" },
+        }),
+      }),
+    );
+    const onError = vi.fn();
+    const onAdd = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+    composer.unstable_on("attachmentAdd", onAdd);
+
+    await composer.addAttachment(
+      new File(["x"], "f.png", { type: "image/png" }),
+    );
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        attachmentId: "att-2",
+      }),
+    );
+    expect(onAdd).not.toHaveBeenCalled();
+  });
 });

package/src/tests/groupParts.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildGroupTree,
+  normalizeGroupKey,
+  type GroupNode,
+} from "../react/utils/groupParts";
+
+const asPaths = (keys: readonly (string | readonly string[] | null)[]) =>
+  keys.map((k) => normalizeGroupKey(k));
+
+// Compact tree dump: "G:key#nodeKey[i,j]{...}" | "P:#nodeKey(i)"
+const dump = (nodes: readonly GroupNode[]): string =>
+  nodes
+    .map((n) => {
+      if (n.type === "part") {
+        return `P:#${n.nodeKey}(${n.index})`;
+      }
+      const inner = dump(n.children);
+      return `G:${n.key}#${n.nodeKey}[${n.indices.join(",")}]{${inner}}`;
+    })
+    .join(",");
+
+describe("normalizeGroupKey", () => {
+  it("maps null/undefined/[] to []", () => {
+    expect(normalizeGroupKey(null)).toEqual([]);
+    expect(normalizeGroupKey(undefined)).toEqual([]);
+    expect(normalizeGroupKey([])).toEqual([]);
+  });
+
+  it("wraps a string into a single-element array", () => {
+    expect(normalizeGroupKey("foo")).toEqual(["foo"]);
+  });
+
+  it("passes arrays through", () => {
+    expect(normalizeGroupKey(["a", "b"])).toEqual(["a", "b"]);
+  });
+});
+
+describe("buildGroupTree", () => {
+  it("returns an empty list for no parts", () => {
+    expect(buildGroupTree([])).toEqual([]);
+  });
+
+  it("emits one part leaf per ungrouped part (no coalescing)", () => {
+    const tree = buildGroupTree(asPaths([null, null, null]));
+    expect(dump(tree)).toBe("P:#0(0),P:#1(1),P:#2(2)");
+  });
+
+  it("wraps adjacent same-key parts in one group with one part child each", () => {
+    const tree = buildGroupTree(asPaths(["a", "a", "a"]));
+    expect(dump(tree)).toBe("G:a#0[0,1,2]{P:#0.0(0),P:#0.1(1),P:#0.2(2)}");
+  });
+
+  it("splits non-adjacent runs of the same key into separate groups", () => {
+    const tree = buildGroupTree(asPaths(["a", null, "a"]));
+    expect(dump(tree)).toBe("G:a#0[0]{P:#0.0(0)},P:#1(1),G:a#2[2]{P:#2.0(2)}");
+  });
+
+  it("nests groups: parts at depth 1 sit alongside depth-2 subgroups", () => {
+    // ["A","B"], ["A","B"], ["A"], ["A"], ["A","C"]:
+    // Outer A spans 0..4. Inside A: a B subgroup (0,1), two depth-1 parts
+    // (2,3), then a C subgroup (4).
+    const tree = buildGroupTree(
+      asPaths([["A", "B"], ["A", "B"], ["A"], ["A"], ["A", "C"]]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2,3,4]{G:B#0.0[0,1]{P:#0.0.0(0),P:#0.0.1(1)},P:#0.1(2),P:#0.2(3),G:C#0.3[4]{P:#0.3.0(4)}}",
+    );
+  });
+
+  it("treats longer prefix changes as group close+open", () => {
+    // ["A","B"], ["A","B","C"], ["A","B"]: opens C under B, closes back.
+    const tree = buildGroupTree(
+      asPaths([
+        ["A", "B"],
+        ["A", "B", "C"],
+        ["A", "B"],
+      ]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2]{G:B#0.0[0,1,2]{P:#0.0.0(0),G:C#0.0.1[1]{P:#0.0.1.0(1)},P:#0.0.2(2)}}",
+    );
+  });
+
+  it("does not coalesce same-keyed groups separated by a divergent sibling", () => {
+    const tree = buildGroupTree(
+      asPaths([
+        ["A", "B"],
+        ["A", "C"],
+        ["A", "B"],
+      ]),
+    );
+    expect(dump(tree)).toBe(
+      "G:A#0[0,1,2]{G:B#0.0[0]{P:#0.0.0(0)},G:C#0.1[1]{P:#0.1.0(1)},G:B#0.2[2]{P:#0.2.0(2)}}",
+    );
+  });
+
+  it("accepts strings and arrays interchangeably via normalizeGroupKey", () => {
+    const tree = buildGroupTree([
+      normalizeGroupKey("A"),
+      normalizeGroupKey(["A"]),
+    ]);
+    expect(dump(tree)).toBe("G:A#0[0,1]{P:#0.0(0),P:#0.1(1)}");
+  });
+
+  it("assigns stable nodeKeys under append (existing keys do not shift)", () => {
+    const before = buildGroupTree(asPaths([["A"], null]));
+    const after = buildGroupTree(asPaths([["A"], null, ["B"]]));
+
+    expect(before[0]!.nodeKey).toBe(after[0]!.nodeKey);
+    expect(before[1]!.nodeKey).toBe(after[1]!.nodeKey);
+    expect(after[2]!.nodeKey).toBe("2");
+  });
+});