@marktiderman/genesis-chat 0.1.0 → 0.2.0

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

@@ -0,0 +1,154 @@
+// @feat:chat
+import { describe, expect, it, vi } from "vitest";
+import { ChatError } from "../../core/client";
+import { base64Utf8, createTusUpload } from "../tus";
+
+const URL_ = "http://127.0.0.1:54321";
+const CONV = "c0000000-0000-4000-8000-000000000001";
+const USER = "u0000000-0000-4000-8000-000000000002";
+
+function server(opts: { failPatchOnce?: boolean; createStatus?: number | (() => number); objectThere?: boolean } = {}) {
+  let received = 0;
+  let failed = false;
+  const calls: { method: string; url: string; headers: Record<string, string>; size?: number }[] = [];
+  const fetch = vi.fn(async (url: string, init: RequestInit = {}) => {
+    const headers = Object.fromEntries(Object.entries((init.headers ?? {}) as Record<string, string>));
+    const method = init.method ?? "GET";
+    const size = init.body instanceof ArrayBuffer ? init.body.byteLength : undefined;
+    calls.push({ method, url, headers, size });
+    if (method === "POST") {
+      const status = (typeof opts.createStatus === "function" ? opts.createStatus() : opts.createStatus) ?? 201;
+      return new Response(null, { status, headers: status === 201 ? { location: `${URL_}/storage/v1/upload/resumable/abc` } : {} });
+    }
+    // Storage answers a missing object with 400 (its body says 404).
+    if (method === "HEAD" && url.includes("/storage/v1/object/authenticated/")) return new Response(null, { status: opts.objectThere ? 200 : 400 });
+    if (method === "HEAD") return new Response(null, { status: 200, headers: { "upload-offset": String(received) } });
+    if (method === "PATCH") {
+      if (opts.failPatchOnce && !failed && received > 0) {
+        failed = true;
+        throw new TypeError("Network request failed");
+      }
+      expect(Number(headers["upload-offset"])).toBe(received);
+      received += size ?? 0;
+      return new Response(null, { status: 204, headers: { "upload-offset": String(received) } });
+    }
+    return new Response(new Uint8Array(10).buffer, { status: 200 });
+  });
+  return { fetch: fetch as unknown as typeof globalThis.fetch, calls, received: () => received };
+}
+
+const file = (bytes: number) => ({ data: new Uint8Array(bytes).buffer, name: "photo.jpg", contentType: "image/jpeg" });
+
+describe("createTusUpload", () => {
+  it("creates the upload at the conversation's path with the person's token, then sends it in chunks", async () => {
+    const s = server();
+    const upload = createTusUpload({ supabaseUrl: `${URL_}/`, userId: USER, getAccessToken: async () => "jwt", apikey: "pk", fetch: s.fetch, chunkBytes: 4, newId: () => "id1" });
+    const path = await upload(CONV, file(10));
+    expect(path).toBe(`${CONV}/${USER}/id1.jpg`);
+    const create = s.calls[0]!;
+    expect(create).toMatchObject({ method: "POST", url: `${URL_}/storage/v1/upload/resumable` });
+    expect(create.headers).toMatchObject({ authorization: "Bearer jwt", apikey: "pk", "tus-resumable": "1.0.0", "upload-length": "10", "x-upsert": "false" });
+    expect(create.headers["upload-metadata"]).toContain(`bucketName ${base64Utf8("genesis-chat")}`);
+    expect(create.headers["upload-metadata"]).toContain(`objectName ${base64Utf8(path)}`);
+    expect(s.calls.filter((c) => c.method === "PATCH").map((c) => c.size)).toEqual([4, 4, 2]);
+    expect(s.received()).toBe(10);
+  });
+
+  it("resumes after a dropped chunk from where the server is, and a retry reuses the path", async () => {
+    const s = server({ failPatchOnce: true });
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch, chunkBytes: 4, newId: () => "id2", retries: 0 });
+    const f = file(10);
+    await expect(upload(CONV, f)).rejects.toBeInstanceOf(ChatError);
+    const path = await upload(CONV, f);
+    expect(path).toBe(`${CONV}/${USER}/id2.jpg`);
+    expect(s.calls.filter((c) => c.method === "POST")).toHaveLength(1);
+    expect(s.calls.some((c) => c.method === "HEAD")).toBe(true);
+    expect(s.received()).toBe(10);
+    // Done: a third call doesn't upload again.
+    const before = s.calls.length;
+    expect(await upload(CONV, f)).toBe(path);
+    expect(s.calls.length).toBe(before);
+  });
+
+  it("an upload the server already has (409) counts as done once the object is checked to be there", async () => {
+    const s = server({ createStatus: 409, objectThere: true });
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch, newId: () => "id3" });
+    expect(await upload(CONV, file(3))).toBe(`${CONV}/${USER}/id3.jpg`);
+    expect(s.calls.filter((c) => c.method === "PATCH")).toHaveLength(0);
+    expect(s.calls.find((c) => c.method === "HEAD")).toMatchObject({ url: `${URL_}/storage/v1/object/authenticated/genesis-chat/${CONV}/${USER}/id3.jpg`, headers: { authorization: "Bearer jwt" } });
+  });
+
+  it("a 409 whose object isn't there is never taken as done: the file goes up whole at a new path", async () => {
+    let creates = 0;
+    const s = server({ createStatus: () => (++creates === 1 ? 409 : 201), objectThere: false });
+    const ids = ["old", "new"];
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch, newId: () => ids.shift()!, chunkBytes: 4 });
+    expect(await upload(CONV, file(10))).toBe(`${CONV}/${USER}/new.jpg`);
+    expect(s.received()).toBe(10);
+    const creates2 = s.calls.filter((c) => c.method === "POST");
+    expect(creates2).toHaveLength(2);
+    expect(creates2[1]!.headers["upload-metadata"]).toContain(`objectName ${base64Utf8(`${CONV}/${USER}/new.jpg`)}`);
+  });
+
+  it("a refusal is a ChatError that isn't retried; signed out or a bad type never reaches the server", async () => {
+    const s = server({ createStatus: 403 });
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch });
+    const err = await upload(CONV, file(3)).catch((e) => e);
+    expect(err).toBeInstanceOf(ChatError);
+    expect(err.forbidden).toBe(true);
+    expect(s.calls.filter((c) => c.method === "POST")).toHaveLength(1);
+
+    const s2 = server();
+    const signedOut = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => null, fetch: s2.fetch });
+    await expect(signedOut(CONV, file(3))).rejects.toMatchObject({ code: "42501" });
+    await expect(signedOut(CONV, { ...file(3), name: "x.svg", contentType: "image/svg+xml" })).rejects.toMatchObject({ code: "22023" });
+    expect(s2.calls.filter((c) => c.method !== "GET")).toHaveLength(0);
+  });
+
+  it("reads a file URI one chunk at a time through openFile, never whole, and closes it", async () => {
+    const s = server();
+    const reads: [number, number][] = [];
+    const close = vi.fn();
+    const openFile = vi.fn(async () => ({
+      size: 10,
+      read: async (offset: number, length: number) => {
+        reads.push([offset, length]);
+        return new Uint8Array(Math.min(length, 10 - offset));
+      },
+      close,
+    }));
+    const readFile = vi.fn(async () => new Uint8Array(10).buffer);
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch, openFile, readFile, chunkBytes: 4, newId: () => "id5" });
+    await upload(CONV, { data: "file:///video.mp4", name: "video.mp4", contentType: "video/mp4" });
+    expect(openFile).toHaveBeenCalledWith("file:///video.mp4");
+    expect(readFile).not.toHaveBeenCalled();
+    expect(reads).toEqual([[0, 4], [4, 4], [8, 2]]);
+    expect(s.calls.find((c) => c.method === "POST")!.headers["upload-length"]).toBe("10");
+    expect(s.calls.filter((c) => c.method === "PATCH").map((c) => c.size)).toEqual([4, 4, 2]);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it("closes the file when the upload fails", async () => {
+    const s = server({ createStatus: 403 });
+    const close = vi.fn();
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: USER, getAccessToken: async () => "jwt", fetch: s.fetch, openFile: () => ({ size: 3, read: async () => new Uint8Array(3), close }) });
+    await expect(upload(CONV, { data: "file:///a.jpg", name: "a.jpg", contentType: "image/jpeg" })).rejects.toBeInstanceOf(ChatError);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads a file URI through readFile", async () => {
+    const s = server();
+    const readFile = vi.fn(async () => new Uint8Array(5).buffer);
+    const upload = createTusUpload({ supabaseUrl: URL_, userId: () => USER, getAccessToken: async () => "jwt", fetch: s.fetch, readFile, newId: () => "id4" });
+    await upload(CONV, { data: "file:///voice.m4a", name: "voice.m4a", contentType: "audio/mp4" });
+    expect(readFile).toHaveBeenCalledWith("file:///voice.m4a");
+    expect(s.received()).toBe(5);
+  });
+});
+
+describe("base64Utf8", () => {
+  it("encodes UTF-8", () => {
+    expect(base64Utf8("genesis-chat")).toBe(Buffer.from("genesis-chat").toString("base64"));
+    expect(base64Utf8("é/ü")).toBe(Buffer.from("é/ü").toString("base64"));
+  });
+});

