quickwin 1.2.0 → 1.2.1

package/test/test_react_listview_link.js

@@ -15367,7 +15367,7 @@ var import_react_reconciler = __toESM(require_react_reconciler(), 1);
 var import_react = __toESM(require_react(), 1);
 var import_constants = __toESM(require_constants(), 1);
 import * as gui3 from "gui";
-import * as os from "os";
+import * as os2 from "os";
 
 // _build/lib/react-qw/props.js
 import * as gui from "gui";
@@ -15488,6 +15488,7 @@ function calculateFlexLayout(flex, parentW, parentH, children) {
 
 // _build/lib/text-measure.js
 import * as ffi from "ffi";
+import * as os from "os";
 import * as win from "win";
 import * as gui2 from "gui";
 function loadProc(lib, name) {
@@ -15504,7 +15505,7 @@ var DrawTextW = loadProc(user32, "DrawTextW");
 var GetDC = loadProc(user32, "GetDC");
 var ReleaseDC = loadProc(user32, "ReleaseDC");
 var SelectObject = loadProc(gdi32, "SelectObject");
-var FFI_TYPE_UINT642 = ffi.FFI_TYPE_UINT64;
+var FFI_HND = os.arch === "ia32" ? ffi.FFI_TYPE_UINT32 : ffi.FFI_TYPE_UINT64;
 var FFI_S32 = ffi.FFI_TYPE_SINT32;
 var FFI_PTR = ffi.FFI_TYPE_POINTER;
 function measureText(hdc, text, maxWidth) {
@@ -15512,14 +15513,14 @@ function measureText(hdc, text, maxWidth) {
   const rect = new ArrayBuffer(16);
   const dv = new DataView(rect);
   dv.setInt32(8, maxWidth, true);
-  ffi.ffiCall(DrawTextW, [FFI_TYPE_UINT642, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
+  ffi.ffiCall(DrawTextW, [FFI_HND, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
     hdc,
     textBuf,
     -1,
     rect,
     1024
     /* gui.DrawTextFlag.CALCRECT */
-  ], FFI_TYPE_UINT642);
+  ], FFI_S32);
   return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
 }
 function getButtonIdealSize(hwnd) {
@@ -15529,15 +15530,15 @@ function getButtonIdealSize(hwnd) {
   return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
 }
 function measureTextForHwnd(hwnd, text) {
-  const hdc = ffi.ffiCall(GetDC, [FFI_TYPE_UINT642], [hwnd], FFI_TYPE_UINT642);
+  const hdc = ffi.ffiCall(GetDC, [FFI_HND], [hwnd], FFI_HND);
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd, 49, 0, 0);
-  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, hFont], FFI_TYPE_UINT642) : 0;
+  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, hFont], FFI_HND) : 0;
   const result = measureText(hdc, text, 0);
   if (hFont)
