@marktiderman/genesis-chat 0.1.1 → 0.2.0

package/src/native/__tests__/push.test.ts

@@ -0,0 +1,209 @@
+// @feat:chat
+import { describe, expect, it, vi } from "vitest";
+import {
+  CHAT_PUSH_CATEGORY,
+  chatNotificationActions,
+  chatPath,
+  chatPushCategory,
+  chatThreadMatch,
+  conversationIdFromData,
+  handleChatPushResponse,
+  registerChatNotificationActions,
+  replyClientId,
+  replyClientIdFor,
+  type ChatPushResponseLike,
+} from "../push";
+import { createOutbox, memoryOutboxStore } from "../../core/outbox";
+import type { ChatClient } from "../../core/client";
+
+const CONV = "6f1d2c3b-4a59-4e8f-9a7b-1c2d3e4f5a6b";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+function response(action: string, extra: Partial<ChatPushResponseLike> = {}, data: Record<string, unknown> = { url: chatPath(CONV), seq: 7 }): ChatPushResponseLike {
+  return { actionIdentifier: action, notification: { request: { identifier: "push-123", content: { data } } }, ...extra };
+}
+
+function fakeClient() {
+  return { send: vi.fn(async () => ({}) as never), markRead: vi.fn(async () => 7) };
+}
+
+describe("the messages category", () => {
+  it("is one preferences category and two actions, neither opening the app", async () => {
+    expect(chatPushCategory()).toMatchObject({ id: "messages", title: "Messages" });
+    const actions = chatNotificationActions();
+    expect(actions.map((a) => a.identifier)).toEqual(["reply", "mark-read"]);
+    expect(actions[0]!.textInput).toEqual({ submitButtonTitle: "Send", placeholder: "Message" });
+    expect(actions.every((a) => a.options.opensAppToForeground === false)).toBe(true);
+    const setNotificationCategoryAsync = vi.fn(async () => undefined);
+    await registerChatNotificationActions({ setNotificationCategoryAsync });
+    expect(setNotificationCategoryAsync).toHaveBeenCalledWith(CHAT_PUSH_CATEGORY, actions);
+  });
+
+  it("registering never throws: a module without categories is reported, not fatal", async () => {
+    const onError = vi.fn();
+    await expect(registerChatNotificationActions({} as never, undefined, onError)).resolves.toBeUndefined();
+    expect(onError).toHaveBeenCalled();
+    const failing = { setNotificationCategoryAsync: () => Promise.reject(new Error("no")) };
+    await expect(registerChatNotificationActions(failing, undefined, onError)).resolves.toBeUndefined();
+  });
+
+  it("finds the conversation in data.conversationId or data.url, nowhere else", () => {
+    expect(conversationIdFromData({ url: `/messages/${CONV}` })).toBe(CONV);
+    expect(conversationIdFromData({ url: `/messages/${CONV}?x=1` })).toBe(CONV);
+    expect(conversationIdFromData({ conversationId: CONV.toUpperCase() })).toBe(CONV);
+    expect(conversationIdFromData({ url: "https://evil.example/messages/" + CONV })).toBeNull();
+    expect(conversationIdFromData({ url: "/messages/not-an-id" })).toBeNull();
+    expect(conversationIdFromData(null)).toBeNull();
+  });
+});
+
+describe("handleChatPushResponse", () => {
+  it("Reply sends the typed text with a client id from the notification, and marks read", async () => {
+    const client = fakeClient();
+    const dismissNotificationAsync = vi.fn(async () => undefined);
+    const outcome = await handleChatPushResponse(response("reply", { userText: "  on my way " }), { client, notifications: { dismissNotificationAsync } });
+    expect(outcome).toBe("replied");
+    expect(client.send).toHaveBeenCalledWith({ conversationId: CONV, clientId: replyClientIdFor("push-123", { url: chatPath(CONV), seq: 7 }, "on my way"), body: "on my way" });
+    expect(client.markRead).toHaveBeenCalledWith(CONV);
+    expect(dismissNotificationAsync).toHaveBeenCalledWith("push-123");
+  });
+
+  it("replying twice from the same notification uses the same client id (the server posts it once)", async () => {
+    const client = fakeClient();
+    await handleChatPushResponse(response("reply", { userText: "yes" }), { client });
+    await handleChatPushResponse(response("reply", { userText: "yes" }), { client });
+    const ids = client.send.mock.calls.map((c) => (c as unknown as [{ clientId: string }])[0].clientId);
+    expect(ids[0]).toBe(ids[1]);
+    expect(ids[0]).toMatch(UUID);
+  });
+
+  it("Mark read marks up to the pushed message", async () => {
+    const client = fakeClient();
+    expect(await handleChatPushResponse(response("mark-read"), { client })).toBe("marked-read");
+    expect(client.markRead).toHaveBeenCalledWith(CONV, 7);
+    expect(client.send).not.toHaveBeenCalled();
+  });
+
+  it("reads the data createChatRunner sends: conversationId and seq, and a seq that is null", async () => {
+    const client = fakeClient();
+    const data = { url: chatPath(CONV), conversationId: CONV, messageId: "m1", seq: 12 };
+    expect(await handleChatPushResponse(response("mark-read", {}, data), { client })).toBe("marked-read");
+    expect(client.markRead).toHaveBeenLastCalledWith(CONV, 12);
+    await handleChatPushResponse(response("mark-read", {}, { conversationId: CONV, seq: null }), { client });
+    expect(client.markRead).toHaveBeenLastCalledWith(CONV, undefined);
+  });
+
+  it("leaves taps, empty replies and other pushes alone", async () => {
+    const client = fakeClient();
+    expect(await handleChatPushResponse(response("expo.modules.notifications.actions.DEFAULT"), { client })).toBe("ignored");
+    expect(await handleChatPushResponse(response("reply", { userText: "   " }), { client })).toBe("ignored");
+    expect(await handleChatPushResponse(response("reply", { userText: "hi" }, { url: "/settings" }), { client })).toBe("ignored");
+    expect(client.send).not.toHaveBeenCalled();
+  });
+
+  it("two replies under one notification id (iOS collapses pushes) get two client ids", async () => {
+    const client = fakeClient();
+    await handleChatPushResponse(response("reply", { userText: "yes" }, { conversationId: CONV, messageId: "m1" }), { client });
+    await handleChatPushResponse(response("reply", { userText: "yes" }, { conversationId: CONV, messageId: "m2" }), { client });
+    // No messageId: the text tells them apart.
+    await handleChatPushResponse(response("reply", { userText: "one" }, { conversationId: CONV }), { client });
+    await handleChatPushResponse(response("reply", { userText: "two" }, { conversationId: CONV }), { client });
+    const ids = client.send.mock.calls.map((c) => (c as unknown as [{ clientId: string }])[0].clientId);
+    expect(new Set(ids).size).toBe(4);
+    for (const id of ids) expect(id).toMatch(UUID);
+  });
+
+  it("with the live outbox, the reply is queued there, once, and an offline one waits failed instead of being lost", async () => {
+    const client = fakeClient();
+    client.send.mockRejectedValue(new Error("Network request failed"));
+    const store = memoryOutboxStore();
+    const outbox = createOutbox({ client: client as unknown as ChatClient, userId: "u1", store });
+    const r = response("reply", { userText: "on my way" }, { conversationId: CONV, messageId: "m1" });
+    expect(await handleChatPushResponse(r, { client, outbox })).toBe("queued");
+    expect(await handleChatPushResponse(r, { client, outbox: () => outbox })).toBe("queued");
+    expect(client.markRead).not.toHaveBeenCalled();
+    expect(outbox.pending(CONV)[0]?.status).toBe("failed");
+    expect(outbox.pending(CONV)).toHaveLength(1);
+    expect(outbox.pending(CONV)[0]).toMatchObject({ input: { body: "on my way", clientId: replyClientIdFor("push-123", r.notification.request.content.data, "on my way") } });
+    expect(await store.load()).toHaveLength(1);
+  });
+
+  it("with the live outbox online, waits for the reply to go, then marks read", async () => {
+    const client = fakeClient();
+    const outbox = createOutbox({ client: client as unknown as ChatClient, userId: "u1", store: memoryOutboxStore() });
+    const r = response("reply", { userText: "on my way" }, { conversationId: CONV, messageId: "m1" });
+    expect(await handleChatPushResponse(r, { client, outbox })).toBe("replied");
+    expect(client.send).toHaveBeenCalledTimes(1);
+    expect(client.markRead).toHaveBeenCalledWith(CONV);
+    expect(outbox.pending(CONV)).toHaveLength(0);
+  });
+
+  it("when the chat screens open while a direct send fails, the reply goes to their outbox, not behind its back", async () => {
+    const client = fakeClient();
+    const store = memoryOutboxStore();
+    const outbox = createOutbox({ client: client as unknown as ChatClient, userId: "u1", store });
+    let live: typeof outbox | null = null;
+    client.send.mockImplementationOnce(async () => {
+      live = outbox; // Messages mounted meanwhile.
+      throw new Error("Network request failed");
+    });
+    client.send.mockRejectedValue(new Error("Network request failed"));
+    const r = response("reply", { userText: "on my way" }, { conversationId: CONV });
+    expect(await handleChatPushResponse(r, { client, outbox: () => live, store, userId: "u1" })).toBe("queued");
+    expect(outbox.pending(CONV)).toHaveLength(1);
+    expect(await store.load()).toHaveLength(1);
+  });
+
+  it("without the live outbox, a reply that can't be sent is added to the saved outbox, once, for Retry", async () => {
+    const client = fakeClient();
+    client.send.mockRejectedValue(new Error("Network request failed"));
+    const store = memoryOutboxStore();
+    await store.save([]);
+    const r = response("reply", { userText: "on my way" }, { conversationId: CONV, messageId: "m1" });
+    const onError = vi.fn();
+    expect(await handleChatPushResponse(r, { client, store, userId: "u1", onError })).toBe("queued");
+    expect(await handleChatPushResponse(r, { client, store, userId: "u1" })).toBe("queued");
+    const saved = await store.load();
+    expect(saved).toHaveLength(1);
+    expect(saved[0]).toMatchObject({ status: "failed", senderId: "u1", input: { conversationId: CONV, body: "on my way" } });
+    expect(client.markRead).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalled();
+    // The outbox the chat screens open later shows it, and Retry sends it with the same client id.
+    client.send.mockResolvedValue({} as never);
+    const outbox = createOutbox({ client: client as unknown as ChatClient, userId: "u1", store });
+    await outbox.load();
+    expect(outbox.pending(CONV)).toHaveLength(1);
+    await outbox.retry(saved[0]!.clientId);
+    await vi.waitFor(() => expect(outbox.pending(CONV)).toHaveLength(0));
+    expect(client.send).toHaveBeenLastCalledWith(expect.objectContaining({ clientId: saved[0]!.clientId, body: "on my way" }));
+  });
+
+  it("never throws: a failed send is the outcome, reported", async () => {
+    const client = fakeClient();
+    client.send.mockRejectedValueOnce(new Error("offline"));
+    const onError = vi.fn();
+    expect(await handleChatPushResponse(response("reply", { userText: "hi" }), { client, onError })).toBe("failed");
+    expect(onError).toHaveBeenCalled();
+  });
+});
+
+describe("replyClientId", () => {
+  it("keeps a uuid, and hashes anything else into a stable valid one", () => {
+    expect(replyClientId(CONV.toUpperCase())).toBe(CONV);
+    const a = replyClientId("0:1729845612:com.example/notif-42");
+    expect(a).toMatch(UUID);
+    expect(a[14]).toBe("8");
+    expect(["8", "9", "a", "b"]).toContain(a[19]);
+    expect(replyClientId("0:1729845612:com.example/notif-42")).toBe(a);
+    expect(replyClientId("0:1729845612:com.example/notif-43")).not.toBe(a);
+  });
+});
+
+describe("chatThreadMatch", () => {
+  it("matches only the open conversation's pushes", () => {
+    const match = chatThreadMatch(CONV)!;
+    expect(match({ url: chatPath(CONV) })).toBe(true);
+    expect(match({ url: chatPath("7f1d2c3b-4a59-4e8f-9a7b-1c2d3e4f5a6b") })).toBe(false);
+    expect(chatThreadMatch(null)).toBeNull();
+  });
+});

