@arbidocs/blocks 0.4.159 → 0.4.161

package/dist/connection/files/page/DocumentsFilterBarActions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * DocumentsFilterBarActions
+ *
+ * Right-hand action cluster rendered inside DocumentsFilterBar. Content
+ * depends on the active Documents view:
+ * - grid / navigator: saved-views selector, row density control, viewer toggle
+ * - explorer: new-folder button, sort controls, tile-size zoom
+ *
+ * Kept out of Documents.tsx purely to shrink that file — this component
+ * owns no state of its own, it's a pass-through view for page-level state.
+ */
+import type { GridApi } from 'ag-grid-community';
+import type { ExplorerSort } from '../../../files/folders';
+import type { GridDocument as Doc } from '../grid/documentColumns';
+import { type LoadableTableView } from '../views/ViewSelector';
+type DocumentsViewMode = 'grid' | 'explorer' | 'navigator';
+export interface DocumentsFilterBarActionsProps {
+    isModal: boolean;
+    documentsViewMode: DocumentsViewMode;
+    getGridApi: () => GridApi<Doc> | null;
+    defaultVisibleColumns: string[];
+    onApplyView: (columns: string[], gridApi?: GridApi<Doc>) => void;
+    onLoadView: (view: LoadableTableView, gridApi: GridApi<Doc>) => void;
+    explorerTileSize: number;
+    onExplorerTileSizeChange: (size: number) => void;
+    documentsRowHeight: number;
+    onDocumentsRowHeightChange: (height: number) => void;
+    currentDocument: Doc | null;
+    isDocumentViewerEnabled: boolean;
+    onToggleDocumentViewer: (docId: string) => void;
+    explorerSort: ExplorerSort;
+    onExplorerSortChange: (sort: ExplorerSort) => void;
+    explorerSortReversed: boolean;
+    onExplorerSortReversedChange: (reversed: boolean) => void;
+    /** Changes whenever the grid's saved state does (the saved-views menu recomputes). */
+    gridStateVersion: unknown;
+}
+export declare function DocumentsFilterBarActions({ isModal, documentsViewMode, getGridApi, defaultVisibleColumns, onApplyView, onLoadView, explorerTileSize, onExplorerTileSizeChange, documentsRowHeight, onDocumentsRowHeightChange, currentDocument, isDocumentViewerEnabled, onToggleDocumentViewer, explorerSort, onExplorerSortChange, explorerSortReversed, onExplorerSortReversedChange, gridStateVersion, }: DocumentsFilterBarActionsProps): import("react").JSX.Element | null;
+export {};

package/dist/connection/files/page/DocumentsUploadButton.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DocumentsUploadButton
+ *
+ * Binding for the page's primary "Add" action: maps upload sources + permissions to the blocks
+ * `FilesAddMenu`. Disabled with an explanatory tooltip for guests / non-members.
+ */
+import type { UploadSource } from '../upload/ConnectedUploadDropzone';
+export interface DocumentsUploadButtonProps {
+    isCompact: boolean;
+    canUpload: boolean;
+    isGuest: boolean;
+    /** Called with the chosen source when a dropdown item is selected. */
+    onSelectSource: (source: UploadSource) => void;
+    /** Opens the "Email this workspace" modal (mail it in later, vs adding now). Absent: not offered. */
+    onEmailWorkspace?: () => void;
+    /** Starts a blank, frontend-only draft in the Document Viewer. Absent: not offered. */
+    onCreateNew?: () => void;
+    /** Takes a photo into a new document. Absent: not offered. */
+    onTakePhoto?: () => void;
+    /** Trigger height. `sm` is a thinner button; defaults to the standard size. */
+    size?: 'default' | 'sm';
+    /** Extra classes on the trigger button, e.g. to shrink it in a card header. */
+    className?: string;
+}
+export declare function DocumentsUploadButton({ isCompact, canUpload, isGuest, onSelectSource, onEmailWorkspace, onCreateNew, onTakePhoto, size, className, }: DocumentsUploadButtonProps): import("react").JSX.Element;

