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

package/README.md

@@ -138,50 +138,65 @@ to the SDK. The default API presents one semantic message list, including delive
 recalls and reactions. It never presents a partial migration as a ready window.
 
 ```ts
-import {createChat, ChatError} from "@pmate/chat-sdk/chat"
-const chat = createChat({appId, accountId, profileId, teamId, token, onError})
-await chat.start() // also handles an optional shared calls/presence connection
-
-// Existing conversations already have a threadId. For a new conversation:
-const threadId = await chat.getConversation({peerId}) // or {groupId}
-try {
-  await chat.getMessages(threadId)
-  openThread(threadId) // cold failure leaves the usable conversation list in place
-} catch (error) {
-  if (error instanceof ChatError && error.retryable) showRetry()
-}
-const off = chat.subscribe(threadId, state => render(state.messages))
+import {createChat} from "@pmate/chat-sdk/chat"
+const chat = createChat({appId, accountId, profileId, teamId,
+  getToken: ({forceRefresh, signal}) => auth.getAccessToken({forceRefresh, signal}),
+})
+await chat.start()
+const threadId = await chat.resolveThreadId({peerId}) // or {groupId}; no remote creation
+const off = chat.subscribeThread(threadId, state => {
+  if (state.status === "ready") render(state.messages)
+  else if (state.status === "error") showRetry(state.error)
+}) // listens first, opens local state, then owns background synchronization
 await chat.sendMessage(threadId, {text: "Hello"})
-await chat.getMessages(threadId, {earlier: true})
+await chat.loadEarlier(threadId)
 off()
 await chat.close()
 ```
 
-`getMessages` returns the same stable snapshot as `getSnapshot` and `subscribe`.
-It resolves with a trusted recent window, or rejects with `ChatError`; Apps do not
-check coverage or select local/remote sources. `{earlier:true}` extends the SDK's
-current window without timestamps, limits or cursors; `{all:true}` traverses
-accessible history and rejects if the scan is incomplete. A failed history scan
-can leave the already trusted recent window usable. Cache hits do not repeat
-history requests. Reconnection and browser wake reconcile newer changes.
-
-A thread snapshot contains `threadId`, one renderable `messages` list, `ready`,
-`hasEarlier`, `unread`, `group`, `readCounts`, optional `conversation` target identity,
-and optional `error`. Target identity survives recalls without exposing redacted
-message bodies. `ready` helps
-route entry and startup before the first read; it is not a cache-source indicator.
-`getSnapshot()` and `subscribe(listener)` provide conversation summaries, aggregate
-unread counts and connection state. Unknown unread counts remain `undefined`.
-Subscription always emits the current snapshot first, including with
-`{fields:["messages","unread"]}`, then meaningful changes only. Messages expose `kind`, `text`, optional `image`,
-`voice`, `quote`, explicit `richContent`, semantic `reactions` and reading/delivery
-state. Apps do not inspect transport bodies or control-event revisions. Group
-causal version numbers and raw message records remain under `advanced`.
-`observeMessages` and `markRead` resolve with `void` after durable submission.
-Object references
-remain stable for unchanged results. Framework adapters can use
-`{emitCurrent:false}`; React can import `useChatSnapshot(chat, threadId)` from
-`@pmate/chat-sdk`. Establishing a subscription never starts a read or marks it read.
+`getThread(id)` is the one-shot equivalent; it returns the same stable snapshot
+as `subscribeThread`. Cache hits do not repeat history requests. `loadEarlier(id)`
+extends the SDK window without limits or cursors. `refreshThread(id)` explicitly
+reconciles authority; ordinary reconnect/wake synchronization is automatic.
+For a cold route, keep the usable list visible until `getThread` resolves, or
+until a subscription delivers `status: "ready"`; no intermediate message loader
+is necessary. Subscription initialization has four bounded concurrent lanes.
+Multiple consumers share work; disposing one does not stop another consumer.
+
+Thread state is `pending`, `ready`, or `error`. A failed initial read is `error`;
+a failed background refresh retains `ready` messages and includes `error`.
+`ready` is retained as a derived compatibility field; use `status` in new code.
+Connection state is independent. A snapshot also contains `hasEarlier`, `unread`,
+`group`, `readCounts` and scoped target identity. Unknown unread stays undefined.
+`subscribeChat` delivers known conversation summaries and aggregate reading state.
+Subscriptions emit their current snapshot first, then meaningful changes only;
+`fields` filters notifications. Callbacks cannot corrupt a shared cache read.
+Opening or subscribing does not mark messages read.
+
+Messages provide kind/text/image/voice/quote, reactions and reading/delivery state.
+No raw wire or control revision is needed. The public models do not derive their
+types from Session, storage or projection internals. Object references stay stable
+when content has not changed. React `useChatSnapshot(chat, threadId)` manages the
+external-store subscription; custom integrations use `getChatStore` from
+`@pmate/chat-sdk/framework`, where synchronous memory snapshots and change-only
+notifications are explicitly separated from ordinary asynchronous reads.
+
+`getThread`, `loadEarlier`, `refreshThread`, `getGroup`, `refreshGroup`,
+`resolveThreadId`, and `getVoiceAttachment` accept `{signal}`. Reader queries accept
+`{afterProfileId, revision, signal}`. Aborting rejects that consumer with the signal
+reason (normally AbortError); it does not abort shared work, publish a fake cache
+failure, or undo a durable send. A late abandoned voice lease is released.
+Complete-history search/export is an explicit, potentially large operation:
+`loadThreadHistory(chat, id, {signal})` from `@pmate/chat-sdk/history`. It traverses
+accessible history and rejects incomplete scans. It is not a flag on normal reads.
+
+The credential provider is invoked on connection/reconnection and authenticated
+HTTP reads; concurrent requests share acquisition. HTTP 401 gets one coalesced
+forced refresh and at most one replay. HTTP 403 is never retried automatically.
+Providers must preserve account/app/profile identity. A fixed `token` remains
+supported as an alternative; select one source. An ambiguous WebSocket AUTH_FAILED
+requires authentication rather than guessing that a permission failure expired.
+Closing fences late providers and prevents further authenticated network work.
 
 Sending accepts text/mentions/quotes, images, voice, recalls, reactions and
 invitations through the same typed content union. The SDK resolves the target
