@pmate/chat-sdk 0.12.0-next.0 → 0.12.0-next.10

package/lib/runtime/messageClient.d.ts

@@ -15,6 +15,8 @@ export type MessageTransport<T> = {
 export type MessageSnapshot<T> = {
     messages: readonly T[];
     hasEarlier: boolean;
+    resetVersion: number;
+    complete: boolean;
 };
 export type MessageClientOptions<T extends StoredMessage> = {
     scope: MessageScope;
@@ -25,14 +27,19 @@ export type MessageClientOptions<T extends StoredMessage> = {
     batchSize?: number;
     writeWindowMs?: number;
     syncWindowMs?: number;
+    transactionBytes?: number;
+    queueBytes?: number;
+    freshnessMs?: number;
 };
 /** Local-first message facade; hosts never select a cache or network source. */
 export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private allListeners;
     private reads;
     private syncing;
+    private paging;
     private writes;
     private activeWrites;
     private writeTasks;
@@ -43,16 +50,25 @@ export declare class MessageClient<T extends StoredMessage> {
     private closing;
     private revoked;
     private batchSize;
+    private transactionBytes;
+    private queueBytes;
+    private pendingBytes;
+    private pendingRecords;
     constructor(options: MessageClientOptions<T>);
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
-    read(thread: string, limit?: number): Promise<MessageSnapshot<T>>;
+    subscribeAll(listener: (threadId: string) => void): () => void;
+    /** Close the connection gap for saved windows with four bounded background lanes. */
+    restore(since: number): Promise<void>;
+    read(thread: string, limit?: number, refresh?: boolean): Promise<MessageSnapshot<T>>;
     /** Application connection/wake events invalidate, rather than fetching directly. */
     invalidate(thread: string): void;
     private reload;
     /** Events are visible only after their atomic batch commits. */
     receive(thread: string, messages: T[]): Promise<void>;
     private persist;
+    private messageBytes;
+    private release;
     private flushWrites;
     private runWrites;
     synchronize(thread: string): Promise<void>;
@@ -62,7 +78,11 @@ export declare class MessageClient<T extends StoredMessage> {
     }, limit?: number): Promise<{
         messages: T[];
         hasEarlier: boolean;
+        resetVersion: number;
+        complete: boolean;
     }>;
+    private fillWindow;
+    private denyView;
     revoke(thread: string): Promise<void>;
     close(): Promise<void>;
 }

package/lib/runtime/messageClient.js

@@ -5,8 +5,10 @@ export class MessageClient {
     options;
     storage;
     watches = new Map();
+    allListeners = new Set();
     reads = new Map();
     syncing = new Map();
+    paging = new Map();
     writes = new Map();
     activeWrites = new Set();
     writeTasks;
@@ -17,45 +19,121 @@ export class MessageClient {
     closing = false;
     revoked = new Set();
     batchSize;
+    transactionBytes;
+    queueBytes;
+    pendingBytes = 0;
+    pendingRecords = 0;
     constructor(options) {
         this.options = options;
         this.storage = options.storage ?? new IndexedDbMessageStore(options.scope, options.merge ?? mergeStoredMessage);
         this.batchSize = options.batchSize ?? 128;
+        this.transactionBytes = options.transactionBytes ?? 1_048_576;
+        this.queueBytes = options.queueBytes ?? 8_388_608;
+        if (!Number.isSafeInteger(this.transactionBytes) || this.transactionBytes < 1 || !Number.isSafeInteger(this.queueBytes) || this.queueBytes < this.transactionBytes)
+            throw new Error("INVALID_MESSAGE_BYTE_LIMIT");
         if (!Number.isSafeInteger(this.batchSize) || this.batchSize < 1 || this.batchSize > 1000)
             throw new Error("INVALID_MESSAGE_BATCH_SIZE");
-        this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => options.onError?.(error, thread));
+        this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => { if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+            this.invalidate(thread);
+        else
+            options.onError?.(error, thread); });
         this.syncTasks = new WindowedTasks(options.syncWindowMs ?? 1000, (error, thread) => options.onError?.(error, thread));
         if (typeof BroadcastChannel !== "undefined") {
-            this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}`);
-            this.channel.onmessage = event => { if (typeof event.data === "string" && this.watches.has(event.data))
-                void this.reload(event.data).catch(error => options.onError?.(error, event.data)); };
+            this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}${this.storage.namespace === "pmate-chat-messages" ? "" : `:${this.storage.namespace}`}`);
+            this.channel.onmessage = event => {
+                if (this.closed)
+                    return;
+                if (event.data?.type === "revoked" && typeof event.data.thread === "string" && Number.isSafeInteger(event.data.version)) {
+                    const denied = event.data;
+                    void (async () => {
+                        const current = await this.storage.read(denied.thread, 1).then(page => page.coverage).catch(() => undefined);
+                        if (this.closed || (current && !current.revoked && (current.resetVersion ?? 0) >= denied.version))
+                            return;
+                        this.denyView(denied.thread, denied.version);
+                        options.onError?.(Object.assign(new Error("MESSAGE_ACCESS_REVOKED"), { status: 403 }), denied.thread);
+                    })();
+                }
+                else if (typeof event.data === "string" && this.watches.has(event.data))
+                    void this.reload(event.data).catch(error => { if (!this.closed)
+                        options.onError?.(error, event.data); });
+            };
         }
     }
     getSnapshot(thread) { return this.watches.get(thread)?.snapshot; }
     subscribe(thread, listener) {
         let watch = this.watches.get(thread);
         if (!watch) {
-            watch = { limit: 100, snapshot: { messages: [], hasEarlier: false }, listeners: new Set() };
+            watch = { snapshot: { messages: [], hasEarlier: false, resetVersion: 0, complete: false }, listeners: new Set() };
             this.watches.set(thread, watch);
         }
         watch.listeners.add(listener);
         return () => { watch.listeners.delete(listener); };
     }
