@floegence/flowersec-core 0.19.10 → 0.20.0

package/dist/rpc/server.js

@@ -1,16 +1,35 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
 import { assertRpcEnvelope } from "./validate.js";
+const DEFAULT_RPC_SERVER_OPTIONS = Object.freeze({
+    maxConcurrentRequests: 32,
+    maxQueuedRequests: 128,
+    maxQueuedNotifications: 128,
+});
 // RpcServer dispatches request envelopes to registered handlers.
 export class RpcServer {
-    readExactly;
-    write;
+    transport;
     // Registered handlers keyed by type ID.
     handlers = new Map();
     // Closed flag to stop the serve loop.
     closed = false;
-    constructor(readExactly, write) {
-        this.readExactly = readExactly;
-        this.write = write;
+    options;
+    requests = [];
+    notifications = [];
+    requestWaiters = [];
+    notificationWaiters = [];
+    writeChain = Promise.resolve();
+    terminalError;
+    terminalSignal;
+    signalTerminal;
+    transportClosed = false;
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.terminalSignal = new Promise((resolve) => { this.signalTerminal = resolve; });
+        this.options = {
+            maxConcurrentRequests: positiveInteger(options.maxConcurrentRequests ?? DEFAULT_RPC_SERVER_OPTIONS.maxConcurrentRequests, "maxConcurrentRequests"),
+            maxQueuedRequests: nonNegativeInteger(options.maxQueuedRequests ?? DEFAULT_RPC_SERVER_OPTIONS.maxQueuedRequests, "maxQueuedRequests"),
+            maxQueuedNotifications: nonNegativeInteger(options.maxQueuedNotifications ?? DEFAULT_RPC_SERVER_OPTIONS.maxQueuedNotifications, "maxQueuedNotifications"),
+        };
     }
     // register binds a handler to a type ID.
     register(typeId, h) {
@@ -18,50 +37,139 @@ export class RpcServer {
     }
     // serve handles request/response frames until closed or aborted.
     async serve(signal) {
-        while (!this.closed) {
-            if (signal?.aborted)
-                throw signal.reason ?? new Error("aborted");
-            const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES));
-            if (v.response_to !== 0)
-                continue;
-            if (v.request_id === 0) {
-                const h = this.handlers.get(v.type_id >>> 0);
-                if (h != null) {
-                    try {
-                        await h(v.payload);
-                    }
-                    catch {
-                        // Keep the serve loop alive on notification handler errors.
+        const supervise = (worker) => worker.catch((err) => {
+            this.fail(err);
+        });
+        const workers = Array.from({ length: this.options.maxConcurrentRequests }, () => supervise(this.requestWorker()));
+        workers.push(supervise(this.notificationWorker()));
+        try {
+            while (!this.closed) {
+                if (signal?.aborted)
+                    throw signal.reason ?? new Error("aborted");
+                const next = await Promise.race([
+                    readJsonFrame(this.transport.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES),
+                    this.terminalSignal.then((error) => { throw error; }),
+                ]);
+                const v = assertRpcEnvelope(next);
+                if (v.response_to !== 0)
+                    continue;
+                if (v.request_id === 0) {
+                    if (this.notifications.length >= this.options.maxQueuedNotifications) {
+                        throw new Error("rpc notification queue exhausted");
                     }
+                    this.notifications.push({ envelope: v });
+                    this.wakeOne(this.notificationWaiters);
+                    continue;
                 }
-                continue;
+                if (this.requests.length >= this.options.maxQueuedRequests) {
+                    await this.writeResponse(v, { payload: null, error: { code: 429, message: "server overloaded" } });
+                    continue;
+                }
+                this.requests.push({ envelope: v });
+                this.wakeOne(this.requestWaiters);
             }
+        }
+        catch (err) {
+            this.terminalError = err;
+            this.close(err);
+            throw err;
+        }
+        finally {
+            this.close(this.terminalError ?? new Error("rpc server closed"));
+            void Promise.allSettled(workers);
+        }
+    }
+    // close stops the serve loop and closes the underlying RPC stream.
+    close(error = new Error("rpc server closed")) {
+        if (!this.closed) {
+            this.closed = true;
+            this.signalTerminal(error);
+            for (const wake of this.requestWaiters.splice(0))
+                wake();
+            for (const wake of this.notificationWaiters.splice(0))
+                wake();
+        }
+        if (!this.transportClosed) {
+            this.transportClosed = true;
+            this.transport.close(error);
+        }
+    }
+    fail(error) {
+        if (this.terminalError !== undefined)
+            return;
+        this.terminalError = error;
+        this.close(error);
+    }
+    async requestWorker() {
+        while (!this.closed) {
+            const work = await this.nextWork(this.requests, this.requestWaiters);
+            if (work == null)
+                return;
+            const v = work.envelope;
             const h = this.handlers.get(v.type_id >>> 0);
             let out;
-            if (h == null) {
+            if (h == null)
                 out = { payload: null, error: { code: 404, message: "handler not found" } };
-            }
             else {
                 try {
                     out = await h(v.payload);
                 }
                 catch {
-                    // Keep the serve loop alive on request handler errors.
                     out = { payload: null, error: { code: 500, message: "internal error" } };
                 }
             }
-            const resp = {
-                type_id: v.type_id,
-                request_id: 0,
-                response_to: v.request_id,
-                payload: out.payload,
-                ...(out.error != null ? { error: out.error } : {})
-            };
-            await writeJsonFrame(this.write, resp);
+            if (this.closed)
+                return;
+            await this.writeResponse(v, out);
         }
     }
-    // close stops the serve loop.
-    close() {
-        this.closed = true;
+    async notificationWorker() {
+        while (!this.closed) {
+            const work = await this.nextWork(this.notifications, this.notificationWaiters);
+            if (work == null)
+                return;
+            const v = work.envelope;
+            const h = this.handlers.get(v.type_id >>> 0);
+            if (h == null)
+                continue;
+            try {
+                await h(v.payload);
+            }
+            catch { /* Notification failures are isolated. */ }
+        }
     }
+    async nextWork(queue, waiters) {
+        while (!this.closed) {
+            const work = queue.shift();
+            if (work != null)
+                return work;
+            await new Promise((resolve) => waiters.push(resolve));
+        }
+        return null;
+    }
+    wakeOne(waiters) {
+        waiters.shift()?.();
+    }
+    async writeResponse(request, out) {
+        const resp = {
+            type_id: request.type_id,
+            request_id: 0,
+            response_to: request.request_id,
+            payload: out.payload,
+            ...(out.error != null ? { error: out.error } : {}),
+        };
+        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, resp));
+        this.writeChain = write.catch(() => { });
+        await write;
+    }
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new RangeError(`${name} must be a positive integer`);
+    return value;
+}
+function nonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError(`${name} must be a non-negative integer`);
+    return value;
 }

package/dist/tunnel-client/connect.js

@@ -131,27 +131,27 @@ export async function connectTunnel(grant, opts) {
         endpoint_instance_id: endpointInstanceId
     };
     const attachJson = JSON.stringify(attach);
-    const keepaliveIntervalMs = opts.keepaliveIntervalMs ?? defaultKeepaliveIntervalMs(idleTimeoutSeconds);
+    const liveness = opts.liveness ?? defaultLiveness(idleTimeoutSeconds);
     return await connectCore({
         path: "tunnel",
         wsUrl: tunnelUrl,
         channelId,
         e2eePskB64u,
         defaultSuite: checkedGrant.default_suite,
-        opts: { ...opts, keepaliveIntervalMs },
+        opts: { ...opts, liveness },
         attach: { attachJson, endpointInstanceId }
     });
 }