package/src/native/__tests__/use-voice-recorder.test.tsx

@@ -0,0 +1,316 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { LocalFile } from "../../core/outbox";
+import type { ExpoAudioLike, RecorderStateLike } from "../modules";
+import { RECORDER_START_READS, RECORDER_STALL_READS, useVoiceRecorder } from "../use-voice-recorder";
+
+// AppState, which the shared React Native shim leaves out: the test moves the app to the background.
+const appState = vi.hoisted(() => {
+  const listeners = new Set<(s: string) => void>();
+  return { listeners, emit: (s: string) => listeners.forEach((l) => l(s)) };
+});
+vi.mock("react-native", async (original) => ({
+  ...(await original<object>()),
+  AppState: {
+    addEventListener: (_: string, l: (s: string) => void) => {
+      appState.listeners.add(l);
+      return { remove: () => appState.listeners.delete(l) };
+    },
+  },
+}));
+
+/** expo-audio, mocked: a recorder whose status the test moves forward. */
+function fakeAudio(opts: { granted?: boolean } = {}) {
+  const status: RecorderStateLike = { isRecording: false, durationMillis: 0, metering: -160, url: null };
+  const recorder = {
+    uri: null as string | null,
+    prepareToRecordAsync: vi.fn(async () => undefined),
+    record: vi.fn(() => {
+      status.isRecording = true;
+    }),
+    stop: vi.fn(async () => {
+      status.isRecording = false;
+      recorder.uri = "file:///rec/voice.m4a";
+    }),
+    getStatus: vi.fn(() => ({ ...status })),
+  };
+  const audio: ExpoAudioLike = {
+    useAudioRecorder: vi.fn(() => recorder),
+    useAudioPlayer: vi.fn(),
+    useAudioPlayerStatus: vi.fn(),
+    RecordingPresets: { HIGH_QUALITY: { extension: ".m4a" } },
+    requestRecordingPermissionsAsync: vi.fn(async () => ({ granted: opts.granted ?? true })),
+    setAudioModeAsync: vi.fn(async () => undefined),
+  } as unknown as ExpoAudioLike;
+  return { audio, recorder, status };
+}
+
+describe("useVoiceRecorder (expo-audio mocked)", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  async function start(audio: ExpoAudioLike, onRecorded: (f: LocalFile) => void, signalRecording = vi.fn()) {
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded, signalRecording }));
+    await act(async () => {
+      hook.result.current.dispatch({ type: "press" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    return hook;
+  }
+
+  it("records with metering on, reads the level as it goes, and sends a voice note with its duration and waveform", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    const onRecorded = vi.fn();
+    const signalRecording = vi.fn();
+    const hook = await start(audio, onRecorded, signalRecording);
+    expect(audio.useAudioRecorder).toHaveBeenCalledWith({ extension: ".m4a", isMeteringEnabled: true });
+    expect(audio.setAudioModeAsync).toHaveBeenCalledWith({ allowsRecording: true, playsInSilentMode: true });
+    expect(recorder.prepareToRecordAsync).toHaveBeenCalled();
+    expect(recorder.record).toHaveBeenCalled();
+    expect(hook.result.current.state.phase).toBe("recording");
+
+    for (const [ms, db] of [[100, -40], [200, -10], [300, -25], [1200, -5]] as const) {
+      status.durationMillis = ms;
+      status.metering = db;
+      await act(async () => void (await vi.advanceTimersByTimeAsync(100)));
+    }
+    expect(hook.result.current.state.durationMs).toBe(1200);
+    expect(signalRecording).toHaveBeenCalled();
+
+    await act(async () => {
+      hook.result.current.dispatch({ type: "release" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.stop).toHaveBeenCalled();
+    expect(onRecorded).toHaveBeenCalledTimes(1);
+    const file = onRecorded.mock.calls[0]![0] as LocalFile;
+    expect(file).toMatchObject({ data: "file:///rec/voice.m4a", contentType: "audio/mp4", meta: { kind: "voice", durationMs: 1200 } });
+    expect(file.meta!.waveform).toHaveLength(48);
+    expect(Math.max(...file.meta!.waveform!)).toBe(100);
+    expect(audio.setAudioModeAsync).toHaveBeenLastCalledWith({ allowsRecording: false });
+    expect(hook.result.current.state.phase).toBe("idle");
+  });
+
+  it("slide to cancel stops and throws the recording away", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    const onRecorded = vi.fn();
+    const hook = await start(audio, onRecorded);
+    status.durationMillis = 2000;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100)));
+    act(() => hook.result.current.dispatch({ type: "move", dx: -200, dy: 0 }));
+    await act(async () => void (await vi.advanceTimersByTimeAsync(0)));
+    expect(recorder.stop).toHaveBeenCalled();
+    expect(onRecorded).not.toHaveBeenCalled();
+    expect(hook.result.current.state.phase).toBe("idle");
+    // The level timer stopped with it.
+    const reads = recorder.getStatus.mock.calls.length;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(500)));
+    expect(recorder.getStatus.mock.calls.length).toBe(reads);
+  });
+
+  it("locked, it keeps recording after letting go, until Send", async () => {
+    const { audio, status } = fakeAudio();
+    const onRecorded = vi.fn();
+    const hook = await start(audio, onRecorded);
+    act(() => hook.result.current.dispatch({ type: "move", dx: 0, dy: -100 }));
+    act(() => hook.result.current.dispatch({ type: "release" }));
+    expect(hook.result.current.state).toMatchObject({ phase: "recording", locked: true });
+    status.durationMillis = 3000;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100)));
+    await act(async () => {
+      hook.result.current.dispatch({ type: "send" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(onRecorded).toHaveBeenCalledTimes(1);
+  });
+
+  it("without microphone permission it never records, and says so", async () => {
+    const { audio, recorder } = fakeAudio({ granted: false });
+    const hook = await start(audio, vi.fn());
+    expect(recorder.record).not.toHaveBeenCalled();
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "denied" });
+  });
+
+  it("leaving the screen mid-recording stops the recorder", async () => {
+    const { audio, recorder } = fakeAudio();
+    const hook = await start(audio, vi.fn());
+    hook.unmount();
+    expect(recorder.stop).toHaveBeenCalled();
+  });
+
+  it("a press cancelled while the microphone starts never records, and lets the microphone go", async () => {
+    const { audio, recorder } = fakeAudio();
+    let grant!: (v: { granted: boolean }) => void;
+    (audio.requestRecordingPermissionsAsync as ReturnType<typeof vi.fn>).mockImplementationOnce(() => new Promise((r) => (grant = r)));
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded: vi.fn() }));
+    act(() => hook.result.current.dispatch({ type: "press" }));
+    act(() => hook.result.current.dispatch({ type: "cancel" }));
+    await act(async () => {
+      grant({ granted: true });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.prepareToRecordAsync).not.toHaveBeenCalled();
+    expect(recorder.record).not.toHaveBeenCalled();
+    expect(audio.setAudioModeAsync).not.toHaveBeenCalledWith({ allowsRecording: true, playsInSilentMode: true });
+    expect(hook.result.current.state.phase).toBe("idle");
+  });
+
+  it("a second press after a cancelled one isn't started by the first one's late answer", async () => {
+    const { audio, recorder } = fakeAudio();
+    const grants: ((v: { granted: boolean }) => void)[] = [];
+    (audio.requestRecordingPermissionsAsync as ReturnType<typeof vi.fn>).mockImplementation(() => new Promise((r) => grants.push(r)));
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded: vi.fn() }));
+    act(() => hook.result.current.dispatch({ type: "press" }));
+    act(() => hook.result.current.dispatch({ type: "cancel" }));
+    act(() => hook.result.current.dispatch({ type: "press" }));
+    await act(async () => {
+      grants[0]!({ granted: true });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.record).not.toHaveBeenCalled();
+    expect(hook.result.current.state.phase).toBe("starting");
+    await act(async () => {
+      grants[1]!({ granted: true });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.record).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useVoiceRecorder when something goes wrong", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  async function recordFor(audio: ExpoAudioLike, status: RecorderStateLike, onRecorded: (f: LocalFile) => void, ms = 1500) {
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded }));
+    await act(async () => {
+      hook.result.current.dispatch({ type: "press" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    status.durationMillis = ms;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100)));
+    return hook;
+  }
+
+  it("a stop that throws sends nothing and says the voice message wasn't saved", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    recorder.stop.mockImplementationOnce(async () => {
+      throw new Error("stop failed");
+    });
+    const onRecorded = vi.fn();
+    const hook = await recordFor(audio, status, onRecorded);
+    await act(async () => {
+      hook.result.current.dispatch({ type: "release" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(onRecorded).not.toHaveBeenCalled();
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "error" });
+  });
+
+  it("a stop that leaves no file says so too", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    recorder.stop.mockImplementationOnce(async () => {
+      status.isRecording = false;
+    });
+    const onRecorded = vi.fn();
+    const hook = await recordFor(audio, status, onRecorded);
+    await act(async () => {
+      hook.result.current.dispatch({ type: "release" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(onRecorded).not.toHaveBeenCalled();
+    expect(hook.result.current.state.notice).toBe("error");
+  });
+
+  it("the recorder stopping by itself (a phone call) ends the attempt with a notice instead of freezing the timer", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    const onRecorded = vi.fn();
+    const hook = await recordFor(audio, status, onRecorded);
+    status.isRecording = false;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100 * RECORDER_STALL_READS)));
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "interrupted" });
+    expect(onRecorded).not.toHaveBeenCalled();
+    expect(recorder.stop).toHaveBeenCalled();
+    const reads = recorder.getStatus.mock.calls.length;
+    await act(async () => void (await vi.advanceTimersByTimeAsync(500)));
+    expect(recorder.getStatus.mock.calls.length).toBe(reads);
+  });
+
+  it("a status that stops reading ends the attempt too", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    const hook = await recordFor(audio, status, vi.fn());
+    recorder.getStatus.mockImplementation(() => {
+      throw new Error("gone");
+    });
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100 * RECORDER_STALL_READS)));
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "interrupted" });
+  });
+
+  it("the app going to the background ends the recording and lets the microphone go", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    const hook = await recordFor(audio, status, vi.fn());
+    act(() => appState.emit("background"));
+    await act(async () => void (await vi.advanceTimersByTimeAsync(0)));
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "interrupted" });
+    expect(recorder.stop).toHaveBeenCalled();
+    expect(audio.setAudioModeAsync).toHaveBeenLastCalledWith({ allowsRecording: false });
+    const before = appState.listeners.size;
+    hook.unmount();
+    expect(appState.listeners.size).toBe(before - 1);
+  });
+
+  it("a record() that never starts ends the attempt with an error notice, not a frozen 0:00", async () => {
+    const { audio, recorder } = fakeAudio();
+    recorder.record.mockImplementation(() => undefined);
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded: vi.fn() }));
+    await act(async () => {
+      hook.result.current.dispatch({ type: "press" });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(hook.result.current.state.phase).toBe("recording");
+    await act(async () => void (await vi.advanceTimersByTimeAsync(100 * RECORDER_START_READS)));
+    expect(hook.result.current.state).toMatchObject({ phase: "idle", notice: "error" });
+  });
+
+  it("the background while the microphone is still starting (Android's permission dialog) doesn't end the attempt", async () => {
+    const { audio, recorder } = fakeAudio();
+    let grant!: (v: { granted: boolean }) => void;
+    (audio.requestRecordingPermissionsAsync as ReturnType<typeof vi.fn>).mockImplementationOnce(() => new Promise((r) => (grant = r)));
+    const hook = renderHook(() => useVoiceRecorder(audio, { limitMs: 60_000, onRecorded: vi.fn() }));
+    act(() => hook.result.current.dispatch({ type: "press" }));
+    act(() => appState.emit("background"));
+    await act(async () => {
+      grant({ granted: true });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.record).toHaveBeenCalled();
+    expect(hook.result.current.state).toMatchObject({ phase: "recording", notice: null });
+  });
+
+  it("leaving the screen while the stop is under way lets it finish, stops once, and still sends the note", async () => {
+    const { audio, recorder, status } = fakeAudio();
+    let finishStop!: () => void;
+    recorder.stop.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          finishStop = () => {
+            recorder.uri = "file:///rec/voice.m4a";
+            resolve();
+          };
+        }),
+    );
+    const onRecorded = vi.fn();
+    const hook = await recordFor(audio, status, onRecorded);
+    act(() => hook.result.current.dispatch({ type: "release" }));
+    hook.unmount();
+    await act(async () => {
+      finishStop();
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(recorder.stop).toHaveBeenCalledTimes(1);
+    expect(onRecorded).toHaveBeenCalledTimes(1);
+    expect(audio.setAudioModeAsync).toHaveBeenLastCalledWith({ allowsRecording: false });
+  });
+});