@marktiderman/genesis-chat 0.2.0 → 0.2.2

package/migrations/0003_genesis_chat_search_threads.sql

@@ -0,0 +1,85 @@
+-- Genesis Chat 0003: a search hit inside a reply thread says which thread
+--
+-- Builds on 0001 and 0002 (never edited once released). genesis_chat.search_messages now also
+-- returns thread_root_id, so the app opens the thread a reply lives in instead of reporting the
+-- message missing. A return type can't change in place, so the function is dropped and made
+-- again, with its grants given again by name.
+--
+-- Also: any change to a message's moderation (a moderator job, an admin edit, not only
+-- moderate_message) sends readers a live hint, so a hidden message updates without a relaunch.
+--
+-- Use: `genesis add chat` copies this after 0002. Verify: tests/0003_genesis_chat_search_threads.test.sql.
+
+-- Messages (and voice or video transcripts) you can read that match `p_query`, newest first.
+-- Within one conversation, or across all of yours. The snippet marks matches with « and »; the
+-- text's own « and » become ‹ and › first, so a message can't fake a highlight. A reply in a
+-- thread carries its thread_root_id.
+drop function genesis_chat.search_messages(text, uuid, integer);
+create function genesis_chat.search_messages(p_query text, p_conversation_id uuid default null, p_limit integer default 30)
+returns table (message_id uuid, conversation_id uuid, seq bigint, sender_id uuid, created_at timestamptz, snippet text, in_transcript boolean, thread_root_id uuid)
+language plpgsql
+stable
+security definer
+set search_path = ''
+as $$
+declare
+  q tsquery;
+begin
+  if auth.uid() is null or length(btrim(coalesce(p_query, ''))) < 2 then
+    return;
+  end if;
+  q := websearch_to_tsquery('simple', p_query);
+  return query
+  with mine as (
+    select me.conversation_id from genesis_chat.members me
+     where me.user_id = auth.uid() and me.left_at is null and me.role <> 'observer'
+       and (p_conversation_id is null or me.conversation_id = p_conversation_id)
+    union
+    select p_conversation_id where p_conversation_id is not null and genesis_chat.i_observe(p_conversation_id)
+  ), hits as (
+    select m.id, m.conversation_id, m.seq, m.sender_id, m.created_at,
+           ts_headline('simple', translate(m.body, '«»', '‹›'), q, 'MaxWords=18, MinWords=6, StartSel=«, StopSel=»') as snippet, false as in_transcript,
+           m.thread_root_id
+      from genesis_chat.messages m join mine using (conversation_id)
+     where m.search @@ q and m.deleted_at is null
+       and (m.visibility = 'everyone' or genesis_chat.i_observe(m.conversation_id))
+       and (m.moderation is distinct from 'hidden' or m.sender_id = auth.uid() or genesis_chat.i_observe(m.conversation_id))
+    union all
+    select m.id, m.conversation_id, m.seq, m.sender_id, m.created_at,
+           ts_headline('simple', translate(a.transcript, '«»', '‹›'), q, 'MaxWords=18, MinWords=6, StartSel=«, StopSel=»'), true,
+           m.thread_root_id
+      from genesis_chat.attachments a
+      join genesis_chat.messages m on m.id = a.message_id
+      join mine on mine.conversation_id = m.conversation_id
+     where a.transcript is not null and a.transcript_search @@ q and m.deleted_at is null
+       and (m.visibility = 'everyone' or genesis_chat.i_observe(m.conversation_id))
+       and (m.moderation is distinct from 'hidden' or m.sender_id = auth.uid() or genesis_chat.i_observe(m.conversation_id))
+  )
+  select distinct on (h.created_at, h.id) h.id, h.conversation_id, h.seq, h.sender_id, h.created_at, h.snippet, h.in_transcript, h.thread_root_id
+    from hits h
+   order by h.created_at desc, h.id
+   limit least(greatest(coalesce(p_limit, 30), 1), 100);
+end;
+$$;
+
+revoke execute on function genesis_chat.search_messages(text, uuid, integer) from public, anon;
+grant execute on function genesis_chat.search_messages(text, uuid, integer) to authenticated, service_role;
+
+-- ── Moderation changes reach readers live ─────────────────────────────────────
+
+create or replace function genesis_chat.message_moderation_changed()
+returns trigger
+language plpgsql
+security definer
+set search_path = ''
+as $$
+begin
+  perform genesis_chat.broadcast('genesis-chat:conv:' || new.conversation_id, 'message',
+    jsonb_build_object('id', new.id, 'seq', new.seq, 'conversation_id', new.conversation_id, 'op', 'update'));
+  return null;
+end;
+$$;
+revoke execute on function genesis_chat.message_moderation_changed() from public, anon, authenticated;
+create trigger messages_moderation_changed after update of moderation on genesis_chat.messages
+  for each row when (new.moderation is distinct from old.moderation)
+  execute function genesis_chat.message_moderation_changed();