package/src/native/__tests__/recorder-machine.test.ts

@@ -0,0 +1,96 @@
+// @feat:chat
+import { describe, expect, it } from "vitest";
+import { idleRecorder, liveBars, recorderStep, type RecorderEvent, type RecorderState } from "../recorder-machine";
+
+const config = { limitMs: 10_000 };
+
+function run(events: RecorderEvent[], from: RecorderState = idleRecorder) {
+  let state = from;
+  const effects: string[] = [];
+  for (const e of events) {
+    const step = recorderStep(state, e, config);
+    state = step.state;
+    effects.push(...step.effects.map((x) => (x.type === "haptic" ? `haptic:${x.event}` : x.type)));
+  }
+  return { state, effects };
+}
+
+describe("recorderStep", () => {
+  it("hold, record, release: sends", () => {
+    const { state, effects } = run([
+      { type: "press" },
+      { type: "ready" },
+      { type: "tick", durationMs: 500, meteringDb: -20 },
+      { type: "tick", durationMs: 1500, meteringDb: -10 },
+      { type: "release" },
+    ]);
+    expect(effects).toEqual(["prepare", "record", "haptic:record-start", "signal", "signal", "signal", "finish", "haptic:send"]);
+    expect(state.phase).toBe("finishing");
+    expect(state.levels).toEqual([-20, -10]);
+    expect(run([{ type: "finished" }], state).state).toEqual(idleRecorder);
+  });
+
+  it("a tap is too short: dropped, with a hint", () => {
+    const { state, effects } = run([{ type: "press" }, { type: "ready" }, { type: "tick", durationMs: 200 }, { type: "release" }]);
+    expect(effects.at(-1)).toBe("discard");
+    expect(state).toMatchObject({ phase: "idle", notice: "too-short" });
+  });
+
+  it("let go before the microphone was ready: nothing records", () => {
+    const { state, effects } = run([{ type: "press" }, { type: "release" }, { type: "ready" }]);
+    expect(effects).toEqual(["prepare", "discard"]);
+    expect(state).toMatchObject({ phase: "idle", notice: "too-short" });
+  });
+
+  it("slide left: arms at half way, cancels past the line", () => {
+    let r = run([{ type: "press" }, { type: "ready" }, { type: "tick", durationMs: 2000 }, { type: "move", dx: -70, dy: 0 }]);
+    expect(r.state.cancelArmed).toBe(true);
+    r = run([{ type: "release" }], r.state);
+    expect(r.effects).toEqual(["discard", "haptic:record-cancel"]);
+    expect(r.state.phase).toBe("idle");
+    const past = run([{ type: "press" }, { type: "ready" }, { type: "move", dx: -130, dy: 0 }]);
+    expect(past.state.phase).toBe("idle");
+    expect(past.effects.slice(-2)).toEqual(["discard", "haptic:record-cancel"]);
+  });
+
+  it("slide up: locks; letting go keeps recording; send or delete ends it", () => {
+    let r = run([{ type: "press" }, { type: "ready" }, { type: "move", dx: 0, dy: -90 }]);
+    expect(r.state.locked).toBe(true);
+    expect(r.effects.at(-1)).toBe("haptic:record-lock");
+    r = run([{ type: "release" }, { type: "move", dx: -500, dy: 0 }, { type: "tick", durationMs: 3000 }], r.state);
+    expect(r.state.phase).toBe("recording");
+    const sent = run([{ type: "send" }], r.state);
+    expect(sent.state.phase).toBe("finishing");
+    expect(sent.effects).toEqual(["finish", "haptic:send"]);
+    const deleted = run([{ type: "cancel" }], r.state);
+    expect(deleted.state.phase).toBe("idle");
+    expect(deleted.effects).toEqual(["discard", "haptic:record-cancel"]);
+  });
+
+  it("reaching the limit sends", () => {
+    const { state, effects } = run([{ type: "press" }, { type: "ready" }, { type: "tick", durationMs: 10_000 }]);
+    expect(state.phase).toBe("finishing");
+    expect(effects.slice(-2)).toEqual(["finish", "haptic:send"]);
+  });
+
+  it("no microphone permission: back to idle, saying so", () => {
+    const { state, effects } = run([{ type: "press" }, { type: "failed", reason: "denied" }]);
+    expect(state).toMatchObject({ phase: "idle", notice: "denied" });
+    expect(effects).toEqual(["prepare", "discard", "haptic:error"]);
+  });
+
+  it("ignores events that don't apply", () => {
+    expect(recorderStep(idleRecorder, { type: "release" }, config).state).toBe(idleRecorder);
+    expect(recorderStep(idleRecorder, { type: "tick", durationMs: 9 }, config).effects).toEqual([]);
+    const finishing = { ...idleRecorder, phase: "finishing" as const };
+    expect(recorderStep(finishing, { type: "cancel" }, config).state).toBe(finishing);
+    expect(recorderStep(finishing, { type: "press" }, config).state).toBe(finishing);
+  });
+});
+
+describe("liveBars", () => {
+  it("pads on the left and maps dB to 0..1", () => {
+    expect(liveBars([-60, 0, -30], 5)).toEqual([0, 0, 0, 1, 0.5]);
+    expect(liveBars([-Infinity], 1)).toEqual([0]);
+  });
+});

