quickwin 2.0.0 → 2.1.1

package/examples/test_tab.js

@@ -15601,10 +15601,18 @@ var C_BASIC_TYPE = [
   "f64",
   "ptr"
 ];
-var PTR_TOKEN_RE = /^<([^<>\s]*)>ptr(!|@[A-Za-z_]\w*)?$/;
+var PTR_TOKEN_RE = /^<([A-Za-z_]\w*|)>ptr(!|@[A-Za-z_]\w*)?$/;
 function isCPtrToken(t) {
   return PTR_TOKEN_RE.test(t);
 }
+var VAL_TOKEN_RE = /^<([A-Za-z_]\w*)>$/;
+function isCValToken(t) {
+  return VAL_TOKEN_RE.test(t);
+}
+function valName(t) {
+  const m = VAL_TOKEN_RE.exec(t);
+  return m?.[1] || "";
+}
 function ptrName(t) {
   const m = PTR_TOKEN_RE.exec(t);
   return m?.[1] || "";
@@ -15612,8 +15620,9 @@ function ptrName(t) {
 var cTokenToType = (t) => {
   if (isCPtrToken(t))
     return "ptr";
-  else
-    return t;
+  if (isCValToken(t))
+    throw new Error(`ffi: cTokenToType: by-value token "${t}" has no scalar slot type`);
+  return t;
 };
 var PTR_SIZE = os.arch === "x64" ? 8 : 4;
 var SizeAlign = {
@@ -15632,8 +15641,12 @@ var NULL = 0;
 function normToken(t) {
   if (isCPtrToken(t)) {
     const m = PTR_TOKEN_RE.exec(t);
-    return m?.[2]?.startsWith("@") ? `<${m[1]}>ptr` : t;
+    const name = m?.[1] || "";
+    const mod = m?.[2];
+    return mod?.startsWith("@") ? `<${name}>ptr` : t;
   }
+  if (isCValToken(t))
+    return t;
   const at = t.indexOf("@");
   const base = at >= 0 ? t.slice(0, at) : t;
   const suffixOk = at < 0 || /^[A-Za-z_]\w*$/.test(t.slice(at + 1));
@@ -15729,6 +15742,9 @@ var PtrArrayBuffer = class extends ArrayBuffer {
 };
 
 // _build/lib/ffi/bind.js
+function valCodec(name, encoders) {
+  return encoders[name];
+}
 var _dllCache = /* @__PURE__ */ new Map();
 function loadDll(dll) {
   const cached = _dllCache.get(dll);
@@ -15754,14 +15770,27 @@ function parseSig(sig) {
     }
     argTokens.push(tok);
   }
+  const retToken = normToken(parts[1]);
+  if (isCValToken(retToken))
+    throw new Error(`ffi-bind: "${sig}": by-value struct at the return position (<${valName(retToken)}>) is not supported \u2014 argument positions only; pass a struct out through an out-param slot instead (<N>ptr + caller buffer)`);
   return {
     argTokens,
-    retToken: normToken(parts[1]),
+    retToken,
     sig
   };
 }
 function makeFn(proc, sig, encoders, decoders) {
   const ps = parseSig(sig);
+  for (const t of ps.argTokens) {
+    if (!isCValToken(t))
+      continue;
+    const name = valName(t);
+    const codec = valCodec(name, encoders);
+    if (!codec || typeof codec.encode !== "function")
+      throw new Error(`ffi-bind: ${sig}: by-value position <${name}> has no registered layout (available: ${Object.keys(encoders).join(", ") || "none"})`);
+    if (typeof codec.size !== "number" || codec.size < 1)
+      throw new Error(`ffi-bind: ${sig}: by-value position <${name}> requires a struct layout with size >= 1 (got ${codec.size}; non-struct codecs expose no size)`);
+  }
   return (...a) => callPacked(proc, ps, a, encoders, decoders);
 }
 var IA32_ARG_SIZE = {
@@ -15781,15 +15810,29 @@ var X64_MIN_SLOTS = 4;
 function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders) {
   const is64 = os2.arch === "x64";
   const getWidth = (t, is642) => {
+    if (isCValToken(t))
+      throw new Error(`ffi-bind: getWidth: by-value token "${t}" (dispatched by widthOf)`);
     if (is642)
       return 8;
     if (isCPtrToken(t))
       return PTR_SIZE;
     return IA32_ARG_SIZE[t];
   };
+  const widthOf = (t) => {
+    if (isCValToken(t)) {
+      if (is64)
+        return 8;
+      const layout = valCodec(valName(t), encoders);
+      if (!layout)
+        throw new Error(`ffi-bind: <${valName(t)}> by-value position has no registered layout`);
+      const size = layout.size;
+      return size % 4 === 0 ? size : size + 4 - size % 4;
+    }
+    return getWidth(t, is64);
+  };
   let total = 0;
   for (const t of argTokens)
-    total += getWidth(t, is64);
+    total += widthOf(t);
   if (is64 && argTokens.length < X64_MIN_SLOTS)
     total = X64_MIN_SLOTS * 8;
   const argFrame = new ArrayBuffer(total);
@@ -15826,10 +15869,28 @@ function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders
           throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}>ptr! encode produced 0 (null pointer forbidden here)`);
         writeSlot(dv, off, { k: "ptr", v: p });
       }
+    } else if (isCValToken(argToken)) {
+      const name = valName(argToken);
+      const codec = valCodec(name, encoders);
+      if (!codec)
+        throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}> by-value position has no registered layout`);
+      if (arg === null || arg === void 0)
+        throw new Error(`ffi-bind: <${name}> value position got ${String(arg)}; pass a struct object (use <${name}>ptr to pass a pointer)`);
+      const size = codec.size;
+      if (!is64 || size <= 8 && (size & size - 1) === 0) {
+        codec.encode(arg, argFrame, off);
+      } else {
+        const buf = new ArrayBuffer(size + 15);
+        const base = ffi.bufferPtr(buf);
+        const pad = (16 - base % 16) % 16;
+        codec.encode(arg, buf, pad);
+        held.push(buf);
+        writeSlot(dv, off, { k: "ptr", v: base + pad });
+      }
     } else {
       writeSlot(dv, off, { k: argToken, v: arg });
     }
-    off += getWidth(argToken, is64);
+    off += widthOf(argToken);
   }
   const retBuf = new ArrayBuffer(8);
   const retIsFp = retToken === "f32" || retToken === "f64";
