@corva/chat-core 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -1,3 +1,105 @@
+import * as zustand_vanilla from 'zustand/vanilla';
+
+declare const ALERT_SEVERITY: {
+    readonly CRITICAL: "critical";
+    readonly WARNING: "warning";
+    readonly INFO: "info";
+};
+type AlertSeverity = (typeof ALERT_SEVERITY)[keyof typeof ALERT_SEVERITY];
+interface AlertData {
+    alertId: string;
+    alertDefinitionId?: string;
+    severity: AlertSeverity;
+    rig?: {
+        id: string;
+        name: string;
+    };
+    title: string;
+    description: string;
+    isTruncated?: boolean;
+    details?: string;
+    detailsUrl?: string;
+    appName?: string;
+    assetId?: string;
+    assetName?: string;
+}
+
+interface AppCommentAttachment {
+    url: string;
+    /** Original file name (with extension), used to tell images apart from other file types. */
+    name?: string;
+    /** File size in bytes, shown next to the name for non-media attachments. */
+    size?: number;
+}
+interface AppCommentData {
+    body: string;
+    appName?: string;
+    authorCorvaId?: number;
+    forwarderCorvaId?: number;
+    activityType?: string;
+    activityId?: string;
+    attachments?: AppCommentAttachment[];
+    /** @deprecated Use `attachments`. Kept so messages sent before multi-attachment still render. */
+    attachmentUrl?: string;
+    /** @deprecated Use `attachments`. */
+    attachmentName?: string;
+    /** @deprecated Use `attachments`. */
+    attachmentSize?: number;
+    appId?: string;
+    dashboardId?: string;
+    appUrl?: string;
+    /** Structured metadata — depth values in ft, formatted at render time in the viewer's preferred unit. */
+    metadata?: {
+        holeDepth?: number;
+        bitDepth?: number;
+        commentDepth?: number;
+    };
+    settingsSnapshotId?: string;
+    isTruncated?: boolean;
+    /** Transient: app settings at forward time. Saved to snapshot storage, never sent in the message. */
+    settings?: Record<string, unknown>;
+}
+/** Single source of truth for reading a comment's files, whichever field the sender populated. */
+declare function getAppCommentAttachments(data: AppCommentData): AppCommentAttachment[];
+/** A single file shared to channels as a new message, rather than forwarded with its comment. */
+interface SharedFile {
+    url: string;
+    name: string;
+    type?: string;
+    /** Worked out from the file name upstream; more reliable than a stored MIME type. */
+    kind?: 'image' | 'video' | 'file';
+}
+
+interface AskCorvaData {
+    responseId: string;
+    answer: string;
+    answerRef?: string;
+    companyId?: number;
+    isTruncated?: boolean;
+    assetId?: number;
+    agentName?: string;
+}
+
+type ChatAssetType = 'rig' | 'frac_fleet' | 'intervention_unit';
+type SelectableAssetType = ChatAssetType | 'well';
+interface ChatAsset {
+    id: string;
+    name: string;
+    type: SelectableAssetType;
+    status?: string;
+}
+interface AssetChatChannel {
+    revolt_channel_id: string;
+    rig_id: number | null;
+    frac_fleet_id: number | null;
+    intervention_unit_id: number | null;
+}
+
+interface LoginCredentials {
+    username: string;
+    password: string;
+}
+
 declare const CORVA_SYS_PREFIX = "$$CORVA::";
 declare const CORVA_MESSAGE_TYPES: {
     readonly ALERT: "alert";
@@ -97,6 +199,568 @@ interface AppCommentWirePayload {
     trunc?: boolean;
 }
 
+interface FeedItemData {
+    feedItemId: string;
+    feedType: string;
+    title: string;
+    description?: string;
+    assetId?: string;
+    author?: string;
+}
+
+interface Message {
+    _id: string;
+    rid: string;
+    msg: string;
+    ts: string;
+    u: {
+        _id: string;
+        username: string;
+        name?: string;
+    };
+    _updatedAt: string;
+    urls?: Array<{
+        url: string;
+        meta?: Record<string, unknown>;
+    }>;
+    attachments?: Attachment[];
+    file?: FileAttachment;
+    files?: FileAttachment[];
+    editedAt?: string;
+    editedBy?: {
+        _id: string;
+        username: string;
+    };
+    alias?: string;
+    avatar?: string;
+    groupable?: boolean;
+    parseUrls?: boolean;
+    t?: string;
+    reactions?: {
+        [emoji: string]: {
+            userIds: string[];
+        };
+    };
+    replies?: string[];
+    tcount?: number;
+    tlm?: string;
+    tmid?: string;
+    deleted?: boolean;
+    pinned?: boolean;
+    pinnedBy?: {
+        _id: string;
+        username: string;
+    };
+    pinnedAt?: string;
+    pinnedMessageId?: string;
+    unpinnedMessageId?: string;
+    systemUsers?: {
+        userId?: string;
+        actorId?: string;
+    };
+    alert?: AlertData;
+    feedItem?: FeedItemData;
+    askCorva?: AskCorvaData;
+    appComment?: AppCommentData;
+    forwardedFrom?: ForwardedFrom;
+    nonce?: string;
+    isOptimistic?: boolean;
+    sendFailed?: boolean;
+    retryFormData?: MessageFormData;
+}
+interface Attachment {
+    title?: string;
+    title_link?: string;
+    text?: string;
+    color?: string;
+    image_url?: string;
+    audio_url?: string;
+    video_url?: string;
+    message_link?: string;
+    thumb_url?: string;
+    collapsed?: boolean;
+    author_name?: string;
+    author_link?: string;
+    author_icon?: string;
+    fields?: Array<{
+        short?: boolean;
+        title: string;
+        value: string;
+    }>;
+}
+interface FileAttachment {
+    _id: string;
+    name: string;
+    type: string;
+    size: number;
+    rid: string;
+    userId: string;
+    description?: string;
+    url?: string;
+}
+/**
+ * A file picked for upload. Structural so a browser `File` fits as-is; React Native passes a
+ * plain object. The host's upload adapter knows how to read its own shape.
+ */
+interface UploadFile {
+    name: string;
+    size: number;
+    type: string;
+}
+interface MessageFormData {
+    text: string;
+    roomId: string;
+    threadId?: string;
+    file?: UploadFile;
+    files?: UploadFile[];
+    uploadedFileIds?: string[];
+    uploadedFileUrls?: string[];
+}
+interface ForwardedFrom {
+    channelId: string;
+    messageId: string;
+    channelName: string;
+    isPrivate: boolean;
+    note?: string;
+    ts?: string;
+}
+
+interface RevoltSystemMessage {
+    type?: string;
+    id?: string;
+    by?: string;
+}
+interface RevoltIncomingMessagePayload {
+    _id: string;
+    nonce?: string;
+    author?: string;
+    channel: string;
+    content?: string;
+    edited?: string;
+    created_at?: string;
+    replies?: Array<{
+        id: string;
+        mention?: boolean;
+    }> | string[];
+    system?: RevoltSystemMessage;
+    attachments?: RevoltMessageAttachment[];
+}
+interface RevoltLoginResponse {
+    user_id: string;
+    session_id: string;
+    token: string;
+}
+interface RevoltUserResponse {
+    _id: string;
+    username: string;
+    discriminator: string;
+    display_name?: string;
+    avatar?: {
+        _id: string;
+        tag: string;
+        filename: string;
+        metadata: {
+            type: string;
+            width: number;
+            height: number;
+        };
+        content_type: string;
+        size: number;
+    };
+    online: boolean;
+    bot?: {
+        owner: string;
+    };
+    relationship?: 'User' | 'Friend' | 'Blocked' | 'Incoming' | 'Outgoing';
+    relations?: {
+        servers?: string[];
+    } | Array<{
+        _id: string;
+        status?: string;
+    }>;
+    email?: string;
+}
+interface RevoltChannel {
+    _id: string;
+    channel_type: 'TextChannel' | 'VoiceChannel' | 'DirectMessage' | 'Group' | 'SavedMessages';
+    name?: string;
+    description?: string;
+    icon?: {
+        _id: string;
+        tag: string;
+        filename: string;
+        metadata: {
+            type: string;
+            width: number;
+            height: number;
+        };
+        content_type: string;
+        size: number;
+    };
+    recipients?: string[];
+    owner?: string;
+    server?: string;
+    default_permissions?: number;
+    role_permissions?: Record<string, number>;
+    nsfw?: boolean;
+    last_message_id?: string;
+    members?: RevoltUserResponse[];
+}
+interface RevoltMessageAttachment {
+    _id?: string;
+    id?: string;
+    tag?: string;
+    filename?: string;
+    metadata?: {
+        type: string;
+        width?: number;
+        height?: number;
+    };
+    content_type?: string;
+    size?: number;
+}
+interface RevoltMessage {
+    _id: string;
+    nonce?: string;
+    channel: string;
+    author: string;
+    content?: string;
+    attachments?: RevoltMessageAttachment[];
+    edited?: string;
+    embeds?: unknown[];
+    mentions?: string[];
+    replies?: string[];
+    reactions?: Record<string, string[]> | Array<{
+        emoji: string;
+        user_id: string;
+    }>;
+    created_at: string;
+    updated_at?: string;
+    system?: {
+        type?: string;
+        id?: string;
+        by?: string;
+    };
+    pinned?: boolean;
+}
+interface RevoltMessageResponse {
+    _id: string;
+    nonce?: string;
+    channel: string;
+    content?: string;
+    author: string;
+    user?: {
+        username: string;
+    };
+}
+interface RevoltUploadResponse {
+    url: string;
+    id?: string;
+}
+
+interface Room {
+    _id: string;
+    name?: string;
+    fname?: string;
+    t: RoomType;
+    msgs?: number;
+    usersCount?: number;
+    u?: {
+        _id: string;
+        username: string;
+    };
+    ts?: string;
+    ro?: boolean;
+    sysMes?: boolean;
+    default?: boolean;
+    description?: string;
+    topic?: string;
+    announcement?: string;
+    lastMessage?: Message;
+    last_message_id?: string;
+    alert?: boolean;
+    open?: boolean;
+    hideUnreadStatus?: boolean;
+    rid?: string;
+    dmUsername?: string;
+    dmAvatarUrl?: string;
+    dmUserId?: string;
+    recipients?: string[];
+}
+type RoomType = 'c' | 'p' | 'd' | 'l';
+
+interface TypingEventData {
+    userId: string;
+    username: string;
+    isTyping: boolean;
+    roomId: string;
+}
+interface ReadyChannelData {
+    _id: string;
+    channel_type: string;
+    last_message_id?: string;
+    name?: string;
+}
+interface ChannelUnread {
+    _id: {
+        channel: string;
+    };
+    last_id?: string;
+}
+interface RevoltSocketEventHandlers {
+    onConnected?: () => void;
+    onAuthenticated?: () => void;
+    onDisconnected?: () => void;
+    onInvalidSession?: () => void;
+    onReady?: (channels: ReadyChannelData[], channelUnreads?: ChannelUnread[]) => void;
+    onMessage?: (message: Message) => void;
+    onMessageUpdate?: (messageId: string, channelId: string, data: {
+        content?: string;
+        edited?: string;
+    }) => void;
+    onMessageDelete?: (messageId: string, channelId: string) => void;
+    onUserStatusChange?: (userId: string, status: string) => void;
+    onTyping?: (data: TypingEventData) => void;
+    onRoomChange?: (roomId: string, change: unknown) => void;
+    onChannelAck?: (channelId: string, messageId: string) => void;
+    onError?: (error: unknown) => void;
+}
+
+interface Subscription {
+    _id: string;
+    rid: string;
+    name: string;
+    fname?: string;
+    t: RoomType;
+    u: {
+        _id: string;
+        username: string;
+    };
+    ts: string;
+    ls?: string;
+    lr?: string;
+    open: boolean;
+    alert: boolean;
+    last_acked_message_id?: string;
+    userMentions: number;
+    groupMentions: number;
+    roles?: string[];
+    archived?: boolean;
+    audioNotificationValue?: string;
+    desktopNotificationDuration?: number;
+    desktopNotifications?: string;
+    disableNotifications?: boolean;
+    emailNotifications?: string;
+    hideUnreadStatus?: boolean;
+    mobilePushNotifications?: string;
+    muteGroupMentions?: boolean;
+    blocked?: boolean;
+    blocker?: boolean;
+    autoTranslate?: boolean;
+    autoTranslateLanguage?: string;
+    lastMessage?: Message;
+    last_message_id?: string;
+    dmUsername?: string;
+    dmAvatarUrl?: string;
+    dmUserId?: string;
+    recipients?: string[];
+}
+
+interface User {
+    _id: string;
+    username: string;
+    name?: string;
+    emails?: Array<{
+        address: string;
+        verified: boolean;
+    }>;
+    status?: UserStatus;
+    statusConnection?: UserStatus;
+    avatarUrl?: string;
+    roles?: string[];
+    active?: boolean;
+    isBot?: boolean;
+    displayName?: string;
+    displayAvatar?: string;
+    email?: string;
+    title?: string;
+    role?: string;
+    company?: string;
+}
+type UserStatus = 'online' | 'away' | 'busy' | 'offline';
+
+declare const ASSET_CHAT_PREFIXES: Record<ChatAssetType, string>;
+declare const ASSET_NOUN: Record<SelectableAssetType, string>;
+declare const ASSET_API_FIELDS: Record<ChatAssetType, string[]>;
+declare const MENTION_REPLACE_PATTERN: RegExp;
+declare const MENTION_SPLIT_PATTERN: RegExp;
+declare const REVOLT_SYSTEM_USER_ID = "00000000000000000000000000";
+declare const SYSTEM_MESSAGE_TEXTS: {
+    readonly USER_ADDED: (by: string, user: string) => string;
+    readonly USER_REMOVED: (by: string, user: string) => string;
+    readonly USER_LEFT: (user: string) => string;
+    readonly MESSAGE_PINNED: (user: string) => string;
+    readonly MESSAGE_UNPINNED: (user: string) => string;
+    readonly DEFAULT_USER: "User";
+};
+declare const CHANNEL_TYPES: {
+    readonly DIRECT_MESSAGE: "DirectMessage";
+    readonly GROUP: "Group";
+    readonly TEXT_CHANNEL: "TextChannel";
+    readonly SAVED_MESSAGES: "SavedMessages";
+};
+declare const GENERAL_CHAT_NAME = "General";
+declare const CHANNEL_NAME_MAX_LENGTH = 32;
+declare const SIDEBAR_SECTIONS: {
+    readonly FAVORITES: "favorites";
+    readonly CHANNELS: "channels";
+    readonly DIRECT: "direct";
+};
+type SidebarSectionKey = (typeof SIDEBAR_SECTIONS)[keyof typeof SIDEBAR_SECTIONS];
+declare const SIDEBAR_TABS: {
+    readonly ALL: "all";
+    readonly UNREAD: "unread";
+    readonly RECENT: "recent";
+};
+type SidebarTabKey = (typeof SIDEBAR_TABS)[keyof typeof SIDEBAR_TABS];
+declare const ROOM_LIST_ORDER: {
+    readonly ALPHABETICAL: "alphabetical";
+    readonly RECENT: "recent";
+};
+type RoomListOrder = (typeof ROOM_LIST_ORDER)[keyof typeof ROOM_LIST_ORDER];
+declare const DEFAULT_ROOM_LIST_ORDER: RoomListOrder;
+declare const MAX_ATTACHMENT_SIZE_MB = 500;
+declare const MAX_ATTACHMENT_SIZE_BYTES: number;
+
+declare function alertMessageAsText(message: Message): Message;
+
+/**
+ * Builds a group channel name from an ordered list of display names, fitting
+ * within the backend's 32-character limit.
+ *
+ * Strategy (in order):
+ *   1. Full display names joined by ", "
+ *   2. First names only joined by ", "
+ *   3. As many first names as fit + ", and N others"
+ *   4. Single (possibly truncated) first name + ", and N others"
+ */
+declare function buildGroupChannelName(displayNames: string[]): string;
+
+declare const canDeleteMessage: (message: Message, currentUserId: string) => boolean;
+
+declare const canEditMessage: (message: Message, currentUserId: string) => boolean;
+
+interface ChannelAsset {
+    assetId: number;
+    assetType: ChatAssetType;
+}
+declare function channelToAsset(channel: AssetChatChannel): ChannelAsset | null;
+
+declare function setAllowedChatAssetTypes(assetTypes: ChatAssetType[]): void;
+declare function isChatAssetTypeAllowed(assetType: ChatAssetType): boolean;
+declare function isDisallowedAssetChatRoom(roomId: string, assetChatChannels: AssetChatChannel[]): boolean;
+declare function resetChatAssetPermissionsSnapshot(): void;
+
+/**
+ * Comparator factory for subscription lists: unread first, then by last activity
+ * (last_message_id descending — ULIDs are lexicographically time-sortable), then
+ * alphabetically by the name returned from getName.
+ */
+declare const compareByActivity: (getName: (sub: Subscription) => string) => (a: Subscription, b: Subscription) => number;
+
+declare const compareByName: (getName: (sub: Subscription) => string) => (a: Subscription, b: Subscription) => number;
+
+declare function createLatestWinsQueue<T>(send: (value: T) => Promise<unknown> | void): (value: T) => void;
+
+declare const DATE_SEPARATOR_LABELS: {
+    readonly TODAY: "Today";
+    readonly YESTERDAY: "Yesterday";
+};
+
+interface ChatAssetIdentity {
+    assetId: string;
+    assetType: ChatAssetType;
+}
+declare function deriveAllowedChatAsset(segment: string | null | undefined, rigId: number | null | undefined, fracFleetId: number | null | undefined, interventionUnitId: number | null | undefined, allowedAssetTypes: ChatAssetType[]): ChatAssetIdentity | null;
+
+/**
+ * Infers asset type from room display name. Asset chat names use
+ * "Rig: ..." / "Fleet: ..." / "Unit: ..." prefixes.
+ * Returns null if the name does not match.
+ */
+declare function getAssetTypeFromDisplayName(displayName: string): ChatAssetType | null;
+
+declare const getReactionCount: (message: Message, emoji: string) => number;
+
+declare const DIRECT_MESSAGE_PLACEHOLDER = "Direct Message";
+/**
+ * Strips the system prefix from asset chat names: "Rig: AssetName" /
+ * "Fleet: AssetName" / "Unit: AssetName" display as just "AssetName".
+ */
+declare function formatAssetChatName(name: string): string;
+declare const getRoomDisplayName: (room: Room | Subscription) => string;
+
+declare const getSystemMessageWithCorvaNames: (message: Message, getUserById: (userId: string) => User | undefined) => string;
+
+declare const getUserDisplayName: (user: Partial<User>) => string;
+
+/**
+ * Returns a secondary text for a user (typically shown below the display name).
+ * Format: "email | title/role" or just "title/role" or "@username"
+ */
+declare const getUserSecondaryText: (user: Partial<User>) => string | undefined;
+
+declare const hasReactions: (message: Message) => boolean;
+
+declare const hasUserReacted: (message: Message, emoji: string, _username: string, currentUserId?: string) => boolean;
+
+declare function isAlertMessage(message: Message): boolean;
+
+declare function isAppCommentMessage(message: Message): boolean;
+
+declare function isAskCorvaMessage(message: Message): boolean;
+
+declare const isDmGroup: (sub: Subscription) => boolean;
+
+declare function isForwardedMessage(message: Message): boolean;
+
+/**
+ * Identifies the "General" room (backend-created channel). Name is "General" only.
+ */
+declare function isGeneralRoom(room: {
+    name?: string;
+    fname?: string;
+} | null | undefined): boolean;
+/**
+ * Find the General room from a list. General is always a channel (t === 'c').
+ */
+declare function findGeneralRoom<T extends {
+    _id: string;
+    name?: string;
+    fname?: string;
+    t?: string;
+}>(rooms: T[]): T | undefined;
+
+declare const SOFT_DELETE_MARKER = "[sysmessage: deleted]";
+declare const isSoftDeletedMessage: (message: Message) => boolean;
+declare const createSoftDeletedMessage: (message: Message) => Message;
+
+declare const isSystemMessage: (message: Message) => boolean;
+
+declare function isUnread(sub: Pick<Subscription, 'last_message_id' | 'last_acked_message_id'>): boolean;
+
+declare function isUserOnline(user: User): boolean;
+
+declare function isVisibleUnread(sub: Subscription, isRoomDisallowed: (roomId: string) => boolean): boolean;
+
+interface ParsedCorvaMessage {
+    messageType: string;
+    alert?: AlertData;
+    feedItem?: FeedItemData;
+    askCorva?: AskCorvaData;
+    appComment?: AppCommentData;
+    forwardedFrom?: ForwardedFrom;
+}
 /**
  * Builds the wire-format content string for an AskCorva response.
  */
@@ -105,5 +769,926 @@ declare function buildAskCorvaMessageContent(requestId: string, answer: string,
  * Builds the wire-format content string for a forwarded message.
  */
 declare function buildForwardMessageContent(sourceChannelId: string, messageId: string, channelName: string, isPrivate: boolean, note?: string, ts?: string): string;
+/**
+ * Builds the wire-format content string for an app comment forwarded to chat.
+ * If the body exceeds MAX_COMMENT_BODY_LENGTH and an activityId is provided,
+ * the body is truncated and `trunc` flag is set for lazy-fetching.
+ */
+declare function buildAppCommentMessageContent(data: AppCommentData): string;
+/**
+ * Detects the $$CORVA:: prefix in message content
+ * and parses the JSON payload into internal types.
+ * Returns null if the content is not a Corva system message.
+ */
+declare function parseCorvaSystemMessage(content: string): ParsedCorvaMessage | null;
+/**
+ * If the raw message content is a $$CORVA:: message,
+ * enriches the Message object with parsed typed data
+ * and sets `t` to the appropriate message type.
+ * Returns the message unchanged if it's not a Corva
+ * system message.
+ */
+declare function enrichWithCorvaData(message: Message): Message;
+
+declare const searchMessages: (messages: Message[], query: string) => Message[];
+
+declare const searchRooms: (rooms: (Room | Subscription)[], query: string) => (Room | Subscription)[];
+
+declare const searchUsers: (users: User[], query: string) => User[];
+
+declare const compareByRecencyDesc: (a: Subscription, b: Subscription) => number;
+
+/**
+ * Sorts channels: pinned first (asset chat if set, else General), then by the
+ * chosen order — alphabetically by name or most recent activity first.
+ */
+declare function sortChannels(channels: Subscription[], assetChatId: string | undefined, order?: RoomListOrder): Subscription[];
+
+/**
+ * Sorts DMs and group DMs by the chosen order — alphabetically by display name
+ * or most recent activity first.
+ */
+declare function sortDMs(dms: Subscription[], order?: RoomListOrder): Subscription[];
+
+declare const sortMessagesByTime: (messages: Message[]) => Message[];
+
+declare const sortUsersByStatus: (users: User[]) => User[];
+
+/**
+ * Converts platform mention markup (@[user:ID|Display Name]) to plain @Display Name.
+ */
+declare function stripPlatformMentions(body: string): string;
+
+/**
+ * Extract timestamp from Revolt ULID
+ * ULIDs contain a timestamp in the first 48 bits
+ */
+declare function extractTimestampFromULID(ulid: string): Date;
+/**
+ * Get message timestamp from Revolt message
+ * Uses _id (ULID) to extract creation time
+ */
+declare function getMessageTimestamp(message: {
+    _id: string;
+    nonce?: string;
+}): string;
+
+interface ChannelNameValidation {
+    error: string | null;
+    isValid: boolean;
+}
+declare function validateChannelName(name: string, existingChannelNames?: string[]): ChannelNameValidation;
+
+type Handler<E> = {
+    bivarianceHack(event: E): void;
+}['bivarianceHack'];
+interface HttpRequestInit {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    keepalive?: boolean;
+}
+interface HttpResponseLike {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: {
+        get(name: string): string | null;
+    };
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+interface SocketCloseEventLike {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+declare const WEBSOCKET_CONNECTING = 0;
+declare const WEBSOCKET_OPEN = 1;
+interface WebSocketLike {
+    readonly readyState: number;
+    onopen: Handler<unknown> | null;
+    onmessage: Handler<{
+        data: unknown;
+    }> | null;
+    onclose: Handler<SocketCloseEventLike> | null;
+    onerror: Handler<unknown> | null;
+    send(data: string): void;
+    close(code?: number): void;
+}
+/**
+ * Everything core needs from the host platform. Web passes browser APIs; React Native passes its
+ * own `fetch`, `WebSocket` and `FormData` handling plus AppState/NetInfo for reconnect hints.
+ *
+ * Wrap native functions rather than passing them bare (`fetch: (url, init) => fetch(url, init)`):
+ * browsers throw "Illegal invocation" when `window.fetch` is called on another object.
+ */
+interface ChatPlatform {
+    fetch(url: string, init?: HttpRequestInit): Promise<HttpResponseLike>;
+    createWebSocket(url: string): WebSocketLike;
+    /** Multipart body for an Autumn upload, with the file under the `file` field. */
+    createUploadBody(file: UploadFile): unknown;
+    /**
+     * Calls `retry` whenever a pending reconnect is worth attempting right away (network came back,
+     * app returned to the foreground). Returns an unsubscribe function.
+     */
+    subscribeReconnectHints?(retry: () => void): () => void;
+}
+
+interface HttpClientConfig {
+    baseUrl: string;
+    fetch: ChatPlatform['fetch'];
+    getToken: () => string | null;
+    onUnauthorized?: (path: string) => void;
+}
+declare class HttpError extends Error {
+    status: number;
+    statusText: string;
+    body: unknown;
+    constructor(status: number, statusText: string, body: unknown, method?: string, path?: string);
+}
+declare function createHttpClient(config: HttpClientConfig): {
+    request: <T = unknown>(path: string, init?: HttpRequestInit) => Promise<T>;
+};
+type HttpClient = ReturnType<typeof createHttpClient>;
+
+declare function createRevoltAPI(baseUrl: string, platform: ChatPlatform): {
+    getBaseUrl: () => string;
+    seedUserCache: (users: User[]) => void;
+    clearUserCache: () => void;
+    setUnauthorizedHandler: (handler: ((source: string) => void) | null) => void;
+    notifyUnauthorized: (source: string) => void | undefined;
+    createGroup: (name: string, recipientIds: string[]) => Promise<{
+        _id: string;
+    }>;
+    addUserToGroup: (groupId: string, userId: string) => Promise<boolean>;
+    removeUserFromGroup: (groupId: string, userId: string) => Promise<boolean>;
+    getGroupMembers: (groupId: string) => Promise<User[]>;
+    getServerMembers: (serverId: string) => Promise<User[]>;
+    getOrCreateDMFromUser: (userId: string) => Promise<{
+        _id: string;
+    }>;
+    getDMRecipient: (dmChannelId: string, currentUserId?: string, cachedChannel?: RevoltChannel) => Promise<User | null>;
+    uploadAttachment: (file: UploadFile) => Promise<{
+        id?: string;
+        url?: string;
+    }>;
+    addReaction: (channelId: string, messageId: string, emoji: string) => Promise<void>;
+    removeReaction: (channelId: string, messageId: string, emoji: string) => Promise<void>;
+    getChannelMessages: (channelId: string, limit?: number, before?: string, nearby?: string) => Promise<Message[]>;
+    sendMessage: (channelId: string, text: string, threadId?: string, attachmentIds?: string[], nonce?: string) => Promise<unknown>;
+    editMessage: (channelId: string, messageId: string, content: string) => Promise<void>;
+    deleteMessage: (channelId: string, messageId: string) => Promise<void>;
+    pinMessage: (channelId: string, messageId: string) => Promise<void>;
+    unpinMessage: (channelId: string, messageId: string) => Promise<void>;
+    fetchMessage: (channelId: string, messageId: string) => Promise<RevoltMessage>;
+    forwardMessage: (targetChannelId: string, sourceChannelId: string, messageId: string, channelName: string, isPrivate: boolean, customMessage?: string, attachmentIds?: string[], sourceTs?: string) => Promise<unknown>;
+    getChannel: (channelId: string) => Promise<RevoltChannel>;
+    getRooms: (serverId?: string | null) => Promise<Room[]>;
+    leaveChannel: (channelId: string, leaveSilently?: boolean | null) => Promise<void>;
+    ackMessage: (channelId: string, messageId: string, options?: {
+        keepalive?: boolean;
+    }) => Promise<boolean>;
+    getUnreads: () => Promise<Map<string, string>>;
+    updateChannel: (channelId: string, updates: {
+        name?: string;
+        description?: string;
+    }) => Promise<RevoltChannel>;
+    getUser: (userId: string) => Promise<User | null>;
+    getFriends: () => Promise<User[]>;
+    searchUsers: (_query: string) => Promise<User[]>;
+    login: (credentials: LoginCredentials) => Promise<{
+        token: string;
+        me: User;
+    }>;
+    me: () => Promise<User>;
+    setToken: (token: string | null) => void;
+    getToken: () => string | null;
+};
+type RevoltAPIInstance = ReturnType<typeof createRevoltAPI>;
+
+interface RevoltSocketConfig {
+    apiUrl: string;
+    wsUrl: string;
+    platform: ChatPlatform;
+}
+declare function createRevoltSocket({ apiUrl, wsUrl, platform }: RevoltSocketConfig, handlers?: RevoltSocketEventHandlers, getMemberById?: (userId: string) => User | undefined): {
+    connect: (sessionToken: string, userId: string) => Promise<void>;
+    disconnect: () => void;
+    destroy: () => void;
+    isConnected: () => boolean;
+    seedUsers: (users: Array<{
+        _id: string;
+        username: string;
+    }>) => void;
+    subscribeToRoom: (_roomId: string) => void;
+    sendTyping: (roomId: string, isTyping: boolean) => void;
+    setEventHandlers: (handlers: RevoltSocketEventHandlers) => void;
+};
+type RevoltSocketInstance = ReturnType<typeof createRevoltSocket>;
+
+/**
+ * Synchronous key-value storage, shaped like `localStorage`. Core reads session and last-room
+ * data synchronously; React Native can back this with MMKV, or an in-memory map hydrated from
+ * AsyncStorage before chat starts and written through in the background.
+ */
+interface KeyValueStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+declare function configureChatStorage(storage: KeyValueStorage | null): void;
+/** Throws until configured; callers already treat storage errors as "storage unavailable". */
+declare function getChatStorage(): KeyValueStorage;
+declare function createMemoryStorage(): KeyValueStorage;
+
+declare const SESSION_STORAGE_KEY = "revolt_chat_session";
+interface SessionData {
+    user: User;
+    token: string;
+    serverId?: string;
+    revoltUserId?: string;
+    assetChatChannels?: AssetChatChannel[];
+    chatUsed?: boolean | null;
+    attentionSeriesPlayed?: number;
+    attentionNextSeriesAt?: number | null;
+}
+interface AttentionBudget {
+    attentionSeriesPlayed: number;
+    attentionNextSeriesAt: number | null;
+}
+interface SaveSessionParams {
+    user: User;
+    token: string;
+    serverId?: string;
+    assetChatChannels?: AssetChatChannel[];
+    chatUsed?: boolean | null;
+}
+declare class SessionManager {
+    static clear(): void;
+    static save({ user, token, serverId, assetChatChannels, chatUsed, }: SaveSessionParams): void;
+    static markChatUsed(): void;
+    static saveAttentionBudget(budget: AttentionBudget): void;
+    static loadAttentionBudget(): AttentionBudget;
+    private static patch;
+    static parseChatUsed(serialized: string | null): boolean | null;
+    static load(): SessionData | null;
+}
+
+declare function saveLastOpenedRoom(roomId: string, userId: string): void;
+declare function getLastOpenedRoom(userId: string): string | null;
+declare function clearLastOpenedRoom(userId: string): void;
+declare function saveLastChatActivity(userId: string): void;
+declare function wasRecentlyActive(userId: string, thresholdDays?: number): boolean;
+
+declare function createMessageCache(): {
+    get: (roomId: string) => Message[] | undefined;
+    set: (roomId: string, messages: Message[]) => void;
+    markDirty: (roomId: string) => void;
+    isDirty: (roomId: string) => boolean;
+    clear: (roomId?: string) => void;
+};
+type MessageCache = ReturnType<typeof createMessageCache>;
+
+interface PageCursor {
+    before?: string;
+    around?: string;
+}
+interface LocatorContext {
+    getMessages: () => Message[];
+    applyMessages: (messages: Message[]) => void;
+    fetchPage: (cursor: PageCursor) => Promise<Message[]>;
+    isCancelled: () => boolean;
+    maxPages?: number;
+}
+declare function loadUntilFound(targetId: string, ctx: LocatorContext): Promise<boolean>;
+
+declare function createTypingManager(): {
+    getDisplayName: (userId: string) => string | undefined;
+    setDisplayName: (userId: string, displayName: string) => void;
+    getDisplayById: () => Record<string, string>;
+    clearTimeout: (userId: string) => void;
+    setTimeout: (userId: string, callback: () => void, delay: number) => void;
+    clearAllTimeouts: () => void;
+    clear: () => void;
+};
+type TypingManager = ReturnType<typeof createTypingManager>;
+
+declare function createRoomTaskQueue(): (roomId: string, task: () => Promise<void>) => Promise<void>;
+
+interface UploadedFile {
+    file: UploadFile;
+    url: string;
+    id?: string;
+}
+interface UploadAndSendResult {
+    response: RevoltMessageResponse;
+    uploadedFiles: UploadedFile[];
+}
+declare function uploadAndSend(api: RevoltAPIInstance, data: MessageFormData, nonce: string): Promise<UploadAndSendResult>;
+declare function buildFinalMessage(response: RevoltMessageResponse, data: MessageFormData, currentUser: {
+    _id: string;
+    username: string;
+} | null, uploadedFiles?: UploadedFile[]): Message;
+declare function settleOptimisticMessage(messages: Message[], tempId: string, finalMessage: Message): Message[];
+declare function failOptimisticMessage(messages: Message[], optimistic: Message, threadId?: string): Message[];
+
+declare const addMessage: (currentMessages: Message[], newMessage: Message) => Message[];
+declare const updateMessageInList: (messages: Message[], messageId: string, updates: Partial<Message>) => Message[];
+declare const removeMessageFromList: (messages: Message[], messageId: string) => Message[];
+
+declare const createGroupSubscription: (groupId: string, name: string, owner: {
+    _id: string;
+    username: string;
+}, recipientIds: string[]) => Subscription;
+declare const createDMSubscription: (roomId: string, recipient?: User) => Subscription;
+declare const addOrUpdateSubscription: (subscriptions: Subscription[], newSubscription: Subscription) => Subscription[];
+declare const removeSubscription: (subscriptions: Subscription[], roomId: string) => Subscription[];
+
+/** Requests against corva-api. The host adds the base URL, the Corva JWT and query encoding. */
+interface CorvaApiAdapter {
+    get<T = unknown>(path: string, params?: Record<string, unknown>): Promise<T>;
+    post<T = unknown>(path: string, body?: Record<string, unknown>): Promise<T>;
+}
+interface AppStateAdapter {
+    /** Tab hidden (web) or app in the background (React Native). */
+    isHidden(): boolean;
+    /** Hidden, or visible without focus. Incoming messages alert while inactive. */
+    isInactive(): boolean;
+    /** Fires on hidden <-> visible changes. Returns an unsubscribe function. */
+    subscribe(listener: (hidden: boolean) => void): () => void;
+    /** Fires when the page or app is about to go away (web `pagehide`), to flush pending acks. */
+    onTerminate?(listener: () => void): () => void;
+}
+/** Host-side reactions to chat events; each app decides how (browser notification, push, sound). */
+interface ChatNotifier<TContext = unknown> {
+    showIncomingMessage?(context: TContext): void;
+    onMessageSent?(userId: string): void;
+    onLogout?(): void;
+}
+interface ChatDates {
+    /** Epoch ms of tomorrow at `hour`:00 in the user's timezone. */
+    startOfTomorrowAt(hour: number, now: number): number;
+}
+interface ChatHost {
+    apiUrl: string;
+    wsUrl: string;
+    platform: ChatPlatform;
+    storage: KeyValueStorage;
+    corvaApi: CorvaApiAdapter;
+    appState: AppStateAdapter;
+    dates: ChatDates;
+    notifier?: ChatNotifier;
+}
+/** Call once at app start, before any store is used. */
+declare function configureChat(host: ChatHost): void;
+declare function getChatHost(): ChatHost;
+declare function resetChatHost(): void;
+
+/** The signed-in Corva user fields chat reads. The host's full user object fits as-is. */
+interface CorvaUser {
+    id: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+    company_id: number;
+    profile_photo?: string;
+    title?: string | null;
+    role?: string;
+    company?: {
+        name?: string;
+    };
+}
+interface CorvaRevoltAuthResponse {
+    revolt_session_token: string;
+    revolt_user_id: string;
+    revolt_company_server_id: string;
+    revolt_channel_id: string;
+    revolt_chat_channels?: AssetChatChannel[];
+    chat_used?: boolean | null;
+}
+interface CorvaAPIUserAttributes {
+    email: string;
+    first_name: string;
+    last_name: string;
+    profile_photo?: string;
+    title?: string;
+    role?: string;
+}
+interface CorvaAPIUser {
+    id: string;
+    attributes: CorvaAPIUserAttributes;
+}
+
+type ViewportMode = 'historical' | 'live';
+type ViewportIndexCurve = 'measured_depth' | 'tvd' | 'tvdss' | 'timestamp';
+type ViewportDeepLink = {
+    mode: ViewportMode;
+    indexCurve: ViewportIndexCurve;
+    range?: {
+        from: number;
+        to: number;
+    };
+};
+
+/** A well or pad's active period, used to jump the message list to that time window. */
+interface FilterEntityWindow {
+    id: number;
+    name: string;
+    startMs: number | null;
+    endMs: number | null;
+    dateMs: number | null;
+}
+
+/** Structural equality for plain JSON-like data (settings objects), in place of lodash `isEqual`. */
+declare function isDeepEqual(a: unknown, b: unknown): boolean;
+
+declare const PAUSE_INDEFINITELY: number;
+declare const PAUSE_PRESETS: {
+    readonly THIRTY_MIN: "30m";
+    readonly ONE_HOUR: "1h";
+    readonly FOUR_HOURS: "4h";
+    readonly EIGHT_HOURS: "8h";
+    readonly UNTIL_TOMORROW: "tomorrow";
+    readonly INDEFINITELY: "indefinitely";
+};
+type PausePreset = (typeof PAUSE_PRESETS)[keyof typeof PAUSE_PRESETS];
+interface PausePresetOption {
+    value: PausePreset;
+    label: string;
+}
+declare const PAUSE_PRESET_OPTIONS: PausePresetOption[];
+declare const MUTE_PRESET_OPTIONS: PausePresetOption[];
+declare function getPauseUntil(preset: PausePreset, now?: number): number;
+declare function isPauseActive(until: number | null | undefined, now?: number): boolean;
+declare function isValidPausePreset(value: unknown): value is PausePreset;
+
+declare function waitForNextPaint(): Promise<void>;
+
+declare function getAssetChatChannel(assetId: string, assetType: ChatAssetType): Promise<string>;
+
+type StoredCorvaUser = CorvaUser | CorvaAPIUser;
+/** Extracts common fields from either CorvaUser or CorvaAPIUser */
+declare function getCorvaUserFields(corvaUser: StoredCorvaUser): {
+    firstName: string;
+    lastName: string;
+    email: string;
+    profilePhoto: string | undefined;
+    title: string | null | undefined;
+    role: string | undefined;
+    id: string | number;
+};
+declare function createCorvaUserService(): {
+    setMapping(revoltUserId: string, corvaUser: StoredCorvaUser): void;
+    getCorvaUser(revoltUserId: string): StoredCorvaUser | undefined;
+    clear(): void;
+    enrichUser(user: User): User;
+};
+type CorvaUserService = ReturnType<typeof createCorvaUserService>;
+
+interface AckScheduler {
+    (channelId: string, messageId: string): void;
+    flushAll: () => void;
+    clear: () => void;
+    /** Newest id this page session acked for the channel (TEMP, see applyUnreads). */
+    sessionAcked: (channelId: string) => string | undefined;
+}
+declare function createAckScheduler(api: RevoltAPIInstance): AckScheduler;
+
+interface SharedRefs {
+    api?: RevoltAPIInstance;
+    socket?: RevoltSocketInstance;
+    serverUrl?: string;
+    messageCache: MessageCache;
+    typingManager: TypingManager;
+    corvaUserService: CorvaUserService;
+    forwardedMessageCache: Map<string, Message>;
+    ackChannel?: AckScheduler;
+}
+declare const sharedRefs: SharedRefs;
+
+/**
+ * Bootstrap: creates the Revolt API + WebSocket client, wires socket event
+ * handlers to the new stores, and populates sharedRefs. Idempotent for the
+ * configured apiUrl.
+ */
+declare const initChat: () => void;
+
+interface AuthStore {
+    user: User | null;
+    serverId: string | null;
+    isConnected: boolean;
+    hasEverConnected: boolean;
+    connectionGaveUp: boolean;
+    assetChatChannels: AssetChatChannel[];
+    chatUsed: boolean | null;
+    setUser: (user: User | null) => void;
+    setConnected: (connected: boolean) => void;
+    setHasEverConnected: (hasConnected: boolean) => void;
+    addAssetChatChannel: (channel: AssetChatChannel) => void;
+    markChatUsed: () => void;
+    login: (credentials: LoginCredentials) => Promise<{
+        success: boolean;
+        user?: User;
+        error?: string;
+    }>;
+    loginWithCorva: (corvaUser: CorvaUser) => Promise<{
+        success: boolean;
+        user?: User;
+        error?: string;
+    }>;
+    logout: () => void;
+    restoreSession: (expectedRevoltUserId?: string) => Promise<boolean>;
+    isAuthenticated: () => boolean;
+    isSocketConnected: () => boolean;
+}
+declare function keepChatUsed(current: boolean | null, incoming: boolean | null | undefined): boolean | null;
+declare const authStore: zustand_vanilla.StoreApi<AuthStore>;
+/** @public */
+declare const resetAuthStore: () => void;
+
+interface HiddenRoomsSettings {
+    hiddenRooms: string[];
+}
+declare const DEFAULT_HIDDEN_ROOMS_SETTINGS: HiddenRoomsSettings;
+interface RoomStore {
+    rooms: Room[];
+    subscriptions: Subscription[];
+    /** True once the initial loadSubscriptions attempt has finished (even on failure). */
+    subscriptionsLoaded: boolean;
+    /** True once Ready (or /sync/unreads) has replaced the "seeded as read" pointers with server truth. */
+    unreadsHydrated: boolean;
+    currentRoom: Room | null;
+    hiddenRoomsSettings: HiddenRoomsSettings;
+    persistHiddenRoomsCallback?: (hiddenRooms: string[]) => void;
+    roomListOrder: RoomListOrder;
+    setRooms: (rooms: Room[]) => void;
+    setSubscriptions: (subscriptions: Subscription[]) => void;
+    setCurrentRoom: (room: Room | null) => void;
+    addOrUpdateSubscription: (subscription: Subscription) => void;
+    removeSubscriptionById: (roomId: string) => void;
+    setRoomListOrder: (order: RoomListOrder) => void;
+    markAllAsRead: () => void;
+    setHiddenRoomsSettings: (settings: HiddenRoomsSettings) => void;
+    setPersistHiddenRoomsCallback: (callback: ((hiddenRooms: string[]) => void) | undefined) => void;
+    hideRoom: (roomId: string) => void;
+    unhideRoom: (roomId: string) => void;
+    isRoomHidden: (roomId: string) => boolean;
+    loadSubscriptions: () => Promise<void>;
+    selectRoom: (roomId: string) => Promise<void>;
+    navigateToMessage: (roomId: string, messageId: string, options?: {
+        threadId?: string;
+    }) => Promise<boolean>;
+    enrichDmSubscription: (roomId: string, userId: string) => Promise<void>;
+    createDirectMessage: (username: string) => Promise<Room | undefined>;
+    createDirectMessageById: (userId: string) => Promise<Room | undefined>;
+    createGroupChannel: (name: string, userIds: string[]) => Promise<Room | undefined>;
+    addUserToGroup: (groupId: string, userId: string) => Promise<boolean>;
+    removeUserFromGroup: (groupId: string, userId: string) => Promise<boolean>;
+    getGroupMembers: (groupId: string) => Promise<User[]>;
+    leaveCurrentChannel: (leaveSilently?: boolean | null) => Promise<boolean>;
+    updateChannel: (channelId: string, updates: {
+        name?: string;
+        description?: string;
+    }) => Promise<RevoltChannel | null>;
+}
+declare const roomStore: zustand_vanilla.StoreApi<RoomStore>;
+declare const resetRoomStore: () => void;
+
+interface MessageStore {
+    messages: Message[];
+    hasMoreMessages: boolean;
+    isLoadingMoreMessages: boolean;
+    setMessages: (messages: Message[]) => void;
+    addMessageToList: (message: Message) => void;
+    updateMessage: (messageId: string, updates: Partial<Message>) => void;
+    removeMessage: (messageId: string) => void;
+    setHasMoreMessages: (hasMore: boolean) => void;
+    setLoadingMoreMessages: (loading: boolean) => void;
+    loadMessages: (roomId: string, roomType: RoomType, count?: number) => Promise<void>;
+    loadMoreMessages: () => Promise<void>;
+    sendMessage: (data: MessageFormData) => Promise<unknown>;
+    retrySendMessage: (tempId: string) => Promise<unknown>;
+    dismissFailedMessage: (tempId: string) => void;
+    editMessage: (messageId: string, content: string) => Promise<void>;
+    deleteMessage: (messageId: string) => Promise<void>;
+    pinMessage: (messageId: string) => Promise<void>;
+    unpinMessage: (messageId: string) => Promise<void>;
+    toggleReaction: (messageId: string, emoji: string) => Promise<void>;
+    getAllMessages: (roomId: string, maxMessages?: number) => Promise<Message[]>;
+    preloadRoomMessages: (roomId: string) => Promise<void>;
+    fetchOriginalMessage: (channelId: string, messageId: string) => Promise<Message | null>;
+}
+declare const messageStore: zustand_vanilla.StoreApi<MessageStore>;
+declare const resetMessageStore: () => void;
+
+interface MemberStore {
+    members: User[];
+    membersRoomId: string | null;
+    membersById: Record<string, User>;
+    typingUsers: string[];
+    serverMembersLoaded: boolean;
+    serverMembersCache: User[] | null;
+    allVisibleUsersCache: User[] | null;
+    corvaUserMappings: Record<string, CorvaUser | CorvaAPIUser>;
+    setMembers: (members: User[], roomId?: string) => void;
+    setCorvaUserMapping: (revoltUserId: string, corvaUser: CorvaUser | CorvaAPIUser) => void;
+    bulkSetCorvaUserMappings: (mappings: Array<{
+        revoltUserId: string;
+        corvaUser: CorvaUser | CorvaAPIUser;
+    }>) => void;
+    getCorvaUserFromState: (revoltUserId: string) => CorvaUser | CorvaAPIUser | undefined;
+    addMemberToCache: (user: User) => void;
+    getMemberById: (userId: string) => User | undefined;
+    removeUserFromMembers: (userId: string) => void;
+    addTypingUser: (userId: string) => void;
+    removeTypingUser: (userId: string) => void;
+    setTypingUsers: (users: string[]) => void;
+    simulateTyping: (userKey: string, isTyping: boolean, displayName?: string) => void;
+    loadRoomMembers: (roomId: string, roomType: RoomType, isAssetChat?: boolean) => Promise<void>;
+    searchUsers: (query: string) => Promise<User[]>;
+    getUserByUsername: (username: string) => Promise<User | null>;
+    getAllVisibleUsers: () => Promise<User[]>;
+    syncCorvaUsers: (companyId?: number) => Promise<boolean>;
+}
+declare const memberStore: zustand_vanilla.StoreApi<MemberStore>;
+declare const resetMemberStore: () => void;
+
+interface TracesViewportRequest {
+    wellAssetId: number;
+    viewport: ViewportDeepLink;
+}
+interface InlineViewState {
+    appId: string;
+    activityId?: string;
+    viewKey: string;
+    appUrl?: string;
+    settingsSnapshotId?: string;
+    tracesViewport?: TracesViewportRequest;
+}
+interface UIStore {
+    isLoading: boolean;
+    error: string | null;
+    isChatVisible: boolean;
+    isSidebarOpen: boolean;
+    sidebarTab: SidebarTabKey;
+    sidebarSectionRequest: SidebarSectionKey | null;
+    sidebarSearchFocusTrigger: number;
+    isNewMessageOpen: boolean;
+    inputFocusTrigger: number;
+    pendingThreadId: string | null;
+    pendingThreadRoomId: string | null;
+    pendingHighlightMessageId: string | null;
+    ephemeralMentionUsersByRoom: Record<string, User[]>;
+    messageDraftsByRoom: Record<string, string>;
+    forwardingMessage: Message | null;
+    forwardingComment: AppCommentData | null;
+    sharingFile: SharedFile | null;
+    inlineViewState: InlineViewState | null;
+    isNavigatingToMessage: boolean;
+    isSwitchingRoom: boolean;
+    pendingWellJump: FilterEntityWindow | null;
+    attentionSeriesPlayed: number;
+    attentionNextSeriesAt: number | null;
+    channelSettingsRequestedAt: number | null;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearError: () => void;
+    setChatVisible: (visible: boolean) => void;
+    setSidebarOpen: (open: boolean) => void;
+    setSidebarTab: (tab: SidebarTabKey) => void;
+    requestSidebarSection: (section: SidebarSectionKey) => void;
+    clearSidebarSectionRequest: () => void;
+    requestSidebarSearchFocus: () => void;
+    setNewMessageOpen: (open: boolean) => void;
+    triggerInputFocus: () => void;
+    setPendingThreadId: (threadId: string | null) => void;
+    setPendingThreadRoomId: (roomId: string | null) => void;
+    setPendingHighlightMessageId: (messageId: string | null) => void;
+    setEphemeralMentionUsers: (roomId: string, users: User[]) => void;
+    clearEphemeralMentionUsers: (roomId: string) => void;
+    getEphemeralMentionUsers: (roomId: string | undefined) => User[];
+    setMessageDraft: (draftKey: string, text: string) => void;
+    setForwardingMessage: (message: Message | null) => void;
+    setForwardingComment: (data: AppCommentData | null) => void;
+    setSharingFile: (file: SharedFile | null) => void;
+    setInlineViewState: (state: InlineViewState | null) => void;
+    setNavigatingToMessage: (navigating: boolean) => void;
+    setSwitchingRoom: (switching: boolean) => void;
+    setPendingWellJump: (period: FilterEntityWindow | null) => void;
+    recordAttentionSeries: (params: {
+        startedAt: number;
+        cooldownMs: number;
+    }) => void;
+    requestChannelSettings: () => void;
+    clearChannelSettingsRequest: () => void;
+}
+declare const uiStore: zustand_vanilla.StoreApi<UIStore>;
+declare const resetUIStore: () => void;
+
+type LockedAsset = ChatAsset & {
+    type: ChatAssetType;
+};
+interface AssetStore {
+    currentAssetId: string | null;
+    currentAssetType: ChatAssetType | null;
+    currentAssetName: string | null;
+    currentAssetStatus: string | null;
+    assetChatId: string | null;
+    assetChatError: string | null;
+    knownAssetChatIds: Set<string>;
+    panelSyncedAssetId: string | null;
+    isAssetLocked: boolean;
+    lockedAsset: LockedAsset | null;
+    isAssetSwitching: boolean;
+    setAssetContext: (assetId: string, assetType: ChatAssetType, assetName?: string, assetStatus?: string, skipAutoSelect?: boolean) => Promise<void>;
+    clearAssetContext: () => void;
+    ensureAssetChatSubscription: () => Promise<Subscription | null>;
+    toggleAssetLock: () => void;
+    relockToAsset: (assetId: string, assetType: ChatAssetType, assetName: string) => Promise<void>;
+}
+declare const assetStore: zustand_vanilla.StoreApi<AssetStore>;
+declare const resetAssetStore: () => void;
+
+declare const NOTIFICATION_SETTING_ALL: "all";
+declare const NOTIFICATION_SETTING_MENTIONS: "mentions";
+declare const NOTIFICATION_SETTING_NOTHING: "nothing";
+type ChannelNotificationSetting = typeof NOTIFICATION_SETTING_ALL | typeof NOTIFICATION_SETTING_MENTIONS | typeof NOTIFICATION_SETTING_NOTHING;
+type EmailNotificationSetting = typeof NOTIFICATION_SETTING_MENTIONS | typeof NOTIFICATION_SETTING_NOTHING;
+declare const NOTIFICATION_DESTINATIONS: {
+    readonly PLATFORM: "platform";
+    readonly MOBILE: "mobile";
+    readonly EMAIL: "email";
+};
+type NotificationDestination = (typeof NOTIFICATION_DESTINATIONS)[keyof typeof NOTIFICATION_DESTINATIONS];
+interface ChannelDestinationSettings {
+    platform: ChannelNotificationSetting;
+    mobile: ChannelNotificationSetting;
+    email: EmailNotificationSetting;
+}
+interface ChannelNotificationPreference {
+    setting: ChannelDestinationSettings;
+    muted: boolean;
+    mutedUntil: number | null;
+    mutePreset: PausePreset | null;
+    notifyThreadReplies: boolean;
+}
+interface NotificationSettings {
+    channels: Record<string, ChannelNotificationPreference>;
+}
+interface NotificationPreferences {
+    browserNotifications: boolean;
+    sound: boolean;
+    pausedUntil: number | null;
+    pausePreset: PausePreset | null;
+}
+interface NotificationStore {
+    notificationSettings: NotificationSettings;
+    preferences: NotificationPreferences;
+    setPreferences: (preferences: NotificationPreferences) => void;
+    setBrowserNotificationsEnabled: (enabled: boolean) => void;
+    setSoundEnabled: (enabled: boolean) => void;
+    pauseNotifications: (preset: PausePreset) => void;
+    resumeNotifications: () => void;
+    setChannelNotificationSetting: (roomId: string, setting: ChannelNotificationSetting) => void;
+    setChannelDestinationSetting: {
+        (roomId: string, destination: typeof NOTIFICATION_DESTINATIONS.EMAIL, setting: EmailNotificationSetting): void;
+        (roomId: string, destination: typeof NOTIFICATION_DESTINATIONS.PLATFORM | typeof NOTIFICATION_DESTINATIONS.MOBILE, setting: ChannelNotificationSetting): void;
+        (roomId: string, destination: NotificationDestination, setting: ChannelNotificationSetting): void;
+    };
+    setChannelMuted: (roomId: string, muted: boolean) => void;
+    muteChannelFor: (roomId: string, preset: PausePreset | null) => void;
+    setChannelThreadReplies: (roomId: string, notify: boolean) => void;
+    resetChannelPreference: (roomId: string) => void;
+    setNotificationSettings: (settings: NotificationSettings) => void;
+}
+declare const DEFAULT_NOTIFICATION_SETTINGS: NotificationSettings;
+declare const DEFAULT_NOTIFICATION_PREFERENCES: NotificationPreferences;
+declare const DEFAULT_CHANNEL_PREFERENCE: ChannelNotificationPreference;
+type StoredChannelPreference = Partial<Omit<ChannelNotificationPreference, 'setting'> & {
+    setting: ChannelNotificationSetting | Partial<ChannelDestinationSettings>;
+}>;
+declare function withChannelPreferenceDefaults(pref: StoredChannelPreference | undefined): ChannelNotificationPreference;
+declare function isDefaultChannelPreference(pref: StoredChannelPreference | undefined): boolean;
+declare function isChannelMuted(pref: Pick<ChannelNotificationPreference, 'muted' | 'mutedUntil'> | undefined, now?: number): boolean;
+declare function isNotificationsPaused(preferences: Pick<NotificationPreferences, 'pausedUntil'>, now?: number): boolean;
+declare const notificationStore: zustand_vanilla.StoreApi<NotificationStore>;
+declare const resetNotificationStore: () => void;
+
+interface ChannelContentFilter {
+    showFeeds: boolean;
+    selectedFeeds: string[];
+}
+interface ChannelContentFilters {
+    channels: Record<string, ChannelContentFilter>;
+}
+interface ChannelContentFilterStore {
+    channelContentFilters: ChannelContentFilters;
+    setChannelContentFilters: (filters: ChannelContentFilters) => void;
+    setChannelShowFeeds: (channelId: string, showFeeds: boolean) => void;
+    setChannelSelectedFeeds: (channelId: string, selectedFeeds: string[]) => void;
+}
+declare const DEFAULT_CHANNEL_CONTENT_FILTER: ChannelContentFilter;
+declare const DEFAULT_CHANNEL_CONTENT_FILTERS: ChannelContentFilters;
+declare const channelContentFilterStore: zustand_vanilla.StoreApi<ChannelContentFilterStore>;
+declare const resetChannelContentFilterStore: () => void;
+
+type ChatToastData = {
+    title: string;
+    content?: string;
+};
+type ChatToastStore = {
+    toastsById: Record<string, ChatToastData>;
+    setToast: (toastId: string, data: ChatToastData) => void;
+    removeToast: (toastId: string) => void;
+};
+declare const chatToastStore: zustand_vanilla.StoreApi<ChatToastStore>;
+
+interface FavoriteRoomsSettings {
+    favoriteRoomIds: string[];
+}
+interface FavoriteRoomsStore {
+    favoriteRoomsSettings: FavoriteRoomsSettings;
+    persistFavoriteRoomsCallback?: (favoriteRoomIds: string[]) => void;
+    setFavoriteRoomsSettings: (settings: FavoriteRoomsSettings) => void;
+    setPersistFavoriteRoomsCallback: (callback: ((favoriteRoomIds: string[]) => void) | undefined) => void;
+    addFavoriteRoom: (roomId: string) => void;
+    removeFavoriteRoom: (roomId: string) => void;
+    isRoomFavorite: (roomId: string) => boolean;
+}
+declare const DEFAULT_FAVORITE_ROOMS_SETTINGS: FavoriteRoomsSettings;
+declare const favoriteRoomsStore: zustand_vanilla.StoreApi<FavoriteRoomsStore>;
+declare const resetFavoriteRoomsStore: () => void;
+
+interface NavigationEntry {
+    roomId: string;
+    threadId?: string;
+}
+interface NavigationHistoryStore {
+    entries: NavigationEntry[];
+    index: number;
+    requestedEntry: NavigationEntry | null;
+    record: (entry: NavigationEntry) => void;
+    goBack: () => void;
+    goForward: () => void;
+    clearRequestedEntry: () => void;
+    forgetRoom: (roomId: string) => void;
+}
+declare const MAX_NAVIGATION_HISTORY = 50;
+declare const navigationHistoryStore: zustand_vanilla.StoreApi<NavigationHistoryStore>;
+declare const selectCanGoBack: (s: NavigationHistoryStore) => boolean;
+declare const selectCanGoForward: (s: NavigationHistoryStore) => boolean;
+declare const resetNavigationHistoryStore: () => void;
+
+declare function handleUnauthorized(): Promise<void>;
+declare function ensureChatSession(corvaUser: CorvaUser): Promise<boolean>;
+
+type RoomSelectionStateUpdate = Partial<Pick<UIStore, 'isLoading' | 'isSwitchingRoom'>>;
+interface PrepareRoomSelectionParams {
+    roomId: string;
+    currentRoomId?: string;
+    isCacheDirty: (roomId: string) => boolean;
+    getCachedMessages: (roomId: string) => Message[] | undefined;
+    setState: (state: RoomSelectionStateUpdate) => void;
+}
+interface RoomSelectionRequest {
+    id: number;
+    roomId: string;
+}
+declare function isCurrentRoomSelection(request: RoomSelectionRequest): boolean;
+declare function prepareRoomSelection({ roomId, currentRoomId, isCacheDirty, getCachedMessages, setState, }: PrepareRoomSelectionParams): Promise<RoomSelectionRequest | null>;
+
+interface SocketEventHandlersConfig {
+    api: RevoltAPIInstance;
+    messageCache: MessageCache;
+    typingManager: TypingManager;
+    loadMessages: (roomId: string, roomType: RoomType) => Promise<void>;
+    simulateTyping: (userKey: string, isTyping: boolean, displayName?: string) => void;
+}
+declare const createSocketEventHandlers: (config: SocketEventHandlersConfig) => {
+    onConnected: () => void;
+    onAuthenticated: () => void;
+    onDisconnected: () => void;
+    onReady: (channels: ReadyChannelData[], channelUnreads?: ChannelUnread[]) => void;
+    onChannelAck: (channelId: string, messageId: string) => void;
+    onMessage: (message: Message) => void;
+    onRoomChange: (roomId: string, change: unknown) => void;
+    onTyping: (data: {
+        userId?: string;
+        username: string;
+        roomId: string;
+        isTyping: boolean;
+    }) => void;
+    onMessageUpdate: (messageId: string, channelId: string, data: {
+        content?: string;
+        edited?: string;
+    }) => void;
+    onMessageDelete: (messageId: string, channelId: string) => void;
+    onUserStatusChange: (userId: string, status: string) => void;
+    onInvalidSession: () => void | undefined;
+    onError: (error: unknown) => void;
+};
+
+declare const installUnreadWatcher: () => void;
 
-export { type AlertWirePayload, type AppCommentWirePayload, type AskCorvaWirePayload, type AttachmentWirePayload, CORVA_MESSAGE_TYPES, CORVA_SYS_PREFIX, type CorvaSystemMessage, type FeedWirePayload, type ForwardWirePayload, type WireSeverity, buildAskCorvaMessageContent, buildForwardMessageContent };
+export { ALERT_SEVERITY, ASSET_API_FIELDS, ASSET_CHAT_PREFIXES, ASSET_NOUN, type AckScheduler, type AlertData, type AlertSeverity, type AlertWirePayload, type AppCommentAttachment, type AppCommentData, type AppCommentWirePayload, type AppStateAdapter, type AskCorvaData, type AskCorvaWirePayload, type AssetChatChannel, type AssetStore, type Attachment, type AuthStore, CHANNEL_NAME_MAX_LENGTH, CHANNEL_TYPES, CORVA_MESSAGE_TYPES, CORVA_SYS_PREFIX, type ChannelAsset, type ChannelContentFilter, type ChannelContentFilterStore, type ChannelContentFilters, type ChannelNameValidation, type ChannelNotificationPreference, type ChannelNotificationSetting, type ChannelUnread, type ChatAsset, type ChatAssetIdentity, type ChatAssetType, type ChatDates, type ChatHost, type ChatNotifier, type ChatPlatform, type CorvaAPIUser, type CorvaApiAdapter, type CorvaRevoltAuthResponse, type CorvaSystemMessage, type CorvaUser, type CorvaUserService, DATE_SEPARATOR_LABELS, DEFAULT_CHANNEL_CONTENT_FILTER, DEFAULT_CHANNEL_CONTENT_FILTERS, DEFAULT_CHANNEL_PREFERENCE, DEFAULT_FAVORITE_ROOMS_SETTINGS, DEFAULT_HIDDEN_ROOMS_SETTINGS, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_SETTINGS, DEFAULT_ROOM_LIST_ORDER, DIRECT_MESSAGE_PLACEHOLDER, type FavoriteRoomsSettings, type FavoriteRoomsStore, type FeedItemData, type FeedWirePayload, type FileAttachment, type FilterEntityWindow, type ForwardWirePayload, type ForwardedFrom, GENERAL_CHAT_NAME, type HiddenRoomsSettings, type HttpClient, type HttpClientConfig, HttpError, type HttpRequestInit, type HttpResponseLike, type KeyValueStorage, type LocatorContext, type LoginCredentials, MAX_ATTACHMENT_SIZE_BYTES, MAX_ATTACHMENT_SIZE_MB, MAX_NAVIGATION_HISTORY, MENTION_REPLACE_PATTERN, MENTION_SPLIT_PATTERN, MUTE_PRESET_OPTIONS, type MemberStore, type Message, type MessageCache, type MessageFormData, type MessageStore, NOTIFICATION_DESTINATIONS, NOTIFICATION_SETTING_ALL, NOTIFICATION_SETTING_MENTIONS, NOTIFICATION_SETTING_NOTHING, type NavigationEntry, type NavigationHistoryStore, type NotificationDestination, type NotificationPreferences, type NotificationSettings, type NotificationStore, PAUSE_INDEFINITELY, PAUSE_PRESETS, PAUSE_PRESET_OPTIONS, type PausePreset, type PausePresetOption, REVOLT_SYSTEM_USER_ID, ROOM_LIST_ORDER, type ReadyChannelData, type RevoltAPIInstance, type RevoltChannel, type RevoltIncomingMessagePayload, type RevoltLoginResponse, type RevoltMessage, type RevoltMessageResponse, type RevoltSocketConfig, type RevoltSocketEventHandlers, type RevoltSocketInstance, type RevoltUploadResponse, type RevoltUserResponse, type Room, type RoomListOrder, type RoomStore, type RoomType, SESSION_STORAGE_KEY, SIDEBAR_SECTIONS, SIDEBAR_TABS, SOFT_DELETE_MARKER, SYSTEM_MESSAGE_TEXTS, type SaveSessionParams, type SelectableAssetType, type SessionData, SessionManager, type SharedFile, type SharedRefs, type SidebarSectionKey, type SidebarTabKey, type SocketCloseEventLike, type SocketEventHandlersConfig, type StoredChannelPreference, type Subscription, type TracesViewportRequest, type TypingManager, type UIStore, type UploadAndSendResult, type UploadFile, type UploadedFile, type User, type UserStatus, type ViewportDeepLink, type ViewportIndexCurve, type ViewportMode, WEBSOCKET_CONNECTING, WEBSOCKET_OPEN, type WebSocketLike, type WireSeverity, addMessage, addOrUpdateSubscription, alertMessageAsText, assetStore, authStore, buildAppCommentMessageContent, buildAskCorvaMessageContent, buildFinalMessage, buildForwardMessageContent, buildGroupChannelName, canDeleteMessage, canEditMessage, channelContentFilterStore, channelToAsset, chatToastStore, clearLastOpenedRoom, compareByActivity, compareByName, compareByRecencyDesc, configureChat, configureChatStorage, createAckScheduler, createCorvaUserService, createDMSubscription, createGroupSubscription, createHttpClient, createLatestWinsQueue, createMemoryStorage, createMessageCache, createRevoltAPI, createRevoltSocket, createRoomTaskQueue, createSocketEventHandlers, createSoftDeletedMessage, createTypingManager, deriveAllowedChatAsset, enrichWithCorvaData, ensureChatSession, extractTimestampFromULID, failOptimisticMessage, favoriteRoomsStore, findGeneralRoom, formatAssetChatName, getAppCommentAttachments, getAssetChatChannel, getAssetTypeFromDisplayName, getChatHost, getChatStorage, getCorvaUserFields, getLastOpenedRoom, getMessageTimestamp, getPauseUntil, getReactionCount, getRoomDisplayName, getSystemMessageWithCorvaNames, getUserDisplayName, getUserSecondaryText, handleUnauthorized, hasReactions, hasUserReacted, initChat, installUnreadWatcher, isAlertMessage, isAppCommentMessage, isAskCorvaMessage, isChannelMuted, isChatAssetTypeAllowed, isCurrentRoomSelection, isDeepEqual, isDefaultChannelPreference, isDisallowedAssetChatRoom, isDmGroup, isForwardedMessage, isGeneralRoom, isNotificationsPaused, isPauseActive, isSoftDeletedMessage, isSystemMessage, isUnread, isUserOnline, isValidPausePreset, isVisibleUnread, keepChatUsed, loadUntilFound, memberStore, messageStore, navigationHistoryStore, notificationStore, parseCorvaSystemMessage, prepareRoomSelection, removeMessageFromList, removeSubscription, resetAssetStore, resetAuthStore, resetChannelContentFilterStore, resetChatAssetPermissionsSnapshot, resetChatHost, resetFavoriteRoomsStore, resetMemberStore, resetMessageStore, resetNavigationHistoryStore, resetNotificationStore, resetRoomStore, resetUIStore, roomStore, saveLastChatActivity, saveLastOpenedRoom, searchMessages, searchRooms, searchUsers, selectCanGoBack, selectCanGoForward, setAllowedChatAssetTypes, settleOptimisticMessage, sharedRefs, sortChannels, sortDMs, sortMessagesByTime, sortUsersByStatus, stripPlatformMentions, uiStore, updateMessageInList, uploadAndSend, validateChannelName, waitForNextPaint, wasRecentlyActive, withChannelPreferenceDefaults };