@floegence/flowersec-core 0.23.0 → 0.25.0

package/dist/reconnect/index.js

@@ -1,6 +1,7 @@
 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) {
     const settings = {
@@ -33,6 +34,26 @@ function backoffDelayMs(attemptIndex, cfg) {
     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;
@@ -101,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();
@@ -145,8 +190,7 @@ export function createReconnectManager() {
         }
         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().
         });
@@ -184,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;
@@ -245,32 +297,17 @@ export function createReconnectManager() {
                     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) => {
@@ -283,7 +320,7 @@ 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) => {
@@ -300,7 +337,7 @@ export function createReconnectManager() {
             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;
     };

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/session.js

@@ -11,7 +11,7 @@ export const DEFAULT_YAMUX_LIMITS = Object.freeze({
     preferredOutboundFrameBytes: SDK_DEFAULTS.yamux.preferredOutboundFrameBytes,
     maxStreamReceiveBytes: SDK_DEFAULTS.yamux.maxStreamReceiveBytes,
     maxSessionReceiveBytes: SDK_DEFAULTS.yamux.maxSessionReceiveBytes,
-    maxStreamWriteQueueBytes: SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes,
+    maxStreamWriteQueueBytes: SDK_DEFAULTS.yamux.maxStreamWriteQueueBytes,
 });
 // YamuxSession multiplexes multiple streams over a single byte stream.
 export class YamuxSession {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {
@@ -121,6 +121,8 @@
     "build": "tsc -p tsconfig.build.json",
     "bench": "vitest bench --run",
     "test": "npm run build && vitest run",
+    "test:browser": "npm run build && playwright test",
+    "ensure:browser": "node ./scripts/ensure-playwright-chromium.mjs",
     "test:coverage": "npm run build && vitest run --coverage",
     "lint": "eslint .",
     "verify:package": "node ./scripts/verify-package-exports.mjs",
@@ -136,6 +138,7 @@
   "devDependencies": {
     "@types/node": "^24.0.0",
     "@types/ws": "^8.5.12",
+    "@playwright/test": "1.58.2",
     "@typescript-eslint/eslint-plugin": "^8.18.0",
     "@typescript-eslint/parser": "^8.18.0",
     "@vitest/coverage-v8": "4.1.0",