quickwin 1.3.0 → 2.1.0

package/test/test_wolfssl_read.ts

@@ -17,7 +17,8 @@ export const suite = {
             else { t.fail++; std.printf('  FAIL: %s\n', name) }
         }
 
-        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        // ── wolfSSL_read return contract: raw int, data lands in the
+        //    caller-owned buffer (thin wrapper — errors stay numbers) ──
         t.section('wolfSSL_read contract (HTTPS /large/65536)')
         await new Promise<void>((resolve) => {
             const s = sock.socket()
@@ -34,10 +35,9 @@ export const suite = {
             let sentRequest = false
             let total = 0
             const EXPECTED = 65536
-            let sawNumber = false
-            let sawArray = false
-            let sawNull = false
-            let nullErrOk = true
+            let sawNonNumber = false
+            let sawEof = false
+            let errOk = true
             let done = false
 
             const finish = () => {
@@ -47,10 +47,10 @@ export const suite = {
                 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)
+                assert('received full body', total >= EXPECTED)
+                assert('wolfSSL_read always returned number', !sawNonNumber)
+                assert('no-data/EOF observed via int (0 or ZERO_RETURN)', sawEof)
+                assert('n<=0 get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', errOk)
                 if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
                 if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
                 sock.closesocket(s)
@@ -72,37 +72,39 @@ export const suite = {
             }
 
             const onReadable = () => {
-                // Drain until content complete or null
+                // Drain until EOF (n===0 / ZERO_RETURN) or WANT_* hands back
+                // to the event loop.
                 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
+                    const buf = new ArrayBuffer(8192)
+                    const n = wolfssl.wolfSSL_read(ssl!, buf)
+                    if (typeof n !== 'number') {
+                        sawNonNumber = true
+                        std.printf('    FAIL got non-number %s (want int)\n', String(n))
+                        finish()
                         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)
+                    if (n > 0) {
+                        total += n
+                        // Keep draining after the body is complete: the point of
+                        // this suite is the no-data/EOF contract, so a full body
+                        // must not short-circuit the read that would observe it.
+                        continue
+                    }
+                    const err = wolfssl.wolfSSL_get_error(ssl!, n)
+                    if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
+                        errOk = false
+                        std.printf('    n=%d get_error=%d outside {WANT_READ,WANT_WRITE,ZERO_RETURN}\n', n, err)
                         finish()
                         return
                     }
-                    if (d instanceof ArrayBuffer) {
-                        sawArray = true
-                        total += d.byteLength
-                        if (total >= EXPECTED) break
+                    if (n === 0 || err === ZERO_RETURN) {
+                        sawEof = true
+                        break
                     }
+                    // WANT_*: wait for next FD_READ/WRITE
+                    return
                 }
-                if (total >= EXPECTED) finish()
+                if (sawEof) finish()
             }
 
             sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
@@ -161,17 +163,17 @@ export const suite = {
 
                 if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
                     // drain remaining then finish
-                    if (ssl && sentRequest && !sawNumber) {
+                    if (ssl && sentRequest && !sawNonNumber) {
                         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 (!sawNonNumber) {
+                        // Server close without an observed EOF read is an edge —
+                        // don't fail if the body already completed.
+                        if (!sawEof && total < EXPECTED && total > 0) {
+                            sawEof = true
                         }
-                        if (total >= EXPECTED || sawNull) finish()
-                        else assert('data before close', false); if (!done) finish()
+                        if (total >= EXPECTED || sawEof) finish()
+                        else { assert('data before close', false); if (!done) finish() }
                     }
                 }
             })

package/test/test_worker_net.js

@@ -27,25 +27,43 @@ export const suite = {
         catch (e) {
             t.checkTrue('worker creation failed: ' + e, false);
         }
+        // Retry across jsdelivr's official CDN hosts: a dropped connection
+        // on a slow CI network must not be reported as a TLS regression.
         t.section('npm-package');
         let worker3;
-        try {
-            const { data: r3 } = await new Promise((resolve, reject) => {
-                worker3 = new os.Worker('https://cdn.jsdelivr.net/npm/quickwin/test/worker_module.js');
-                const timer = os.setTimeout(() => reject(new Error('timeout')), 15000);
-                worker3.onmessage = (e) => {
-                    os.clearTimeout(timer);
-                    resolve({ worker: worker3, data: e.data });
-                };
-                worker3.postMessage({ type: 'start' });
-            });
-            t.check('npm worker message type', 'result', r3.type);
-            t.check('npm worker imported value', 42, r3.value);
-            worker3.postMessage({ type: 'done' });
-            worker3.onmessage = null;
-        }
-        catch (e) {
-            t.checkTrue('npm worker failed: ' + e, false);
+        const NPM_HOSTS = ['cdn.jsdelivr.net', 'fastly.jsdelivr.net', 'gcore.jsdelivr.net'];
+        let workerOk = false;
+        for (const host of NPM_HOSTS) {
+            for (let attempt = 0; attempt < 3 && !workerOk; attempt++) {
+                try {
+                    const { data: r3 } = await new Promise((resolve, reject) => {
+                        worker3 = new os.Worker('https://' + host + '/npm/quickwin/test/worker_module.js');
+                        const timer = os.setTimeout(() => reject(new Error('timeout')), 15000);
+                        worker3.onmessage = (e) => {
+                            os.clearTimeout(timer);
+                            resolve({ worker: worker3, data: e.data });
+                        };
+                        worker3.postMessage({ type: 'start' });
+                    });
+                    t.check('npm worker message type', 'result', r3.type);
+                    t.check('npm worker imported value', 42, r3.value);
+                    worker3.postMessage({ type: 'done' });
+                    worker3.onmessage = null;
+                    workerOk = true;
+                }
+                catch (e) {
+                    if (worker3) {
+                        worker3.onmessage = null;
+                        worker3 = null;
+                    }
+                    if (attempt === 2 && host === NPM_HOSTS[NPM_HOSTS.length - 1])
+                        t.checkTrue('npm worker failed: ' + e, false);
+                    else
+                        os.sleep(500);
+                }
+            }
+            if (workerOk)
+                break;
         }
     }
 };

package/test/test_worker_net.ts

@@ -31,24 +31,36 @@ export const suite = {
             t.checkTrue('worker creation failed: ' + e, false)
         }
 
+        // Retry across jsdelivr's official CDN hosts: a dropped connection
+        // on a slow CI network must not be reported as a TLS regression.
         t.section('npm-package')
         let worker3: any
-        try {
-            const { data: r3 } = await new Promise<any>((resolve, reject) => {
-                worker3 = new os.Worker('https://cdn.jsdelivr.net/npm/quickwin/test/worker_module.js')
-                const timer = os.setTimeout(() => reject(new Error('timeout')), 15000)
-                worker3.onmessage = (e: any) => {
-                    os.clearTimeout(timer)
-                    resolve({ worker: worker3, data: e.data })
+        const NPM_HOSTS = ['cdn.jsdelivr.net', 'fastly.jsdelivr.net', 'gcore.jsdelivr.net']
+        let workerOk = false
+        for (const host of NPM_HOSTS) {
+            for (let attempt = 0; attempt < 3 && !workerOk; attempt++) {
+                try {
+                    const { data: r3 } = await new Promise<any>((resolve, reject) => {
+                        worker3 = new os.Worker('https://' + host + '/npm/quickwin/test/worker_module.js')
+                        const timer = os.setTimeout(() => reject(new Error('timeout')), 15000)
+                        worker3.onmessage = (e: any) => {
+                            os.clearTimeout(timer)
+                            resolve({ worker: worker3, data: e.data })
+                        }
+                        worker3.postMessage({ type: 'start' })
+                    })
+                    t.check('npm worker message type', 'result', r3.type)
+                    t.check('npm worker imported value', 42, r3.value)
+                    worker3.postMessage({ type: 'done' })
+                    worker3.onmessage = null
+                    workerOk = true
+                } catch (e) {
+                    if (worker3) { worker3.onmessage = null; worker3 = null }
+                    if (attempt === 2 && host === NPM_HOSTS[NPM_HOSTS.length - 1]) t.checkTrue('npm worker failed: ' + e, false)
+                    else os.sleep(500)
                 }
-                worker3.postMessage({ type: 'start' })
-            })
-            t.check('npm worker message type', 'result', r3.type)
-            t.check('npm worker imported value', 42, r3.value)
-            worker3.postMessage({ type: 'done' })
-            worker3.onmessage = null
-        } catch (e) {
-            t.checkTrue('npm worker failed: ' + e, false)
+            }
+            if (workerOk) break
         }
     }
 }

package/tsconfig.json

@@ -15,7 +15,7 @@
     "esModuleInterop": true,
     // "skipLibCheck": true,
     "allowJs": false,
-    "lib": ["ES2020"],
+    "lib": ["ES2025"],
     "types": ["./quickwin.d.ts"],
     "rootDir": ".",
     "outDir": "_build",

package/examples/exec_server.ts

@@ -1,80 +0,0 @@
-import { createServer } from '../lib/http-server.js'
-import * as os from 'os'
-
-// WORKER_DATA_URL 由 esbuild --define 在 build.ts 中注入（base64 data: URL）
-declare const WORKER_DATA_URL: string
-
-const EXEC_TIMEOUT_MS = 60_000
-
-interface ExecResult {
-    out: Uint8Array
-    code: number
-    error: string | null
-}
-
-function runInWorker(cmd: string): Promise<ExecResult> {
-    return new Promise((resolve, reject) => {
-        const worker = new os.Worker(WORKER_DATA_URL)
-        const id = 1
-        let settled = false
-        let timer: ReturnType<typeof os.setTimeout>
-
-        const finish = (fn: () => void) => {
-            if (settled) return
-            settled = true
-            os.clearTimeout(timer)
-            worker.onmessage = null
-            fn()
-        }
-
-        timer = os.setTimeout(() => {
-            finish(() => reject(new Error('exec timeout')))
-        }, EXEC_TIMEOUT_MS)
-
-        worker.onmessage = (e) => {
-            const msg = e.data as { type: string; id: number; out?: Uint8Array; code?: number; error?: string | null }
-            if (msg.type !== 'result' || msg.id !== id) return
-            finish(() => resolve({ out: msg.out ?? new Uint8Array(0), code: msg.code ?? -1, error: msg.error ?? null }))
-        }
-
-        try {
-            worker.postMessage({ type: 'run', id, cmd })
-        } catch (ex) {
-            finish(() => reject(ex instanceof Error ? ex : new Error(String(ex))))
-        }
-    })
-}
-
-const server = createServer(async (req) => {
-    const path = new URL(req.url).pathname
-    if (req.method === 'GET' && (path === '/' || path === '/health')) {
-        return new Response('ok', { headers: { 'Content-Type': 'text/plain' } })
-    }
-    if (req.method === 'POST' && path === '/exec') {
-        const body = await req.json() as { cmd: string }
-        try {
-            const { out, code, error } = await runInWorker(body.cmd)
-            if (error) {
-                return new Response(JSON.stringify({ error }), {
-                    status: 500,
-                    headers: { 'Content-Type': 'application/json' }
-                })
-            }
-            return new Response(out, {
-                headers: {
-                    'Content-Type': 'application/octet-stream',
-                    'X-Exit-Code': String(code),
-                }
-            })
-        } catch (ex) {
-            return new Response(JSON.stringify({ error: String(ex) }), {
-                status: 504,
-                headers: { 'Content-Type': 'application/json' }
-            })
-        }
-    }
-    return new Response('Not Found', { status: 404 })
-})
-
-const rc = server.listen(8080, '0.0.0.0')
-console.log('listen rc=' + rc + ' addr=' + JSON.stringify(server.address()))

package/lib/ffi-bind.js

@@ -1,85 +0,0 @@
-import * as ffi from 'ffi';
-import * as win from 'win';
-import './text-codec.js';
-const KIND_TO_FFI = {
-    void: ffi.FFI_TYPE_VOID,
-    u8: ffi.FFI_TYPE_UINT8,
-    i8: ffi.FFI_TYPE_SINT8,
-    u16: ffi.FFI_TYPE_UINT16,
-    i16: ffi.FFI_TYPE_SINT16,
-    u32: ffi.FFI_TYPE_UINT32,
-    i32: ffi.FFI_TYPE_SINT32,
-    u64: ffi.FFI_TYPE_UINT64,
-    i64: ffi.FFI_TYPE_SINT64,
-    f32: ffi.FFI_TYPE_FLOAT,
-    f64: ffi.FFI_TYPE_DOUBLE,
-    ptr: ffi.FFI_TYPE_POINTER,
-    wstr: ffi.FFI_TYPE_POINTER,
-};
-// 与类型层 CTypeOf 同步的运行时别名表
-const C_ALIAS = {
-    int: 'i32', long: 'i32', short: 'i16', char: 'i8', float: 'f32', double: 'f64',
-    DWORD: 'u32', UINT: 'u32', ULONG: 'u32', LONG: 'i32', BOOL: 'i32', HRESULT: 'i32',
-    SHORT: 'i16', USHORT: 'u16', BYTE: 'u8',
-    LONG_PTR: 'ptr', ULONG_PTR: 'ptr', INT_PTR: 'ptr', UINT_PTR: 'ptr', DWORD_PTR: 'ptr',
-    SIZE_T: 'ptr', WPARAM: 'ptr', LPARAM: 'ptr',
-    HANDLE: 'ptr', HWND: 'ptr', HDC: 'ptr', HMODULE: 'ptr', HFONT: 'ptr', HBRUSH: 'ptr',
-    HICON: 'ptr', HBITMAP: 'ptr', LPVOID: 'ptr', LPCVOID: 'ptr', LPCWSTR: 'ptr',
-    PCWSTR: 'ptr', LPWSTR: 'ptr',
-};
-export function normKind(t) {
-    const k = C_ALIAS[t] ?? t;
-    if (!(k in KIND_TO_FFI))
-        throw new Error(`ffi-bind: invalid kind "${t}"`);
-    return k;
-}
-const _dllCache = new Map();
-function loadDll(dll) {
-    const cached = _dllCache.get(dll);
-    if (cached !== undefined)
-        return cached;
-    const loaded = win.LoadLibrary(dll);
-    if (!loaded)
-        throw new Error(`ffi-bind: LoadLibrary("${dll}") failed`);
-    _dllCache.set(dll, loaded);
-    return loaded;
-}
-function parseSig(sig) {
-    const parts = sig.split(' -> ');
-    const ret = parts[1];
-    if (ret === undefined || parts.length > 2) {
-        throw new Error(`ffi-bind: invalid signature "${sig}" (expected "arg1 arg2 -> ret")`);
-    }
-    const retK = normKind(ret);
-    if (retK === 'wstr')
-        throw new Error('ffi-bind: "wstr" cannot be a return type');
-    const tokens = (parts[0] ?? '') === '' ? [] : parts[0].split(' ');
-    const args = tokens.map((t) => normKind(t));
-    return { args, ret: retK };
-}
-function makeFn(proc, sig) {
-    const { args, ret } = parseSig(sig);
-    const argTypes = args.map((k) => KIND_TO_FFI[k]);
-    const retType = KIND_TO_FFI[ret];
-    return (...a) => {
-        const vals = args.map((k, i) => k === 'wstr' ? new TextEncoder('utf-16le').encode(String(a[i]) + '\0').buffer : a[i]);
-        return ffi.ffiCall(proc, argTypes, vals, retType);
-    };
-}
-export function bind(dll, name, sig) {
-    const proc = win.GetProcAddress(loadDll(dll), name);
-    if (!proc)
-        throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
-    return makeFn(proc, sig);
-}
-export function bindLib(dll, map) {
-    const out = {};
-    const h = loadDll(dll);
-    for (const [name, sig] of Object.entries(map)) {
-        const proc = win.GetProcAddress(h, name);
-        if (!proc)
-            throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
-        out[name] = makeFn(proc, sig);
-    }
-    return out;
-}

package/lib/ffi-bind.ts

@@ -1,170 +0,0 @@
-import * as ffi from 'ffi'
-import * as win from 'win'
-import './text-codec.js'
-
-// 声明式 FFI 绑定：把字符串签名（'ptr wstr i32 ptr i32 -> i32'）解析成
-// 一个可调用函数（bind）或一个 dll 的签名表（bindLib）。
-// kind：void u8 i8 u16 i16 u32 i32 u64 i64 f32 f64 ptr wstr
-//   可用 C/Windows typedef 别名：int long short char float double
-//     + DWORD UINT LONG BOOL HRESULT ... + *_PTR WPARAM LPARAM SIZE_T
-//     + HANDLE HWND HDC ... (+ LPVOID/LPCWSTR 等指针 typedef)
-//   别名在 token 层归一化到上面规范 kind（见 CTypeOf / C_ALIAS，两者须同步）
-//   ptr   收 ArrayBuffer | number | null，槽宽=指针宽（ia32 4B / x64 8B）
-//   wstr  收 string，自动 utf-16le+'\0' 编码后走 ptr 槽（仅参数，不能作返回）
-
-type Kind = 'void' | 'u8' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'u64' | 'i64' | 'f32' | 'f64' | 'ptr' | 'wstr'
-
-type ArgTypeOf = {
-    u8: number; i8: number; u16: number; i16: number
-    u32: number; i32: number
-    u64: number; i64: number
-    f32: number; f64: number
-    ptr: ArrayBuffer | number | null
-    wstr: string
-}
-type RetTypeOf = {
-    u8: number; i8: number; u16: number; i16: number
-    u32: number; i32: number
-    u64: number; i64: number
-    f32: number; f64: number
-    ptr: number | null
-}
-
-// C / Windows typedef → 规范 kind。Windows x86/x64 均 LLP64：int/long 恒 32 位，
-// long long 恒 64 位；LONG_PTR/WPARAM/SIZE_T 等指针宽随 arch 走 'ptr' 槽。
-// 运行时见 C_ALIAS（两表内容必须保持一致）。
-type CTypeOf = {
-    int: 'i32'
-    long: 'i32'
-    short: 'i16'
-    char: 'i8'
-    float: 'f32'
-    double: 'f64'
-    DWORD: 'u32'
-    UINT: 'u32'
-    ULONG: 'u32'
-    LONG: 'i32'
-    BOOL: 'i32'
-    HRESULT: 'i32'
-    SHORT: 'i16'
-    USHORT: 'u16'
-    BYTE: 'u8'
-    LONG_PTR: 'ptr'
-    ULONG_PTR: 'ptr'
-    INT_PTR: 'ptr'
-    UINT_PTR: 'ptr'
-    DWORD_PTR: 'ptr'
-    SIZE_T: 'ptr'
-    WPARAM: 'ptr'
-    LPARAM: 'ptr'
-    HANDLE: 'ptr'
-    HWND: 'ptr'
-    HDC: 'ptr'
-    HMODULE: 'ptr'
-    HFONT: 'ptr'
-    HBRUSH: 'ptr'
-    HICON: 'ptr'
-    HBITMAP: 'ptr'
-    LPVOID: 'ptr'
-    LPCVOID: 'ptr'
-    LPCWSTR: 'ptr'
-    PCWSTR: 'ptr'
-    LPWSTR: 'ptr'
-}
-
-export type Norm<T extends string> = T extends keyof CTypeOf ? CTypeOf[T] : T
-
-type ArgsOf<T extends string> =
-    T extends '' ? []
-        : T extends `${infer H} ${infer R}` ? [ArgTypeOf[Norm<H> & keyof ArgTypeOf], ...ArgsOf<R>]
-        : [ArgTypeOf[Norm<T> & keyof ArgTypeOf]]
-
-type _Args<S extends string> = S extends `${infer A} -> ${string}` ? ArgsOf<A> : never
-type _Ret<S extends string> = S extends `${string} -> ${infer R}` ? RetTypeOf[Norm<R> & keyof RetTypeOf] : never
-
-const KIND_TO_FFI: Record<Kind, ffi.FfiType> = {
-    void: ffi.FFI_TYPE_VOID,
-    u8: ffi.FFI_TYPE_UINT8,
-    i8: ffi.FFI_TYPE_SINT8,
-    u16: ffi.FFI_TYPE_UINT16,
-    i16: ffi.FFI_TYPE_SINT16,
-    u32: ffi.FFI_TYPE_UINT32,
-    i32: ffi.FFI_TYPE_SINT32,
-    u64: ffi.FFI_TYPE_UINT64,
-    i64: ffi.FFI_TYPE_SINT64,
-    f32: ffi.FFI_TYPE_FLOAT,
-    f64: ffi.FFI_TYPE_DOUBLE,
-    ptr: ffi.FFI_TYPE_POINTER,
-    wstr: ffi.FFI_TYPE_POINTER,
-}
-
-// 与类型层 CTypeOf 同步的运行时别名表
-const C_ALIAS: Record<string, Kind> = {
-    int: 'i32', long: 'i32', short: 'i16', char: 'i8', float: 'f32', double: 'f64',
-    DWORD: 'u32', UINT: 'u32', ULONG: 'u32', LONG: 'i32', BOOL: 'i32', HRESULT: 'i32',
-    SHORT: 'i16', USHORT: 'u16', BYTE: 'u8',
-    LONG_PTR: 'ptr', ULONG_PTR: 'ptr', INT_PTR: 'ptr', UINT_PTR: 'ptr', DWORD_PTR: 'ptr',
-    SIZE_T: 'ptr', WPARAM: 'ptr', LPARAM: 'ptr',
-    HANDLE: 'ptr', HWND: 'ptr', HDC: 'ptr', HMODULE: 'ptr', HFONT: 'ptr', HBRUSH: 'ptr',
-    HICON: 'ptr', HBITMAP: 'ptr', LPVOID: 'ptr', LPCVOID: 'ptr', LPCWSTR: 'ptr',
-    PCWSTR: 'ptr', LPWSTR: 'ptr',
-}
-
-export function normKind(t: string): Kind {
-    const k = C_ALIAS[t] ?? t
-    if (!(k in KIND_TO_FFI)) throw new Error(`ffi-bind: invalid kind "${t}"`)
-    return k as Kind
-}
-
-const _dllCache: Map<string, win.HMODULE> = new Map()
-
-function loadDll(dll: string): win.HMODULE {
-    const cached = _dllCache.get(dll)
-    if (cached !== undefined) return cached
-    const loaded = win.LoadLibrary(dll)
-    if (!loaded) throw new Error(`ffi-bind: LoadLibrary("${dll}") failed`)
-    _dllCache.set(dll, loaded)
-    return loaded
-}
-
-function parseSig(sig: string): { args: Kind[]; ret: Kind } {
-    const parts = sig.split(' -> ')
-    const ret = parts[1]
-    if (ret === undefined || parts.length > 2) {
-        throw new Error(`ffi-bind: invalid signature "${sig}" (expected "arg1 arg2 -> ret")`)
-    }
-    const retK = normKind(ret)
-    if (retK === 'wstr') throw new Error('ffi-bind: "wstr" cannot be a return type')
-    const tokens = (parts[0] ?? '') === '' ? [] : (parts[0] as string).split(' ')
-    const args = tokens.map((t) => normKind(t))
-    return { args, ret: retK }
-}
-
-function makeFn(proc: number, sig: string): (...a: unknown[]) => unknown {
-    const { args, ret } = parseSig(sig)
-    const argTypes = args.map((k) => KIND_TO_FFI[k])
-    const retType = KIND_TO_FFI[ret]
-    return (...a: unknown[]) => {
-        const vals = args.map((k, i) =>
-            k === 'wstr' ? new TextEncoder('utf-16le').encode(String(a[i]) + '\0').buffer : a[i])
-        return ffi.ffiCall(proc, argTypes as any, vals as any, retType)
-    }
-}
-
-export function bind<const S extends string>(dll: string, name: string, sig: S): (...args: _Args<S>) => _Ret<S> {
-    const proc = win.GetProcAddress(loadDll(dll), name)
-    if (!proc) throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`)
-    return makeFn(proc, sig) as unknown as (...args: _Args<S>) => _Ret<S>
-}
-
-export function bindLib<const M extends Record<string, string>>(dll: string, map: M):
-    { [K in keyof M]: (...args: _Args<M[K]>) => _Ret<M[K]> } {
-    const out: Record<string, (...a: unknown[]) => unknown> = {}
-    const h = loadDll(dll)
-    for (const [name, sig] of Object.entries(map)) {
-        const proc = win.GetProcAddress(h, name)
-        if (!proc) throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`)
-        out[name] = makeFn(proc, sig)
-    }
-    return out as { [K in keyof M]: (...args: _Args<M[K]>) => _Ret<M[K]> }
-}