-    read(thread, limit = 100) {
-        if (this.closed || this.closing || this.revoked.has(thread))
+    subscribeAll(listener) { this.allListeners.add(listener); return () => { this.allListeners.delete(listener); }; }
+    /** Close the connection gap for saved windows with four bounded background lanes. */
+    async restore(since) {
+        const queue = (await this.storage.windows()).filter(window => (window.syncedAt ?? 0) < since && !window.revoked);
+        await Promise.all(Array.from({ length: Math.min(4, queue.length) }, async () => {
+            while (queue.length && !this.closed && !this.closing) {
+                const window = queue.shift();
+                try {
+                    await this.synchronize(window.thread);
+                }
+                catch (error) {
+                    if (!this.closed && !this.closing)
+                        this.options.onError?.(error, window.thread);
+                }
+            }
+        }));
+    }
+    read(thread, limit = 100, refresh = false) {
+        if (this.closed || this.closing)
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             return Promise.reject(new Error("INVALID_MESSAGE_LIMIT"));
-        const key = JSON.stringify([thread, limit]), running = this.reads.get(key);
+        const key = JSON.stringify([thread, limit, refresh]), running = this.reads.get(key);
         if (running)
             return running;
         const task = (async () => {
             const local = await this.storage.read(thread, limit);
-            if (!local.coverage?.complete)
-                await this.synchronize(thread);
+            if (refresh || !local.coverage?.complete || local.coverage.revoked || this.revoked.has(thread)) {
+                if (typeof navigator !== "undefined" && navigator.onLine === false) {
+                    if (!refresh && local.messages.length && !local.coverage?.revoked)
+                        return this.reload(thread);
+                    throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
+                }
+                this.revoked.delete(thread);
+                try {
+                    await this.synchronize(thread);
+                }
+                catch (error) {
+                    if (refresh || !local.messages.length || [401, 403].includes(error?.status ?? 0))
+                        throw error;
+                    this.options.onError?.(error, thread);
+                    return this.reload(thread);
+                }
+            }
             if (this.closed)
                 throw new Error("MESSAGE_CLIENT_CLOSED");
-            return this.reload(thread, limit);
+            let result;
+            try {
+                result = await this.fillWindow(thread, limit);
+            }
+            catch (error) {
+                if ([401, 403].includes(error?.status ?? 0))
+                    throw error;
+                const cached = await this.storage.read(thread, limit);
+                if (!cached.messages.length)
+                    throw error;
+                this.options.onError?.(error, thread);
+                await this.reload(thread);
+                return { messages: cached.messages, hasEarlier: true, complete: false, resetVersion: cached.coverage?.resetVersion ?? 0 };
+            }
+            const snapshot = await this.reload(thread);
+            if (local.coverage?.complete && Date.now() - (local.coverage.syncedAt ?? 0) > (this.options.freshnessMs ?? 30_000)
+                && (typeof navigator === "undefined" || navigator.onLine !== false))
+                this.invalidate(thread);
+            return limit === 100 ? snapshot : result;
         })().finally(() => { if (this.reads.get(key) === task)
             this.reads.delete(key); });
         this.reads.set(key, task);
@@ -66,10 +144,15 @@ export class MessageClient {
         if (!this.closed && !this.closing && !this.revoked.has(thread))
             this.syncTasks.schedule(thread, () => this.synchronize(thread));
     }
-    async reload(thread, limit = this.watches.get(thread)?.limit ?? 100) {
+    async reload(thread) {
+        const limit = 100;
         const page = await this.storage.read(thread, limit);
         if (this.closed)
             throw new Error("MESSAGE_CLIENT_CLOSED");
+        if (this.revoked.has(thread)) {
+            page.messages = [];
+            page.hasEarlier = false;
+        }
         let watch = this.watches.get(thread);
         const oldById = new Map(watch?.snapshot.messages.map(message => [message.id, message]));
         const messages = page.messages.map(message => {
@@ -77,49 +160,97 @@ export class MessageClient {
             return old && JSON.stringify(old) === JSON.stringify(message) ? old : message;
         });
         const old = watch?.snapshot;
-        if (old && old.hasEarlier === (page.hasEarlier || Boolean(page.coverage?.nextBefore)) && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
+        const resetVersion = Math.max(page.coverage?.resetVersion ?? 0, this.revoked.has(thread) ? watch?.snapshot.resetVersion ?? 0 : 0), complete = !this.revoked.has(thread) && (page.coverage?.complete ?? false);
+        const hasEarlier = !this.revoked.has(thread) && (page.hasEarlier || Boolean(page.coverage?.nextBefore));
+        if (old && old.resetVersion === resetVersion && old.complete === complete && old.hasEarlier === hasEarlier && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
             return old;
-        const snapshot = { messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        const snapshot = { messages, resetVersion, complete, hasEarlier };
         if (!watch) {
-            watch = { limit, snapshot, listeners: new Set() };
+            watch = { snapshot, listeners: new Set() };
             this.watches.set(thread, watch);
         }
-        watch.limit = limit;
         watch.snapshot = snapshot;
         watch.listeners.forEach(listener => listener());
+        this.allListeners.forEach(listener => listener(thread));
         return snapshot;
     }
     /** Events are visible only after their atomic batch commits. */
     receive(thread, messages) {
-        if (this.closed || this.closing || this.revoked.has(thread))
+        if (this.closed || this.closing)
             return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        if (this.revoked.has(thread))
+            return Promise.reject(new Error("MESSAGE_ACCESS_REVOKED"));
         const queue = this.writes.get(thread) ?? [];
-        if (messages.length > 1000 || queue.reduce((count, write) => count + write.messages.length, messages.length) > 4096)
+        if (messages.length > 1000 || this.pendingRecords + messages.length > 4096)
             return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
-        const promise = new Promise((resolve, reject) => queue.push({ messages, resolve, reject }));
+        let bytes = 0;
+        try {
+            for (const message of messages) {
+                bytes += this.messageBytes(message);
+                if (this.pendingBytes + bytes > this.queueBytes)
+                    throw new Error("MESSAGE_STORAGE_BACKPRESSURE");
+            }
+            messages = structuredClone(messages);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        this.pendingBytes += bytes;
+        this.pendingRecords += messages.length;
+        const promise = new Promise((resolve, reject) => queue.push({ messages, bytes, version: this.watches.get(thread)?.snapshot.resetVersion ?? 0, resolve, reject }));
         this.writes.set(thread, queue);
         this.writeTasks.schedule(thread, () => this.flushWrites(thread));
         return promise;
     }
-    async persist(thread, messages, checkpoint, complete, nextBefore) {
+    async persist(thread, messages, checkpoint, complete, nextBefore, syncedAt, expectedVersion) {
+        const initial = (await this.storage.read(thread, 1)).coverage;
+        const version = expectedVersion ?? initial?.resetVersion ?? 0;
+        const guard = { version, authoritative: complete === true };
         let changed = 0;
+        let navigationChanged = false;
         // Coverage advances only after all bounded batches have durably committed.
-        for (let offset = 0; offset < messages.length; offset += this.batchSize) {
+        let batch = [], bytes = 0;
+        const commit = async () => {
+            if (!batch.length)
+                return;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            changed += await this.storage.commit(thread, messages.slice(offset, offset + this.batchSize));
+            changed += await this.storage.commit(thread, batch, undefined, guard);
+            batch = [];
+            bytes = 0;
+        };
+        for (const message of messages) {
+            const size = this.messageBytes(message);
+            if (batch.length >= this.batchSize || bytes + size > this.transactionBytes)
+                await commit();
+            batch.push(message);
+            bytes += size;
         }
+        await commit();
         if (complete !== undefined || checkpoint !== undefined) {
             const old = (await this.storage.read(thread, 1)).coverage;
             if (this.closed || this.revoked.has(thread))
                 throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            await this.storage.commit(thread, [], { complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore });
+            navigationChanged = (nextBefore !== undefined && nextBefore !== old?.nextBefore) || (complete !== undefined && complete !== old?.complete);
+            await this.storage.commit(thread, [], { resetVersion: version, revoked: complete === true ? false : old?.revoked, syncedAt: syncedAt ?? old?.syncedAt, complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore }, guard);
         }
-        if (changed) {
+        if (changed || navigationChanged) {
             await this.reload(thread);
             this.channel?.postMessage(thread);
         }
     }
+    messageBytes(message) {
+        const bytes = new TextEncoder().encode(JSON.stringify(message)).byteLength;
+        if (bytes > this.transactionBytes)
+            throw new Error("MESSAGE_RECORD_TOO_LARGE");
+        return bytes;
+    }
+    release(queue) {
+        for (const write of queue) {
+            this.pendingBytes -= write.bytes;
+            this.pendingRecords -= write.messages.length;
+        }
+    }
     flushWrites(thread) {
         const task = this.runWrites(thread).finally(() => this.activeWrites.delete(task));
         this.activeWrites.add(task);
@@ -131,12 +262,29 @@ export class MessageClient {
             return;
         this.writes.delete(thread);
         try {
-            await this.persist(thread, queue.flatMap(write => write.messages));
-            queue.forEach(write => write.resolve());
+            const groups = new Map();
+            for (const write of queue) {
+                const group = groups.get(write.version) ?? [];
+                group.push(write);
+                groups.set(write.version, group);
+            }
+            let failed = false, failure;
+            for (const [version, writes] of groups) {
+                try {
+                    await this.persist(thread, writes.flatMap(write => write.messages), undefined, undefined, undefined, undefined, version);
+                    writes.forEach(write => write.resolve());
+                }
+                catch (error) {
+                    failed = true;
+                    failure = error;
+                    writes.forEach(write => write.reject(error));
+                }
+            }
+            if (failed)
+                throw failure;
         }
-        catch (error) {
-            queue.forEach(write => write.reject(error));
-            throw error;
+        finally {
+            this.release(queue);
         }
     }
     synchronize(thread) {
@@ -147,6 +295,7 @@ export class MessageClient {
             return running;
         const task = (async () => {
             const coverage = (await this.storage.read(thread, 1)).coverage;
+            let version = coverage?.resetVersion ?? 0;
             let after = coverage?.complete ? coverage.checkpoint : undefined;
             let page = after && this.options.transport.changes
                 ? await this.options.transport.changes(thread, after, this.abort.signal)
@@ -154,7 +303,7 @@ export class MessageClient {
             if (page.resetRequired) {
                 if (this.closed || this.revoked.has(thread))
                     throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-                await this.storage.removeThread(thread);
+                version = await this.storage.resetThread(thread);
                 after = undefined;
                 page = await this.options.transport.load(thread, this.abort.signal);
             }
@@ -163,7 +312,7 @@ export class MessageClient {
                     throw new Error("MESSAGE_ACCESS_REVOKED");
                 if (page.resetRequired)
                     throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
-                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore);
+                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore, Date.now(), version);
                 if (!page.hasMoreChanges)
                     break;
                 if (!page.checkpoint || page.checkpoint === after || !this.options.transport.changes)
@@ -171,7 +320,17 @@ export class MessageClient {
                 after = page.checkpoint;
                 page = await this.options.transport.changes(thread, after, this.abort.signal);
             }
-        })().finally(() => { if (this.syncing.get(thread) === task)
+        })().catch(async (error) => {
+            if (!this.closed && !this.closing && error?.status === 403) {
+                try {
+                    await this.revoke(thread);
+                }
+                catch (cacheError) {
+                    Object.assign(error, { cacheError });
+                }
+            }
+            throw error;
+        }).finally(() => { if (this.syncing.get(thread) === task)
             this.syncing.delete(thread); });
         this.syncing.set(thread, task);
         return task;
@@ -183,31 +342,80 @@ export class MessageClient {
             throw new Error("MESSAGE_ACCESS_REVOKED");
         if (!(await this.storage.read(thread, 1)).coverage?.complete)
             await this.synchronize(thread);
+        return this.fillWindow(thread, limit, before);
+    }
+    async fillWindow(thread, limit, before) {
         let page = await this.storage.read(thread, limit, before);
+        let resets = 0;
         while (page.messages.length < limit && page.coverage?.nextBefore && this.options.transport.older) {
-            const token = page.coverage.nextBefore;
-            const remote = await this.options.transport.older(thread, token, this.abort.signal);
-            if (this.closed || this.revoked.has(thread))
-                throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
-            if (remote.resetRequired) {
-                await this.storage.removeThread(thread);
-                throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+            const pending = this.paging.get(thread);
+            if (pending) {
+                await pending;
+                page = await this.storage.read(thread, limit, before);
+                continue;
             }
-            if (remote.nextBefore === token)
-                throw new Error("MESSAGE_SYNC_NO_PROGRESS");
-            await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null);
+            const token = page.coverage.nextBefore, version = page.coverage.resetVersion ?? 0;
+            const task = (async () => {
+                const remote = await this.options.transport.older(thread, token, this.abort.signal);
+                if (this.closed || this.revoked.has(thread))
+                    throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+                if (remote.resetRequired) {
+                    if (++resets > 2)
+                        throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+                    await this.storage.resetThread(thread);
+                    await this.synchronize(thread);
+                    return;
+                }
+                if (remote.nextBefore === token)
+                    throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+                await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null, undefined, version);
+            })().catch(async (error) => {
+                if (!this.closed && !this.closing && error?.status === 403) {
+                    try {
+                        await this.revoke(thread);
+                    }
+                    catch (cacheError) {
+                        Object.assign(error, { cacheError });
+                    }
+                }
+                throw error;
+            }).finally(() => { if (this.paging.get(thread) === task)
+                this.paging.delete(thread); });
+            this.paging.set(thread, task);
+            await task;
             page = await this.storage.read(thread, limit, before);
         }
-        return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore), resetVersion: page.coverage?.resetVersion ?? 0, complete: page.coverage?.complete ?? false };
     }
-    async revoke(thread) {
+    denyView(thread, version) {
         this.revoked.add(thread);
+        const watch = this.watches.get(thread);
+        const snapshot = { messages: [], hasEarlier: false, complete: false, resetVersion: Math.max(watch?.snapshot.resetVersion ?? 0, version ?? (watch?.snapshot.resetVersion ?? 0) + 1) };
+        if (watch && !watch.snapshot.messages.length && !watch.snapshot.complete && !watch.snapshot.hasEarlier && watch.snapshot.resetVersion === snapshot.resetVersion)
+            return;
+        if (watch) {
+            watch.snapshot = snapshot;
+            watch.listeners.forEach(listener => listener());
+        }
+        else
+            this.watches.set(thread, { snapshot, listeners: new Set() });
+        this.allListeners.forEach(listener => listener(thread));
+    }
+    async revoke(thread) {
+        this.denyView(thread);
         const queue = this.writes.get(thread);
         this.writes.delete(thread);
-        queue?.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
-        await this.storage.removeThread(thread);
-        await this.reload(thread);
-        this.channel?.postMessage(thread);
+        if (queue) {
+            queue.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
+            this.release(queue);
+        }
+        try {
+            await this.storage.resetThread(thread, true);
+            await this.reload(thread);
+        }
+        finally {
+            this.channel?.postMessage({ type: "revoked", thread, version: this.watches.get(thread)?.snapshot.resetVersion });
+        }
     }
     async close() {
         // Flush accepted event batches before closing; new requests are rejected afterwards.
@@ -220,6 +428,7 @@ export class MessageClient {
         this.abort.abort();
         this.channel?.close();
         this.watches.clear();
+        this.allListeners.clear();
         this.storage.close();
     }
 }

package/lib/runtime/messageReaders.d.ts

@@ -0,0 +1,46 @@
+import { type MessageScope } from "./messageStore.js";
+export type MessageReadersPage = {
+    appId: string;
+    threadId: string;
+    messageId: string;
+    revision: number;
+    total: number;
+    profileIds: string[];
+    nextAfter: string | null;
+    resetRequired: boolean;
+};
+export type MessageReadersQuery = {
+    threadId: string;
+    messageId: string;
+    afterProfileId?: string;
+    revision?: number;
+    limit?: number;
+};
+export type MessageReadersOptions = {
+    appId: string;
+    profileId: string;
+    token: string;
+    hubHttpUrl: string;
+    fetch?: typeof fetch;
+    scope?: MessageScope;
+    onError?: (error: unknown) => void;
+};
+export declare class MessageReadersError extends Error {
+    readonly status: number;
+    readonly forbidden: boolean;
+    constructor(status: number, message: string);
+}
+/** Authenticated detail reads; concurrent identical requests share one transport call. */
+export declare class MessageReadersClient {
+    private options;
+    private pending;
+    private lifetime;
+    private cache?;
+    private revoked;
+    private generation;
+    constructor(options: MessageReadersOptions);
+    getReaders(query: MessageReadersQuery, signal?: AbortSignal): Promise<MessageReadersPage>;
+    private cachedRequest;
+    private request;
+    close(): Promise<void>;
+}