quickwin 1.2.0 → 1.3.0

package/lib/fetch.js

@@ -81,6 +81,10 @@ async function fetchRequest(req) {
         let receivedBytes = 0;
         const cleanupSocket = () => {
             state = ST_DONE;
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = undefined;
+            }
             if (ssl) {
                 wolfssl.wolfSSL_free(ssl);
                 ssl = null;
@@ -100,12 +104,38 @@ async function fetchRequest(req) {
                 timerId = undefined;
             }
         };
+        const armTimeout = () => {
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = undefined;
+            }
+            timerId = setTimeout(() => {
+                timerId = undefined;
+                if (state === ST_DONE)
+                    return;
+                if (!resolved) {
+                    doReject(new Error('Request timeout'));
+                    return;
+                }
+                if (state === ST_RECV_BODY && stream && _controller) {
+                    try {
+                        _controller.error(new Error('Body timeout'));
+                    }
+                    catch { /* already closed */ }
+                    stream = null;
+                    cleanupSocket();
+                }
+            }, timeout);
+        };
         const doResolve = (response) => {
-            if (!resolved) {
-                resolved = true;
+            if (resolved)
+                return;
+            resolved = true;
+            if (state === ST_DONE)
                 cleanup();
-                resolve(response);
-            }
+            else
+                armTimeout();
+            resolve(response);
         };
         const doReject = (error) => {
             if (!resolved) {
@@ -115,9 +145,7 @@ async function fetchRequest(req) {
                 reject(error);
             }
         };
-        timerId = setTimeout(() => {
-            doReject(new Error('Request timeout'));
-        }, timeout);
+        armTimeout();
         s = sock.socket();
         if (s < 0) {
             doReject(new Error('Failed to create socket'));

package/lib/fetch.ts

@@ -107,6 +107,7 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
 
         const cleanupSocket = (): void => {
             state = ST_DONE
+            if (timerId) { clearTimeout(timerId); timerId = undefined }
             if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
             if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
             if (s !== null && s >= 0) { sock.closesocket(s); s = null }
@@ -116,17 +117,36 @@ async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
             if (timerId) { clearTimeout(timerId); timerId = undefined }
         }
 
+        const armTimeout = (): void => {
+            if (timerId) { clearTimeout(timerId); timerId = undefined }
+            timerId = setTimeout(() => {
+                timerId = undefined
+                if (state === ST_DONE) return
+                if (!resolved) {
+                    doReject(new Error('Request timeout'))
+                    return
+                }
+                if (state === ST_RECV_BODY && stream && _controller) {
+                    try { _controller.error(new Error('Body timeout')) } catch { /* already closed */ }
+                    stream = null
+                    cleanupSocket()
+                }
+            }, timeout)
+        }
+
         const doResolve = (response: ResponseImpl): void => {
-            if (!resolved) { resolved = true; cleanup(); resolve(response) }
+            if (resolved) return
+            resolved = true
+            if (state === ST_DONE) cleanup()
+            else armTimeout()
+            resolve(response)
         }
 
         const doReject = (error: Error): void => {
             if (!resolved) { resolved = true; cleanup(); cleanupSocket(); reject(error) }
         }
 
-        timerId = setTimeout(() => {
-            doReject(new Error('Request timeout'))
-        }, timeout)
+        armTimeout()
 
         s = sock.socket()
         if (s < 0) { doReject(new Error('Failed to create socket')); return }

package/lib/ffi-bind.js

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,170 @@
+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]> }
+}

package/lib/ffi-struct.js

