quickwin 2026.5.2-3.145209

package/test/test_helper.ts

@@ -0,0 +1,80 @@
+import * as std from 'std'
+
+const GREEN = '\x1b[32m'
+const RED   = '\x1b[31m'
+const BOLD  = '\x1b[1m'
+const RESET = '\x1b[0m'
+
+function formatDuration(ms: number): string {
+    if (ms >= 1000) return (ms / 1000).toFixed(2) + 's'
+    return ms + 'ms'
+}
+
+export function readWasmFile(path: string): ArrayBuffer | null {
+    const base = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1)
+    const parts = (base + path).split('/')
+    const out: string[] = []
+    for (const p of parts) {
+        if (p === '..') out.pop()
+        else if (p !== '.') out.push(p)
+    }
+    let filePath = out.join('/').slice(7)
+    if (filePath.length >= 3 && filePath[1] === ':') filePath = filePath.slice(1)
+    const fp = std.open(filePath, 'rb')
+    if (!fp) return null
+    fp.seek(0, 2)
+    const size = fp.tell()
+    fp.seek(0, 0)
+    const buffer = new ArrayBuffer(size)
+    fp.read(buffer, 0, size)
+    fp.close()
+    return buffer
+}
+
+export class Tester {
+    ok = 0
+    fail = 0
+    private startTime = Date.now()
+    private sectionStart = this.startTime
+    private lastSection = ''
+
+    section(name: string): void {
+        const now = Date.now()
+        if (this.lastSection) {
+            const elapsed = now - this.sectionStart
+            std.printf('  (%s)\n', formatDuration(elapsed))
+        }
+        this.sectionStart = now
+        this.lastSection = name
+        std.printf('\n%s=== %s ===%s\n', BOLD, name, RESET)
+    }
+
+    check(name: string, expected: unknown, actual: unknown): void {
+        if (typeof expected === 'number' && typeof actual === 'number') {
+            if (Math.abs(expected - actual) < 0.0001) {
+                this.ok++; std.printf('  %sPASS:%s %s = %s\n', GREEN, RESET, name, String(actual))
+            } else {
+                this.fail++; std.printf('  %sFAIL:%s %s = %s (expected %s)\n', RED, RESET, name, String(actual), String(expected))
+            }
+        } else if (expected === actual) {
+            this.ok++; std.printf('  %sPASS:%s %s = %s\n', GREEN, RESET, name, String(actual))
+        } else {
+            this.fail++; std.printf('  %sFAIL:%s %s = %s (expected %s)\n', RED, RESET, name, String(actual), String(expected))
+        }
+    }
+
+    checkTrue(name: string, actual: boolean): void {
+        this.check(name, true, actual)
+    }
+
+    summary(): void {
+        const now = Date.now()
+        if (this.lastSection) {
+            const elapsed = now - this.sectionStart
+            std.printf('  (%s)\n', formatDuration(elapsed))
+        }
+        const total = now - this.startTime
+        const color = this.fail > 0 ? RED : GREEN
+        std.printf('\n%s%d/%d passed (%s)%s\n', color, this.ok, this.ok + this.fail, formatDuration(total), RESET)
+    }
+}

package/test/test_http_import.js