package/src/native/__tests__/rows-actions.test.ts

@@ -0,0 +1,76 @@
+// @feat:chat
+import { describe, expect, it } from "vitest";
+import type { ThreadItem } from "../../core/thread";
+import type { ChatMessage } from "../../core/types";
+import { messageActionsFor, canReactTo } from "../actions";
+import { buildThreadRows, invertedRows } from "../rows";
+
+const ME = "me";
+let n = 0;
+function msg(sender: string, at: string, extra: Partial<ChatMessage> = {}): ChatMessage {
+  n++;
+  return {
+    id: `m${n}`, conversationId: "c", seq: n, clientId: `cl${n}`, senderId: sender, senderRole: "member", kind: "text", body: `b${n}`,
+    mentions: [], replyToId: null, threadRootId: null, threadCount: 0, threadLastAt: null, topic: null, visibility: "everyone",
+    silent: false, meta: {}, createdAt: at, editedAt: null, deletedAt: null, attachments: [], reactions: [], ...extra,
+  };
+}
+const item = (m: ChatMessage): ThreadItem => ({ type: "message", message: m });
+
+describe("thread rows", () => {
+  const a = msg("sam", "2026-10-24T09:00:00");
+  const b = msg("sam", "2026-10-24T09:01:00");
+  const c = msg(ME, "2026-10-24T09:02:00");
+  const d = msg("lee", "2026-10-25T08:00:00");
+  const items = [a, b, c, d].map(item);
+
+  it("puts a day separator before each day and the New line before the first unread", () => {
+    const rows = buildThreadRows(items, { me: ME, firstUnreadId: d.id, group: true, now: new Date("2026-10-25T12:00:00") });
+    expect(rows.map((r) => r.type)).toEqual(["day", "message", "message", "message", "day", "unread", "message"]);
+    expect(rows[0]).toMatchObject({ label: "Yesterday" });
+    expect(rows[4]).toMatchObject({ label: "Today" });
+  });
+
+  it("in a group: the name over the first of a run, the avatar beside the last, never on mine", () => {
+    const rows = buildThreadRows(items, { me: ME, group: true }).filter((r) => r.type === "message");
+    expect(rows.map((r) => [r.showName, r.showAvatar])).toEqual([
+      [true, false],
+      [false, true],
+      [false, false],
+      [true, true],
+    ]);
+    const direct = buildThreadRows(items, { me: ME, group: false }).filter((r) => r.type === "message");
+    expect(direct.every((r) => !r.showName && !r.showAvatar)).toBe(true);
+  });
+
+  it("is newest first for the inverted list, keyed by client id (a send that lands keeps its row)", () => {
+    const rows = invertedRows(items, { me: ME, group: false });
+    expect(rows[0]).toMatchObject({ type: "message", key: `c:${d.clientId}` });
+    const pending: ThreadItem = { type: "pending", pending: { clientId: d.clientId, input: { conversationId: "c", clientId: d.clientId }, senderId: ME, createdAt: d.createdAt, status: "sending" } };
+    expect(invertedRows([pending], { me: ME, group: false }).find((r) => r.type === "message")!.key).toBe(`c:${d.clientId}`);
+  });
+});
+
+describe("messageActionsFor", () => {
+  const base = { me: ME, role: "member" as const, canPost: true, pinned: false, canPin: false, canCopy: true };
+
+  it("a member's own message: reply, copy, delete; no pin where the kind doesn't allow it", () => {
+    expect(messageActionsFor(msg(ME, "2026-10-24T09:00:00"), base)).toEqual(["reply", "copy", "delete"]);
+  });
+
+  it("someone else's: no delete for a member; an admin may pin and delete", () => {
+    const theirs = msg("sam", "2026-10-24T09:00:00");
+    expect(messageActionsFor(theirs, base)).toEqual(["reply", "copy"]);
+    expect(messageActionsFor(theirs, { ...base, role: "admin", canPin: true, pinned: true })).toEqual(["reply", "copy", "unpin", "delete"]);
+    expect(messageActionsFor(theirs, { ...base, canPin: true })).toEqual(["reply", "copy", "pin"]);
+  });
+
+  it("a read-only viewer can only copy; deleted and system messages offer nothing", () => {
+    const theirs = msg("sam", "2026-10-24T09:00:00");
+    expect(messageActionsFor(theirs, { ...base, role: "observer", canPost: false })).toEqual(["copy"]);
+    expect(canReactTo(theirs, { canPost: false })).toBe(false);
+    expect(messageActionsFor(msg(ME, "2026-10-24T09:00:00", { deletedAt: "x" }), base)).toEqual([]);
+    expect(messageActionsFor(msg("sam", "2026-10-24T09:00:00", { kind: "system" }), { ...base, role: "owner" })).toEqual([]);
+    expect(messageActionsFor(msg(ME, "2026-10-24T09:00:00", { body: "" }), { ...base, canCopy: true })).toEqual(["reply", "delete"]);
+  });
+});