@@ -0,0 +1,224 @@
+import * as os from 'os';
+import { normKind } from './ffi-bind.js';
+const PTR = os.arch === 'x64' ? 8 : 4;
+// kind → [align, size]
+const AS = {
+    u8: [1, 1], i8: [1, 1],
+    u16: [2, 2], i16: [2, 2],
+    u32: [4, 4], i32: [4, 4],
+    u64: [8, 8], i64: [8, 8],
+    f32: [4, 4], f64: [8, 8],
+    ptr: [PTR, PTR],
+    wstr: [2, 2], // 仅定长数组元素用（wchar）
+};
+function alignUp(v, a) {
+    return (v + a - 1) & ~(a - 1);
+}
+function parseField(f) {
+    const arr = /^(.+)\[(\d+)\]$/.exec(f);
+    if (arr) {
+        const b = normKind(arr[1]);
+        if (b === 'void')
+            throw new Error(`ffi-struct: "void" cannot be an array base`);
+        return { base: b, count: Number(arr[2]) };
+    }
+    const b = normKind(f);
+    if (b === 'void' || b === 'wstr')
+        throw new Error(`ffi-struct: invalid scalar field type "${f}"`);
+    return { base: b, count: 1 };
+}
+function layout(def) {
+    const fields = [];
+    let cursor = 0;
+    let maxAlign = 1;
+    for (const key of Object.keys(def)) {
+        const v = def[key];
+        let a;
+        let w;
+        if (typeof v === 'string') {
+            const { base, count } = parseField(v);
+            const [align, elem] = AS[base];
+            a = align;
+            w = count >= 1 ? elem * count : elem;
+            fields.push({ name: key, base, count, offset: 0 });
+        }
+        else {
+            const child = v;
+            a = child.structAlign;
+            w = child.size;
+            fields.push({ name: key, base: 'u8', count: 0, offset: 0, child });
+        }
+        const off = alignUp(cursor, a);
+        const f = fields[fields.length - 1];
+        f.offset = off;
+        cursor = off + w;
+        if (a > maxAlign)
+            maxAlign = a;
+    }
+    return { fields, size: alignUp(cursor, maxAlign), structAlign: maxAlign };
+}
+const _layoutCache = new WeakMap();
+function buildLayout(def) {
+    let hit = _layoutCache.get(def);
+    if (hit)
+        return hit;
+    hit = layout(def);
+    _layoutCache.set(def, hit);
+    return hit;
+}
+function readScalar(dv, off, k) {
+    switch (k) {
+        case 'u8': return dv.getUint8(off);
+        case 'i8': return dv.getInt8(off);
+        case 'u16': return dv.getUint16(off, true);
+        case 'i16': return dv.getInt16(off, true);
+        case 'u32': return dv.getUint32(off, true);
+        case 'i32': return dv.getInt32(off, true);
+        case 'u64': return Number(dv.getBigUint64(off, true));
+        case 'i64': return Number(dv.getBigInt64(off, true));
+        case 'f32': return dv.getFloat32(off, true);
+        case 'f64': return dv.getFloat64(off, true);
+        case 'ptr': return readPtr(dv, off);
+        case 'wstr': return dv.getUint16(off, true);
+    }
+}
+function readPtr(dv, off) {
+    if (PTR === 8)
+        return Number(dv.getBigUint64(off, true));
+    return dv.getUint32(off, true);
+}
+function writeScalar(dv, off, k, val) {
+    switch (k) {
+        case 'u8':
+            dv.setUint8(off, val);
+            break;
+        case 'i8':
+            dv.setInt8(off, val);
+            break;
+        case 'u16':
+            dv.setUint16(off, val, true);
+            break;
+        case 'i16':
+            dv.setInt16(off, val, true);
+            break;
+        case 'u32':
+            dv.setUint32(off, val >>> 0, true);
+            break;
+        case 'i32':
+            dv.setInt32(off, val | 0, true);
+            break;
+        case 'u64':
+            dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
+            break;
+        case 'i64':
+            dv.setBigInt64(off, BigInt(Math.trunc(val)), true);
+            break;
+        case 'f32':
+            dv.setFloat32(off, val, true);
+            break;
+        case 'f64':
+            dv.setFloat64(off, val, true);
+            break;
+        case 'ptr':
+            writePtr(dv, off, val);
+            break;
+        case 'wstr':
+            dv.setUint16(off, val, true);
+            break;
+    }
+}
+function writePtr(dv, off, val) {
+    if (PTR === 8)
+        dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
+    else
+        dv.setUint32(off, val >>> 0, true);
+}
+function readField(dv, base, f) {
+    const off = base + f.offset;
+    if (f.child)
+        return readInto(f.child, dv.buffer, off);
+    if (f.count > 1) {
+        if (f.base === 'wstr') {
+            const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
+            let end = 0;
+            while (end < arr.length && arr[end] !== 0)
+                end++;
+            let s = '';
+            for (let i = 0; i < end; i++)
+                s += String.fromCharCode(arr[i]);
+            return s;
+        }
+        const out = [];
+        const step = AS[f.base][1];
+        for (let i = 0; i < f.count; i++)
+            out.push(readScalar(dv, off + i * step, f.base));
+        return out;
+    }
+    return readScalar(dv, off, f.base);
+}
+function writeField(dv, base, f, v) {
+    const off = base + f.offset;
+    if (f.child) {
+        writeInto(f.child, v, dv.buffer, off);
+        return;
+    }
+    if (f.count > 1) {
+        if (f.base === 'wstr') {
+            const s = String(v ?? '');
+            const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
+            for (let i = 0; i < arr.length; i++)
+                arr[i] = 0;
+            const n = Math.min(s.length, f.count - 1);
+            for (let i = 0; i < n; i++)
+                arr[i] = s.charCodeAt(i);
+            return;
+        }
+        const step = AS[f.base][1];
+        const list = (v ?? []);
+        for (let i = 0; i < f.count; i++)
+            writeScalar(dv, off + i * step, f.base, list[i] ?? 0);
+        return;
+    }
+    writeScalar(dv, off, f.base, Number(v));
+}
+function doSize(def) {
+    return buildLayout(def).size;
+}
+function readInto(child, buf, offset) {
+    const r = child;
+    return r.read(buf, offset);
+}
+function doRead(_def, fields, buf, offset) {
+    const out = {};
+    const dv = new DataView(buf);
+    for (const f of fields)
+        out[f.name] = readField(dv, offset, f);
+    return out;
+}
+function doWrite(def, fields, v, buf, offset = 0) {
+    buf = buf ?? new ArrayBuffer(doSize(def));
+    const dv = new DataView(buf);
+    for (const f of fields)
+        writeField(dv, offset, f, v[f.name]);
+    return buf;
+}
+function writeInto(child, v, buf, offset) {
+    const w = child;
+    w.write(v, buf, offset);
+}
+export function struct(def) {
+    const { fields, size, structAlign } = buildLayout(def);
+    return {
+        __fields: def,
+        size,
+        structAlign,
+        read: (buf, offset = 0) => doRead(def, fields, buf, offset),
+        write: (v, buf, offset = 0) => doWrite(def, fields, v, buf, offset),
+        offsetOf: (name) => {
+            for (const f of fields)
+                if (f.name === name)
+                    return f.offset;
+            throw new Error(`ffi-struct: no field "${String(name)}"`);
+        },
+    };
+}