@@ -0,0 +1,78 @@
+import * as std from 'std';
+import * as os from 'os';
+function getCacheDir() {
+    // import.meta.url: file:///C:/.../_build/test/file.js
+    const url = import.meta.url;
+    // Strip file:// (7 chars), giving /C:/.../
+    let path = url.slice(7);
+    // Remove leading / before drive letter
+    if (path.length >= 3 && path[1] === ':')
+        path = path.slice(1);
+    // path now: C:/Users/Docker/quickwin/_build/test/file.js
+    // Go up to _build/
+    const idx = path.lastIndexOf('/');
+    if (idx < 0)
+        return '_cache';
+    const buildDir = path.slice(0, idx); // .../_build/test
+    const idx2 = buildDir.lastIndexOf('/');
+    if (idx2 < 0)
+        return '_cache';
+    return buildDir.slice(0, idx2 + 1) + '_cache'; // .../_build/_cache
+}
+export const suite = {
+    name: 'http-import',
+    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);
+            }
+        }
+        const url = 'https://esm.sh/left-pad@1.3.0';
+        const cacheDir = getCacheDir();
+        t.section('list cache before');
+        const [before, err] = os.readdir(cacheDir);
+        if (err !== 0) {
+            std.printf('  cache dir: %s (error %d, will be created on first request)\n', cacheDir, err);
+        }
+        const beforeCount = err === 0 ? before.length : 0;
+        t.section('import module');
+        let mod;
+        try {
+            mod = await import(url);
+        }
+        catch (e) {
+            assert('import succeeds', false);
+            std.printf('  ERROR: %s\n', String(e));
+            return;
+        }
+        assert('import succeeds', true);
+        assert('default is function', typeof mod.default === 'function');
+        assert('left-pad works', mod.default('hello', 8) === '   hello');
+        t.section('check cache');
+        const [after, err2] = os.readdir(cacheDir);
+        assert('cache dir readable', err2 === 0);
+        if (err2 !== 0)
+            return;
+        assert('cache has body files', after.some(function (f) { return f.endsWith('.body'); }));
+        assert('cache has meta files', after.some(function (f) { return f.endsWith('.meta'); }));
+        for (const f of after) {
+            if (f.endsWith('.meta') && (err !== 0 || before.indexOf(f) < 0)) {
+                std.printf('  meta: %s\n', f);
+                const fp = std.open(cacheDir + '/' + f, 'r');
+                if (fp) {
+                    const metaStr = fp.readAsString();
+                    fp.close();
+                    if (metaStr) {
+                        const meta = JSON.parse(metaStr);
+                        std.printf('    storedAt: %d, maxAge: %d\n', meta.storedAt, meta.maxAge);
+                    }
+                }
+            }
+        }
+    }
+};

package/test/test_http_import.ts

@@ -0,0 +1,74 @@
+import * as std from 'std'
+import * as os from 'os'
+import { Tester } from './test_helper.js'
+
+function getCacheDir(): string {
+    // import.meta.url: file:///C:/.../_build/test/file.js
+    const url = import.meta.url
+    // Strip file:// (7 chars), giving /C:/.../
+    let path = url.slice(7)
+    // Remove leading / before drive letter
+    if (path.length >= 3 && path[1] === ':') path = path.slice(1)
+    // path now: C:/Users/Docker/quickwin/_build/test/file.js
+    // Go up to _build/
+    const idx = path.lastIndexOf('/')
+    if (idx < 0) return '_cache'
+    const buildDir = path.slice(0, idx) // .../_build/test
+    const idx2 = buildDir.lastIndexOf('/')
+    if (idx2 < 0) return '_cache'
+    return buildDir.slice(0, idx2 + 1) + '_cache' // .../_build/_cache
+}
+
+export const suite = {
+    name: 'http-import',
+    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) }
+        }
+
+        const url = 'https://esm.sh/left-pad@1.3.0'
+        const cacheDir = getCacheDir()
+
+        t.section('list cache before')
+        const [before, err] = os.readdir(cacheDir)
+        if (err !== 0) {
+            std.printf('  cache dir: %s (error %d, will be created on first request)\n', cacheDir, err)
+        }
+        const beforeCount = err === 0 ? before.length : 0
+
+        t.section('import module')
+        let mod: any
+        try {
+            mod = await import(url)
+        } catch (e) {
+            assert('import succeeds', false)
+            std.printf('  ERROR: %s\n', String(e))
+            return
+        }
+        assert('import succeeds', true)
+        assert('default is function', typeof mod.default === 'function')
+        assert('left-pad works', mod.default('hello', 8) === '   hello')
+
+        t.section('check cache')
+        const [after, err2] = os.readdir(cacheDir)
+        assert('cache dir readable', err2 === 0)
+        if (err2 !== 0) return
+        assert('cache has body files', after.some(function(f: string) { return f.endsWith('.body') }))
+        assert('cache has meta files', after.some(function(f: string) { return f.endsWith('.meta') }))
+        for (const f of after) {
+            if (f.endsWith('.meta') && (err !== 0 || before.indexOf(f) < 0)) {
+                std.printf('  meta: %s\n', f)
+                const fp = std.open(cacheDir + '/' + f, 'r')
+                if (fp) {
+                    const metaStr = fp.readAsString()
+                    fp.close()
+                    if (metaStr) {
+                        const meta = JSON.parse(metaStr)
+                        std.printf('    storedAt: %d, maxAge: %d\n', meta.storedAt, meta.maxAge)
+                    }
+                }
+            }
+        }
+    }
+}