package/src/native/__tests__/thread-layout.test.ts

@@ -0,0 +1,41 @@
+// @feat:chat
+import { describe, expect, it } from "vitest";
+import { chatThreadStackOptions } from "../stack-options";
+import { barsThatFit, waveformBars } from "../voice-player";
+
+describe("chatThreadStackOptions", () => {
+  it("keeps the bar opaque, so the inverted list never sits under iOS's see-through bar", () => {
+    const opts = chatThreadStackOptions({ headerTitle: "Lin" }, "#f2f2f7");
+    expect(opts).toMatchObject({ title: "Lin", headerTransparent: false, headerStyle: { backgroundColor: "#f2f2f7" } });
+    expect(opts.headerLargeTitle).toBeUndefined();
+  });
+
+  it("never turns on a large title, which would collapse into the flipped list", () => {
+    expect(chatThreadStackOptions({ headerTitle: "Lin", large: true }, "#fff").headerLargeTitle).toBeUndefined();
+  });
+
+  it("lets the app's own header options win", () => {
+    const opts = chatThreadStackOptions({ headerTitle: "Lin", headerOptions: { headerStyle: { backgroundColor: "red" } } }, "#fff");
+    expect(opts.headerStyle).toEqual({ backgroundColor: "red" });
+  });
+});
+
+describe("barsThatFit", () => {
+  it("fits one 3-point bar and a 2-point gap each across the width", () => {
+    expect(barsThatFit(98)).toBe(20);
+    expect(barsThatFit(3)).toBe(1);
+  });
+
+  it("draws one bar before the width is known", () => {
+    expect(barsThatFit(0)).toBe(1);
+    expect(barsThatFit(Number.NaN)).toBe(1);
+  });
+
+  it("never asks for more bars than the slot holds", () => {
+    for (const width of [40, 78, 98, 140]) {
+      const n = barsThatFit(width);
+      expect(n * 3 + (n - 1) * 2).toBeLessThanOrEqual(width);
+      expect(waveformBars([10, 50, 90], n)).toHaveLength(n);
+    }
+  });
+});