@@ -217,35 +232,28 @@ wait for confirmed delivery and a causal server version. SDK-owned requests shar
 bounded queues and time windows; Apps do not poll. `watchReaders(threadId,ids,receiver)`
 selects receipt counts for the current viewport; clear with `watchReaders(undefined,[])`.
 
-`ChatError` exposes `code`, `retryable`, optional HTTP `status`, and the original
-`cause`. Recovery categories are `unavailable`, `access-denied`,
-`storage-unavailable`, `invalid-input`, `conflict`, `closed`, and `busy`.
-Permission failures withdraw the current scoped session and retire its caches;
-failed cleanup remains in the error cause. They never turn into trusted offline
-data. Dispose and recreate
-the SDK when account, profile, team or token changes.
+`ChatError` exposes code, retryable, optional HTTP status and cause. Categories are
+unavailable, authentication-required, access-denied, storage-unavailable,
+invalid-input, conflict, closed and busy. Token expiry requires authentication;
+a 403 withdraws the scoped session and its caches. Account/profile/team changes
+require a new SDK instance. Token renewal alone uses the provider.
 
 ### Advanced integration and migration
 
-`chat.advanced` exposes the underlying `ChatSession` for one-time legacy imports,
-custom transports and diagnostics. Its `messages` are raw records, `timeline` is
-the semantic projection, and `complete/resetVersion` describe coverage internals.
-The older `createChat` export from `@pmate/chat-sdk/runtime` retains this low-level
-contract for compatibility. New Apps should import from `@pmate/chat-sdk/chat`
-or the package root. Do not mix the two snapshot contracts.
-
-For migration, replace `subscribe(id, () => render(getSnapshot(id).timeline))`
-with `subscribe(id, state => render(state.messages))`; replace
-`item.message.body` parsing with `item.kind/text/image/voice/quote`; replace conversation
-objects and App-supplied recipients with `threadId`; await `getMessages` before
-opening a cold thread instead of checking `page.complete`. Replace `initialize()`
-with `start()`; a shared connection is initialized without another connect call.
-Raw wire sends are available only through `advanced.sendMessage`. Group changes
-use `createGroup/updateGroup`; UI never assigns reaction versions or recipients.
-
-The advanced storage and transport classes remain exported from `/runtime`.
-They must share one authenticated scope and must not bypass scope authority.
-Normal UI code should not maintain another message cache or outbox.
+The default client has no `advanced`, `getSnapshot`, `getMessages`, `getConversation`
+or generic `subscribe`. Use resolveThreadId, getThread, subscribeThread,
+loadEarlier and refreshThread. Public readers no longer accept a separate fourth
+signal argument. Use `{signal}` together with the query instead.
+
+Host-owned calls/presence transports use `createChatWithTransport` from
+`@pmate/chat-sdk/advanced`; it returns the same public client. `getChatRuntime(chat)`
+provides explicit one-time migration/diagnostic access. `handleChatReach` and
+`revokeChatAccess` are advanced integration helpers. A deprecated
+`getLegacyChat(chat)` adapter is available only from this entry during migration.
+The raw factory is named `createChatSession` in `/runtime`; its old `createChat`
+name is deprecated. Raw storage/transport clients remain advanced capabilities.
+They must share identity and respect scope authority. Apps do not maintain a second
+message cache, outbox, recipient roster or control revision generator.
 
 ### Reading storage recovery
 