package/test/test_mupdf_render.js

@@ -0,0 +1,69 @@
+import * as std from 'std';
+import '../lib/polyfill.js';
+function loadWasmBytes(path) {
+    const fp = std.open(path, 'rb');
+    if (!fp)
+        throw new Error('Cannot open: ' + path);
+    fp.seek(0, 2);
+    const size = fp.tell();
+    fp.seek(0, 0);
+    const buffer = new ArrayBuffer(size);
+    fp.read(buffer, 0, size);
+    fp.close();
+    return buffer;
+}
+function setupMupdfModule(wasmPath) {
+    const wasmBinary = loadWasmBytes(wasmPath);
+    globalThis["$libmupdf_wasm_Module"] = {
+        wasmBinary,
+        locateFile: (p) => p
+    };
+}
+export const suite = {
+    name: 'mupdf-render',
+    run: async (t) => {
+        try {
+            setupMupdfModule('./vendor/mupdf-wasm/mupdf-wasm.wasm');
+            const mupdf = await import('../vendor/mupdf-wasm/mupdf.js');
+            const fp = std.open('./example.pdf', 'rb');
+            if (!fp) {
+                console.log('SKIP: no example.pdf');
+                return;
+            }
+            fp.seek(0, 2);
+            const size = fp.tell();
+            fp.seek(0, 0);
+            const buf = new ArrayBuffer(size);
+            fp.read(buf, 0, size);
+            fp.close();
+            console.log('pdf size:', size);
+            const doc = mupdf.Document.openDocument(new Uint8Array(buf), "application/pdf");
+            console.log('pages:', doc.countPages());
+            const page = doc.loadPage(0);
+            const bounds = page.getBounds();
+            if (bounds && bounds.length === 4)
+                console.log('page size:', bounds[2] - bounds[0], 'x', bounds[3] - bounds[1]);
+            const pixmap = page.toPixmap(mupdf.Matrix.scale(2, 2), mupdf.ColorSpace.DeviceRGB, false);
+            if (pixmap) {
+                console.log('pixmap:', pixmap.getWidth(), 'x', pixmap.getHeight());
+                const png = pixmap.asPNG();
+                console.log('png size:', png.byteLength);
+                const out = std.open('./output.png', 'wb');
+                if (out) {
+                    const pngBuf = new ArrayBuffer(png.byteLength);
+                    new Uint8Array(pngBuf).set(png);
+                    out.write(pngBuf, 0, png.byteLength);
+                    out.close();
+                }
+                console.log('saved to output.png');
+            }
+            doc.destroy();
+            console.log('done');
+            t.ok++;
+        }
+        catch (error) {
+            console.log('ERROR:', error);
+            t.fail++;
+        }
+    }
+};

package/test/test_mupdf_render.ts

@@ -0,0 +1,74 @@
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+import '../lib/polyfill.js'
+
+function loadWasmBytes(path: string): ArrayBuffer {
+    const fp = std.open(path, 'rb')
+    if (!fp) throw new Error('Cannot open: ' + path)
+    fp.seek(0, 2)
+    const size = fp.tell()
+    fp.seek(0, 0)
+    const buffer = new ArrayBuffer(size)
+    fp.read(buffer, 0, size)
+    fp.close()
+    return buffer
+}
+
+function setupMupdfModule(wasmPath: string) {
+    const wasmBinary = loadWasmBytes(wasmPath)
+    ;(globalThis as any)["$libmupdf_wasm_Module"] = {
+        wasmBinary,
+        locateFile: (p: string) => p
+    }
+}
+
+export const suite = {
+    name: 'mupdf-render',
+    run: async (t: Tester): Promise<void> => {
+        try {
+            setupMupdfModule('./vendor/mupdf-wasm/mupdf-wasm.wasm')
+
+            const mupdf: typeof import('../vendor/mupdf-wasm/mupdf.js') = await import('../vendor/mupdf-wasm/mupdf.js')
+
+            const fp = std.open('./example.pdf', 'rb')
+            if (!fp) { console.log('SKIP: no example.pdf'); return }
+            fp.seek(0, 2)
+            const size = fp.tell()
+            fp.seek(0, 0)
+            const buf = new ArrayBuffer(size)
+            fp.read(buf, 0, size)
+            fp.close()
+            console.log('pdf size:', size)
+
+            const doc = mupdf.Document.openDocument(new Uint8Array(buf), "application/pdf")
+            console.log('pages:', doc.countPages())
+
+            const page = doc.loadPage(0)
+            const bounds = page.getBounds()
+            if (bounds && bounds.length === 4)
+                console.log('page size:', bounds[2] - bounds[0], 'x', bounds[3] - bounds[1])
+
+            const pixmap = page.toPixmap(mupdf.Matrix.scale(2, 2), mupdf.ColorSpace.DeviceRGB, false)
+            if (pixmap) {
+                console.log('pixmap:', pixmap.getWidth(), 'x', pixmap.getHeight())
+                const png = pixmap.asPNG()
+                console.log('png size:', png.byteLength)
+                const out = std.open('./output.png', 'wb')
+                if (out) {
+                    const pngBuf = new ArrayBuffer(png.byteLength)
+                    new Uint8Array(pngBuf).set(png)
+                    out.write(pngBuf, 0, png.byteLength)
+                    out.close()
+                }
+                console.log('saved to output.png')
+            }
+
+            doc.destroy()
+            console.log('done')
+            t.ok++
+        } catch (error) {
+            console.log('ERROR:', error)
+            t.fail++
+        }
+    }
+}