package/src/native/__tests__/thread-screen.test.tsx

@@ -0,0 +1,116 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act, cleanup, render, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { GenesisModulesProvider, NativeToastProvider } from "@marktiderman/genesis-ui-native/components";
+import type { ChatClient } from "../../core/client";
+import type { ChatMessage } from "../../core/types";
+import { ChatProvider } from "../../react/index";
+import { ChatNativeProvider } from "../context";
+import type { ThreadRow } from "../rows";
+import { nearBottom, ChatThreadScreen, threadListMode } from "../thread-screen";
+
+vi.mock("react-native", async (original) => ({ ...(await original<object>()), useWindowDimensions: () => ({ width: 390, height: 844, scale: 3, fontScale: 1 }) }));
+
+afterEach(cleanup);
+
+const ME = "11111111-1111-4111-8111-111111111111";
+const SAM = "22222222-2222-4222-8222-222222222222";
+const CONV = "33333333-3333-4333-8333-333333333333";
+
+function msg(seq: number, senderId: string, createdAt: string): ChatMessage {
+  return {
+    id: `m${seq}`, conversationId: CONV, seq, clientId: `c${seq}`, senderId, senderRole: "member", kind: "text", body: `body ${seq}`,
+    mentions: [], replyToId: null, threadRootId: null, threadCount: 0, threadLastAt: null, topic: null, visibility: "everyone",
+    silent: false, meta: {}, createdAt, editedAt: null, deletedAt: null, attachments: [], reactions: [],
+  } as ChatMessage;
+}
+
+function fakeClient(messages: ChatMessage[], lastReadSeq: number): ChatClient {
+  const sub = { unsubscribe: vi.fn(), typing: vi.fn(), recording: vi.fn(), send: vi.fn() };
+  return {
+    conversation: vi.fn(async () => ({ id: CONV, kind: "direct", title: null, settings: {}, status: "open", archivedAt: null })),
+    members: vi.fn(async () => [
+      { conversationId: CONV, userId: ME, role: "member", lastReadSeq, joinedAt: "2026-10-01T00:00:00Z" },
+      { conversationId: CONV, userId: SAM, role: "member", lastReadSeq: 9, joinedAt: "2026-10-01T00:00:00Z" },
+    ]),
+    kind: vi.fn(async () => ({ kind: "direct", label: "Direct", maxMembers: 2 })),
+    myRole: vi.fn(async () => "member"),
+    canPost: vi.fn(async () => true),
+    messages: vi.fn(async () => ({ messages, hasEarlier: true })),
+    message: vi.fn(async () => null),
+    subscribeConversation: vi.fn(() => sub),
+    subscribeInbox: vi.fn(() => ({ unsubscribe: vi.fn() })),
+    markRead: vi.fn(async () => 0),
+    pins: vi.fn(async () => []),
+    fileUrls: vi.fn(async () => ({})),
+  } as unknown as ChatClient;
+}
+
+/** A list that records what it was given (the app's FlashList, as GenesisNativeApp passes it). */
+function recordingList() {
+  const seen: { props: Record<string, unknown> }[] = [];
+  function List(props: Record<string, unknown>) {
+    seen.push({ props });
+    return null;
+  }
+  return { List, last: () => seen.at(-1)!.props };
+}
+
+function wrap(client: ChatClient, list: unknown, children: ReactNode) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return (
+    <QueryClientProvider client={qc}>
+      <GenesisModulesProvider modules={{ list: list as never }}>
+        <ChatProvider client={client} userId={ME}>
+          <NativeToastProvider>
+            <ChatNativeProvider>{children}</ChatNativeProvider>
+          </NativeToastProvider>
+        </ChatProvider>
+      </GenesisModulesProvider>
+    </QueryClientProvider>
+  );
+}
+
+describe("ChatThreadScreen's list", () => {
+  it("is oldest first and upright, so VoiceOver reads each day's heading and the New messages line before their messages", async () => {
+    const messages = [msg(1, SAM, "2026-10-23T09:00:00Z"), msg(2, ME, "2026-10-23T09:01:00Z"), msg(3, SAM, "2026-10-24T10:00:00Z"), msg(4, SAM, "2026-10-24T10:01:00Z")];
+    const list = recordingList();
+    render(wrap(fakeClient(messages, 3), list.List, <ChatThreadScreen conversationId={CONV} />));
+    await waitFor(() => expect((list.last().data as ThreadRow[] | undefined)?.some((r) => r.type === "unread")).toBe(true));
+    const rows = list.last().data as ThreadRow[];
+    const shape = rows.map((r) => (r.type === "message" ? (r.item.type === "message" ? r.item.message.id : "pending") : r.type));
+    expect(shape).toEqual(["day", "m1", "m2", "day", "m3", "unread", "m4"]);
+    expect(list.last().inverted).toBeFalsy();
+  });
+
+  it("uses FlashList's bottom-anchored chat mode, never the autoscrollToTopThreshold FlashList 2 ignores, and loads earlier at the top", async () => {
+    const list = recordingList();
+    render(wrap(fakeClient([msg(1, SAM, "2026-10-24T10:00:00Z")], 0), list.List, <ChatThreadScreen conversationId={CONV} />));
+    await waitFor(() => expect((list.last().data as ThreadRow[] | undefined)?.length).toBeGreaterThan(0));
+    const mvcp = list.last().maintainVisibleContentPosition as Record<string, unknown>;
+    expect(mvcp).toMatchObject({ startRenderingFromBottom: true, autoscrollToBottomThreshold: 0.2 });
+    expect(mvcp).not.toHaveProperty("autoscrollToTopThreshold");
+    expect(typeof list.last().onStartReached).toBe("function");
+    expect(list.last().onEndReached).toBeUndefined();
+    // "Load earlier" sits at the top, over the oldest message.
+    expect(list.last().ListHeaderComponent).toBeTruthy();
+  });
+});
+
+describe("threadListMode", () => {
+  it("follows new rows by hand only on FlatList, which keeps its place for earlier rows", () => {
+    expect(threadListMode(true, false)).toMatchObject({ followsByHand: false });
+    expect(threadListMode(true, true).maintainVisibleContentPosition).toMatchObject({ animateAutoScrollToBottom: false });
+    expect(threadListMode(false, false)).toEqual({ followsByHand: true, maintainVisibleContentPosition: { minIndexForVisible: 0 } });
+  });
+
+  it("counts a position within the slack of the end as the bottom", () => {
+    const at = (y: number) => ({ contentOffset: { y }, contentSize: { height: 2000 }, layoutMeasurement: { height: 800 } });
+    expect(nearBottom(at(1200))).toBe(true);
+    expect(nearBottom(at(1100))).toBe(true);
+    expect(nearBottom(at(900))).toBe(false);
+  });
+});