@oxpulse/chat-sdk 0.1.0

package/dist/client.js

@@ -0,0 +1,639 @@
+/**
+ * SDKChatClient — standalone npm package implementation.
+ *
+ * This is a standalone copy of the HTTP client for use by third-party
+ * integrations that import @oxpulse/chat-sdk directly.  The SvelteKit
+ * front-end uses web/src/lib/api/sdkChat.ts (same semantics, same wire
+ * protocol) — kept separate to avoid pulling in SvelteKit build tooling.
+ *
+ * W4 skeleton: full implementation mirrors web/src/lib/api/sdkChat.ts.
+ * Publishing to npmjs.org is deferred to W8 (embed widget wave).
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SDKChatClient_instances, _SDKChatClient_baseUrl, _SDKChatClient_jwt, _SDKChatClient_compression, _SDKChatClient_minCompressBytes, _SDKChatClient_dictHint, _SDKChatClient_ready, _SDKChatClient_encodeBody, _SDKChatClient_fetchSubscribeTicket;
+import { ensureWireCodecReady, encodeHttpBody, decodeHttpBody, setDictLoader, setDictBaseUrl, asWireBytes, } from '@oxpulse/wire-codec';
+import { SDKChatError } from './errors.js';
+import { arrayBufferToBase64url, base64ToArrayBuffer, httpStatusToCode, backoffMs, dispatchTransient, } from './utils.js';
+function dtoToRoom(dto) {
+    return {
+        appId: dto.app_id,
+        roomId: dto.room_id,
+        title: dto.title,
+        productRef: dto.product_ref,
+        createdBy: dto.created_by,
+        createdAt: dto.created_at,
+        archivedAt: dto.archived_at,
+        metadata: dto.metadata,
+        members: dto.members.map(dtoToMember),
+    };
+}
+function dtoToMember(dto) {
+    return {
+        appId: dto.app_id,
+        roomId: dto.room_id,
+        userId: dto.user_id,
+        role: dto.role,
+        joinedAt: dto.joined_at,
+        lastReadSeq: dto.last_read_seq,
+        active: dto.active,
+    };
+}
+// ─── Client ───────────────────────────────────────────────────────────────────
+const DEFAULT_MIN_COMPRESS_BYTES = 256;
+export class SDKChatClient {
+    constructor(opts) {
+        _SDKChatClient_instances.add(this);
+        _SDKChatClient_baseUrl.set(this, void 0);
+        _SDKChatClient_jwt.set(this, void 0);
+        _SDKChatClient_compression.set(this, void 0);
+        _SDKChatClient_minCompressBytes.set(this, void 0);
+        _SDKChatClient_dictHint.set(this, void 0);
+        _SDKChatClient_ready.set(this, null);
+        if (opts.jwt.startsWith('Bearer ')) {
+            throw new SDKChatError('invalid_args', 'jwt must not include the "Bearer " prefix');
+        }
+        __classPrivateFieldSet(this, _SDKChatClient_baseUrl, opts.baseUrl.replace(/\/$/, ''), "f");
+        __classPrivateFieldSet(this, _SDKChatClient_jwt, opts.jwt, "f");
+        __classPrivateFieldSet(this, _SDKChatClient_compression, opts.compression ?? 'none', "f");
+        __classPrivateFieldSet(this, _SDKChatClient_minCompressBytes, opts.minCompressBytes ?? DEFAULT_MIN_COMPRESS_BYTES, "f");
+        __classPrivateFieldSet(this, _SDKChatClient_dictHint, opts.dictHint ?? 'zstd-dict-ru-v1', "f");
+        if (__classPrivateFieldGet(this, _SDKChatClient_compression, "f") !== 'none') {
+            // Configure loader before ensureWireCodecReady so dicts are preloaded correctly.
+            if (opts.dictLoader !== undefined) {
+                setDictLoader(opts.dictLoader);
+            }
+            else if (opts.dictBaseUrl !== undefined) {
+                setDictBaseUrl(opts.dictBaseUrl);
+            }
+            // Kick off zstd init + dict preload lazily. Awaited before first send.
+            __classPrivateFieldSet(this, _SDKChatClient_ready, ensureWireCodecReady(), "f");
+        }
+    }
+    /**
+     * Encode a payload to the bytes that would be sent on the wire, without sending.
+     * Mirrors the encoding _encodeBody applies to POST /api/sdk/messages.
+     */
+    async encodeEnvelope(payload) {
+        return __classPrivateFieldGet(this, _SDKChatClient_instances, "m", _SDKChatClient_encodeBody).call(this, payload);
+    }
+    /**
+     * Decode bytes received from the server back to the JSON payload.
+     * Server responses are always plain JSON; this also handles wire-codec
+     * compressed frames for completeness (round-trip with encodeEnvelope).
+     *
+     * Note: #compression governs OUTGOING encoding only. A server may send a
+     * compressed frame (0xC6/0xC7) regardless of the client's compression setting.
+     * decodeEnvelope checks the first byte directly and initializes zstd if needed.
+     */
+    async decodeEnvelope(bytes) {
+        if (typeof bytes === 'string') {
+            return JSON.parse(bytes);
+        }
+        if (bytes.length === 0)
+            throw new SDKChatError('server_error', 'decodeEnvelope: empty input');
+        const first = bytes[0];
+        if (first === 0x7b || first === 0x5b) {
+            // Plain JSON bytes — no zstd needed.
+            return JSON.parse(new TextDecoder().decode(bytes));
+        }
+        // Compressed frame (0xC6/0xC7): ensure zstd is ready regardless of #compression setting.
+        // #compression controls outgoing encoding only; server may compress responses independently.
+        if (first === 0xc6 || first === 0xc7) {
+            if (__classPrivateFieldGet(this, _SDKChatClient_ready, "f") !== null) {
+                await __classPrivateFieldGet(this, _SDKChatClient_ready, "f");
+                __classPrivateFieldSet(this, _SDKChatClient_ready, null, "f");
+            }
+            else {
+                // #compression is 'none' — zstd not pre-initialized; initialize on demand.
+                await ensureWireCodecReady();
+            }
+        }
+        return decodeHttpBody(asWireBytes(bytes));
+    }
+    async send(roomId, args) {
+        const msgId = args.msgId ?? crypto.randomUUID();
+        const payload = {
+            room_id: roomId,
+            msg_id: msgId,
+            sender_uid: args.senderUid,
+            sealed_b64: arrayBufferToBase64url(args.sealed),
+        };
+        if (args.threadRootMsgId !== undefined) {
+            payload['thread_root_msg_id'] = args.threadRootMsgId;
+        }
+        const body = await __classPrivateFieldGet(this, _SDKChatClient_instances, "m", _SDKChatClient_encodeBody).call(this, payload);
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': typeof body === 'string' ? 'application/json' : 'application/octet-stream',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: body,
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', String(err));
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `send failed: HTTP ${resp.status}`, resp.status);
+        }
+        const json = (await resp.json());
+        return { seq: json.seq, msgId: json.msg_id };
+    }
+    async list(roomId, args = {}) {
+        const params = new URLSearchParams({
+            room_id: roomId,
+            after_seq: String(args.afterSeq ?? 0),
+            limit: String(args.limit ?? 50),
+        });
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/messages?${params}`, {
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', String(err));
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `list failed: HTTP ${resp.status}`, resp.status);
+        }
+        const json = (await resp.json());
+        return json.map((row) => ({
+            seq: row.seq,
+            msgId: row.msg_id,
+            senderUid: row.sender_uid,
+            sealed: base64ToArrayBuffer(row.sealed_b64),
+            createdAt: row.created_at,
+            threadRootMsgId: row.thread_root_msg_id ?? null,
+            productRef: row.product_ref ?? null,
+            productMeta: row.product_meta ?? null,
+        }));
+    }
+    subscribe(roomId, args) {
+        let destroyed = false;
+        let lastSeq = 0;
+        let es = null;
+        const attach = (ticket) => {
+            if (destroyed)
+                return;
+            const url = `${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/messages/subscribe?ticket=${encodeURIComponent(ticket)}&after_seq=${lastSeq}`;
+            es = new EventSource(url);
+            es.onmessage = (ev) => {
+                try {
+                    const data = JSON.parse(ev.data);
+                    // W6: dispatch transient events that arrive on the default channel.
+                    if (data.type && data.type !== 'message') {
+                        dispatchTransient(data.type, data, args);
+                        return;
+                    }
+                    lastSeq = data.seq;
+                    args.onMessage({
+                        seq: data.seq,
+                        msgId: data.msg_id,
+                        senderUid: data.sender_uid,
+                        sealed: base64ToArrayBuffer(data.sealed_b64),
+                        createdAt: data.created_at,
+                        threadRootMsgId: data.thread_root_msg_id ?? null,
+                        productRef: data.product_ref ?? null,
+                        productMeta: data.product_meta ?? null,
+                    });
+                }
+                catch {
+                    // Malformed frame — ignore.
+                }
+            };
+            // W6: named SSE events for transient channel.
+            const transientTypes = ['typing', 'presence', 'read_receipt'];
+            for (const evType of transientTypes) {
+                es.addEventListener(evType, (ev) => {
+                    const msgEv = ev;
+                    try {
+                        const data = JSON.parse(msgEv.data);
+                        dispatchTransient(evType, data, args);
+                    }
+                    catch {
+                        // Malformed frame — ignore.
+                    }
+                });
+            }
+            es.onerror = () => {
+                es?.close();
+                es = null;
+                if (destroyed)
+                    return;
+                reconnect(0);
+            };
+        };
+        // dispatchTransient imported from utils.ts — single source of truth
+        // shared with web/src/lib/api/sdkChat.ts. See packages/chat-sdk/src/utils.ts.
+        let reconnectTimer = null;
+        const reportError = (err) => {
+            if (!args.onError)
+                return;
+            const sdkErr = err instanceof SDKChatError
+                ? err
+                : new SDKChatError('network', `subscribe internal error: ${String(err)}`);
+            args.onError(sdkErr);
+        };
+        const reconnect = (attempt) => {
+            const delay = backoffMs(attempt);
+            reconnectTimer = setTimeout(async () => {
+                reconnectTimer = null;
+                if (destroyed)
+                    return;
+                try {
+                    const missed = await this.list(roomId, { afterSeq: lastSeq });
+                    for (const row of missed) {
+                        lastSeq = row.seq;
+                        args.onMessage(row);
+                    }
+                }
+                catch (err) {
+                    // Surface replay failures to caller; will still retry on next reconnect.
+                    reportError(err);
+                }
+                if (destroyed)
+                    return;
+                let ticket;
+                try {
+                    ticket = await __classPrivateFieldGet(this, _SDKChatClient_instances, "m", _SDKChatClient_fetchSubscribeTicket).call(this, roomId, lastSeq);
+                }
+                catch (err) {
+                    // Retry with backoff on ticket failure; surface error.
+                    reportError(err);
+                    reconnect(attempt + 1);
+                    return;
+                }
+                attach(ticket);
+            }, delay);
+        };
+        // Initial connection: fetch ticket then open EventSource.
+        (async () => {
+            if (destroyed)
+                return;
+            let ticket;
+            try {
+                ticket = await __classPrivateFieldGet(this, _SDKChatClient_instances, "m", _SDKChatClient_fetchSubscribeTicket).call(this, roomId, lastSeq);
+            }
+            catch (err) {
+                reportError(err);
+                reconnect(0);
+                return;
+            }
+            attach(ticket);
+        })();
+        return () => {
+            destroyed = true;
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            es?.close();
+            es = null;
+        };
+    }
+    // ── W6: Typing / Presence / Read receipts ─────────────────────────────────
+    /**
+     * Broadcast a typing indicator for roomId.
+     * Wire-contract: POST /api/sdk/rooms/:room_id/typing
+     * Body: { ttl_secs? }
+     */
+    async sendTyping(roomId, ttlSecs) {
+        const body = {};
+        if (ttlSecs !== undefined)
+            body['ttl_secs'] = ttlSecs;
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/typing`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `sendTyping failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `sendTyping failed: HTTP ${resp.status}`, resp.status);
+        }
+    }
+    /**
+     * Send a presence heartbeat for roomId.
+     * Wire-contract: POST /api/sdk/rooms/:room_id/presence
+     * Body: {}
+     */
+    async sendPresence(roomId) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/presence`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: JSON.stringify({}),
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `sendPresence failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `sendPresence failed: HTTP ${resp.status}`, resp.status);
+        }
+    }
+    /**
+     * Fetch presence snapshot for roomId.
+     * Wire-contract: GET /api/sdk/rooms/:room_id/presence
+     * Returns: Array<PresenceUser>
+     */
+    async getPresence(roomId) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/presence`, {
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `getPresence failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `getPresence failed: HTTP ${resp.status}`, resp.status);
+        }
+        const arr = (await resp.json());
+        // Wire-contract assertion: each entry must have user_id.
+        return arr.map((entry) => {
+            if (!Object.prototype.hasOwnProperty.call(entry, 'user_id')) {
+                throw new SDKChatError('server_error', 'getPresence: entry missing user_id');
+            }
+            return { userId: entry.user_id, lastSeenAt: entry.last_seen_at };
+        });
+    }
+    /**
+     * Mark messages up to seq as read (monotonic — cannot regress).
+     * Wire-contract: POST /api/sdk/rooms/:room_id/read?seq=N
+     */
+    async markRead(roomId, seq) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/read?seq=${seq}`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `markRead failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `markRead failed: HTTP ${resp.status}`, resp.status);
+        }
+    }
+    // ── W5: Room management ────────────────────────────────────────────────────
+    /**
+     * Create a room. Idempotent per roomId.
+     * Wire-contract: POST /api/sdk/rooms
+     */
+    async createRoom(args = {}) {
+        const body = {};
+        if (args.roomId !== undefined)
+            body['room_id'] = args.roomId;
+        if (args.title !== undefined)
+            body['title'] = args.title;
+        if (args.productRef !== undefined)
+            body['product_ref'] = args.productRef;
+        if (args.metadata !== undefined)
+            body['metadata'] = args.metadata;
+        if (args.initialMembers !== undefined) {
+            body['initial_members'] = args.initialMembers.map((m) => ({
+                user_id: m.userId,
+                role: m.role,
+            }));
+        }
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `createRoom failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `createRoom failed: HTTP ${resp.status}`, resp.status);
+        }
+        const dto = (await resp.json());
+        // Wire-contract assertion: room_id must be present.
+        if (!Object.prototype.hasOwnProperty.call(dto, 'room_id')) {
+            throw new SDKChatError('server_error', 'createRoom: response missing room_id');
+        }
+        return dtoToRoom(dto);
+    }
+    /**
+     * Fetch room metadata + active members.
+     * Wire-contract: GET /api/sdk/rooms/:room_id
+     */
+    async getRoom(roomId) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}`, {
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `getRoom failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `getRoom failed: HTTP ${resp.status}`, resp.status);
+        }
+        const dto = (await resp.json());
+        if (!Object.prototype.hasOwnProperty.call(dto, 'room_id')) {
+            throw new SDKChatError('server_error', 'getRoom: response missing room_id');
+        }
+        return dtoToRoom(dto);
+    }
+    /**
+     * Update room title / metadata. Owner-only.
+     * Wire-contract: PATCH /api/sdk/rooms/:room_id
+     */
+    async updateRoom(roomId, args) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}`, {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: JSON.stringify(args),
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `updateRoom failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `updateRoom failed: HTTP ${resp.status}`, resp.status);
+        }
+        const dto = (await resp.json());
+        if (!Object.prototype.hasOwnProperty.call(dto, 'room_id')) {
+            throw new SDKChatError('server_error', 'updateRoom: response missing room_id');
+        }
+        return dtoToRoom(dto);
+    }
+    /**
+     * List active members of a room (fetches room and returns members).
+     */
+    async listMembers(roomId) {
+        const room = await this.getRoom(roomId);
+        return room.members;
+    }
+    /**
+     * Add a user to a room.
+     * Wire-contract: POST /api/sdk/rooms/:room_id/members
+     * Body: { user_id, role? }
+     */
+    async addMember(roomId, userId, role = 'member') {
+        const body = { user_id: userId, role };
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/members`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `addMember failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `addMember failed: HTTP ${resp.status}`, resp.status);
+        }
+        const dto = (await resp.json());
+        // Wire-contract assertion: user_id must be present.
+        if (!Object.prototype.hasOwnProperty.call(dto, 'user_id')) {
+            throw new SDKChatError('server_error', 'addMember: response missing user_id');
+        }
+        return dtoToMember(dto);
+    }
+    /**
+     * Remove a user from a room (soft-delete).
+     * Wire-contract: DELETE /api/sdk/rooms/:room_id/members/:user_id
+     */
+    async removeMember(roomId, userId) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/members/${encodeURIComponent(userId)}`, {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `removeMember failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `removeMember failed: HTTP ${resp.status}`, resp.status);
+        }
+    }
+    // ── W7: Thread view ────────────────────────────────────────────────────────
+    /**
+     * Fetch all reply messages in a thread.
+     * Wire-contract: GET /api/sdk/rooms/:room_id/threads/:root_msg_id
+     * Returns: Array<MessageRow> sorted by seq ascending (server-side ORDER BY seq).
+     * Requires scope: chat:read:<room_id>.
+     */
+    async getThread(roomId, rootMsgId) {
+        let resp;
+        try {
+            resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/rooms/${encodeURIComponent(roomId)}/threads/${encodeURIComponent(rootMsgId)}`, {
+                headers: { Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}` },
+            });
+        }
+        catch (err) {
+            throw new SDKChatError('network', `getThread failed: ${String(err)}`);
+        }
+        if (!resp.ok) {
+            throw new SDKChatError(httpStatusToCode(resp.status), `getThread failed: HTTP ${resp.status}`, resp.status);
+        }
+        const json = (await resp.json());
+        return json.map((row) => ({
+            seq: row.seq,
+            msgId: row.msg_id,
+            senderUid: row.sender_uid,
+            sealed: base64ToArrayBuffer(row.sealed_b64),
+            createdAt: row.created_at,
+            threadRootMsgId: row.thread_root_msg_id ?? null,
+            productRef: row.product_ref ?? null,
+            productMeta: row.product_meta ?? null,
+        }));
+    }
+}
+_SDKChatClient_baseUrl = new WeakMap(), _SDKChatClient_jwt = new WeakMap(), _SDKChatClient_compression = new WeakMap(), _SDKChatClient_minCompressBytes = new WeakMap(), _SDKChatClient_dictHint = new WeakMap(), _SDKChatClient_ready = new WeakMap(), _SDKChatClient_instances = new WeakSet(), _SDKChatClient_encodeBody = 
+/** Encode payload bytes for POST /api/sdk/messages per the configured compression mode.
+ *  Returns a string for plain JSON (Content-Type: application/json) or
+ *  Uint8Array for compressed frames (Content-Type: application/octet-stream). */
+async function _SDKChatClient_encodeBody(payload) {
+    if (__classPrivateFieldGet(this, _SDKChatClient_compression, "f") === 'none') {
+        return JSON.stringify(payload);
+    }
+    // Ensure zstd is ready before first compressed send.
+    if (__classPrivateFieldGet(this, _SDKChatClient_ready, "f") !== null) {
+        await __classPrivateFieldGet(this, _SDKChatClient_ready, "f");
+        __classPrivateFieldSet(this, _SDKChatClient_ready, null, "f");
+    }
+    const jsonStr = JSON.stringify(payload);
+    const enc = new TextEncoder();
+    const jsonBytes = enc.encode(jsonStr);
+    if (jsonBytes.length < __classPrivateFieldGet(this, _SDKChatClient_minCompressBytes, "f")) {
+        // Below threshold — fall back to plain JSON regardless of mode.
+        return jsonStr;
+    }
+    if (__classPrivateFieldGet(this, _SDKChatClient_compression, "f") === 'dict') {
+        // encodeHttpBody falls back to dictless 0xC6 automatically if dict not loaded.
+        return encodeHttpBody(jsonBytes, __classPrivateFieldGet(this, _SDKChatClient_dictHint, "f"));
+    }
+    // 'auto': dictless 0xC6
+    return encodeHttpBody(jsonBytes);
+}, _SDKChatClient_fetchSubscribeTicket = async function _SDKChatClient_fetchSubscribeTicket(roomId, afterSeq) {
+    let resp;
+    try {
+        resp = await fetch(`${__classPrivateFieldGet(this, _SDKChatClient_baseUrl, "f")}/api/sdk/messages/subscribe-ticket`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${__classPrivateFieldGet(this, _SDKChatClient_jwt, "f")}`,
+            },
+            body: JSON.stringify({ room_id: roomId, after_seq: afterSeq }),
+        });
+    }
+    catch (err) {
+        throw new SDKChatError('network', `subscribe-ticket fetch failed: ${String(err)}`);
+    }
+    if (!resp.ok) {
+        throw new SDKChatError(httpStatusToCode(resp.status), `subscribe-ticket HTTP ${resp.status}`, resp.status);
+    }
+    const body = (await resp.json());
+    return body.ticket;
+};
+//# sourceMappingURL=client.js.map