@@ -16220,21 +16281,20 @@ function createStruct(t) {
     size,
     structAlign: maxEffectiveAlign,
     decode: (p) => {
-      if (typeof p === "number") {
-        const buf = new ArrayBuffer(size);
-        const u8 = new Uint8Array(buf);
-        for (let i = 0; i < size; i++)
-          u8[i] = ffi2.readByte(p + i);
-        return doDecode(new DataView(buf), 0, fields);
-      }
+      if (typeof p === "number")
+        return doDecode(new DataView(ffi2.readBytes(p, size)), 0, fields);
       return doDecode(new DataView(p), 0, fields);
     },
-    alloc: (() => new PtrArrayBuffer(size)),
-    encode: ((v, buf) => {
+    alloc: ((n) => {
+      if (n !== void 0 && (!Number.isInteger(n) || n < 1))
+        throw new Error(`ffi-struct: alloc(n) requires an integer n >= 1 (PAB(0) never escapes \u2014 pass NULL for an empty pointer position)`);
+      return new PtrArrayBuffer(size * (n ?? 1));
+    }),
+    encode: ((v, buf, offset) => {
       if (v === void 0 || v === null)
         throw new Error(`ffi-struct: encode(v) requires an argument; use alloc() for a zeroed out-param slot`);
       const out = buf ?? new PtrArrayBuffer(size);
-      doEncode(new DataView(out), 0, fields, v);
+      doEncode(new DataView(out), offset ?? 0, fields, v);
       return out;
     }),
     offsetOf: (name) => {
@@ -16254,6 +16314,49 @@ function buildDecl(kind, member, pack) {
       decl[k] = v;
   return decl;
 }
+function structArray(def) {
+  const { fields, size } = computeStructLayout(def.__struct);
+  const readN = (dv, n) => {
+    const out = [];
+    for (let i = 0; i < n; i++)
+      out.push(doDecode(dv, i * size, fields));
+    return out;
+  };
+  return {
+    encode: (els) => {
+      if (!Array.isArray(els) || els.length === 0)
+        throw new Error(`ffi-struct: structArray(def).encode(els) requires a non-empty element array (pass NULL for an empty pointer position)`);
+      const out = def.alloc(els.length);
+      for (let i = 0; i < els.length; i++)
+        def.encode(els[i], out, i * def.size);
+      return out;
+    },
+    decode: ((p, count) => {
+      if (count !== void 0 && (!Number.isInteger(count) || count < 0))
+        throw new Error(`ffi-struct: structArray.decode(p, count) requires a non-negative integer count, got ${count}`);
+      if (typeof p === "number") {
+        if (count === void 0)
+          throw new Error(`ffi-struct: structArray.decode(address, count) requires an explicit count (a bare address carries no length)`);
+        if (count === 0)
+          return [];
+        return readN(new DataView(ffi2.readBytes(p, count * size)), count);
+      }
+      let n;
+      if (count !== void 0) {
+        n = count;
+        if (n * size > p.byteLength)
+          throw new Error(`ffi-struct: structArray.decode: count ${n} \xD7 size ${size} = ${n * size} exceeds buffer byteLength ${p.byteLength}`);
+      } else {
+        if (p.byteLength % size !== 0)
+          throw new Error(`ffi-struct: structArray.decode: byteLength ${p.byteLength} is not a multiple of size ${size} (mixed buffer? pass count explicitly)`);
+        n = p.byteLength / size;
+      }
+      if (n === 0)
+        return [];
+      return readN(new DataView(p), n);
+    })
+  };
+}
 function struct(a, b6, c) {
   const isNamed = typeof a === "string";
   const raw = isNamed ? b6 : a;
@@ -16503,11 +16606,12 @@ import * as os4 from "os";
 
 // _build/lib/windows/gdi32.js
 var b2 = (name, sig, encoders) => bind("gdi32.dll", name, sig, encoders);
-var DeleteObject = /* @__PURE__ */ b2("DeleteObject", "<>ptr -> i32");
+var POINTArr = structArray(POINT);
+var DeleteObject = /* @__PURE__ */ b2("DeleteObject", "<HGDIOBJ>ptr -> i32");
 var GetDeviceCaps = /* @__PURE__ */ b2("GetDeviceCaps", "<HDC>ptr! i32@DeviceCap -> i32");
-var CreateFontIndirect = /* @__PURE__ */ b2("CreateFontIndirectW", "<LOGFONTW>ptr -> <>ptr", { LOGFONTW });
-var SelectObject = /* @__PURE__ */ b2("SelectObject", "<HDC>ptr! <>ptr -> <>ptr");
-var GetObject = /* @__PURE__ */ b2("GetObjectW", "<>ptr i32 <BYTE>ptr -> i32");
+var CreateFontIndirect = /* @__PURE__ */ b2("CreateFontIndirectW", "<LOGFONTW>ptr -> <HGDIOBJ>ptr", { LOGFONTW });
+var SelectObject = /* @__PURE__ */ b2("SelectObject", "<HDC>ptr! <HGDIOBJ>ptr -> <HGDIOBJ>ptr");
+var GetObject = /* @__PURE__ */ b2("GetObjectW", "<HGDIOBJ>ptr i32 <BYTE>ptr -> i32");
 
 // _build/lib/react-qw/props.js
 import * as gui from "gui";
@@ -16654,7 +16758,7 @@ function measureTextForHwnd(hwnd2, text) {
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd2, 49, 0, 0);
-  const oldFont = hFont ? SelectObject(hdc, hFont) : 0;
+  const oldFont = hFont ? SelectObject(hdc, hFont) : NULL;
   const result = measureText(hdc, text, 0);
   if (hFont)
     SelectObject(hdc, oldFont);
@@ -18039,11 +18143,11 @@ var import_react17 = __toESM(require_react(), 1);
 
 // _build/lib/windows/comdlg32.js
 var b3 = (name, sig) => bind("comdlg32.dll", name, sig);
-var GetOpenFileName = /* @__PURE__ */ b3("GetOpenFileNameW", "<BYTE>ptr -> u32");
+var GetOpenFileName = /* @__PURE__ */ b3("GetOpenFileNameW", "<OPENFILENAMEW>ptr -> u32");
 
 // _build/lib/windows/shell32.js
 var b4 = (name, sig) => bind("shell32.dll", name, sig);
-var SHBrowseForFolder = /* @__PURE__ */ b4("SHBrowseForFolderW", "<BYTE>ptr -> <>ptr");
+var SHBrowseForFolder = /* @__PURE__ */ b4("SHBrowseForFolderW", "<BROWSEINFOW>ptr -> <>ptr");
 var SHGetPathFromIDList = /* @__PURE__ */ b4("SHGetPathFromIDListW", "<>ptr <BYTE>ptr -> u32");
 
 // _build/lib/windows/ole32.js
@@ -18068,7 +18172,7 @@ function openFileDialog(owner, filter, title, multiple) {
     lpstrTitle: titleWide?.ptr ?? 0,
     Flags: flags
   });
-  const ret = GetOpenFileName(ofn);
+  const ret = GetOpenFileName(ofn.ptr);
   if (!ret)
     return null;
   if (!multiple) {
@@ -18086,7 +18190,7 @@ function openFolderDialog(owner, title) {
     lpszTitle: titleWide?.ptr ?? 0,
     ulFlags: 65
   });
-  const pidl = SHBrowseForFolder(bi);
+  const pidl = SHBrowseForFolder(bi.ptr);
   if (!pidl)
     return null;
   const pathBuf = WCHAR.alloc(260);
@@ -18181,7 +18285,7 @@ function createRoot(container) {
   } else {
     hwnd2 = container;
   }
-  const root = reconciler_default.createContainer(hwnd2, 0, null, false, null, "", noop, noop, noop, noop);
+  const root = reconciler_default.createContainer(hwnd2, 0, null, false, null, "", (error, info) => console.log("[React uncaught]", error, error.stack, info.componentStack), (error, info) => console.log("[React caught]", error, error.stack, info.componentStack), (error, info) => console.log("[React recoverable]", error, error.stack, info.componentStack), noop);
   const rootInst = { hwnd: hwnd2, type: "_root", props: { type: "_root", style: { flexDirection: "column", alignItems: "stretch" } }, children: [] };
   instancesByHwnd.set(hwnd2, rootInst);
   if (typeof container === "object")

package/lib/certs.js

@@ -203,12 +203,17 @@ tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
 /q4AaOeMSQ+2b1tbFfLn
 -----END CERTIFICATE-----`;
 // Register at import time. Importers of this module get the anchors
-// without writing any code themselves.
-wolfssl.addTrustedCA(GLOBALSIGN_R3);
-wolfssl.addTrustedCA(GLOBALSIGN_R1);
-wolfssl.addTrustedCA(USERTRUST_ECC_CA);
-wolfssl.addTrustedCA(DIGICERT_GLOBAL_G2);
-wolfssl.addTrustedCA(GLOBALSIGN_R46);
-wolfssl.addTrustedCA(ISRG_X1);
-wolfssl.addTrustedCA(ISRG_X2);
+// without writing any code themselves. addTrustedCA only returns the
+// slot count (-1 when full/empty); the fatal-vs-not decision is ours.
+function trust(pem) {
+    if (wolfssl.addTrustedCA(pem) < 0)
+        throw new Error('certs: trust store full or empty PEM');
+}
+trust(GLOBALSIGN_R3);
+trust(GLOBALSIGN_R1);
+trust(USERTRUST_ECC_CA);
+trust(DIGICERT_GLOBAL_G2);
+trust(GLOBALSIGN_R46);
+trust(ISRG_X1);
+trust(ISRG_X2);
 export const TRUSTED_CA_COUNT = 7;

package/lib/certs.ts

@@ -212,13 +212,18 @@ tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
 -----END CERTIFICATE-----`
 
 // Register at import time. Importers of this module get the anchors
-// without writing any code themselves.
-wolfssl.addTrustedCA(GLOBALSIGN_R3)
-wolfssl.addTrustedCA(GLOBALSIGN_R1)
-wolfssl.addTrustedCA(USERTRUST_ECC_CA)
-wolfssl.addTrustedCA(DIGICERT_GLOBAL_G2)
-wolfssl.addTrustedCA(GLOBALSIGN_R46)
-wolfssl.addTrustedCA(ISRG_X1)
-wolfssl.addTrustedCA(ISRG_X2)
+// without writing any code themselves. addTrustedCA only returns the
+// slot count (-1 when full/empty); the fatal-vs-not decision is ours.
+function trust(pem: string): void {
+    if (wolfssl.addTrustedCA(pem) < 0)
+        throw new Error('certs: trust store full or empty PEM')
+}
+trust(GLOBALSIGN_R3)
+trust(GLOBALSIGN_R1)
+trust(USERTRUST_ECC_CA)
+trust(DIGICERT_GLOBAL_G2)
+trust(GLOBALSIGN_R46)
+trust(ISRG_X1)
+trust(ISRG_X2)
 
 export const TRUSTED_CA_COUNT = 7

package/lib/fetch.js

@@ -56,6 +56,9 @@ const ST_DONE = 5;
 // ── Main fetch request ──
 async function fetchRequest(req) {
     const parsedUrl = new URL(req.url);
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+        throw new TypeError('fetch: unsupported protocol "' + parsedUrl.protocol + '"');
+    }
     const method = req.method;
     const headers = new HeadersImpl(req.headers);
     const timeout = req.timeout || 30000;
@@ -241,7 +244,21 @@ async function fetchRequest(req) {
                             break;
                         let data;
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                            const buf = new ArrayBuffer(8192);
+                            const n = wolfssl.wolfSSL_read(ssl, buf);
+                            if (n > 0) {
+                                data = buf.slice(0, n);
+                            }
+                            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 */)
+                                    break;
+                                if (n === 0 || err === 6 /* wolfssl.ErrorCode.WOLFSSL_ERROR_ZERO_RETURN */)
+                                    break;
+                                doReject(new Error('TLS read failed: ' + err));
+                                return;
+                            }
                         }
                         else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192);
@@ -314,7 +331,31 @@ async function fetchRequest(req) {
                             break;
                         let data;
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                            const buf = new ArrayBuffer(8192);
+                            const n = wolfssl.wolfSSL_read(ssl, buf);
+                            if (n > 0) {
+                                data = buf.slice(0, n);
+                            }
+                            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 */)
+                                    break;
+                                if (n === 0 || err === 6 /* wolfssl.ErrorCode.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.
+                                if (_controller) {
+                                    try {
+                                        _controller.error(new Error('TLS read failed: ' + err));
+                                    }
+                                    catch { /* already closed */ }
+                                }
+                                stream = null;
+                                cleanupSocket();
+                                return;
+                            }
                         }
                         else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192);