package/lib/advanced.d.ts

@@ -0,0 +1,10 @@
+import type { Chat } from "./chatContract.js";
+import type { CreateChatOptions } from "./runtime/createChat.js";
+/** Host-owned transport integration. The default factory never accepts raw transports. */
+export declare function createChatWithTransport(options: CreateChatOptions): Chat;
+/** Explicit migration/diagnostic access, outside the ordinary client. */
+export declare function getChatRuntime(chat: Chat): import("./runtime/chatSession.js").ChatSession<import("./runtime/cachedMessage.js").CachedChatMessage>;
+export declare function handleChatReach(chat: Chat, event: Parameters<ReturnType<typeof getChatRuntime>["handleReach"]>[0]): Promise<"handled" | undefined>;
+export declare function revokeChatAccess(chat: Chat): Promise<void>;
+/** @deprecated Transitional next.68 adapter. New App code must use the public client. */
+export declare function getLegacyChat(chat: Chat): import("./internal/chatEngine.js").ChatEngine;

package/lib/advanced.js

@@ -0,0 +1,10 @@
+import { createPublicChat } from "./internal/createPublicChat.js";
+import { chatEngine } from "./internal/chatRegistry.js";
+/** Host-owned transport integration. The default factory never accepts raw transports. */
+export function createChatWithTransport(options) { return createPublicChat(options); }
+/** Explicit migration/diagnostic access, outside the ordinary client. */
+export function getChatRuntime(chat) { return chatEngine(chat).advanced; }
+export function handleChatReach(chat, event) { return chatEngine(chat).handleReach(event); }
+export function revokeChatAccess(chat) { return chatEngine(chat).revokeAccess(); }
+/** @deprecated Transitional next.68 adapter. New App code must use the public client. */
+export function getLegacyChat(chat) { return chatEngine(chat); }

package/lib/chat.d.ts

