@marktiderman/genesis-chat 0.2.0 → 0.2.2

package/src/__tests__/outbox-hosted.test.ts

@@ -0,0 +1,269 @@
+/** @feat:chat Hosted uploads joining the outbox at start, and upload progress. */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createChatClient, type ChatClient, type ChatSupabase } from "../core/client";
+import { createOutbox, type HostedUpload, type HostedUploadStart, type OutboxStore, type QueuedMessage } from "../core/outbox";
+import { sendBytes } from "../core/transfer";
+import { installFakeXHR } from "./fake-xhr";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+/** Saves through JSON, as localStorage or MMKV would: nothing is shared with the live queue. */
+function jsonStore(): OutboxStore & { raw: () => QueuedMessage[] } {
+  let saved = "[]";
+  return {
+    load: async () => JSON.parse(saved) as QueuedMessage[],
+    save: async (q) => void (saved = JSON.stringify(q)),
+    raw: () => JSON.parse(saved) as QueuedMessage[],
+  };
+}
+
+/** A client whose send is idempotent by clientId, like send_message. */
+function fakeClient() {
+  const posted = new Map<string, { id: string; input: Record<string, unknown> }>();
+  const sends: Record<string, unknown>[] = [];
+  const client = {
+    upload: vi.fn(async (_c: string, _u: string, _d: unknown, o: { name: string; onProgress?: (s: number, t: number) => void }) => {
+      o.onProgress?.(5, 10);
+      return `c1/me/${o.name}`;
+    }),
+    send: vi.fn(async (input: Record<string, unknown>) => {
+      sends.push(input);
+      const clientId = String(input.clientId);
+      if (!posted.has(clientId)) posted.set(clientId, { id: `m-${posted.size + 1}`, input });
+      const p = posted.get(clientId)!;
+      return { id: p.id, conversationId: input.conversationId, clientId, seq: 1 } as never;
+    }),
+  } as unknown as ChatClient;
+  return { client, sends, posted };
+}
+
+/** A hosted upload whose bytes finish when the test says. */
+function hostedHook() {
+  const calls: { file: string; resume?: unknown }[] = [];
+  const finishers: { resolve: () => void; reject: (e: unknown) => void }[] = [];
+  let n = 0;
+  const hook: HostedUpload = vi.fn(async (_conversationId, file, opts) => {
+    calls.push({ file: file.name, resume: opts.resume });
+    const done = new Promise<void>((resolve, reject) => finishers.push({ resolve, reject }));
+    const start: HostedUploadStart = {
+      provider: "mux",
+      providerId: opts.resume?.providerId ?? `upl_${++n}`,
+      status: "pending",
+      url: opts.resume?.url ?? `https://up.test/${n}`,
+      done,
+    };
+    return start;
+  });
+  return { hook, calls, finishers };
+}
+
+const video = (name = "clip.mp4") => ({ data: `file:///cache/${name}`, name, contentType: "video/mp4", hosted: true, meta: { kind: "video" as const, durationMs: 3000 } });
+
+describe("a hosted video joins the outbox at start", () => {
+  it("is sent in its place, pending, before its bytes are up; text written after it lands after it", async () => {
+    const { client, sends } = fakeClient();
+    const h = hostedHook();
+    const outbox = createOutbox({ client, userId: "me", hostedUpload: h.hook, readFile: async () => new Blob(["v"]) });
+    const videoId = await outbox.send({ conversationId: "c1", body: "" }, [video()]);
+    const textId = await outbox.send({ conversationId: "c1", body: "Watch this" });
+    await tick();
+    await tick();
+    expect(sends.map((s) => s.clientId)).toEqual([videoId, textId]);
+    expect(sends[0]!.attachments).toEqual([
+      expect.objectContaining({ kind: "video", provider: "mux", providerId: "upl_1", status: "pending", mime: "video/mp4", durationMs: 3000 }),
+    ]);
+    // Nothing went to storage.
+    expect(client.upload).not.toHaveBeenCalled();
+    // Posted, it waits only for its bytes.
+    expect(outbox.pending("c1")).toEqual([expect.objectContaining({ clientId: videoId, sentMessageId: "m-1", status: "sending" })]);
+    h.finishers[0]!.resolve();
+    await tick();
+    expect(outbox.pending("c1")).toEqual([]);
+  });
+
+  it("carries the upload on after a relaunch and sends the message again with the same clientId and upload id", async () => {
+    const store = jsonStore();
+    const first = fakeClient();
+    const h1 = hostedHook();
+    const before = createOutbox({ client: first.client, userId: "me", store, hostedUpload: h1.hook });
+    const id = await before.send({ conversationId: "c1", body: "" }, [video()]);
+    await tick();
+    await tick();
+    expect(first.sends).toHaveLength(1);
+    expect(store.raw()[0]).toMatchObject({ clientId: id, hosted: { 0: { provider: "mux", providerId: "upl_1", url: "https://up.test/1" } } });
+
+    // The app closes with the bytes half up; it opens again.
+    const h2 = hostedHook();
+    const after = createOutbox({ client: first.client, userId: "me", store, hostedUpload: h2.hook });
+    await after.load();
+    await after.retryAll();
+    await tick();
+    await tick();
+    expect(h2.calls).toEqual([{ file: "clip.mp4", resume: expect.objectContaining({ provider: "mux", providerId: "upl_1", url: "https://up.test/1" }) }]);
+    expect(first.sends).toHaveLength(2);
+    expect(first.sends[1]).toMatchObject({ clientId: id, attachments: [expect.objectContaining({ providerId: "upl_1", status: "pending" })] });
+    // Posted once.
+    expect(first.posted.size).toBe(1);
+    h2.finishers[0]!.resolve();
+    await tick();
+    expect(after.pending()).toEqual([]);
+    expect(store.raw()).toEqual([]);
+  });
+
+  it("a failed transfer marks the posted message failed without holding later ones; Retry carries the same upload on", async () => {
+    const { client, sends } = fakeClient();
+    const h = hostedHook();
+    const outbox = createOutbox({ client, userId: "me", hostedUpload: h.hook });
+    const videoId = await outbox.send({ conversationId: "c1", body: "" }, [video()]);
+    await tick();
+    h.finishers[0]!.reject(new Error("network"));
+    await tick();
+    await tick();
+    expect(outbox.pending("c1")[0]).toMatchObject({ clientId: videoId, status: "failed", error: "The video didn't finish uploading" });
+    await outbox.send({ conversationId: "c1", body: "Still here" });
+    await tick();
+    expect(sends.at(-1)).toMatchObject({ body: "Still here" });
+
+    await outbox.retry(videoId);
+    await tick();
+    await tick();
+    expect(h.calls.at(-1)).toEqual({ file: "clip.mp4", resume: expect.objectContaining({ providerId: "upl_1" }) });
+    h.finishers.at(-1)!.resolve();
+    await tick();
+    expect(outbox.pending("c1")).toEqual([]);
+  });
+
+  it("goes to storage, as before, without a hostedUpload", async () => {
+    const { client, sends } = fakeClient();
+    const outbox = createOutbox({ client, userId: "me", readFile: async () => new Blob(["v"]) });
+    await outbox.send({ conversationId: "c1", body: "" }, [video()]);
+    await tick();
+    await tick();
+    expect(client.upload).toHaveBeenCalledTimes(1);
+    expect(sends[0]!.attachments).toEqual([expect.objectContaining({ kind: "video", path: "c1/me/clip.mp4" })]);
+  });
+
+  it("discarding the message stops its bytes", async () => {
+    const { client } = fakeClient();
+    let signal: AbortSignal | undefined;
+    const hook: HostedUpload = async (_c, _f, opts) => {
+      signal = opts.signal;
+      return { provider: "mux", providerId: "upl_x", status: "pending", done: new Promise<void>(() => undefined) };
+    };
+    const outbox = createOutbox({ client, userId: "me", hostedUpload: hook });
+    const id = await outbox.send({ conversationId: "c1", body: "" }, [video()]);
+    await tick();
+    await outbox.discard(id);
+    expect(signal?.aborted).toBe(true);
+    expect(outbox.pending()).toEqual([]);
+  });
+});
+
+describe("upload progress", () => {
+  it("shows each storage file's progress on the pending message", async () => {
+    const { client } = fakeClient();
+    let finish!: () => void;
+    let report!: (s: number, t: number) => void;
+    (client.upload as ReturnType<typeof vi.fn>).mockImplementationOnce(
+      (_c: string, _u: string, _d: unknown, o: { name: string; onProgress?: (s: number, t: number) => void }) =>
+        new Promise((r) => {
+          report = o.onProgress!;
+          finish = () => r(`c1/me/${o.name}`);
+        }),
+    );
+    const changes: QueuedMessage[][] = [];
+    const outbox = createOutbox({ client, userId: "me", onChange: (q) => changes.push(q) });
+    await outbox.send({ conversationId: "c1" }, [{ data: new Blob(["0123456789"]), name: "a.png", contentType: "image/png" }]);
+    await tick();
+    report(4, 10);
+    expect(outbox.pending("c1")[0]!.files?.[0]?.progress).toBe(0.4);
+    report(10, 10);
+    expect(outbox.pending("c1")[0]!.files?.[0]?.progress).toBe(1);
+    finish();
+    await tick();
+    expect(outbox.pending("c1")).toEqual([]);
+  });
+
+  it("passes onProgress to the app's upload hook too", async () => {
+    const { client } = fakeClient();
+    let seen = 0;
+    const outbox = createOutbox({
+      client,
+      userId: "me",
+      upload: async (_c, file, o) => {
+        o?.onProgress?.(1, 2);
+        seen = outbox.pending("c1")[0]!.files![0]!.progress!;
+        return `c1/me/${file.name}`;
+      },
+    });
+    await outbox.send({ conversationId: "c1" }, [{ data: "file:///a.jpg", name: "a.jpg", contentType: "image/jpeg" }]);
+    await tick();
+    expect(seen).toBe(0.5);
+  });
+});
+
+describe("client.upload with onProgress", () => {
+  function storageFake() {
+    const signedFor: string[] = [];
+    const plain: string[] = [];
+    const supabase = {
+      schema: () => ({}),
+      storage: {
+        from: () => ({
+          createSignedUploadUrl: async (path: string) => {
+            signedFor.push(path);
+            return { data: { signedUrl: `https://sb.test/storage/v1/object/upload/sign/genesis-chat/${path}?token=t`, path, token: "t" }, error: null };
+          },
+          upload: async (path: string) => {
+            plain.push(path);
+            return { data: { path }, error: null };
+          },
+        }),
+      },
+    } as unknown as ChatSupabase;
+    return { supabase, signedFor, plain };
+  }
+
+  it("sends the bytes to a signed upload URL through XMLHttpRequest and reports progress", async () => {
+    const XHR = installFakeXHR();
+    const s = storageFake();
+    const client = createChatClient(s.supabase);
+    const progress: number[][] = [];
+    const going = client.upload("c1", "me", new Blob(["0123456789"]), { name: "a.png", contentType: "image/png", id: "f1", onProgress: (a, b) => progress.push([a, b]) });
+    await tick();
+    const xhr = XHR.all[0]!;
+    expect(xhr).toMatchObject({ method: "PUT", url: "https://sb.test/storage/v1/object/upload/sign/genesis-chat/c1/me/f1.png?token=t", sent: true });
+    expect(xhr.headers).toMatchObject({ "content-type": "image/png", "x-upsert": "false" });
+    xhr.progress(3, 10);
+    xhr.respond(200, "{}");
+    expect(await going).toBe("c1/me/f1.png");
+    expect(progress).toEqual([
+      [3, 10],
+      [10, 10],
+    ]);
+    expect(s.plain).toEqual([]);
+  });
+
+  it("uses the plain upload without onProgress", async () => {
+    installFakeXHR();
+    const s = storageFake();
+    const client = createChatClient(s.supabase);
+    expect(await client.upload("c1", "me", new Blob(["x"]), { name: "a.png", contentType: "image/png", id: "f2" })).toBe("c1/me/f2.png");
+    expect(s.plain).toEqual(["c1/me/f2.png"]);
+    expect(s.signedFor).toEqual([]);
+  });
+
+  it("a refused PUT is a permanent ChatError; a dropped connection is transient", async () => {
+    const XHR = installFakeXHR();
+    const refused = sendBytes("https://x.test/a", new Blob(["x"]));
+    XHR.all[0]!.respond(403);
+    await expect(refused).rejects.toMatchObject({ name: "ChatError", permanent: true });
+    const dropped = sendBytes("https://x.test/b", new Blob(["x"]));
+    XHR.all[1]!.fail();
+    await expect(dropped).rejects.toMatchObject({ name: "ChatError", transient: true });
+  });
+});

