@marktiderman/genesis-chat 0.2.0 → 0.2.2

package/src/core/outbox.ts

@@ -8,11 +8,19 @@
  * and only sent again by hand. `clear()` (sign-out) stops sends in flight: none
  * posts, or saves anything, afterwards. Storage is the platform's (memory by default;
  * localStorage on web, MMKV or SQLite on native), behind OutboxStore.
+ *
+ * A hosted video (`LocalFile.hosted`, with `hostedUpload`) doesn't wait for its bytes: the
+ * upload is started (the provider's upload id minted), the message is sent in its place in the
+ * order with the attachment `pending`, and the bytes carry on going up; the provider's webhook
+ * marks it ready. The message stays here (hidden from the thread once the server has it) until
+ * its bytes are up, so a relaunch carries the upload on (`resume`) and sends the message again
+ * with the same clientId, which posts nothing twice.
  */
 import type { ChatClient } from "./client";
 import { ChatError } from "./client";
 import { attachmentKindFor, randomId } from "./media";
-import type { AttachmentInput, ChatMessage, PendingFile, PendingMessage, SendInput } from "./types";
+import type { UploadProgress } from "./transfer";
+import type { AttachmentInput, ChatMessage, HostedAttachment, PendingFile, PendingMessage, SendInput } from "./types";
 
 /** A file still on the device, uploaded when its message is sent. */
 export interface LocalFile {
@@ -24,8 +32,50 @@ export interface LocalFile {
   previewUrl?: string;
   /** Known up front: a voice note's duration and waveform, a photo's size. */
   meta?: Partial<Omit<AttachmentInput, "path" | "kind">> & { kind?: AttachmentInput["kind"] };
+  /**
+   * Send it to the hosted video provider (the outbox's `hostedUpload`) instead of storage: the
+   * message goes at once, in order, with the attachment pending, while the bytes go up. Without
+   * a `hostedUpload` it goes to storage like any file.
+   */
+  hosted?: boolean;
+}
+
+/** A hosted upload as the outbox keeps it (saved with the message), so it can be carried on. */
+export interface HostedUploadRecord {
+  provider: HostedAttachment["provider"];
+  providerId: string;
+  /** Where the bytes go, when the hook returned it: what a resume needs. */
+  url?: string;
+  /** Every byte is there. */
+  uploaded?: boolean;
+}
+
+/** What `hostedUpload` resolves with as soon as the upload exists (before the bytes are up). */
+export interface HostedUploadStart extends HostedAttachment {
+  /** Where the bytes go; kept with the message, handed back as `resume.url`. */
+  url?: string;
+  /** Settles when every byte is there (rejects when the transfer fails). Absent: already there. */
+  done?: Promise<void>;
 }
 
+export interface HostedUploadOptions {
+  /** Aborts when the message is discarded or the outbox cleared. */
+  signal?: AbortSignal;
+  onProgress?: UploadProgress;
+  /**
+   * The upload started before (a relaunch, a retry after the transfer failed): carry it on and
+   * resolve with the same `providerId`. A message may already be posted with it, so mint a new
+   * one only when the old upload is gone; that message's video then stays pending.
+   */
+  resume?: HostedUploadRecord;
+}
+
+/** Starts (or carries on) a hosted upload; resolves once the provider's upload id exists. */
+export type HostedUpload = (conversationId: string, file: LocalFile, opts: HostedUploadOptions) => Promise<HostedUploadStart>;
+
+/** Uploads a file to storage and resolves with its path. */
+export type StorageUpload = (conversationId: string, file: LocalFile, opts?: { signal?: AbortSignal; onProgress?: UploadProgress }) => Promise<string>;
+
 export interface QueuedMessage extends Omit<PendingMessage, "files"> {
   files: LocalFile[];
   /** What each file is, kept with the saved copy (PendingMessage.files). */
@@ -33,10 +83,20 @@ export interface QueuedMessage extends Omit<PendingMessage, "files"> {
   /** Files lost on a relaunch (bytes that weren't persisted). */
   lostFiles?: number;
   attempts: number;
+  /** Hosted uploads started, by file slot. */
+  hosted?: Record<number, HostedUploadRecord>;
+  /** Posted (this message's id): it waits here only for its hosted bytes to finish. */
+  sentMessageId?: string;
 }
 
 function describe(f: LocalFile): PendingFile {
-  return { name: f.name, contentType: f.contentType, kind: f.meta?.kind ?? attachmentKindFor(f.contentType), meta: f.meta };
+  return {
+    name: f.name,
+    contentType: f.contentType,
+    kind: f.meta?.kind ?? attachmentKindFor(f.contentType),
+    meta: f.meta,
+    ...(f.hosted ? { hosted: true } : {}),
+  };
 }
 
 export interface OutboxStore {
@@ -55,8 +115,18 @@ export interface OutboxOptions {
   store?: OutboxStore;
   /** Reads a native file URI into bytes for upload. */
   readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
-  /** Upload hook, e.g. resumable uploads on native. Defaults to client.upload. `signal` aborts when the message is discarded or the outbox cleared. */
-  upload?: (conversationId: string, file: LocalFile, opts?: { signal?: AbortSignal }) => Promise<string>;
+  /**
+   * Upload hook, e.g. resumable uploads on native. Defaults to client.upload. `signal` aborts
+   * when the message is discarded or the outbox cleared; call `onProgress(sent, total)` as bytes
+   * go, and the pending bubble shows it (`PendingMessage.files[i].progress`).
+   */
+  upload?: StorageUpload;
+  /**
+   * Starts a hosted video upload for a file marked `hosted` and resolves once the provider's
+   * upload id exists, with `done` for the bytes. See HostedUpload; without it, hosted files go
+   * to storage.
+   */
+  hostedUpload?: HostedUpload;
   /** Called with every change, for the UI. */
   onChange?: (queue: QueuedMessage[]) => void;
   /** Called when a message lands. */
@@ -95,6 +165,9 @@ export function createOutbox(opts: OutboxOptions) {
   const running = new Map<string, number>(); // conversationId -> the generation running it
   const aborts = new Map<string, AbortController>(); // clientId -> its uploads' controller
   const uploaded = new Map<string, string>(); // clientId:index -> path
+  // Hosted bytes still going up, by clientId:index, and the controller that stops them.
+  const transfers = new Map<string, Promise<void>>();
+  const hostedAborts = new Map<string, AbortController>();
 
   const release = opts.releasePreview ?? releaseObjectUrl;
   const releasePreviews = (q: QueuedMessage) => {
@@ -128,6 +201,23 @@ export function createOutbox(opts: OutboxOptions) {
     void store.save(queue.map(saveable));
   };
 
+  /** A file's upload progress, for the UI only (not saved). */
+  const setProgress = (q: QueuedMessage, index: number, sent: number, total: number) => {
+    const slots = q.pendingFiles;
+    if (!slots?.[index] || !queue.includes(q)) return;
+    // Whole percents: the bar shows no finer, and each change re-renders every chat hook.
+    const progress = total > 0 ? Math.round(Math.min(1, Math.max(0, sent / total)) * 100) / 100 : 0;
+    if (slots[index]!.progress === progress) return;
+    q.pendingFiles = slots.map((slot, j) => (j === index ? { ...slot, progress } : slot));
+    opts.onChange?.([...queue]);
+  };
+
+  const stopHosted = (clientId: string) => {
+    hostedAborts.get(clientId)?.abort();
+    hostedAborts.delete(clientId);
+    for (const k of [...transfers.keys()]) if (k.startsWith(`${clientId}:`)) transfers.delete(k);
+  };
+
   /** Swaps a byte file for a saved URI, so it survives a relaunch. */
   async function persist(q: QueuedMessage) {
     if (!opts.persistFile) return;
@@ -165,8 +255,12 @@ export function createOutbox(opts: OutboxOptions) {
         .filter((q) => !live.has(q.clientId))
         .map((q) => {
           const lost = (q.pendingFiles ?? []).filter((f) => f.lost).length;
+          // Posted, its hosted bytes still going up when the app closed: it is sent again (the
+          // same clientId posts nothing twice) after its upload is carried on.
+          const rest: QueuedMessage = { ...q };
+          delete rest.sentMessageId;
           return {
-            ...q,
+            ...rest,
             status: q.status === "sending" || lost > 0 ? "failed" : q.status,
             error: lost > 0 ? "Attach the file again to send" : (q.error ?? "Not sent"),
             files: q.files ?? [],
@@ -182,10 +276,74 @@ export function createOutbox(opts: OutboxOptions) {
     return loading;
   }
 
-  async function uploadFile(conversationId: string, file: LocalFile, signal?: AbortSignal): Promise<string> {
-    if (opts.upload) return opts.upload(conversationId, file, { signal });
+  async function uploadFile(conversationId: string, file: LocalFile, signal?: AbortSignal, onProgress?: UploadProgress): Promise<string> {
+    if (opts.upload) return opts.upload(conversationId, file, { signal, onProgress });
     const data = typeof file.data === "string" ? await (opts.readFile ?? notReadable)(file.data) : file.data;
-    return opts.client.upload(conversationId, opts.userId, data, { name: file.name, contentType: file.contentType });
+    return opts.client.upload(conversationId, opts.userId, data, { name: file.name, contentType: file.contentType, onProgress, signal });
+  }
+
+  const isHosted = (f: LocalFile) => Boolean(f.hosted && opts.hostedUpload);
+
+  /**
+   * The hosted upload for one file slot: the one going up, or a new (or carried-on) one. Resolves
+   * once the provider's upload id exists; its bytes go on in `transfers`.
+   */
+  async function startHosted(q: QueuedMessage, index: number, file: LocalFile): Promise<HostedUploadRecord> {
+    const key = `${q.clientId}:${index}`;
+    const known = q.hosted?.[index];
+    if (known && (known.uploaded || transfers.has(key))) return known;
+    let controller = hostedAborts.get(q.clientId);
+    if (!controller && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      hostedAborts.set(q.clientId, controller);
+    }
+    const started = await opts.hostedUpload!(q.input.conversationId, file, {
+      signal: controller?.signal,
+      onProgress: (sent, total) => setProgress(q, index, sent, total),
+      ...(known ? { resume: known } : {}),
+    });
+    const record: HostedUploadRecord = { provider: started.provider, providerId: started.providerId, ...(started.url ? { url: started.url } : {}) };
+    q.hosted = { ...q.hosted, [index]: record };
+    // Saved at once: a relaunch before the message goes carries this upload on, not a new one.
+    if (queue.includes(q)) emit();
+    const transfer = Promise.resolve(started.done).then(
+      () => {
+        record.uploaded = true;
+        if (transfers.get(key) === transfer) transfers.delete(key);
+        setProgress(q, index, 1, 1);
+      },
+      (e: unknown) => {
+        if (transfers.get(key) === transfer) transfers.delete(key);
+        throw e;
+      },
+    );
+    transfer.catch(() => undefined);
+    transfers.set(key, transfer);
+    return record;
+  }
+
+  /** A posted message's hosted bytes: once they are all up, it leaves; a failed transfer marks it failed (Retry carries it on). */
+  async function settleHosted(q: QueuedMessage, gen: number) {
+    const waiting = Object.entries(q.hosted ?? {})
+      .filter(([, r]) => !r.uploaded)
+      .map(([i]) => transfers.get(`${q.clientId}:${i}`) ?? Promise.reject(new ChatError("The upload stopped", undefined, "upload")));
+    try {
+      await Promise.all(waiting);
+    } catch (e) {
+      if (gen !== generation || !queue.includes(q) || q.status !== "sending") return;
+      q.attempts += 1;
+      q.status = "failed";
+      q.error = e instanceof ChatError && e.code === "GSABORT" ? "The upload was cancelled" : "The video didn't finish uploading";
+      emit();
+      return;
+    }
+    if (gen !== generation || !queue.includes(q)) return;
+    // A retry may have started more meanwhile: wait for those too.
+    if (Object.values(q.hosted ?? {}).some((r) => !r.uploaded)) return void settleHosted(q, gen);
+    queue = queue.filter((x) => x !== q);
+    hostedAborts.delete(q.clientId);
+    emit();
+    releasePreviews(q);
   }
 
   async function run(conversationId: string) {
@@ -199,7 +357,8 @@ export function createOutbox(opts: OutboxOptions) {
         if (gen !== generation) return;
         // In the order written: the first message still here decides. One that failed (a lost
         // file, a refusal, no connection) holds back the ones after it until it is retried.
-        const next = queue.find((q) => q.input.conversationId === conversationId);
+        // A posted message waiting only for its hosted bytes holds nothing back.
+        const next = queue.find((q) => q.input.conversationId === conversationId && !q.sentMessageId);
         if (!next || next.status !== "sending") break;
         if ((next.lostFiles ?? 0) > 0) {
           next.status = "failed";
@@ -213,10 +372,25 @@ export function createOutbox(opts: OutboxOptions) {
           const attachments: AttachmentInput[] = [...(next.input.attachments ?? [])];
           for (let i = 0; i < next.files.length; i++) {
             const file = next.files[i]!;
+            if (isHosted(file)) {
+              const hosted = await startHosted(next, i, file);
+              if (stale(next)) return;
+              attachments.push({
+                ...file.meta,
+                kind: file.meta?.kind ?? attachmentKindFor(file.contentType),
+                provider: hosted.provider,
+                providerId: hosted.providerId,
+                status: "pending",
+                name: file.meta?.name ?? file.name,
+                mime: file.contentType,
+              });
+              continue;
+            }
             const key = `${next.clientId}:${i}`;
             let path = uploaded.get(key);
             if (!path) {
-              path = await uploadFile(conversationId, file, controller?.signal);
+              const index = i;
+              path = await uploadFile(conversationId, file, controller?.signal, (sent, total) => setProgress(next, index, sent, total));
               if (stale(next)) return;
               uploaded.set(key, path);
             }
@@ -232,8 +406,18 @@ export function createOutbox(opts: OutboxOptions) {
           const message = await opts.client.send({ ...next.input, attachments });
           // Posted, but the person signed out meanwhile: the next session must not hear of it.
           if (gen !== generation) return;
-          queue = queue.filter((q) => q.clientId !== next.clientId);
           for (let i = 0; i < next.files.length; i++) uploaded.delete(`${next.clientId}:${i}`);
+          if (Object.values(next.hosted ?? {}).some((r) => !r.uploaded)) {
+            // Posted with its video pending: it stays (out of the thread, which has the server's
+            // copy) until the bytes are up, so a relaunch can carry the upload on.
+            next.sentMessageId = message.id;
+            emit();
+            opts.onSent?.(message, next.clientId);
+            void settleHosted(next, gen);
+            continue;
+          }
+          queue = queue.filter((q) => q.clientId !== next.clientId);
+          hostedAborts.delete(next.clientId);
           emit();
           opts.onSent?.(message, next.clientId);
           // The bubble now draws the stored copy: the local preview can go.
@@ -259,7 +443,15 @@ export function createOutbox(opts: OutboxOptions) {
 
   /** Can this failed message go without the person's help (retryAll, coming back online)? */
   const canAutoRetry = (x: QueuedMessage) =>
-    !x.permanent && !(x.lostFiles ?? 0) && x.files.every((f) => typeof f.data !== "string" || Boolean(opts.readFile || opts.upload));
+    !x.permanent &&
+    !(x.lostFiles ?? 0) &&
+    x.files.every((f) => typeof f.data !== "string" || Boolean(isHosted(f) ? opts.hostedUpload : opts.readFile || opts.upload));
+
+  /** A failed message goes again: a posted one (its transfer failed) re-sends, idempotently, after carrying its upload on. */
+  const requeue = (x: QueuedMessage) => {
+    x.status = "sending";
+    delete x.sentMessageId;
+  };
 
   return {
     /** Queues a message; it shows at once and sends in order. Returns its clientId. */
@@ -301,7 +493,7 @@ export function createOutbox(opts: OutboxOptions) {
       for (const x of queue) {
         if (x.input.conversationId !== q.input.conversationId || x.status !== "failed") continue;
         if ((x.lostFiles ?? 0) > 0) break;
-        x.status = "sending";
+        requeue(x);
         x.permanent = false;
       }
       emit();
@@ -354,7 +546,7 @@ export function createOutbox(opts: OutboxOptions) {
       const gen = generation;
       await persist(q);
       if (gen !== generation || !queue.includes(q)) return;
-      q.status = "sending";
+      requeue(q);
       emit();
       void run(q.input.conversationId);
     },
@@ -372,10 +564,11 @@ export function createOutbox(opts: OutboxOptions) {
         const c = x.input.conversationId;
         if (held.has(c) || x.status !== "failed") continue;
         if (!canAutoRetry(x)) {
-          held.add(c);
+          // A posted one (only its upload failed) holds nothing back.
+          if (!x.sentMessageId) held.add(c);
           continue;
         }
-        x.status = "sending";
+        requeue(x);
         conversations.add(c);
       }
       emit();
@@ -388,6 +581,9 @@ export function createOutbox(opts: OutboxOptions) {
       generation += 1;
       for (const c of aborts.values()) c.abort();
       aborts.clear();
+      for (const c of hostedAborts.values()) c.abort();
+      hostedAborts.clear();
+      transfers.clear();
       running.clear();
       const gone = queue;
       queue = [];
@@ -404,10 +600,20 @@ export function createOutbox(opts: OutboxOptions) {
       queue = queue.filter((q) => q.clientId !== clientId);
       aborts.get(clientId)?.abort();
       aborts.delete(clientId);
+      stopHosted(clientId);
       if (gone) releasePreviews(gone);
       emit();
     },
 
+    /**
+     * Uploads one file to storage the way the outbox does (the `upload` hook, or `readFile` then
+     * the client's upload) and resolves with its path: for files sent outside the queue, such as
+     * a scheduled message's.
+     */
+    uploadFile(conversationId: string, file: LocalFile, o: { signal?: AbortSignal; onProgress?: UploadProgress } = {}): Promise<string> {
+      return uploadFile(conversationId, file, o.signal, o.onProgress);
+    },
+
     pending(conversationId?: string): PendingMessage[] {
       return queue
         .filter((q) => !conversationId || q.input.conversationId === conversationId)

package/src/core/transfer.ts

@@ -0,0 +1,71 @@
+/**
+ * @feat:chat
+ * Sending bytes with progress, the same on every platform. fetch can't report how much of a
+ * request body has gone, so where XMLHttpRequest exists (browsers, React Native) the body goes
+ * through it and `onProgress(sent, total)` follows `upload.onprogress`; elsewhere it goes
+ * through fetch and reports once, at the end.
+ */
+import { ChatError } from "./client";
+
+export type UploadProgress = (sent: number, total: number) => void;
+
+export interface SendBytesOptions {
+  method?: "PUT" | "POST";
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+  onProgress?: UploadProgress;
+  /** For tests and runtimes without XMLHttpRequest. */
+  fetch?: typeof fetch;
+}
+
+const sizeOf = (body: Blob | ArrayBuffer) => (typeof Blob !== "undefined" && body instanceof Blob ? body.size : (body as ArrayBuffer).byteLength);
+
+/** A failed answer's code: a 5xx, 408 or no answer is worth retrying, 429 waits, any other 4xx is a refusal. */
+const refusal = (status: number) => (status >= 500 || status === 0 || status === 408 ? undefined : status === 429 ? "GS429" : "22023");
+
+const aborted = () => new ChatError("The upload was cancelled", "GSABORT", "upload");
+
+/** Sends `body` to `url`; resolves with the response text, throws a ChatError on a non-2xx answer. */
+export function sendBytes(url: string, body: Blob | ArrayBuffer, opts: SendBytesOptions = {}): Promise<string> {
+  const method = opts.method ?? "PUT";
+  const total = sizeOf(body);
+  if (opts.signal?.aborted) return Promise.reject(aborted());
+  if (typeof XMLHttpRequest === "undefined" || opts.fetch) {
+    const f = opts.fetch ?? fetch;
+    return f(url, { method, body, headers: opts.headers, signal: opts.signal }).then(async (res) => {
+      if (!res.ok) throw new ChatError(`The upload failed (${res.status})`, refusal(res.status), "upload");
+      opts.onProgress?.(total, total);
+      return res.text().catch(() => "");
+    });
+  }
+  return new Promise<string>((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const onAbort = () => xhr.abort();
+    const done = () => opts.signal?.removeEventListener("abort", onAbort);
+    xhr.open(method, url);
+    for (const [k, v] of Object.entries(opts.headers ?? {})) xhr.setRequestHeader(k, v);
+    if (opts.onProgress && xhr.upload) {
+      xhr.upload.onprogress = (e: ProgressEvent) => opts.onProgress?.(e.loaded, e.lengthComputable ? e.total : total);
+    }
+    xhr.onload = () => {
+      done();
+      if (xhr.status >= 200 && xhr.status < 300) {
+        opts.onProgress?.(total, total);
+        resolve(typeof xhr.responseText === "string" ? xhr.responseText : "");
+      } else {
+        reject(new ChatError(`The upload failed (${xhr.status})`, refusal(xhr.status), "upload"));
+      }
+    };
+    // No answer at all: the connection, worth retrying.
+    xhr.onerror = () => {
+      done();
+      reject(new ChatError("The upload didn't reach the server", undefined, "upload"));
+    };
+    xhr.onabort = () => {
+      done();
+      reject(aborted());
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    xhr.send(body);
+  });
+}

package/src/core/types.ts

@@ -204,6 +204,21 @@ export interface PendingFile {
   meta?: Partial<AttachmentInput>;
   /** Not kept between launches (bytes with nowhere to save them): attach it again. */
   lost?: boolean;
+  /** How much of it has uploaded, 0 to 1, once the upload reports progress. */
+  progress?: number;
+  /** Going to the hosted video provider (Mux, Cloudflare) rather than storage. */
+  hosted?: boolean;
+}
+
+/**
+ * A hosted video upload that has started: the provider's upload id, sent with the message as
+ * `{ provider, providerId, status: "pending" }` while the bytes still go up. The provider's
+ * webhook marks the attachment ready.
+ */
+export interface HostedAttachment {
+  provider: "mux" | "cloudflare";
+  providerId: string;
+  status: "pending";
 }
 
 /** A live hint from Realtime: something changed; fetch to see what. */
@@ -296,6 +311,8 @@ export interface ChatSearchHit {
   snippet: string;
   /** Found in a voice note's or video's transcript, not the text. */
   inTranscript: boolean;
+  /** The thread the message is a reply in (open that thread to show it); null on the main timeline. */
+  threadRootId: string | null;
 }
 
 /** Open Graph data for a link (fetched by the server's runner). Plain text: never render it as HTML. */

package/src/index.ts

@@ -9,5 +9,6 @@ export * from "./core/client";
 export * from "./core/media";
 export * from "./core/thread";
 export * from "./core/outbox";
+export * from "./core/transfer";
 export * from "./core/availability";
 export * from "./core/extras";

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

@@ -154,6 +154,22 @@ describe("the long-press sheet's +", () => {
   });
 });
 
+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" />;

package/src/native/__tests__/organise-screens.test.tsx

@@ -13,6 +13,8 @@ import { ChatNativeProvider } from "../context";
 import { ChatScheduledList, ChatScheduleSheet } from "../schedule-sheet";
 import { ChatSearchScreen } from "../search-screen";
 import { ChatThreadScreen } from "../thread-screen";
+import { scrollToShow } from "../topics";
+import { activePlaybackId, claimPlayback } from "../voice-player";
 
 vi.mock("react-native", async (original) => ({ ...(await original<object>()), useWindowDimensions: () => ({ width: 390, height: 844, scale: 3, fontScale: 1 }) }));
 
@@ -342,3 +344,81 @@ describe("ChatAvailabilityScreen", () => {
     await waitFor(() => expect(called(client, "setAvailability")[0]!.args[0]).toMatchObject({ awayMessage: null, awayUntil: null, hours: null }));
   });
 });
+
+describe("simulator check leftovers", () => {
+  const cohort = (closed: boolean, messages: MemoryConversationSeed["messages"] = []): MemoryConversationSeed => ({
+    id: "cohort",
+    kind: "cohort",
+    members: [{ userId: ME, role: "member" }, { userId: SAM }, { userId: LEE }],
+    topics: [{ topic: "week-1", title: "Week 1", closed }],
+    messages,
+  });
+
+  it("says a closed topic is closed when it has no messages, instead of inviting a hello", async () => {
+    const client = memory([cohort(true)]);
+    render(wrap(client, <ChatThreadScreen conversationId="cohort" testID="t" />));
+    fireEvent.click(await screen.findByTestId("t-topics-week-1"));
+    await waitFor(() => expect(screen.getByTestId("t-empty").textContent).toContain("This topic is closed."));
+    expect(screen.getByTestId("t-empty").textContent).not.toContain("Say hello below.");
+  });
+
+  it("still invites a hello in an open topic with no messages", async () => {
+    const client = memory([cohort(false)]);
+    render(wrap(client, <ChatThreadScreen conversationId="cohort" testID="t" />));
+    fireEvent.click(await screen.findByTestId("t-topics-week-1"));
+    await waitFor(() => expect(screen.getByTestId("t-empty").textContent).toContain("Say hello below."));
+  });
+
+  it("pauses what this thread is playing when the screen loses focus, and nothing of another's", async () => {
+    const client = memory([{ id: "dm", members: [{ userId: ME }, { userId: SAM }], messages: [{ id: "m1", senderId: SAM, body: "", attachments: [{ id: "att-1", kind: "voice", path: "dm/x/a.m4a" }] }] }]);
+    const view = render(wrap(client, <ChatThreadScreen conversationId="dm" testID="t" />));
+    await screen.findByTestId("t-message-m1");
+    const other = vi.fn();
+    claimPlayback("elsewhere", other);
+    view.rerender(wrap(client, <ChatThreadScreen conversationId="dm" focused={false} testID="t" />));
+    expect(other).not.toHaveBeenCalled();
+
+    view.rerender(wrap(client, <ChatThreadScreen conversationId="dm" testID="t" />));
+    const mine = vi.fn();
+    claimPlayback("att-1", mine);
+    view.rerender(wrap(client, <ChatThreadScreen conversationId="dm" focused={false} testID="t" />));
+    expect(mine).toHaveBeenCalledTimes(1);
+    expect(activePlaybackId()).toBeNull();
+  });
+
+  it("names the message in each scheduled row's Cancel, so two at the same time differ", async () => {
+    const client = memory([{ id: "dm", members: [{ userId: ME }, { userId: SAM }] }]);
+    const at = new Date(Date.now() + 3600_000);
+    await client.schedule({ conversationId: "dm", clientId: "c1", body: "first one", sendAt: at });
+    await client.schedule({ conversationId: "dm", clientId: "c2", body: "second one", sendAt: at });
+    render(wrap(client, <ChatScheduledList conversationId="dm" testID="l" />));
+    const cancels = await screen.findAllByText("Cancel");
+    const labels = cancels.map((c) => c.closest("button")!.getAttribute("aria-label"));
+    expect(new Set(labels).size).toBe(2);
+    expect(labels.some((l) => l?.startsWith("Cancel, first one, Scheduled for"))).toBe(true);
+    expect(labels.some((l) => l?.startsWith("Cancel, second one, Scheduled for"))).toBe(true);
+  });
+
+  it("sizes the schedule and topic sheets to their content", async () => {
+    const client = memory([{ ...cohort(false), members: [{ userId: ME, role: "owner" }, { userId: SAM }, { userId: LEE }] }]);
+    render(wrap(client, <ChatScheduleSheet open onOpenChange={vi.fn()} onSchedule={vi.fn()} testID="s" />));
+    const schedule = (await screen.findByTestId("s-pick-0")).closest("[role=dialog]")!;
+    expect(schedule.getAttribute("data-presentation-style")).toBeNull();
+    expect(schedule.getAttribute("data-transparent")).toBe("true");
+    cleanup();
+
+    render(wrap(client, <ChatThreadScreen conversationId="cohort" testID="t" />));
+    fireEvent.click(await screen.findByTestId("t-topics-menu"));
+    const topics = (await screen.findByTestId("t-topics-new")).closest("[role=dialog]")!;
+    expect(topics.getAttribute("data-transparent")).toBe("true");
+  });
+});
+
+describe("scrollToShow", () => {
+  it("brings a chip past either edge into view, and leaves one in view alone", () => {
+    expect(scrollToShow({ x: 400, width: 80 }, { offset: 0, width: 300 })).toBe(400 + 80 + 8 - 300);
+    expect(scrollToShow({ x: 20, width: 60 }, { offset: 100, width: 300 })).toBe(12);
+    expect(scrollToShow({ x: 120, width: 60 }, { offset: 100, width: 300 })).toBeNull();
+    expect(scrollToShow({ x: 120, width: 60 }, { offset: 0, width: 0 })).toBeNull();
+  });
+});