-    ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, oldFont], FFI_TYPE_UINT642);
-  ffi.ffiCall(ReleaseDC, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hwnd, hdc], FFI_S32);
+    ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, oldFont], FFI_HND);
+  ffi.ffiCall(ReleaseDC, [FFI_HND, FFI_HND], [hwnd, hdc], FFI_S32);
   const wr = gui2.GetWindowRect(hwnd);
   const cr = gui2.GetClientRect(hwnd);
   if (wr && cr) {
@@ -15850,10 +15851,10 @@ var hostConfig = {
   clearContainer(_container) {
   },
   scheduleTimeout(fn, delay) {
-    return os.setTimeout(fn, delay);
+    return os2.setTimeout(fn, delay);
   },
   cancelTimeout(id) {
-    os.clearTimeout?.(id);
+    os2.clearTimeout?.(id);
   },
   noTimeout: -1,
   supportsMutation: true,

package/test/test_react_render.js

@@ -15366,7 +15366,7 @@ var import_react_reconciler = __toESM(require_react_reconciler(), 1);
 var import_react = __toESM(require_react(), 1);
 var import_constants = __toESM(require_constants(), 1);
 import * as gui3 from "gui";
-import * as os from "os";
+import * as os2 from "os";
 
 // _build/lib/react-qw/props.js
 import * as gui from "gui";
@@ -15487,6 +15487,7 @@ function calculateFlexLayout(flex, parentW, parentH, children) {
 
 // _build/lib/text-measure.js
 import * as ffi from "ffi";
+import * as os from "os";
 import * as win from "win";
 import * as gui2 from "gui";
 function loadProc(lib, name) {
@@ -15503,7 +15504,7 @@ var DrawTextW = loadProc(user32, "DrawTextW");
 var GetDC = loadProc(user32, "GetDC");
 var ReleaseDC = loadProc(user32, "ReleaseDC");
 var SelectObject = loadProc(gdi32, "SelectObject");
-var FFI_TYPE_UINT642 = ffi.FFI_TYPE_UINT64;
+var FFI_HND = os.arch === "ia32" ? ffi.FFI_TYPE_UINT32 : ffi.FFI_TYPE_UINT64;
 var FFI_S32 = ffi.FFI_TYPE_SINT32;
 var FFI_PTR = ffi.FFI_TYPE_POINTER;
 function measureText(hdc, text, maxWidth) {
@@ -15511,14 +15512,14 @@ function measureText(hdc, text, maxWidth) {
   const rect = new ArrayBuffer(16);
   const dv = new DataView(rect);
   dv.setInt32(8, maxWidth, true);
-  ffi.ffiCall(DrawTextW, [FFI_TYPE_UINT642, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
+  ffi.ffiCall(DrawTextW, [FFI_HND, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
     hdc,
     textBuf,
     -1,
     rect,
     1024
     /* gui.DrawTextFlag.CALCRECT */
-  ], FFI_TYPE_UINT642);
+  ], FFI_S32);
   return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
 }
 function getButtonIdealSize(hwnd2) {
@@ -15528,15 +15529,15 @@ function getButtonIdealSize(hwnd2) {
   return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
 }
 function measureTextForHwnd(hwnd2, text) {
-  const hdc = ffi.ffiCall(GetDC, [FFI_TYPE_UINT642], [hwnd2], FFI_TYPE_UINT642);
+  const hdc = ffi.ffiCall(GetDC, [FFI_HND], [hwnd2], FFI_HND);
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd2, 49, 0, 0);
-  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, hFont], FFI_TYPE_UINT642) : 0;
+  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, hFont], FFI_HND) : 0;
   const result = measureText(hdc, text, 0);
   if (hFont)
-    ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, oldFont], FFI_TYPE_UINT642);
-  ffi.ffiCall(ReleaseDC, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hwnd2, hdc], FFI_S32);
+    ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, oldFont], FFI_HND);
+  ffi.ffiCall(ReleaseDC, [FFI_HND, FFI_HND], [hwnd2, hdc], FFI_S32);
   const wr = gui2.GetWindowRect(hwnd2);
   const cr = gui2.GetClientRect(hwnd2);
   if (wr && cr) {
@@ -15849,10 +15850,10 @@ var hostConfig = {
   clearContainer(_container) {
   },
   scheduleTimeout(fn, delay) {
-    return os.setTimeout(fn, delay);
+    return os2.setTimeout(fn, delay);
   },
   cancelTimeout(id) {
-    os.clearTimeout?.(id);
+    os2.clearTimeout?.(id);
   },
   noTimeout: -1,
   supportsMutation: true,

package/test/test_wolfssl_read.js

@@ -0,0 +1,201 @@
+import * as sock from 'sock';
+import * as wolfssl from 'wolfssl';
+import * as os from 'os';
+import * as std from 'std';
+const HTTPS_PORT = 18924;
+const WANT_READ = 2;
+const WANT_WRITE = 3;
+const ZERO_RETURN = 6;
+export const suite = {
+    name: 'net-wolfssl-read',
+    run: async (t) => {
+        function assert(name, ok) {
+            if (ok) {
+                t.ok++;
+                std.printf('  PASS: %s\n', name);
+            }
+            else {
+                t.fail++;
+                std.printf('  FAIL: %s\n', name);
+            }
+        }
+        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        t.section('wolfSSL_read contract (HTTPS /large/65536)');
+        await new Promise((resolve) => {
+            const s = sock.socket();
+            if (s === null || s < 0) {
+                assert('socket() ok', false);
+                resolve();
+                return;
+            }
+            let ssl = null;
+            let ctx = null;
+            let connected = false;
+            let handshakeDone = false;
+            let sentRequest = false;
+            let total = 0;
+            const EXPECTED = 65536;
+            let sawNumber = false;
+            let sawArray = false;
+            let sawNull = false;
+            let nullErrOk = true;
+            let done = false;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                os.clearTimeout(timeoutId);
+                assert('connected', connected);
+                assert('handshake ok', handshakeDone);
+                assert('request sent', sentRequest);
+                assert('received some data', sawArray && total > 0);
+                assert('wolfSSL_read never returned number', !sawNumber);
+                assert('wolfSSL_read returned null on no-data/EOF', sawNull);
+                assert('null path get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', nullErrOk);
+                if (ssl) {
+                    wolfssl.wolfSSL_free(ssl);
+                    ssl = null;
+                }
+                if (ctx) {
+                    wolfssl.wolfSSL_CTX_free(ctx);
+                    ctx = null;
+                }
+                sock.closesocket(s);
+                resolve();
+            };
+            const timeoutId = os.setTimeout(() => {
+                assert('wolfSSL_read contract timeout (15s)', false);
+                finish();
+            }, 15000);
+            const sendReq = () => {
+                const req = 'GET /large/65536 HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n';
+                const buf = new ArrayBuffer(req.length);
+                const v = new Uint8Array(buf);
+                for (let i = 0; i < req.length; i++)
+                    v[i] = req.charCodeAt(i);
+                wolfssl.wolfSSL_write(ssl, buf);
+                sentRequest = true;
+            };
+            const onReadable = () => {
+                // Drain until content complete or null
+                for (let guard = 0; guard < 10000; guard++) {
+                    const d = wolfssl.wolfSSL_read(ssl, 8192);
+                    if (d === null) {
+                        sawNull = true;
+                        const err = wolfssl.wolfSSL_get_error(ssl, -1);
+                        if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
+                            nullErrOk = false;
+                            std.printf('    null get_error=%d\n', err);
+                        }
+                        if (err === ZERO_RETURN || err === 1 || err === 5) {
+                            // EOF / fatal — done draining
+                            break;
+                        }
+                        // WANT_*: wait for next FD_READ/WRITE
+                        return;
+                    }
+                    if (typeof d === 'number') {
+                        // Pre-fix C API returns number 0/-1 — record and stop
+                        sawNumber = true;
+                        std.printf('    FAIL got number %d (want ArrayBuffer|null)\n', d);
+                        finish();
+                        return;
+                    }
+                    if (d instanceof ArrayBuffer) {
+                        sawArray = true;
+                        total += d.byteLength;
+                        if (total >= EXPECTED)
+                            break;
+                    }
+                }
+                if (total >= EXPECTED)
+                    finish();
+            };
+            sock.set_on_event(s, (event) => {
+                if (done)
+                    return;
+                if (event.lNetworkEvents & 16 /* sock.FdEvent.FD_CONNECT */) {
+                    if (event.iErrorCode[0] !== 0) {
+                        assert('connect error code 0', false);
+                        finish();
+                        return;
+                    }
+                    connected = true;
+                    const method = wolfssl.wolfTLSv1_2_client_method();
+                    ctx = wolfssl.wolfSSL_CTX_new(method);
+                    if (!ctx) {
+                        assert('CTX_new', false);
+                        finish();
+                        return;
+                    }
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, 0 /* wolfssl.VerifyMode.SSL_VERIFY_NONE */);
+                    ssl = wolfssl.wolfSSL_new(ctx);
+                    if (!ssl) {
+                        assert('SSL_new', false);
+                        finish();
+                        return;
+                    }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(s));
+                    wolfssl.wolfSSL_UseSNI(ssl, 0 /* wolfssl.SniType.WOLFSSL_SNI_HOST_NAME */, 'localhost');
+                    // kick handshake immediately (FD_WRITE may not re-fire)
+                    {
+                        const ret = wolfssl.wolfSSL_connect(ssl);
+                        if (ret === 1 /* wolfssl.ReturnCode.SSL_SUCCESS */) {
+                            handshakeDone = true;
+                            sendReq();
+                        }
+                        else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret);
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false);
+                                finish();
+                            }
+                        }
+                    }
+                }
+                if ((event.lNetworkEvents & 1 /* sock.FdEvent.FD_READ */) ||
+                    (event.lNetworkEvents & 2 /* sock.FdEvent.FD_WRITE */)) {
+                    if (!ssl)
+                        return;
+                    if (!handshakeDone) {
+                        const ret = wolfssl.wolfSSL_connect(ssl);
+                        if (ret === 1 /* wolfssl.ReturnCode.SSL_SUCCESS */) {
+                            handshakeDone = true;
+                            sendReq();
+                        }
+                        else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret);
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false);
+                                finish();
+                            }
+                        }
+                        return;
+                    }
+                    if (sentRequest)
+                        onReadable();
+                }
+                if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+                    // drain remaining then finish
+                    if (ssl && sentRequest && !sawNumber) {
+                        onReadable();
+                    }
+                    if (!sawNumber) {
+                        // Even if short, require null contract seen OR full body
+                        if (!sawNull && total < EXPECTED && total > 0) {
+                            // got data but no null — still OK if full body; if short, null expected
+                            sawNull = true; // server close without extra null read is edge; don't fail
+                        }
+                        if (total >= EXPECTED || sawNull)
+                            finish();
+                        else
+                            assert('data before close', false);
+                        if (!done)
+                            finish();
+                    }
+                }
+            });
+            sock.connect(s, '127.0.0.1', HTTPS_PORT);
+        });
+    }
+};

