@lifi/perps-sdk 0.0.0-preview-64fca0d

package/dist/types/websocket/ReconnectingWebSocket.d.ts

@@ -0,0 +1,130 @@
+import type { WsConnectionStatus, WsStatusListener } from './types.js';
+type WsEventMap = {
+    open: () => void;
+    close: (code: number, reason: string) => void;
+    error: (error: Event) => void;
+    message: (data: string) => void;
+};
+type WsEvent = keyof WsEventMap;
+/**
+ * Options for {@link ReconnectingWebSocket}.
+ *
+ * @public
+ */
+export interface ReconnectingWebSocketOptions {
+    maxRetries?: number;
+    pingIntervalMs?: number;
+    /**
+     * Keepalive frame sent every `pingIntervalMs` while the socket is open.
+     * Framing is venue-specific, so when omitted no keepalive is sent.
+     */
+    pingPayload?: string;
+    /**
+     * Stale-stream watchdog window. With `pingPayload` configured, the socket is
+     * force-reconnected when no inbound frame arrives within this window.
+     * Defaults to 3× `pingIntervalMs`.
+     */
+    staleWindowMs?: number;
+}
+/**
+ * A `WebSocket` transport that auto-reconnects with jittered exponential
+ * backoff (`partysocket` internals), buffers sends (bounded) while
+ * disconnected, keepalive-pings with the caller-supplied `pingPayload`, and
+ * force-reconnects a silently stale stream. Surfaces the
+ * {@link WsConnectionStatus} state machine: `reconnecting` on transient drops,
+ * terminal `disconnected` once the retry budget is exhausted.
+ *
+ * @public
+ */
+export declare class ReconnectingWebSocket {
+    private readonly socket;
+    private readonly maxRetries;
+    private readonly pingIntervalMs;
+    private readonly pingPayload;
+    private readonly staleWindowMs;
+    private closed;
+    private reconnectRequested;
+    private lastCloseRetryCount;
+    private pingTimer;
+    private staleTimer;
+    private listeners;
+    private statusListeners;
+    private status;
+    private readyResolvers;
+    constructor(url: string, options?: ReconnectingWebSocketOptions);
+    private handleOpen;
+    private handleClose;
+    private handleError;
+    private handleMessage;
+    private setStatus;
+    private callListener;
+    private startPing;
+    private stopPing;
+    private armWatchdog;
+    private clearWatchdog;
+    /**
+     * Send `data`, buffering it (bounded) for replay when the socket is not yet
+     * open.
+     *
+     * @public
+     */
+    send(data: string): void;
+    /**
+     * Permanently close the socket and suppress further reconnection.
+     *
+     * @public
+     */
+    close(): void;
+    /**
+     * Drop the current connection (if any) and reconnect with a fresh retry
+     * budget. Recovers a socket that reached terminal `disconnected`: status
+     * returns to `reconnecting` and the normal backoff cycle restarts.
+     *
+     * @public
+     */
+    reconnect(): void;
+    /**
+     * Register a listener for a socket lifecycle event.
+     *
+     * @public
+     */
+    on<E extends WsEvent>(event: E, fn: WsEventMap[E]): void;
+    /**
+     * Remove a previously registered lifecycle-event listener.
+     *
+     * @public
+     */
+    off<E extends WsEvent>(event: E, fn: WsEventMap[E]): void;
+    /**
+     * Current connection health. `reconnecting` until the first open;
+     * `disconnected` once auto-reconnect is abandoned (terminal until
+     * {@link ReconnectingWebSocket.reconnect} is called).
+     *
+     * @public
+     */
+    getStatus(): WsConnectionStatus;
+    /**
+     * Register a connection-health listener. Fires on every status transition,
+     * including the terminal `disconnected` emitted on reconnect exhaustion.
+     *
+     * @public
+     */
+    onStatus(fn: WsStatusListener): void;
+    /**
+     * Remove a previously registered connection-health listener.
+     *
+     * @public
+     */
+    offStatus(fn: WsStatusListener): void;
+    /**
+     * Resolve once the socket is open; reject if it closes or exhausts retries
+     * before opening. When the socket is already terminally dead — `close()`d or
+     * reconnect-exhausted (`disconnected`) — rejects immediately rather than
+     * queuing a waiter nothing would ever settle.
+     *
+     * @public
+     */
+    ready(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ReconnectingWebSocket.d.ts.map

package/dist/types/websocket/ReconnectingWebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReconnectingWebSocket.d.ts","sourceRoot":"","sources":["../../../src/websocket/ReconnectingWebSocket.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAGtE,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7C,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC7B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAChC,CAAA;AAED,KAAK,OAAO,GAAG,MAAM,UAAU,CAAA;AAyB/B;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;;GASG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,SAAS,CAKhB;IACD,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,cAAc,CAGf;gBAEK,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,4BAA4B;IAyB/D,OAAO,CAAC,UAAU,CAWjB;IAED,OAAO,CAAC,WAAW,CA4BlB;IAED,OAAO,CAAC,WAAW,CAIlB;IAED,OAAO,CAAC,aAAa,CAOpB;IAED,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,aAAa;IAOrB;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM;IAIjB;;;;OAIG;IACH,KAAK;IAWL;;;;;;OAMG;IACH,SAAS;IAWT;;;;OAIG;IACH,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC;IAIjD;;;;OAIG;IACH,GAAG,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC;IAIlD;;;;;;OAMG;IACH,SAAS,IAAI,kBAAkB;IAI/B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,gBAAgB;IAI7B;;;;OAIG;IACH,SAAS,CAAC,EAAE,EAAE,gBAAgB;IAI9B;;;;;;;OAOG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAcvB"}

package/dist/types/websocket/WsProviderBase.d.ts

@@ -0,0 +1,89 @@
+import type { Subscription, SubscriptionEvent } from '@lifi/perps-types';
+import type { ProviderGetQuoteParams, QuoteListener } from '../types/provider.js';
+import type { ReconnectingWebSocket } from './ReconnectingWebSocket.js';
+import type { SubscriptionListener, WsProvider, WsStatusListener } from './types.js';
+/**
+ * Linger before tearing a channel off the wire after its last listener
+ * releases. A re-subscribe to the same key within this window cancels the
+ * pending teardown, so React StrictMode's synchronous unmount→remount (ref
+ * count 1→0→1) and fast route flips collapse to one wire subscription rather
+ * than a subscribe→unsubscribe→subscribe churn the venue would reject.
+ *
+ * @public
+ */
+export declare const WS_CHANNEL_TEARDOWN_LINGER_MS = 250;
+/**
+ * Base for per-provider realtime transports. Owns the {@link
+ * ReconnectingWebSocket}, the fan-out lifecycle — ref-counted multi-listener
+ * subscription per channel key, deferred teardown, status fan-out — so any
+ * number of consumers (and StrictMode double-mounts) collapse to exactly one
+ * wire subscribe/unsubscribe per key, and the wire-subscription registry:
+ * subs recorded via {@link WsProviderBase.registerSub} are sent only while
+ * connected and replayed (failure-isolated) on every (re)open. Subclasses own
+ * everything wire-specific via {@link WsProviderBase.openChannel}, {@link
+ * WsProviderBase.sendSubscribe} and {@link WsProviderBase.handleMessage}:
+ * payload framing, frame validation and dispatch.
+ *
+ * `TSub` is the per-subscription state {@link WsProviderBase.sendSubscribe}
+ * needs to (re)build one subscribe frame.
+ *
+ * @public
+ */
+export declare abstract class WsProviderBase<TSub = unknown> implements WsProvider {
+    protected readonly rws: ReconnectingWebSocket;
+    protected readonly providerKey: string;
+    private readonly channels;
+    private readonly statusListeners;
+    private readonly wireSubs;
+    constructor(rws: ReconnectingWebSocket, providerKey: string);
+    subscribe(sub: Subscription, listener: SubscriptionListener, onStatus?: WsStatusListener): Promise<() => void>;
+    reconnect(): void;
+    close(): void;
+    /** Deliver an event to every listener on `key`. */
+    protected emit(key: string, event: SubscriptionEvent): void;
+    /**
+     * Tear `key` off the wire immediately if no listener holds it — i.e. it is
+     * lingering in the deferred-teardown window (or its open is still
+     * unwinding). Returns `true` when the key is free (absent or just torn
+     * down), `false` — leaving the channel untouched — while live listeners
+     * hold it. Lets a subclass that enforces an exclusivity invariant across
+     * keys reclaim a released channel without waiting out the linger.
+     */
+    protected closeChannelIfIdle(key: string): boolean;
+    /**
+     * Record a wire subscription for replay-on-(re)open and, when the socket is
+     * already connected, send its subscribe frame via {@link sendSubscribe}.
+     * While the socket is down the replay loop on the next open is the sole
+     * sender — sending in both places would double-subscribe. A failed send
+     * removes the sub again so a rejected open leaves no registry entry behind.
+     */
+    protected registerSub(key: string, state: TSub): Promise<void>;
+    /** Forget a wire subscription so the next (re)open no longer replays it. */
+    protected unregisterSub(key: string): void;
+    private replaySubs;
+    /** Venue-specific {@link WsProvider.subscribeQuote}; see `resolveSubscribeQuote`. */
+    abstract subscribeQuote(params: ProviderGetQuoteParams, onQuote: QuoteListener): Promise<() => void>;
+    /** Canonical fan-out key for `sub`; must match the key the subclass emits to. */
+    protected abstract toKey(sub: Subscription): string;
+    /**
+     * Open the channel on the wire (0→1 transition only). Record the wire
+     * sub(s) via {@link registerSub} and return a closure that unregisters them
+     * and sends the unsubscribe frame(s).
+     */
+    protected abstract openChannel(sub: Subscription): Promise<() => void>;
+    /**
+     * Encode and send the subscribe frame for one registered sub. Called by the
+     * base while connected — once on register and again on every (re)open — so
+     * it must be safe to invoke repeatedly with the same state (e.g. re-fetch a
+     * fresh auth token per call rather than embedding one in `state`).
+     */
+    protected abstract sendSubscribe(state: TSub): void | Promise<void>;
+    /** Parse one inbound frame and route it via {@link emit}. */
+    protected abstract handleMessage(raw: string): void;
+    /** Release subclass-only resources on {@link close} (keep-alive, cached state). */
+    protected onClose(): void;
+    private callListener;
+    private acquireChannel;
+    private releaseChannel;
+}
+//# sourceMappingURL=WsProviderBase.d.ts.map

package/dist/types/websocket/WsProviderBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WsProviderBase.d.ts","sourceRoot":"","sources":["../../../src/websocket/WsProviderBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,KAAK,EACV,sBAAsB,EACtB,aAAa,EACd,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAGnB;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,MAAM,CAAA;AAiBhD;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,cAAc,CAAC,IAAI,GAAG,OAAO,CAAE,YAAW,UAAU;IACxE,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,qBAAqB,CAAA;IAC7C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAEtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsC;IACtE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAEvC,GAAG,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM;IAcrD,SAAS,CACb,GAAG,EAAE,YAAY,EACjB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,MAAM,IAAI,CAAC;IA2BtB,SAAS,IAAI,IAAI;IAOjB,KAAK,IAAI,IAAI;IAab,mDAAmD;IACnD,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAU3D;;;;;;;OAOG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAgBlD;;;;;;OAMG;cACa,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAapE,4EAA4E;IAC5E,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;YAI5B,UAAU;IAaxB,qFAAqF;IACrF,QAAQ,CAAC,cAAc,CACrB,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,IAAI,CAAC;IAEtB,iFAAiF;IACjF,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM;IAEnD;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;IAEtE;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEnE,6DAA6D;IAC7D,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAEnD,mFAAmF;IACnF,SAAS,CAAC,OAAO,IAAI,IAAI;IAEzB,OAAO,CAAC,YAAY;YAYN,cAAc;IAgD5B,OAAO,CAAC,cAAc;CAwCvB"}

package/dist/types/websocket/cachePromise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Single-flight a promise through a caller-owned cache slot, evicting the
+ * cached promise if it rejects so the next call retries cleanly.
+ *
+ * Concurrent callers share the one in-flight promise; the rejection still
+ * propagates to every awaiter that triggered it. Only a settled rejection is
+ * evicted — a resolved promise stays cached.
+ *
+ * @param read - Returns the currently cached promise, or `undefined` if none.
+ * @param write - Stores (or with `undefined`, clears) the cached promise.
+ * @param factory - Creates the promise when the slot is empty.
+ */
+export declare function cachePromise<T>(read: () => Promise<T> | undefined, write: (promise: Promise<T> | undefined) => void, factory: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=cachePromise.d.ts.map

package/dist/types/websocket/cachePromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachePromise.d.ts","sourceRoot":"","sources":["../../../src/websocket/cachePromise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,EAClC,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,KAAK,IAAI,EAChD,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/types/websocket/types.d.ts

@@ -0,0 +1,60 @@
+import type { Subscription, SubscriptionEvent } from '@lifi/perps-types';
+import type { ProviderGetQuoteParams, QuoteListener } from '../types/provider.js';
+/**
+ * The concrete {@link SubscriptionEvent} variant a given subscription `S`
+ * emits, narrowed by its `channel`.
+ *
+ * @public
+ */
+export type EventForSubscription<S extends Subscription> = Extract<SubscriptionEvent, {
+    channel: S['channel'];
+}>;
+/**
+ * Listener invoked with each realtime {@link SubscriptionEvent}.
+ *
+ * @public
+ */
+export type SubscriptionListener = (event: SubscriptionEvent) => void;
+/**
+ * Health of a provider's underlying WS connection.
+ *
+ * - `connected` — socket open, live data flowing.
+ * - `reconnecting` — socket dropped; auto-reconnect with backoff in progress.
+ *   Data may be stale until it returns to `connected`.
+ * - `disconnected` — reconnection abandoned after the retry cap. The
+ *   connection is permanently dead and will not recover on its own; the
+ *   subscription's data is stale. Terminal.
+ *
+ * @public
+ */
+export type WsConnectionStatus = 'connected' | 'reconnecting' | 'disconnected';
+/**
+ * Listener invoked when the underlying WS connection's health changes.
+ *
+ * @public
+ */
+export type WsStatusListener = (status: WsConnectionStatus) => void;
+/**
+ * Per-provider realtime transport contract used by {@link PerpsWsClient}.
+ * Implemented by the provider packages' WS plugins.
+ *
+ * @public
+ */
+export interface WsProvider {
+    subscribe(sub: Subscription, listener: SubscriptionListener, onStatus?: WsStatusListener): Promise<() => void>;
+    /**
+     * Recover a terminally exhausted connection. Safe no-op unless status is
+     * `disconnected`.
+     */
+    reconnect(): void;
+    /**
+     * Stream live fill {@link Quote}s for `params.size` USD notional of
+     * `params.symbol` on this venue, layered on the orderbook channel: the
+     * provider resolves the symbol against its own markets and re-runs the
+     * one-shot quote transform on each (throttled) book update, applying its
+     * public base fee tier. Returns an idempotent unsubscribe.
+     */
+    subscribeQuote(params: ProviderGetQuoteParams, onQuote: QuoteListener): Promise<() => void>;
+    close(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/websocket/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/websocket/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,KAAK,EACV,sBAAsB,EACtB,aAAa,EACd,MAAM,sBAAsB,CAAA;AAE7B;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,YAAY,IAAI,OAAO,CAChE,iBAAiB,EACjB;IAAE,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC,CAAA;CAAE,CAC1B,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,cAAc,GAAG,cAAc,CAAA;AAE9E;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAA;AAEnE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,CACP,GAAG,EAAE,YAAY,EACjB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,MAAM,IAAI,CAAC,CAAA;IACtB;;;OAGG;IACH,SAAS,IAAI,IAAI,CAAA;IACjB;;;;;;OAMG;IACH,cAAc,CACZ,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,IAAI,CAAC,CAAA;IACtB,KAAK,IAAI,IAAI,CAAA;CACd"}

package/dist/types/websocket/wsLog.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Structured logger for WS message-handling and subscription failures, shared
+ * by the provider packages so a malformed frame, a throwing mapper, or a failed
+ * resubscribe never vanishes silently.
+ *
+ * @internal
+ */
+export declare const wsLog: {
+    /**
+     * A single frame that could not be parsed as JSON. Expected to recur on a
+     * noisy stream, so logged at `warn` with a truncated payload — never fatal.
+     */
+    readonly parseFailure: (provider: string, raw: string) => void;
+    /**
+     * A frame parsed but its handler threw (mapper bug, `MarketNotFound`, …).
+     * This is unexpected and must surface; the frame is skipped so one bad
+     * frame does not stall the stream or starve other channels.
+     */
+    readonly handlerFailure: (provider: string, error: unknown) => void;
+    /**
+     * An `error`-channel frame the server pushed (e.g. a rejected or duplicate
+     * subscription). The frame parsed fine — this is the venue reporting a
+     * problem, not a malformed frame — so surface it at `error` with the
+     * server's own text rather than mislabelling it a parse failure.
+     */
+    readonly serverError: (provider: string, message: string) => void;
+    /**
+     * A channel's (re)subscribe threw while (re)opening the socket — e.g. an
+     * auth-token fetch rejected after a reconnect. Surfaced at `error`; the
+     * channel is skipped so one failure does not abort the others.
+     */
+    readonly subscribeFailure: (provider: string, channel: string, error: unknown) => void;
+    /**
+     * A frame item referenced a market id missing from the registry (e.g.
+     * listed after the snapshot). The item is skipped — never the whole frame —
+     * so logged at `warn`.
+     */
+    readonly unknownMarket: (provider: string, marketId: string) => void;
+    /**
+     * A background market-registry refetch rejected. Unknown-market items keep
+     * being skipped until the next cooldown-gated retry, so logged at `warn`.
+     */
+    readonly marketRefreshFailure: (provider: string, error: unknown) => void;
+    /**
+     * A consumer listener callback threw during fan-out. Logged and skipped so
+     * one bad listener cannot starve sibling listeners or break socket flow.
+     */
+    readonly listenerFailure: (provider: string, listenerType: string, error: unknown) => void;
+};
+//# sourceMappingURL=wsLog.d.ts.map

package/dist/types/websocket/wsLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsLog.d.ts","sourceRoot":"","sources":["../../../src/websocket/wsLog.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,eAAO,MAAM,KAAK;IAChB;;;OAGG;sCACoB,MAAM,OAAO,MAAM,KAAG,IAAI;IAGjD;;;;OAIG;wCACsB,MAAM,SAAS,OAAO,KAAG,IAAI;IAGtD;;;;;OAKG;qCACmB,MAAM,WAAW,MAAM,KAAG,IAAI;IAGpD;;;;OAIG;0CACwB,MAAM,WAAW,MAAM,SAAS,OAAO,KAAG,IAAI;IAMzE;;;;OAIG;uCACqB,MAAM,YAAY,MAAM,KAAG,IAAI;IAKvD;;;OAGG;8CAC4B,MAAM,SAAS,OAAO,KAAG,IAAI;IAG5D;;;OAGG;yCAES,MAAM,gBACF,MAAM,SACb,OAAO,KACb,IAAI;CAMC,CAAA"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@lifi/perps-sdk",
+  "version": "0.0.0-preview-64fca0d",
+  "description": "LI.FI Perps SDK for perpetuals trading",
+  "homepage": "https://github.com/lifinance/perps-sdk",
+  "bugs": {
+    "url": "https://github.com/lifinance/perps-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lifinance/perps-sdk.git"
+  },
+  "license": "Apache-2.0",
+  "author": "LI.FI <dev@li.fi>",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "typings": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**",
+    "!dist/**/*.tsbuildinfo",
+    "src/**/*.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.mock.ts",
+    "!src/**/*.handlers.ts",
+    "!src/**/*.tsbuildinfo",
+    "!**/__mocks__/**",
+    "!*.tmp",
+    "!*.env",
+    "!tsconfig.json"
+  ],
+  "dependencies": {
+    "@lifi/types": "17.82.1",
+    "partysocket": "^1.1.19",
+    "viem": "^2.48.8",
+    "@lifi/perps-types": "0.0.0-preview-64fca0d"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "perps",
+    "perpetuals",
+    "trading",
+    "defi",
+    "ethereum",
+    "lifi",
+    "sdk",
+    "viem",
+    "hyperliquid"
+  ]
+}