@lasersell/lasersell-sdk 0.1.0

package/dist/stream/client.js

@@ -0,0 +1,995 @@
+import WebSocket from "ws";
+import { clientMessageToText, serverMessageFromText, } from "./proto.js";
+const MIN_RECONNECT_BACKOFF_MS = 100;
+const MAX_RECONNECT_BACKOFF_MS = 2_000;
+export const STREAM_ENDPOINT = "wss://stream.lasersell.io/v1/ws";
+export const LOCAL_STREAM_ENDPOINT = "ws://localhost:8082/v1/ws";
+export function singleWalletStreamConfigure(walletPubkey, strategy, deadlineTimeoutSec) {
+    return {
+        wallet_pubkeys: [walletPubkey],
+        strategy,
+        deadline_timeout_sec: deadlineTimeoutSec,
+    };
+}
+export function strategyConfigFromOptional(strategy = {}) {
+    return {
+        target_profit_pct: strategy.target_profit_pct ?? 0,
+        stop_loss_pct: strategy.stop_loss_pct ?? 0,
+    };
+}
+export function singleWalletStreamConfigureOptional(walletPubkey, strategy = {}, deadlineTimeoutSec = 0) {
+    return {
+        wallet_pubkeys: [walletPubkey],
+        strategy: strategyConfigFromOptional(strategy),
+        deadline_timeout_sec: deadlineTimeoutSec,
+    };
+}
+export class StreamClientError extends Error {
+    kind;
+    constructor(kind, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "StreamClientError";
+        this.kind = kind;
+    }
+    static websocket(cause) {
+        return new StreamClientError("websocket", `websocket error: ${stringifyError(cause)}`, cause);
+    }
+    static json(cause) {
+        return new StreamClientError("json", `json error: ${stringifyError(cause)}`, cause);
+    }
+    static invalidApiKeyHeader(cause) {
+        return new StreamClientError("invalid_api_key_header", `invalid api-key header: ${stringifyError(cause)}`, cause);
+    }
+    static sendQueueClosed() {
+        return new StreamClientError("send_queue_closed", "send queue is closed");
+    }
+    static protocol(message) {
+        return new StreamClientError("protocol", `protocol error: ${message}`);
+    }
+}
+export class StreamClient {
+    apiKey;
+    local = false;
+    endpointOverride;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    withLocalMode(local) {
+        this.local = local;
+        return this;
+    }
+    withEndpoint(endpoint) {
+        this.endpointOverride = endpoint.trimEnd();
+        return this;
+    }
+    async connect(configure) {
+        validateStrategyAndDeadline(configure.strategy, configure.deadline_timeout_sec ?? 0);
+        const worker = new StreamConnectionWorker(this.endpoint(), this.apiKey, configure);
+        await worker.waitReady();
+        return new StreamConnection(worker);
+    }
+    async connectLanes(configure, options = {}) {
+        validateStrategyAndDeadline(configure.strategy, configure.deadline_timeout_sec ?? 0);
+        const worker = new StreamConnectionWorker(this.endpoint(), this.apiKey, configure, {
+            inboundMode: "lanes",
+            lowPriorityCapacity: options.lowPriorityCapacity,
+        });
+        await worker.waitReady();
+        return new StreamConnectionLanes(worker);
+    }
+    endpoint() {
+        if (this.endpointOverride !== undefined) {
+            return this.endpointOverride;
+        }
+        if (this.local) {
+            return LOCAL_STREAM_ENDPOINT;
+        }
+        return STREAM_ENDPOINT;
+    }
+}
+export function validateStrategyAndDeadline(strategy, deadlineTimeoutSec) {
+    validateStrategyValue(strategy.target_profit_pct, "strategy.target_profit_pct");
+    validateStrategyValue(strategy.stop_loss_pct, "strategy.stop_loss_pct");
+    const deadline = Number(deadlineTimeoutSec);
+    if (!Number.isFinite(deadline)) {
+        throw StreamClientError.protocol("deadline_timeout_sec must be a finite number");
+    }
+    if (deadline < 0) {
+        throw StreamClientError.protocol("deadline_timeout_sec must be >= 0");
+    }
+    if (strategy.target_profit_pct > 0 ||
+        strategy.stop_loss_pct > 0 ||
+        deadline > 0) {
+        return;
+    }
+    throw StreamClientError.protocol("at least one of strategy.target_profit_pct, strategy.stop_loss_pct, or deadline_timeout_sec must be > 0");
+}
+function validateStrategyValue(value, field) {
+    if (!Number.isFinite(value)) {
+        throw StreamClientError.protocol(`${field} must be a finite number`);
+    }
+    if (value < 0) {
+        throw StreamClientError.protocol(`${field} must be >= 0`);
+    }
+}
+export class StreamConnection {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    sender() {
+        return new StreamSender(this.worker);
+    }
+    split() {
+        return [this.sender(), new StreamReceiver(this.worker)];
+    }
+    async recv() {
+        return await this.worker.recv();
+    }
+    close() {
+        this.worker.close();
+    }
+}
+export class StreamConnectionLanes {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    sender() {
+        return new StreamSender(this.worker);
+    }
+    highReceiver() {
+        return new StreamHighReceiver(this.worker);
+    }
+    lowReceiver() {
+        return new StreamLowReceiver(this.worker);
+    }
+    split() {
+        return [this.sender(), this.highReceiver(), this.lowReceiver()];
+    }
+    close() {
+        this.worker.close();
+    }
+}
+export class StreamHighReceiver {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    async recv() {
+        return await this.worker.recvHigh();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const message = await this.recv();
+            if (message === null) {
+                break;
+            }
+            yield message;
+        }
+    }
+}
+export class StreamLowReceiver {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    async recv() {
+        return await this.worker.recvLow();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const message = await this.recv();
+            if (message === null) {
+                break;
+            }
+            yield message;
+        }
+    }
+}
+export class StreamReceiver {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    async recv() {
+        return await this.worker.recv();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const message = await this.recv();
+            if (message === null) {
+                break;
+            }
+            yield message;
+        }
+    }
+}
+export class StreamSender {
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    send(message) {
+        this.worker.enqueue(message);
+    }
+    ping(client_time_ms) {
+        this.send({
+            type: "ping",
+            client_time_ms,
+        });
+    }
+    updateStrategy(strategy) {
+        this.send({
+            type: "update_strategy",
+            strategy,
+        });
+    }
+    closePosition(selector) {
+        this.send(closeMessage(normalizePositionSelector(selector)));
+    }
+    closeById(positionId) {
+        this.closePosition({ position_id: positionId });
+    }
+    requestExitSignal(selector, slippage_bps) {
+        this.send(requestExitSignalMessage(normalizePositionSelector(selector), slippage_bps));
+    }
+    requestExitSignalById(positionId, slippage_bps) {
+        this.requestExitSignal({ position_id: positionId }, slippage_bps);
+    }
+}
+function closeMessage(selector) {
+    if ("token_account" in selector) {
+        return {
+            type: "close_position",
+            token_account: selector.token_account,
+        };
+    }
+    return {
+        type: "close_position",
+        position_id: selector.position_id,
+    };
+}
+function requestExitSignalMessage(selector, slippageBps) {
+    if ("token_account" in selector) {
+        return {
+            type: "request_exit_signal",
+            token_account: selector.token_account,
+            slippage_bps: slippageBps,
+        };
+    }
+    return {
+        type: "request_exit_signal",
+        position_id: selector.position_id,
+        slippage_bps: slippageBps,
+    };
+}
+function normalizePositionSelector(selector) {
+    if (typeof selector === "string") {
+        return {
+            token_account: selector,
+        };
+    }
+    if (typeof selector === "number") {
+        return {
+            position_id: selector,
+        };
+    }
+    if ("token_account" in selector && typeof selector.token_account === "string") {
+        return {
+            token_account: selector.token_account,
+        };
+    }
+    if ("position_id" in selector && typeof selector.position_id === "number") {
+        return {
+            position_id: selector.position_id,
+        };
+    }
+    if ("tokenAccount" in selector && typeof selector.tokenAccount === "string") {
+        return {
+            token_account: selector.tokenAccount,
+        };
+    }
+    if ("positionId" in selector && typeof selector.positionId === "number") {
+        return {
+            position_id: selector.positionId,
+        };
+    }
+    throw StreamClientError.protocol("position selector must be token account string or position id number");
+}
+class StreamConnectionWorker {
+    endpoint;
+    apiKey;
+    configure;
+    inboundMode;
+    inboundCombined;
+    inboundHigh;
+    inboundLow;
+    outbound = new AsyncQueue();
+    currentSocket = null;
+    stopped = false;
+    readyPromise;
+    readySettled = false;
+    resolveReady;
+    rejectReady;
+    constructor(endpoint, apiKey, configure, options = {}) {
+        this.endpoint = endpoint;
+        this.apiKey = apiKey;
+        this.configure = configure;
+        this.inboundMode = options.inboundMode ?? "combined";
+        if (this.inboundMode === "combined") {
+            this.inboundCombined = new AsyncQueue();
+        }
+        else {
+            this.inboundHigh = new AsyncQueue();
+            this.inboundLow = new AsyncQueue({
+                maxLen: options.lowPriorityCapacity ?? 1024,
+                dropOldest: true,
+            });
+        }
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = (error) => {
+                reject(error);
+            };
+        });
+        void this.run();
+    }
+    async waitReady() {
+        return await this.readyPromise;
+    }
+    enqueue(message) {
+        if (this.stopped) {
+            throw StreamClientError.sendQueueClosed();
+        }
+        this.outbound.push(message);
+    }
+    async recv() {
+        if (this.inboundCombined === undefined) {
+            throw StreamClientError.protocol("recv() is not available for lane-mode connections; use StreamConnectionLanes receivers");
+        }
+        return await this.inboundCombined.shift();
+    }
+    async recvHigh() {
+        if (this.inboundHigh === undefined) {
+            throw StreamClientError.protocol("recvHigh() is only available for lane-mode connections");
+        }
+        return await this.inboundHigh.shift();
+    }
+    async recvLow() {
+        if (this.inboundLow === undefined) {
+            throw StreamClientError.protocol("recvLow() is only available for lane-mode connections");
+        }
+        return await this.inboundLow.shift();
+    }
+    close() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.outbound.close();
+        if (this.currentSocket !== null) {
+            safeClose(this.currentSocket);
+        }
+    }
+    async run() {
+        let backoffMs = MIN_RECONNECT_BACKOFF_MS;
+        while (!this.stopped) {
+            try {
+                const outcome = await this.runConnectedSession();
+                if (outcome === "graceful_shutdown") {
+                    break;
+                }
+                backoffMs = MIN_RECONNECT_BACKOFF_MS;
+            }
+            catch (error) {
+                const mapped = asStreamClientError(error);
+                if (!this.readySettled) {
+                    this.setReadyError(mapped);
+                    break;
+                }
+            }
+            if (this.stopped) {
+                break;
+            }
+            const shouldContinue = await sleepWithStop(backoffMs, () => this.stopped);
+            if (!shouldContinue) {
+                break;
+            }
+            backoffMs = Math.min(backoffMs * 2, MAX_RECONNECT_BACKOFF_MS);
+        }
+        if (!this.readySettled) {
+            this.setReadyError(StreamClientError.sendQueueClosed());
+        }
+        this.stopped = true;
+        this.outbound.close();
+        this.closeInbound();
+    }
+    async runConnectedSession() {
+        const { socket, frames } = await openSocket(this.endpoint, this.apiKey);
+        this.currentSocket = socket;
+        try {
+            const firstServerMessage = await recvServerMessageBeforeConfigure(socket, frames);
+            if (firstServerMessage.type !== "hello_ok") {
+                throw StreamClientError.protocol("expected first server message to be hello_ok");
+            }
+            this.pushInbound(firstServerMessage);
+            const configureMessage = {
+                type: "configure",
+                wallet_pubkeys: [...this.configure.wallet_pubkeys],
+                strategy: { ...this.configure.strategy },
+            };
+            await sendClientMessage(socket, configureMessage);
+            const configuredMessage = await recvServerMessageAfterConfigure(socket, frames);
+            this.pushInbound(configuredMessage);
+            if (!this.readySettled) {
+                this.readySettled = true;
+                this.resolveReady();
+            }
+            while (!this.stopped) {
+                const nextOutbound = this.outbound.shiftNow();
+                if (nextOutbound !== undefined) {
+                    try {
+                        await sendClientMessage(socket, nextOutbound);
+                        continue;
+                    }
+                    catch {
+                        return "reconnect";
+                    }
+                }
+                const frame = frames.shiftNow();
+                if (frame !== undefined) {
+                    const outcome = await this.handleFrame(socket, frame);
+                    if (outcome === "reconnect") {
+                        return "reconnect";
+                    }
+                    continue;
+                }
+                const outboundWait = this.outbound.shiftCancelable();
+                const frameWait = frames.waitNextCancelable();
+                const next = await Promise.race([
+                    outboundWait.promise.then((message) => ({
+                        source: "outbound",
+                        message,
+                    })),
+                    frameWait.promise.then((nextFrame) => ({
+                        source: "frame",
+                        frame: nextFrame,
+                    })),
+                ]);
+                if (next.source === "outbound") {
+                    frameWait.cancel();
+                    if (next.message === null) {
+                        return "graceful_shutdown";
+                    }
+                    try {
+                        await sendClientMessage(socket, next.message);
+                        continue;
+                    }
+                    catch {
+                        return "reconnect";
+                    }
+                }
+                outboundWait.cancel();
+                const outcome = await this.handleFrame(socket, next.frame);
+                if (outcome === "reconnect") {
+                    return "reconnect";
+                }
+            }
+            return "graceful_shutdown";
+        }
+        finally {
+            this.currentSocket = null;
+            safeClose(socket);
+        }
+    }
+    async handleFrame(socket, frame) {
+        switch (frame.kind) {
+            case "text": {
+                let parsed;
+                try {
+                    parsed = serverMessageFromText(frame.text);
+                }
+                catch {
+                    return "reconnect";
+                }
+                this.pushInbound(parsed);
+                return "continue";
+            }
+            case "ping": {
+                try {
+                    socket.pong(frame.payload);
+                }
+                catch {
+                    return "reconnect";
+                }
+                return "continue";
+            }
+            case "pong": {
+                return "continue";
+            }
+            case "binary":
+            case "close":
+            case "error": {
+                return "reconnect";
+            }
+            default: {
+                const _unreachable = frame;
+                return _unreachable;
+            }
+        }
+    }
+    setReadyError(error) {
+        if (this.readySettled) {
+            return;
+        }
+        this.readySettled = true;
+        this.rejectReady(error);
+    }
+    pushInbound(message) {
+        if (this.inboundMode === "combined") {
+            this.inboundCombined.push(message);
+            return;
+        }
+        if (message.type === "pnl_update") {
+            this.inboundLow.push(message);
+        }
+        else {
+            this.inboundHigh.push(message);
+        }
+    }
+    closeInbound() {
+        this.inboundCombined?.close();
+        this.inboundHigh?.close();
+        this.inboundLow?.close();
+    }
+}
+async function openSocket(url, apiKey) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let socket;
+        try {
+            socket = new WebSocket(url, {
+                headers: {
+                    "x-api-key": apiKey,
+                },
+            });
+        }
+        catch (error) {
+            reject(StreamClientError.invalidApiKeyHeader(error));
+            return;
+        }
+        // Attach frame listeners before waiting for `open` so we never miss an
+        // immediate server hello frame on low-latency links.
+        const frames = new WebSocketFrameQueue(socket);
+        const onOpen = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve({ socket, frames });
+        };
+        const onError = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(StreamClientError.websocket(error));
+        };
+        const onClose = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(StreamClientError.protocol("socket closed before open"));
+        };
+        const cleanup = () => {
+            socket.off("open", onOpen);
+            socket.off("error", onError);
+            socket.off("close", onClose);
+        };
+        socket.on("open", onOpen);
+        socket.on("error", onError);
+        socket.on("close", onClose);
+    });
+}
+async function recvServerMessageBeforeConfigure(socket, frames) {
+    while (true) {
+        const frame = await frames.waitNext();
+        switch (frame.kind) {
+            case "text": {
+                try {
+                    return serverMessageFromText(frame.text);
+                }
+                catch (error) {
+                    throw StreamClientError.json(error);
+                }
+            }
+            case "ping": {
+                socket.pong(frame.payload);
+                break;
+            }
+            case "pong": {
+                break;
+            }
+            case "close": {
+                throw StreamClientError.protocol("socket closed before hello_ok");
+            }
+            case "error": {
+                throw StreamClientError.websocket(frame.error);
+            }
+            case "binary": {
+                throw StreamClientError.protocol("received non-text frame before hello_ok");
+            }
+            default: {
+                const _unreachable = frame;
+                throw _unreachable;
+            }
+        }
+    }
+}
+async function recvServerMessageAfterConfigure(socket, frames) {
+    while (true) {
+        const frame = await frames.waitNext();
+        switch (frame.kind) {
+            case "text": {
+                try {
+                    return serverMessageFromText(frame.text);
+                }
+                catch (error) {
+                    throw StreamClientError.json(error);
+                }
+            }
+            case "ping": {
+                socket.pong(frame.payload);
+                break;
+            }
+            case "pong": {
+                break;
+            }
+            case "close": {
+                throw StreamClientError.protocol("socket closed before configure acknowledgement");
+            }
+            case "error": {
+                throw StreamClientError.websocket(frame.error);
+            }
+            case "binary": {
+                throw StreamClientError.protocol("received non-text frame before configure acknowledgement");
+            }
+            default: {
+                const _unreachable = frame;
+                throw _unreachable;
+            }
+        }
+    }
+}
+async function sendClientMessage(socket, message) {
+    const text = clientMessageToText(message);
+    await new Promise((resolve, reject) => {
+        socket.send(text, (error) => {
+            if (error) {
+                reject(StreamClientError.websocket(error));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function safeClose(socket) {
+    if (socket.readyState === WebSocket.CLOSING ||
+        socket.readyState === WebSocket.CLOSED) {
+        return;
+    }
+    socket.close();
+}
+class Deque {
+    buffer;
+    head = 0;
+    len = 0;
+    mask;
+    constructor(initialCapacity = 16) {
+        const cap = nextPowerOfTwo(Math.max(2, initialCapacity));
+        this.buffer = new Array(cap);
+        this.mask = cap - 1;
+    }
+    get length() {
+        return this.len;
+    }
+    push(value) {
+        if (this.len === this.buffer.length) {
+            this.grow();
+        }
+        const index = (this.head + this.len) & this.mask;
+        this.buffer[index] = value;
+        this.len += 1;
+    }
+    unshift(value) {
+        if (this.len === this.buffer.length) {
+            this.grow();
+        }
+        this.head = (this.head - 1) & this.mask;
+        this.buffer[this.head] = value;
+        this.len += 1;
+    }
+    shift() {
+        if (this.len === 0) {
+            return undefined;
+        }
+        const value = this.buffer[this.head];
+        this.buffer[this.head] = undefined;
+        this.head = (this.head + 1) & this.mask;
+        this.len -= 1;
+        return value;
+    }
+    grow() {
+        const old = this.buffer;
+        const newCap = old.length * 2;
+        const next = new Array(newCap);
+        for (let i = 0; i < this.len; i += 1) {
+            next[i] = old[(this.head + i) & this.mask];
+        }
+        this.buffer = next;
+        this.head = 0;
+        this.mask = newCap - 1;
+    }
+}
+function nextPowerOfTwo(value) {
+    let v = Math.max(2, Math.floor(value));
+    v -= 1;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    return v + 1;
+}
+class WebSocketFrameQueue {
+    frames = new Deque();
+    waiters = [];
+    constructor(socket) {
+        socket.on("message", (data, isBinary) => {
+            if (isBinary) {
+                this.push({ kind: "binary" });
+                return;
+            }
+            const text = rawDataToString(data);
+            this.push({ kind: "text", text });
+        });
+        socket.on("ping", (payload) => {
+            this.push({
+                kind: "ping",
+                payload: rawDataToBuffer(payload),
+            });
+        });
+        socket.on("pong", (payload) => {
+            this.push({
+                kind: "pong",
+                payload: rawDataToBuffer(payload),
+            });
+        });
+        socket.on("close", (code, reason) => {
+            this.push({
+                kind: "close",
+                code,
+                reason: reason.toString("utf8"),
+            });
+        });
+        socket.on("error", (error) => {
+            this.push({ kind: "error", error });
+        });
+    }
+    shiftNow() {
+        return this.frames.shift();
+    }
+    waitNextCancelable() {
+        const next = this.shiftNow();
+        if (next !== undefined) {
+            return {
+                promise: Promise.resolve(next),
+                cancel: () => { },
+            };
+        }
+        let waiter;
+        const promise = new Promise((resolve) => {
+            waiter = {
+                canceled: false,
+                hasValue: false,
+                value: null,
+                settled: false,
+                resolve,
+            };
+            this.waiters.push(waiter);
+        });
+        const cancel = () => {
+            if (waiter === undefined || waiter.canceled) {
+                return;
+            }
+            waiter.canceled = true;
+            if (!waiter.settled) {
+                const index = this.waiters.indexOf(waiter);
+                if (index >= 0) {
+                    this.waiters.splice(index, 1);
+                }
+                return;
+            }
+            if (waiter.hasValue && waiter.value !== null) {
+                this.frames.unshift(waiter.value);
+                waiter.hasValue = false;
+                waiter.value = null;
+            }
+        };
+        return { promise, cancel };
+    }
+    async waitNext() {
+        const { promise } = this.waitNextCancelable();
+        return await promise;
+    }
+    push(frame) {
+        const waiter = this.waiters.shift();
+        if (waiter !== undefined) {
+            waiter.settled = true;
+            waiter.hasValue = true;
+            waiter.value = frame;
+            waiter.resolve(frame);
+            return;
+        }
+        this.frames.push(frame);
+    }
+}
+class AsyncQueue {
+    items = new Deque();
+    waiters = [];
+    closed = false;
+    maxLen;
+    dropOldest;
+    constructor(options) {
+        this.maxLen = options?.maxLen;
+        this.dropOldest = options?.dropOldest ?? false;
+    }
+    push(item) {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter !== undefined) {
+            waiter.settled = true;
+            waiter.hasValue = true;
+            waiter.value = item;
+            waiter.resolve(item);
+            return;
+        }
+        if (this.maxLen !== undefined && this.items.length >= this.maxLen) {
+            if (this.dropOldest) {
+                this.items.shift();
+            }
+            else {
+                return;
+            }
+        }
+        this.items.push(item);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            if (waiter !== undefined) {
+                waiter.settled = true;
+                waiter.hasValue = true;
+                waiter.value = null;
+                waiter.resolve(null);
+            }
+        }
+    }
+    shiftNow() {
+        return this.items.shift();
+    }
+    shiftCancelable() {
+        const next = this.shiftNow();
+        if (next !== undefined) {
+            return {
+                promise: Promise.resolve(next),
+                cancel: () => { },
+            };
+        }
+        if (this.closed) {
+            return {
+                promise: Promise.resolve(null),
+                cancel: () => { },
+            };
+        }
+        let waiter;
+        const promise = new Promise((resolve) => {
+            waiter = {
+                canceled: false,
+                hasValue: false,
+                value: null,
+                settled: false,
+                resolve,
+            };
+            this.waiters.push(waiter);
+        });
+        const cancel = () => {
+            if (waiter === undefined || waiter.canceled) {
+                return;
+            }
+            waiter.canceled = true;
+            if (!waiter.settled) {
+                const index = this.waiters.indexOf(waiter);
+                if (index >= 0) {
+                    this.waiters.splice(index, 1);
+                }
+                return;
+            }
+            if (waiter.hasValue && waiter.value !== null && !this.closed) {
+                this.items.unshift(waiter.value);
+                waiter.hasValue = false;
+                waiter.value = null;
+            }
+        };
+        return { promise, cancel };
+    }
+    async shift() {
+        const { promise } = this.shiftCancelable();
+        return await promise;
+    }
+}
+function rawDataToString(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    return rawDataToBuffer(data).toString("utf8");
+}
+function rawDataToBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data);
+    }
+    const value = data;
+    if (value instanceof ArrayBuffer) {
+        return Buffer.from(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+    throw StreamClientError.protocol("unexpected websocket raw data frame");
+}
+function asStreamClientError(error) {
+    if (error instanceof StreamClientError) {
+        return error;
+    }
+    return StreamClientError.websocket(error);
+}
+async function sleepWithStop(ms, shouldStop) {
+    const intervalMs = 20;
+    let remaining = ms;
+    while (remaining > 0) {
+        if (shouldStop()) {
+            return false;
+        }
+        const step = Math.min(intervalMs, remaining);
+        await sleep(step);
+        remaining -= step;
+    }
+    return !shouldStop();
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function stringifyError(error) {
+    if (error instanceof Error) {
+        return `${error.name}: ${error.message}`;
+    }
+    return String(error);
+}
+//# sourceMappingURL=client.js.map