@floegence/flowersec-core 0.20.1 → 0.20.2

package/dist/yamux/session.js

@@ -24,6 +24,7 @@ export class YamuxSession {
     // Maximum allowed DATA frame length.
     limits;
     onDiagnostic;
+    onTerminal;
     // True when this side is the yamux client (odd local stream IDs).
     client;
     // Next stream ID to allocate (odd/even based on role).
@@ -39,25 +40,21 @@ export class YamuxSession {
     activeProbe;
     constructor(conn, opts) {
         this.conn = conn;
-        this.reader = new ByteReader(async () => {
-            try {
-                return await this.conn.read();
-            }
-            catch {
-                return null;
-            }
-        });
+        this.reader = new ByteReader(() => this.conn.read());
         this.onIncomingStream = opts.onIncomingStream;
         this.limits = normalizeYamuxLimits({ ...opts.limits, ...(opts.maxFrameBytes === undefined ? {} : { maxFrameBytes: opts.maxFrameBytes }) });
         this.onDiagnostic = opts.onDiagnostic;
+        this.onTerminal = opts.onTerminal;
         this.client = opts.client;
         this.nextStreamId = opts.client ? 1 : 2;
         void this.readLoop();
     }
     // openStream allocates a new stream and performs the SYN handshake.
-    async openStream() {
+    async openStream(opts = {}) {
         if (this.closed)
             throw new Error("session closed");
+        if (opts.signal?.aborted)
+            throw abortError(opts.signal);
         if (this.streams.size >= this.limits.maxActiveStreams) {
             const error = new YamuxResourceExhaustedError("active_streams", this.streams.size, this.limits.maxActiveStreams);
             this.diagnostic({ code: "resource_limit_reached", resource: error.resource, current: error.current, limit: error.limit });
@@ -68,7 +65,9 @@ export class YamuxSession {
         const s = new YamuxStream(this, id, "init");
         this.streams.set(id, s);
         try {
-            await s.open();
+            await raceAbort(s.open(), opts.signal, () => {
+                void s.reset(abortError(opts.signal));
+            });
             return s;
         }
         catch (error) {
@@ -82,7 +81,13 @@ export class YamuxSession {
     }
     // writeRaw writes a raw yamux frame to the underlying connection.
     async writeRaw(chunk) {
-        await this.conn.write(chunk);
+        try {
+            await this.conn.write(chunk);
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
     }
     outboundFrameBytes() {
         return this.limits.preferredOutboundFrameBytes;
@@ -119,8 +124,9 @@ export class YamuxSession {
         return await new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pingWaiters.delete(opaque);
-                reject(new Error("yamux ping timeout"));
-                this.close();
+                const error = new Error("yamux ping timeout");
+                reject(error);
+                this.fail(error);
             }, timeoutMs);
             timer?.unref?.();
             this.pingWaiters.set(opaque, { startedAt, resolve, reject, timer });
@@ -132,14 +138,15 @@ export class YamuxSession {
                 this.pingWaiters.delete(opaque);
                 clearTimeout(waiter.timer);
                 reject(err);
+                this.fail(err);
             });
         });
     }
     // sendRst sends a reset frame and removes the stream.
     async sendRst(id) {
         const hdr = encodeHeader({ type: TYPE_WINDOW_UPDATE, flags: FLAG_RST, streamId: id, length: 0 });
+        this.onStreamClosed(id);
         if (this.closed) {
-            this.onStreamClosed(id);
             return;
         }
         try {
@@ -148,7 +155,6 @@ export class YamuxSession {
         catch {
             // Best-effort reset; ignore errors when the session is closing.
         }
-        this.onStreamClosed(id);
     }
     // notifySendWindow wakes any writers waiting on window credit.
     notifySendWindow(streamId) {
@@ -191,6 +197,21 @@ export class YamuxSession {
     }
     // close terminates the session and resets all streams.
     close() {
+        this.closeInternal();
+    }
+    fail(error) {
+        if (this.closed)
+            return;
+        const terminalError = error instanceof Error ? error : new Error(String(error));
+        this.closeInternal();
+        try {
+            this.onTerminal?.(terminalError);
+        }
+        catch {
+            // Lifecycle callbacks must not affect session shutdown.
+        }
+    }
+    closeInternal() {
         if (this.closed)
             return;
         this.closed = true;
@@ -219,16 +240,16 @@ export class YamuxSession {
                 const hdrBytes = await this.reader.readExactly(HEADER_LEN);
                 const h = decodeHeader(hdrBytes, 0);
                 if (h.version !== YAMUX_VERSION) {
-                    this.close();
+                    this.fail(new Error("unsupported yamux version"));
                     return;
                 }
                 if (h.type === TYPE_DATA) {
                     if (h.length > this.limits.maxFrameBytes) {
-                        this.close();
+                        this.fail(new Error("yamux frame exceeds limit"));
                         return;
                     }
                     if (h.streamId === 0) {
-                        this.close();
+                        this.fail(new Error("yamux data frame has stream id zero"));
                         return;
                     }
                     const existing = this.streams.get(h.streamId);
@@ -255,7 +276,7 @@ export class YamuxSession {
                     }
                     if (this.sessionReceiveBytes + h.length > this.limits.maxSessionReceiveBytes) {
                         this.diagnostic({ code: "resource_limit_reached", resource: "session_receive_bytes", current: this.sessionReceiveBytes + h.length, limit: this.limits.maxSessionReceiveBytes });
-                        this.close();
+                        this.fail(new Error("yamux session receive limit reached"));
                         return;
                     }
                     const data = h.length > 0 ? await this.reader.readExactly(h.length) : new Uint8Array();
@@ -275,15 +296,15 @@ export class YamuxSession {
                     continue;
                 }
                 if (h.type === TYPE_GO_AWAY) {
-                    this.close();
+                    this.fail(new Error("yamux peer sent go away"));
                     return;
                 }
-                this.close();
+                this.fail(new Error("unsupported yamux frame type"));
                 return;
             }
         }
-        catch {
-            this.close();
+        catch (error) {
+            this.fail(error);
         }
     }
     async handlePing(flags, opaque) {
@@ -303,7 +324,7 @@ export class YamuxSession {
     }
     async handleDataFrame(streamId, flags, data) {
         if (streamId === 0) {
-            this.close();
+            this.fail(new Error("yamux data frame has stream id zero"));
             return false;
         }
         let s = this.streams.get(streamId);
@@ -332,7 +353,7 @@ export class YamuxSession {
     }
     async handleWindowUpdateFrame(streamId, flags, delta) {
         if (streamId === 0) {
-            this.close();
+            this.fail(new Error("yamux window update has stream id zero"));
             return;
         }
         let s = this.streams.get(streamId);
@@ -358,7 +379,7 @@ export class YamuxSession {
             }
         }
         if (!s.onWindowUpdate(delta, flags)) {
-            this.close();
+            this.fail(new Error("yamux send window overflow"));
         }
     }
     isInboundStreamIdValid(streamId) {
@@ -376,6 +397,36 @@ export class YamuxSession {
         catch { /* Diagnostics cannot affect transport behavior. */ }
     }
 }
+function abortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    if (typeof reason === "string" && reason !== "")
+        return new Error(reason);
+    return new Error("yamux open stream aborted");
+}
+async function raceAbort(promise, signal, onAbort) {
+    if (signal == null)
+        return await promise;
+    if (signal.aborted) {
+        onAbort();
+        throw abortError(signal);
+    }
+    return await new Promise((resolve, reject) => {
+        const abort = () => {
+            onAbort();
+            reject(abortError(signal));
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
 function normalizeYamuxLimits(input) {
     const maxFrameBytes = input?.maxFrameBytes ?? DEFAULT_YAMUX_LIMITS.maxFrameBytes;
     const limits = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {