@marktiderman/genesis-chat 0.1.0 → 0.2.0

package/dist/outbox-B0y3phE0.d.ts

@@ -0,0 +1,151 @@
+import { b as AttachmentKind, A as AttachmentInput, i as ChatClient, B as PendingMessage, P as PendingFile, q as ChatMessage, E as SendInput } from './client-DMa2j7kz.js';
+
+/**
+ * @feat:chat
+ * Media rules shared by every platform: which files may be sent (the same list
+ * migration 0001 checks), what kind an upload becomes, the default limits, and
+ * the waveform a voice note carries so its bubble draws before the audio loads.
+ */
+
+/**
+ * A random UUID (v4): `crypto.randomUUID` where the platform has it (some React Native
+ * runtimes don't), else `crypto.getRandomValues`, else Math.random as a last resort. Ids
+ * only need to be unique per sender: the server checks (sender, client_id).
+ */
+declare function randomId(): string;
+/** Mirrors genesis_chat.allowed_extension. Never SVG or HTML, which a browser runs as a page. */
+declare const ALLOWED_EXTENSIONS: readonly ["png", "jpg", "jpeg", "webp", "gif", "heic", "heif", "m4a", "aac", "mp3", "ogg", "oga", "opus", "weba", "webm", "mp4", "mov", "pdf", "txt", "csv", "docx", "xlsx", "pptx"];
+/** The extension a file is stored under: from its content type, else its name. */
+declare function fileExtension(name: string, contentType?: string): string;
+declare function isAllowedExtension(ext: string): boolean;
+/** What an upload becomes in a message. */
+declare function attachmentKindFor(contentType: string, opts?: {
+    recordedVoice?: boolean;
+}): AttachmentKind;
+/** Default limits (decision 5): an app may lower them, not raise them past the bucket's 100 MB. */
+declare const CHAT_LIMITS: {
+    /** Voice notes and videos, for members. */
+    readonly recordingMs: number;
+    /** For owners, admins and observers (coaches, staff). */
+    readonly staffRecordingMs: number;
+    readonly fileBytes: number;
+    readonly videoBytes: number;
+    readonly attachmentsPerMessage: 20;
+    readonly bodyChars: 10000;
+};
+/** The longest recording this role may make. */
+declare function recordingLimitMs(role: string | null | undefined): number;
+/**
+ * Peaks for a waveform: `count` values 0–100 from raw samples (-1…1), the loudest
+ * in each bucket, scaled so the loudest bucket is 100. Quiet recordings still show
+ * a shape; silence shows a flat line.
+ */
+declare function waveformPeaks(samples: ArrayLike<number>, count?: number): number[];
+/**
+ * Peaks from a level meter read while recording (expo-audio's `metering`, in dB,
+ * about -160…0): resampled to `count` values 0–100.
+ */
+declare function waveformFromMetering(levelsDb: number[], count?: number): number[];
+/** 0:42, 1:05:09. */
+declare function formatDuration(ms: number | null | undefined): string;
+/** Playback speeds offered for voice and video (free for everyone, decision 5). */
+declare const PLAYBACK_RATES: readonly [1, 1.5, 2];
+declare function nextPlaybackRate(rate: number): number;
+
+/**
+ * @feat:chat
+ * The send queue: a message shows at once as pending, its files upload, then it
+ * is sent with the clientId made when it was written, so a retry (after a lost
+ * connection, a closed app) never posts twice. Messages to one conversation go
+ * in the order they were written: the first that can't go (a lost file, a refusal)
+ * holds back the ones after it. A refusal (not allowed, bad data) is `permanent`
+ * 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 file still on the device, uploaded when its message is sent. */
+interface LocalFile {
+    /** The bytes, or (native) a file URI the platform reads in `readFile`. */
+    data: Blob | ArrayBuffer | string;
+    name: string;
+    contentType: string;
+    /** A preview to show while it uploads (an object URL, a file URI). The outbox owns it from here: see `releasePreview`. */
+    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"];
+    };
+}
+interface QueuedMessage extends Omit<PendingMessage, "files"> {
+    files: LocalFile[];
+    /** What each file is, kept with the saved copy (PendingMessage.files). */
+    pendingFiles?: PendingFile[];
+    /** Files lost on a relaunch (bytes that weren't persisted). */
+    lostFiles?: number;
+    attempts: number;
+}
+interface OutboxStore {
+    load(): Promise<QueuedMessage[]>;
+    save(queue: QueuedMessage[]): Promise<void>;
+}
+declare const memoryOutboxStore: () => OutboxStore;
+interface OutboxOptions {
+    client: ChatClient;
+    userId: string;
+    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>;
+    /** Called with every change, for the UI. */
+    onChange?: (queue: QueuedMessage[]) => void;
+    /** Called when a message lands. */
+    onSent?: (message: ChatMessage, clientId: string) => void;
+    /** Makes client ids. Default: a random UUID (works where crypto.randomUUID is missing). */
+    newId?: () => string;
+    /**
+     * Keeps a file held as bytes (a pasted image, a recording) between launches: write it
+     * somewhere and return a URI `readFile` can read (native: the app's cache directory).
+     * Without it, such a file isn't saved, and after a relaunch its message asks for it again.
+     */
+    persistFile?: (file: LocalFile) => Promise<string>;
+    /**
+     * Lets go of a file's `previewUrl` once its message has landed, been discarded or cleared.
+     * Default: revokes `blob:` object URLs (the web's), and leaves everything else alone.
+     */
+    releasePreview?: (url: string) => void;
+}
+/** Revokes a `blob:` object URL; anything else (a native file URI) is left alone. */
+declare function releaseObjectUrl(url: string): void;
+declare function createOutbox(opts: OutboxOptions): {
+    /** Queues a message; it shows at once and sends in order. Returns its clientId. */
+    send(input: Omit<SendInput, "clientId"> & {
+        clientId?: string;
+    }, files?: LocalFile[]): Promise<string>;
+    retry(clientId: string): Promise<void>;
+    /**
+     * Gives a message the files it lost on a relaunch and sends it. `files` fill the lost
+     * slots in order (`PendingMessage.files[i].lost`); the files that were kept stay. Pass
+     * one per lost slot; with fewer, the message keeps waiting for the rest.
+     */
+    reattach(clientId: string, files: LocalFile[]): Promise<void>;
+    /**
+     * Retries failed messages (after the connection comes back), in order per conversation,
+     * stopping at the first that can't go on its own: one waiting for a lost file, or one the
+     * server refused (`permanent`, retried only by hand). The ones after it keep waiting.
+     */
+    retryAll(): Promise<void>;
+    /** Forgets every queued message, here and in the store (call it on sign-out). */
+    clear(): Promise<void>;
+    discard(clientId: string): Promise<void>;
+    pending(conversationId?: string): PendingMessage[];
+    /** A new client id, made the way this outbox makes them. */
+    newId: typeof randomId;
+    load: () => Promise<void>;
+};
+type Outbox = ReturnType<typeof createOutbox>;
+
+export { ALLOWED_EXTENSIONS as A, CHAT_LIMITS as C, type LocalFile as L, type Outbox as O, PLAYBACK_RATES as P, type QueuedMessage as Q, type OutboxOptions as a, type OutboxStore as b, attachmentKindFor as c, createOutbox as d, formatDuration as e, fileExtension as f, recordingLimitMs as g, releaseObjectUrl as h, isAllowedExtension as i, waveformPeaks as j, memoryOutboxStore as m, nextPlaybackRate as n, randomId as r, waveformFromMetering as w };