@@ -362,7 +403,14 @@ async function fetchRequest(req) {
                             break;
                         let data;
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192);
+                            const buf = new ArrayBuffer(8192);
+                            const n = wolfssl.wolfSSL_read(ssl, buf);
+                            // Best-effort drain: any non-data result (EOF, WANT_*,
+                            // late error) ends the drain — the stream closes below.
+                            if (n > 0)
+                                data = buf.slice(0, n);
+                            else
+                                break;
                         }
                         else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192);

package/lib/fetch.ts

@@ -78,6 +78,9 @@ const ST_DONE = 5
 
 async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
     const parsedUrl = new URL(req.url)
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+        throw new TypeError('fetch: unsupported protocol "' + parsedUrl.protocol + '"')
+    }
     const method = req.method
     const headers = new HeadersImpl(req.headers)
     const timeout = req.timeout || 30000
@@ -225,7 +228,18 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                         if (s !== null && s < 0 && !ssl) break
                         let data: ArrayBuffer | null
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                            const buf = new ArrayBuffer(8192)
+                            const n = wolfssl.wolfSSL_read(ssl, buf)
+                            if (n > 0) {
+                                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
+                                doReject(new Error('TLS read failed: ' + err))
+                                return
+                            }
                         } else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192)
                         } else { break }
