@floegence/flowersec-core 0.22.1 → 0.24.0

package/dist/reconnect/index.js

@@ -1,32 +1,59 @@
 import { getClientTermination } from "../client-connect/termination.js";
 import { emitObserverDiagnostic, withObserverContext } from "../observability/observer.js";
 import { SDK_DEFAULTS } from "../defaults.js";
+import { AbortError, FlowersecError } from "../utils/errors.js";
 export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
 function normalizeAutoReconnect(cfg) {
-    if (!cfg?.enabled) {
-        return {
-            enabled: false,
-            maxAttempts: 1,
-            initialDelayMs: SDK_DEFAULTS.reconnect.initialDelayMs,
-            maxDelayMs: SDK_DEFAULTS.reconnect.maxDelayMs,
-            factor: SDK_DEFAULTS.reconnect.factor,
-            jitterRatio: SDK_DEFAULTS.reconnect.jitterRatio,
-        };
-    }
-    return {
-        enabled: true,
-        maxAttempts: Math.max(1, cfg.maxAttempts ?? SDK_DEFAULTS.reconnect.maxAttempts),
-        initialDelayMs: Math.max(0, cfg.initialDelayMs ?? SDK_DEFAULTS.reconnect.initialDelayMs),
-        maxDelayMs: Math.max(0, cfg.maxDelayMs ?? SDK_DEFAULTS.reconnect.maxDelayMs),
-        factor: Math.max(1, cfg.factor ?? SDK_DEFAULTS.reconnect.factor),
-        jitterRatio: Math.max(0, cfg.jitterRatio ?? SDK_DEFAULTS.reconnect.jitterRatio),
+    const settings = {
+        enabled: cfg?.enabled === true,
+        maxAttempts: cfg?.enabled === true ? (cfg.maxAttempts ?? SDK_DEFAULTS.reconnect.maxAttempts) : 1,
+        initialDelayMs: cfg?.initialDelayMs ?? SDK_DEFAULTS.reconnect.initialDelayMs,
+        maxDelayMs: cfg?.maxDelayMs ?? SDK_DEFAULTS.reconnect.maxDelayMs,
+        factor: cfg?.factor ?? SDK_DEFAULTS.reconnect.factor,
+        jitterRatio: cfg?.jitterRatio ?? SDK_DEFAULTS.reconnect.jitterRatio,
     };
+    if (!Number.isSafeInteger(settings.maxAttempts) || settings.maxAttempts < 1) {
+        throw new TypeError("autoReconnect.maxAttempts must be a positive integer");
+    }
+    if (!Number.isFinite(settings.initialDelayMs) || settings.initialDelayMs < 0) {
+        throw new TypeError("autoReconnect.initialDelayMs must be a non-negative finite number");
+    }
+    if (!Number.isFinite(settings.maxDelayMs) || settings.maxDelayMs < 0) {
+        throw new TypeError("autoReconnect.maxDelayMs must be a non-negative finite number");
+    }
+    if (!Number.isFinite(settings.factor) || settings.factor < 1) {
+        throw new TypeError("autoReconnect.factor must be a finite number greater than or equal to one");
+    }
+    if (!Number.isFinite(settings.jitterRatio) || settings.jitterRatio < 0 || settings.jitterRatio > 1) {
+        throw new TypeError("autoReconnect.jitterRatio must be a finite number between zero and one");
+    }
+    return settings;
 }
 function backoffDelayMs(attemptIndex, cfg) {
     const base = Math.min(cfg.maxDelayMs, cfg.initialDelayMs * Math.pow(cfg.factor, attemptIndex));
     const jitter = cfg.jitterRatio <= 0 ? 0 : base * cfg.jitterRatio * (Math.random() * 2 - 1);
     return Math.max(0, Math.round(base + jitter));
 }
+const TERMINAL_RECONNECT_CODES = new Set([
+    "invalid_input",
+    "invalid_option",
+    "role_mismatch",
+    "transport_policy_denied",
+    "invalid_psk",
+    "invalid_suite",
+    "missing_grant",
+    "missing_connect_info",
+    "missing_tunnel_url",
+    "missing_ws_url",
+    "missing_channel_id",
+    "missing_token",
+    "missing_init_exp",
+]);
+function isTerminalConnectError(error) {
+    if (error instanceof AbortError || error.name === "AbortError")
+        return true;
+    return error instanceof FlowersecError && (error.code === "canceled" || TERMINAL_RECONNECT_CODES.has(error.code));
+}
 function isSameConfig(a, b) {
     if (a == null)
         return false;
@@ -73,13 +100,19 @@ export function createReconnectManager() {
         retryResolve = null;
     };
     const abortActiveAttempt = () => {
+        attemptAbort?.abort("canceled");
+        attemptAbort = null;
+    };
+    const closeClient = (value) => {
+        if (value == null)
+            return null;
         try {
-            attemptAbort?.abort("canceled");
+            value.close();
+            return null;
         }
-        catch {
-            // ignore
+        catch (error) {
+            return asError(error);
         }
-        attemptAbort = null;
     };
     const sleep = (ms) => new Promise((resolve) => {
         retryResolve = resolve;
@@ -89,6 +122,30 @@ export function createReconnectManager() {
             resolve();
         }, ms);
     });
+    const finishWithError = (cfg, error, currentAttemptSeq) => {
+        setState({ status: "error", error, client: null });
+        emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq: currentAttemptSeq }), {
+            path: "auto",
+            stage: "reconnect",
+            code_domain: "event",
+            code: "reconnect_exhausted",
+            result: "fail",
+        });
+    };
+    const scheduleRetry = async (t, cfg, error, settings, failedAttemptIndex, currentAttemptSeq) => {
+        if (t !== token || active !== cfg)
+            return false;
+        setState({ status: "connecting", error, client: null });
+        emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq: currentAttemptSeq }), {
+            path: "auto",
+            stage: "reconnect",
+            code_domain: "event",
+            code: "reconnect_scheduled",
+            result: "retry",
+        });
+        await sleep(backoffDelayMs(failedAttemptIndex, settings));
+        return t === token && active === cfg;
+    };
     const disconnectInternal = () => {
         cancelRetrySleep();
         abortActiveAttempt();
@@ -96,13 +153,10 @@ export function createReconnectManager() {
         activeConnectPromise = null;
         token += 1;
         attemptSeq = 0;
-        if (s.client) {
-            try {
-                s.client.close();
-            }
-            catch {
-                // ignore
-            }
+        const closeError = closeClient(s.client);
+        if (closeError != null) {
+            setState({ status: "error", error: closeError, client: null });
+            throw closeError;
         }
         setState({ status: "disconnected", error: null, client: null });
     };
@@ -115,32 +169,28 @@ export function createReconnectManager() {
             return;
         const ar = normalizeAutoReconnect(cfg.autoReconnect);
         if (!ar.enabled) {
-            if (s.client) {
-                try {
-                    s.client.close();
-                }
-                catch {
-                    // ignore
-                }
-            }
-            setState({ status: "error", error, client: null });
+            const closeError = closeClient(s.client);
+            const finalError = closeError == null
+                ? error
+                : new AggregateError([error, closeError], "reconnect termination and client close failed");
+            setState({ status: "error", error: finalError, client: null });
             return;
         }
         // Restart the connection loop in the background.
         cancelRetrySleep();
         abortActiveAttempt();
-        if (s.client) {
-            try {
-                s.client.close();
-            }
-            catch {
-                // ignore
-            }
+        const closeError = closeClient(s.client);
+        if (closeError != null) {
+            setState({
+                status: "error",
+                error: new AggregateError([error, closeError], "reconnect termination and client close failed"),
+                client: null,
+            });
+            return;
         }
         token += 1;
         const nextToken = token;
-        const reconnectPromise = startConnectLoop(nextToken, cfg);
-        setState({ status: "connecting", error, client: null });
+        const reconnectPromise = startConnectLoop(nextToken, cfg, error);
         void reconnectPromise.catch(() => {
             // connectWithRetry updates state; keep errors observable via state().
         });
@@ -178,9 +228,17 @@ export function createReconnectManager() {
         attemptAbort = new AbortController();
         return await cfg.connectOnce({ signal: attemptAbort.signal, observer: createObserver(t, cfg, currentAttemptSeq) ?? {} });
     };
-    const connectWithRetry = async (t, cfg) => {
+    const connectWithRetry = async (t, cfg, initialFailure) => {
         const ar = normalizeAutoReconnect(cfg.autoReconnect);
         let attempts = 0;
+        if (initialFailure != null) {
+            if (isTerminalConnectError(initialFailure)) {
+                finishWithError(cfg, initialFailure, attemptSeq);
+                throw initialFailure;
+            }
+            if (!await scheduleRetry(t, cfg, initialFailure, ar, 0, attemptSeq))
+                return;
+        }
         for (;;) {
             if (t !== token)
                 return;
@@ -198,21 +256,15 @@ export function createReconnectManager() {
             try {
                 const client = await connectOnce(t, cfg, attemptSeq);
                 if (t !== token) {
-                    try {
-                        client.close();
-                    }
-                    catch {
-                        // ignore
-                    }
+                    const closeError = closeClient(client);
+                    if (closeError != null)
+                        throw new ReconnectCleanupError(closeError);
                     return;
                 }
                 if (active !== cfg) {
-                    try {
-                        client.close();
-                    }
-                    catch {
-                        // ignore
-                    }
+                    const closeError = closeClient(client);
+                    if (closeError != null)
+                        throw new ReconnectCleanupError(closeError);
                     return;
                 }
                 setState({ status: "connected", client, error: null });
@@ -222,6 +274,10 @@ export function createReconnectManager() {
                         if (s.client !== client)
                             return;
                         startReconnect(t, cfg, error);
+                    }, (error) => {
+                        if (s.client !== client)
+                            return;
+                        startReconnect(t, cfg, asError(error));
                     });
                 }
                 emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq }), {
@@ -234,37 +290,24 @@ export function createReconnectManager() {
                 return;
             }
             catch (err) {
+                if (err instanceof ReconnectCleanupError)
+                    throw err.cleanupError;
                 const e = err instanceof Error ? err : new Error(String(err));
                 if (t !== token)
                     return;
                 if (active !== cfg)
                     return;
-                const canRetry = ar.enabled && attempts < ar.maxAttempts;
+                const canRetry = ar.enabled && attempts < ar.maxAttempts && !isTerminalConnectError(e);
                 if (!canRetry) {
-                    setState({ status: "error", error: e, client: null });
-                    emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq }), {
-                        path: "auto",
-                        stage: "reconnect",
-                        code_domain: "event",
-                        code: "reconnect_exhausted",
-                        result: "fail",
-                    });
+                    finishWithError(cfg, e, attemptSeq);
                     throw e;
                 }
-                setState({ status: "connecting", error: e, client: null });
-                const delay = backoffDelayMs(attempts - 1, ar);
-                emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq }), {
-                    path: "auto",
-                    stage: "reconnect",
-                    code_domain: "event",
-                    code: "reconnect_scheduled",
-                    result: "retry",
-                });
-                await sleep(delay);
+                if (!await scheduleRetry(t, cfg, e, ar, attempts - 1, attemptSeq))
+                    return;
             }
         }
     };
