quickwin 2.3.0 → 2.3.1

package/constants.ts

@@ -961,6 +961,13 @@ export const enum ProcessCreationFlag {
     NO_WINDOW = 134217728, // 0x8000000
 }
 
+// File
+export const enum MoveFileFlag {
+    REPLACE_EXISTING = 1, // 0x1
+    COPY_ALLOWED = 2, // 0x2
+    WRITE_THROUGH = 8, // 0x8
+}
+
 // Error codes
 export const enum ErrorCode {
     FILE_NOT_FOUND = 2, // 0x2

package/enum_map.d.ts

@@ -108,6 +108,7 @@ interface EnumMap {
     IDI: import('./constants').IDI
     DrawTextFlag: import('./constants').DrawTextFlag
     ProcessCreationFlag: import('./constants').ProcessCreationFlag
+    MoveFileFlag: import('./constants').MoveFileFlag
     ErrorCode: import('./constants').ErrorCode
     PowerBroadcast: import('./constants').PowerBroadcast
     DevMode: import('./constants').DevMode

package/examples/execd/main.js

@@ -18535,6 +18535,8 @@ function concatU8(parts) {
   return out;
 }
 function toArrayBuffer(u8) {
+  if (u8.byteOffset === 0 && u8.byteLength === u8.buffer.byteLength)
+    return u8.buffer;
   return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
 }
 function findCrLfCrLf(buf) {
@@ -18694,6 +18696,7 @@ var HttpServer = class {
       const c2 = {
         sock: ac.handle,
         parts: [],
+        partsLen: 0,
         pending: null,
         current: null,
         outQueue: null,
@@ -18732,7 +18735,9 @@ function onRead(c2) {
     const d2 = sock.recv(c2.sock, 8192);
     if (!d2)
       break;
-    c2.parts.push(new Uint8Array(d2));
+    const u8 = new Uint8Array(d2);
+    c2.parts.push(u8);
+    c2.partsLen += u8.length;
   }
   if (!c2.closed)
     tryProcess(c2);
@@ -18822,11 +18827,17 @@ async function writeStreamingBody(c2, body, chunked, trailer) {
       if (done)
         break;
       if (value && value.byteLength > 0) {
-        const frame = chunked ? encodeChunkFrame(value, enc) : value;
-        if (!queueSend(c2, frame)) {
-          await new Promise((resolve) => {
-            c2.resumeRead = resolve;
-          });
+        const MAX_SEND = 65536;
+        for (let off = 0; off < value.byteLength; off += MAX_SEND) {
+          const piece = value.byteLength <= MAX_SEND ? value : value.subarray(off, Math.min(off + MAX_SEND, value.byteLength));
+          const frame = chunked ? encodeChunkFrame(piece, enc) : piece;
+          if (!queueSend(c2, frame)) {
+            await new Promise((resolve) => {
+              c2.resumeRead = resolve;
+            });
+          }
+          if (c2.closed)
+            break;
         }
       }
     }
@@ -18867,36 +18878,36 @@ function whole(c2) {
 function trimParts(c2, buf, consumed) {
   if (consumed >= buf.length) {
     c2.parts = [];
+    c2.partsLen = 0;
   } else {
     c2.parts = [buf.subarray(consumed)];
+    c2.partsLen = buf.length - consumed;
   }
 }
 function tryProcess(c2) {
   if (c2.closed || c2.current)
     return;
-  const buf = whole(c2);
   if (c2.pending) {
     const bodyStart2 = c2.pending.bodyStart;
     const parsed2 = c2.pending.parsed;
-    let body;
-    let end;
-    if (parsed2.chunked) {
-      const dec = decodeChunked(buf, bodyStart2);
-      if (!dec)
-        return;
-      body = dec.data;
-      end = dec.end;
-    } else {
-      const needed = parsed2.contentLength;
-      if (bodyStart2 + needed > buf.length)
+    if (!parsed2.chunked) {
+      const end = bodyStart2 + parsed2.contentLength;
+      if (end > c2.partsLen)
         return;
-      body = buf.subarray(bodyStart2, bodyStart2 + needed);
-      end = bodyStart2 + needed;
+      const buf3 = whole(c2);
+      c2.pending = null;
+      dispatchRequest(c2, parsed2, buf3.subarray(bodyStart2, end), end, buf3);
+      return;
     }
+    const buf2 = whole(c2);
+    const dec = decodeChunked(buf2, bodyStart2);
+    if (!dec)
+      return;
     c2.pending = null;
-    dispatchRequest(c2, parsed2, body, end);
+    dispatchRequest(c2, parsed2, dec.data, dec.end, buf2);
     return;
   }
+  const buf = whole(c2);
   const headerEnd = findCrLfCrLf(buf);
   if (headerEnd < 0)
     return;
@@ -18914,18 +18925,18 @@ function tryProcess(c2) {
       c2.pending = { parsed, bodyStart };
       return;
     }
-    dispatchRequest(c2, parsed, dec.data, dec.end);
+    dispatchRequest(c2, parsed, dec.data, dec.end, buf);
   } else if (parsed.contentLength > 0) {
     if (bodyStart + parsed.contentLength > buf.length) {
       c2.pending = { parsed, bodyStart };
       return;
     }
-    dispatchRequest(c2, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength);
+    dispatchRequest(c2, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength, buf);
   } else {
-    dispatchRequest(c2, parsed, new Uint8Array(0), bodyStart);
+    dispatchRequest(c2, parsed, new Uint8Array(0), bodyStart, buf);
   }
 }
-function dispatchRequest(c2, parsed, body, end) {
+function dispatchRequest(c2, parsed, body, end, wholeBuf) {
   const connHeader = (parsed.headers["connection"] || "").toLowerCase();
   if (parsed.version === "HTTP/1.1")
     c2.keepAlive = connHeader.indexOf("close") < 0;
@@ -18948,7 +18959,7 @@ function dispatchRequest(c2, parsed, body, end) {
   });
   c2.ac = ac;
   c2.current = { req };
-  trimParts(c2, whole(c2), end);
+  trimParts(c2, wholeBuf ?? whole(c2), end);
   void handleRequest(c2);
 }
 async function handleRequest(c2) {
@@ -22022,10 +22033,6 @@ function createRoot(container) {
 // _build/examples/execd/main.js
 var import_react18 = __toESM(require_react(), 1);
 
-// _build/examples/execd/tray.js
-import * as os6 from "os";
-import * as gui18 from "gui";
-
 // _build/lib/windows/kernel32.js
 var b7 = (name, sig, encoders) => bind2("kernel32.dll", name, sig, encoders);
 var CloseHandle = /* @__PURE__ */ b7("CloseHandle", "<>ptr -> i32");
@@ -22034,9 +22041,13 @@ var GetCurrentProcess = /* @__PURE__ */ b7("GetCurrentProcess", " -> <HPROCESS>p
 var VirtualAllocEx = /* @__PURE__ */ b7("VirtualAllocEx", "<HPROCESS>ptr <>ptr <>ptr u32 u32 -> <>ptr");
 var VirtualFreeEx = /* @__PURE__ */ b7("VirtualFreeEx", "<HPROCESS>ptr <>ptr <>ptr u32 -> i32");
 var ReadProcessMemory = /* @__PURE__ */ b7("ReadProcessMemory", "<HPROCESS>ptr <>ptr <BYTE>ptr <>ptr <>ptr -> i32");
+var MoveFileEx = /* @__PURE__ */ b7("MoveFileExW", "<WCHAR>ptr! <WCHAR>ptr! u32 -> i32");
+var GetLastError = /* @__PURE__ */ b7("GetLastError", " -> u32");
 var IsWow64Process = /* @__PURE__ */ b7("IsWow64Process", "<HPROCESS>ptr <BYTE>ptr -> i32");
 
 // _build/examples/execd/tray.js
+import * as os6 from "os";
+import * as gui18 from "gui";
 var TB_GETBUTTON = 1047;
 var TB_BUTTONCOUNT = 1048;
 var TB_GETITEMRECT = 1053;
@@ -22744,7 +22755,14 @@ API\uFF08\u914D\u7F6E token \u540E\u9700 Authorization: Bearer <token>\uFF0C\u67
   POST /input        body = JSON \u6570\u7EC4\uFF08\u6279\u91CF\u6CE8\u5165\uFF1Bx/y \u7269\u7406\u50CF\u7D20\uFF09\uFF1A
                      {"t":"move","x":,"y":} | {"t":"down|up","btn":"left|right|middle|x1|x2","x":,"y":?} |
                      {"t":"key","key":"a|enter|0x41","up":true?} | {"t":"sleep","ms":0..5000}
-                     \u2192 JSON {sent,expected}\uFF1B\u6309 sleep \u5207\u6BB5\uFF0C\u6BB5\u5185\u4E00\u6B21 SendInput \u539F\u5B50\u6CE8\u5165`;
+                     \u2192 JSON {sent,expected}\uFF1B\u6309 sleep \u5207\u6BB5\uFF0C\u6BB5\u5185\u4E00\u6B21 SendInput \u539F\u5B50\u6CE8\u5165
+  POST /upload       ?path=<\u76EE\u6807\u8DEF\u5F84>&mkdir=0 body=\u539F\u59CB\u5B57\u8282\uFF08\u975E\u7A7A\uFF09\u2192 JSON {bytes,path}
+                     \u9ED8\u8BA4\u9010\u5C42\u5EFA\u7236\u76EE\u5F55\uFF08mkdir=0 \u4E25\u683C\u8981\u6C42\u7236\u76EE\u5F55\u5DF2\u5B58\u5728\uFF0C\u9632\u8DEF\u5F84 typo\uFF09\uFF1B
+                     \u539F\u5B50\u5199\uFF1A\u5148\u5199 <path>.uploading \u518D MoveFileEx \u8986\u76D6\uFF0C\u770B\u4E0D\u5230\u534A\u622A\u6587\u4EF6\u3002
+                     \u65E0 SMB \u73AF\u5883\u7684\u4F20\u6587\u4EF6\u901A\u9053\uFF0C\u8DEF\u5F84\u5168\u653E\u5F00\u30028MB \u5206\u5757\u5199\u76D8\uFF08CRT \u5355\u5757\u5927\u5199
+                     \u5728 XP \u7F51\u7EDC\u76D8 ~64MiB \u8FB9\u754C\u4F1A\u88AB\u6574\u5757\u62D2\u7EDD\uFF09\uFF0CXP/win7 \u5B9E\u6D4B 100MB+ OK
+  GET  /download     ?path=<\u6587\u4EF6\u8DEF\u5F84> \u2192 \u539F\u59CB\u5B57\u8282\u6D41\uFF08application/octet-stream\uFF0CX-Bytes \u5934\uFF1B
+                     \u5206\u5757\u8BFB\u5230 EOF \u65E0\u5927\u5C0F\u4E0A\u9650\uFF09\u2014\u2014type \u547D\u4EE4\u7684\u4E8C\u8FDB\u5236\u5B89\u5168\u7248`;
 function usageResponse() {
   return new Response(USAGE, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
 }
@@ -22809,10 +22827,23 @@ function vkOf(key) {
   }
   throw new Error("bad key: " + JSON.stringify(key) + " (a-z/0-9|name|0..0xFFFF)");
 }
+function mkdirParents(dest) {
+  const segs = dest.replace(/\//g, "\\").split("\\");
+  let acc = "";
+  for (let i2 = 0; i2 < segs.length - 1; i2++) {
+    acc = acc === "" ? segs[i2] : acc + "\\" + segs[i2];
+    if (acc === "" || /^[A-Za-z]:$/.test(acc))
+      continue;
+    try {
+      os7.mkdir(acc);
+    } catch {
+    }
+  }
+}
 var server = createServer(async (req) => {
   const t0 = Date.now();
   const path = new URL(req.url).pathname;
-  const isApi = req.method === "POST" && (path === "/exec" || path === "/set_resolution" || path === "/input") || req.method === "GET" && (path === "/window_list" || path === "/screenshot" || path === "/tray_list");
+  const isApi = req.method === "POST" && (path === "/exec" || path === "/set_resolution" || path === "/input" || path === "/upload") || req.method === "GET" && (path === "/window_list" || path === "/screenshot" || path === "/tray_list" || path === "/download");
   if (!isApi)
     return usageResponse();
   const denied = authCheck(req);
@@ -23031,6 +23062,103 @@ var server = createServer(async (req) => {
       return jsonError(504, String(ex));
     }
   }
+  if (req.method === "POST" && path === "/upload") {
+    const bad = (msg) => {
+      logReq(t0, "POST /upload", 400, msg);
+      return jsonError(400, msg);
+    };
+    const params = new URL(req.url).searchParams;
+    const dest = params.get("path");
+    if (!dest)
+      return bad("path=<\u76EE\u6807\u8DEF\u5F84>");
+    let bytes;
+    try {
+      bytes = new Uint8Array(await req.arrayBuffer());
+    } catch (ex) {
+      return bad("bad body: " + String(ex));
+    }
+    if (bytes.length === 0)
+      return bad("empty body");
+    try {
+      if (params.get("mkdir") !== "0")
+        mkdirParents(dest);
+      const tmp = dest + ".uploading";
+      const f2 = std2.open(tmp, "wb");
+      if (!f2)
+        throw new Error("open for write failed: " + tmp);
+      let w2 = 0;
+      try {
+        const CHUNK = 8 * 1024 * 1024;
+        for (let off = 0; off < bytes.length; off += CHUNK) {
+          const n2 = f2.write(bytes.buffer, off, Math.min(CHUNK, bytes.length - off));
+          if (n2 <= 0)
+            break;
+          w2 += n2;
+        }
+      } finally {
+        f2.close();
+      }
+      if (w2 !== bytes.length)
+        throw new Error("short write: " + w2 + "/" + bytes.length);
+      if (!MoveFileEx(
+        tmp,
+        dest,
+        1
+        /* MoveFileFlag.REPLACE_EXISTING */
+      ))
+        throw new Error("MoveFileEx failed (GetLastError " + GetLastError() + "): " + tmp + " -> " + dest);
+    } catch (ex) {
+      logReq(t0, "POST /upload", 500, String(ex));
+      return jsonError(500, String(ex));
+    }
+    logReq(t0, "POST /upload", 200, bytes.length + "B -> " + dest);
+    return new Response(JSON.stringify({ bytes: bytes.length, path: dest }), { headers: { "Content-Type": "application/json" } });
+  }
+  if (req.method === "GET" && path === "/download") {
+    const p2 = new URL(req.url).searchParams.get("path");
+    if (!p2) {
+      logReq(t0, "GET /download", 400, "path=<\u6587\u4EF6\u8DEF\u5F84>");
+      return jsonError(400, "path=<\u6587\u4EF6\u8DEF\u5F84>");
+    }
+    let f2 = null;
+    try {
+      f2 = std2.open(p2, "rb");
+    } catch (ex) {
+      logReq(t0, "GET /download", 500, String(ex));
+      return jsonError(500, String(ex));
+    }
+    if (f2 === null) {
+      logReq(t0, "GET /download", 404, p2);
+      return jsonError(404, "cannot open: " + p2);
+    }
+    try {
+      const chunks = [];
+      const buf = new Uint8Array(64 * 1024);
+      let total = 0;
+      for (; ; ) {
+        const n2 = f2.read(buf.buffer, 0, buf.length);
+        if (n2 <= 0)
+          break;
+        chunks.push(n2 === buf.length ? buf.slice() : buf.slice(0, n2));
+        total += n2;
+      }
+      const all = new Uint8Array(total);
+      let off = 0;
+      for (const c2 of chunks) {
+        all.set(c2, off);
+        off += c2.length;
+      }
+      logReq(t0, "GET /download", 200, total + "B <- " + p2);
+      return new Response(all, {
+        headers: { "Content-Type": "application/octet-stream", "X-Bytes": String(total) }
+      });
+    } catch (ex) {
+      logReq(t0, "GET /download", 500, String(ex));
+      return jsonError(500, String(ex));
+    } finally {
+      f2.close();
+    }
+  }
   return usageResponse();
 });
 var rc = server.listen(8080, "0.0.0.0");

package/lib/http-server.js

@@ -24,6 +24,11 @@ function concatU8(parts) {
     return out;
 }
 function toArrayBuffer(u8) {
+    // 已经是完整 buffer（byteOffset=0、无尾部余量）时零复制返回——发送大
+    // body 的主路径，避免每片 send 前白拷一份。视图场景仍 slice 出独立副本
+    //（FFI 持有的 buffer 生命周期不受 view 约束）。
+    if (u8.byteOffset === 0 && u8.byteLength === u8.buffer.byteLength)
+        return u8.buffer;
     return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
 }
 function findCrLfCrLf(buf) {
@@ -190,6 +195,7 @@ export class HttpServer {
             const c = {
                 sock: ac.handle,
                 parts: [],
+                partsLen: 0,
                 pending: null,
                 current: null,
                 outQueue: null,
@@ -229,7 +235,9 @@ function onRead(c) {
         const d = sock.recv(c.sock, 8192);
         if (!d)
             break;
-        c.parts.push(new Uint8Array(d));
+        const u8 = new Uint8Array(d);
+        c.parts.push(u8);
+        c.partsLen += u8.length;
     }
     if (!c.closed)
         tryProcess(c);
@@ -334,9 +342,19 @@ async function writeStreamingBody(c, body, chunked, trailer) {
             if (done)
                 break;
             if (value && value.byteLength > 0) {
-                const frame = chunked ? encodeChunkFrame(value, enc) : value;
-                if (!queueSend(c, frame)) {
-                    await new Promise((resolve) => { c.resumeRead = resolve; });
+                // 切成 ≤64KB 再入 queueSend：单发 200MB 级大 chunk 时
+                // toArrayBuffer 会全量 slice 复制，partial drain 又每次复制
+                // 剩余（O(n²)），XP 32 位 1GB 上直接把进程水位顶穿导致断连；
+                // 小片让每次复制/发送恒为常数大小，backpressure 语义不变。
+                const MAX_SEND = 65536;
+                for (let off = 0; off < value.byteLength; off += MAX_SEND) {
+                    const piece = value.byteLength <= MAX_SEND ? value : value.subarray(off, Math.min(off + MAX_SEND, value.byteLength));
+                    const frame = chunked ? encodeChunkFrame(piece, enc) : piece;
+                    if (!queueSend(c, frame)) {
+                        await new Promise((resolve) => { c.resumeRead = resolve; });
+                    }
+                    if (c.closed)
+                        break;
                 }
             }
         }
@@ -383,38 +401,43 @@ function whole(c) {
 function trimParts(c, buf, consumed) {
     if (consumed >= buf.length) {
         c.parts = [];
+        c.partsLen = 0;
     }
     else {
         c.parts = [buf.subarray(consumed)];
+        c.partsLen = buf.length - consumed;
     }
 }
 function tryProcess(c) {
     if (c.closed || c.current)
         return;
-    const buf = whole(c);
     if (c.pending) {
         const bodyStart = c.pending.bodyStart;
         const parsed = c.pending.parsed;
-        let body;
-        let end;
-        if (parsed.chunked) {
-            const dec = decodeChunked(buf, bodyStart);
-            if (!dec)
-                return;
-            body = dec.data;
-            end = dec.end;
-        }
-        else {
-            const needed = parsed.contentLength;
-            if (bodyStart + needed > buf.length)
+        if (!parsed.chunked) {
+            // O(1) length check while the body is still arriving — only
+            // concatenate once, when the last byte is in.
+            const end = bodyStart + parsed.contentLength;
+            if (end > c.partsLen)
                 return;
-            body = buf.subarray(bodyStart, bodyStart + needed);
-            end = bodyStart + needed;
+            const buf = whole(c);
+            c.pending = null;
+            dispatchRequest(c, parsed, buf.subarray(bodyStart, end), end, buf);
+            return;
         }
+        // chunked: no total length up front, so a decode attempt still needs
+        // the concatenated view (re-tried per read event as before).
+        const buf = whole(c);
+        const dec = decodeChunked(buf, bodyStart);
+        if (!dec)
+            return;
         c.pending = null;
-        dispatchRequest(c, parsed, body, end);
+        dispatchRequest(c, parsed, dec.data, dec.end, buf);
         return;
     }
+    // Header phase: bodies are checked against `partsLen` above, so a full
+    // concatenation is only needed here — once per request, not per read.
+    const buf = whole(c);
     const headerEnd = findCrLfCrLf(buf);
     if (headerEnd < 0)
         return;
@@ -432,20 +455,20 @@ function tryProcess(c) {
             c.pending = { parsed, bodyStart };
             return;
         }
-        dispatchRequest(c, parsed, dec.data, dec.end);
+        dispatchRequest(c, parsed, dec.data, dec.end, buf);
     }
     else if (parsed.contentLength > 0) {
         if (bodyStart + parsed.contentLength > buf.length) {
             c.pending = { parsed, bodyStart };
             return;
         }
-        dispatchRequest(c, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength);
+        dispatchRequest(c, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength, buf);
     }
     else {
-        dispatchRequest(c, parsed, new Uint8Array(0), bodyStart);
+        dispatchRequest(c, parsed, new Uint8Array(0), bodyStart, buf);
     }
 }
-function dispatchRequest(c, parsed, body, end) {
+function dispatchRequest(c, parsed, body, end, wholeBuf) {
     const connHeader = (parsed.headers['connection'] || '').toLowerCase();
     if (parsed.version === 'HTTP/1.1')
         c.keepAlive = connHeader.indexOf('close') < 0;
@@ -468,7 +491,9 @@ function dispatchRequest(c, parsed, body, end) {
     });
     c.ac = ac;
     c.current = { req };
-    trimParts(c, whole(c), end);
+    // `wholeBuf` is the concatenation the caller already produced — reuse it
+    // instead of concatenating the very same parts a second time.
+    trimParts(c, wholeBuf ?? whole(c), end);
     void handleRequest(c);
 }
 async function handleRequest(c) {

package/lib/http-server.ts

@@ -35,6 +35,10 @@ interface ActiveReq {
 interface Conn {
     sock: SockHandle
     parts: Uint8Array[]
+    /** Cached total length of `parts` — lets the pending-body wait check
+     *  "have we received enough yet" in O(1) instead of re-concatenating
+     *  every received byte on each read event (O(n²) for large bodies). */
+    partsLen: number
     pending: PendingReq | null
     current: ActiveReq | null
     outQueue: Uint8Array | null
@@ -69,6 +73,10 @@ function concatU8(parts: Uint8Array[]): Uint8Array {
 }
 
 function toArrayBuffer(u8: Uint8Array): ArrayBuffer {
+    // 已经是完整 buffer（byteOffset=0、无尾部余量）时零复制返回——发送大
+    // body 的主路径，避免每片 send 前白拷一份。视图场景仍 slice 出独立副本
+    //（FFI 持有的 buffer 生命周期不受 view 约束）。
+    if (u8.byteOffset === 0 && u8.byteLength === u8.buffer.byteLength) return u8.buffer as ArrayBuffer
     return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength) as ArrayBuffer
 }
 
@@ -213,6 +221,7 @@ export class HttpServer {
             const c: Conn = {
                 sock: ac.handle,
                 parts: [],
+                partsLen: 0,
                 pending: null,
                 current: null,
                 outQueue: null,
@@ -251,7 +260,9 @@ function onRead(c: Conn): void {
     while (true) {
         const d = sock.recv(c.sock, 8192)
         if (!d) break
-        c.parts.push(new Uint8Array(d))
+        const u8 = new Uint8Array(d)
+        c.parts.push(u8)
+        c.partsLen += u8.length
     }
     if (!c.closed) tryProcess(c)
 }
@@ -350,9 +361,18 @@ async function writeStreamingBody(c: Conn, body: ReadableStream<Uint8Array> | nu
             const { done, value } = await reader.read()
             if (done) break
             if (value && value.byteLength > 0) {
-                const frame = chunked ? encodeChunkFrame(value, enc) : value
-                if (!queueSend(c, frame)) {
-                    await new Promise<void>((resolve) => { c.resumeRead = resolve })
+                // 切成 ≤64KB 再入 queueSend：单发 200MB 级大 chunk 时
+                // toArrayBuffer 会全量 slice 复制，partial drain 又每次复制
+                // 剩余（O(n²)），XP 32 位 1GB 上直接把进程水位顶穿导致断连；
+                // 小片让每次复制/发送恒为常数大小，backpressure 语义不变。
+                const MAX_SEND = 65536
+                for (let off = 0; off < value.byteLength; off += MAX_SEND) {
+                    const piece = value.byteLength <= MAX_SEND ? value : value.subarray(off, Math.min(off + MAX_SEND, value.byteLength))
+                    const frame = chunked ? encodeChunkFrame(piece, enc) : piece
+                    if (!queueSend(c, frame)) {
+                        await new Promise<void>((resolve) => { c.resumeRead = resolve })
+                    }
+                    if (c.closed) break
                 }
             }
         }
@@ -396,36 +416,42 @@ function whole(c: Conn): Uint8Array {
 function trimParts(c: Conn, buf: Uint8Array, consumed: number): void {
     if (consumed >= buf.length) {
         c.parts = []
+        c.partsLen = 0
     } else {
         c.parts = [buf.subarray(consumed)]
+        c.partsLen = buf.length - consumed
     }
 }
 
 function tryProcess(c: Conn): void {
     if (c.closed || c.current) return
-    const buf = whole(c)
 
     if (c.pending) {
         const bodyStart = c.pending.bodyStart
         const parsed = c.pending.parsed
-        let body: Uint8Array
-        let end: number
-        if (parsed.chunked) {
-            const dec = decodeChunked(buf, bodyStart)
-            if (!dec) return
-            body = dec.data
-            end = dec.end
-        } else {
-            const needed = parsed.contentLength
-            if (bodyStart + needed > buf.length) return
-            body = buf.subarray(bodyStart, bodyStart + needed)
-            end = bodyStart + needed
+        if (!parsed.chunked) {
+            // O(1) length check while the body is still arriving — only
+            // concatenate once, when the last byte is in.
+            const end = bodyStart + parsed.contentLength
+            if (end > c.partsLen) return
+            const buf = whole(c)
+            c.pending = null
+            dispatchRequest(c, parsed, buf.subarray(bodyStart, end), end, buf)
+            return
         }
+        // chunked: no total length up front, so a decode attempt still needs
+        // the concatenated view (re-tried per read event as before).
+        const buf = whole(c)
+        const dec = decodeChunked(buf, bodyStart)
+        if (!dec) return
         c.pending = null
-        dispatchRequest(c, parsed, body, end)
+        dispatchRequest(c, parsed, dec.data, dec.end, buf)
         return
     }
 
+    // Header phase: bodies are checked against `partsLen` above, so a full
+    // concatenation is only needed here — once per request, not per read.
+    const buf = whole(c)
     const headerEnd = findCrLfCrLf(buf)
     if (headerEnd < 0) return
     const absEnd = headerEnd + 4
@@ -440,19 +466,19 @@ function tryProcess(c: Conn): void {
             c.pending = { parsed, bodyStart }
             return
         }
-        dispatchRequest(c, parsed, dec.data, dec.end)
+        dispatchRequest(c, parsed, dec.data, dec.end, buf)
     } else if (parsed.contentLength > 0) {
         if (bodyStart + parsed.contentLength > buf.length) {
             c.pending = { parsed, bodyStart }
             return
         }
-        dispatchRequest(c, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength)
+        dispatchRequest(c, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength, buf)
     } else {
-        dispatchRequest(c, parsed, new Uint8Array(0), bodyStart)
+        dispatchRequest(c, parsed, new Uint8Array(0), bodyStart, buf)
     }
 }
 
-function dispatchRequest(c: Conn, parsed: ParsedHeader, body: Uint8Array, end: number): void {
+function dispatchRequest(c: Conn, parsed: ParsedHeader, body: Uint8Array, end: number, wholeBuf?: Uint8Array): void {
     const connHeader = (parsed.headers['connection'] || '').toLowerCase()
     if (parsed.version === 'HTTP/1.1') c.keepAlive = connHeader.indexOf('close') < 0
     else c.keepAlive = connHeader.indexOf('keep-alive') >= 0
@@ -477,7 +503,9 @@ function dispatchRequest(c: Conn, parsed: ParsedHeader, body: Uint8Array, end: n
 
     c.ac = ac
     c.current = { req }
-    trimParts(c, whole(c), end)
+    // `wholeBuf` is the concatenation the caller already produced — reuse it
+    // instead of concatenating the very same parts a second time.
+    trimParts(c, wholeBuf ?? whole(c), end)
     void handleRequest(c)
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "quickwin",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "QuickJS Win32 runtime — GUI, networking, WASM, FFI, and more",
   "bin": {
     "quickwin": "qwin.exe",