package/dist/push.d.ts

@@ -0,0 +1,206 @@
+import { i as ChatClient } from './client-DMa2j7kz.js';
+import { O as Outbox, b as OutboxStore, Q as QueuedMessage } from './outbox-B0y3phE0.js';
+import '@supabase/supabase-js';
+
+/**
+ * @feat:chat
+ * Push glue for genesis-native's push block, data only: the `messages`
+ * category (a switch in Notification settings and an Android channel), its
+ * notification actions (Reply with a text field, Mark read), what a tap opens
+ * (`data.url` = `/messages/<conversationId>`), the reply and mark-read
+ * handlers for the block's `onResponse`, and the match that keeps a thread's
+ * own pushes out of the foreground while it is open (the block's `suppress`).
+ *
+ *   const push = createPush({ …, categories: [...yours, chatPushCategory()],
+ *     onResponse: (r) => void handleChatPushResponse(r, { client: chatClient, notifications: Notifications }) });
+ *   void registerChatNotificationActions(Notifications);       // once, at start
+ *   useSuppressNotifications(chatThreadMatch(conversationId)); // in the thread screen
+ *
+ * The sender sets `categoryId: "messages"` (iOS) / the `messages` channel
+ * (Android) and `data: { url: "/messages/<id>", conversationId, seq, messageId }`;
+ * `chatPushPayload` builds those and the fields iOS rich push reads (the
+ * sender's name and photo, the group, a photo), and it is server safe: import
+ * it from `@marktiderman/genesis-chat/push`.
+ *
+ * A reply goes through the outbox, so a phone that is offline keeps it: pass
+ * the live one (`useChat().outbox`) when the chat screens are mounted, and the
+ * persisted store and user id (`ChatProvider outboxStore`) for when they
+ * aren't. A reply that can't be sent then waits there, failed, with Retry in
+ * its thread.
+ */
+
+declare const CHAT_PUSH_CATEGORY = "messages";
+declare const CHAT_REPLY_ACTION = "reply";
+declare const CHAT_MARK_READ_ACTION = "mark-read";
+interface ChatPushCopy {
+    title: string;
+    description: string;
+    reply: string;
+    replySubmit: string;
+    replyPlaceholder: string;
+    markRead: string;
+}
+declare const chatPushCopy: ChatPushCopy;
+/** The path a message's push opens. */
+declare function chatPath(conversationId: string): string;
+/** The category for createPush's `categories` (genesis-native's NotificationCategory). */
+declare function chatPushCategory(copy?: Partial<ChatPushCopy>): {
+    id: string;
+    title: string;
+    description: string;
+    importance: "high";
+};
+/** expo-notifications' `setNotificationCategoryAsync`, the one call this needs. */
+interface NotificationCategoriesLike {
+    setNotificationCategoryAsync(identifier: string, actions: {
+        identifier: string;
+        buttonTitle: string;
+        textInput?: {
+            submitButtonTitle: string;
+            placeholder: string;
+        };
+        options?: {
+            opensAppToForeground?: boolean;
+            isDestructive?: boolean;
+            isAuthenticationRequired?: boolean;
+        };
+    }[], options?: Record<string, unknown>): Promise<unknown>;
+    dismissNotificationAsync?(identifier: string): Promise<void>;
+}
+/** The actions on a message's notification: Reply (a text field) and Mark read, neither opening the app. */
+declare function chatNotificationActions(copy?: Partial<ChatPushCopy>): ({
+    identifier: string;
+    buttonTitle: string;
+    textInput: {
+        submitButtonTitle: string;
+        placeholder: string;
+    };
+    options: {
+        opensAppToForeground: boolean;
+    };
+} | {
+    identifier: string;
+    buttonTitle: string;
+    options: {
+        opensAppToForeground: boolean;
+    };
+    textInput?: undefined;
+})[];
+/** Registers the actions with the OS (once, at start; it is idempotent). */
+declare function registerChatNotificationActions(notifications: NotificationCategoriesLike, copy?: Partial<ChatPushCopy>, onError?: (error: unknown) => void): Promise<unknown>;
+/** The conversation a push is about: `data.conversationId`, else the id in `data.url`. */
+declare function conversationIdFromData(data: Record<string, unknown> | null | undefined): string | null;
+/**
+ * The client id a reply from this notification sends with: the notification's
+ * own id, as a uuid (it already is one on iOS; anything else is hashed into
+ * one), so the same reply delivered twice posts once.
+ */
+declare function replyClientId(notificationId: string): string;
+/**
+ * The client id for one reply: from the notification's id, the message it is
+ * about (`data.messageId`) and the reply's text. The same reply delivered
+ * twice posts once; two replies to one conversation never share an id, even
+ * when iOS reuses the notification's id for a collapsed push.
+ */
+declare function replyClientIdFor(notificationId: string, data: Record<string, unknown> | null | undefined, body: string): string;
+/** The part of a notification response this reads (expo-notifications' `NotificationResponse`). */
+interface ChatPushResponseLike {
+    actionIdentifier: string;
+    /** The text typed into Reply. */
+    userText?: string;
+    notification: {
+        request: {
+            identifier: string;
+            content: {
+                data?: Record<string, unknown> | null;
+            };
+        };
+    };
+}
+/** "queued": the reply couldn't go now and waits in the outbox, failed, for Retry. */
+type ChatPushOutcome = "replied" | "queued" | "marked-read" | "ignored" | "failed";
+type LiveOutbox = Pick<Outbox, "send" | "pending"> & Partial<Pick<Outbox, "load">>;
+/** How long a reply queued in the live outbox is waited for before it counts as queued, not sent. */
+declare const PUSH_REPLY_WAIT_MS = 15000;
+/** Where a reply waits when it can't go now. */
+interface ChatPushOutboxDeps {
+    /** The live outbox (`useChat().outbox`), or a getter for it (read again after a slow failure): the reply is queued there and sent in order. */
+    outbox?: LiveOutbox | null | (() => LiveOutbox | null | undefined);
+    /** Without a live outbox: the persisted store (`ChatProvider outboxStore`) a reply that failed is added to. */
+    store?: OutboxStore | null;
+    /** Whose store it is (the signed-in user's id). */
+    userId?: string | null;
+}
+/** A reply that couldn't be sent, as the outbox keeps it: shown failed in its thread, with Retry. */
+declare function failedReply(input: {
+    conversationId: string;
+    clientId: string;
+    body: string;
+}, userId: string, error?: string): QueuedMessage;
+/**
+ * Handles Reply and Mark read from a message's notification (pass it as the
+ * push block's `onResponse`). Taps on the notification itself are the block's
+ * routing, not this. Never throws: a failure is the outcome "failed" (and
+ * `onError`).
+ */
+declare function handleChatPushResponse(response: ChatPushResponseLike, deps: {
+    client: Pick<ChatClient, "send" | "markRead">;
+    notifications?: Pick<NotificationCategoriesLike, "dismissNotificationAsync">;
+    onError?: (error: unknown) => void;
+    /** How long to wait for a reply queued in the live outbox to go. Default PUSH_REPLY_WAIT_MS. */
+    waitMs?: number;
+} & ChatPushOutboxDeps): Promise<ChatPushOutcome>;
+/** For the push block's `suppress` / `useSuppressNotifications`: this conversation's pushes, while its thread is open. */
+declare function chatThreadMatch(conversationId: string | null | undefined): ((data: Record<string, unknown>) => boolean) | null;
+/** What a message's push says about itself, for `chatPushPayload`. */
+interface ChatPushPayloadInput {
+    conversationId: string;
+    messageId: string;
+    seq?: number | null | undefined;
+    /** Who sent it: an opaque id (never an email or phone), the name to show and an https photo. */
+    sender?: {
+        id: string;
+        name: string;
+        avatarUrl?: string | null | undefined;
+    } | null | undefined;
+    /** The conversation's name when it is a group; leave it out for a direct conversation. */
+    groupName?: string | null | undefined;
+    /** An https photo in the message, attached to the notification. */
+    imageUrl?: string | null | undefined;
+    /**
+     * The recipient hides previews: the push carries the link and ids only (no
+     * sender, group or photo) and the service extension doesn't run. Send neutral
+     * title and body text with it.
+     */
+    hidePreviews?: boolean | undefined;
+}
+/** The `data` of a message's push. Flat strings and numbers, as genesis-notifications' `PushMessage.data` takes. */
+interface ChatPushData {
+    [key: string]: string | number;
+    url: string;
+    conversationId: string;
+    messageId: string;
+}
+/** The fields to spread into an Expo push message (with `to`, `title`, `body`, `badge`, `channelId`). */
+interface ChatPushPayload {
+    categoryId: typeof CHAT_PUSH_CATEGORY;
+    /** Groups the conversation's notifications, and is the conversation iOS files a Communication Notification under. */
+    threadId: string;
+    /** iOS runs genesis-native's Notification Service Extension only when this is true (`mutable-content: 1`). */
+    mutableContent: boolean;
+    data: ChatPushData;
+}
+/**
+ * The category, thread, `mutableContent` and `data` of a message's push, for
+ * the server that sends it:
+ *
+ *   const message = { to, title, body, badge, channelId: "messages", ...chatPushPayload({ conversationId, messageId, seq, sender, groupName, imageUrl, hidePreviews }) };
+ *
+ * On iOS, with the rich push plugin, a push with a sender is a Communication
+ * Notification (the sender's photo; Focus treats it as a message) and `imageUrl`
+ * is attached. Fields that aren't usable (a URL that isn't https, an empty
+ * name) are left out rather than sent.
+ */
+declare function chatPushPayload(input: ChatPushPayloadInput): ChatPushPayload;
+
+export { CHAT_MARK_READ_ACTION, CHAT_PUSH_CATEGORY, CHAT_REPLY_ACTION, type ChatPushCopy, type ChatPushData, type ChatPushOutboxDeps, type ChatPushOutcome, type ChatPushPayload, type ChatPushPayloadInput, type ChatPushResponseLike, type NotificationCategoriesLike, PUSH_REPLY_WAIT_MS, chatNotificationActions, chatPath, chatPushCategory, chatPushCopy, chatPushPayload, chatThreadMatch, conversationIdFromData, failedReply, handleChatPushResponse, registerChatNotificationActions, replyClientId, replyClientIdFor };

