@arbidocs/react 0.5.111 → 0.5.113

package/dist/useAudioRecorder.d-B9rlMI_E.d.cts

@@ -1,778 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-import { Arbi, calls, chats, CallApiError } from '@arbidocs/sdk/browser';
-import { WsAgentDmStatusMessage } from '@arbidocs/client';
-
-/**
- * The meeting chat of a call (ARBI `docs/meeting-chats-plan.md` §3–4).
- *
- * Every call has one place its conversation persists:
- *   - an E2E `chats` row (`cht-`): the direct chat of a DM call, the group of a group call, or a
- *     `meeting` chat made lazily on first use — its key is a fresh random epoch key sealed in this
- *     browser to each member (creator + invitees by default), its title encrypted under it;
- *   - a shared thread (`con-`) in the locked workspace of a thread call — encrypted by the server
- *     with the workspace key like any thread, so @ARBI works there.
- *
- * `ensureMeetingChat` is get-or-create (`POST /v1/calls/{id}/chat`; the server serialises
- * concurrent creators, the loser gets the winner's chat).
- */
-
-type MeetingChatRef = {
-    kind: 'chat';
-    chatExtId: string;
-} | {
-    kind: 'thread';
-    conversationExtId: string;
-    workspaceExtId: string;
-};
-/** The meeting chat a call (or a `POST /chat` answer) already names, or null. */
-declare function meetingChatRefFrom(row: Pick<calls.CallResponse, 'chat_ext_id' | 'meeting_conversation_ext_id'> & {
-    locked_workspace_ext_id?: string | null;
-    workspace_ext_id?: string | null;
-}): MeetingChatRef | null;
-/** The keys the call row itself carries: its creator's and each invitee's. */
-declare function callMemberKeys(call: Pick<calls.CallResponse, 'creator_ext_id' | 'creator_encryption_public_key' | 'invitees'>): Map<string, string>;
-/**
- * The E2E body for a new meeting chat: a fresh chat key sealed to me and to each member whose
- * public key is known (the call's creator and invitees by default, with the keys the call row
- * carries; `extraMembers` beyond them also get K sealed to them, so they can always join), and the
- * call's title under the chat key. A member without a key is left out (they can be added later);
- * `members` may be empty — a chat with only me is valid.
- */
-declare function buildMeetingChatBody(arbi: Arbi, queryClient: QueryClient, call: calls.CallResponse, callKey: Uint8Array, extraMembers?: string[]): Promise<calls.CallChatCreate>;
-/** The call's meeting chat, made now if it has none. Concurrent callers share one request. */
-declare function ensureMeetingChat(arbi: Arbi, queryClient: QueryClient, callExtId: string, callKey: Uint8Array): Promise<MeetingChatRef>;
-/** Forget cached refs (tests; sign-out). */
-declare function clearMeetingChatCache(): void;
-/** A call whose meeting chat is to be shown, with what is already known about it. */
-interface MeetingChatTarget {
-    callExtId: string;
-    /** The call's E2E chat (DM / group / meeting), when known. */
-    chatExtId?: string | null;
-    /** A thread call's meeting thread, when known, and its workspace. */
-    meetingConversationExtId?: string | null;
-    workspaceExtId?: string | null;
-    /** K, when the caller already has it (else my sealed copy is opened). */
-    callKey?: Uint8Array | null;
-}
-/** The ref for a target whose chat is already known, or null when it must be made / looked up. */
-declare function knownMeetingChat(target: MeetingChatTarget): MeetingChatRef | null;
-/** The target's meeting chat: the known one, else made on first use (needs K). */
-declare function resolveMeetingChat(arbi: Arbi, queryClient: QueryClient, target: MeetingChatTarget): Promise<MeetingChatRef>;
-
-/**
- * The call session: the one active call of this browser tab, the queue of incoming rings, lobby
- * knocks waiting for this user's decision, and which calls the server says are live.
- *
- * Session-only and in memory: a LiveKit token and the call key never reach storage, so a reload
- * starts empty. One per tab (a tab is in at most one call), so it is a module store read with
- * {@link useCallSession} and changed with {@link callSession}'s actions, from React and from plain
- * code (call actions, the WebSocket) alike. Signing out calls {@link resetCallSession}.
- */
-
-/** The devices picked before joining (the pre-join). */
-interface JoinChoices {
-    audioEnabled: boolean;
-    videoEnabled: boolean;
-    audioDeviceId?: string;
-    videoDeviceId?: string;
-}
-/** Microphone on, camera off: an answered ring joins with these (calls are audio-first). */
-declare const DEFAULT_JOIN_CHOICES: JoinChoices;
-interface ActiveCall {
-    callExtId: string;
-    /** The call's E2EE key K (32 bytes). */
-    key: Uint8Array;
-    linkVersion: number;
-    /** Display label for the dock header. */
-    title: string | null;
-    isCreator: boolean;
-    /** The call's E2E chat (DM, group or meeting chat), when it has one. */
-    chatExtId: string | null;
-    /** Thread call: the thread with the log card. */
-    logConversationExtId: string | null;
-    /** Thread call: its meeting thread, once made. */
-    meetingConversationExtId: string | null;
-    /** Thread call: the workspace it is locked to. */
-    lockedWorkspaceExtId: string | null;
-    /**
-     * `prejoin` shows the device check, `knocking` waits in the lobby, `connected` mounts the room.
-     * A webinar's audience also has `webinar-waiting` ("Starting soon": not live yet, joins by itself
-     * once it is) and `webinar-ended` (the host ended it).
-     */
-    phase: 'prejoin' | 'knocking' | 'connected' | 'webinar-waiting' | 'webinar-ended';
-    tokenResponse: calls.CallTokenResponse | null;
-    choices: JoinChoices | null;
-    /** While knocking: stops waiting for admission. */
-    knock: {
-        abort(): void;
-    } | null;
-    /** Users to ring once we join: user ext id → K sealed to them. */
-    ringOnJoin: Record<string, string> | null;
-    /** A personal invite link's token (`/call/<id>?i=…`): redeemed for a token, no lobby. */
-    inviteToken?: string | null;
-    minimized: boolean;
-    startedAt: number;
-    /**
-     * A webinar's stage changed under us (moved to the audience, or stepped down): the server removes
-     * us from the room and we join again with a new token, so that room's disconnect is not a leave.
-     */
-    rejoining?: boolean;
-}
-/** A ring waiting for accept/decline. */
-interface IncomingCall extends Omit<calls.CallRingingMessage, 'type'> {
-    receivedAt: number;
-}
-/** Someone in the lobby of a call this user can admit people to. */
-interface PendingKnock {
-    callExtId: string;
-    knockId: string;
-    displayName: string;
-    /** The signed-in user asking (everyone in a call has an account). */
-    userExtId: string;
-    receivedAt: number;
-}
-/** Where a live call belongs (from `call.started`). */
-interface LiveCall {
-    chatExtId: string | null;
-    logConversationExtId: string | null;
-    meetingConversationExtId: string | null;
-}
-interface CallSessionState {
-    active: ActiveCall | null;
-    incoming: IncomingCall[];
-    knocks: PendingKnock[];
-    /** Calls the server says are live (`call.started` … `call.ended`), by call ext id. */
-    liveCalls: Record<string, LiveCall>;
-}
-type NewActiveCall = Omit<ActiveCall, 'minimized' | 'startedAt'> & {
-    minimized?: boolean;
-};
-declare const EMPTY_CALL_SESSION: CallSessionState;
-/** The call session's state and actions (usable outside React). */
-declare const callSession: {
-    getState: () => CallSessionState;
-    subscribe(listener: () => void): () => void;
-    setActiveCall(next: NewActiveCall): void;
-    /** Patch the active call (no-op when it is a different call or none). */
-    updateActiveCall(callExtId: string, patch: Partial<ActiveCall>): void;
-    endActiveCall(): void;
-    setCallMinimized(minimized: boolean): void;
-    /** Queue a ring. A repeat ring for the same call replaces the earlier entry. */
-    enqueueIncomingCall(ring: Omit<IncomingCall, "receivedAt">): void;
-    removeIncomingCall(callExtId: string): void;
-    addKnock(knock: Omit<PendingKnock, "receivedAt">): void;
-    removeKnock(knockId: string): void;
-    markCallLive(callExtId: string, where: LiveCall): void;
-    /** Call ended: forget it and drop any unanswered ring / knock for it. */
-    markCallEnded(callExtId: string): void;
-};
-/** Forget everything (signing out). A call in progress is left by its room unmounting. */
-declare function resetCallSession(): void;
-/** Read the call session in React, re-rendering when the selected value changes. */
-declare function useCallSession<T>(selector: (state: CallSessionState) => T): T;
-/** The id of the thread's live call, if the server reports one (a thread call). */
-declare function threadLiveCallId(s: CallSessionState, conversationExtId: string): string | null;
-/** Whether the server reports a live call logged in this thread. */
-declare function threadHasLiveCall(s: CallSessionState, conversationExtId: string): boolean;
-/** The id of the chat's live call (DM, group or meeting chat), if the server reports one. */
-declare function chatLiveCallId(s: CallSessionState, chatExtId: string): string | null;
-/** Whether the server reports a live call in this chat (DM, group or meeting chat). */
-declare function chatHasLiveCall(s: CallSessionState, chatExtId: string): boolean;
-
-/**
- * The one chat cache: my chat list (`arbiQueryKeys.chatList()`, raw — titles and last messages
- * stay ciphertext) and each open thread (`arbiQueryKeys.chatThread(id)`, decrypted). Every reader
- * (the messenger, unread badges, the DM kit, a call's chat) and every writer (a send, a delete,
- * a WebSocket event) goes through here, so one change shows everywhere at once.
- *
- * Live events: `<ArbiWebSocketProvider>` applies them itself; a host with its own socket passes each
- * chat event to `applyChatEvent`.
- */
-
-type ChatResponse = chats.ChatResponse;
-type ChatMessageResponse = chats.ChatMessageResponse;
-type DecryptedChatMessage = chats.DecryptedChatMessage;
-type ChatAttachmentFile = chats.ChatAttachmentFile;
-type ChatMemberKey = chats.ChatMemberKey;
-/** A message in an open thread; an optimistic row carries a local id until the server echoes it. */
-type ChatThreadMessage = DecryptedChatMessage & {
-    optimistic?: boolean;
-};
-/** An open thread's cache entry: decrypted messages, oldest first. */
-interface ChatThreadData {
-    messages: ChatThreadMessage[];
-    /** False once the oldest page has been loaded. */
-    hasMore: boolean;
-}
-/** The signed-in user's external id, or null when signed out. */
-declare function myChatId(arbi: Arbi): string | null;
-declare function setOpenChat(chatExtId: string | null): void;
-declare function getOpenChat(): string | null;
-/** My chats as the cache holds them (empty until the list has loaded). */
-declare function cachedChats(queryClient: QueryClient): ChatResponse[];
-/** One of my chats from the cache, if the list has it. */
-declare function cachedChat(queryClient: QueryClient, chatExtId: string): ChatResponse | undefined;
-/** Put a chat (new or updated) into the list, keeping the list newest first. */
-declare function upsertChat(queryClient: QueryClient, chat: ChatResponse): void;
-/** Drop a chat I left or lost, with its thread. */
-declare function removeChat(queryClient: QueryClient, chatExtId: string): void;
-/** Append a message to a loaded thread (deduplicated, replacing its optimistic copy). */
-declare function appendToThread(queryClient: QueryClient, chatExtId: string, message: ChatThreadMessage, replaceOptimisticId?: string): void;
-/** `chat.message`: a new message in one of my chats. */
-declare function applyChatMessage(arbi: Arbi, queryClient: QueryClient, chatExtId: string, message: ChatMessageResponse): Promise<void>;
-/** `chat.read`: a member's watermark moved (a read receipt). */
-declare function applyChatRead(arbi: Arbi, queryClient: QueryClient, chatExtId: string, userExtId: string, lastReadAt: string): void;
-/**
- * `chat.updated`: members, keys, title or a deleted message changed. Refetch the chat; when it now
- * needs a new epoch and I am still in it, seal one. A changed `message` (a deleted message's
- * tombstone) is applied in place; without one the open thread is reloaded.
- */
-declare function applyChatUpdated(arbi: Arbi, queryClient: QueryClient, chatExtId: string, message?: ChatMessageResponse | null): Promise<void>;
-/** My own agent's progress on a message I sent it (`agent_dm_status`). */
-type AgentDmStatus = WsAgentDmStatusMessage;
-/** `agent_dm_status`: remember my agent's latest progress (read by `useAgentDmStatus`). */
-declare function applyAgentDmStatus(queryClient: QueryClient, status: AgentDmStatus): void;
-/** The chat events of the server's WebSocket, as `applyChatEvent` takes them. */
-type ChatEvent = {
-    type: 'chat.message';
-    chat_ext_id: string;
-    message: ChatMessageResponse;
-} | {
-    type: 'chat.read';
-    chat_ext_id: string;
-    user_ext_id: string;
-    last_read_at: string;
-} | {
-    type: 'chat.updated';
-    chat_ext_id: string;
-    message?: ChatMessageResponse | null;
-} | AgentDmStatus;
-/** Apply one chat event of the server's WebSocket to the cache. Other messages are ignored. */
-declare function applyChatEvent(arbi: Arbi, queryClient: QueryClient, event: {
-    type: string;
-}): Promise<void>;
-
-/**
- * In-call chat (ARBI `docs/meeting-chats-plan.md` §4).
- *
- * Live: each message goes over the LiveKit data channel (reliable, topic {@link CALL_CHAT_TOPIC})
- * as `base64(nonce ‖ secretbox(json, K))` — K is the call's frame key, so the SFU, which never
- * holds K, only forwards ciphertext (media E2EE does not cover data packets).
- *
- * Persisted: a signed-in member's message is also posted to the call's meeting chat
- * ({@link ensureMeetingChat}, made lazily on the first one): an E2E chat message under the chat
- * key, or a comment in the workspace meeting thread (encrypted by the server with the workspace
- * key). A workspace guest on a thread call can read the meeting chat but not post to it: the panel
- * is read-only for them.
- */
-
-declare const CALL_CHAT_TOPIC = "arbi.chat";
-/** What a workspace guest sees instead of a composer in a thread call's meeting chat. */
-declare const READ_ONLY_MEETING_TEXT = "Read only: you can\u2019t post in this meeting chat";
-/** Longest message accepted over the data channel (well under LiveKit's reliable-packet limit). */
-declare const CALL_CHAT_MAX_CHARS = 4000;
-/** What one data packet carries, encrypted under K. */
-interface CallChatPacket {
-    v: 1;
-    /** Random id, so a sender's echo and a re-delivery deduplicate. */
-    id: string;
-    text: string;
-    /** Sender clock, ms since epoch. */
-    at: number;
-}
-/** One line of the in-call chat panel. */
-interface CallChatLine {
-    id: string;
-    senderIdentity: string;
-    senderName: string;
-    text: string;
-    at: number;
-    mine: boolean;
-    /**
-     * `live`: data channel only (received from someone else, or not kept); `saving` / `saved` /
-     * `unsaved`: my own message and its persistence; `history`: loaded from the meeting chat.
-     */
-    status: 'live' | 'saving' | 'saved' | 'unsaved' | 'history';
-}
-declare function newPacketId(): string;
-/** Encrypt a chat packet under K for `publishData`. */
-declare function encodeCallChatPacket(packet: CallChatPacket, callKey: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-/** Open a received packet; null when it is not ours, not under K, or malformed. */
-declare function decodeCallChatPacket(payload: Uint8Array, callKey: Uint8Array): Promise<CallChatPacket | null>;
-/** One of my chats: from the cache when the list has it, else fetched. */
-declare function chatByExtId(arbi: Arbi, queryClient: QueryClient, chatExtId: string): Promise<ChatResponse>;
-/**
- * Post my message to the meeting chat, making the chat first if the call has none. Throws when it
- * cannot be kept (not a host of the call, the thread's workspace not open, …).
- */
-declare function persistMeetingMessage(arbi: Arbi, queryClient: QueryClient, callExtId: string, callKey: Uint8Array, text: string): Promise<MeetingChatRef>;
-/** A persisted message, before it is matched against live lines. */
-interface HistoryMessage {
-    id: string;
-    senderExtId: string | null;
-    /** Known name, or null to resolve from the room. */
-    senderName: string | null;
-    text: string;
-    at: number;
-}
-declare const HISTORY_LIMIT = 50;
-/**
- * The meeting chat's recent messages (oldest first), decrypted, or null when the call has no
- * meeting chat yet. Never creates one.
- */
-declare function loadMeetingHistory(arbi: Arbi, queryClient: QueryClient, callExtId: string): Promise<{
-    ref: MeetingChatRef;
-    messages: HistoryMessage[];
-} | null>;
-/**
- * The panel's lines: history first, then live lines, minus the live lines that a member already
- * persisted (same sender, same text, close in time), ordered by time.
- */
-declare function mergeChatLines(history: HistoryMessage[], live: CallChatLine[], context: {
-    myIdentity: string;
-    nameOf(identity: string): string | null;
-}): CallChatLine[];
-
-/**
- * Live call transcription (ARBI `docs/meeting-chats-plan.md` §5): captions over the data channel
- * and transcript persistence into the call's meeting chat.
- *
- * Attribution is by origin: a participant's browser transcribes only its own microphone, so the
- * speaker is whoever sent the audio — there is no diarization.
- *
- * Captions: the speaker's client broadcasts `{segment_id, text, identity, name, t}` on topic
- * {@link CALL_CAPTION_TOPIC}, sealed under the call key K exactly like an in-call chat packet, so
- * the SFU only forwards ciphertext. The transcription state itself is announced by the SERVER on
- * {@link CALL_TRANSCRIPTION_TOPIC} (plaintext; it carries no content).
- *
- * Persistence: the speaker stores its own segments. A speaker who cannot post to the meeting chat (a
- * workspace guest on a thread call: read-only) marks its captions `proxy`, and every member that can
- * post stores them instead — idempotent by the segment id (`dedupe_key` in a chat, the `transcript`
- * marker in a thread), so each is stored once whichever member wins.
- */
-
-declare const CALL_CAPTION_TOPIC = "arbi.caption";
-/** Server-sent: `{on, by_identity, by_name}`. */
-declare const CALL_TRANSCRIPTION_TOPIC = "arbi.transcription";
-declare const CAPTION_MAX_CHARS = 2000;
-/**
- * Voice-activity tuning for live call speech: the shared 700 ms pause rule, but a segment needs only
- * 400 ms of voice, and a segment still too short waits 1 s more for the rest of a short phrase
- * ("Perfect." … "Thank you both.") so a closing line is not dropped as two blips.
- */
-declare const LIVE_SEGMENTER: {
-    readonly minVoiceMs: 400;
-    readonly holdShortMs: 1000;
-};
-/** One caption over the data channel, encrypted under K. */
-interface CaptionPacket {
-    v: 1;
-    segment_id: string;
-    text: string;
-    /** The speaker's LiveKit identity (checked against the packet's sender on receipt). */
-    identity: string;
-    name: string;
-    /** When the segment started, ms since epoch. */
-    t: number;
-    /** The speaker cannot post to the meeting chat: members store this segment for them. */
-    proxy?: boolean;
-}
-/** A caption on screen. */
-interface CaptionLine {
-    segmentId: string;
-    identity: string;
-    name: string;
-    text: string;
-    /** Segment start, ms since epoch. */
-    t: number;
-    mine: boolean;
-    /** Local receipt time (drives the fade). */
-    receivedAt: number;
-}
-/** A transcript segment to store. */
-interface TranscriptSegment {
-    segmentId: string;
-    text: string;
-    speakerIdentity: string;
-    speakerName: string;
-    /** ISO start of the segment. */
-    startedAt: string | null;
-}
-declare const SEGMENT_ID_PATTERN: RegExp;
-/** A fresh segment id (`^[A-Za-z0-9_-]{8,64}$`). */
-declare function newSegmentId(): string;
-declare function encodeCaptionPacket(packet: CaptionPacket, callKey: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-/** Open a received caption; null when it is not under K or malformed. */
-declare function decodeCaptionPacket(payload: Uint8Array, callKey: Uint8Array): Promise<CaptionPacket | null>;
-/**
- * Who stores a segment:
- *   - `own`: my own segment, and I can post to the meeting chat;
- *   - `proxy`: someone else's segment marked `proxy` (they cannot post: a workspace guest), and I
- *     can post — every such member stores it, the server dedupes by segment id;
- *   - null: the speaker stores it themselves, or I cannot post (read-only, or no call key to open
- *     the meeting chat with). My own segment then goes out marked `proxy` for members to store.
- */
-declare function transcriptPersistRole(params: {
-    myIdentity: string;
-    /** I can post to the meeting chat (not a workspace guest of a thread call). */
-    canPost: boolean;
-    hasCallKey: boolean;
-    speakerIdentity: string;
-    /** The caption was marked `proxy` by its speaker. */
-    speakerNeedsProxy: boolean;
-}): 'own' | 'proxy' | null;
-/** The thread comment text of a segment ("Name: text"). */
-declare function threadTranscriptText(segment: TranscriptSegment): string;
-/**
- * Store one segment in the call's meeting chat (made on first use): an E2E chat message of kind
- * `transcript` under the chat key, or a comment with a transcript marker in a workspace meeting
- * thread. Idempotent per segment id. Returns the chat it went to.
- *
- * In a thread the marker's `speaker_ext_id` is the speaker: the server accepts it from the speaker,
- * or from a member when the speaker is a guest of the workspace (422 `speaker_mismatch` otherwise).
- */
-declare function persistTranscriptSegment(arbi: Arbi, queryClient: QueryClient, callExtId: string, callKey: Uint8Array, segment: TranscriptSegment): Promise<MeetingChatRef>;
-/**
- * Store one segment in a known meeting chat (see {@link persistTranscriptSegment}); also used for
- * the lines transcribed from a recording (segment ids `rec-<track>-<seq>`).
- */
-declare function storeTranscriptSegment(arbi: Arbi, queryClient: QueryClient, ref: MeetingChatRef, segment: TranscriptSegment): Promise<void>;
-
-/**
- * Call recording in the browser (ARBI `docs/meeting-chats-plan.md` §6).
- *
- * Calls are end-to-end encrypted, so the server never records them: every participant's browser
- * records its OWN microphone (attribution by origin), and in "Audio + video" mode the host's
- * browser also records one composite of its view. The server only ever stores ciphertext.
- *
- * Keys: each track (one per speaker, plus the composite) has a random file key, wrapped under the
- * conversation key — the meeting chat's epoch key for a contacts call, the workspace key for a
- * thread call — and stored with the track (`wrapped_key`, `key_version`). Each ~30 s part is
- * SecretBox-encrypted with the file key here and uploaded like a document: presign → PUT the
- * ciphertext straight to the object store → commit (HEAD-verified server-side).
- *
- * Offsets are relative to the recording's `started_at`, so the tracks align in time.
- */
-
-/** Server-sent, plaintext: `{on, mode, recording_ext_id, by_identity, by_name}`. */
-declare const CALL_RECORDING_TOPIC = "arbi.recording";
-/** Part length: every part is a standalone file of about this long. */
-declare const RECORDING_CHUNK_MS = 30000;
-/** Speaker audio: Opus ~16–24 kbps mono (~7–11 MB per speaker-hour). */
-declare const SPEAKER_AUDIO_BITS_PER_SECOND = 24000;
-/** Composite video (≤720p): ~300–600 kbps. */
-declare const COMPOSITE_VIDEO_BITS_PER_SECOND = 500000;
-declare const COMPOSITE_AUDIO_BITS_PER_SECOND = 32000;
-/** A part's offset from the recording start, ms (never negative). */
-declare function partOffsetMs(partStartedAt: number, recordingStartedAt: string | number): number;
-/** A fresh random 32-byte file key. */
-declare function newTrackKey(): Promise<Uint8Array>;
-/** The file key under the conversation key: base64(nonce ‖ secretbox). */
-declare function wrapTrackKey(fileKey: Uint8Array, conversationKey: Uint8Array): Promise<string>;
-declare function unwrapTrackKey(wrapped: string, conversationKey: Uint8Array): Promise<Uint8Array>;
-declare function encryptPart(bytes: Uint8Array, fileKey: Uint8Array): Promise<Uint8Array>;
-declare function decryptPart(cipher: Uint8Array, fileKey: Uint8Array): Promise<Uint8Array>;
-/** The key a recording's tracks are wrapped under, and its version (null: the workspace key). */
-interface ConversationKey {
-    key: Uint8Array;
-    keyVersion: number | null;
-}
-/**
- * The conversation key of a call's recordings:
- *   - a thread call: its locked workspace's key (the key direct uploads use, unwrapped here);
- *   - a contacts call: the meeting chat's epoch key — the current one to record (`keyVersion`
- *     omitted; the chat is made on first use, which needs the call key K), or the given version
- *     to read a track.
- */
-declare function conversationKeyForCall(arbi: Arbi, queryClient: QueryClient, call: Pick<calls.CallResponse, 'external_id' | 'chat_ext_id' | 'workspace_locked' | 'locked_workspace_ext_id'>, options?: {
-    callKey?: Uint8Array | null;
-    keyVersion?: number | null;
-}): Promise<ConversationKey>;
-/** The meeting chat a call's recording transcript goes to (made on first use when K is known). */
-declare function meetingRefForCall(arbi: Arbi, queryClient: QueryClient, call: calls.CallResponse, callKey?: Uint8Array | null): Promise<MeetingChatRef>;
-/** One recorded part, as the recorder hands it over. */
-interface PendingPart {
-    blob: Blob;
-    /** Wall clock, ms since epoch. */
-    startedAt: number;
-    durationMs: number;
-}
-type RecordingApi = Arbi['calls']['recording'];
-interface UploaderDeps {
-    createTrack: RecordingApi['createTrack'];
-    presign: RecordingApi['presignPart'];
-    commit: RecordingApi['commitPart'];
-    getRecording: RecordingApi['get'];
-    put(url: string, body: Uint8Array, headers?: Record<string, string>): Promise<void>;
-    encrypt(bytes: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
-    wrap(fileKey: Uint8Array, conversationKey: Uint8Array): Promise<string>;
-    unwrap(wrapped: string, conversationKey: Uint8Array): Promise<Uint8Array>;
-    newKey(): Promise<Uint8Array>;
-    sleep(ms: number): Promise<void>;
-}
-/** Attempts per part (and for the track) before a transient failure is given up. */
-declare const UPLOAD_ATTEMPTS = 5;
-declare const UPLOAD_BACKOFF_MS = 1000;
-/**
- * Network errors, 408/429, 5xx (but 507, the quota) and a commit that found no object yet
- * (409 `part_not_uploaded`: presign and PUT again — re-presigning is allowed until committed).
- */
-declare function isRetryable(err: unknown): boolean;
-/** The recording takes no more parts: over (past its grace), gone, or not ours to add to. */
-declare function isRecordingOver(err: unknown): boolean;
-interface TrackUploaderOptions {
-    /** Who uploads: the parts go through `arbi.calls.recording`. */
-    arbi: Arbi;
-    callExtId: string;
-    recordingExtId: string;
-    kind: calls.RecordingTrackKind;
-    mimeType: string;
-    /** The conversation key to wrap the file key under (resolved once, lazily). */
-    conversationKey(): Promise<ConversationKey>;
-    /** The recording's start (`CallRecordingState.started_at`; otherwise read from the recording). */
-    recordingStartedAt?: string | null;
-    /** The call link version I joined with (admission, as for transcription). */
-    linkVersion?: number | null;
-    /** The recording can take no more parts (quota): the server stopped it. */
-    onStopped?(err: CallApiError): void;
-    /** A part could not be kept. */
-    onPartLost?(err: unknown): void;
-    deps?: Partial<UploaderDeps>;
-}
-/**
- * Uploads one track's parts in order: encrypt → presign → PUT → commit, retried with backoff.
- *
- * The track is created on the first part. Creation is idempotent per speaker (and for the
- * composite), so after a reconnect — or a reload — the server hands back the SAME track: its
- * existing wrapped key is unwrapped and used, and numbering resumes after its last part.
- */
-declare class TrackUploader {
-    private readonly options;
-    private readonly deps;
-    private track;
-    private trackPromise;
-    private nextSeq;
-    private queue;
-    private running;
-    /** No more parts are accepted (quota, or the recording is gone). */
-    stopped: boolean;
-    /** Parts committed (for tests and the UI). */
-    committed: number;
-    constructor(options: TrackUploaderOptions);
-    /** Queue a part; parts upload one at a time, in order. */
-    enqueue(part: PendingPart): void;
-    /** Resolves once every queued part was uploaded (or given up). */
-    flush(): Promise<void>;
-    private drain;
-    private withRetry;
-    private ensureTrack;
-    private createTrack;
-    private uploadPart;
-}
-/** The seq after a track's last part (0 for a new track). */
-declare function nextSeqAfter(parts: {
-    seq: number;
-}[]): number;
-declare function trackUploaderFor(options: TrackUploaderOptions): TrackUploader;
-/** Forget the uploaders (tests; sign-out). */
-declare function clearTrackUploaders(): void;
-
-/**
- * audio-segmenter — the voice-activity state machine behind `useAudioRecorder`'s
- * segmenting mode. Pure: fed one (level, time) sample per meter tick, it says
- * when a speech segment starts and when it ends, and whether the segment held
- * enough voice to be worth keeping. The hook owns the MediaRecorders; this
- * owns only the decisions, so it is unit-testable with synthetic levels.
- *
- * A segment starts on the first sample at or above `voiceThreshold`, ends after
- * `silenceMs` without voice or at `maxMs` (a cut while still speaking starts the
- * next segment on the same sample), and is dropped when it held less than
- * `minVoiceMs` of voice — a cough, a click, a door.
- */
-interface SegmenterConfig {
-    /** Meter level (0-1, as `useAudioRecorder` reports it) that counts as voice. */
-    voiceThreshold: number;
-    /** Silence that ends a segment. */
-    silenceMs: number;
-    /** Longest segment; a longer utterance is cut into several. */
-    maxMs: number;
-    /** Segments with less voice than this are dropped. */
-    minVoiceMs: number;
-    /**
-     * Extra silence a segment that is still too short waits for more voice before it ends (0 = none).
-     * A short word and a short phrase a pause apart — "Perfect." … "Thank you both." — then make one
-     * segment instead of two dropped ones.
-     */
-    holdShortMs?: number;
-}
-declare const DEFAULT_SEGMENTER_CONFIG: SegmenterConfig;
-type SegmenterState = {
-    phase: 'idle';
-} | {
-    phase: 'voice';
-    /** When the segment started (the clock of the samples). */
-    startedAt: number;
-    /** The last sample that carried voice. */
-    lastVoiceAt: number;
-    /** The previous sample, to integrate voice time between samples. */
-    lastSampleAt: number;
-    /** Voice accumulated so far. */
-    voiceMs: number;
-};
-type SegmenterEvent = {
-    type: 'start';
-    at: number;
-} | {
-    type: 'end';
-    at: number;
-    startedAt: number;
-    voiceMs: number;
-    /** False when the segment held too little voice: discard it. */
-    keep: boolean;
-    reason: 'silence' | 'max' | 'flush';
-};
-declare const INITIAL_SEGMENTER_STATE: SegmenterState;
-/**
- * The meter level (0-1) of an RMS amplitude, as the segmenter's thresholds expect it. Normal
- * speech RMS is tiny (a laptop mic at conversational distance rarely exceeds ~0.1), so it is
- * boosted, then a sqrt (perceptual) curve makes quiet-to-moderate speech clearly visible.
- */
-declare function levelFromRms(rms: number): number;
-/** Feed one meter sample. Returns the next state and what happened (0-2 events). */
-declare function stepSegmenter(state: SegmenterState, level: number, t: number, config?: SegmenterConfig): {
-    state: SegmenterState;
-    events: SegmenterEvent[];
-};
-/** Close the open segment, if any (recording stopped). */
-declare function flushSegmenter(state: SegmenterState, t: number, config?: SegmenterConfig): {
-    state: SegmenterState;
-    events: SegmenterEvent[];
-};
-
-/**
- * The webinar's wire formats on the client: the server's LiveKit data messages (topic
- * `arbi.webinar`, trusted only when server-sent) and the Q&A text, end-to-end under the call key K
- * in the same secretbox format as the call title (`encryptCallTitle` / `decryptCallTitle`), and
- * joining a webinar again without leaving it.
- */
-
-declare const CALL_WEBINAR_TOPIC = "arbi.webinar";
-/** The audience cannot publish: no microphone, no camera, no device check. */
-declare const AUDIENCE_CHOICES: JoinChoices;
-type Hand = NonNullable<calls.WebinarState['hands']>[number];
-type WebinarPacket = {
-    type: 'state';
-    live: boolean;
-    live_at: string | null;
-    chat: calls.WebinarChat;
-} | {
-    type: 'hands';
-    hands: Hand[];
-} | {
-    type: 'questions';
-} | {
-    type: 'promoted';
-} | {
-    type: 'demoted';
-};
-/**
- * A data packet on {@link CALL_WEBINAR_TOPIC}, or null. `fromParticipant` is whether a participant
- * sent it: only the server speaks on this topic, so anything from a participant is dropped.
- */
-declare function parseWebinarPacket(payload: Uint8Array, fromParticipant: boolean): WebinarPacket | null;
-/** A question with its text opened under K (`null` when it does not open: shown as such). */
-interface OpenQuestion extends calls.CallQuestion {
-    text: string;
-    answerText: string | null;
-}
-declare function sealQuestionText(text: string, key: Uint8Array): Promise<string>;
-declare function openQuestion(q: calls.CallQuestion, key: Uint8Array): Promise<OpenQuestion>;
-/** The room I am in is about to drop me for a rejoin: its disconnect is not a leave. */
-declare function markRejoining(callExtId: string, on?: boolean): void;
-/** Join again as the audience (the room that dropped me has already gone). */
-declare function rejoinAsAudience(arbi: Arbi, callExtId: string): Promise<void>;
-
-/**
- * useAudioRecorder
- *
- * Shared recording engine — getUserMedia capture, MediaRecorder lifecycle,
- * and an AnalyserNode-driven live level meter. Host apps layer their own
- * interaction model on top of the primitives here: a press-and-hold mic
- * calls start()/stop() on press/release and never pauses; a toggle-style
- * recorder exposes all of start/pause/resume/stop/reset as buttons.
- *
- * Two optional modes extend it (both used by live call transcription):
- *   - `track`: record from a MediaStreamTrack the host already has (a call's
- *     microphone track) instead of opening the microphone; the track stays the
- *     host's and is never stopped here.
- *   - `onSegment`: segmenting mode. Instead of one recording, the level meter
- *     drives a voice-activity state machine (`audio-segmenter.ts`) and each
- *     speech segment is recorded by its own MediaRecorder, so every emitted
- *     blob is a standalone file. Too-short segments are dropped. `blob` stays
- *     null and pause/resume do nothing in this mode. Stopping, unmounting or
- *     hiding the page emits the open segment (if it held enough voice).
- *   - `chunkMs` (with `onSegment`): chunk mode, used by call recording. No
- *     voice detection: the recorder is restarted every `chunkMs`
- *     (`chunked-recorder.ts`), so every part — silence included — is a
- *     standalone file, emitted in order through `onSegment`. Stopping (or
- *     unmounting) flushes the tail part: a recording never drops audio.
- *
- * REUSE-FIRST: no app coupling. Failures surface via the returned `error`
- * string rather than an app-specific toast/notification call — the host
- * decides how (or whether) to display it.
- */
-
-type AudioRecorderState = 'idle' | 'recording' | 'paused' | 'stopped';
-/** One speech segment emitted in segmenting mode. */
-interface AudioSegment {
-    /** A standalone recording (its own container header), ready to upload. */
-    blob: Blob;
-    mimeType: string;
-    /** Wall-clock start of the segment, ms since epoch. */
-    startedAt: number;
-    durationMs: number;
-    /** How much of it carried voice (chunk mode: the whole part). */
-    voiceMs: number;
-    /** Chunk mode: the part's index in this recording run (0, 1, 2…). */
-    index?: number;
-}
-interface UseAudioRecorderOptions {
-    /** Record from this track instead of opening the microphone (it is never stopped here). */
-    track?: MediaStreamTrack | null;
-    /** Segmenting mode: called with each kept speech segment. */
-    onSegment?: (segment: AudioSegment) => void;
-    /** Voice-activity tuning for segmenting mode. */
-    segmenter?: Partial<SegmenterConfig>;
-    /** Chunk mode (with `onSegment`): a standalone part every `chunkMs`, no voice detection. */
-    chunkMs?: number;
-    /** Chunk mode: the MediaRecorder MIME type (default: Opus/WebM, else AAC/MP4). */
-    mimeType?: string;
-    /** Chunk mode: the encoder bitrate. */
-    audioBitsPerSecond?: number;
-}
-interface UseAudioRecorderResult {
-    state: AudioRecorderState;
-    /** Live input level, 0-1. 0 while idle/paused/stopped. */
-    level: number;
-    /** Total recorded duration so far (excludes time spent paused). Frozen at
-     *  its final value once stopped, until reset() clears it. */
-    elapsedMs: number;
-    /** The finished recording. Only set once state === 'stopped'. */
-    blob: Blob | null;
-    /** The MediaRecorder MIME type used (e.g. 'audio/webm'). Only set once
-     *  recording has started at least once. */
-    mimeType: string | null;
-    /** A human-readable message from the last failed start() attempt. Cleared
-     *  at the start of every new attempt, so it always transitions through
-     *  `null` even if the next failure has the same message. */
-    error: string | null;
-    start: () => Promise<void>;
-    pause: () => void;
-    resume: () => void;
-    stop: () => void;
-    /** Back to idle: clears blob/elapsedMs/mimeType, ready to record again. */
-    reset: () => void;
-}
-declare function useAudioRecorder(options?: UseAudioRecorderOptions): UseAudioRecorderResult;
-
-export { type TranscriptSegment as $, AUDIENCE_CHOICES as A, type DecryptedChatMessage as B, CALL_CAPTION_TOPIC as C, DEFAULT_JOIN_CHOICES as D, EMPTY_CALL_SESSION as E, type HistoryMessage as F, type IncomingCall as G, HISTORY_LIMIT as H, INITIAL_SEGMENTER_STATE as I, type JoinChoices as J, type LiveCall as K, LIVE_SEGMENTER as L, type MeetingChatRef as M, type MeetingChatTarget as N, type NewActiveCall as O, type OpenQuestion as P, type PendingKnock as Q, type PendingPart as R, READ_ONLY_MEETING_TEXT as S, RECORDING_CHUNK_MS as T, SEGMENT_ID_PATTERN as U, SPEAKER_AUDIO_BITS_PER_SECOND as V, type SegmenterConfig as W, type SegmenterEvent as X, type SegmenterState as Y, TrackUploader as Z, type TrackUploaderOptions as _, type ActiveCall as a, transcriptPersistRole as a$, UPLOAD_ATTEMPTS as a0, UPLOAD_BACKOFF_MS as a1, type UploaderDeps as a2, type UseAudioRecorderOptions as a3, type UseAudioRecorderResult as a4, type WebinarPacket as a5, appendToThread as a6, applyAgentDmStatus as a7, applyChatEvent as a8, applyChatMessage as a9, loadMeetingHistory as aA, markRejoining as aB, meetingChatRefFrom as aC, meetingRefForCall as aD, mergeChatLines as aE, myChatId as aF, newPacketId as aG, newSegmentId as aH, newTrackKey as aI, nextSeqAfter as aJ, openQuestion as aK, parseWebinarPacket as aL, partOffsetMs as aM, persistMeetingMessage as aN, persistTranscriptSegment as aO, rejoinAsAudience as aP, removeChat as aQ, resetCallSession as aR, resolveMeetingChat as aS, sealQuestionText as aT, setOpenChat as aU, stepSegmenter as aV, storeTranscriptSegment as aW, threadHasLiveCall as aX, threadLiveCallId as aY, threadTranscriptText as aZ, trackUploaderFor as a_, applyChatRead as aa, applyChatUpdated as ab, buildMeetingChatBody as ac, cachedChat as ad, cachedChats as ae, callMemberKeys as af, callSession as ag, chatByExtId as ah, chatHasLiveCall as ai, chatLiveCallId as aj, clearMeetingChatCache as ak, clearTrackUploaders as al, conversationKeyForCall as am, decodeCallChatPacket as an, decodeCaptionPacket as ao, decryptPart as ap, encodeCallChatPacket as aq, encodeCaptionPacket as ar, encryptPart as as, ensureMeetingChat as at, flushSegmenter as au, getOpenChat as av, isRecordingOver as aw, isRetryable as ax, knownMeetingChat as ay, levelFromRms as az, type AgentDmStatus as b, unwrapTrackKey as b0, upsertChat as b1, useAudioRecorder as b2, useCallSession as b3, wrapTrackKey as b4, type AudioRecorderState as c, type AudioSegment as d, CALL_CHAT_MAX_CHARS as e, CALL_CHAT_TOPIC as f, CALL_RECORDING_TOPIC as g, CALL_TRANSCRIPTION_TOPIC as h, CALL_WEBINAR_TOPIC as i, CAPTION_MAX_CHARS as j, COMPOSITE_AUDIO_BITS_PER_SECOND as k, COMPOSITE_VIDEO_BITS_PER_SECOND as l, type CallChatLine as m, type CallChatPacket as n, type CallSessionState as o, type CaptionLine as p, type CaptionPacket as q, type ChatAttachmentFile as r, type ChatEvent as s, type ChatMemberKey as t, type ChatMessageResponse as u, type ChatResponse as v, type ChatThreadData as w, type ChatThreadMessage as x, type ConversationKey as y, DEFAULT_SEGMENTER_CONFIG as z };