package/test/test_mupdf_twice.js

@@ -0,0 +1,77 @@
+import '../lib/polyfill.js';
+import * as std from 'std';
+function loadWasmBytes(path) {
+    const fp = std.open(path, 'rb');
+    if (!fp)
+        throw new Error('Cannot open: ' + path);
+    fp.seek(0, 2);
+    const size = fp.tell();
+    fp.seek(0, 0);
+    const buffer = new ArrayBuffer(size);
+    fp.read(buffer, 0, size);
+    fp.close();
+    return buffer;
+}
+export const suite = {
+    name: 'mupdf-twice',
+    run: async (t) => {
+        try {
+            console.log('  Loading WASM binary...');
+            const wasmBinary = loadWasmBytes('./vendor/mupdf-wasm/mupdf-wasm.wasm');
+            console.log('  WASM binary loaded, size:', wasmBinary.byteLength);
+            globalThis["$libmupdf_wasm_Module"] = {
+                wasmBinary,
+                locateFile: (p) => p
+            };
+            console.log('  Importing mupdf module...');
+            const mupdf = await import('../vendor/mupdf-wasm/mupdf.js');
+            console.log('  mupdf module imported ok');
+            const fp = std.open('./example.pdf', 'rb');
+            if (!fp) {
+                console.log('SKIP: no example.pdf');
+                return;
+            }
+            fp.seek(0, 2);
+            const size = fp.tell();
+            fp.seek(0, 0);
+            const pdfBuf = new ArrayBuffer(size);
+            fp.read(pdfBuf, 0, size);
+            fp.close();
+            console.log('  PDF loaded, size:', size);
+            t.section('Test 1: two toPixmap on same page (no destroy)');
+            try {
+                const doc = mupdf.Document.openDocument(new Uint8Array(pdfBuf), "application/pdf");
+                const page = doc.loadPage(0);
+                console.log('  1: toPixmap #1...');
+                const pm1 = page.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false);
+                console.log('  1: toPixmap #1 done:', pm1.getWidth(), 'x', pm1.getHeight());
+                t.check('toPixmap #1 ok', true, pm1 !== null);
+                console.log('  1: toPixmap #2...');
+                const pm2 = page.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false);
+                console.log('  1: toPixmap #2 done:', pm2.getWidth(), 'x', pm2.getHeight());
+                t.check('toPixmap #2 ok', true, pm2 !== null);
+            }
+            catch (e) {
+                console.log('  1: ERROR:', e instanceof Error ? e.message : String(e));
+            }
+            t.section('Test 2: second openDocument + toPixmap (no destroy of first)');
+            try {
+                console.log('  2: openDocument #2...');
+                const doc2 = mupdf.Document.openDocument(new Uint8Array(pdfBuf), "application/pdf");
+                console.log('  2: loadPage #2...');
+                const page2 = doc2.loadPage(0);
+                console.log('  2: toPixmap #3...');
+                const pm3 = page2.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false);
+                console.log('  2: toPixmap #3 done:', pm3.getWidth(), 'x', pm3.getHeight());
+                t.check('toPixmap #3 ok', true, pm3 !== null);
+            }
+            catch (e) {
+                console.log('  2: ERROR:', e instanceof Error ? e.message : String(e));
+            }
+            console.log('All mupdf-twice tests done');
+        }
+        catch (e) {
+            console.log('TOP-LEVEL ERROR:', e instanceof Error ? e.message : String(e));
+        }
+    }
+};