package/migrations/tests/0002_genesis_chat_coaching.test.sql

@@ -6,7 +6,7 @@
 -- People: a1 owns a group with b2 and e5 in it; c3 is outside; d4 is staff (an observer).
 begin;
 create extension if not exists pgtap with schema extensions;
-select plan(65);
+select plan(66);
 
 insert into auth.users (id, aud, role, email, instance_id)
 select ('00000000-0000-4000-8000-00000000c2' || n)::uuid, 'authenticated', 'authenticated', 'genesis-chat2-' || n || '@example.test', '00000000-0000-0000-0000-000000000000'
@@ -257,9 +257,13 @@ select ok(not exists (select 1 from genesis_chat.inbox(p_exclude_kinds => array[
           'and leaves out the kinds asked to');
 select ok(genesis_chat.unread_total(p_exclude_kinds => array['cohort', 'direct']) = 0, 'so does the badge');
 
+select pg_temp.sign_in('a1');
+insert into t select 'late', (genesis_chat.send_message(pg_temp.v('dm1'), gen_random_uuid(), 'One more thing')).id;
 select pg_temp.as_server();
-select ok((select coalesce(bool_and(unread_total = 0), true) from genesis_chat.push_targets(pg_temp.v('bad'), array['cohort', 'direct'])),
-          'the push badge leaves out the kinds the app leaves out of its own');
+select ok((select unread_total > 0 from genesis_chat.push_targets(pg_temp.v('late')) where user_id = pg_temp.person('b2')),
+          'the push badge counts a new message');
+select is((select unread_total from genesis_chat.push_targets(pg_temp.v('late'), array['cohort', 'direct']) where user_id = pg_temp.person('b2')), 0,
+          'and leaves out the kinds the app leaves out of its own');
 
 select * from finish();
 rollback;

package/migrations/tests/0003_genesis_chat_search_threads.test.sql

@@ -0,0 +1,50 @@
+-- @feat:chat
+-- pgTAP test for 0003_genesis_chat_search_threads.sql (with 0001 and 0002 applied).
+-- Copy into your app's `supabase/tests/database/` and run `supabase test db`.
+-- Writes only its own users, kinds and conversations, and rolls everything back.
+begin;
+create extension if not exists pgtap with schema extensions;
+select plan(6);
+
+insert into auth.users (id, aud, role, email, instance_id)
+select ('00000000-0000-4000-8000-00000000c3' || n)::uuid, 'authenticated', 'authenticated', 'genesis-chat3-' || n || '@example.test', '00000000-0000-0000-0000-000000000000'
+from unnest(array['a1', 'b2', 'c3']) n;
+
+create function pg_temp.person(n text) returns uuid language sql immutable as $$ select ('00000000-0000-4000-8000-00000000c3' || n)::uuid $$;
+create function pg_temp.sign_in(n text) returns void language plpgsql as $$
+begin
+  perform set_config('request.jwt.claims', json_build_object('sub', pg_temp.person(n), 'role', 'authenticated')::text, true);
+  perform set_config('request.jwt.claim.sub', pg_temp.person(n)::text, true);
+  perform set_config('role', 'authenticated', true);
+end $$;
+grant execute on function pg_temp.person(text), pg_temp.sign_in(text) to authenticated, service_role;
+
+create temp table t (k text primary key, v uuid);
+grant select, insert on t to authenticated, service_role;
+create function pg_temp.v(k_ text) returns uuid language sql stable as $$ select v from t where k = k_ $$;
+grant execute on function pg_temp.v(text) to authenticated, service_role;
+
+create function public.genesis_chat3_test_may_start(member_ids uuid[], subject_type text, subject_id text, user_id uuid)
+returns boolean language sql stable set search_path = '' as $$ select true $$;
+select genesis_chat.register_kind('group', 'Group', p_membership => 'admins',
+  p_start_check => 'public.genesis_chat3_test_may_start(uuid[], text, text, uuid)');
+
+select pg_temp.sign_in('a1');
+insert into t select 'grp', genesis_chat.start_conversation('group', array[pg_temp.person('b2')], 'Search lab');
+insert into t select 'root', (genesis_chat.send_message(pg_temp.v('grp'), gen_random_uuid(), 'a thread starter about kayaks')).id;
+select genesis_chat.send_message(pg_temp.v('grp'), gen_random_uuid(), 'a reply about zebras', p_thread_root_id => pg_temp.v('root'));
+
+select pg_temp.sign_in('b2');
+select is((select thread_root_id from genesis_chat.search_messages('zebras')), pg_temp.v('root'), 'a reply in a thread comes with its thread');
+select is((select thread_root_id from genesis_chat.search_messages('kayaks')), null, 'a message on the main timeline with none');
+select pg_temp.sign_in('c3');
+select ok(not exists (select 1 from genesis_chat.search_messages('zebras')), 'someone outside still finds nothing');
+reset role;
+select ok(not has_function_privilege('anon', 'genesis_chat.search_messages(text, uuid, integer)', 'execute'), 'anon can''t search');
+select ok(has_function_privilege('authenticated', 'genesis_chat.search_messages(text, uuid, integer)', 'execute'), 'signed-in people can');
+
+select ok(exists (select 1 from pg_trigger where tgname = 'messages_moderation_changed' and tgrelid = 'genesis_chat.messages'::regclass),
+          'a change to a message''s moderation sends readers a live hint');
+
+select * from finish();
+rollback;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marktiderman/genesis-chat",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -61,13 +61,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@marktiderman/genesis-features": "^0.3.0",
+    "@marktiderman/genesis-features": "^0.4.0",
     "frimousse": "0.4.0"
   },
   "peerDependencies": {
-    "@marktiderman/genesis-core": "^1.7.0",
-    "@marktiderman/genesis-ui": "^2.13.0",
-    "@marktiderman/genesis-ui-native": "^2.4.0",
+    "@marktiderman/genesis-core": "^1.9.0",
+    "@marktiderman/genesis-ui": "^2.15.0",
+    "@marktiderman/genesis-ui-native": "^2.4.1",
     "@supabase/supabase-js": "^2.118.0",
     "@tanstack/react-query": "^5.0.0",
     "hls.js": "^1.5.0",
@@ -140,10 +140,10 @@
     }
   },
   "devDependencies": {
-    "@marktiderman/genesis-core": "^1.7.0",
-    "@marktiderman/genesis-notifications": "^0.1.1",
-    "@marktiderman/genesis-ui": "^2.13.0",
-    "@marktiderman/genesis-ui-native": "^2.4.0",
+    "@marktiderman/genesis-core": "^1.9.0",
+    "@marktiderman/genesis-notifications": "^0.1.2",
+    "@marktiderman/genesis-ui": "^2.15.0",
+    "@marktiderman/genesis-ui-native": "^2.4.1",
     "@supabase/supabase-js": "^2.118.0",
     "@tanstack/react-query": "^5.75.0",
     "@testing-library/react": "^16.3.2",
@@ -193,6 +193,10 @@
           {
             "file": "migrations/0002_genesis_chat_coaching.sql",
             "test": "migrations/tests/0002_genesis_chat_coaching.test.sql"
+          },
+          {
+            "file": "migrations/0003_genesis_chat_search_threads.sql",
+            "test": "migrations/tests/0003_genesis_chat_search_threads.test.sql"
           }
         ],
         "install": [

package/src/__tests__/coaching-core.test.ts

@@ -69,8 +69,10 @@ describe("mappers for 0002", () => {
       userId: "u", awayMessage: "Back Monday", awayUntil: null, timeZone: "Europe/London", hours: { mon: [["09:00", "17:00"]] },
     });
     expect(toSearchHit({ message_id: "m", conversation_id: "c", seq: "4", sender_id: null, created_at: "t", snippet: "a «b»", in_transcript: true })).toEqual({
-      messageId: "m", conversationId: "c", seq: 4, senderId: null, createdAt: "t", snippet: "a «b»", inTranscript: true,
+      messageId: "m", conversationId: "c", seq: 4, senderId: null, createdAt: "t", snippet: "a «b»", inTranscript: true, threadRootId: null,
     });
+    // A reply in a thread says which thread, so the app can open it.
+    expect(toSearchHit({ message_id: "m", conversation_id: "c", seq: 5, created_at: "t", snippet: "x", in_transcript: false, thread_root_id: "root" }).threadRootId).toBe("root");
     const p = toLinkPreview({ url: "https://x.test/a", status: "ok", title: "T", image_url: "http://x.test/i.png", fetched_at: "t" });
     expect(p.imageUrl).toBeNull();
     expect(toLinkPreview({ url: "https://x.test/a", image_url: "https://x.test/i.png", fetched_at: "t" }).imageUrl).toBe("https://x.test/i.png");

package/src/__tests__/coaching-react.test.tsx

@@ -9,6 +9,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import type { OutboxStore, QueuedMessage } from "../core/outbox";
 import {
   ChatProvider,
+  type ChatProviderProps,
   useAvailability,
   useBroadcast,
   useChat,
@@ -27,7 +28,7 @@ const ME = "00000000-0000-4000-8000-0000000000a1";
 const SAM = "00000000-0000-4000-8000-0000000000b2";
 const LEE = "00000000-0000-4000-8000-0000000000c3";
 
-function setup(over: Partial<MemoryChatOptions> = {}, store?: OutboxStore) {
+function setup(over: Partial<MemoryChatOptions> = {}, store?: OutboxStore, extra: Partial<ChatProviderProps> = {}) {
   const client = createMemoryChatClient({
     me: ME,
     conversations: [
@@ -50,7 +51,7 @@ function setup(over: Partial<MemoryChatOptions> = {}, store?: OutboxStore) {
   const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   const wrapper = ({ children }: { children: ReactNode }) => (
     <QueryClientProvider client={queryClient}>
-      <ChatProvider client={client} userId={ME} outboxStore={store}>
+      <ChatProvider client={client} userId={ME} outboxStore={store} {...extra}>
         {children}
       </ChatProvider>
     </QueryClientProvider>
@@ -83,6 +84,55 @@ describe("hooks for 0002", () => {
     await waitFor(() => expect(result.current.items).toHaveLength(0));
   });
 
+  it("useScheduled removes one that failed when due, as cancel_scheduled allows", async () => {
+    const { wrapper, client } = setup();
+    const { result } = renderHook(() => useScheduled("c1"), { wrapper });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await act(async () => {
+      await result.current.schedule({ conversationId: "c1", body: "Later", sendAt: new Date(Date.now() + 3_600_000) });
+    });
+    client.failNextSends(1);
+    await client.sendDue(new Date(Date.now() + 7_200_000));
+    await act(() => result.current.refetch());
+    await waitFor(() => expect(result.current.items[0]?.status).toBe("failed"));
+    await act(() => result.current.cancel(result.current.items[0]!.id));
+    await waitFor(() => expect(result.current.items).toHaveLength(0));
+    expect(client.calls.filter((c) => c.method === "cancelScheduled")).toHaveLength(1);
+  });
+
+  it("useScheduled takes native file URIs, read through the provider's readFile, as send does", async () => {
+    const readFile = vi.fn(async () => new Blob(["jpeg"], { type: "image/jpeg" }));
+    const { wrapper, client } = setup({}, undefined, { readFile });
+    const { result } = renderHook(() => useScheduled("c1"), { wrapper });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await act(async () => {
+      await result.current.schedule({ conversationId: "c1", body: "", sendAt: new Date(Date.now() + 3_600_000) }, [
+        { data: "file:///photos/a.jpg", name: "a.jpg", contentType: "image/jpeg" },
+        { data: "file:///rec/v.m4a", name: "v.m4a", contentType: "audio/mp4", meta: { kind: "voice", durationMs: 2000 } },
+      ]);
+    });
+    expect(readFile).toHaveBeenCalledWith("file:///photos/a.jpg");
+    expect(readFile).toHaveBeenCalledWith("file:///rec/v.m4a");
+    expect(client.calls.filter((c) => c.method === "upload")).toHaveLength(2);
+    await waitFor(() => expect(result.current.items).toHaveLength(1));
+    expect(result.current.items[0]!.attachments).toEqual([
+      expect.objectContaining({ kind: "image", mime: "image/jpeg", path: expect.stringContaining("a.jpg") }),
+      expect.objectContaining({ kind: "voice", durationMs: 2000, path: expect.stringContaining("v.m4a") }),
+    ]);
+  });
+
+  it("useScheduled uploads through the provider's upload hook when there is one", async () => {
+    const upload = vi.fn(async (conversationId: string, file: { name: string }) => `${conversationId}/me/${file.name}`);
+    const { wrapper } = setup({}, undefined, { upload });
+    const { result } = renderHook(() => useScheduled("c1"), { wrapper });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await act(async () => {
+      await result.current.schedule({ conversationId: "c1", body: "", sendAt: new Date(Date.now() + 3_600_000) }, [{ data: "file:///a.jpg", name: "a.jpg", contentType: "image/jpeg" }]);
+    });
+    expect(upload).toHaveBeenCalledWith("c1", expect.objectContaining({ data: "file:///a.jpg" }), expect.anything());
+    await waitFor(() => expect(result.current.items[0]?.attachments[0]?.path).toBe("c1/me/a.jpg"));
+  });
+
   it("useAvailability reads a conversation's and saves yours", async () => {
     const { wrapper } = setup();
     const { result } = renderHook(() => useAvailability("c1"), { wrapper });
@@ -199,6 +249,27 @@ describe("review fixes in the hooks", () => {
     expect(result.current.canPost).toBe(true);
   });
 
+  it("retries every lookup of the conversation, not only access", async () => {
+    const { wrapper, client } = setup();
+    const realMembers = client.members;
+    client.members = vi.fn(async () => {
+      throw new Error("Failed to fetch");
+    });
+    const { result } = renderHook(() => useConversation("c1"), { wrapper });
+    await waitFor(() => expect(client.members).toHaveBeenCalled());
+    client.members = vi.fn(realMembers);
+    await waitFor(() => expect(result.current.messages.length).toBeGreaterThan(0));
+    const realMessages = client.messages;
+    client.messages = vi.fn(realMessages);
+    await act(async () => {
+      await result.current.refetchAccess();
+    });
+    expect(client.members).toHaveBeenCalled();
+    // Never the message history: a refetch would drop loaded pages and merged live messages.
+    expect(client.messages).not.toHaveBeenCalled();
+    expect(typeof result.current.refetchConversation).toBe("function");
+  });
+
   const savedStore = (q: QueuedMessage[]) => {
     let saved = q;
     return { load: async () => saved, save: async (x: QueuedMessage[]) => void (saved = x), get: () => saved };

package/src/__tests__/coaching-web.test.tsx

@@ -4,19 +4,21 @@
  */
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { act, cleanup, configure, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
-import type { ReactNode } from "react";
+import { useEffect, type ReactNode } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { ChatProvider, type ChatProviderProps } from "../react";
+import { ChatProvider, useChat, type ChatProviderProps } from "../react";
 import {
   ChatAvailabilitySettings,
   ChatBroadcast,
   ChatLinkPreview,
+  ChatScheduledList,
   ChatThread,
   createMemoryChatClient,
   type MemoryChatClient,
   type MemoryChatOptions,
   type MemoryConversationSeed,
 } from "../web";
+import { installFakeXHR } from "./fake-xhr";
 
 afterEach(() => {
   cleanup();
@@ -147,6 +149,19 @@ describe("scheduled send", () => {
     await waitFor(() => expect(screen.queryByTestId("genesis-chat-scheduled-count")).toBeNull());
   });
 
+  it("offers Remove for a scheduled message that failed when due", async () => {
+    const client = make(dm());
+    await client.schedule({ conversationId: "c1", clientId: "00000000-0000-4000-8000-00000000s001", body: "Too late", sendAt: new Date(Date.now() + 3_600_000) });
+    client.failNextSends(1);
+    await client.sendDue(new Date(Date.now() + 7_200_000));
+    mount(client, <ChatScheduledList conversationId="c1" />);
+    expect((await screen.findByTestId("genesis-chat-scheduled-item")).textContent).toContain("Couldn't send");
+    expect(screen.queryByTestId("genesis-chat-scheduled-cancel")).toBeNull();
+    fireEvent.click(screen.getByTestId("genesis-chat-scheduled-remove"));
+    await waitFor(() => expect(client.calls.some((c) => c.method === "cancelScheduled")).toBe(true));
+    await waitFor(() => expect(screen.queryByTestId("genesis-chat-scheduled-item")).toBeNull());
+  });
+
   it("schedules at a date and time you pick", async () => {
     const client = make(dm());
     mount(client, <ChatThread conversationId="c1" resolveUser={resolveUser} />);
@@ -216,6 +231,37 @@ describe("availability", () => {
   });
 });
 
+describe("upload progress", () => {
+  it("draws a progress bar on a pending message while its file uploads", async () => {
+    const client = make(dm());
+    let report!: (sent: number, total: number) => void;
+    let finish!: () => void;
+    const upload = vi.fn(
+      (_c: string, file: { name: string }, o?: { onProgress?: (s: number, t: number) => void }) =>
+        new Promise<string>((r) => {
+          report = o!.onProgress!;
+          finish = () => r(`c1/${ME}/${file.name}`);
+        }),
+    );
+    function SendOne() {
+      const { outbox } = useChat();
+      useEffect(() => {
+        void outbox.send({ conversationId: "c1", body: "" }, [{ data: new Blob(["0123456789"]), name: "a.pdf", contentType: "application/pdf" }]);
+      }, [outbox]);
+      return null;
+    }
+    mount(client, <><ChatThread conversationId="c1" resolveUser={resolveUser} /><SendOne /></>, { upload });
+    await waitFor(() => expect(upload).toHaveBeenCalled());
+    act(() => report(3, 10));
+    const bar = await screen.findByTestId("genesis-chat-upload-progress");
+    expect(bar.getAttribute("aria-valuenow")).toBe("30");
+    act(() => report(8, 10));
+    await waitFor(() => expect(screen.getByTestId("genesis-chat-upload-progress").getAttribute("aria-valuenow")).toBe("80"));
+    await act(async () => finish());
+    await waitFor(() => expect(screen.queryByTestId("genesis-chat-upload-progress")).toBeNull());
+  });
+});
+
 describe("search", () => {
   it("finds a message further up, loads to it and highlights it", async () => {
     const messages = [
@@ -234,6 +280,29 @@ describe("search", () => {
     await waitFor(() => expect(document.querySelector("#genesis-chat-msg-old .ring-2")).not.toBeNull());
   });
 
+  it("opens the thread of a hit that is a reply in one, scrolled to the reply", async () => {
+    const client = make(
+      dm({
+        messages: [
+          { id: "root", senderId: SAM, body: "How did the week go?", createdAt: at(1), threadCount: 1 },
+          { id: "reply", senderId: ME, body: "Saw a zebra on my run", createdAt: at(2), threadRootId: "root" },
+        ],
+      }),
+    );
+    const onOpenThread = vi.fn();
+    mount(client, <ChatThread conversationId="c1" resolveUser={resolveUser} onOpenThread={onOpenThread} />);
+    fireEvent.click(await screen.findByTestId("genesis-chat-thread-search"));
+    fireEvent.change(await screen.findByTestId("genesis-chat-search-input"), { target: { value: "zebra" } });
+    fireEvent.click(await screen.findByTestId("genesis-chat-search-hit"));
+    await waitFor(() => expect(onOpenThread).toHaveBeenCalledTimes(1));
+    const [root, opts] = onOpenThread.mock.calls[0]! as [{ id: string }, { jumpTo: { messageId: string; seq: number } }];
+    expect(root.id).toBe("root");
+    expect(opts.jumpTo.messageId).toBe("reply");
+    // And here, the thread's first message.
+    await waitFor(() => expect(document.querySelector("#genesis-chat-msg-root .ring-2")).not.toBeNull());
+    expect(screen.queryByText("That message isn't here any more")).toBeNull();
+  });
+
   it("marks hits in a transcript", async () => {
     const client = make(dm({ messages: [{ id: "v", senderId: SAM, body: "", createdAt: at(1), attachments: [{ kind: "voice", transcript: "call the dentist" }] }] }));
     mount(client, <ChatThread conversationId="c1" resolveUser={resolveUser} />);
@@ -397,13 +466,12 @@ describe("video in the composer", () => {
     });
   }
 
-  it("records, uploads to the app's videoUpload with a PUT, and sends a pending Mux video", async () => {
+  it("records, sends a pending Mux video at once, and PUTs its bytes to the app's videoUpload meanwhile", async () => {
     const time = { now: 2_000_000 };
     vi.spyOn(Date, "now").mockImplementation(() => time.now);
     vi.stubGlobal("MediaRecorder", FakeRecorder);
     const camera = stubCamera();
-    const fetchMock = vi.fn(async () => new Response(null, { status: 200 }));
-    vi.stubGlobal("fetch", fetchMock);
+    const XHR = installFakeXHR();
     const create = vi.fn(async () => ({ url: "https://storage.mux.test/upload/1", providerId: "up_1", provider: "mux" as const }));
     const client = make(dm());
     mount(client, <ChatThread conversationId="c1" resolveUser={resolveUser} />, { videoUpload: { create } });
@@ -411,7 +479,11 @@ describe("video in the composer", () => {
     await waitFor(() => expect(client.calls.some((c) => c.method === "send")).toBe(true));
     expect(camera.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({ audio: true, video: expect.anything() }));
     expect(create).toHaveBeenCalledWith("c1");
-    expect(fetchMock).toHaveBeenCalledWith("https://storage.mux.test/upload/1", expect.objectContaining({ method: "PUT", headers: { "Content-Type": "video/webm" } }));
+    // The message went before the bytes: the PUT is still open.
+    await waitFor(() => expect(XHR.all.length).toBe(1));
+    const put = XHR.all[0]!;
+    expect(put).toMatchObject({ method: "PUT", url: "https://storage.mux.test/upload/1", headers: { "Content-Type": "video/webm" }, sent: true, status: 0 });
+    act(() => put.respond(200));
     const sent = client.calls.find((c) => c.method === "send")!.args[0] as { body: string; attachments: Record<string, unknown>[] };
     expect(sent.attachments[0]).toMatchObject({ kind: "video", provider: "mux", providerId: "up_1", status: "pending", durationMs: 4000, mime: "video/webm" });
     // Nothing went to storage, and the camera was released.

package/src/__tests__/fake-xhr.ts

@@ -0,0 +1,54 @@
+/** @feat:chat A scriptable XMLHttpRequest: the test answers each request and reports its progress. */
+import { vi } from "vitest";
+
+export class FakeXHR {
+  static all: FakeXHR[] = [];
+  method = "";
+  url = "";
+  headers: Record<string, string> = {};
+  body: unknown = undefined;
+  sent = false;
+  aborted = false;
+  status = 0;
+  responseText = "";
+  upload: { onprogress: ((e: ProgressEvent) => void) | null } = { onprogress: null };
+  onload: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  onabort: (() => void) | null = null;
+  constructor() {
+    FakeXHR.all.push(this);
+  }
+  open(method: string, url: string) {
+    this.method = method;
+    this.url = url;
+  }
+  setRequestHeader(k: string, v: string) {
+    this.headers[k] = v;
+  }
+  send(body: unknown) {
+    this.body = body;
+    this.sent = true;
+  }
+  abort() {
+    this.aborted = true;
+    this.onabort?.();
+  }
+  progress(loaded: number, total: number) {
+    this.upload.onprogress?.({ loaded, total, lengthComputable: true } as ProgressEvent);
+  }
+  respond(status = 200, text = "") {
+    this.status = status;
+    this.responseText = text;
+    this.onload?.();
+  }
+  fail() {
+    this.onerror?.();
+  }
+}
+
+/** Installs FakeXHR as XMLHttpRequest (undone by vi.unstubAllGlobals). */
+export function installFakeXHR(): typeof FakeXHR {
+  FakeXHR.all = [];
+  vi.stubGlobal("XMLHttpRequest", FakeXHR);
+  return FakeXHR;
+}