quickwin 2.2.0 → 2.3.1

package/lib/fetch.js

@@ -180,7 +180,7 @@ async function fetchRequest(req) {
         sock.set_on_event(fd, (event) => {
             if (state === ST_DONE)
                 return;
-            if (event.lNetworkEvents & 16 /* sock.FdEvent.FD_CONNECT */) {
+            if (event.lNetworkEvents & 16 /* FdEvent.FD_CONNECT */) {
                 const err = event.iErrorCode[0];
                 if (err !== 0) {
                     doReject(new Error('Connection failed: ' + err));
@@ -194,10 +194,10 @@ async function fetchRequest(req) {
                         return;
                     }
                     if (req.rejectUnauthorized === false) {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, 0 /* wolfssl.VerifyMode.SSL_VERIFY_NONE */);
+                        wolfssl.wolfSSL_CTX_set_verify(ctx, 0 /* VerifyMode.SSL_VERIFY_NONE */);
                     }
                     else {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, 1 /* wolfssl.VerifyMode.SSL_VERIFY_PEER */);
+                        wolfssl.wolfSSL_CTX_set_verify(ctx, 1 /* VerifyMode.SSL_VERIFY_PEER */);
                         wolfssl.loadTrustedCerts(ctx);
                     }
                     ssl = wolfssl.wolfSSL_new(ctx);
@@ -207,7 +207,7 @@ async function fetchRequest(req) {
                     }
                     wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(fd));
                     if (parsedUrl.hostname) {
-                        wolfssl.wolfSSL_UseSNI(ssl, 0 /* wolfssl.SniType.WOLFSSL_SNI_HOST_NAME */, parsedUrl.hostname);
+                        wolfssl.wolfSSL_UseSNI(ssl, 0 /* SniType.WOLFSSL_SNI_HOST_NAME */, parsedUrl.hostname);
                         if (req.rejectUnauthorized !== false) {
                             wolfssl.wolfSSL_check_domain_name(ssl, parsedUrl.hostname);
                         }
@@ -219,21 +219,21 @@ async function fetchRequest(req) {
                     state = ST_RECV_HEADERS;
                 }
             }
-            if ((event.lNetworkEvents & 1 /* sock.FdEvent.FD_READ */) || (event.lNetworkEvents & 2 /* sock.FdEvent.FD_WRITE */)) {
+            if ((event.lNetworkEvents & 1 /* FdEvent.FD_READ */) || (event.lNetworkEvents & 2 /* FdEvent.FD_WRITE */)) {
                 if (state === ST_HANDSHAKE) {
                     if (!ssl) {
                         doReject(new Error('TLS not initialized'));
                         return;
                     }
                     const ret = wolfssl.wolfSSL_connect(ssl);
-                    if (ret === 1 /* wolfssl.ReturnCode.SSL_SUCCESS */) {
+                    if (ret === 1 /* ReturnCode.SSL_SUCCESS */) {
                         wolfssl.wolfSSL_write(ssl, httpRequest);
                         state = ST_RECV_HEADERS;
                     }
                     else {
                         const err = wolfssl.wolfSSL_get_error(ssl, ret);
-                        if (err !== 2 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ */ &&
-                            err !== 3 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE */) {
+                        if (err !== 2 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ */ &&
+                            err !== 3 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE */) {
                             doReject(new Error('TLS handshake failed: ' + err));
                         }
                     }
@@ -251,10 +251,10 @@ async function fetchRequest(req) {
                             }
                             else {
                                 const err = wolfssl.wolfSSL_get_error(ssl, n);
-                                if (err === 2 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ */ ||
-                                    err === 3 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE */)
+                                if (err === 2 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ */ ||
+                                    err === 3 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE */)
                                     break;
-                                if (n === 0 || err === 6 /* wolfssl.ErrorCode.WOLFSSL_ERROR_ZERO_RETURN */)
+                                if (n === 0 || err === 6 /* WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN */)
                                     break;
                                 doReject(new Error('TLS read failed: ' + err));
                                 return;
@@ -338,10 +338,10 @@ async function fetchRequest(req) {
                             }
                             else {
                                 const err = wolfssl.wolfSSL_get_error(ssl, n);
-                                if (err === 2 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ */ ||
-                                    err === 3 /* wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE */)
+                                if (err === 2 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ */ ||
+                                    err === 3 /* WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE */)
                                     break;
-                                if (n === 0 || err === 6 /* wolfssl.ErrorCode.WOLFSSL_ERROR_ZERO_RETURN */)
+                                if (n === 0 || err === 6 /* WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN */)
                                     break;
                                 // Fatal TLS error mid-body: the response already
                                 // resolved, so fail the body stream instead of
@@ -390,7 +390,7 @@ async function fetchRequest(req) {
                     }
                 }
             }
-            if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+            if (event.lNetworkEvents & 32 /* FdEvent.FD_CLOSE */) {
                 if (state === ST_DONE)
                     return;
                 if (state === ST_RECV_HEADERS) {

package/lib/fetch.ts

@@ -12,6 +12,7 @@ import {
     RequestImpl,
     ResponseImpl,
 } from './http-common.js'
+import { FdEvent, ReturnCode, SniType, VerifyMode, WolfsslErrorCode } from '../constants'
 
 // ── HTTP Response Parser ──
 
@@ -178,7 +179,7 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
         sock.set_on_event(fd, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
             if (state === ST_DONE) return
 
-            if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+            if (event.lNetworkEvents & FdEvent.FD_CONNECT) {
                 const err = event.iErrorCode[0]
                 if (err !== 0) { doReject(new Error('Connection failed: ' + err)); return }
 
@@ -187,16 +188,16 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                     ctx = wolfssl.wolfSSL_CTX_new(tlsMethod)
                     if (!ctx) { doReject(new Error('SSL_CTX_new failed')); return }
                     if (req.rejectUnauthorized === false) {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_NONE)
+                        wolfssl.wolfSSL_CTX_set_verify(ctx, VerifyMode.SSL_VERIFY_NONE)
                     } else {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_PEER)
+                        wolfssl.wolfSSL_CTX_set_verify(ctx, VerifyMode.SSL_VERIFY_PEER)
                         wolfssl.loadTrustedCerts(ctx)
                     }
                     ssl = wolfssl.wolfSSL_new(ctx)
                     if (!ssl) { doReject(new Error('SSL_new failed')); return }
                     wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(fd))
                     if (parsedUrl.hostname) {
-                        wolfssl.wolfSSL_UseSNI(ssl, wolfssl.SniType.WOLFSSL_SNI_HOST_NAME, parsedUrl.hostname)
+                        wolfssl.wolfSSL_UseSNI(ssl, SniType.WOLFSSL_SNI_HOST_NAME, parsedUrl.hostname)
                         if (req.rejectUnauthorized !== false) {
                             wolfssl.wolfSSL_check_domain_name(ssl, parsedUrl.hostname)
                         }
@@ -208,17 +209,17 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                 }
             }
 
-            if ((event.lNetworkEvents & sock.FdEvent.FD_READ) || (event.lNetworkEvents & sock.FdEvent.FD_WRITE)) {
+            if ((event.lNetworkEvents & FdEvent.FD_READ) || (event.lNetworkEvents & FdEvent.FD_WRITE)) {
                 if (state === ST_HANDSHAKE) {
                     if (!ssl) { doReject(new Error('TLS not initialized')); return }
                     const ret = wolfssl.wolfSSL_connect(ssl)
-                    if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                    if (ret === ReturnCode.SSL_SUCCESS) {
                         wolfssl.wolfSSL_write(ssl, httpRequest)
                         state = ST_RECV_HEADERS
                     } else {
                         const err = wolfssl.wolfSSL_get_error(ssl, ret)
-                        if (err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ &&
-                            err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE) {
+                        if (err !== WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ &&
+                            err !== WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE) {
                             doReject(new Error('TLS handshake failed: ' + err))
                         }
                     }
@@ -234,9 +235,9 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                                 data = buf.slice(0, n)
                             } else {
                                 const err = wolfssl.wolfSSL_get_error(ssl, n)
-                                if (err === wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ ||
-                                    err === wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
-                                if (n === 0 || err === wolfssl.ErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
+                                if (err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ ||
+                                    err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
+                                if (n === 0 || err === WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
                                 doReject(new Error('TLS read failed: ' + err))
                                 return
                             }
@@ -315,9 +316,9 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                                 data = buf.slice(0, n)
                             } else {
                                 const err = wolfssl.wolfSSL_get_error(ssl, n)
-                                if (err === wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ ||
-                                    err === wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
-                                if (n === 0 || err === wolfssl.ErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
+                                if (err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ ||
+                                    err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
+                                if (n === 0 || err === WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
                                 // Fatal TLS error mid-body: the response already
                                 // resolved, so fail the body stream instead of
                                 // silently waiting for an FD event that never comes.
@@ -355,7 +356,7 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                 }
             }
 
-            if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+            if (event.lNetworkEvents & FdEvent.FD_CLOSE) {
                 if (state === ST_DONE) return
                 if (state === ST_RECV_HEADERS) {
                     doReject(new Error('Connection closed before response'))

package/lib/ffi/bind.js

@@ -73,7 +73,7 @@ function makeFn(proc, sig, encoders, decoders) {
     }
     return (...a) => callPacked(proc, ps, a, encoders, decoders);
 }
-// 每个参数在 argFrame 里占的字节数。与 quickjs-ffi-type.h 的 qwin_ffi_arg_size[]
+// 每个参数在 argFrame 里占的字节数。与 src/quickjs-ffi-type.h 的 qwin_ffi_arg_size[]
 // 保持一致（ia32：≤4B 类型进 4 字节、更大的进 8 字节；x64：恒 8 字节槽）。
 // 注意这是「槽宽」，不是类型的 sizeof——同一定义也用于返回槽。指针布局恒指针宽。
 const IA32_ARG_SIZE = {
@@ -334,7 +334,7 @@ const leakRegistry = new FinalizationRegistry((held) => {
 // args/ret 为「底档 + '!' 绑定」的记录（与 ParsedSig 同形态——修饰随 token 走，
 // 消费者要么整体拿到、要么整体拿不到）。'!' 违约（C 传入 0 / fn 返回 0）打印诊断并
 // 中止本次分发（fn 不被调用 / 结果槽保持 0），与 fn-throw 同风格：此处不 throw，
-// 异常通道只留给用户回调（C 桩捕获 wrapper 异常并清零，quickjs-ffi-closure.c）。
+// 异常通道只留给用户回调（C 桩捕获 wrapper 异常并清零，src/quickjs-ffi-closure.c）。
 function dispatchClosure(args, ret, fn, frameBuf, retBuf, sig) {
     const dv = new DataView(retBuf);
     const is64 = os.arch === 'x64';
@@ -409,7 +409,7 @@ export function closure(sig, fn, opts) {
     const retSpec = { tok: cTokenToType(retToken), nonnull: retToken.endsWith('!') };
     const is64 = os.arch === 'x64';
     const stackCapture = argSpecs.reduce((s, x) => s + IA32_ARG_SIZE[x.tok], 0);
-    // C 桩捕获窗定长（quickjs-ffi-closure.c：x64 栈区 96B=12 槽，第 5 参起在栈上，
+    // C 桩捕获窗定长（src/quickjs-ffi-closure.c：x64 栈区 96B=12 槽，第 5 参起在栈上，
     // 即至多 16 参；ia32 16×4B）——超限 dispatch 会读到捕获缓冲之外的垃圾，或
     // RangeError 被吞成返回 0，故创建期 fail-fast。扩容改 C 侧 buf 尺寸并同步放宽。
     if (is64 ? argSpecs.length > 16 : stackCapture > 64) {

package/lib/ffi/bind.ts

@@ -123,7 +123,7 @@ function makeFn(proc: number, sig: string, encoders: CodecMap, decoders: CodecMa
     return (...a: unknown[]) => callPacked(proc, ps, a, encoders, decoders)
 }
 
-// 每个参数在 argFrame 里占的字节数。与 quickjs-ffi-type.h 的 qwin_ffi_arg_size[]
+// 每个参数在 argFrame 里占的字节数。与 src/quickjs-ffi-type.h 的 qwin_ffi_arg_size[]
 // 保持一致（ia32：≤4B 类型进 4 字节、更大的进 8 字节；x64：恒 8 字节槽）。
 // 注意这是「槽宽」，不是类型的 sizeof——同一定义也用于返回槽。指针布局恒指针宽。
 const IA32_ARG_SIZE: Record<C_BasicType_No_Void, number> = {
@@ -429,7 +429,7 @@ const leakRegistry: FinalizationRegistry<{ sig: string, ptr: number }> =
 // args/ret 为「底档 + '!' 绑定」的记录（与 ParsedSig 同形态——修饰随 token 走，
 // 消费者要么整体拿到、要么整体拿不到）。'!' 违约（C 传入 0 / fn 返回 0）打印诊断并
 // 中止本次分发（fn 不被调用 / 结果槽保持 0），与 fn-throw 同风格：此处不 throw，
-// 异常通道只留给用户回调（C 桩捕获 wrapper 异常并清零，quickjs-ffi-closure.c）。
+// 异常通道只留给用户回调（C 桩捕获 wrapper 异常并清零，src/quickjs-ffi-closure.c）。
 function dispatchClosure(
     args: { tok: C_BasicType_No_Void, nonnull: boolean }[],
     ret: { tok: C_BasicType, nonnull: boolean },
@@ -508,7 +508,7 @@ export function closure<S extends string>(sig: S, fn: BindFn<S, {}, {}>,
     const retSpec = { tok: cTokenToType(retToken), nonnull: retToken.endsWith('!') }
     const is64 = os.arch === 'x64'
     const stackCapture = argSpecs.reduce((s, x) => s + IA32_ARG_SIZE[x.tok], 0)
-    // C 桩捕获窗定长（quickjs-ffi-closure.c：x64 栈区 96B=12 槽，第 5 参起在栈上，
+    // C 桩捕获窗定长（src/quickjs-ffi-closure.c：x64 栈区 96B=12 槽，第 5 参起在栈上，
     // 即至多 16 参；ia32 16×4B）——超限 dispatch 会读到捕获缓冲之外的垃圾，或
     // RangeError 被吞成返回 0，故创建期 fail-fast。扩容改 C 侧 buf 尺寸并同步放宽。
     if (is64 ? argSpecs.length > 16 : stackCapture > 64) {

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) {
@@ -163,7 +168,7 @@ export class HttpServer {
         }
         this.serverSock = s;
         sock.set_on_event(s, (event) => {
-            if (event.lNetworkEvents & 8 /* sock.FdEvent.FD_ACCEPT */)
+            if (event.lNetworkEvents & 8 /* FdEvent.FD_ACCEPT */)
                 this.acceptLoop();
         });
         return 0;
@@ -190,6 +195,7 @@ export class HttpServer {
             const c = {
                 sock: ac.handle,
                 parts: [],
+                partsLen: 0,
                 pending: null,
                 current: null,
                 outQueue: null,
@@ -207,11 +213,11 @@ export class HttpServer {
     onConnEvent(c, event) {
         if (c.closed)
             return;
-        if (event.lNetworkEvents & 1 /* sock.FdEvent.FD_READ */)
+        if (event.lNetworkEvents & 1 /* FdEvent.FD_READ */)
             onRead(c);
-        if (event.lNetworkEvents & 2 /* sock.FdEvent.FD_WRITE */)
+        if (event.lNetworkEvents & 2 /* FdEvent.FD_WRITE */)
             flushQueue(c);
-        if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+        if (event.lNetworkEvents & 32 /* FdEvent.FD_CLOSE */) {
             onRead(c);
             abortConn(c);
             closeConn(c);
@@ -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

@@ -2,6 +2,7 @@ import './polyfill.js'
 import * as sock from 'sock'
 import { HeadersImpl, RequestImpl, ResponseImpl, _readStream } from './http-common.js'
 import { AbortController } from './abort.js'
+import { FdEvent } from '../constants'
 
 type SockHandle = import('sock').SockHandle
 
@@ -34,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
@@ -68,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
 }
 
@@ -191,7 +200,7 @@ export class HttpServer {
         if (sock.listen(s, backlog ?? 64) !== 0) { sock.closesocket(s); return -1 }
         this.serverSock = s
         sock.set_on_event(s, (event: NetEvent) => {
-            if (event.lNetworkEvents & sock.FdEvent.FD_ACCEPT) this.acceptLoop()
+            if (event.lNetworkEvents & FdEvent.FD_ACCEPT) this.acceptLoop()
         })
         return 0
     }
@@ -212,6 +221,7 @@ export class HttpServer {
             const c: Conn = {
                 sock: ac.handle,
                 parts: [],
+                partsLen: 0,
                 pending: null,
                 current: null,
                 outQueue: null,
@@ -229,9 +239,9 @@ export class HttpServer {
 
     private onConnEvent(c: Conn, event: NetEvent): void {
         if (c.closed) return
-        if (event.lNetworkEvents & sock.FdEvent.FD_READ) onRead(c)
-        if (event.lNetworkEvents & sock.FdEvent.FD_WRITE) flushQueue(c)
-        if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+        if (event.lNetworkEvents & FdEvent.FD_READ) onRead(c)
+        if (event.lNetworkEvents & FdEvent.FD_WRITE) flushQueue(c)
+        if (event.lNetworkEvents & FdEvent.FD_CLOSE) {
             onRead(c)
             abortConn(c)
             closeConn(c)
@@ -250,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)
 }
@@ -349,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
                 }
             }
         }
@@ -395,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
@@ -439,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
@@ -476,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/lib/react-qw/components/Button.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from 'react';
 export const Button = forwardRef(({ children, onClick, style, disabled }, ref) => {
-    return (_jsx("w", { type: "BUTTON", text: children != null ? (Array.isArray(children) ? children.join('') : String(children)) : '', ws: 268435456 /* gui.WindowStyle.VISIBLE */, style: style, disabled: disabled, ref: ref, onEvent: (e) => {
-            if (e.msg === 514 /* gui.WmMsg.LBUTTONUP */)
+    return (_jsx("w", { type: "BUTTON", text: children != null ? (Array.isArray(children) ? children.join('') : String(children)) : '', ws: 268435456 /* WindowStyle.VISIBLE */, style: style, disabled: disabled, ref: ref, onEvent: (e) => {
+            if (e.msg === 514 /* WmMsg.LBUTTONUP */)
                 onClick?.();
         } }));
 });

package/lib/react-qw/components/CheckBox.js

@@ -10,17 +10,17 @@ export const CheckBox = forwardRef(({ checked: controlledChecked, defaultChecked
         const h = cbRef.current;
         if (!h)
             return;
-        gui.SendMessage(h, 241 /* gui.ButtonMsg.SETCHECK */, displayChecked ? 1 /* gui.ButtonCheckState.CHECKED */ : 0 /* gui.ButtonCheckState.UNCHECKED */, 0);
+        gui.SendMessage(h, 241 /* ButtonMsg.SETCHECK */, displayChecked ? 1 /* ButtonCheckState.CHECKED */ : 0 /* ButtonCheckState.UNCHECKED */, 0);
     }, [displayChecked]);
-    return (_jsx("w", { type: "BUTTON", text: label ?? '', ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 3 /* gui.ButtonStyle.AUTOCHECKBOX */, style: style, disabled: disabled, ref: (h) => {
+    return (_jsx("w", { type: "BUTTON", text: label ?? '', ws: 268435456 /* WindowStyle.VISIBLE */ | 3 /* ButtonStyle.AUTOCHECKBOX */, style: style, disabled: disabled, ref: (h) => {
             cbRef.current = h;
             if (typeof ref === 'function')
                 ref(h);
             else if (ref)
                 ref.current = h;
         }, onEvent: (e) => {
-            if (e.msg === 514 /* gui.WmMsg.LBUTTONUP */) {
-                const newChecked = gui.SendMessage(e.hwnd, 240 /* gui.ButtonMsg.GETCHECK */, 0, 0) !== 0;
+            if (e.msg === 514 /* WmMsg.LBUTTONUP */) {
+                const newChecked = gui.SendMessage(e.hwnd, 240 /* ButtonMsg.GETCHECK */, 0, 0) !== 0;
                 if (newChecked !== displayChecked) {
                     if (!isControlled)
                         setInternalChecked(newChecked);