@pmate/chat-sdk 0.12.0-next.68 → 0.12.0-next.69

package/lib/internal/chatEngine.js

@@ -0,0 +1,280 @@
+import { createMessagePresenter } from "../messageView.js";
+import { createChat as createSession } from "../runtime/createChat.js";
+import { asChatError } from "../runtime/chatError.js";
+import { ChatError } from "../chatError.js";
+export { ChatError } from "../chatError.js";
+const emptyMessages = Object.freeze([]);
+/** App-facing API. Cache coverage, raw protocol and synchronization stay in advanced. */
+export class ChatEngine {
+    advanced;
+    options;
+    groups = new WeakMap();
+    group(value) {
+        if (!value)
+            return undefined;
+        let projected = this.groups.get(value);
+        if (!projected) {
+            const { versionNumber: _, ...visible } = value;
+            projected = visible;
+            this.groups.set(value, projected);
+        }
+        return projected;
+    }
+    present = createMessagePresenter();
+    redactedQuotes = new WeakMap();
+    messageLists = new WeakMap();
+    messages(items) {
+        let values = this.messageLists.get(items);
+        if (!values) {
+            const recalled = new Set(items.filter(item => item.recalled).map(item => item.id));
+            values = items.map(item => {
+                const value = this.present(item);
+                if (!value.quote?.messageId || !recalled.has(value.quote.messageId))
+                    return value;
+                let hidden = this.redactedQuotes.get(value);
+                if (!hidden) {
+                    hidden = { ...value, quote: { ...value.quote, content: "", recalled: true } };
+                    this.redactedQuotes.set(value, hidden);
+                }
+                return hidden;
+            });
+            this.messageLists.set(items, values);
+        }
+        return values;
+    }
+    views = new Map();
+    summary;
+    targets = new Map();
+    errors = new Map();
+    listeners = new Map();
+    closed = false;
+    constructor(advanced, options) {
+        this.advanced = advanced;
+        this.options = options;
+    }
+    async operation(run) { try {
+        return await run();
+    }
+    catch (error) {
+        throw asChatError(error);
+    } }
+    async deny(threadId, failure) {
+        this.errors.set(threadId, failure);
+        this.targets.delete(threadId);
+        const retiring = this.advanced.revokeAccess();
+        this.notify(threadId);
+        try {
+            await retiring;
+        }
+        catch (error) {
+            failure.cause = new AggregateError([failure.cause, error], "Access withdrawn; cache cleanup incomplete");
+        }
+    }
+    threadOperation(threadId, run) {
+        return this.operation(async () => {
+            const denied = threadId ? this.errors.get(threadId) : undefined;
+            if (denied?.code === "access-denied")
+                throw denied;
+            try {
+                return await run();
+            }
+            catch (error) {
+                const failure = asChatError(error);
+                if (threadId && failure.code === "access-denied")
+                    await this.deny(threadId, failure);
+                throw failure;
+            }
+        });
+    }
+    start() { return this.operation(() => this.options.connection ? this.advanced.initialize() : this.advanced.start()); }
+    /** Resolve a scoped ID locally, registering its target when needed. No remote group is created. */
+    resolveThreadId(target) { return this.getConversation(target); }
+    /** A trusted recent window. Source selection and synchronization belong to the SDK. */
+    getThread(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId), options); }
+    loadEarlier(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId, { earlier: true }), options); }
+    refreshThread(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId, { refresh: true }), options); }
+    readForCaller(run, { signal }) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason ?? new DOMException("The operation was aborted", "AbortError"));
+        if (!signal)
+            return run();
+        // A caller's cancellation never aborts another subscriber's shared read.
+        return new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason ?? new DOMException("The operation was aborted", "AbortError")); };
+            signal.addEventListener("abort", abort, { once: true });
+            run().then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+        });
+    }
+    threadSubscribers = new Map();
+    openQueue = new Set();
+    opening = 0;
+    drainOpens() {
+        while (!this.closed && this.opening < 4 && this.openQueue.size) {
+            const id = this.openQueue.values().next().value;
+            this.openQueue.delete(id);
+            if (!this.threadSubscribers.has(id))
+                continue;
+            this.opening++;
+            void this.getThread(id).catch(() => { }).finally(() => { this.opening--; this.drainOpens(); });
+        }
+    }
+    /** Listen first, then open the local window; concurrent consumers share the initial read. */
+    subscribeThread(threadId, listener, options = {}) {
+        const off = this.subscribe(threadId, listener, options), count = this.threadSubscribers.get(threadId) ?? 0;
+        this.threadSubscribers.set(threadId, count + 1);
+        if (!count) {
+            this.openQueue.add(threadId);
+            this.drainOpens();
+        }
+        let disposed = false;
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            off();
+            const remaining = (this.threadSubscribers.get(threadId) ?? 1) - 1;
+            if (remaining)
+                this.threadSubscribers.set(threadId, remaining);
+            else {
+                this.threadSubscribers.delete(threadId);
+                this.openQueue.delete(threadId);
+            }
+        };
+    }
+    /** @deprecated Use resolveThreadId. Retained only for the migration window. */
+    getConversation(target) {
+        return this.operation(async () => {
+            const id = await this.advanced.getConversation(target);
+            const value = target.groupId !== undefined ? { kind: "group", targetId: target.groupId } : { kind: "dm", targetId: target.peerId };
+            this.targets.delete(id);
+            this.targets.set(id, value);
+            if (this.targets.size > 256)
+                this.targets.delete(this.targets.keys().next().value);
+            this.notify(id);
+            return id;
+        });
+    }
+    getSnapshot(threadId) {
+        if (threadId === undefined) {
+            const source = this.advanced.getSnapshot(), previous = this.summary;
+            const threads = source.threads.filter(thread => this.errors.get(thread.threadId)?.code !== "access-denied").map(thread => ({ threadId: thread.threadId, lastMessage: this.messages(this.advanced.getSnapshot(thread.threadId).timeline).at(-1), group: this.group(thread.group), unread: thread.unread, outgoingCount: thread.outgoingCount }));
+            const unreadMessageCount = source.unreadMessageCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.unreadMessageCount ?? 0), 0);
+            const badgeCount = source.badgeCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.badgeCount ?? 0), 0);
+            if (previous && previous.connection === source.connection && previous.badgeCount === badgeCount && previous.unreadMessageCount === unreadMessageCount && previous.threads.length === threads.length && threads.every((thread, i) => { const old = previous.threads[i]; return thread.threadId === old.threadId && thread.lastMessage === old.lastMessage && thread.group === old.group && thread.unread === old.unread && thread.outgoingCount === old.outgoingCount; }))
+                return previous;
+            return this.summary = { threads, connection: source.connection, badgeCount, unreadMessageCount };
+        }
+        const source = this.advanced.getSnapshot(threadId), previous = this.views.get(threadId);
+        const error = this.closed ? undefined : this.errors.get(threadId), denied = error?.code === "access-denied";
+        const target = this.closed || !this.advanced.active || denied ? undefined : this.advanced.getConversationTarget(threadId) ?? this.targets.get(threadId);
+        const conversation = previous?.conversation?.kind === target?.kind && previous?.conversation?.targetId === target?.targetId ? previous?.conversation : target ? { kind: target.kind, targetId: target.targetId } : undefined;
+        // Partial migrated rows never masquerade as a trusted recent window.
+        const next = { threadId, conversation, messages: !denied && source.complete ? this.messages(source.timeline) : emptyMessages, ready: !denied && source.complete, hasEarlier: !denied && source.hasEarlier, unread: denied ? undefined : source.unread, group: denied ? undefined : this.group(source.group), readCounts: denied ? undefined : source.readCounts, error, status: !denied && source.complete ? "ready" : error ? "error" : "pending" };
+        if (previous && Object.keys(next).every(key => next[key] === previous[key]))
+            return previous;
+        this.views.set(threadId, next);
+        return next;
+    }
+    async getMessages(threadId, query = {}) {
+        try {
+            if (Object.keys(query).some(key => !["earlier", "all", "refresh"].includes(key)))
+                throw new ChatError("invalid-input", "Unsupported message query");
+            const page = await this.advanced.getMessages(threadId, query);
+            if (!page.complete)
+                throw new ChatError("unavailable", "Messages are not ready; retry when connected");
+            this.errors.delete(threadId);
+            this.notify(threadId);
+            return this.getSnapshot(threadId);
+        }
+        catch (error) {
+            const failure = asChatError(error);
+            if (!this.closed) {
+                if (failure.code === "access-denied")
+                    await this.deny(threadId, failure);
+                else {
+                    this.errors.set(threadId, failure);
+                    this.notify(threadId);
+                }
+            }
+            throw failure;
+        }
+    }
+    sendMessage(threadId, content, options = {}) {
+        return this.threadOperation(threadId, async () => {
+            if (content && ("groupCreate" in content || "groupUpdate" in content))
+                throw new ChatError("invalid-input", "Use createGroup or updateGroup for group changes");
+            const result = await this.advanced.sendMessage(threadId, content, options);
+            return { id: result.hash, timestamp: result.t };
+        });
+    }
+    retryMessage(messageId) { return this.operation(async () => { const result = await this.advanced.retryMessage(messageId); return { id: result.hash, timestamp: result.t }; }); }
+    subscribe(target, callback, options = {}) {
+        const global = typeof target === "function", key = global ? "" : target;
+        const config = global ? callback : options;
+        const read = () => global ? this.getSnapshot() : this.getSnapshot(key);
+        let previous = read();
+        const emit = () => {
+            const value = read();
+            const fields = config?.fields;
+            const changed = fields ? fields.some(field => previous[field] !== value[field]) : value !== previous;
+            previous = value;
+            if (changed) {
+                try {
+                    (global ? target : callback)(value);
+                }
+                catch (error) {
+                    try {
+                        this.options.onError(error);
+                    }
+                    catch { /* A consumer cannot break other consumers or cache publication. */ }
+                }
+            }
+        };
+        let listeners = this.listeners.get(key);
+        if (!listeners) {
+            listeners = new Set();
+            this.listeners.set(key, listeners);
+        }
+        listeners.add(emit);
+        const off = global ? this.advanced.subscribeChanges(emit) : this.advanced.subscribeChanges(key, emit, this.sessionFields(options.fields));
+        const dispose = () => { off(); listeners.delete(emit); if (!listeners.size)
+            this.listeners.delete(key); };
+        if (config?.emitCurrent !== false) {
+            try {
+                (global ? target : callback)(previous);
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+        }
+        return dispose;
+    }
+    sessionFields(fields) {
+        return fields ? [...new Set(fields.flatMap(field => field === "messages" ? ["timeline", "complete"] : field === "ready" || field === "status" ? ["complete"] : field === "conversation" ? ["messages", "group"] : field === "error" || field === "threadId" ? [] : [field]))] : undefined;
+    }
+    notify(threadId) { this.listeners.get(threadId)?.forEach(listener => listener()); this.listeners.get("")?.forEach(listener => listener()); }
+    observeMessages(threadId, ids, event) { return this.threadOperation(threadId, async () => { await this.advanced.observeMessages(threadId, ids, event); }); }
+    markRead(threadId) { return this.threadOperation(threadId, async () => { await this.advanced.markRead(threadId); }); }
+    getReaders(threadId, messageId, page = {}, signal) {
+        return this.threadOperation(threadId, async () => {
+            if (Object.keys(page).some(key => !["afterProfileId", "revision"].includes(key)))
+                throw new ChatError("invalid-input", "Unsupported reader query");
+            return this.advanced.getReaders(threadId, messageId, page, signal);
+        });
+    }
+    watchReaders(threadId, ids, receiver) { return this.threadOperation(threadId, () => this.advanced.observeMessages(threadId, ids, "receipts", receiver)); }
+    handleReach(event) { return this.operation(() => this.advanced.handleReach(event)); }
+    getVoiceAttachment(threadId, messageId) { return this.threadOperation(threadId, () => this.advanced.getVoiceAttachment(threadId, messageId)); }
+    getGroup(threadId, options = {}) { return this.threadOperation(threadId, async () => this.group(await this.advanced.getGroup(threadId, options))); }
+    createGroup(input) {
+        return this.operation(async () => {
+            const groupId = input.groupId ?? crypto.randomUUID(), threadId = await this.getConversation({ groupId });
+            const group = await this.advanced.createGroup({ id: threadId, kind: "group", targetId: groupId, teamId: this.options.teamId }, { title: input.title, members: input.members });
+            return { ...this.group(group), threadId };
+        });
+    }
+    updateGroup(threadId, changes) { return this.threadOperation(threadId, async () => this.group(await this.advanced.updateGroup(threadId, changes))); }
+    revokeAccess() { return this.operation(() => this.advanced.revokeAccess()); }
+    close() { this.closed = true; return this.operation(() => this.advanced.close()).finally(() => { this.errors.clear(); this.targets.clear(); this.listeners.clear(); this.threadSubscribers.clear(); this.openQueue.clear(); this.views.clear(); this.summary = undefined; this.present = createMessagePresenter(); this.messageLists = new WeakMap(); this.groups = new WeakMap(); this.redactedQuotes = new WeakMap(); }); }
+}