@@ -295,7 +309,23 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                         if (s !== null && s < 0 && !ssl) break
                         let data: ArrayBuffer | null
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                            const buf = new ArrayBuffer(8192)
+                            const n = wolfssl.wolfSSL_read(ssl, buf)
+                            if (n > 0) {
+                                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
+                                // 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.
+                                if (_controller) { try { _controller.error(new Error('TLS read failed: ' + err)) } catch { /* already closed */ } }
+                                stream = null
+                                cleanupSocket()
+                                return
+                            }
                         } else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192)
                         } else { break }
@@ -335,7 +365,12 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
                         if (s !== null && s < 0 && !ssl) break
                         let data: ArrayBuffer | null
                         if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                            const buf = new ArrayBuffer(8192)
+                            const n = wolfssl.wolfSSL_read(ssl, buf)
+                            // Best-effort drain: any non-data result (EOF, WANT_*,
+                            // late error) ends the drain — the stream closes below.
+                            if (n > 0) data = buf.slice(0, n)
+                            else break
                         } else if (s !== null && s >= 0) {
                             data = sock.recv(s, 8192)
                         } else { break }

package/lib/ffi/bind.js

@@ -3,7 +3,12 @@ import * as os from 'os';
 import * as std from 'std';
 import * as win from 'win';
 import '../text-codec.js';
