@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/src/native/__tests__/emoji.test.tsx

@@ -0,0 +1,254 @@
+// @vitest-environment happy-dom
+// @feat:chat
+/// <reference types="vite/client" />
+import pickerSource from "../emoji-picker.tsx?raw";
+import dataSource from "../emoji-data.ts?raw";
+import emojiSource from "../emoji.ts?raw";
+import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ChatMessage } from "../../core/types";
+import { ChatComposer } from "../composer";
+import { clearDrafts, memoryDraftStorage } from "../composer-state";
+import { ChatNativeProvider } from "../context";
+import { ChatEmojiPicker } from "../emoji-picker";
+import { EMOJI_CATEGORIES, emojiEntry, emojiInCategory, insertAtSelection, loadRecentEmoji, pushRecentEmoji, recentEmojiKey, RECENT_EMOJI_MAX, saveRecentEmoji, searchEmoji } from "../emoji";
+import { QUICK_REACTIONS } from "../actions";
+import { MessageActionsSheet } from "../message-actions-sheet";
+import { useChatComposer } from "../use-composer";
+
+// The grids' FlatList props, as the picker gave them.
+const lists = vi.hoisted(() => [] as Record<string, unknown>[]);
+vi.mock("react-native", async (original) => {
+  const rn = await original<Record<string, unknown> & { FlatList: (p: Record<string, unknown>) => unknown }>();
+  return {
+    ...rn,
+    useWindowDimensions: () => ({ width: 390, height: 844, scale: 3, fontScale: 1 }),
+    FlatList: (props: Record<string, unknown>) => {
+      lists.push(props);
+      return rn.FlatList(props);
+    },
+  };
+});
+
+afterEach(cleanup);
+
+describe("the bundled emoji", () => {
+  it("ship in the app: nothing in the picker or its data fetches or names a URL", () => {
+    for (const src of [pickerSource, emojiSource, dataSource.split("\n").slice(9).join("\n")]) {
+      expect(src).not.toMatch(/https?:\/\//);
+      expect(src).not.toMatch(/\bfetch\(|emojibaseUrl|jsdelivr|frimousse/);
+    }
+  });
+
+  it("are every category's base emoji, kept modest", () => {
+    const all = EMOJI_CATEGORIES.flatMap((c) => emojiInCategory(c.id));
+    expect(all.length).toBeGreaterThan(1500);
+    expect(all.length).toBeLessThan(2200);
+    expect(dataSource.length).toBeLessThan(100_000);
+    expect(new Set(all.map((e) => e.emoji)).size).toBe(all.length);
+    expect(emojiInCategory("smileys")[0]).toMatchObject({ emoji: "😀", label: "grinning face" });
+    // No skin-tone variants: those are the base emoji's, chosen elsewhere.
+    expect(all.some((e) => /\u{1F3FB}|\u{1F3FF}/u.test(e.emoji))).toBe(false);
+  });
+
+  it("are found by words of their label or tags", () => {
+    expect(searchEmoji("thumbs up")[0]?.emoji).toBe("👍");
+    expect(searchEmoji("gri").map((e) => e.emoji)).toContain("😀");
+    expect(searchEmoji("red heart").map((e) => e.emoji)).toContain("❤️");
+    expect(searchEmoji("   ")).toEqual([]);
+    expect(searchEmoji("zzzqqq")).toEqual([]);
+    expect(emojiEntry("👍").label).toBe("thumbs up");
+  });
+
+  it("are written as keyboards type them, so a picked reaction counts with the same quick one", () => {
+    for (const quick of QUICK_REACTIONS) expect(emojiEntry(quick).label, quick).not.toBe(quick);
+    const all = EMOJI_CATEGORIES.flatMap((c) => emojiInCategory(c.id));
+    expect(all.some((e) => /\p{Emoji_Presentation}\uFE0F/u.test(e.emoji))).toBe(false);
+    expect(all.map((e) => e.emoji)).toContain("❤️");
+  });
+});
+
+describe("recent emoji", () => {
+  it("put the newest first, once, and keep at most the limit", () => {
+    expect(pushRecentEmoji(["😀", "👍"], "👍")).toEqual(["👍", "😀"]);
+    const many = Array.from({ length: RECENT_EMOJI_MAX }, (_, i) => String(i));
+    expect(pushRecentEmoji(many, "x")).toHaveLength(RECENT_EMOJI_MAX);
+    expect(pushRecentEmoji(many, "x")[0]).toBe("x");
+  });
+
+  it("are kept per person with their drafts, so signing out clears them", async () => {
+    const storage = memoryDraftStorage();
+    await saveRecentEmoji(storage, "u1", ["🎉"]);
+    await saveRecentEmoji(storage, "u2", ["🙂"]);
+    expect(await loadRecentEmoji(storage, "u1")).toEqual(["🎉"]);
+    await clearDrafts(storage, "u1");
+    expect(await storage.getItem(recentEmojiKey("u1"))).toBeNull();
+    expect(await loadRecentEmoji(storage, "u2")).toEqual(["🙂"]);
+  });
+
+  it("survive a corrupt entry as none", async () => {
+    const storage = memoryDraftStorage();
+    await storage.setItem(recentEmojiKey("u1"), "{not json");
+    expect(await loadRecentEmoji(storage, "u1")).toEqual([]);
+  });
+});
+
+describe("insertAtSelection", () => {
+  it("types at the cursor, over a selection, or at the end", () => {
+    expect(insertAtSelection("hello world", { start: 5, end: 5 }, "🙂")).toEqual({ text: "hello🙂 world", cursor: 7 });
+    expect(insertAtSelection("hello world", { start: 6, end: 11 }, "🌍")).toEqual({ text: "hello 🌍", cursor: 8 });
+    expect(insertAtSelection("hi", null, "👋")).toEqual({ text: "hi👋", cursor: 4 });
+    expect(insertAtSelection("hi", { start: 40, end: 50 }, "!")).toEqual({ text: "hi!", cursor: 3 });
+  });
+});
+
+const ME = "u1";
+function textMessage(): ChatMessage {
+  return {
+    id: "m1", conversationId: "c1", seq: 1, clientId: "c", senderId: "u2", senderRole: "member", kind: "text", body: "hi",
+    mentions: [], replyToId: null, threadRootId: null, threadCount: 0, threadLastAt: null, topic: null, visibility: "everyone",
+    silent: false, meta: {}, createdAt: "2026-10-25T10:00:00Z", editedAt: null, deletedAt: null, attachments: [], reactions: [],
+  } as ChatMessage;
+}
+
+describe("the long-press sheet's +", () => {
+  const context = { me: ME, role: "member" as const, canPost: true, pinned: false, canPin: false, canCopy: false };
+
+  it("opens every emoji, searchable, and reacts with the one picked", async () => {
+    const onReact = vi.fn();
+    const onClose = vi.fn();
+    const drafts = memoryDraftStorage();
+    render(
+      <ChatNativeProvider modules={{ drafts }}>
+        <MessageActionsSheet message={textMessage()} context={context} onClose={onClose} onReact={onReact} onAction={vi.fn()} testID="acts" />
+      </ChatNativeProvider>,
+    );
+    const more = await screen.findByTestId("acts-react-more");
+    expect(more.getAttribute("aria-label")).toBe("More reactions");
+    fireEvent.click(more);
+    expect(screen.getByTestId("acts-picker")).toBeTruthy();
+    // Categories are tabs, each named for screen readers.
+    expect(screen.getByTestId("acts-picker-tab-food").getAttribute("aria-label")).toBe("Food and drink");
+    fireEvent.change(screen.getByTestId("acts-picker-search").querySelector("input")!, { target: { value: "party popper" } });
+    const party = await screen.findByTestId("acts-picker-emoji-🎉");
+    expect(party.getAttribute("aria-label")).toBe("party popper");
+    fireEvent.click(party);
+    expect(onReact).toHaveBeenCalledWith(expect.objectContaining({ id: "m1" }), "🎉", true);
+    expect(onClose).toHaveBeenCalled();
+    // Kept as a recent one for this person.
+    await waitFor(async () => expect(await loadRecentEmoji(drafts, ME)).toEqual(["🎉"]));
+  });
+
+  it("shows the person's recent emoji first, under Recent", async () => {
+    const drafts = memoryDraftStorage();
+    await saveRecentEmoji(drafts, "u-recent", ["🦄"]);
+    render(
+      <ChatNativeProvider modules={{ drafts }}>
+        <MessageActionsSheet message={textMessage()} context={{ ...context, me: "u-recent" }} onClose={vi.fn()} onReact={vi.fn()} onAction={vi.fn()} testID="acts" />
+      </ChatNativeProvider>,
+    );
+    fireEvent.click(await screen.findByTestId("acts-react-more"));
+    await screen.findByTestId("acts-picker-tab-recent");
+    expect(screen.getByTestId("acts-picker-tab-recent").getAttribute("aria-selected")).toBe("true");
+    expect(screen.getByTestId("acts-picker-emoji-🦄")).toBeTruthy();
+  });
+});
+
+describe("the long-press sheet's caption", () => {
+  const context = { me: "u1", role: "member" as const, canPost: true, pinned: false, canPin: false, canCopy: false };
+  it("has room under the sheet's top edge, and names an app card by its kind's title", async () => {
+    const message = { ...textMessage(), body: "", attachments: [{ id: "a1", kind: "check_in", ref: {} }] } as unknown as ChatMessage;
+    render(
+      <ChatNativeProvider>
+        <MessageActionsSheet message={message} context={context} onClose={vi.fn()} onReact={vi.fn()} onAction={vi.fn()} attachmentKinds={{ check_in: { title: () => "Check-in" } }} testID="acts" />
+      </ChatNativeProvider>,
+    );
+    const caption = await screen.findByTestId("acts-caption");
+    expect(caption.textContent).toBe("Check-in");
+    const body = JSON.parse(caption.parentElement!.getAttribute("data-style")!) as { paddingTop?: number };
+    expect(body.paddingTop).toBeGreaterThanOrEqual(16);
+  });
+});
+
+function ComposerHarness() {
+  const composer = useChatComposer("c1", null, ME);
+  return <ChatComposer composer={composer} canPost disabledReason={null} role="member" onSend={vi.fn()} userId="u-composer" testID="cmp" />;
+}
+
+describe("the composer's emoji button", () => {
+  it("opens the picker, which types at the cursor", async () => {
+    render(
+      <ChatNativeProvider>
+        <ComposerHarness />
+      </ChatNativeProvider>,
+    );
+    const input = screen.getByTestId("cmp-input") as HTMLInputElement;
+    fireEvent.change(input, { target: { value: "see you" } });
+    const button = screen.getByTestId("cmp-emoji");
+    expect(button.getAttribute("aria-label")).toBe("Add emoji");
+    await act(async () => fireEvent.click(button));
+    fireEvent.click(await screen.findByTestId("cmp-emoji-sheet-picker-emoji-😀"));
+    await waitFor(() => expect(input.value).toBe("see you😀"));
+    fireEvent.click(screen.getByTestId("cmp-emoji-sheet-done"));
+    await waitFor(() => expect(screen.queryByTestId("cmp-emoji-sheet-picker")).toBeNull());
+  });
+});
+
+describe("the picker's grid", () => {
+  it("lays out rows by row index (FlatList with numColumns asks per row), so every row scrolls into place", () => {
+    lists.length = 0;
+    render(
+      <ChatNativeProvider>
+        <ChatEmojiPicker onSelect={vi.fn()} testID="pk" />
+      </ChatNativeProvider>,
+    );
+    const grid = lists.find((p) => p.testID === "pk-grid")!;
+    const columns = grid.numColumns as number;
+    expect(columns).toBe(8);
+    const layout = grid.getItemLayout as (d: unknown, i: number) => { length: number; offset: number };
+    expect(layout(null, 5)).toEqual({ length: 44, offset: 5 * 44, index: 5 });
+    const rows = Math.ceil((grid.data as unknown[]).length / columns);
+    expect(layout(null, rows - 1).offset).toBe((rows - 1) * 44);
+  });
+
+  it("keeps an emoji picked while the stored recents were still loading", async () => {
+    const drafts = memoryDraftStorage();
+    await saveRecentEmoji(drafts, "u-race", ["🍕", "🎸"]);
+    let release!: () => void;
+    const gate = new Promise<void>((r) => (release = r));
+    // Read when asked, answered late: as AsyncStorage does with a write queued behind the read.
+    const slow = {
+      ...drafts,
+      getItem: async (k: string) => {
+        const value = await drafts.getItem(k);
+        await gate;
+        return value;
+      },
+    };
+    render(
+      <ChatNativeProvider modules={{ drafts: slow }}>
+        <ChatEmojiPicker onSelect={vi.fn()} userId="u-race" testID="pk" />
+      </ChatNativeProvider>,
+    );
+    fireEvent.click(screen.getByTestId("pk-emoji-😀"));
+    await act(async () => release());
+    await waitFor(async () => expect(await loadRecentEmoji(drafts, "u-race")).toEqual(["😀", "🍕", "🎸"]));
+  });
+});
+
+describe("the composer's emoji button, picked twice quickly", () => {
+  it("types both", async () => {
+    render(
+      <ChatNativeProvider modules={{ drafts: memoryDraftStorage() }}>
+        <ComposerHarness />
+      </ChatNativeProvider>,
+    );
+    await act(async () => fireEvent.click(screen.getByTestId("cmp-emoji")));
+    const smile = await screen.findByTestId("cmp-emoji-sheet-picker-emoji-😀");
+    act(() => {
+      fireEvent.click(smile);
+      fireEvent.click(smile);
+    });
+    await waitFor(() => expect((screen.getByTestId("cmp-input") as HTMLInputElement).value).toBe("😀😀"));
+  });
+});

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

@@ -0,0 +1,48 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { cleanup, render, waitFor } from "@testing-library/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 { ChatProvider } from "../../react/index";
+import { ChatNativeProvider } from "../context";
+import { ChatInboxScreen } from "../inbox-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";
+
+function fakeClient() {
+  const inbox = vi.fn(async (_opts: Record<string, unknown>) => []);
+  const client = {
+    inbox,
+    subscribeInbox: vi.fn(() => ({ unsubscribe: vi.fn() })),
+    unreadTotal: vi.fn(async () => 0),
+  } as unknown as ChatClient;
+  return { client, inbox };
+}
+
+describe("ChatInboxScreen", () => {
+  it("passes kinds and excludeKinds to the inbox, so an app can keep support tickets out of Messages", async () => {
+    const { client, inbox } = fakeClient();
+    const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    render(
+      <QueryClientProvider client={qc}>
+        <GenesisModulesProvider modules={{}}>
+          <ChatProvider client={client} userId={ME}>
+            <NativeToastProvider>
+              <ChatNativeProvider>
+                <ChatInboxScreen onOpen={() => {}} excludeKinds={["support"]} kinds={["direct", "group"]} />
+              </ChatNativeProvider>
+            </NativeToastProvider>
+          </ChatProvider>
+        </GenesisModulesProvider>
+      </QueryClientProvider>,
+    );
+    await waitFor(() => expect(inbox).toHaveBeenCalled());
+    expect(inbox.mock.calls[0]![0]).toMatchObject({ kinds: ["direct", "group"], excludeKinds: ["support"] });
+  });
+});

package/src/native/__tests__/message-bubble.test.tsx

@@ -0,0 +1,127 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ChatAttachment, ChatMessage, PendingMessage } from "../../core/types";
+import { ChatNativeProvider } from "../context";
+import { MessageBubble } from "../message-bubble";
+import type { ChatNativeModules } from "../modules";
+import { act } from "@testing-library/react";
+import { invertedRows, type ThreadRow } from "../rows";
+
+// The shared React Native shim has no useWindowDimensions; attachments size pictures by it.
+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";
+
+function failedRow(files: PendingMessage["files"]): Extract<ThreadRow, { type: "message" }> {
+  const pending: PendingMessage = {
+    clientId: "c1",
+    input: { conversationId: "conv", clientId: "c1", body: "" },
+    senderId: ME,
+    createdAt: "2026-10-25T10:00:00Z",
+    status: "failed",
+    error: "Attach the file again to send",
+    files,
+  };
+  return invertedRows([{ type: "pending", pending }], { me: ME, group: false }).find((r) => r.type === "message") as Extract<ThreadRow, { type: "message" }>;
+}
+
+function show(row: Extract<ThreadRow, { type: "message" }>, handlers: Partial<Parameters<typeof MessageBubble>[0]> = {}) {
+  render(<MessageBubble row={row} me={ME} urls={{}} group={false} reducedMotion testID="b" {...handlers} />);
+}
+
+describe("a failed message", () => {
+  it("whose file was lost offers Attach again, not Retry, with the files it lost", () => {
+    const onReattach = vi.fn();
+    const files = [{ name: "photo.png", contentType: "image/png", kind: "image", lost: true }];
+    show(failedRow(files), { onReattach, onRetry: vi.fn(), onDiscard: vi.fn() });
+    expect(screen.getByTestId("b-failed").textContent).toBe("Attach the file again to send");
+    expect(screen.queryByTestId("b-retry")).toBeNull();
+    fireEvent.click(screen.getByTestId("b-reattach"));
+    expect(onReattach).toHaveBeenCalledWith("c1", files);
+    expect(screen.getByTestId("b-discard")).toBeTruthy();
+  });
+
+  it("whose files are all still there offers Retry", () => {
+    const onRetry = vi.fn();
+    show(failedRow([{ name: "photo.jpg", contentType: "image/jpeg", kind: "image" }]), { onRetry, onReattach: vi.fn() });
+    expect(screen.queryByTestId("b-reattach")).toBeNull();
+    fireEvent.click(screen.getByTestId("b-retry"));
+    expect(onRetry).toHaveBeenCalledWith("c1");
+  });
+
+  it("draws a pending voice note from PendingMessage.files, with its duration", () => {
+    show(failedRow([{ name: "voice.m4a", contentType: "audio/mp4", kind: "voice", meta: { durationMs: 9000, waveform: [10, 50] } }]));
+    expect(screen.getByTestId("b-voice-0")).toBeTruthy();
+  });
+});
+
+function attachment(id: string, kind: "image" | "voice", path: string): ChatAttachment {
+  return {
+    id, messageId: "m1", position: 0, kind, ref: {}, provider: "storage", path, providerId: null, playbackId: null, url: null, status: "ready",
+    name: kind === "image" ? `${id}.jpg` : "voice.m4a", mime: null, bytes: null, width: 10, height: 10, durationMs: 4000, waveform: [10, 60],
+    posterPath: null, thumbhash: null, transcript: null, transcriptStatus: null,
+  } as ChatAttachment;
+}
+
+function messageRow(attachments: ChatAttachment[]): Extract<ThreadRow, { type: "message" }> {
+  const message = {
+    id: "m1", conversationId: "conv", seq: 1, clientId: "cm1", senderId: "22222222-2222-4222-8222-222222222222", senderRole: "member", kind: "text",
+    body: "look", mentions: [], replyToId: null, threadRootId: null, threadCount: 0, threadLastAt: null, topic: null, visibility: "everyone",
+    silent: false, meta: {}, createdAt: "2026-10-25T10:00:00Z", editedAt: null, deletedAt: null, attachments, reactions: [],
+  } as unknown as ChatMessage;
+  return invertedRows([{ type: "message", message }], { me: ME, group: false }).find((r) => r.type === "message") as Extract<ThreadRow, { type: "message" }>;
+}
+
+function fakeAudio() {
+  const player = { play: vi.fn(), pause: vi.fn(), seekTo: vi.fn(async () => undefined), setPlaybackRate: vi.fn() };
+  const audio = {
+    useAudioRecorder: vi.fn(),
+    useAudioPlayer: vi.fn(() => player),
+    useAudioPlayerStatus: vi.fn(() => ({ currentTime: 0, duration: 4, playing: false, didJustFinish: false, isLoaded: true, playbackRate: 1 })),
+    RecordingPresets: { HIGH_QUALITY: {} },
+    requestRecordingPermissionsAsync: vi.fn(),
+    setAudioModeAsync: vi.fn(),
+  };
+  return { audio: audio as unknown as ChatNativeModules["audio"], player };
+}
+
+const fireA11y = (el: HTMLElement, name: string) => act(() => void el.dispatchEvent(new CustomEvent("accessibilityaction", { detail: name })));
+
+describe("a bubble with media, for VoiceOver", () => {
+  it("carries the hidden controls as its own actions: play and speed for a voice note, open for each photo", () => {
+    const { audio, player } = fakeAudio();
+    const onOpenImage = vi.fn();
+    const urls = { "p/voice.m4a": "https://x/voice.m4a", "p/a.jpg": "https://x/a.jpg", "p/b.jpg": "https://x/b.jpg" };
+    render(
+      <ChatNativeProvider modules={{ audio }}>
+        <MessageBubble
+          row={messageRow([attachment("v", "voice", "p/voice.m4a"), attachment("a", "image", "p/a.jpg"), attachment("b", "image", "p/b.jpg")])}
+          me={ME}
+          urls={urls}
+          group={false}
+          reducedMotion
+          onOpenImage={onOpenImage}
+          onReply={vi.fn()}
+          testID="b"
+        />
+      </ChatNativeProvider>,
+    );
+    const bubble = screen.getByTestId("b-bubble");
+    expect(bubble.getAttribute("data-a11y-actions")).toBe("voice-0,voice-rate-0,photo-0,photo-1,reply");
+    fireA11y(bubble, "photo-1");
+    expect(onOpenImage).toHaveBeenCalledWith("https://x/b.jpg", "Photo, b.jpg");
+    fireA11y(bubble, "voice-0");
+    expect(player.play).toHaveBeenCalledTimes(1);
+    fireA11y(bubble, "voice-rate-0");
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+  });
+
+  it("offers no play action without expo-audio, where the note can't play", () => {
+    render(<MessageBubble row={messageRow([attachment("v", "voice", "p/voice.m4a")])} me={ME} urls={{ "p/voice.m4a": "https://x/v" }} group={false} reducedMotion testID="b" />);
+    expect(screen.getByTestId("b-bubble").getAttribute("data-a11y-actions") ?? "").not.toContain("voice");
+  });
+});

package/src/native/__tests__/organise-logic.test.ts

@@ -0,0 +1,164 @@
+// @feat:chat
+import { describe, expect, it } from "vitest";
+import type { ChatInboxItem, ChatMessage, ChatTopic } from "../../core/types";
+import { availabilityInput, awayLineFor, clockToDate, dateToClock, defaultWeek, formFrom, hoursFromWeek, sameTimeDays, weekFromHours } from "../availability";
+import { broadcastOutcome, broadcastRows } from "../broadcast-sheet";
+import { emptyComposer, type ComposerState } from "../composer-state";
+import { chatNativeCopy } from "../copy";
+import { moderationNote } from "../moderation";
+import { defaultScheduleAt, scheduleInputFrom, withDay, withTime } from "../schedule-sheet";
+import { snippetText } from "../search-screen";
+import { canManageTopics, checkTopicName, topicClosedFor, topicMenuFor } from "../topics";
+import { rowIndexOf } from "../use-jump";
+import type { ThreadRow } from "../rows";
+
+const topic = (key: string, closed = false): ChatTopic => ({
+  conversationId: "c", topic: key, title: key, position: 0, closedAt: closed ? "2026-10-01T00:00:00Z" : null, createdBy: null, createdAt: "2026-10-01T00:00:00Z",
+});
+
+describe("topics", () => {
+  it("are managed by owners and admins only", () => {
+    expect(canManageTopics("owner")).toBe(true);
+    expect(canManageTopics("admin")).toBe(true);
+    expect(canManageTopics("member")).toBe(false);
+    expect(canManageTopics("observer")).toBe(false);
+    expect(canManageTopics(null)).toBe(false);
+  });
+
+  it("closed, take posts only from owners, admins and observers", () => {
+    expect(topicClosedFor(topic("a", true), "member")).toBe(true);
+    expect(topicClosedFor(topic("a", true), "owner")).toBe(false);
+    expect(topicClosedFor(topic("a", true), "admin")).toBe(false);
+    expect(topicClosedFor(topic("a", true), "observer")).toBe(false);
+    expect(topicClosedFor(topic("a"), "member")).toBe(false);
+    expect(topicClosedFor(null, "member")).toBe(false);
+  });
+
+  it("offer New always, and Rename with Close or Reopen for the topic shown", () => {
+    expect(topicMenuFor(null)).toEqual(["new"]);
+    expect(topicMenuFor(topic("a"))).toEqual(["new", "rename", "close"]);
+    expect(topicMenuFor(topic("a", true))).toEqual(["new", "rename", "reopen"]);
+  });
+
+  it("key a new topic from its name, refuse a clash or an empty name, and keep the key on a rename", () => {
+    expect(checkTopicName("Week 1: Habits", [])).toEqual({ key: "week-1-habits" });
+    expect(checkTopicName("  ", [])).toEqual({ error: "empty" });
+    expect(checkTopicName("Week 1: habits!", [topic("week-1-habits")])).toEqual({ error: "exists" });
+    expect(checkTopicName("New name", [topic("week-1-habits")], "week-1-habits")).toEqual({ key: "week-1-habits" });
+  });
+});
+
+describe("scheduled send", () => {
+  const composer = (text: string, files = 0): ComposerState => ({
+    ...emptyComposer,
+    text,
+    attachments: Array.from({ length: files }, (_, i) => ({ key: `k${i}`, file: { data: "file:///a.jpg", name: "a.jpg", contentType: "image/jpeg" } })),
+  }) as ComposerState;
+  const at = new Date("2026-10-26T09:00:00");
+
+  it("schedules what's written, in the topic shown, with its reply and mentions", () => {
+    const state = { ...composer("hi @[Sam](user:22222222-2222-4222-8222-222222222222)"), replyTo: { messageId: "m1", name: "Sam", preview: "x" } } as ComposerState;
+    const made = scheduleInputFrom(state, { conversationId: "c", topic: "week-1", at });
+    expect(made).toEqual({
+      input: { conversationId: "c", body: "hi @[Sam](user:22222222-2222-4222-8222-222222222222)", mentions: ["22222222-2222-4222-8222-222222222222"], replyToId: "m1", topic: "week-1", sendAt: at },
+    });
+  });
+
+  it("won't schedule nothing, or files (native files are URIs; scheduling uploads bytes only)", () => {
+    expect(scheduleInputFrom(composer("   "), { conversationId: "c", at })).toEqual({ error: "empty" });
+    expect(scheduleInputFrom(composer("with a photo", 1), { conversationId: "c", at })).toEqual({ error: "files" });
+  });
+
+  it("starts the custom time an hour ahead on the next five minutes, and sets day and time apart", () => {
+    const d = defaultScheduleAt(new Date("2026-10-25T10:02:30"));
+    expect([d.getHours(), d.getMinutes(), d.getSeconds()]).toEqual([11, 5, 0]);
+    const base = new Date("2026-10-25T14:30:00");
+    const day = withDay(base, new Date("2026-12-01T03:00:00"));
+    expect([day.getMonth(), day.getDate(), day.getHours(), day.getMinutes()]).toEqual([11, 1, 14, 30]);
+    const time = withTime(base, new Date("2020-01-01T08:15:00"));
+    expect([time.getDate(), time.getHours(), time.getMinutes()]).toEqual([25, 8, 15]);
+  });
+});
+
+describe("availability", () => {
+  it("reads saved hours as a week and writes the week back, keeping extra ranges", () => {
+    const saved = { mon: [["09:00", "12:00"], ["13:00", "17:00"]] as [string, string][], wed: [["10:00", "14:00"]] as [string, string][] };
+    const week = weekFromHours(saved);
+    expect(week.mon).toEqual({ on: true, from: "09:00", to: "12:00" });
+    expect(week.tue.on).toBe(false);
+    expect(hoursFromWeek({ ...week, mon: { ...week.mon, from: "08:00" } }, saved)).toEqual({ mon: [["08:00", "12:00"], ["13:00", "17:00"]], wed: [["10:00", "14:00"]] });
+    expect(Object.keys(hoursFromWeek(defaultWeek(), null))).toEqual(["mon", "tue", "wed", "thu", "fri"]);
+  });
+
+  it("refuses a day that starts and ends at the same time", () => {
+    const week = defaultWeek();
+    expect(sameTimeDays(week)).toEqual([]);
+    expect(sameTimeDays({ ...week, tue: { on: true, from: "09:00", to: "09:00" }, sat: { on: false, from: "09:00", to: "09:00" } })).toEqual(["tue"]);
+  });
+
+  it("saves the form as setAvailability expects (blank message and no hours as null)", () => {
+    const until = new Date("2026-11-02T09:00:00Z");
+    const form = { ...formFrom(null, "Europe/London"), message: "  Back Monday ", until, useHours: false };
+    expect(availabilityInput(form, null)).toEqual({ awayMessage: "Back Monday", awayUntil: until.toISOString(), timeZone: "Europe/London", hours: null });
+    expect(availabilityInput({ ...form, message: " ", until: null, useHours: true }, null)).toMatchObject({ awayMessage: null, awayUntil: null, hours: { mon: [["09:00", "17:00"]] } });
+  });
+
+  it("round-trips a clock time through a picker's Date", () => {
+    expect(dateToClock(clockToDate("07:45"))).toBe("07:45");
+    expect(dateToClock(clockToDate("bad"))).toBe("09:00");
+  });
+
+  it("names the other person when away, everyone away in a group, and skips you and observers", () => {
+    const now = new Date("2026-10-25T12:00:00Z");
+    const away = { userId: "sam", awayMessage: "On a retreat", awayUntil: null, timeZone: "UTC", hours: null };
+    const names: Record<string, string> = { me: "Me", sam: "Sam", lee: "Lee", obs: "Obs" };
+    const forUser = (id: string) => (id === "sam" || id === "lee" || id === "obs" || id === "me" ? { ...away, userId: id } : null);
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "sam", role: "member" }], "me", forUser, (id) => names[id]!, now)).toBe("Sam is away: On a retreat");
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "sam", role: "member" }, { userId: "lee", role: "member" }, { userId: "obs", role: "observer" }], "me", forUser, (id) => names[id]!, now)).toBe("Sam and Lee are away");
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "x", role: "member" }], "me", forUser, (id) => id, now)).toBeNull();
+  });
+});
+
+describe("broadcast", () => {
+  const item = (id: string, title: string | null, other: string | null, archived = false) => ({ conversationId: id, title, otherUserId: other, archived }) as ChatInboxItem;
+  it("lists the inbox by name, without archived ones, filtered by the query", () => {
+    const items = [item("1", null, "zoe"), item("2", "Coaching group", null), item("3", null, "amy"), item("4", null, "old", true)];
+    const person = (id: string | null) => (id ? { name: id === "zoe" ? "Zoe" : id === "amy" ? "Amy" : "Old" } : undefined);
+    expect(broadcastRows(items, { person, untitled: "Conversation" }).map((r) => r.title)).toEqual(["Amy", "Coaching group", "Zoe"]);
+    expect(broadcastRows(items, { person, untitled: "Conversation", query: "zo" }).map((r) => r.title)).toEqual(["Zoe"]);
+    expect(broadcastRows(items, { person, untitled: "Conversation", filter: (i) => i.otherUserId !== null }).map((r) => r.title)).toEqual(["Amy", "Zoe"]);
+  });
+
+  it("says how many it reached", () => {
+    expect(broadcastOutcome(3, 3, chatNativeCopy)).toEqual({ title: "Sent to 3 conversations", partial: false });
+    expect(broadcastOutcome(1, 1, chatNativeCopy)).toEqual({ title: "Sent to 1 conversation", partial: false });
+    expect(broadcastOutcome(2, 3, chatNativeCopy)).toEqual({ title: "Sent to 2 of 3. You can't post in the others.", partial: true });
+  });
+});
+
+describe("moderation", () => {
+  const m = (moderation: ChatMessage["moderation"], deletedAt: string | null = null) => ({ moderation, deletedAt });
+  it("tells a hidden message's sender only they see it, and marks hidden and flagged ones for observers", () => {
+    expect(moderationNote(m("hidden"), { mine: true, observer: false })).toBe("hidden-mine");
+    expect(moderationNote(m("hidden"), { mine: false, observer: true })).toBe("hidden");
+    expect(moderationNote(m("flagged"), { mine: false, observer: true })).toBe("flagged");
+    expect(moderationNote(m("flagged"), { mine: true, observer: false })).toBeNull();
+    expect(moderationNote(m(null), { mine: false, observer: true })).toBeNull();
+    expect(moderationNote(m("hidden", "2026-10-01T00:00:00Z"), { mine: true, observer: false })).toBeNull();
+  });
+});
+
+describe("search and jumping", () => {
+  it("reads a snippet without its marks", () => {
+    expect(snippetText("…a «word» here")).toBe("…a word here");
+  });
+  it("finds a message's row past day and unread rows", () => {
+    const rows = [
+      { type: "day", key: "d", label: "Today" },
+      { type: "unread", key: "u" },
+      { type: "message", key: "c1", item: { type: "message", message: { id: "m1" } } },
+    ] as unknown as ThreadRow[];
+    expect(rowIndexOf(rows, "m1")).toBe(2);
+    expect(rowIndexOf(rows, "m9")).toBe(-1);
+  });
+});