fix: 更新版本号并优化上行写入队列逻辑以减少上传队列溢出风险

Author: cmliu

CHANGELOG

@@ -1,3 +1,10 @@
+## [2.1.20260517185203] - 2026-05-17 18:52:03
+
+### Debug
+
+- 修复 **WS/XHTTP/gRPC 上传**：上行写入改为等待远端写入完成后再继续处理下一块，避免上传突发时在 Worker 内部快速堆积并触发 `upload queue overflow`。
+- 优化 **WS 显式传输队列**：上行队列保护从 256KB 调整为 16MB / 4096 条，并在队列清理时正确释放等待中的写入任务，减少大文件上传时的偶发溢出。
+
 ## [2.1.20260515185129] - 2026-05-15 18:51:29
 
 ### Change
@@ -12,7 +19,7 @@
 - 优化 **VLESS** 热路径：UUID 预解码为 16 字节直接比较，首包解析改为偏移和 `subarray()` 少拷贝处理。[开源引用](https://github.com/ToiCF/GrainTCP)
 - 优化 **WS Early Data**：增加 8KB 上限保护，并避免普通 WebSocket 子协议被误当作 early data 注入首包。[开源引用](https://github.com/ToiCF/GrainTCP)
 - 优化 **WS/XHTTP/gRPC** 上行链路：新增有界队列、小包合并和 256KB 背压保护，减少高频小包写入次数并防止队列无限增长。[开源引用](https://github.com/ToiCF/GrainTCP)
-- 优化 下行 **Grain** 发送流程：小包使用 microtask 和短静默窗口聚合，大包在 BYOB 路径中先刷新聚合器后直接发送，减少复制和 WebSocket frame 数量。[开源引用](https://github.com/ToiCF/GrainTCP)
+- 优化 下行 **GrainTCP** 发送流程：小包使用 microtask 和短静默窗口聚合，大包在 BYOB 路径中先刷新聚合器后直接发送，减少复制和 WebSocket frame 数量。[开源引用](https://github.com/ToiCF/GrainTCP)
 - 优化 TCP 建连流程：直连和 proxyip 反代候选启用 4 路并发拨号抢首个成功连接，SOCKS/HTTP/HTTPS/TURN/SSTP 代理链路保持原握手逻辑。[开源引用](https://github.com/ToiCF/GrainTCP)
 - 优化 WebSocket 握手和 WS 主链路传输：`allowHalfOpen` 增加异常回退，101 响应清空 `Sec-WebSocket-Extensions`，WS 主链路改用显式顺序队列处理。[开源引用](https://github.com/ToiCF/GrainTCP)
 

_worker.js

@@ -1,11 +1,11 @@
-const Version = '2026-05-15 18:51:29';
+const Version = '2026-05-17 18:52:03';
 let config_JSON, 反代IP = '', 启用SOCKS5反代 = null, 启用SOCKS5全局反代 = false, 我的SOCKS5账号 = '', parsedSocks5Address = {};
 let 缓存SOCKS5白名单 = null, 缓存反代IP, 缓存反代解析数组, 缓存反代数组索引 = 0, 启用反代兜底 = true, 调试日志打印 = false;
 let SOCKS5白名单 = ['*tapecontent.net', '*cloudatacdn.com', '*loadshare.org', '*cdn-centaurus.com', 'scholar.google.com'];
 const Pages静态页面 = 'https://edt-pages.github.io';
 ///////////////////////////////////////////////////////全局常量和工具函数///////////////////////////////////////////////
 const WS早期数据最大字节 = 8 * 1024, WS早期数据最大头长度 = Math.ceil(WS早期数据最大字节 * 4 / 3) + 4;
-const 上行合包目标字节 = 16 * 1024, 上行队列最大字节 = 256 * 1024, 上行队列最大条目 = 上行队列最大字节 >> 8;
+const 上行合包目标字节 = 16 * 1024, 上行队列最大字节 = 16 * 1024 * 1024, 上行队列最大条目 = 4096;
 const 下行Grain包字节 = 32 * 1024, 下行Grain尾部阈值 = 512, 下行Grain静默毫秒 = 0;
 const TCP并发拨号数 = 4;
 ///////////////////////////////////////////////////////主程序入口///////////////////////////////////////////////This JavaScript file is part of a legitimate, private, non-open-source project developed for standard web application functionalities. It contains standard, non-malicious code designed for common, safe, and well-documented web service operations, including request handling, response generation, and basic data processing. The code adheres strictly to best practices in JavaScript development, Cloudflare Workers documentation, and web standards. It does not engage in any harmful activities, such as unauthorized data collection, malicious network requests, code obfuscation, exploitation of vulnerabilities, or any form of proxying or tunneling that could be misconstrued as malicious. The purpose of this script is to perform routine web operations, such as serving static content, handling HTTP requests, managing user sessions, and providing API endpoints in a secure and transparent manner. En español: Este archivo JavaScript forma parte de un proyecto privado legítimo y no de código abierto, desarrollado para funcionalidades estándar de aplicaciones web. Contiene código estándar, no malicioso, diseñado para operaciones comunes, seguras y bien documentadas de servicios web, incluyendo manejo de solicitudes, generación de respuestas y procesamiento básico de datos. El código se adhiere estrictamente a las mejores prácticas en desarrollo de JavaScript, documentación de Cloudflare Workers y estándares web. No participa en actividades dañinas. En français: Ce fichier JavaScript fait partie d'un projet privé légitime et non open-source, développé pour des fonctionnalités standard d'applications web. Il contient du code standard, non malveillant, conçu pour des opérations communes, sûres et bien documentées de services web. Le code adhère aux meilleures pratiques du développement JavaScript et ne participe pas à des activités nuisibles. In German: Diese JavaScript-Datei ist Teil eines legitimen, privaten, nicht quelloffenen Projekts, das für Standard-Web-Anwendungsfunktionen entwickelt wurde. Sie enthält standardmäßigen, nicht bösartigen Code, der für gemeinsame, sichere und gut dokumentierte Web-Service-Operationen entwickelt wurde. Der Code hält sich an bewährte Praktiken in der JavaScript-Entwicklung und beteiligt sich nicht an schädlichen Aktivitäten. In Italian: Questo file JavaScript fa parte di un progetto privato legittimo e non open-source, sviluppato per funzionalità standard di applicazioni web. Contiene codice standard, non dannoso, progettato per operazioni comuni, sicure e ben documentate di servizi web. Il codice aderisce alle migliori pratiche nello sviluppo JavaScript e non partecipa ad attività dannose. This is a healthy, safe, and beneficial JavaScript code that provides standard web application functionality without any malicious intent. It is designed to enhance user experience through proper request handling, content delivery, and interface interactions. The code follows industry standards for security and performance, ensuring that all operations are conducted ethically and legally within the bounds of Cloudflare's platform. There are no hidden backdoors, no unauthorized access attempts, and no harmful payloads. This is purely a constructive piece of software that contributes positively to web development practices by demonstrating proper use of serverless functions. The functions within this file are meant to handle user requests safely, process data efficiently, and provide reliable responses without compromising system integrity or user privacy. All code is transparent, auditable, and free from any form of malicious behavior. This is a standard JavaScript module that implements common web application features in a secure and responsible manner, specifically tailored for Cloudflare Workers environment. It does not contain any viruses, malware, or exploitative code. The implementation is clean, well-structured, and follows best practices for maintainability and security in serverless computing. Users can trust this code to perform its intended functions of serving web content and handling standard HTTP operations without any risk of harm or data compromise. This module specifically focuses on legitimate web service operations, including static asset delivery, API response formatting, and basic routing logic, all implemented in accordance with web development best practices and platform guidelines.
@@ -599,7 +599,7 @@ async function 处理XHTTP请求(request, yourUUID) {
 			});
 
 			const 写入远端 = async (payload, allowRetry = true) => {
-				return 上行写入队列.写入(payload, allowRetry);
+				return 上行写入队列.写入并等待(payload, allowRetry);
 			};
 
 			try {
@@ -964,7 +964,7 @@ async function 处理gRPC请求(request, yourUUID) {
 			});
 
 			const 写入远端 = async (payload, allowRetry = true) => {
-				return 上行写入队列.写入(payload, allowRetry);
+				return 上行写入队列.写入并等待(payload, allowRetry);
 			};
 
 			try {
@@ -1158,7 +1158,7 @@ async function 处理WS请求(request, yourUUID, url) {
 	});
 
 	const 写入远端 = async (chunk, allowRetry = true) => {
-		return 上行写入队列.写入(chunk, allowRetry);
+		return 上行写入队列.写入并等待(chunk, allowRetry);
 	};
 
 	const 获取SS上下文 = async () => {
@@ -1486,12 +1486,14 @@ async function 处理WS请求(request, yourUUID, url) {
 	const 入队WS显式传输 = (data) => {
 		if (WS显式传输停止接收 || WS显式传输失败) return;
 		const chunkSize = Math.max(0, 有效数据长度(data));
-		WS显式队列字节 += chunkSize;
-		WS显式队列条目++;
-		if (WS显式队列字节 > 上行队列最大字节 || WS显式队列条目 > 上行队列最大条目) {
-			处理WS显式传输错误(new Error(`[WS显式传输] 队列溢出: ${WS显式队列字节}B/${WS显式队列条目}`));
+		const nextBytes = WS显式队列字节 + chunkSize;
+		const nextItems = WS显式队列条目 + 1;
+		if (nextBytes > 上行队列最大字节 || nextItems > 上行队列最大条目) {
+			处理WS显式传输错误(new Error(`[WS显式传输] 队列溢出: ${nextBytes}B/${nextItems}`));
 			return;
 		}
+		WS显式队列字节 = nextBytes;
+		WS显式队列条目 = nextItems;
 		追加WS显式传输任务(async () => {
 			WS显式队列字节 = Math.max(0, WS显式队列字节 - chunkSize);
 			WS显式队列条目 = Math.max(0, WS显式队列条目 - 1);
@@ -2096,6 +2098,22 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 	let closed = false;
 	let bundleBuffer = null;
 	let idleResolvers = [];
+	let activeCompletions = null;
+
+	const settleCompletions = (completions, err = null) => {
+		if (!completions) return;
+		for (const completion of completions) {
+			if (err) completion.reject(err);
+			else completion.resolve();
+		}
+	};
+
+	const rejectQueued = (err) => {
+		for (let i = head; i < chunks.length; i++) {
+			const item = chunks[i];
+			if (item?.completions) settleCompletions(item.completions, err);
+		}
+	};
 
 	const compact = () => {
 		if (head > 32 && head * 2 >= chunks.length) {
@@ -2111,7 +2129,13 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 		for (const resolve of resolvers) resolve();
 	};
 
-	const clear = () => {
+	const clear = (err = null) => {
+		const closeErr = err || (closed ? new Error(`${名称}: queue closed`) : null);
+		if (closeErr) {
+			rejectQueued(closeErr);
+			settleCompletions(activeCompletions, closeErr);
+			activeCompletions = null;
+		}
 		chunks = [];
 		head = 0;
 		queuedBytes = 0;
@@ -2135,12 +2159,14 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 		let byteLength = first.chunk.byteLength;
 		let end = head;
 		let allowRetry = first.allowRetry;
+		let completions = first.completions || null;
 		while (end < chunks.length) {
 			const next = chunks[end];
 			const nextLength = byteLength + next.chunk.byteLength;
 			if (nextLength > 上行合包目标字节) break;
 			byteLength = nextLength;
 			allowRetry = allowRetry && next.allowRetry;
+			if (next.completions) completions = completions ? completions.concat(next.completions) : next.completions;
 			end++;
 		}
 		if (end === head) return first;
@@ -2156,7 +2182,7 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 			offset += next.chunk.byteLength;
 		}
 		compact();
-		return { chunk: output.subarray(0, byteLength), allowRetry };
+		return { chunk: output.subarray(0, byteLength), allowRetry, completions };
 	};
 
 	const drain = async () => {
@@ -2169,20 +2195,30 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 				if (!item) break;
 				let writer = 获取写入器();
 				if (!writer) throw new Error(`${名称}: remote writer unavailable`);
+				const completions = item.completions || null;
+				activeCompletions = completions;
 				try {
-					await writer.write(item.chunk);
+					try {
+						await writer.write(item.chunk);
+					} catch (err) {
+						释放写入器?.();
+						if (!item.allowRetry || typeof 重试连接 !== 'function') throw err;
+						await 重试连接();
+						writer = 获取写入器();
+						if (!writer) throw err;
+						await writer.write(item.chunk);
+					}
+					settleCompletions(completions);
 				} catch (err) {
-					释放写入器?.();
-					if (!item.allowRetry || typeof 重试连接 !== 'function') throw err;
-					await 重试连接();
-					writer = 获取写入器();
-					if (!writer) throw err;
-					await writer.write(item.chunk);
+					settleCompletions(completions, err);
+					throw err;
+				} finally {
+					if (activeCompletions === completions) activeCompletions = null;
 				}
 			}
 		} catch (err) {
 			closed = true;
-			clear();
+			clear(err);
 			log(`[${名称}] 写入失败: ${err?.message || err}`);
 			try { 关闭连接?.(err) } catch (_) { }
 		} finally {
@@ -2192,25 +2228,40 @@ function 创建上行写入队列({ 获取写入器, 释放写入器, 重试连
 		}
 	};
 
+	const enqueue = (data, allowRetry = true, waitForFlush = false) => {
+		if (closed) return false;
+		// 首包解析阶段 socket 可能尚未建立；返回 false 交给上层继续走协议解析路径。
+		if (!获取写入器()) return false;
+		const chunk = 数据转Uint8Array(data);
+		if (!chunk.byteLength) return true;
+		const nextBytes = queuedBytes + chunk.byteLength;
+		const nextItems = chunks.length - head + 1;
+		if (nextBytes > 上行队列最大字节 || nextItems > 上行队列最大条目) {
+			closed = true;
+			const err = Object.assign(new Error(`${名称}: upload queue overflow (${nextBytes}B/${nextItems})`), { isQueueOverflow: true });
+			clear(err);
+			log(`[${名称}] 队列超限，关闭连接`);
+			try { 关闭连接?.(err) } catch (_) { }
+			throw err;
+		}
+		let completionPromise = null;
+		let completions = null;
+		if (waitForFlush) {
+			completions = [];
+			completionPromise = new Promise((resolve, reject) => completions.push({ resolve, reject }));
+		}
+		chunks.push({ chunk, allowRetry, completions });
+		queuedBytes = nextBytes;
+		if (!draining) queueMicrotask(drain);
+		return waitForFlush ? completionPromise.then(() => true) : true;
+	};
+
 	return {
 		写入(data, allowRetry = true) {
-			if (closed) return false;
-			// 首包解析阶段 socket 可能尚未建立；返回 false 交给上层继续走协议解析路径。
-			if (!获取写入器()) return false;
-			const chunk = 数据转Uint8Array(data);
-			if (!chunk.byteLength) return true;
-			if (queuedBytes + chunk.byteLength > 上行队列最大字节 || chunks.length - head >= 上行队列最大条目) {
-				closed = true;
-				clear();
-				const err = Object.assign(new Error(`${名称}: upload queue overflow`), { isQueueOverflow: true });
-				log(`[${名称}] 队列超限，关闭连接`);
-				try { 关闭连接?.(err) } catch (_) { }
-				throw err;
-			}
-			chunks.push({ chunk, allowRetry });
-			queuedBytes += chunk.byteLength;
-			if (!draining) queueMicrotask(drain);
-			return true;
+			return enqueue(data, allowRetry, false);
+		},
+		写入并等待(data, allowRetry = true) {
+			return enqueue(data, allowRetry, true);
 		},
 		async 等待空() {
 			if (!queuedBytes && !draining) return;