-function defaultKeepaliveIntervalMs(idleTimeoutSeconds) {
+function defaultLiveness(idleTimeoutSeconds) {
     if (!Number.isFinite(idleTimeoutSeconds) || idleTimeoutSeconds <= 0)
-        return 0;
+        return false;
     const idleMs = Math.floor(idleTimeoutSeconds * 1000);
     if (idleMs <= 0)
-        return 0;
+        return false;
     let interval = Math.floor(idleMs / 2);
     if (interval < 500)
         interval = 500;
     if (interval >= idleMs)
         interval = Math.floor(idleMs / 2);
-    return interval;
+    return { intervalMs: interval, timeoutMs: Math.min(10_000, interval) };
 }

package/dist/utils/errors.d.ts

@@ -6,7 +6,7 @@ export declare class AbortError extends Error {
 }
 export type FlowersecPath = "auto" | "tunnel" | "direct";
 export type FlowersecStage = "validate" | "connect" | "attach" | "handshake" | "secure" | "yamux" | "rpc" | "close";
-export type FlowersecErrorCode = "timeout" | "canceled" | "invalid_version" | "invalid_input" | "invalid_option" | "invalid_endpoint_instance_id" | "invalid_psk" | "invalid_suite" | "missing_grant" | "missing_connect_info" | "missing_conn" | "missing_handler" | "missing_stream_kind" | "role_mismatch" | "missing_tunnel_url" | "missing_ws_url" | "missing_origin" | "missing_channel_id" | "missing_token" | "missing_init_exp" | "timestamp_after_init_exp" | "timestamp_out_of_skew" | "auth_tag_mismatch" | "resolve_failed" | "random_failed" | "upgrade_failed" | "dial_failed" | "attach_failed" | "too_many_connections" | "expected_attach" | "invalid_attach" | "invalid_token" | "channel_mismatch" | "init_exp_mismatch" | "idle_timeout_mismatch" | "token_replay" | "tenant_mismatch" | "policy_denied" | "policy_error" | "replace_rate_limited" | "handshake_failed" | "ping_failed" | "mux_failed" | "accept_stream_failed" | "open_stream_failed" | "stream_hello_failed" | "rpc_failed" | "not_connected";
+export type FlowersecErrorCode = "timeout" | "canceled" | "invalid_version" | "invalid_input" | "invalid_option" | "invalid_endpoint_instance_id" | "invalid_psk" | "invalid_suite" | "missing_grant" | "missing_connect_info" | "missing_conn" | "missing_handler" | "missing_stream_kind" | "role_mismatch" | "missing_tunnel_url" | "missing_ws_url" | "missing_origin" | "missing_channel_id" | "missing_token" | "missing_init_exp" | "timestamp_after_init_exp" | "timestamp_out_of_skew" | "auth_tag_mismatch" | "resolve_failed" | "transport_policy_denied" | "credential_commit_failed" | "random_failed" | "upgrade_failed" | "dial_failed" | "attach_failed" | "too_many_connections" | "expected_attach" | "invalid_attach" | "invalid_token" | "channel_mismatch" | "init_exp_mismatch" | "idle_timeout_mismatch" | "token_replay" | "tenant_mismatch" | "policy_denied" | "policy_error" | "replace_rate_limited" | "handshake_failed" | "ping_failed" | "mux_failed" | "accept_stream_failed" | "open_stream_failed" | "stream_hello_failed" | "rpc_failed" | "resource_exhausted" | "not_connected";
 export declare class FlowersecError extends Error {
     readonly code: FlowersecErrorCode;
     readonly stage: FlowersecStage;

package/dist/ws-client/binaryTransport.d.ts

@@ -7,28 +7,41 @@ export declare class WsCloseError extends Error {
 export type WebSocketLike = {
     binaryType: string;
     readyState: number;
+    /** Bytes accepted by send() but not yet transmitted by the implementation. */
+    readonly bufferedAmount: number;
     send(data: string | ArrayBuffer | Uint8Array): void;
     close(code?: number, reason?: string): void;
     addEventListener(type: "open" | "message" | "error" | "close", listener: (ev: any) => void): void;
     removeEventListener(type: "open" | "message" | "error" | "close", listener: (ev: any) => void): void;
 };
+export type WebSocketLimits = Readonly<{
+    maxInboundQueuedBytes: number;
+    outboundLowWatermarkBytes: number;
+    outboundHighWatermarkBytes: number;
+    outboundHardLimitBytes: number;
+    outboundDrainTimeoutMs: number;
+}>;
+export declare const DEFAULT_WEB_SOCKET_LIMITS: WebSocketLimits;
+export type WebSocketBinaryTransportOptions = Readonly<{
+    webSocketLimits?: Partial<WebSocketLimits>;
+    observer?: ClientObserverLike;
+}>;
 export declare class WebSocketBinaryTransport {
     private readonly ws;
     private readonly observer;
     private readonly queue;
     private queueHead;
     private queueBytes;
-    private readonly maxQueuedBytes;
+    private readonly limits;
     private waiters;
     private waitersHead;
     private waitersSettled;
     private messageChain;
     private error;
     private localCloseRequested;
-    constructor(ws: WebSocketLike, opts?: Readonly<{
-        maxQueuedBytes?: number;
-        observer?: ClientObserverLike;
-    }>);
+    private writeChain;
+    private pendingOutboundBytes;
+    constructor(ws: WebSocketLike, opts?: WebSocketBinaryTransportOptions);
     readBinary(opts?: Readonly<{
         signal?: AbortSignal;
         timeoutMs?: number;
@@ -42,6 +55,8 @@ export declare class WebSocketBinaryTransport {
     private readonly onError;
     private readonly onClose;
     private push;
+    private sendWithBackpressure;
+    private failAndClose;
     private shiftQueue;
     private shiftWaiter;
     private compactWaitersMaybe;

package/dist/ws-client/binaryTransport.js

@@ -1,4 +1,4 @@
-import { normalizeObserver } from "../observability/observer.js";
+import { emitObserverDiagnostic, normalizeObserver } from "../observability/observer.js";
 import { AbortError, TimeoutError, throwIfAborted } from "../utils/errors.js";
 export class WsCloseError extends Error {
     code;
@@ -17,6 +17,13 @@ export class WsCloseError extends Error {
         this.reason = reason;
     }
 }
+export const DEFAULT_WEB_SOCKET_LIMITS = Object.freeze({
+    maxInboundQueuedBytes: 4 * (1 << 20),
+    outboundLowWatermarkBytes: 256 * 1024,
+    outboundHighWatermarkBytes: 1 << 20,
+    outboundHardLimitBytes: 4 * (1 << 20),
+    outboundDrainTimeoutMs: 10_000,
+});
 // WebSocketBinaryTransport adapts WebSocket messages to binary reads/writes.
 export class WebSocketBinaryTransport {
     // Underlying WebSocket instance (browser or polyfill).
@@ -30,7 +37,7 @@ export class WebSocketBinaryTransport {
     // Current buffered byte count for backpressure.
     queueBytes = 0;
     // Maximum buffered bytes before closing the socket.
-    maxQueuedBytes;
+    limits;
     // Pending readers waiting for the next frame.
     waiters = [];
     // Read cursor for waiters to avoid Array.shift() O(n).
@@ -43,10 +50,13 @@ export class WebSocketBinaryTransport {
     error = null;
     // Tracks whether the close is initiated locally to avoid double-reporting.
     localCloseRequested = false;
+    // Promise tail used to preserve write order and apply one shared backpressure lane.
+    writeChain = Promise.resolve();
+    pendingOutboundBytes = 0;
     constructor(ws, opts = {}) {
         this.ws = ws;
         this.observer = normalizeObserver(opts.observer);
-        this.maxQueuedBytes = Math.max(0, opts.maxQueuedBytes ?? 4 * (1 << 20));
+        this.limits = normalizeWebSocketLimits(opts.webSocketLimits);
         this.ws.binaryType = "arraybuffer";
         this.ws.addEventListener("message", this.onMessage);
         this.ws.addEventListener("error", this.onError);
@@ -116,7 +126,26 @@ export class WebSocketBinaryTransport {
         throwIfAborted(opts.signal, "write aborted");
         if (this.error != null)
             throw this.error;
-        this.ws.send(frame);
+        if (frame.byteLength > this.limits.outboundHardLimitBytes ||
+            this.pendingOutboundBytes + this.ws.bufferedAmount + frame.byteLength > this.limits.outboundHardLimitBytes) {
+            const err = new Error("ws send queue exceeds hard limit");
+            this.failAndClose(err, "send_buffer_exceeded");
+            throw err;
+        }
+        this.pendingOutboundBytes += frame.byteLength;
+        let handedToWebSocket = false;
+        const write = this.writeChain
+            .then(() => this.sendWithBackpressure(frame, opts.signal, () => {
+            handedToWebSocket = true;
+            this.pendingOutboundBytes = Math.max(0, this.pendingOutboundBytes - frame.byteLength);
+        }))
+            .finally(() => {
+            if (!handedToWebSocket) {
+                this.pendingOutboundBytes = Math.max(0, this.pendingOutboundBytes - frame.byteLength);
+            }
+        });
+        this.writeChain = write.catch(() => { });
+        await write;
     }
     // close tears down listeners and rejects pending readers.
     close() {
@@ -147,7 +176,7 @@ export class WebSocketBinaryTransport {
             return;
         }
         if (data instanceof ArrayBuffer) {
-            if (this.maxQueuedBytes > 0 && this.queueBytes + data.byteLength > this.maxQueuedBytes) {
+            if (this.queueBytes + data.byteLength > this.limits.maxInboundQueuedBytes) {
                 this.fail(new Error("ws recv buffer exceeded"), "recv_buffer_exceeded");
                 this.localCloseRequested = true;
                 this.observer.onWsClose("local");
@@ -159,7 +188,7 @@ export class WebSocketBinaryTransport {
         }
         if (ArrayBuffer.isView(data)) {
             const view = data;
-            if (this.maxQueuedBytes > 0 && this.queueBytes + view.byteLength > this.maxQueuedBytes) {
+            if (this.queueBytes + view.byteLength > this.limits.maxInboundQueuedBytes) {
                 this.fail(new Error("ws recv buffer exceeded"), "recv_buffer_exceeded");
                 this.localCloseRequested = true;
                 this.observer.onWsClose("local");
@@ -170,7 +199,7 @@ export class WebSocketBinaryTransport {
             return;
         }
         if (typeof Blob !== "undefined" && data instanceof Blob) {
-            if (this.maxQueuedBytes > 0 && this.queueBytes + data.size > this.maxQueuedBytes) {
+            if (this.queueBytes + data.size > this.limits.maxInboundQueuedBytes) {
                 this.fail(new Error("ws recv buffer exceeded"), "recv_buffer_exceeded");
                 this.localCloseRequested = true;
                 this.observer.onWsClose("local");
@@ -216,7 +245,7 @@ export class WebSocketBinaryTransport {
             w.resolve(b);
             return;
         }
-        if (this.maxQueuedBytes > 0 && this.queueBytes + b.length > this.maxQueuedBytes) {
+        if (this.queueBytes + b.length > this.limits.maxInboundQueuedBytes) {
             this.fail(new Error("ws recv buffer exceeded"), "recv_buffer_exceeded");
             this.localCloseRequested = true;
             this.observer.onWsClose("local");
@@ -226,6 +255,58 @@ export class WebSocketBinaryTransport {
         this.queue.push(b);
         this.queueBytes += b.length;
     }
+    async sendWithBackpressure(frame, signal, onHandedToWebSocket) {
+        throwIfAborted(signal, "write aborted");
+        if (this.error != null)
+            throw this.error;
+        if (frame.byteLength > this.limits.outboundHardLimitBytes) {
+            const err = new Error("ws send frame exceeds hard limit");
+            this.failAndClose(err, "send_buffer_exceeded");
+            throw err;
+        }
+        const startedAt = Date.now();
+        const mustDrain = this.ws.bufferedAmount + frame.byteLength > this.limits.outboundHighWatermarkBytes ||
+            this.ws.bufferedAmount + frame.byteLength > this.limits.outboundHardLimitBytes;
+        while (mustDrain) {
+            throwIfAborted(signal, "write aborted");
+            if (this.error != null)
+                throw this.error;
+            if (Date.now() - startedAt >= this.limits.outboundDrainTimeoutMs) {
+                const err = new TimeoutError("ws send buffer drain timeout");
+                this.failAndClose(err, "send_buffer_timeout");
+                throw err;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            if (this.ws.bufferedAmount <= this.limits.outboundLowWatermarkBytes &&
+                this.ws.bufferedAmount + frame.byteLength <= this.limits.outboundHardLimitBytes) {
+                break;
+            }
+        }
+        this.ws.send(frame);
+        onHandedToWebSocket();
+        if (this.ws.bufferedAmount > this.limits.outboundHardLimitBytes) {
+            const err = new Error("ws send buffer exceeded");
+            this.failAndClose(err, "send_buffer_exceeded");
+            throw err;
+        }
+    }
+    failAndClose(err, reason) {
+        emitObserverDiagnostic(this.observer, {
+            stage: "transport",
+            code_domain: "event",
+            code: reason === "send_buffer_timeout" ? "queue_pressure" : "resource_limit_reached",
+            result: "fail",
+            resource: "websocket_outbound_bytes",
+            current: this.ws.bufferedAmount + this.pendingOutboundBytes,
+            limit: this.limits.outboundHardLimitBytes,
+        });
+        this.fail(err, reason);
+        if (!this.localCloseRequested) {
+            this.localCloseRequested = true;
+            this.observer.onWsClose("local");
+            this.ws.close();
+        }
+    }
     shiftQueue() {
         if (this.queueHead >= this.queue.length)
             return undefined;
@@ -299,3 +380,24 @@ export class WebSocketBinaryTransport {
         }
     }
 }
+function normalizeWebSocketLimits(input) {
+    const limits = {
+        maxInboundQueuedBytes: input?.maxInboundQueuedBytes ?? DEFAULT_WEB_SOCKET_LIMITS.maxInboundQueuedBytes,
+        outboundLowWatermarkBytes: input?.outboundLowWatermarkBytes ?? DEFAULT_WEB_SOCKET_LIMITS.outboundLowWatermarkBytes,
+        outboundHighWatermarkBytes: input?.outboundHighWatermarkBytes ?? DEFAULT_WEB_SOCKET_LIMITS.outboundHighWatermarkBytes,
+        outboundHardLimitBytes: input?.outboundHardLimitBytes ?? DEFAULT_WEB_SOCKET_LIMITS.outboundHardLimitBytes,
+        outboundDrainTimeoutMs: input?.outboundDrainTimeoutMs ?? DEFAULT_WEB_SOCKET_LIMITS.outboundDrainTimeoutMs,
+    };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new TypeError(`${name} must be a non-negative integer`);
+    }
+    if (limits.maxInboundQueuedBytes === 0 || limits.outboundHardLimitBytes === 0 || limits.outboundDrainTimeoutMs === 0) {
+        throw new TypeError("websocket hard limits and drain timeout must be positive");
+    }
+    if (limits.outboundLowWatermarkBytes > limits.outboundHighWatermarkBytes ||
+        limits.outboundHighWatermarkBytes > limits.outboundHardLimitBytes) {
+        throw new TypeError("websocket outbound watermarks must satisfy low <= high <= hard");
+    }
+    return Object.freeze(limits);
+}

package/dist/yamux/byteReader.d.ts

@@ -6,5 +6,6 @@ export declare class ByteReader {
     private buffered;
     constructor(readChunk: () => Promise<Uint8Array | null>);
     readExactly(n: number): Promise<Uint8Array>;
+    discardExactly(n: number): Promise<void>;
     bufferedBytes(): number;
 }

package/dist/yamux/byteReader.js

@@ -44,6 +44,32 @@ export class ByteReader {
         }
         return out;
     }
+    // discardExactly consumes bytes without allocating a contiguous output buffer.
+    async discardExactly(n) {
+        if (n < 0)
+            throw new Error("invalid length");
+        let remaining = n;
+        while (remaining > 0) {
+            if (this.buffered === 0) {
+                const chunk = await this.readChunk();
+                if (chunk == null)
+                    throw new StreamEOFError();
+                if (chunk.length === 0)
+                    continue;
+                this.chunks.push(chunk);
+                this.buffered += chunk.length;
+            }
+            const head = this.chunks[this.chunkHead];
+            const take = Math.min(remaining, head.length - this.headOff);
+            this.headOff += take;
+            this.buffered -= take;
+            remaining -= take;
+            if (this.headOff === head.length) {
+                this.chunkHead++;
+                this.headOff = 0;
+            }
+        }
+    }
     // bufferedBytes returns the number of bytes currently buffered.
     bufferedBytes() {
         return this.buffered;

package/dist/yamux/errors.d.ts

@@ -2,3 +2,10 @@ export declare class StreamEOFError extends Error {
     constructor(message?: string);
 }
 export declare function isStreamEOFError(e: unknown): e is StreamEOFError;
+export declare class YamuxResourceExhaustedError extends Error {
+    readonly resource: string;
+    readonly current: number;
+    readonly limit: number;
+    constructor(resource: string, current: number, limit: number);
+}
+export declare function isYamuxResourceExhaustedError(error: unknown): error is YamuxResourceExhaustedError;

package/dist/yamux/errors.js

@@ -8,3 +8,18 @@ export class StreamEOFError extends Error {
 export function isStreamEOFError(e) {
     return e instanceof StreamEOFError;
 }
+export class YamuxResourceExhaustedError extends Error {
+    resource;
+    current;
+    limit;
+    constructor(resource, current, limit) {
+        super(`yamux ${resource} limit reached (${current}/${limit})`);
+        this.name = "YamuxResourceExhaustedError";
+        this.resource = resource;
+        this.current = current;
+        this.limit = limit;
+    }
+}
+export function isYamuxResourceExhaustedError(error) {
+    return error instanceof YamuxResourceExhaustedError;
+}

package/dist/yamux/session.d.ts

@@ -1,4 +1,19 @@
 import { YamuxStream } from "./stream.js";
+export type YamuxDiagnostic = Readonly<{
+    code: "stream_rejected" | "resource_limit_reached";
+    resource: string;
+    current: number;
+    limit: number;
+}>;
+export type YamuxLimits = Readonly<{
+    maxActiveStreams: number;
+    maxInboundStreams: number;
+    maxFrameBytes: number;
+    preferredOutboundFrameBytes: number;
+    maxStreamReceiveBytes: number;
+    maxSessionReceiveBytes: number;
+}>;
+export declare const DEFAULT_YAMUX_LIMITS: YamuxLimits;
 export type ByteDuplex = {
     /** Reads the next chunk from the underlying connection. */
     read(): Promise<Uint8Array>;
@@ -14,21 +29,35 @@ export type YamuxSessionOptions = Readonly<{
     onIncomingStream?: (s: YamuxStream) => void;
     /** Maximum frame payload bytes accepted per stream frame. */
     maxFrameBytes?: number;
+    /** Generic stream and receive-memory limits. */
+    limits?: Partial<YamuxLimits>;
+    /** Optional generic resource diagnostic callback. */
+    onDiagnostic?: (event: YamuxDiagnostic) => void;
 }>;
 export declare class YamuxSession {
     private readonly conn;
     private readonly reader;
     private readonly streams;
     private readonly onIncomingStream;
-    private readonly maxFrameBytes;
+    private readonly limits;
+    private readonly onDiagnostic;
     private readonly client;
     private nextStreamId;
     private closed;
     private readonly sendWindowWaiters;
+    private readonly inboundStreams;
+    private sessionReceiveBytes;
+    private nextPingId;
+    private readonly pingWaiters;
+    private activeProbe;
     constructor(conn: ByteDuplex, opts: YamuxSessionOptions);
     openStream(): Promise<YamuxStream>;
     getStream(id: number): YamuxStream | undefined;
     writeRaw(chunk: Uint8Array): Promise<void>;
+    outboundFrameBytes(): number;
+    releaseReceiveBytes(bytes: number): void;
+    probeLiveness(timeoutMs?: number): Promise<number>;
+    private startLivenessProbe;
     sendRst(id: number): Promise<void>;
     notifySendWindow(streamId: number): void;
     waitForSendWindow(streamId: number): Promise<void>;
@@ -41,4 +70,5 @@ export declare class YamuxSession {
     private handleDataFrame;
     private handleWindowUpdateFrame;
     private isInboundStreamIdValid;
+    private diagnostic;
 }