package/src/__tests__/review-279.test.ts

@@ -0,0 +1,41 @@
+/** @feat:chat Fixes from the review of release 279: upload refusals, and what app cards are told. */
+import { describe, expect, it } from "vitest";
+import { ChatError } from "../core/client";
+import { sendBytes } from "../core/transfer";
+import type { ChatAttachment } from "../core/types";
+import type { ChatAttachmentKind, ChatCardContext } from "../react/index";
+import { attachmentCardOf } from "../web/attachments";
+
+const answering = (status: number) => (async () => new Response("", { status })) as unknown as typeof fetch;
+const failure = (status: number) => sendBytes("https://x.test/a", new Blob(["x"]), { fetch: answering(status) }).then(
+    () => { throw new Error("expected a failure"); },
+    (e: ChatError) => e,
+  );
+
+describe("an upload's failed answer", () => {
+  it("is retried on its own after a timeout or a server error", async () => {
+    expect((await failure(408)).transient).toBe(true);
+    expect((await failure(503)).transient).toBe(true);
+  });
+  it("waits when rate limited, without blocking the conversation as a refusal would", async () => {
+    const e = await failure(429);
+    expect(e.rateLimited).toBe(true);
+    expect(e.permanent).toBe(false);
+  });
+  it("is a refusal for any other 4xx", async () => {
+    expect((await failure(403)).permanent).toBe(true);
+  });
+});
+
+describe("an app card on the web", () => {
+  const checkIn: ChatAttachmentKind = {
+    title: () => "Check-in",
+    action: (_a, ctx?: ChatCardContext) => (ctx?.mine ? null : { label: "Answer", href: "https://app.test/check-in" }),
+  };
+  const a = { kind: "check_in", ref: {} } as unknown as ChatAttachment;
+
+  it("is told whether it is on your own message", () => {
+    expect(attachmentCardOf(checkIn, a, { mine: false })?.action?.label).toBe("Answer");
+    expect(attachmentCardOf(checkIn, a, { mine: true })?.action).toBeNull();
+  });
+});