package/test/test_mupdf_twice.ts

@@ -0,0 +1,81 @@
+import '../lib/polyfill.js'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+function loadWasmBytes(path: string): ArrayBuffer {
+    const fp = std.open(path, 'rb')
+    if (!fp) throw new Error('Cannot open: ' + path)
+    fp.seek(0, 2)
+    const size = fp.tell()
+    fp.seek(0, 0)
+    const buffer = new ArrayBuffer(size)
+    fp.read(buffer, 0, size)
+    fp.close()
+    return buffer
+}
+
+export const suite = {
+    name: 'mupdf-twice',
+    run: async (t: Tester): Promise<void> => {
+        try {
+            console.log('  Loading WASM binary...')
+            const wasmBinary = loadWasmBytes('./vendor/mupdf-wasm/mupdf-wasm.wasm')
+            console.log('  WASM binary loaded, size:', wasmBinary.byteLength)
+
+            ;(globalThis as any)["$libmupdf_wasm_Module"] = {
+                wasmBinary,
+                locateFile: (p: string) => p
+            }
+
+            console.log('  Importing mupdf module...')
+            const mupdf: typeof import('../vendor/mupdf-wasm/mupdf.js') = await import('../vendor/mupdf-wasm/mupdf.js')
+            console.log('  mupdf module imported ok')
+
+            const fp = std.open('./example.pdf', 'rb')
+            if (!fp) { console.log('SKIP: no example.pdf'); return }
+            fp.seek(0, 2)
+            const size = fp.tell()
+            fp.seek(0, 0)
+            const pdfBuf = new ArrayBuffer(size)
+            fp.read(pdfBuf, 0, size)
+            fp.close()
+            console.log('  PDF loaded, size:', size)
+
+            t.section('Test 1: two toPixmap on same page (no destroy)')
+            try {
+                const doc = mupdf.Document.openDocument(new Uint8Array(pdfBuf), "application/pdf")
+                const page = doc.loadPage(0)
+
+                console.log('  1: toPixmap #1...')
+                const pm1 = page.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false)
+                console.log('  1: toPixmap #1 done:', pm1.getWidth(), 'x', pm1.getHeight())
+                t.check('toPixmap #1 ok', true, pm1 !== null)
+
+                console.log('  1: toPixmap #2...')
+                const pm2 = page.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false)
+                console.log('  1: toPixmap #2 done:', pm2.getWidth(), 'x', pm2.getHeight())
+                t.check('toPixmap #2 ok', true, pm2 !== null)
+            } catch (e: any) {
+                console.log('  1: ERROR:', e instanceof Error ? e.message : String(e))
+            }
+
+            t.section('Test 2: second openDocument + toPixmap (no destroy of first)')
+            try {
+                console.log('  2: openDocument #2...')
+                const doc2 = mupdf.Document.openDocument(new Uint8Array(pdfBuf), "application/pdf")
+                console.log('  2: loadPage #2...')
+                const page2 = doc2.loadPage(0)
+                console.log('  2: toPixmap #3...')
+                const pm3 = page2.toPixmap(mupdf.Matrix.scale(1, 1), mupdf.ColorSpace.DeviceRGB, false)
+                console.log('  2: toPixmap #3 done:', pm3.getWidth(), 'x', pm3.getHeight())
+                t.check('toPixmap #3 ok', true, pm3 !== null)
+            } catch (e: any) {
+                console.log('  2: ERROR:', e instanceof Error ? e.message : String(e))
+            }
+
+            console.log('All mupdf-twice tests done')
+        } catch (e: any) {
+            console.log('TOP-LEVEL ERROR:', e instanceof Error ? e.message : String(e))
+        }
+    }
+}

package/test/test_mupdf_wasm.js