package/dist/connection/files/page/PersistedGridView.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The core `GridView` with its column state (order, widths, sort) kept on this device, per grid
+ * id: the files page's default grid for a host that keeps no grid state of its own.
+ */
+import { type GridViewProps } from '../../../files/GridView';
+export declare function PersistedGridView<T>(props: GridViewProps<T>): import("react").JSX.Element;

package/dist/connection/files/page/ProgressiveLoadingChip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Subtle "Loading documents list..." indicator shown while the progressive
+ * document loader is appending pages. Rendered centered in the TabHeader.
+ *
+ * Hidden once the loader has finished (all pages done).
+ *
+ * The user can still interact with the table while loading continues; the
+ * indicator just surfaces that a background fetch is extending the list.
+ * Document count itself is shown elsewhere (TabHeader badge), so this
+ * component deliberately doesn't repeat it.
+ */
+export declare function ProgressiveLoadingChip(): import("react").JSX.Element | null;

package/dist/connection/files/page/useDocumentNavigation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * useDocumentNavigation Hook
+ *
+ * Provides navigation controls and download functionality for document navigation.
+ */
+type Doc = {
+    external_id: string;
+};
+interface UseDocumentNavigationProps<D extends Doc> {
+    currentDoc: D | null;
+    documents: D[];
+    onNavigate: (docId: string) => void;
+}
+interface UseDocumentNavigationResult {
+    currentIndex: number;
+    handlePrevious: () => void;
+    handleNext: () => void;
+}
+export declare function useDocumentNavigation<D extends Doc>({ currentDoc, documents, onNavigate, }: UseDocumentNavigationProps<D>): UseDocumentNavigationResult;
+export {};

package/dist/connection/files/review/ConnectedAiReview.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AiReviewModal — the "AI Review" flow.
+ *
+ * You write what you want to know in one prompt; the modal creates an
+ * Annotation field (named after the question), runs the AI across the selected
+ * documents, shows each answer as it lands, and surfaces the new column in the
+ * grid. No tag editor, no separate field-name step.
+ *
+ * The active run (field + the docs it ran over) is held in the store, so the
+ * "annotation run finished" toast can re-open this modal on its results even after
+ * you've closed it. (Applying existing tags lives in the Tags sidebar.)
+ *
+ * The Tags page opens the same flow for one kind (`kind`): a new tag is created as that kind,
+ * and the picker offers only tags of it. With a tag open there (`tag`), the modal starts on that
+ * tag with its saved instruction, and running it saves the edited question back to the tag.
+ */
+import { type TagKind } from '@arbidocs/sdk/browser';
+import { type WorkspaceDocument } from '@arbidocs/react';
+import type { GridApi } from 'ag-grid-community';
+type Doc = WorkspaceDocument;
+export interface ConnectedAiReviewProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The documents to review (the current bulk selection). */
+    documents: Doc[];
+    getGridApi: () => GridApi | null;
+    /** Make the new field visible in the grid (same handler the panel uses). */
+    onReorderColumns: (visibleIds: string[], gridApi?: GridApi) => void;
+    /** Review tags of this kind only: the picker offers them, and a new one is created as it. */
+    kind?: Extract<TagKind, 'label' | 'annotation' | 'issue'>;
+    /** Start on this tag, its saved instruction in the prompt. */
+    tag?: {
+        id: string;
+        name: string;
+    };
+    /** `documents` is the whole workspace, not a selection (shapes the subtitle). */
+    allDocuments?: boolean;
+}
+export declare function ConnectedAiReview({ open, onOpenChange, documents, getGridApi, onReorderColumns, kind, tag: startTag, allDocuments, }: ConnectedAiReviewProps): import("react").JSX.Element;
+export {};

package/dist/connection/files/review/reviewProgress.d.ts

@@ -0,0 +1,2 @@
+/** "10/16 reviewed", then "Done: 13 of 16 answered, 3 with no value" once nothing is pending. */
+export declare function reviewProgress(answered: number, empty: number, total: number): string;

package/dist/connection/files/store.d.ts

@@ -3,6 +3,8 @@
  * documents, so a new one is a placeholder until something is moved into it), per workspace, for
  * the session (kept in `sessionStorage`, so a reload keeps them).
  */