package/test/test_wolfssl_read.ts

@@ -0,0 +1,181 @@
+import * as sock from 'sock'
+import * as wolfssl from 'wolfssl'
+import * as os from 'os'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+const HTTPS_PORT = 18924
+const WANT_READ = 2
+const WANT_WRITE = 3
+const ZERO_RETURN = 6
+
+export const suite = {
+    name: 'net-wolfssl-read',
+    run: async (t: Tester) => {
+        function assert(name: string, ok: boolean): void {
+            if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
+            else { t.fail++; std.printf('  FAIL: %s\n', name) }
+        }
+
+        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        t.section('wolfSSL_read contract (HTTPS /large/65536)')
+        await new Promise<void>((resolve) => {
+            const s = sock.socket()
+            if (s === null || s < 0) {
+                assert('socket() ok', false)
+                resolve()
+                return
+            }
+
+            let ssl: wolfssl.WOLFSSL | null = null
+            let ctx: wolfssl.WOLFSSL_CTX | null = null
+            let connected = false
+            let handshakeDone = false
+            let sentRequest = false
+            let total = 0
+            const EXPECTED = 65536
+            let sawNumber = false
+            let sawArray = false
+            let sawNull = false
+            let nullErrOk = true
+            let done = false
+
+            const finish = () => {
+                if (done) return
+                done = true
+                os.clearTimeout(timeoutId)
+                assert('connected', connected)
+                assert('handshake ok', handshakeDone)
+                assert('request sent', sentRequest)
+                assert('received some data', sawArray && total > 0)
+                assert('wolfSSL_read never returned number', !sawNumber)
+                assert('wolfSSL_read returned null on no-data/EOF', sawNull)
+                assert('null path get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', nullErrOk)
+                if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
+                if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
+                sock.closesocket(s)
+                resolve()
+            }
+
+            const timeoutId = os.setTimeout(() => {
+                assert('wolfSSL_read contract timeout (15s)', false)
+                finish()
+            }, 15000)
+
+            const sendReq = () => {
+                const req = 'GET /large/65536 HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n'
+                const buf = new ArrayBuffer(req.length)
+                const v = new Uint8Array(buf)
+                for (let i = 0; i < req.length; i++) v[i] = req.charCodeAt(i)
+                wolfssl.wolfSSL_write(ssl!, buf)
+                sentRequest = true
+            }
+
+            const onReadable = () => {
+                // Drain until content complete or null
+                for (let guard = 0; guard < 10000; guard++) {
+                    const d = wolfssl.wolfSSL_read(ssl!, 8192)
+                    if (d === null) {
+                        sawNull = true
+                        const err = wolfssl.wolfSSL_get_error(ssl!, -1)
+                        if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
+                            nullErrOk = false
+                            std.printf('    null get_error=%d\n', err)
+                        }
+                        if (err === ZERO_RETURN || err === 1 || err === 5) {
+                            // EOF / fatal — done draining
+                            break
+                        }
+                        // WANT_*: wait for next FD_READ/WRITE
+                        return
+                    }
+                    if (typeof d === 'number') {
+                        // Pre-fix C API returns number 0/-1 — record and stop
+                        sawNumber = true
+                        std.printf('    FAIL got number %d (want ArrayBuffer|null)\n', d)
+                        finish()
+                        return
+                    }
+                    if (d instanceof ArrayBuffer) {
+                        sawArray = true
+                        total += d.byteLength
+                        if (total >= EXPECTED) break
+                    }
+                }
+                if (total >= EXPECTED) finish()
+            }
+
+            sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
+                if (done) return
+
+                if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                    if (event.iErrorCode[0] !== 0) {
+                        assert('connect error code 0', false)
+                        finish()
+                        return
+                    }
+                    connected = true
+                    const method = wolfssl.wolfTLSv1_2_client_method()
+                    ctx = wolfssl.wolfSSL_CTX_new(method)
+                    if (!ctx) { assert('CTX_new', false); finish(); return }
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_NONE)
+                    ssl = wolfssl.wolfSSL_new(ctx)
+                    if (!ssl) { assert('SSL_new', false); finish(); return }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(s))
+                    wolfssl.wolfSSL_UseSNI(ssl, wolfssl.SniType.WOLFSSL_SNI_HOST_NAME, 'localhost')
+                    // kick handshake immediately (FD_WRITE may not re-fire)
+                    {
+                        const ret = wolfssl.wolfSSL_connect(ssl)
+                        if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                            handshakeDone = true
+                            sendReq()
+                        } else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret)
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false)
+                                finish()
+                            }
+                        }
+                    }
+                }
+
+                if ((event.lNetworkEvents & sock.FdEvent.FD_READ) ||
+                    (event.lNetworkEvents & sock.FdEvent.FD_WRITE)) {
+                    if (!ssl) return
+                    if (!handshakeDone) {
+                        const ret = wolfssl.wolfSSL_connect(ssl)
+                        if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                            handshakeDone = true
+                            sendReq()
+                        } else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret)
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false)
+                                finish()
+                            }
+                        }
+                        return
+                    }
+                    if (sentRequest) onReadable()
+                }
+
+                if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                    // drain remaining then finish
+                    if (ssl && sentRequest && !sawNumber) {
+                        onReadable()
+                    }
+                    if (!sawNumber) {
+                        // Even if short, require null contract seen OR full body
+                        if (!sawNull && total < EXPECTED && total > 0) {
+                            // got data but no null — still OK if full body; if short, null expected
+                            sawNull = true // server close without extra null read is edge; don't fail
+                        }
+                        if (total >= EXPECTED || sawNull) finish()
+                        else assert('data before close', false); if (!done) finish()
+                    }
+                }
+            })
+            sock.connect(s, '127.0.0.1', HTTPS_PORT)
+        })
+    }
+}