-import { cTokenToType, isCPtrToken, normToken, PTR_SIZE, ptrName, readScalar, writeSlot, PtrArrayBuffer } from './ctype.js';
+import { cTokenToType, isCPtrToken, isCValToken, valName, normToken, PTR_SIZE, ptrName, readScalar, writeSlot, PtrArrayBuffer } from './ctype.js';
+// CodecMap 的值是结构形（size 只在 StructDef 上、不属 Codec 契约），统一走 unknown
+// 二跳提取；存在性与 size 由 makeFn 绑定期校验。
+function valCodec(name, encoders) {
+    return encoders[name];
+}
 const _dllCache = new Map();
 function loadDll(dll) {
     const cached = _dllCache.get(dll);
@@ -36,14 +41,36 @@ function parseSig(sig) {
     }
     // 裸 'ptr'/非法 token 由类型层拦截（C_BasicType_Token 已 Exclude 'ptr'、拼错 token 塌成 never）；
     // 运行时再比较只会得到 TS2367「两类型无重叠」——类型已表达的约束不重复校验。
+    const retToken = normToken(parts[1]);
+    // 按值形 '<N>' 仅支持入参位：大结构返回需要隐藏指针/sret 级 ABI（本运行时的
+    // retBuf 恒 8 字节，只支持标量/浮点/指针返回），绑定期 throw 而非静默降级。
+    // 类型层对返回位的 '<N>' 不设专门分支（fallthrough），本 throw 是唯一防线。
+    if (isCValToken(retToken))
+        throw new Error(`ffi-bind: "${sig}": by-value struct at the return position ` +
+            `(<${valName(retToken)}>) is not supported — argument positions only; ` +
+            `pass a struct out through an out-param slot instead (<N>ptr + caller buffer)`);
     return {
         argTokens,
-        retToken: normToken(parts[1]),
+        retToken,
         sig,
     };
 }
 function makeFn(proc, sig, encoders, decoders) {
     const ps = parseSig(sig);
+    // 按值位的能力校验前移到绑定期（模块加载即炸，不留到首个调用）：布局缺位 / 非结构
+    // 布局（无 size）/ 退化 size 都是签名层面的错误，报错指向具体位与可用布局清单。
+    for (const t of ps.argTokens) {
+        if (!isCValToken(t))
+            continue;
+        const name = valName(t);
+        const codec = valCodec(name, encoders);
+        if (!codec || typeof codec.encode !== 'function')
+            throw new Error(`ffi-bind: ${sig}: by-value position <${name}> has no registered layout ` +
+                `(available: ${Object.keys(encoders).join(', ') || 'none'})`);
+        if (typeof codec.size !== 'number' || codec.size < 1)
+            throw new Error(`ffi-bind: ${sig}: by-value position <${name}> requires a struct ` +
+                `layout with size >= 1 (got ${codec.size}; non-struct codecs expose no size)`);
+    }
     return (...a) => callPacked(proc, ps, a, encoders, decoders);
 }
 // 每个参数在 argFrame 里占的字节数。与 quickjs-ffi-type.h 的 qwin_ffi_arg_size[]