package/lib/internal/chatRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { Chat } from "../chatContract.js";
+import type { ChatEngine } from "./chatEngine.js";
+export declare function registerChat(chat: Chat, engine: ChatEngine): void;
+export declare function chatEngine(chat: Chat): ChatEngine;

package/lib/internal/chatRegistry.js

@@ -0,0 +1,4 @@
+const engines = new WeakMap();
+export function registerChat(chat, engine) { engines.set(chat, engine); }
+export function chatEngine(chat) { const engine = engines.get(chat); if (!engine)
+    throw new TypeError("Unknown Chat client"); return engine; }

package/lib/internal/createPublicChat.d.ts

@@ -0,0 +1,4 @@
+import type { Chat } from "../chatContract.js";
+import { type CreateChatOptions } from "../runtime/createChat.js";
+/** Build only the public capabilities; no aliases or engine fields on the returned object. */
+export declare function createPublicChat(options: CreateChatOptions): Chat;

package/lib/internal/createPublicChat.js

@@ -0,0 +1,52 @@
+import { waitForCaller } from "../credentials.js";
+import { ChatEngine } from "./chatEngine.js";
+import { registerChat } from "./chatRegistry.js";
+import { createChat as createSession } from "../runtime/createChat.js";
+import { asChatError } from "../runtime/chatError.js";
+import { ChatError } from "../chatError.js";
+/** Build only the public capabilities; no aliases or engine fields on the returned object. */
+export function createPublicChat(options) {
+    const configured = { ...options, onError: (error) => options.onError?.(asChatError(error)) };
+    let session;
+    try {
+        session = createSession(configured);
+    }
+    catch (error) {
+        throw asChatError(error);
+    }
+    const engine = new ChatEngine(session, configured);
+    const keys = (value, allowed) => { if (Object.keys(value).some(key => !allowed.includes(key)))
+        throw new ChatError("invalid-input", "Unsupported operation options"); };
+    const read = (run, options = {}, cleanup) => {
+        try {
+            keys(options, ["signal"]);
+            options.signal?.throwIfAborted();
+            return waitForCaller(run(), options.signal, cleanup);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    const chat = Object.freeze({
+        start: () => engine.start(), close: () => engine.close(),
+        resolveThreadId: (target, options = {}) => read(() => engine.resolveThreadId(target), options),
+        getThread: (id, options) => read(() => engine.getThread(id), options), loadEarlier: (id, options) => read(() => engine.loadEarlier(id), options), refreshThread: (id, options) => read(() => engine.refreshThread(id), options),
+        subscribeThread: (id, listener, options = {}) => { keys(options, ["fields"]); return engine.subscribeThread(id, listener, options); }, subscribeChat: (listener, options = {}) => { keys(options, ["fields"]); return engine.subscribe(listener, options); },
+        sendMessage: (id, content, options) => engine.sendMessage(id, content, options), retryMessage: id => engine.retryMessage(id),
+        observeMessages: (id, ids, event) => engine.observeMessages(id, ids, event), markRead: id => engine.markRead(id), watchReaders: (id, ids, receiver) => engine.watchReaders(id, ids, receiver),
+        getReaders: (id, messageId, options = {}) => {
+            try {
+                keys(options, ["afterProfileId", "revision", "signal"]);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+            return read(() => engine.getReaders(id, messageId, { afterProfileId: options.afterProfileId, revision: options.revision }), { signal: options.signal });
+        },
+        getVoiceAttachment: (id, messageId, options = {}) => read(() => engine.getVoiceAttachment(id, messageId), options, lease => lease.release()),
+        getGroup: (id, options = {}) => read(() => engine.getGroup(id), options), refreshGroup: (id, options = {}) => read(() => engine.getGroup(id, { refresh: true }), options),
+        createGroup: input => engine.createGroup(input), updateGroup: (id, changes) => engine.updateGroup(id, changes),
+    });
+    registerChat(chat, engine);
+    return chat;
+}

package/lib/messageView.d.ts

@@ -1,37 +1,6 @@
 import type { TimelineItem } from "./runtime/messageTimeline.js";
 import type { CachedChatMessage } from "./runtime/cachedMessage.js";
-import type { MessageQuote } from "./runtime/outgoingContent.js";
-import type { ChatMention } from "./mentions/model.js";
-export type ChatMessage = Readonly<Omit<TimelineItem<CachedChatMessage>, "message" | "reactionEvents"> & {
-    kind: "text" | "image" | "voice" | "emoji" | "quote" | "invitation" | "system" | "attachment";
-    text: string;
-    senderName?: string;
-    senderAvatar?: string;
-    timeLabel?: string;
-    image?: Readonly<{
-        url: string;
-        name?: string;
-    }>;
-    voice?: Readonly<{
-        url: string;
-        durationMs: number;
-        transcript?: string;
-    }>;
-    quote?: Readonly<MessageQuote & {
-        recalled?: boolean;
-    }>;
-    attachment?: Readonly<{
-        name?: string;
-        size?: string;
-    }>;
-    /** Explicit versioned content, interpreted with SDK readMessageContent. */
-    richContent?: unknown;
-    mentions?: readonly ChatMention[];
-    recipientCount?: number;
-    system?: Readonly<{
-        type: "group-created" | "group-updated" | "contact-updated";
-        title?: string;
-    }>;
-}>;
+import type { ChatMessage } from "./chatTypes.js";
+export type { ChatMessage } from "./chatTypes.js";
 /** Decode a body once; reading and delivery projections reuse its normalized content. */
 export declare function createMessagePresenter(): (item: TimelineItem<CachedChatMessage>) => ChatMessage;

package/lib/runtime/chatClient.d.ts

@@ -16,6 +16,7 @@ export type ChatClientOptions = {
     onNotification?: OnlineNotificationHandler;
     profileId?: string;
     botKey?: PmateBotKeyFile | string | unknown;
+    getToken?: () => Promise<string>;
     session?: BotLoginSession;
     hubUrl?: string;
     authBaseUrl?: string;

package/lib/runtime/chatClient.js

@@ -161,7 +161,7 @@ export class ChatClient {
         catch (error) {
             if (generation !== this.generation)
                 return;
-            if (error instanceof ChatAckError) {
+            if (error instanceof ChatAckError || ["authentication-required", "access-denied"].includes(error?.code ?? "")) {
                 this.close();
                 this.setConnection("authentication_required");
             }
@@ -295,7 +295,12 @@ export class ChatClient {
         });
     }
     async sendAuth() {
-        const token = this.session?.token;
+        const generation = this.generation;
+        const token = this.options.getToken ? await this.options.getToken() : this.session?.token;
+        if (generation !== this.generation)
+            throw new Error("ChatClient closed");
+        if (this.session && token)
+            this.session = { ...this.session, token };
         if (!token) {
             throw new Error("Missing PMate session token");
         }

package/lib/runtime/chatError.d.ts

@@ -1,12 +1,3 @@
-export type ChatErrorCode = "unavailable" | "access-denied" | "storage-unavailable" | "invalid-input" | "conflict" | "closed" | "busy";
-/** Stable recovery categories. The original failure remains available as cause. */
-export declare class ChatError extends Error {
-    readonly code: ChatErrorCode;
-    readonly retryable: boolean;
-    readonly status?: number;
-    constructor(code: ChatErrorCode, message: string, options?: {
-        cause?: unknown;
-        status?: number;
-    });
-}
+import { ChatError } from "../chatError.js";
+export { ChatError, type ChatErrorCode } from "../chatError.js";
 export declare function asChatError(error: unknown): ChatError;

package/lib/runtime/chatError.js

@@ -1,22 +1,11 @@
-/** Stable recovery categories. The original failure remains available as cause. */
-export class ChatError extends Error {
-    code;
-    retryable;
-    status;
-    constructor(code, message, options = {}) {
-        super(message, { cause: options.cause });
-        this.code = code;
-        this.name = "ChatError";
-        this.status = options.status;
-        this.retryable = ["unavailable", "storage-unavailable", "busy"].includes(code);
-    }
-}
+import { ChatError } from "../chatError.js";
+export { ChatError } from "../chatError.js";
 export function asChatError(error) {
     if (error instanceof ChatError)
         return error;
     const value = error;
     const status = value?.status, message = value?.message ?? String(error);
-    const code = status === 401 || status === 403 || /ACCESS_REVOKED|ACCESS_DENIED|SCOPE_CHANGED/.test(message) ? "access-denied"
+    const code = status === 401 ? "authentication-required" : status === 403 || /ACCESS_REVOKED|ACCESS_DENIED|SCOPE_CHANGED/.test(message) ? "access-denied"
         : /CLOSED/.test(message) ? "closed"
             : status === 409 || /REVISION_CONFLICT|PROJECTION_CHANGED/.test(message) ? "conflict"
                 : /BACKPRESSURE|TOO_LARGE/.test(message) ? "busy"

package/lib/runtime/chatSession.d.ts

@@ -16,6 +16,7 @@ import { unreadInConversation } from "./readIndex.js";
 import type { StoredMessage } from "./messageStore.js";
 import type { ChatRuntimeMessage } from "./protocol.js";
 export type ChatSessionOptions<T extends StoredMessage> = {
+    onDispose?: () => void;
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
     sharedConnection?: ChatClient;

package/lib/runtime/chatSession.js

@@ -907,6 +907,7 @@ export class ChatSession {
                     throw failed.reason;
             }
             finally {
+                this.options.onDispose?.();
                 this.listeners.clear();
                 this.globalListeners.clear();
                 this.readingListeners.clear();

package/lib/runtime/createChat.d.ts

@@ -1,3 +1,4 @@
+import { type TokenProvider } from "../credentials.js";
 import { ChatSession } from "./chatSession.js";
 import type { ChatClient, ChatClientOptions } from "./chatClient.js";
 import { type CachedChatMessage } from "./cachedMessage.js";
@@ -7,7 +8,8 @@ export type CreateChatOptions = {
     accountId: string;
     profileId: string;
     teamId: string;
-    token: string;
+    token?: string;
+    getToken?: TokenProvider;
     /** Limit reconnect reconciliation for a dedicated conversation document. */
     threadId?: string;
     uploadEndpoint?: string;
@@ -21,4 +23,6 @@ export type CreateChatOptions = {
     onReach?: ChatClientOptions["onReach"];
 };
 /** Standard browser entry: storage, paging, realtime and reading share one identity. */
-export declare function createChat(options: CreateChatOptions): ChatSession<CachedChatMessage>;
+export declare function createChatSession(options: CreateChatOptions): ChatSession<CachedChatMessage>;
+/** @deprecated Advanced compatibility factory. Use /chat createChat, or createChatSession for raw sessions. */
+export declare const createChat: typeof createChatSession;

package/lib/runtime/createChat.js

@@ -1,3 +1,4 @@
+import { ChatCredentials } from "../credentials.js";
 import { voiceUploader } from "./voiceUpload.js";
 import { isOffline } from "./connectivity.js";
 import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
@@ -6,20 +7,26 @@ import { SocialReadClient } from "./socialReadClient.js";
 import { isValidChatTeamId } from "./thread.js";
 import { decodeCachedChatMessage } from "./cachedMessage.js";
 /** Standard browser entry: storage, paging, realtime and reading share one identity. */
-export function createChat(options) {
-    const { appId, accountId, profileId, teamId, token, onError } = options;
+export function createChatSession(options) {
+    const { appId, accountId, profileId, teamId, onError } = options;
+    const token = options.token ?? "";
+    if (!token && !options.getToken)
+        throw new Error("INVALID_CHAT_CREDENTIALS");
     if (!isValidChatTeamId(teamId))
         throw new Error("INVALID_CHAT_TEAM");
     const endpoint = (options.endpoint ?? "https://hub.pmate.chat").replace(/\/+$/, "");
     const http = endpoint.replace(/^ws/, "http"), ws = endpoint.replace(/^http/, "ws");
-    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: options.fetch });
+    const credentials = options.getToken ? new ChatCredentials(options.getToken, new URL(http).origin, options.fetch) : undefined;
+    const fetcher = credentials?.fetch ?? options.fetch;
+    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: fetcher });
     const page = async (threadId, signal, cursor = {}) => {
         const result = await reader.messagePage({ threadId, teamId, limit: 100, ...cursor }, signal);
         return { ...result, messages: result.messages.map(message => ({ ...message, id: message.messageId, timestamp: message.serverCreatedAt })) };
     };
     return new ChatSession({
         sharedConnection: options.connection,
-        uploadVoice: voiceUploader(profileId, options.uploadEndpoint, options.fetch),
+        onDispose: () => credentials?.close(),
+        uploadVoice: voiceUploader(profileId, options.uploadEndpoint, fetcher),
         reconcileOutgoing: async (record, signal) => {
             if (isOffline())
                 throw new Error("OUTBOX_RECONCILIATION_OFFLINE");
@@ -35,8 +42,9 @@ export function createChat(options) {
         loadGroup: (groupId, signal) => reader.group({ groupId, teamId }, signal),
         activeThreadId: options.threadId,
         messages: { scope: { appId, accountId, profileId, teamId }, transport: { authorizeScope: async (signal) => { await reader.contacts(teamId, signal); }, load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
-        reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
-        connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,
+        reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: fetcher, onError },
+        connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: fetcher,
+            getToken: credentials?.getToken,
             session: { token, identity: { accountId, app: appId, profileId } }, onNotification: options.onNotification, onReach: options.onReach },
         readingCandidate: message => {
             if (isReadingControl(message.body, appId))
@@ -50,3 +58,5 @@ export function createChat(options) {
         decode: message => decodeCachedChatMessage(message, { appId, profileId, teamId }), onError,
     });
 }
+/** @deprecated Advanced compatibility factory. Use /chat createChat, or createChatSession for raw sessions. */
+export const createChat = createChatSession;

package/lib/runtime/readCounts.js

@@ -51,7 +51,7 @@ export class ReadCountsClient {
         const scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
         const response = await (this.options.fetch ?? fetch)(`${this.options.hubHttpUrl.replace(/\/$/, "")}${path}`, { method: "POST", headers: { authorization: `Bearer ${this.options.token}`, "content-type": "application/json" }, body: JSON.stringify(body), signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(8000)]) : AbortSignal.timeout(8000), redirect: "error" });
         if (!response.ok)
-            throw new Error(`READ_COUNTS_HTTP_${response.status}`);
+            throw Object.assign(new Error(`READ_COUNTS_HTTP_${response.status}`), { status: response.status });
         const envelope = await response.json();
         if (envelope.success !== true)
             throw new Error("INVALID_READ_COUNTS_RESPONSE");

package/lib/runtime/readSync.js

@@ -40,7 +40,7 @@ export class ReadSyncClient {
                 ...init, signal: timeout.signal, headers: { ...init.headers, authorization: `Bearer ${this.options.sessionToken}` },
             });
             if (!response.ok)
-                throw new Error(`READ_SYNC_HTTP_${response.status}`);
+                throw Object.assign(new Error(`READ_SYNC_HTTP_${response.status}`), { status: response.status });
             const envelope = await response.json();
             if (envelope.success !== true || envelope.data === undefined)
                 throw new Error("INVALID_READ_SYNC_RESPONSE");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.68",
+  "version": "0.12.0-next.69",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",
@@ -33,6 +33,21 @@
       "types": "./lib/chat.d.ts",
       "import": "./lib/chat.js",
       "default": "./lib/chat.js"
+    },
+    "./advanced": {
+      "types": "./lib/advanced.d.ts",
+      "import": "./lib/advanced.js",
+      "default": "./lib/advanced.js"
+    },
+    "./framework": {
+      "types": "./lib/framework.d.ts",
+      "import": "./lib/framework.js",
+      "default": "./lib/framework.js"
+    },
+    "./history": {
+      "types": "./lib/history.d.ts",
+      "import": "./lib/history.js",
+      "default": "./lib/history.js"
     }
   },
   "publishConfig": {