@@ -0,0 +1,33 @@
+import { readWasmFile } from './test_helper.js';
+export const suite = {
+    name: 'vendor/mupdf-wasm',
+    run: (t) => {
+        t.section('validate binary');
+        const buf = readWasmFile('../vendor/mupdf-wasm/mupdf-wasm.wasm');
+        if (!buf) {
+            t.fail++;
+            return;
+        }
+        t.check('file size > 0', true, buf.byteLength > 0);
+        const header = new Uint8Array(buf);
+        t.check('magic', true, header[0] === 0x00 && header[1] === 0x61 && header[2] === 0x73 && header[3] === 0x6d);
+        t.check('version 1', true, header[4] === 0x01 && header[5] === 0x00 && header[6] === 0x00 && header[7] === 0x00);
+        t.check('WebAssembly.validate', true, WebAssembly.validate(buf));
+        t.section('Module');
+        var mod = null;
+        try {
+            mod = new WebAssembly.Module(buf);
+            t.ok++;
+        }
+        catch (e) {
+            t.fail++;
+        }
+        t.section('imports/exports');
+        if (mod) {
+            const exps = WebAssembly.Module.exports(mod);
+            t.check('exports > 0', true, exps.length > 0);
+            const imps = WebAssembly.Module.imports(mod);
+            t.check('imports', imps.length, imps.length);
+        }
+    }
+};

package/test/test_mupdf_wasm.ts

@@ -0,0 +1,30 @@
+import { Tester, readWasmFile } from './test_helper.js'
+
+export const suite = {
+    name: 'vendor/mupdf-wasm',
+    run: (t: Tester) => {
+        t.section('validate binary')
+        const buf = readWasmFile('../vendor/mupdf-wasm/mupdf-wasm.wasm')
+        if (!buf) { t.fail++; return }
+        t.check('file size > 0', true, buf.byteLength > 0)
+        const header = new Uint8Array(buf)
+        t.check('magic', true, header[0] === 0x00 && header[1] === 0x61 && header[2] === 0x73 && header[3] === 0x6d)
+        t.check('version 1', true, header[4] === 0x01 && header[5] === 0x00 && header[6] === 0x00 && header[7] === 0x00)
+        t.check('WebAssembly.validate', true, WebAssembly.validate(buf))
+
+        t.section('Module')
+        var mod: WebAssembly.Module | null = null
+        try {
+            mod = new WebAssembly.Module(buf)
+            t.ok++
+        } catch (e) { t.fail++ }
+
+        t.section('imports/exports')
+        if (mod) {
+            const exps = WebAssembly.Module.exports(mod)
+            t.check('exports > 0', true, exps.length > 0)
+            const imps = WebAssembly.Module.imports(mod)
+            t.check('imports', imps.length, imps.length)
+        }
+    }
+}

package/test/test_net_event.js

@@ -0,0 +1,63 @@
+import * as sock from "sock";
+import * as os from "os";
+export const suite = {
+    name: 'net-event',
+    run: async (t) => {
+        await new Promise((resolve, reject) => {
+            const s = sock.socket();
+            if (!s || s === 0) {
+                t.fail++;
+                reject(new Error('socket() failed'));
+                return;
+            }
+            var connected = false, gotData = false;
+            const hostIP = sock.resolve("httpbin.org");
+            if (!hostIP) {
+                t.fail++;
+                reject(new Error('dns failed'));
+                return;
+            }
+            const timeoutId = os.setTimeout(() => {
+                if (!connected) {
+                    sock.closesocket(s);
+                    reject(new Error('connect timeout'));
+                }
+            }, 10000);
+            sock.set_on_event(s, (event) => {
+                if (event.lNetworkEvents & sock.FD_CONNECT) {
+                    if (event.iErrorCode[0] === 0) {
+                        connected = true;
+                        t.ok++;
+                        os.clearTimeout(timeoutId);
+                        const req = "GET / HTTP/1.1\r\nHost: httpbin.org\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);
+                        sock.send(s, buf);
+                    }
+                    else {
+                        sock.closesocket(s);
+                        reject(new Error('connect error: ' + event.iErrorCode[0]));
+                    }
+                }
+                if (event.lNetworkEvents & sock.FD_READ && connected && !gotData) {
+                    const data = sock.recv(s, 4096);
+                    if (data && data.byteLength > 0) {
+                        gotData = true;
+                        t.ok++;
+                    }
+                }
+                if (event.lNetworkEvents & sock.FD_CLOSE) {
+                    os.clearTimeout(timeoutId);
+                    sock.closesocket(s);
+                    if (gotData && connected)
+                        resolve();
+                    else
+                        reject(new Error('test incomplete'));
+                }
+            });
+            sock.connect(s, hostIP, 80);
+        });
+    }
+};