+import type { GridState } from 'ag-grid-community';
+import type { ExplorerFolder } from '../../files/folders/folderPaths';
 interface FilesState {
     /** Placeholder folder paths per workspace. */
     pendingFolders: Readonly<Record<string, readonly string[]>>;
@@ -24,4 +26,98 @@ export declare const useFilesStore: import("zustand").UseBoundStore<Omit<import(
 }>;
 /** A workspace's placeholder folders. */
 export declare function usePendingFolders(workspaceId: string | null | undefined): readonly string[];
+/** How the files page shows the documents: a table, the explorer, review one by one, or search. */
+export type FilesViewMode = 'grid' | 'explorer' | 'navigator' | 'search';
+interface FilesPrefsState {
+    /** The documents list's tri-state filters (filter id → include / exclude / off). */
+    documentFilters: Readonly<Record<string, 'include' | 'exclude' | null>>;
+    setDocumentFilters: (filters: Record<string, 'include' | 'exclude' | null>) => void;
+    /** The files page's view. */
+    viewMode: FilesViewMode;
+    setViewMode: (mode: FilesViewMode) => void;
+    /** The table's row height (density). */
+    rowHeight: number;
+    setRowHeight: (height: number) => void;
+}
+/** The Files kits' preferences, kept on this device (`localStorage`) across sessions. */
+export declare const useFilesPrefs: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<FilesPrefsState>, "setState" | "persist"> & {
+    setState(partial: FilesPrefsState | Partial<FilesPrefsState> | ((state: FilesPrefsState) => FilesPrefsState | Partial<FilesPrefsState>), replace?: false | undefined): unknown;
+    setState(state: FilesPrefsState | ((state: FilesPrefsState) => FilesPrefsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<FilesPrefsState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: FilesPrefsState) => void) => () => void;
+        onFinishHydration: (fn: (state: FilesPrefsState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<FilesPrefsState, unknown, unknown>>;
+    };
+}>;
+/** An AI review run: the fields, the documents, and which of them the server finished. */
+export interface AiReviewRun {
+    tags: {
+        id: string;
+        name: string;
+    }[];
+    docIds: string[];
+    /** The documents the server finished (a finished cell with no value will not fill). */
+    finishedDocIds?: string[];
+    /** It replaces values already there: a cell shows its new value only once finished. */
+    replacing?: boolean;
+}
+interface AiReviewState {
+    /** The AI review dialog is open. */
+    open: boolean;
+    /** The run on screen, kept after closing so "View results" can bring the answers back. */
+    run: AiReviewRun | null;
+    setOpen: (open: boolean) => void;
+    setRun: (run: AiReviewRun | null) => void;
+    /** The server finished these documents of the run (with or without a value). */
+    markFinished: (docIds: string[]) => void;
+}
+/** The AI review dialog and its run, reachable from outside React (a finished-run notice). */
+export declare const useAiReviewStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AiReviewState>>;
+interface GridStatesState {
+    /** AG Grid's saved state (columns, widths, sort) per grid id. */
+    gridStates: Readonly<Record<string, GridState>>;
+    setGridState: (gridId: string, state: GridState) => void;
+}
+/** The Files grids' saved state, kept on this device, for hosts that keep none of their own. */
+export declare const useFilesGridStates: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<GridStatesState>, "setState" | "persist"> & {
+    setState(partial: GridStatesState | Partial<GridStatesState> | ((state: GridStatesState) => GridStatesState | Partial<GridStatesState>), replace?: false | undefined): unknown;
+    setState(state: GridStatesState | ((state: GridStatesState) => GridStatesState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<GridStatesState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: GridStatesState) => void) => () => void;
+        onFinishHydration: (fn: (state: GridStatesState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<GridStatesState, unknown, unknown>>;
+    };
+}>;
+/** A document the Delete confirmation asks about. */
+export interface DeleteRequestDocument {
+    external_id: string;
+    file_name?: string | null;
+    doc_metadata?: {
+        title?: string | null;
+    } | null;
+}
+interface FilesDialogsState {
+    /** Move the selection (or `folder`) to a folder. */
+    move: {
+        folder: ExplorerFolder | null;
+    } | null;
+    openMove: (folder?: ExplorerFolder | null) => void;
+    closeMove: () => void;
+    /** Edit the selection's labels and fields. */
+    bulkTagsOpen: boolean;
+    setBulkTagsOpen: (open: boolean) => void;
+    /** Confirm deleting one document. */
+    deleteRequest: DeleteRequestDocument | null;
+    requestDelete: (doc: DeleteRequestDocument | null) => void;
+}
+/** The files page's dialogs, also opened from outside it (commands, the viewer's related files). */
+export declare const useFilesDialogs: import("zustand").UseBoundStore<import("zustand").StoreApi<FilesDialogsState>>;
 export {};

package/dist/connection/files/useDocumentFilters.d.ts

@@ -0,0 +1,54 @@
+/**
+ * useDocumentsFilters Hook
+ *
+ * Manages document filter state, options, and groups for the Documents page.
+ * Uses the shared useFilters hook for core filtering logic.
+ *
+ * Includes a binary "source filter" toggle (Uploaded vs Generated) that
+ * pre-filters documents before tri-state filters are applied, and a
+ * hierarchical folder tree with prefix matching.
+ */
+import { type WorkspaceDocument } from '@arbidocs/react';
+import type { TagResponse } from '@arbidocs/sdk/browser';
+import type { TriState, TriStateGroup, TriStateOption } from '../../settings/TriStateFilterMenu';
+type Doc = WorkspaceDocument;
+type Tag = TagResponse;
+/** A filter of the documents list, with what it matches. */
+export type DocumentFilterOption<T extends string = string> = TriStateOption<T> & {
+    /** A label's colour (chips). */
+    color?: string;
+};
+/** Keep the oldest of each set of documents with the same content (exact duplicates). */
+export declare function deduplicateByContentHash<T extends {
+    content_hash?: string | null;
+    created_at: string;
+}>(items: T[]): T[];
+export type DocumentFilterId = 'source_uploaded' | 'source_generated' | 'shared' | 'in_chat' | 'available_offline' | 'uploaded_by_me' | 'updated_last_week' | 'duplicates' | 'parent_child' | 'indexing_complete' | 'indexing_failed' | 'indexing_in_progress' | `folder:${string}` | string;
+export type SearchFieldId = 'title' | 'file_name' | 'folder' | 'doc_author' | 'doc_subject' | 'doc_nature' | 'doc_date' | 'status' | 'file_type' | 'content_hash' | 'custom_fields' | 'external_id';
+export declare const SEARCH_FIELD_OPTIONS: {
+    value: SearchFieldId;
+    label: string;
+}[];
+export declare const DEFAULT_SEARCH_FIELDS: SearchFieldId[];
+interface UseDocumentFiltersParams<D extends Doc> {
+    documents: D[];
+    allTags: Tag[];
+    /** The documents in the open conversation (the "In Chat" filter). */
+    inConversationDocuments: ReadonlyArray<{
+        docId: string;
+    } | undefined>;
+    searchQuery?: string;
+    searchFields?: SearchFieldId[];
+}
+export declare function useDocumentFilters<D extends Doc>({ documents, allTags, inConversationDocuments, searchQuery, searchFields, }: UseDocumentFiltersParams<D>): {
+    documentFilters: Map<string, TriState>;
+    setDocumentFilters: (next: Map<DocumentFilterId, TriState>) => void;
+    folderPath: string[];
+    setFolderPath: (path: string[]) => void;
+    filteredDocuments: D[];
+    documentFilterOptions: DocumentFilterOption<string>[];
+    documentFilterGroups: TriStateGroup<string>[];
+    hasActiveFilters: boolean;
+    clearFilters: () => void;
+};
+export {};

package/dist/connection/files/views/ViewSelector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ViewSelector: data binding for the saved-views popover (UI lives in
+ * `@arbidocs/blocks` `ViewSelectorMenu`).
+ *
+ * Lives in the Documents page TabHeader. Derives the active view from the actual grid column
+ * state.
+ */
+import type { GridApi } from 'ag-grid-community';
+import type { SavedGridView } from '../../../files/views/gridViews';
+import type { GridDocument as Doc } from '../grid/documentColumns';
+/** A view as loaded: a saved TableView, or a built-in carrying its pin instruction
+ *  (`pinned_left`: which columns to pin left; [] = unpin everything). Saved views never
+ *  carry it (the schema doesn't store pinning), so loading them leaves pins alone. */
+export type LoadableTableView = SavedGridView;
+interface ViewSelectorProps {
+    getGridApi: () => GridApi<Doc> | null;
+    defaultColumns: string[];
+    /** Live column toggle (visibility/order only) — does not touch zoom/row height. */
+    onApplyView: (columns: string[], gridApi: GridApi<Doc>) => void;
+    /** Restore a full saved view: columns + widths + Gallery zoom + row height
+     *  (+ pinning, for built-ins that specify it). */
+    onLoadView: (view: LoadableTableView, gridApi: GridApi<Doc>) => void;
+    /** Current Gallery tile size + table row height, captured when saving a view. */
+    currentTileSize: number;
+    currentRowHeight: number;
+    /** Baseline for the built-in Default view, so deviations flip to "Unsaved".
+     *  (Row-height baselines live on the built-in views themselves.) */
+    defaultTileSize: number;
+    /** Changes whenever the grid's saved state does: the current view is recomputed. */
+    stateVersion: unknown;
+}
+export declare function ViewSelector({ getGridApi, defaultColumns, onApplyView, onLoadView, currentTileSize, currentRowHeight, defaultTileSize, stateVersion, }: ViewSelectorProps): import("react").JSX.Element;
+export {};

package/dist/connection/files/views/tableViews.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Saved table views in user settings (`tableviews`): one array holding the views of every table
+ * the user has saved one for, keyed by workspace and table. A view without `table` belongs to the
+ * workspace's documents (Files) table; one with `table` belongs to that database's grid
+ * (`dbs-…`). Settings are written whole, so every change keeps the other tables' views.
+ */
+import type { components } from '@arbidocs/client';
+import type { SavedGridView } from '../../../files/views/gridViews';
+export type TableView = components['schemas']['TableView'];
+/** The table a view belongs to: a database id, or `null` for the documents table. */
+export type TableViewTable = string | null;
+/** The views of one table, one per name (the last one stored wins). */
+export declare function viewsOfTable(all: TableView[] | null | undefined, workspaceId: string | null | undefined, table: TableViewTable): TableView[];
+/** All views with `view` stored for this table (replacing one of the same name). */
+export declare function withTableView(all: TableView[] | null | undefined, view: SavedGridView, workspaceId: string, table: TableViewTable): TableView[];
+/** All views without this table's view named `name`. */
+export declare function withoutTableView(all: TableView[] | null | undefined, name: string, workspaceId: string, table: TableViewTable): TableView[];
+/**
+ * All views with `views` added to this table, skipping names it already has (a view already on
+ * the server wins). Used to move views kept in this browser into settings.
+ */
+export declare function withMissingTableViews(all: TableView[] | null | undefined, views: SavedGridView[], workspaceId: string, table: TableViewTable): TableView[];

package/dist/connection/files/views/useTableViews.d.ts

@@ -0,0 +1,22 @@
+import type { SavedGridView } from '../../../files/views/gridViews';
+import { type TableViewTable } from './tableViews';
+export declare function useTableViews(table: TableViewTable): {
+    savedViews: {
+        workspace: string;
+        table?: string | null;
+        name: string;
+        columns: string[];
+        column_widths?: {
+            [key: string]: number;
+        } | null;
+        tile_size?: number | null;
+        row_height?: number | null;
+    }[];
+    /** Settings and workspace are known: views can be written without losing any. */
+    ready: boolean;
+    workspaceId: string | null;
+    saveView: (view: SavedGridView) => Promise<void>;
+    deleteView: (name: string) => Promise<void>;
+    importViews: (views: SavedGridView[]) => Promise<void>;
+    isSaving: boolean;
+};

package/dist/connection/mail/ConnectedMailbox.d.ts

@@ -1,6 +1,6 @@
 /**
- * The whole mail screen bound to the mail client in scope (`MailClientProvider`, else the
- * `ArbiProvider` session): first-run setup or the accounts, the folder picker and filter, the message
+ * The whole mail screen bound to the mail client in scope (the host config's `mail`, else the
+ * host `arbi`'s session): first-run setup or the accounts, the folder picker and filter, the message
  * list, the reader and the composer.
  *
  * The host owns navigation: it can ask for a draft (`draftId`), a folder (`folder`) or a new message

package/dist/connection/messenger/ChatAttachments.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A chat message's attached files, rendered inside its bubble.
+ *
+ * Images are fetched, decrypted and previewed inline from a blob URL that is revoked when the
+ * preview unmounts. Other files are a chip (name + size) that fetches and decrypts on click and
+ * saves the result. Decryption happens in the browser with the key from the message's manifest;
+ * the server only ever hands over ciphertext.
+ */
+import { type ChatAttachmentFile } from '@arbidocs/react';
+export interface ChatAttachmentListProps {
+    files: ChatAttachmentFile[];
+    /** Set when the message has attachments whose manifest could not be decrypted. */
+    error?: string;
+}
+export declare function ChatAttachmentList({ files, error }: ChatAttachmentListProps): import("react").JSX.Element | null;

package/dist/connection/messenger/ConnectedChatThread.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One open chat thread — direct (a person, a self-chat, or my personal agent), group or meeting.
+ *
+ * Container-agnostic: a messenger frames it. Every message is end-to-end encrypted under the chat
+ * key (`arbi.chats`); files are encrypted with their own keys and travel in a manifest under the
+ * same chat key. A chat has no assistant — the one exception is the direct chat with my own agent
+ * (the PA chat), which carries the selected workspace and records workspace switches as
+ * context-only notes. A host draws more kinds of message (a call's) with `host.ThreadHistory`.
+ */
+import { type ChatResponse, type DmUser } from '@arbidocs/react';
+import type { MessengerHost } from './types';
+export interface ConnectedChatThreadProps {
+    /** The chat to show; null for a peer never messaged (the direct chat is created on send). */
+    chat: ChatResponse | null;
+    /** The other party of a direct chat (myself for a self-chat); unset for a group. */
+    peer?: DmUser | null;
+    host?: MessengerHost;
+    /** Called after a message is sent. */
+    onMessageSent?: () => void;
+}
+export declare function ConnectedChatThread({ chat, peer, host, onMessageSent, }: ConnectedChatThreadProps): import("react").JSX.Element;

package/dist/connection/messenger/ConnectedGroupMembers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A group's people: rename it, add people, remove someone (owners) or leave.
+ *
+ * Removing or leaving changes who holds the key: the server marks the chat `rotation_required`
+ * and a remaining member's client seals a fresh key to exactly the people left (done right after
+ * a removal, and by whoever is online after a leave), so the departed can't read on.
+ */
+import { type ChatResponse } from '@arbidocs/react';
+import type { MessengerHost } from './types';
+export interface ConnectedGroupMembersProps {
+    chat: ChatResponse;
+    /** The decrypted title, if any. */
+    title: string | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Called after I leave, so the caller can close the thread. */
+    onLeft?: () => void;
+    host?: MessengerHost;
+}
+export declare function ConnectedGroupMembers({ chat, title, open, onOpenChange, onLeft, host, }: ConnectedGroupMembersProps): import("react").JSX.Element;

package/dist/connection/messenger/ConnectedMessenger.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The chats messenger for a side panel: the list of chats OR one thread, never both.
+ *
+ *   - nothing open  → the chat rows fill the panel, "+ Invite", "New group" (and the host's
+ *                     list actions, e.g. "New call") first
+ *   - one open      → the thread fills it under a static identity header
+ *
+ * A row is a direct chat (a person, myself, or my agent), a group or a meeting chat, plus the
+ * people I can message and have no chat with yet. Rows are the shared <ConversationList>; the
+ * thread is <ConnectedChatThread>. Which conversation is open is the host's (its tabs).
+ */
+import { type ReactNode } from 'react';
+import { type ChatResponse, type DmConversation, type DmUser } from '@arbidocs/react';
+import type { MessengerHost } from './types';
+/** Tri-state filters (a host's filter menu), keyed by what they select for. */
+export type MessengerFilters = ReadonlyMap<string, 'include' | 'exclude' | null>;
+/** A row as the list shows it: a chat row, or a host's extra row (e.g. an invitation). */
+type ListRow = DmConversation & {
+    chat?: ChatResponse | null;
+};
+export interface ConnectedMessengerProps {
+    /** The open conversation (`usr-`/`agt-` peer or `cht-` chat), or null to show the list. */
+    activeId: string | null;
+    /** Open a conversation (a row was picked, or a group was just created). */
+    onOpen: (id: string) => void;
+    /** Close a conversation (I left its group). */
+    onClose?: (id: string) => void;
+    /** People to offer a conversation with although we have no chat yet (contacts, my agents). */
+    people?: DmUser[];
+    /** Rows after the chats that are not conversations yet, e.g. pending invitations. */
+    extraRows?: DmConversation[];
+    /**
+     * Narrow the rows. Built in: `unread`, `muted`, `agents`, `meetings`; `rowFilters` adds more.
+     * `include` keeps only matching rows, `exclude` drops them.
+     */
+    filters?: MessengerFilters;
+    /** More filters by id (e.g. invitations by their status). */
+    rowFilters?: Record<string, (row: ListRow) => boolean>;
+    /** Shows "Add a contact by email" first in the list. */
+    onInvite?: () => void;
+    /** More calls to action after "New group" (e.g. "New call"). */
+    listActions?: ReactNode;
+    /** Controls in a direct conversation's header. `addPeople` starts a group with the peer. */
+    directActions?: (peer: DmUser, context: {
+        addPeople?: () => void;
+    }) => ReactNode;
+    /** Controls in a group's header, before the members button. */
+    groupActions?: (chat: ChatResponse, title: string | null) => ReactNode;
+    host?: MessengerHost;
+}
+export declare function ConnectedMessenger({ activeId, onOpen, onClose, people, extraRows, filters, rowFilters, onInvite, listActions, directActions, groupActions, host, }: ConnectedMessengerProps): import("react").JSX.Element;
+export {};

package/dist/connection/messenger/index.d.ts

@@ -0,0 +1,6 @@
+export { ConnectedMessenger, type ConnectedMessengerProps, type MessengerFilters, } from './ConnectedMessenger';
+export { ConnectedChatThread, type ConnectedChatThreadProps } from './ConnectedChatThread';
+export { ConnectedGroupMembers, type ConnectedGroupMembersProps } from './ConnectedGroupMembers';
+export { ChatAttachmentList, type ChatAttachmentListProps } from './ChatAttachments';
+export { useMessengerRows, groupFallbackName } from './useMessengerRows';
+export type { ChatHistoryProps, ChatPeoplePickerProps, ChatThreadItem, MessengerHost, MessengerRow, MessengerUserVariant, } from './types';

package/dist/connection/messenger/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * What a host adds to the messenger kit. Every field is optional: without any, the kit runs on
+ * `@arbidocs/react` alone (plain avatars, plain text). The ARBI app fills them
+ * with its own presence-aware avatars, markdown, calls and contact actions. These are the
+ * messenger's part of the planned single host configuration (ARBI-frontend#1660).
+ */
+import type { ComponentType, ReactNode } from 'react';
+import type { ChatResponse, ChatThreadMessage, DmConversation, DmUser } from '@arbidocs/react';
+import { type PresenceDisplayStatus } from '@arbidocs/react/ui';
+import type { components } from '@arbidocs/client';
+export type NotificationResponse = components['schemas']['NotificationResponse'];
+/**
+ * How a person is drawn: a row or header `avatar`, a `small-avatar` (a group's stacked faces), the
+ * `author` pill above someone's run of messages, or a `member` of a group's member list.
+ */
+export type MessengerUserVariant = 'avatar' | 'small-avatar' | 'author' | 'member';
+/** One message of a thread with its place in it (from `annotateThread`). */
+export interface ChatThreadItem {
+    message: ChatThreadMessage;
+    isFirstOfDay: boolean;
+    isLastOfRun: boolean;
+}
+/**
+ * Everything a thread's history knows, for a host that draws more kinds of message (calls,
+ * transcripts, recordings) around the kit's own. `renderItem` draws a message the kit's way.
+ */
+export interface ChatHistoryProps {
+    chat: ChatResponse | null;
+    /** The thread's messages, oldest first (optimistic ones included). */
+    messages: ChatThreadMessage[];
+    /** The messages with their day and run boundaries. */
+    items: ChatThreadItem[];
+    /** Draws one item the kit's way (separator, author pill, bubble, note). */
+    renderItem: (item: ChatThreadItem, index: number) => ReactNode;
+    /** "Load earlier messages", when there are older ones. */
+    loadOlder: ReactNode;
+    /** A member (or former member) by id. */
+    memberById: (userExtId: string | null | undefined) => DmUser | undefined;
+    /** A member's display name; "Former member" when unknown. */
+    senderName: (userExtId: string | null | undefined) => string;
+    /** Me. */
+    myExtId: string | null;
+    /** The host's time format (`MessengerHost.formatTime`). */
+    formatTime: (iso: string) => string;
+    /** The day separator's label. */
+    formatDay: (iso: string) => string;
+}
+/** The props of the host's people picker (new group, add people to a chat). */
+export interface ChatPeoplePickerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /**
+     * `new-group`: a fresh group (≥2 people, optional title). `from-direct`: "Add people" in a direct
+     * chat starts a NEW group with the peer (a direct chat never grows). `add-members`: add people
+     * to an existing group.
+     */
+    mode: 'new-group' | 'from-direct' | 'add-members';
+    /** Always included and not removable (the direct peer for `from-direct`). */
+    fixed?: DmUser[];
+    /** Already members, so not offered (`add-members`). */
+    excludeIds?: string[];
+    /** Create or add. Resolves when done; a rejection keeps the picker open. */
+    onSubmit: (people: DmUser[], title: string | null) => Promise<void>;
+}
+export interface MessengerHost {
+    /** Draw a person. Default: the kit's initials avatar / plain name. */
+    renderUser?: (user: DmUser | null, variant: MessengerUserVariant) => ReactNode;
+    /** Render a message's text. Default: plain text. */
+    renderMessageBody?: (text: string, context: {
+        workspaceId: string | null;
+    }) => ReactNode;
+    /** A message's time (on the last bubble of a run). Default: "Today, 14:05". */
+    formatTime?: (iso: string) => string;
+    /** A day separator's label. Default: "Today", "Yesterday", "Mar 3". */
+    formatDay?: (iso: string) => string;
+    /** Someone's presence, for the open conversation's header. Omit to show none. */
+    presenceOf?: (userExtId: string) => PresenceDisplayStatus | undefined;
+    /**
+     * Personal Assistant chat: make sure the workspace my agent will act in can be used (its key
+     * is at hand). Resolves false when it cannot. Default: always ready.
+     */
+    prepareAgentWorkspace?: (workspaceId: string) => Promise<boolean>;
+    /** Open the thread my agent is working in (its workspace may need opening first). */
+    openAgentThread?: (workspaceId: string, conversationId: string) => void;
+    /** Review a pending workspace access request from the open conversation's peer. */
+    onReviewAccessRequest?: (request: NotificationResponse) => void;
+    /** A meeting chat's call key, sealed to people added to it. Without it they cannot be added. */
+    meetingCallKey?: (chat: ChatResponse) => Promise<Uint8Array | null>;
+    /** The people picker for groups. Without one, groups can't be created or grown here. */
+    PeoplePicker?: ComponentType<ChatPeoplePickerProps>;
+    /**
+     * Draws a thread's history around the kit's items, e.g. a call's transcript and recordings.
+     * Default: the kit's items only.
+     */
+    ThreadHistory?: ComponentType<ChatHistoryProps>;
+}
+/** A messenger row: the conversation, and the chat behind it (none yet for a new contact). */
+export type MessengerRow = DmConversation & {
+    id: string;
+    chat: ChatResponse | null;
+    /** Members other than me (the peer for a direct chat; empty for a self-chat). */
+    others: DmUser[];
+};