@@ -59,15 +86,36 @@ const X64_MIN_SLOTS = 4;
 function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders) {
     const is64 = os.arch === 'x64';
     const getWidth = (t, is64) => {
+        // 按值形由 widthOf 分派（槽宽依赖布局 size），此处只认标量/指针档；守卫同时
+        // 收窄类型（IA32_ARG_SIZE 索引不认 val 形）。
+        if (isCValToken(t))
+            throw new Error(`ffi-bind: getWidth: by-value token "${t}" (dispatched by widthOf)`);
         if (is64)
             return 8;
         if (isCPtrToken(t))
             return PTR_SIZE;
         return IA32_ARG_SIZE[t];
     };
+    // 按值位的槽宽：x64 恒 8 字节（尺寸 ∈{1,2,4,8} 按「同尺寸整数」进槽，其余尺寸进
+    // 槽的是指向临时副本的指针）；ia32 = ALIGN(size, 4) —— 结构字节原样压栈，无按
+    // 引用一说（libffi ffi.c 的 ia32 分支同规则，桩只做一次 rep movsb 搬运）。
+    const widthOf = (t) => {
+        if (isCValToken(t)) {
+            if (is64)
+                return 8;
+            const layout = valCodec(valName(t), encoders);
+            // 绑定期 makeFn 已校验（存在 + size >= 1）；此处兜动态/无类型路径。
+            if (!layout)
+                throw new Error(`ffi-bind: <${valName(t)}> by-value position has no registered layout`);
+            const size = layout.size;
+            return size % 4 === 0 ? size : size + 4 - (size % 4);
+        }
+        // val 形已在上分支 return，此处恒为标量/指针形（类型层收窄，见 C_BasicType_Token）。
+        return getWidth(t, is64);
+    };
     let total = 0;
     for (const t of argTokens)
-        total += getWidth(t, is64);
+        total += widthOf(t);
     if (is64 && argTokens.length < X64_MIN_SLOTS)
         total = X64_MIN_SLOTS * 8;
     const argFrame = new ArrayBuffer(total);
@@ -118,10 +166,40 @@ function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders
                 writeSlot(dv, off, { k: 'ptr', v: p });
             }
         }