-    const startConnectLoop = (t, cfg) => {
+    const startConnectLoop = (t, cfg, initialFailure) => {
         let resolveLoop;
         let rejectLoop;
         const loop = new Promise((resolve, reject) => {
@@ -277,25 +320,24 @@ export function createReconnectManager() {
                 activeConnectPromise = null;
         });
         activeConnectPromise = promise;
-        void connectWithRetry(t, cfg).then(resolveLoop, rejectLoop);
+        void connectWithRetry(t, cfg, initialFailure).then(resolveLoop, rejectLoop);
         return promise;
     };
     const connect = async (cfg) => {
+        normalizeAutoReconnect(cfg.autoReconnect);
         cancelRetrySleep();
         abortActiveAttempt();
         token += 1;
         const t = token;
         active = cfg;
         attemptSeq = 0;
-        if (s.client) {
-            try {
-                s.client.close();
-            }
-            catch {
-                // ignore
-            }
+        const closeError = closeClient(s.client);
+        if (closeError != null) {
+            active = null;
+            setState({ status: "error", error: closeError, client: null });
+            throw closeError;
         }
-        const connectPromise = startConnectLoop(t, cfg);
+        const connectPromise = startConnectLoop(t, cfg, null);
         setState({ status: "connecting", error: null, client: null });
         await connectPromise;
     };
@@ -333,3 +375,14 @@ export function createReconnectManager() {
         disconnect,
     };
 }
+class ReconnectCleanupError extends Error {
+    cleanupError;
+    constructor(cleanupError) {
+        super("reconnect cleanup failed", { cause: cleanupError });
+        this.cleanupError = cleanupError;
+        this.name = "ReconnectCleanupError";
+    }
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}

package/dist/rpc/server.d.ts

@@ -32,6 +32,7 @@ export declare class RpcServer {
     private readonly terminalSignal;
     private signalTerminal;
     private transportClosed;
+    private admittedRequests;
     constructor(transport: RpcServerTransport, options?: RpcServerOptions, router?: RpcRouter);
     register(typeId: number, h: RpcHandler): void;
     notify(typeId: number, payload: unknown): Promise<void>;

package/dist/rpc/server.js

@@ -31,6 +31,7 @@ export class RpcServer {
     terminalSignal;
     signalTerminal;
     transportClosed = false;
+    admittedRequests = 0;
     constructor(transport, options = {}, router = new RpcRouter()) {
         this.transport = transport;
         this.router = router;
@@ -57,11 +58,15 @@ export class RpcServer {
     }
     // serve handles request/response frames until closed or aborted.
     async serve(signal) {
-        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()));
+        const workers = Array.from({ length: this.options.maxConcurrentRequests }, () => this.requestWorker());
+        workers.push(this.notificationWorker());
+        const workerFailure = Promise.race(workers.map(async (worker) => {
+            await worker;
+            if (!this.closed)
+                throw new Error("rpc worker ended before server shutdown");
+            return await new Promise(() => undefined);
+        }));
+        let failure;
         try {
             while (!this.closed) {
                 if (signal?.aborted)
@@ -69,6 +74,7 @@ export class RpcServer {
                 const next = await Promise.race([
                     readJsonFrame(this.transport.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES),
                     this.terminalSignal.then((error) => { throw error; }),
+                    workerFailure,
                 ]);
                 const v = assertRpcEnvelope(next);
                 if (v.response_to !== 0)
@@ -81,23 +87,38 @@ export class RpcServer {
                     this.wakeOne(this.notificationWaiters);
                     continue;
                 }
-                if (this.requests.length >= this.options.maxQueuedRequests) {
+                if (this.admittedRequests >= this.options.maxConcurrentRequests + this.options.maxQueuedRequests) {
                     await this.writeResponse(v, { payload: null, error: { code: 429, message: "server overloaded" } });
                     continue;
                 }
+                this.admittedRequests += 1;
                 this.requests.push({ envelope: v });
                 this.wakeOne(this.requestWaiters);
             }
         }
         catch (err) {
+            failure = err;
             this.terminalError = err;
-            this.close(err);
-            throw err;
         }
-        finally {
-            this.close(this.terminalError ?? new Error("rpc server closed"));
-            void Promise.allSettled(workers);
+        let closeError;
+        try {
+            this.close(failure ?? this.terminalError ?? new Error("rpc server closed"));
+        }
+        catch (error) {
+            closeError = error;
         }
+        const settled = await Promise.allSettled(workers);
+        const workerErrors = settled
+            .filter((result) => result.status === "rejected")
+            .map((result) => result.reason)
+            .filter((error) => error !== failure);
+        const errors = [failure, closeError, ...workerErrors].filter((error) => error !== undefined);
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "rpc server and cleanup failed");
+        if (this.terminalError !== undefined)
+            throw this.terminalError;
     }
     // close stops the serve loop and closes the underlying RPC stream.
     close(error = new Error("rpc server closed")) {
@@ -138,9 +159,14 @@ export class RpcServer {
                     out = { payload: null, error: { code: 500, message: "internal error" } };
                 }
             }
-            if (this.closed)
-                return;
-            await this.writeResponse(v, out);
+            try {
+                if (this.closed)
+                    return;
+                await this.writeResponse(v, out);
+            }
+            finally {
+                this.admittedRequests = Math.max(0, this.admittedRequests - 1);
+            }
         }
     }
     async notificationWorker() {
@@ -152,10 +178,7 @@ export class RpcServer {
             const h = this.router.handler(v.type_id);
             if (h == null)
                 continue;
-            try {
-                await h(v.payload);
-            }
-            catch { /* Notification failures are isolated. */ }
+            await h(v.payload);
         }
     }
     async nextWork(queue, waiters) {
@@ -182,8 +205,14 @@ export class RpcServer {
     }
     async writeEnvelope(envelope) {
         const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, envelope));
-        this.writeChain = write.catch(() => { });
-        await write;
+        this.writeChain = write;
+        try {
+            await write;
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
     }
 }
 function positiveInteger(value, name) {

package/dist/streamio/index.js

@@ -11,12 +11,9 @@ function abortReasonToError(signal) {
 }
 function bindAbortToStream(stream, signal) {
     const onAbort = () => {
-        try {
-            stream.reset(abortReasonToError(signal));
-        }
-        catch {
-            // Best-effort cancel.
-        }
+        void Promise.resolve(stream.reset(abortReasonToError(signal))).catch(() => {
+            // The read/write operation reports the authoritative abort to its caller.
+        });
     };
     if (signal.aborted) {
         onAbort();

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" | "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 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" | "rekey_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/yamux/byteReader.d.ts

@@ -8,4 +8,6 @@ export declare class ByteReader {
     readExactly(n: number): Promise<Uint8Array>;
     discardExactly(n: number): Promise<void>;
     bufferedBytes(): number;
+    private consumeAvailable;
+    private compactConsumedChunks;
 }

package/dist/yamux/byteReader.js

@@ -23,25 +23,7 @@ export class ByteReader {
             this.buffered += chunk.length;
         }
         const out = new Uint8Array(n);
-        let outOff = 0;
-        while (outOff < n) {
-            const head = this.chunks[this.chunkHead];
-            const avail = head.length - this.headOff;
-            const need = n - outOff;
-            const take = Math.min(avail, need);
-            out.set(head.subarray(this.headOff, this.headOff + take), outOff);
-            outOff += take;
-            this.headOff += take;
-            this.buffered -= take;
-            if (this.headOff === head.length) {
-                this.chunkHead++;
-                this.headOff = 0;
-                if (this.chunkHead > 1024 && this.chunkHead * 2 > this.chunks.length) {
-                    this.chunks.splice(0, this.chunkHead);
-                    this.chunkHead = 0;
-                }
-            }
-        }
+        this.consumeAvailable(n, out);
         return out;
     }
     // discardExactly consumes bytes without allocating a contiguous output buffer.
@@ -59,19 +41,41 @@ export class ByteReader {
                 this.chunks.push(chunk);
                 this.buffered += chunk.length;
             }
+            remaining -= this.consumeAvailable(remaining);
+        }
+    }
+    // bufferedBytes returns the number of bytes currently buffered.
+    bufferedBytes() {
+        return this.buffered;
+    }
+    consumeAvailable(maxBytes, output) {
+        let consumed = 0;
+        while (consumed < maxBytes && this.buffered > 0) {
             const head = this.chunks[this.chunkHead];
-            const take = Math.min(remaining, head.length - this.headOff);
+            const take = Math.min(maxBytes - consumed, head.length - this.headOff);
+            if (output != null)
+                output.set(head.subarray(this.headOff, this.headOff + take), consumed);
             this.headOff += take;
             this.buffered -= take;
-            remaining -= take;
+            consumed += take;
             if (this.headOff === head.length) {
                 this.chunkHead++;
                 this.headOff = 0;
             }
         }
+        this.compactConsumedChunks();
+        return consumed;
     }
-    // bufferedBytes returns the number of bytes currently buffered.
-    bufferedBytes() {
-        return this.buffered;
+    compactConsumedChunks() {
+        if (this.buffered === 0) {
+            this.chunks.length = 0;
+            this.chunkHead = 0;
+            this.headOff = 0;
+            return;
+        }
+        if (this.chunkHead > 1024 && this.chunkHead * 2 > this.chunks.length) {
+            this.chunks.splice(0, this.chunkHead);
+            this.chunkHead = 0;
+        }
     }
 }

package/dist/yamux/errors.d.ts

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

package/dist/yamux/errors.js

@@ -8,6 +8,15 @@ export class StreamEOFError extends Error {
 export function isStreamEOFError(e) {
     return e instanceof StreamEOFError;
 }
+export class YamuxStreamResetError extends Error {
+    constructor() {
+        super("yamux stream reset");
+        this.name = "YamuxStreamResetError";
+    }
+}
+export function isYamuxStreamResetError(error) {
+    return error instanceof YamuxStreamResetError;
+}
 export class YamuxResourceExhaustedError extends Error {
     resource;
     current;
@@ -23,3 +32,12 @@ export class YamuxResourceExhaustedError extends Error {
 export function isYamuxResourceExhaustedError(error) {
     return error instanceof YamuxResourceExhaustedError;
 }
+export class YamuxPingTimeoutError extends Error {
+    constructor() {
+        super("yamux ping timeout");
+        this.name = "YamuxPingTimeoutError";
+    }
+}
+export function isYamuxPingTimeoutError(error) {
+    return error instanceof YamuxPingTimeoutError;
+}