package/dist/push.js

@@ -0,0 +1,3 @@
+export { CHAT_MARK_READ_ACTION, CHAT_PUSH_CATEGORY, CHAT_REPLY_ACTION, PUSH_REPLY_WAIT_MS, chatNotificationActions, chatPath, chatPushCategory, chatPushCopy, chatPushPayload, chatThreadMatch, conversationIdFromData, failedReply, handleChatPushResponse, registerChatNotificationActions, replyClientId, replyClientIdFor } from './chunk-VEPZROQB.js';
+//# sourceMappingURL=push.js.map
+//# sourceMappingURL=push.js.map

package/dist/push.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"push.js"}

package/dist/react.d.ts

@@ -1,8 +1,9 @@
 import * as _tanstack_query_core from '@tanstack/query-core';
-import { C as ChatClient, a as ChatConversation, b as ChatMember, c as ChatRole, d as ChatKindRules, e as ChatMessage, f as ChatActivity, S as SendInput, g as ChatSignal, h as ChatInboxItem } from './client-BtdALFCx.js';
+import { h as ChatAttachment, i as ChatClient, k as ChatConversation, p as ChatMember, t as ChatRole, n as ChatKindRules, q as ChatMessage, g as ChatActivity, E as SendInput, M as MessagePage, C as ChatAvailability, d as AvailabilityInput, v as ChatSignal, m as ChatInboxItem, o as ChatLinkPreview, D as ScheduledMessage, S as ScheduleInput, u as ChatSearchHit, x as ChatTopic, T as TopicInput } from './client-DMa2j7kz.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { OutboxStore, LocalFile, ThreadItem, Outbox, QueuedMessage } from './index.js';
+import { b as OutboxStore, L as LocalFile, O as Outbox, Q as QueuedMessage } from './outbox-B0y3phE0.js';
+import { T as ThreadItem } from './thread-DWXHKPdw.js';
 import '@supabase/supabase-js';
 
 declare const chatKeys: {
@@ -14,15 +15,58 @@ declare const chatKeys: {
     role: (id: string) => readonly ["genesis-chat", "role", string];
     pins: (id: string) => readonly ["genesis-chat", "pins", string];
     files: (paths: string[]) => readonly ["genesis-chat", "files", string[]];
+    /** Under the conversation's key, so its `conversation` hint (set_topic broadcasts one) refreshes them. */
+    topics: (id: string) => readonly ["genesis-chat", "conversation", string, "topics"];
+    scheduled: (conversationId?: string | null) => readonly ["genesis-chat", "scheduled", string | null];
+    availability: (conversationId: string) => readonly ["genesis-chat", "conversation", string, "availability"];
+    myAvailability: () => readonly ["genesis-chat", "my-availability"];
+    search: (query: string, conversationId?: string | null) => readonly ["genesis-chat", "search", string | null, string];
+    previews: (messageIds: string[]) => readonly ["genesis-chat", "previews", string[]];
+    /** One message's link previews (useLinkPreviews keeps one query per message). */
+    preview: (messageId: string) => readonly ["genesis-chat", "preview", string];
 };
+/** How many messages a catch-up asks for at a time, and how many pages before it gives up and jumps to the newest. */
+declare const CATCH_UP_PAGE = 200;
+declare const CATCH_UP_MAX_PAGES = 10;
+/** What a messages list holds in the query cache: the page, and whether older messages exist. */
+type MessagesData = MessagePage;
 /** Does a messages list (`[genesis-chat, conversation, id, messages, threadRootId, topic]`) hold this message? */
 declare function belongsTo(key: readonly unknown[], m: ChatMessage): boolean;
+/**
+ * Hosted video uploads (Mux direct uploads): your server makes an upload and returns its URL;
+ * the renderer PUTs the recording there and sends `{ kind: "video", provider: "mux", providerId,
+ * status: "pending" }`. Without it, videos go to storage as files.
+ */
+interface ChatVideoUpload {
+    create(conversationId: string): Promise<{
+        url: string;
+        providerId: string;
+        provider: "mux";
+    }>;
+}
+/** What an app attachment kind's card shows (a form, a check-in): plain data, drawn by each renderer. */
+interface ChatAttachmentKind {
+    title(attachment: ChatAttachment): string;
+    subtitle?(attachment: ChatAttachment): string | null | undefined;
+    /** The card's button: a link (`href`) or a handler (`onPress`). */
+    action?(attachment: ChatAttachment): {
+        label: string;
+        href?: string;
+        onPress?: () => void;
+    } | null | undefined;
+}
 interface ChatContextValue {
     client: ChatClient;
     userId: string;
     outbox: Outbox;
     queue: QueuedMessage[];
     loadPeople?: (userIds: string[]) => Promise<Record<string, ChatPerson>>;
+    videoUpload?: ChatVideoUpload;
+    attachmentKinds?: Record<string, ChatAttachmentKind>;
+    /** Retries every failed message (call it when the connection comes back: AppState, NetInfo). */
+    retryAll(): Promise<void>;
+    /** Forgets every unsent message, here and in the outbox store (call it on sign-out). */
+    clearOutbox(): Promise<void>;
     /** Subscribe to inbox hints (one channel for the app, fanned out here). */
     onInbox(listener: (s: ChatSignal) => void): () => void;
 }
@@ -34,14 +78,22 @@ interface ChatProviderProps {
     outboxStore?: OutboxStore;
     /** Reads a native file URI for upload. */
     readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
-    /** Replaces the plain upload (resumable uploads on native). */
-    upload?: (conversationId: string, file: LocalFile) => Promise<string>;
+    /** Replaces the plain upload (resumable uploads on native). `signal` aborts when the message is discarded or the outbox cleared. */
+    upload?: (conversationId: string, file: LocalFile, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<string>;
     /** Makes client ids (default: a random UUID that works without crypto.randomUUID). */
     newId?: () => string;
     /** Keeps a byte file (a pasted image, a recording) across launches: write it, return a URI. */
     persistFile?: (file: LocalFile) => Promise<string>;
+    /** Lets go of a sent file's preview (default: revokes `blob:` object URLs only). */
+    releasePreview?: (url: string) => void;
     /** Names and avatars for user ids, fetched in batches (usePeople, usePerson). */
     loadPeople?: (userIds: string[]) => Promise<Record<string, ChatPerson>>;
+    /** Hosted video uploads (Mux); videos go to storage without it. */
+    videoUpload?: ChatVideoUpload;
+    /** Cards for your own attachment kinds (`{ form: { title, subtitle, action } }`). */
+    attachmentKinds?: Record<string, ChatAttachmentKind>;
     children: ReactNode;
 }
 /** How the app shows a person. */
@@ -50,11 +102,13 @@ interface ChatPerson {
     avatarUrl?: string | null;
 }
 /** Puts chat in reach of every hook below it. Needs a TanStack QueryClientProvider above it. */
-declare function ChatProvider({ client, userId, outboxStore, readFile, upload, newId, persistFile, loadPeople, children }: ChatProviderProps): react.JSX.Element;
+declare function ChatProvider({ client, userId, outboxStore, readFile, upload, newId, persistFile, releasePreview, loadPeople, videoUpload, attachmentKinds, children, }: ChatProviderProps): react.JSX.Element;
 declare function useChat(): ChatContextValue;
 /** Your conversations, live. `kind` narrows to one kind; `archived` shows the archived ones. */
 declare function useInbox(opts?: {
     kind?: string;
+    kinds?: string[];
+    excludeKinds?: string[];
     archived?: boolean;
     limit?: number;
 }): {
@@ -64,7 +118,9 @@ declare function useInbox(opts?: {
     refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ChatInboxItem[]>, Error>>;
 };
 /** How many messages wait for you everywhere (for a badge), live. */
-declare function useUnreadTotal(): number;
+declare function useUnreadTotal(opts?: {
+    excludeKinds?: string[];
+}): number;
 interface UseConversationOptions {
     /** Mark messages read as they arrive while this is true (the thread is on screen). Default true. */
     markRead?: boolean;
@@ -82,6 +138,14 @@ declare function useConversation(conversationId: string | null | undefined, opts
     canPost: boolean;
     /** Your role and posting rights are still loading: show the composer as waiting, not refused. */
     accessLoading: boolean;
+    /** The conversation itself is still loading (it settles to `null` when you can't see it). */
+    conversationLoading: boolean;
+    /** Your role couldn't be loaded (offline): offer `refetchAccess`, don't say "can't post". */
+    accessError: Error | null;
+    refetchAccess: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<{
+        role: ChatRole | null;
+        canPost: boolean;
+    }>, Error>>;
     /** The kind's rules (max members, threads, who posts). */
     kind: NonNullable<NoInfer<ChatKindRules | null>> | null;
     /** May you pin here: owners and admins, or anyone in a two-person conversation. */
@@ -95,11 +159,14 @@ declare function useConversation(conversationId: string | null | undefined, opts
     hasEarlier: boolean;
     loadingEarlier: boolean;
     loadEarlier: () => Promise<void>;
+    loadUntil: (seq: number) => Promise<boolean>;
     /** Where to draw the "New" line, from what you had read when it opened. */
     firstUnreadId: string | null;
     activity: ChatActivity[];
     signalTyping: () => void;
     signalRecording: () => void;
+    /** Tells the others you are recording a video (throttled). */
+    signalRecordingVideo: () => void;
     markRead: () => Promise<void>;
     send: (input: Omit<SendInput, "conversationId" | "clientId">, files?: LocalFile[]) => Promise<string>;
     retry: (clientId: string) => Promise<void>;
@@ -133,5 +200,80 @@ declare function useStartConversation(): (kind: string, memberIds: string[], opt
     subjectType?: string;
     subjectId?: string;
 }) => Promise<string>;
+/**
+ * A conversation's topics, live (set_topic's hint refreshes them), and `setTopic` for owners
+ * and admins: add one (`setTopic("week-1", { title: "Week 1" })`), close or reopen it.
+ */
+declare function useTopics(conversationId: string | null | undefined): {
+    topics: ChatTopic[];
+    isLoading: boolean;
+    error: Error | null;
+    setTopic: (topic: string, input?: TopicInput) => Promise<void>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ChatTopic[]>, Error>>;
+};
+/**
+ * Your scheduled messages (in one conversation, or all), soonest first, with `schedule` and
+ * `cancel`. `schedule` uploads byte files first (`LocalFile.data` a Blob or ArrayBuffer; a
+ * native URI goes through the provider's `readFile`), then schedules them with the message.
+ */
+declare function useScheduled(conversationId?: string | null, opts?: {
+    enabled?: boolean;
+}): {
+    items: ScheduledMessage[];
+    isLoading: boolean;
+    error: Error | null;
+    schedule: (input: Omit<ScheduleInput, "clientId"> & {
+        clientId?: string;
+    }, files?: LocalFile[]) => Promise<string>;
+    cancel: (id: string) => Promise<void>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ScheduledMessage[]>, Error>>;
+};
+/**
+ * Availability: yours (`mine`, `setMine`) and, given a conversation, its members' (`members`,
+ * `forUser`). Pair with `awayLine` and `isWithinWorkingHours` from the core.
+ */
+declare function useAvailability(conversationId?: string | null): {
+    mine: NonNullable<NoInfer<ChatAvailability | null>> | null;
+    mineLoading: boolean;
+    setMine: (input: AvailabilityInput) => Promise<void>;
+    members: ChatAvailability[];
+    /** Everyone else's, without yours. */
+    others: ChatAvailability[];
+    forUser: (id: string) => ChatAvailability | null;
+    isLoading: boolean;
+};
+/** Sends one message into many conversations (replies come back privately in each). */
+declare function useBroadcast(): {
+    send: (conversationIds: string[], body: string, opts?: {
+        silent?: boolean;
+        clientId?: string;
+    }) => Promise<string[]>;
+    sending: boolean;
+};
+/** The value, once it has stopped changing for `ms`. */
+declare function useDebouncedValue<T>(value: T, ms: number): T;
+/** Search, debounced (250 ms by default), in one conversation or all of yours. Queries under two characters return nothing. */
+declare function useSearch(query: string, opts?: {
+    conversationId?: string | null;
+    debounceMs?: number;
+    limit?: number;
+}): {
+    hits: ChatSearchHit[];
+    /** The query the hits are for. */
+    query: string;
+    /** Typing, or fetching: results are on their way. */
+    isSearching: boolean;
+    error: Error | null;
+};
+/** At most this many link-preview reads at once, per client. */
+declare const LINK_PREVIEW_CONCURRENCY = 4;
+/**
+ * Link previews for these messages, by message id, in link order (only those the server has
+ * fetched). Pass the messages whose text has links (`extractLinks(body).length > 0`). One query
+ * per message, so a new message asks only for its own, and at most LINK_PREVIEW_CONCURRENCY
+ * run at once. One with none yet is asked again a few times, since the runner fills them
+ * moments after it lands.
+ */
+declare function useLinkPreviews(messageIds: (string | null | undefined)[]): Record<string, ChatLinkPreview[]>;
 
-export { type ChatPerson, ChatProvider, type ChatProviderProps, type ConversationState, LocalFile, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, useChat, useConversation, useFileUrls, useInbox, useMessageActions, usePeople, usePerson, usePins, useStartConversation, useUnreadTotal };
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, type ChatAttachmentKind, type ChatPerson, ChatProvider, type ChatProviderProps, type ChatVideoUpload, type ConversationState, LINK_PREVIEW_CONCURRENCY, LocalFile, type MessagesData, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal };

package/dist/react.js

@@ -1,5 +1,5 @@
-export { ChatProvider, belongsTo, chatKeys, useChat, useConversation, useFileUrls, useInbox, useMessageActions, usePeople, usePerson, usePins, useStartConversation, useUnreadTotal } from './chunk-27UTR5FW.js';
-import './chunk-SAY24E6V.js';
-import './chunk-JQXZUEEL.js';
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, ChatProvider, LINK_PREVIEW_CONCURRENCY, belongsTo, chatKeys, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal } from './chunk-PZTOY2LY.js';
+import './chunk-5D5A7I4Q.js';
+import './chunk-7S6HYNWW.js';
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map