+        else if (isCValToken(argToken)) {
+            // 按值位：对象直传（值域由注册布局推导），无地址词汇 —— NULL / number
+            // 进这里是必然错位（引擎按值语义，指针位请写 <N>ptr），fail-loud。
+            const name = valName(argToken);
+            const codec = valCodec(name, encoders);
+            if (!codec)
+                throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}> by-value position ` +
+                    `has no registered layout`);
+            if (arg === null || arg === undefined)
+                throw new Error(`ffi-bind: <${name}> value position got ${String(arg)}; ` +
+                    `pass a struct object (use <${name}>ptr to pass a pointer)`);
+            const size = codec.size;
+            if (!is64 || (size <= 8 && (size & (size - 1)) === 0)) {
+                // 字节直接落槽：ia32 结构按值压栈（任意尺寸）；x64 尺寸 ∈{1,2,4,8}
+                // 按「同尺寸整数」传值——字节在 8 字节槽低位，callee 右对齐读。
+                // argFrame 构造时即零填充，槽高位为 0（callee 忽略高位，无歧义）。
+                codec.encode(arg, argFrame, off);
+            }
+            else {
+                // x64 其余尺寸（>8 或非 2 的幂）按引用：槽放指针，指向 caller 分配的
+                // 16 字节对齐临时副本（MS x64 官方规则：单参数永不跨多个寄存器；对齐
+                // 偏移自算，不依赖分配器的对齐保证）。held 保持引用直到调用返回。
+                const buf = new ArrayBuffer(size + 15);
+                const base = ffi.bufferPtr(buf);
+                const pad = (16 - (base % 16)) % 16;
+                codec.encode(arg, buf, pad);
+                held.push(buf);
+                writeSlot(dv, off, { k: 'ptr', v: base + pad });
+            }
+        }
         else {
             writeSlot(dv, off, { k: argToken, v: arg });
         }
-        off += getWidth(argToken, is64);
+        off += widthOf(argToken);
     }
     const retBuf = new ArrayBuffer(8);
     const retIsFp = retToken === 'f32' || retToken === 'f64';
@@ -155,7 +233,8 @@ function readRet(ret, retBuf) {
  *  品牌指针逐字节读到 NUL（野指针无终止 4MiB 上限 fail-fast）、ArrayBuffer 直读到
  *  NUL 或末尾（out 参数未写 NUL 时按读满处理）；alloc 预分配返回带 .ptr 的
  *  PtrArrayBuffer（a = 字符数，缺省 256）。类型取必需形态——
- *  内建三件齐备，调用无需空断言。 */
+ *  内建三件齐备，调用无需空断言。刻意 Pick 而非 Required<Codec>：只声明消费的
+ *  三件（encode/decode/alloc），新增可选能力位不被拉成必填。 */
 export const WCHAR = {
     encode: (v) => {
         // TextEncoder 没有 encodeInto：先编码再拷入带 .ptr 的 buffer（单次 memcpy，
@@ -316,6 +395,16 @@ function dispatchClosure(args, ret, fn, frameBuf, retBuf, sig) {
  *  → 打印泄漏警告（只警告、不自动释放，见 leakRegistry）。 */
 export function closure(sig, fn, opts) {
     const { argTokens, retToken } = parseSig(sig);
+    // 按值位仅支持 bind 的入参方向：closure 的 C→JS 方向由 quickjs-ffi-closure-*.S
+    // 按固定槽宽读参数（x64 固定 8 字节槽、ia32 IA32_ARG_SIZE 表），不区分「槽内是
+    // 结构字节还是指向临时副本的指针」——该分派未实现，创建期 fail-fast。
+    for (const t of argTokens)
+        if (isCValToken(t))
+            throw new Error(`ffi-bind: closure signature cannot take a by-value struct ` +
+                `(<${valName(t)}>); by-value is bind-only — the C→JS direction has no ` +
+                `struct slot decoding (pass a pointer and decode on the JS side)`);
+    // 上方已拒 '<N>' 按值形：此处 tok 恒为标量/指针档（cTokenToType 对 val 形原样返回，
+    // 但那条路径不可达——IA32_ARG_SIZE 索引与 dispatchClosure 只认标量档）。
     const argSpecs = argTokens.map(t => ({ tok: cTokenToType(t), nonnull: t.endsWith('!') }));
     const retSpec = { tok: cTokenToType(retToken), nonnull: retToken.endsWith('!') };
     const is64 = os.arch === 'x64';