@floegence/flowersec-core 2.5.1 → 2.5.3

package/dist/node/acceptor.js

@@ -443,12 +443,31 @@ export async function createAcceptor(options) {
         const abort = () => controller.abort(operation.signal?.reason);
         operation.signal?.addEventListener("abort", abort, { once: true });
         try {
-            return await Promise.any(listeners.map(async (listener, index) => {
-                const selected = listeners[(index + cursor) % listeners.length];
-                return await selected.accept({ signal: controller.signal });
-            })).finally(() => {
-                cursor = (cursor + 1) % listeners.length;
-                controller.abort();
+            return await new Promise((resolve, reject) => {
+                let settled = false;
+                let remaining = listeners.length;
+                const errors = [];
+                listeners.forEach((listener, index) => {
+                    const selected = listeners[(index + cursor) % listeners.length];
+                    void selected.accept({ signal: controller.signal }).then((carrier) => {
+                        if (!settled) {
+                            settled = true;
+                            cursor = (cursor + 1) % listeners.length;
+                            controller.abort();
+                            resolve(carrier);
+                        }
+                        else {
+                            carrier.abort({ code: 1000, reason: "accept race lost" });
+                        }
+                    }, (error) => {
+                        errors.push(error);
+                        remaining -= 1;
+                        if (!settled && remaining === 0) {
+                            settled = true;
+                            reject(new AggregateError(errors, "all listeners failed to accept"));
+                        }
+                    });
+                });
             });
         }
         finally {

package/dist/proxy/windowBridge.d.ts

@@ -12,6 +12,7 @@ export declare class MessagePortByteStream implements ByteStream {
     private buffered;
     private readBuffered;
     private ended;
+    private writeClosed;
     private closed;
     constructor(port: MessagePort);
     read(options?: OperationOptions): Promise<Uint8Array | null>;

package/dist/proxy/windowBridge.js

@@ -18,6 +18,7 @@ export class MessagePortByteStream {
     buffered = 0;
     readBuffered = 0;
     ended = false;
+    writeClosed = false;
     closed = false;
     constructor(port) {
         this.port = port;
@@ -52,6 +53,8 @@ export class MessagePortByteStream {
     async write(data, options = {}) {
         if (this.closed || this.terminalError !== undefined)
             throw this.terminalError ?? new SessionError("closed");
+        if (this.writeClosed)
+            throw new SessionError("operation_failed");
         if (options.signal?.aborted === true)
             throw new SessionError("canceled");
         if (data.length === 0)
@@ -79,8 +82,9 @@ export class MessagePortByteStream {
         return data.length;
     }
     async closeWrite() {
-        if (this.closed)
+        if (this.closed || this.writeClosed)
             return;
+        this.writeClosed = true;
         this.port.postMessage({ type: "end" });
     }
     async reset() {
@@ -100,6 +104,10 @@ export class MessagePortByteStream {
             return;
         const message = value;
         if (message.type === "chunk") {
+            if (this.ended || this.closed) {
+                this.fail(new SessionError("operation_failed"));
+                return;
+            }
             if (!Number.isSafeInteger(message.id) || !(message.data instanceof ArrayBuffer) || message.data.byteLength > MAX_BRIDGE_CHUNK_BYTES) {
                 this.fail(new SessionError("operation_failed"));
                 return;
@@ -130,6 +138,8 @@ export class MessagePortByteStream {
             return;
         }
         if (message.type === "end") {
+            if (this.ended)
+                return;
             this.ended = true;
             for (const waiter of this.readWaiters.splice(0))
                 waiter.resolve(null);
@@ -219,20 +229,39 @@ export function registerProxyAppWindow(options) {
         openWebSocketStream: async (path, openOptions = {}) => {
             if (disposed)
                 throw new SessionError("closed");
+            if (openOptions.signal?.aborted === true)
+                throw new SessionError("canceled");
             const channel = new MessageChannel();
             const response = new Promise((resolve, reject) => {
-                const timer = setTimeout(() => { channel.port1.close(); reject(new SessionError("timeout")); }, 10_000);
+                let settled = false;
+                const finish = (error, opened) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    openOptions.signal?.removeEventListener("abort", abort);
+                    if (error !== undefined) {
+                        channel.port1.close();
+                        reject(error);
+                    }
+                    else
+                        resolve(opened);
+                };
+                const abort = () => {
+                    channel.port1.postMessage({ type: "reset" });
+                    finish(new SessionError("canceled"));
+                };
+                const timer = setTimeout(() => finish(new SessionError("timeout")), 10_000);
                 channel.port1.onmessage = (event) => {
                     if (event.data?.type !== WEBSOCKET_ACK_MESSAGE)
                         return;
-                    clearTimeout(timer);
                     if (event.data.ok !== true) {
-                        channel.port1.close();
-                        reject(new SessionError("operation_failed"));
+                        finish(new SessionError("operation_failed"));
                         return;
                     }
-                    resolve(Object.freeze({ stream: new MessagePortByteStream(channel.port1), protocol: typeof event.data.protocol === "string" ? event.data.protocol : "" }));
+                    finish(undefined, Object.freeze({ stream: new MessagePortByteStream(channel.port1), protocol: typeof event.data.protocol === "string" ? event.data.protocol : "" }));
                 };
+                openOptions.signal?.addEventListener("abort", abort, { once: true });
             });
             controller.postMessage({
                 type: WEBSOCKET_OPEN_MESSAGE,
@@ -241,9 +270,6 @@ export function registerProxyAppWindow(options) {
                 protocols: openOptions.protocols ?? [],
                 ...(nonce === undefined ? {} : { capabilityNonce: nonce }),
             }, origin, [channel.port2]);
-            if (openOptions.signal !== undefined) {
-                openOptions.signal.addEventListener("abort", () => channel.port1.close(), { once: true });
-            }
             return await response;
         },
         dispose: () => { disposed = true; },
@@ -303,10 +329,25 @@ export function registerProxyControllerWindow(options) {
         }
         if (event.data?.type === WEBSOCKET_OPEN_MESSAGE && event.data.version === 2) {
             void (async () => {
+                let canceled = false;
+                const openController = new AbortController();
+                port.onmessage = (message) => {
+                    if (message.data?.type === "reset" ||
+                        message.data?.type === "close") {
+                        canceled = true;
+                        openController.abort();
+                        port.close();
+                    }
+                };
                 try {
                     const opened = await options.runtime.openWebSocketStream(String(event.data.path ?? ""), {
                         protocols: Array.isArray(event.data.protocols) ? event.data.protocols.map(String) : [],
+                        signal: openController.signal,
                     });
+                    if (canceled) {
+                        await opened.stream.reset();
+                        return;
+                    }
                     port.postMessage({ type: WEBSOCKET_ACK_MESSAGE, ok: true, protocol: opened.protocol });
                     await bridgeStreams(opened.stream, port);
                 }

package/dist/transport/webTransportAdapter.js

@@ -327,6 +327,7 @@ class WebTransportDatagramAdapter {
         this.terminalError = error;
         this.incoming.fail(error);
         void this.writable.abort(error).catch(() => undefined);
+        void this.readable.cancel(error).catch(() => undefined);
     }
     assertOpen() {
         if (this.terminalError !== undefined)
@@ -416,15 +417,26 @@ class IncomingWebTransportStreamQueue {
     }
 }
 class IncomingDatagramQueue {
+    static MAX_VALUES = 256;
+    static MAX_BYTES = 4 * 1024 * 1024;
     values = [];
+    bufferedBytes = 0;
     waiters = new Set();
     terminalError;
     push(value) {
         if (this.terminalError !== undefined)
             return;
         const waiter = this.waiters.values().next().value;
-        if (waiter === undefined)
+        if (waiter === undefined) {
+            // DATAGRAMs are lossy by contract. Drop an incoming value once the
+            // bounded queue budget is exhausted, while keeping the native reader
+            // drained so an unconsumed peer cannot grow memory without bound.
+            if (this.values.length >= IncomingDatagramQueue.MAX_VALUES ||
+                this.bufferedBytes + value.byteLength > IncomingDatagramQueue.MAX_BYTES)
+                return;
             this.values.push(value);
+            this.bufferedBytes += value.byteLength;
+        }
         else
             waiter.deliver(value);
     }
@@ -434,8 +446,10 @@ class IncomingDatagramQueue {
         if (this.terminalError !== undefined)
             return Promise.reject(this.terminalError);
         const value = this.values.shift();
-        if (value !== undefined)
+        if (value !== undefined) {
+            this.bufferedBytes -= value.byteLength;
             return Promise.resolve(value);
+        }
         return new Promise((resolve, reject) => {
             let settled = false;
             const cleanup = () => {
@@ -470,6 +484,7 @@ class IncomingDatagramQueue {
             return;
         this.terminalError = error;
         this.values.length = 0;
+        this.bufferedBytes = 0;
         for (const waiter of [...this.waiters])
             waiter.fail(error);
     }

package/dist/v2/session.d.ts

@@ -132,7 +132,7 @@ export declare class SessionV2 implements SessionV2Contract {
     private peerResponderFrozen;
     private responderChanged;
     private idleWatchdogStarted;
-    private idleTimer;
+    private idleTimerCancel;
     private readonly terminationState;
     private readonly rpcRouter;
     constructor(carrier: CarrierSessionV2, control: CarrierStreamV2, controlReader: ExactReader, config: SessionConfigV2, material: HandshakeMaterial);

package/dist/v2/session.js

@@ -137,7 +137,7 @@ export class SessionV2 {
     peerResponderFrozen = false;
     responderChanged = deferred();
     idleWatchdogStarted = false;
-    idleTimer;
+    idleTimerCancel;
     terminationState = deferred();
     rpcRouter;
     constructor(carrier, control, controlReader, config, material) {
@@ -1017,10 +1017,9 @@ export class SessionV2 {
         const timeoutMs = sessionIdleTimeoutMs(this.config);
         if (timeoutMs === 0)
             return;
-        if (this.idleTimer !== undefined)
-            clearTimeout(this.idleTimer);
-        this.idleTimer = setTimeout(() => {
-            this.idleTimer = undefined;
+        this.idleTimerCancel?.();
+        this.idleTimerCancel = scheduleLongTimeout(() => {
+            this.idleTimerCancel = undefined;
             this.fail(new SessionV2Error("timeout", "Flowersec v2 session idle timeout exceeded"));
         }, timeoutMs);
     }
@@ -1034,10 +1033,8 @@ export class SessionV2 {
         this.terminalError = error;
         this.lifecycle = "closed";
         this.terminationState.resolve({ error });
-        if (this.idleTimer !== undefined) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = undefined;
-        }
+        this.idleTimerCancel?.();
+        this.idleTimerCancel = undefined;
         this.incoming.fail(error);
         this.outboundPermits.fail(error);
         this.inboundPermits.fail(error);
@@ -1988,12 +1985,38 @@ function createSessionDeadline(config, phase) {
 }
 function defaultDeadlineFactory(timeoutMs, phase) {
     const controller = new AbortController();
-    const timer = setTimeout(() => {
+    const cancelTimer = scheduleLongTimeout(() => {
         controller.abort(new SessionV2Error("timeout", `${phase} deadline exceeded`));
     }, timeoutMs);
     return {
         signal: controller.signal,
-        cancel: () => clearTimeout(timer),
+        cancel: cancelTimer,
+    };
+}
+const MAX_NATIVE_TIMEOUT_MS = 2_147_483_647;
+// Node and browsers clamp setTimeout delays above a signed 32-bit integer.
+// Keep the public timeout range intact by scheduling the remaining duration in
+// bounded segments against a monotonic wall-clock deadline.
+function scheduleLongTimeout(callback, timeoutMs) {
+    const clock = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+    const deadline = clock() + timeoutMs;
+    let timer;
+    let canceled = false;
+    const schedule = () => {
+        if (canceled)
+            return;
+        const remaining = deadline - clock();
+        if (remaining <= 0) {
+            callback();
+            return;
+        }
+        timer = setTimeout(schedule, Math.min(remaining, MAX_NATIVE_TIMEOUT_MS));
+    };
+    schedule();
+    return () => {
+        canceled = true;
+        if (timer !== undefined)
+            clearTimeout(timer);
     };
 }
 function combineSignals(...signals) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Flowersec core TypeScript library for carrier-neutral encrypted sessions and multiplexed streams.",
   "license": "MIT",
   "repository": {
@@ -77,7 +77,7 @@
     "ws": "^8.21.2"
   },
   "optionalDependencies": {
-    "@floegence/flowersec-node-native": "2.5.1"
+    "@floegence/flowersec-node-native": "2.5.3"
   },
   "devDependencies": {
     "@playwright/test": "1.62.1",
@@ -95,5 +95,5 @@
     "vite": "^8.2.1",
     "vitest": "4.1.10"
   },
-  "flowersecSourceCommit": "8debd2888634e8e7c88fd848ff5b08d22aa6d1f2"
+  "flowersecSourceCommit": "aa50aab509e3519b2b9c8e49abccc407a831a741"
 }

package/sbom/cyclonedx.json

@@ -1,20 +1,20 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:7870295b-822d-59a5-8999-b6c86bdedcd2",
+  "serialNumber": "urn:uuid:ec0f2db1-aea5-5835-89bb-52b08c4a4a1c",
   "version": 1,
   "metadata": {
     "component": {
       "type": "library",
       "name": "@floegence/flowersec-core",
-      "version": "2.5.1",
-      "purl": "pkg:npm/%40floegence/flowersec-core@2.5.1",
-      "bom-ref": "pkg:npm/%40floegence/flowersec-core@2.5.1"
+      "version": "2.5.3",
+      "purl": "pkg:npm/%40floegence/flowersec-core@2.5.3",
+      "bom-ref": "pkg:npm/%40floegence/flowersec-core@2.5.3"
     },
     "properties": [
       {
         "name": "flowersec:source-inventory-sha256",
-        "value": "aba1d1c470bb7af7da0d63211ac38f323b17e6e6f91337c0951508521d23b2b0"
+        "value": "1a8ba3adc252c3c72e7a5129a172b0c767a075161ac1d0379f0b257f091816fb"
       }
     ]
   },
@@ -190,7 +190,7 @@
   ],
   "dependencies": [
     {
-      "ref": "pkg:npm/%40floegence/flowersec-core@2.5.1",
+      "ref": "pkg:npm/%40floegence/flowersec-core@2.5.3",
       "dependsOn": [
         "pkg:npm/%40noble/ciphers@2.3.0",
         "pkg:npm/%40noble/curves@2.3.0",

package/sbom/spdx.json

@@ -3,7 +3,7 @@
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
   "name": "flowersec-ts",
-  "documentNamespace": "https://github.com/floegence/flowersec/sbom/flowersec-ts/aba1d1c470bb7af7da0d63211ac38f323b17e6e6f91337c0951508521d23b2b0",
+  "documentNamespace": "https://github.com/floegence/flowersec/sbom/flowersec-ts/1a8ba3adc252c3c72e7a5129a172b0c767a075161ac1d0379f0b257f091816fb",
   "creationInfo": {
     "created": "1970-01-01T00:00:00Z",
     "creators": [
@@ -13,19 +13,19 @@
   "packages": [
     {
       "name": "@floegence/flowersec-core",
-      "SPDXID": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
-      "versionInfo": "2.5.1",
+      "SPDXID": "SPDXRef-Package-290762592d648256929a",
+      "versionInfo": "2.5.3",
       "downloadLocation": "NOASSERTION",
       "filesAnalyzed": false,
       "licenseConcluded": "NOASSERTION",
       "licenseDeclared": "NOASSERTION",
       "copyrightText": "NOASSERTION",
-      "comment": "Flowersec source inventory SHA-256: aba1d1c470bb7af7da0d63211ac38f323b17e6e6f91337c0951508521d23b2b0",
+      "comment": "Flowersec source inventory SHA-256: 1a8ba3adc252c3c72e7a5129a172b0c767a075161ac1d0379f0b257f091816fb",
       "externalRefs": [
         {
           "referenceCategory": "PACKAGE-MANAGER",
           "referenceType": "purl",
-          "referenceLocator": "pkg:npm/%40floegence/flowersec-core@2.5.1"
+          "referenceLocator": "pkg:npm/%40floegence/flowersec-core@2.5.3"
         }
       ]
     },
@@ -136,30 +136,30 @@
     {
       "spdxElementId": "SPDXRef-DOCUMENT",
       "relationshipType": "DESCRIBES",
-      "relatedSpdxElement": "SPDXRef-Package-8e2bb9ca6799b3b43dc6"
+      "relatedSpdxElement": "SPDXRef-Package-290762592d648256929a"
     },
     {
-      "spdxElementId": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
+      "spdxElementId": "SPDXRef-Package-290762592d648256929a",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-5ce913a03239b02770fb"
     },
     {
-      "spdxElementId": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
+      "spdxElementId": "SPDXRef-Package-290762592d648256929a",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-01009adf60db02c13634"
     },
     {
-      "spdxElementId": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
+      "spdxElementId": "SPDXRef-Package-290762592d648256929a",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-8815b117c8a1d5f7eeb0"
     },
     {
-      "spdxElementId": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
+      "spdxElementId": "SPDXRef-Package-290762592d648256929a",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-f8b45a289df643042b94"
     },
     {
-      "spdxElementId": "SPDXRef-Package-8e2bb9ca6799b3b43dc6",
+      "spdxElementId": "SPDXRef-Package-290762592d648256929a",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-b779412f685822663496"
     },