@@ -1,131 +1,5 @@
-import type { ChatGroup as RuntimeGroup } from "./runtime/groupClient.js";
-import { type ChatMessage } from "./messageView.js";
-export type { ChatMessage } from "./messageView.js";
-import { type CreateChatOptions } from "./runtime/createChat.js";
-import type { ChatSession, ChatSummarySnapshot as SessionSummary, ChatThreadSnapshot as SessionThread } from "./runtime/chatSession.js";
-import type { CachedChatMessage } from "./runtime/cachedMessage.js";
-import type { ConversationTarget } from "./runtime/conversationDirectory.js";
-import type { OutgoingContent as RuntimeContent } from "./runtime/outgoingContent.js";
-import { ChatError } from "./runtime/chatError.js";
-export { ChatError } from "./runtime/chatError.js";
-export type { ChatErrorCode } from "./runtime/chatError.js";
-export type { CreateChatOptions, ConversationTarget };
-export type OutgoingContent = Exclude<RuntimeContent, {
-    groupCreate: unknown;
-} | {
-    groupUpdate: unknown;
-}>;
-export type ChatGroup = Readonly<Omit<RuntimeGroup, "versionNumber">>;
-export type ConversationInfo = Readonly<{
-    kind: "dm" | "group";
-    targetId: string;
-}>;
-export type ChatThreadSnapshot = Readonly<{
-    threadId: string;
-    messages: readonly ChatMessage[];
-    ready: boolean;
-    hasEarlier: boolean;
-    conversation?: ConversationInfo;
-    unread: SessionThread<CachedChatMessage>["unread"];
-    group: ChatGroup | undefined;
-    readCounts: SessionThread<CachedChatMessage>["readCounts"];
-    error?: ChatError;
-}>;
-export type ChatSnapshot = Readonly<{
-    threads: readonly {
-        threadId: string;
-        lastMessage?: ChatMessage;
-        group: ChatGroup | undefined;
-        unread: ChatThreadSnapshot["unread"];
-        outgoingCount: number;
-    }[];
-    unreadMessageCount: number | undefined;
-    badgeCount: number | undefined;
-    connection: SessionSummary<CachedChatMessage>["connection"];
-}>;
-export type MessageQuery = {
-    earlier?: boolean;
-    all?: boolean;
-    refresh?: boolean;
-};
-export type ReadersQuery = {
-    afterProfileId?: string;
-    revision?: number;
-};
-export type GroupChanges = {
-    expectedRevision?: string;
-    addMembers?: readonly string[];
-    removeMembers?: readonly string[];
-    title?: string;
-    avatar?: string;
-};
-export type SendOptions = {
-    waitFor?: "accepted" | "delivered";
-};
-export type SentMessage = Readonly<{
-    id: string;
-    timestamp: number;
-}>;
-type SubscribeOptions<T> = {
-    fields?: readonly (keyof T)[];
-    emitCurrent?: boolean;
-};
-/** App-facing API. Cache coverage, raw protocol and synchronization stay in advanced. */
-export declare class Chat {
-    readonly advanced: ChatSession<CachedChatMessage>;
-    private options;
-    private groups;
-    private group;
-    private present;
-    private redactedQuotes;
-    private messageLists;
-    private messages;
-    private views;
-    private summary?;
-    private targets;
-    private errors;
-    private listeners;
-    private closed;
-    constructor(advanced: ChatSession<CachedChatMessage>, options: CreateChatOptions);
-    private operation;
-    private deny;
-    private threadOperation;
-    start(): Promise<void>;
-    getConversation(target: ConversationTarget): Promise<string>;
-    getSnapshot(): ChatSnapshot;
-    getSnapshot(threadId: string): ChatThreadSnapshot;
-    getMessages(threadId: string, query?: MessageQuery): Promise<ChatThreadSnapshot>;
-    sendMessage(threadId: string, content: OutgoingContent, options?: SendOptions): Promise<SentMessage>;
-    retryMessage(messageId: string): Promise<SentMessage>;
-    subscribe(listener: (snapshot: ChatSnapshot) => void, options?: SubscribeOptions<ChatSnapshot>): () => void;
-    subscribe(threadId: string, listener: (snapshot: ChatThreadSnapshot) => void, options?: SubscribeOptions<ChatThreadSnapshot>): () => void;
-    private sessionFields;
-    private notify;
-    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): Promise<void>;
-    markRead(threadId: string): Promise<void>;
-    getReaders(threadId: string, messageId: string, page?: ReadersQuery, signal?: AbortSignal): Promise<import("./runtime/messageReaders.js").MessageReadersPage>;
-    watchReaders(threadId: string | undefined, ids: string[], receiver?: string): Promise<void>;
-    handleReach(event: Parameters<ChatSession<CachedChatMessage>["handleReach"]>[0]): Promise<"handled" | undefined>;
-    getVoiceAttachment(threadId: string, messageId: string): Promise<import("./runtime/durableSender.js").VoiceAttachmentLease>;
-    getGroup(threadId: string, options?: {
-        refresh?: boolean;
-    }): Promise<Readonly<Omit<RuntimeGroup, "versionNumber">>>;
-    createGroup(input: {
-        groupId?: string;
-        title: string;
-        members: readonly string[];
-    }): Promise<{
-        threadId: string;
-        revision: string;
-        teamId: string;
-        title: string;
-        groupId: string;
-        avatar?: string;
-        ownerId: string;
-        memberIds: readonly string[];
-    }>;
-    updateGroup(threadId: string, changes: GroupChanges): Promise<Readonly<Omit<RuntimeGroup, "versionNumber">>>;
-    revokeAccess(): Promise<void>;
-    close(): Promise<void>;
-}
+import type { Chat, CreateChatOptions } from "./chatContract.js";
+export type * from "./chatContract.js";
+export type * from "./chatTypes.js";
+export { ChatError, type ChatErrorCode } from "./chatError.js";
 export declare function createChat(options: CreateChatOptions): Chat;

package/lib/chat.js

@@ -1,219 +1,11 @@
-import { createMessagePresenter } from "./messageView.js";
-import { createChat as createSession } from "./runtime/createChat.js";
-import { asChatError, ChatError } from "./runtime/chatError.js";
-export { ChatError } from "./runtime/chatError.js";
-const emptyMessages = Object.freeze([]);
-/** App-facing API. Cache coverage, raw protocol and synchronization stay in advanced. */
-export class Chat {
-    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()); }
-    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 };
-        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)
-                (global ? target : callback)(value);
-        };
-        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" ? ["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.views.clear(); this.summary = undefined; this.present = createMessagePresenter(); this.messageLists = new WeakMap(); this.groups = new WeakMap(); this.redactedQuotes = new WeakMap(); }); }
-}
+import { createPublicChat } from "./internal/createPublicChat.js";
+import { ChatError } from "./chatError.js";
+export { ChatError } from "./chatError.js";
 export function createChat(options) {
-    const configured = { ...options, onError: (error) => options.onError(asChatError(error)) };
-    return new Chat(createSession(configured), configured);
+    const allowed = ["appId", "accountId", "profileId", "teamId", "threadId", "endpoint", "uploadEndpoint", "clientInstanceId", "fetch", "onError", "token", "getToken"];
+    if (Object.keys(options).some(key => !allowed.includes(key)))
+        throw new ChatError("invalid-input", "Unsupported chat option; transport integration belongs to /advanced");
+    if (options.token !== undefined && options.getToken !== undefined)
+        throw new ChatError("invalid-input", "Select one credential source");
+    return createPublicChat({ ...options, onError: error => options.onError?.(error) });
 }