package/src/__tests__/review-fixes-web.test.tsx

@@ -24,6 +24,7 @@ import {
   type MemoryChatOptions,
   type MemoryConversationSeed,
 } from "../web";
+import { installFakeXHR } from "./fake-xhr";
 
 afterEach(() => {
   cleanup();
@@ -343,22 +344,24 @@ describe("the camera", () => {
     await screen.findByTestId("genesis-chat-video-retake");
   }
 
-  it("cancels a hosted video upload, sending nothing", async () => {
-    let signal: AbortSignal | undefined;
-    vi.stubGlobal("fetch", vi.fn((_url: string, init: RequestInit) => new Promise((_r, reject) => {
-      signal = init.signal ?? undefined;
-      signal?.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
-    })));
+  it("a hosted video keeps its place: text typed after it lands after it, while its bytes still go up", async () => {
+    const XHR = installFakeXHR();
     const client = make(dm());
     mount(client, <ChatThread conversationId="c1" resolveUser={resolveUser} />, { videoUpload: { create: async () => ({ url: "https://up.test/1", providerId: "u1", provider: "mux" }) } });
     await recordTake();
     await act(async () => {
       fireEvent.click(screen.getByTestId("genesis-chat-video-send"));
     });
-    fireEvent.click(await screen.findByTestId("genesis-chat-video-cancel-upload"));
-    await waitFor(() => expect(signal?.aborted).toBe(true));
-    await screen.findByTestId("genesis-chat-video-send");
-    expect(client.calls.some((c) => c.method === "send")).toBe(false);
+    // The dialog closes at once; the upload carries on.
+    await waitFor(() => expect(screen.queryByTestId("genesis-chat-video-recorder")).toBeNull());
+    fireEvent.change(await screen.findByTestId("genesis-chat-input"), { target: { value: "Watch this" } });
+    fireEvent.keyDown(screen.getByTestId("genesis-chat-input"), { key: "Enter" });
+    await waitFor(() => expect(client.calls.filter((c) => c.method === "send").length).toBe(2));
+    const sends = client.calls.filter((c) => c.method === "send").map((c) => c.args[0] as { body: string; attachments?: { provider?: string; status?: string }[] });
+    expect(sends[0]!.attachments?.[0]).toMatchObject({ provider: "mux", status: "pending" });
+    expect(sends[1]!.body).toBe("Watch this");
+    expect(XHR.all[0]!.status).toBe(0);
+    act(() => XHR.all[0]!.respond(200));
   });
 
   it("keeps the take's preview while it uploads, and frees it once the message lands", async () => {

package/src/__tests__/server-fake-video.test.ts

@@ -0,0 +1,81 @@
+/** @feat:chat The dev-only fake hosted video provider. */
+import { describe, expect, it } from "vitest";
+import { chatUploadPassthrough, createVideoUploadHandler, fakeVideoProvider } from "../server";
+import { fakeSupabase, type Row } from "./server-fakes";
+
+const CONV = "11111111-1111-4111-8111-111111111111";
+const USER = "22222222-2222-4222-8222-222222222222";
+
+function setup(attachments: Row[] = [], over: { readyWaitMs?: number } = {}) {
+  const tables = { attachments };
+  const sb = fakeSupabase({ tables, rpc: { update_attachment: () => null } });
+  const video = fakeVideoProvider({ supabase: sb.client, uploadUrl: "http://localhost:3000/dev/fake-video", env: "development", newId: () => "abc", sleep: async () => undefined, ...over });
+  return { sb, video, tables };
+}
+
+describe("fakeVideoProvider", () => {
+  it("refuses to run in production unless forced", () => {
+    const sb = fakeSupabase({});
+    expect(() => fakeVideoProvider({ supabase: sb.client, uploadUrl: "http://localhost/x", env: "production" })).toThrow(/production/);
+    expect(() => fakeVideoProvider({ supabase: sb.client, uploadUrl: "http://localhost/x", env: "production", force: true })).not.toThrow();
+  });
+
+  it("mints a local upload URL and id through the usual upload handler", async () => {
+    const { video } = setup();
+    const handler = createVideoUploadHandler({ video, authorize: () => ({ userId: USER }), corsOrigin: "http://localhost:3000" });
+    const res = await handler(new Request("http://localhost:3000/api/video-upload", { method: "POST", body: JSON.stringify({ conversationId: CONV }) }));
+    expect(await res.json()).toEqual({ url: "http://localhost:3000/dev/fake-video?id=fake_abc", providerId: "fake_abc", provider: "mux" });
+  });
+
+  it("markReady does what Mux's ready webhook does: ready, a playback id and a fake HLS URL", async () => {
+    const { sb, video } = setup([{ id: "att1", provider: "mux", provider_id: "fake_abc" }]);
+    await video.markReady("fake_abc", { durationMs: 4200.4, posterPath: `${CONV}/${USER}/p.jpg` });
+    expect(sb.rpcCalls).toEqual([
+      {
+        fn: "update_attachment",
+        args: {
+          p_attachment_id: "att1",
+          p_patch: {
+            status: "ready",
+            playback_id: "fake-fake_abc",
+            url: "https://fake-video.invalid/fake_abc.m3u8",
+            transcript_status: "off",
+            duration_ms: 4200,
+            poster_path: `${CONV}/${USER}/p.jpg`,
+          },
+        },
+      },
+    ]);
+  });
+
+  it("says so when no message carries the upload yet", async () => {
+    const { video } = setup();
+    await expect(video.markReady("fake_nope")).rejects.toThrow(/is its message sent/);
+  });
+
+  it("its handler stores the PUT body in the genesis-chat bucket, then marks the attachment ready", async () => {
+    const { sb, video } = setup([{ id: "att1", provider: "mux", provider_id: "fake_abc" }]);
+    const { url } = await video.createUpload({ corsOrigin: "http://localhost:3000", passthrough: chatUploadPassthrough({ conversationId: CONV, userId: USER }) });
+    const res = await video.handler(new Request(url, { method: "PUT", body: new Uint8Array([1, 2, 3]), headers: { "content-type": "video/webm" } }));
+    expect(res.status).toBe(200);
+    expect(res.headers.get("access-control-allow-origin")).toBe("http://localhost:3000");
+    expect(sb.uploaded).toEqual([{ bucket: "genesis-chat", path: `${CONV}/${USER}/fake_abc.webm`, bytes: 3, contentType: "video/webm" }]);
+    expect(sb.rpcCalls.map((c) => c.fn)).toEqual(["update_attachment"]);
+    expect(await video.playbackUrl("fake-fake_abc")).toBe(`https://files.test/${CONV}/${USER}/fake_abc.webm?token=x`);
+  });
+
+  it("stores the body and answers 202 when the message hasn't arrived in time", async () => {
+    const { sb, video } = setup([], { readyWaitMs: 0 });
+    const { url } = await video.createUpload({ corsOrigin: "http://localhost:3000", passthrough: chatUploadPassthrough({ conversationId: CONV }) });
+    const res = await video.handler(new Request(url, { method: "PUT", body: new Uint8Array([1]) }));
+    expect(res.status).toBe(202);
+    expect(await res.json()).toMatchObject({ stored: true, ready: false, providerId: "fake_abc" });
+    expect(sb.uploaded).toHaveLength(1);
+  });
+
+  it("answers a preflight, and refuses an unknown upload", async () => {
+    const { video } = setup();
+    expect((await video.handler(new Request("http://localhost:3000/dev/fake-video?id=x", { method: "OPTIONS" }))).status).toBe(204);
+    expect((await video.handler(new Request("http://localhost:3000/dev/fake-video?id=x", { method: "PUT", body: "x" }))).status).toBe(404);
+  });
+});

package/src/__tests__/server-fakes.ts

@@ -10,6 +10,7 @@ export interface FakeSupabase {
   rpcCalls: { fn: string; args: Record<string, unknown> }[];
   removed: { bucket: string; paths: string[] }[];
   signed: string[];
+  uploaded: { bucket: string; path: string; bytes: number; contentType?: string }[];
 }
 
 /** rpc results by function name; tables as arrays of rows, filtered by eq(). */
@@ -22,6 +23,7 @@ export function fakeSupabase(opts: {
   const rpcCalls: FakeSupabase["rpcCalls"] = [];
   const removed: FakeSupabase["removed"] = [];
   const signed: string[] = [];
+  const uploaded: FakeSupabase["uploaded"] = [];
   const builder = (table: string) => {
     const filters: [string, unknown][] = [];
     let orderBy: string | null = null;
@@ -58,6 +60,10 @@ export function fakeSupabase(opts: {
           removed.push({ bucket, paths });
           return { data: opts.removeError ? null : paths.map((name) => ({ name })), error: opts.removeError ?? null };
         },
+        upload: async (path: string, body: ArrayBuffer, o?: { contentType?: string }) => {
+          uploaded.push({ bucket, path, bytes: body.byteLength, contentType: o?.contentType });
+          return { data: { path }, error: null };
+        },
         createSignedUrl: async (path: string, seconds: number) => {
           signed.push(`${path}@${seconds}`);
           return opts.signedUrlError
@@ -67,7 +73,7 @@ export function fakeSupabase(opts: {
       }),
     },
   };
-  return { client: client as unknown as ChatSupabase, rpcCalls, removed, signed };
+  return { client: client as unknown as ChatSupabase, rpcCalls, removed, signed, uploaded };
 }
 
 export interface FakeFetch {

package/src/__tests__/server-safety.test.ts

@@ -142,10 +142,23 @@ describe("createLinkUnfurler", () => {
     ["a long attribute name", "a"],
     ["unclosed tags in a title", "<title>" + "<".repeat(1000)],
   ])("parses a 512 KiB page of %s in linear time", (_, unit) => {
-    const page = unit.repeat(Math.ceil((512 * 1024) / unit.length));
-    const started = performance.now();
-    parseOpenGraph(unit === "a" ? `<meta ${page}>` : page, "https://x.example/");
-    expect(performance.now() - started).toBeLessThan(500);
+    // Time grows with the page, not its square: four times the bytes may take about four times as
+    // long (quadratic would take sixteen). Compared against the same machine's smaller page, so a
+    // slow CI runner can't fail it; the best of three runs keeps a pause from counting.
+    const timeFor = (bytes: number) => {
+      const page = unit.repeat(Math.ceil(bytes / unit.length));
+      const html = unit === "a" ? `<meta ${page}>` : page;
+      let best = Infinity;
+      for (let i = 0; i < 3; i++) {
+        const started = performance.now();
+        parseOpenGraph(html, "https://x.example/");
+        best = Math.min(best, performance.now() - started);
+      }
+      return best;
+    };
+    const small = timeFor(128 * 1024);
+    const large = timeFor(512 * 1024);
+    expect(large).toBeLessThan(small * 10 + 50);
   });
 
   it("still reads a title and an unclosed script runs to the end", () => {

package/src/__tests__/web.test.tsx

@@ -237,6 +237,22 @@ describe("ChatInbox", () => {
     expect(document.activeElement).toBe(groupRow);
   });
 
+  it("previews a message that is only an app card by its kind's title", async () => {
+    const client = createMemoryChatClient({
+      me: ME,
+      conversations: [{ id: "d1", members: [{ userId: ME }, { userId: SAM }], messages: [{ senderId: SAM, body: "", createdAt: at(10), attachments: [{ kind: "check_in" }] }] }],
+    });
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    render(
+      <QueryClientProvider client={queryClient}>
+        <ChatProvider client={client} userId={ME} attachmentKinds={{ check_in: { title: () => "Check-in" } }}>
+          <ChatInbox resolveUser={resolveUser} onSelect={() => undefined} />
+        </ChatProvider>
+      </QueryClientProvider>,
+    );
+    expect((await screen.findByTestId("genesis-chat-inbox-row-d1")).textContent).toContain("Check-in");
+  });
+
   it("shows an empty state when there are none", async () => {
     const client = createMemoryChatClient({ me: ME, conversations: [] });
     mount(client, <ChatInbox resolveUser={resolveUser} onSelect={() => undefined} />);

package/src/core/client.ts

@@ -29,6 +29,7 @@ import type {
 } from "./types";
 import { normalizeHours } from "./availability";
 import { fileExtension, isAllowedExtension, randomId } from "./media";
+import { sendBytes, type UploadProgress } from "./transfer";
 
 /** Any supabase-js client; the app's generated Database types don't need to list genesis_chat. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -254,6 +255,7 @@ export function toSearchHit(r: Row): ChatSearchHit {
     createdAt: String(r.created_at),
     snippet: String(r.snippet ?? ""),
     inTranscript: Boolean(r.in_transcript),
+    threadRootId: str(r.thread_root_id),
   };
 }
 
@@ -643,13 +645,37 @@ export function createChatClient(supabase: ChatSupabase, options: ChatClientOpti
      * Uploads a file into the conversation's folder for the signed-in person and
      * returns its path, ready to attach. Resumable for big files is the native
      * renderer's job (Supabase TUS); this is the plain upload.
+     *
+     * With `onProgress(sent, total)`, where XMLHttpRequest exists (browsers, React Native), the
+     * bytes go to a signed upload URL (`createSignedUploadUrl`, which checks the same storage
+     * policy as a plain upload) through XMLHttpRequest, which reports progress; elsewhere the
+     * plain upload runs and reports once, at the end. `signal` cancels it.
      */
-    async upload(conversationId: string, userId: string, file: Blob | ArrayBuffer, opts: { name: string; contentType: string; id?: string }) {
+    async upload(
+      conversationId: string,
+      userId: string,
+      file: Blob | ArrayBuffer,
+      opts: { name: string; contentType: string; id?: string; onProgress?: UploadProgress; signal?: AbortSignal },
+    ) {
       const ext = fileExtension(opts.name, opts.contentType);
       if (!isAllowedExtension(ext)) throw new ChatError(`Files of type .${ext} can't be sent`, "22023", "upload");
       const id = opts.id ?? randomId();
       const path = `${conversationId}/${userId}/${id}.${ext}`;
-      must("upload", await supabase.storage.from(CHAT_BUCKET).upload(path, file, { contentType: opts.contentType, upsert: false }));
+      const bucket = supabase.storage.from(CHAT_BUCKET);
+      if (opts.onProgress && typeof XMLHttpRequest !== "undefined" && typeof bucket.createSignedUploadUrl === "function") {
+        const signed = must<{ signedUrl: string } | null>("upload", await bucket.createSignedUploadUrl(path));
+        if (!signed?.signedUrl) throw new ChatError("No upload URL came back", undefined, "upload");
+        await sendBytes(signed.signedUrl, file, {
+          method: "PUT",
+          headers: { "content-type": opts.contentType, "x-upsert": "false", "cache-control": "max-age=3600" },
+          signal: opts.signal,
+          onProgress: opts.onProgress,
+        });
+        return path;
+      }
+      must("upload", await bucket.upload(path, file, { contentType: opts.contentType, upsert: false }));
+      const total = typeof Blob !== "undefined" && file instanceof Blob ? file.size : (file as ArrayBuffer).byteLength;
+      opts.onProgress?.(total, total);
       return path;
     },