quickwin 2026.5.2-3.145209

package/test/test_net_event.ts

@@ -0,0 +1,59 @@
+import * as sock from "sock"
+import * as std from "std"
+import * as os from "os"
+import { Tester } from './test_helper.js'
+
+interface WSAEvent {
+    lNetworkEvents: number;
+    iErrorCode: number[];
+}
+
+export const suite = {
+    name: 'net-event',
+    run: async (t: Tester): Promise<void> => {
+        await new Promise<void>((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: WSAEvent) => {
+                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)
+        })
+    }
+}

package/test/test_net_fetch.js

@@ -0,0 +1,153 @@
+import '../lib/fetch.js';
+import * as std from 'std';
+export const suite = {
+    name: 'net-fetch',
+    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);
+            }
+        }
+        async function safeFetch(url, init) {
+            try {
+                return await fetch(url, init);
+            }
+            catch {
+                return null;
+            }
+        }
+        // ── Basic HTTP GET ──
+        t.section('HTTP GET');
+        const r1 = await safeFetch('https://httpbin.org/anything');
+        if (r1) {
+            assert('status received', r1.status > 0);
+            const body = await r1.text();
+            assert('body received', body.length > 0);
+        }
+        else {
+            assert('httpbin.org reachable', false);
+        }
+        // ── body / bodyUsed / stream ──
+        t.section('body / bodyUsed / stream');
+        const r2 = await safeFetch('https://httpbin.org/anything');
+        if (r2) {
+            assert('r.body exists', typeof r2.body === 'object' && r2.body !== null);
+            assert('bodyUsed false before read', r2.bodyUsed === false);
+            const reader = r2.body.getReader();
+            let total = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                total += value.length;
+            }
+            assert('reader streams all bytes', total > 0);
+            assert('bodyUsed true after stream', r2.bodyUsed === true);
+        }
+        else {
+            assert('body test endpoint reachable', false);
+        }
+        // ── text/json/arrayBuffer ──
+        t.section('text / json / arrayBuffer');
+        const r3 = await safeFetch('https://httpbin.org/anything');
+        if (r3) {
+            const text = await r3.text();
+            assert('text() returns string', typeof text === 'string' && text.length > 0);
+            assert('bodyUsed true after text()', r3.bodyUsed === true);
+            const r4 = await safeFetch('https://httpbin.org/anything');
+            if (r4) {
+                const buf = await r4.arrayBuffer();
+                assert('arrayBuffer() returns bytes', buf.byteLength > 0);
+            }
+        }
+        else {
+            assert('text/json/ab endpoint reachable', false);
+        }
+        // double text() throws
+        t.section('bodyUsed throws');
+        const r5 = await safeFetch('https://httpbin.org/anything');
+        if (r5) {
+            await r5.text();
+            try {
+                await r5.text();
+                assert('double text() throws', false);
+            }
+            catch (e) {
+                assert('double text() throws TypeError', e.message === 'Body already used');
+            }
+        }
+        // ── POST ──
+        t.section('POST');
+        const r6 = await safeFetch('https://httpbin.org/anything', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ msg: 'hello' })
+        });
+        if (r6) {
+            const body = await r6.text();
+            assert('POST body received', body.length > 0);
+        }
+        else {
+            assert('POST endpoint reachable', false);
+        }
+        // ── Headers (local, no network) ──
+        t.section('Headers (local)');
+        const h = new Headers({ 'Content-Type': 'text/html', 'X-Custom': 'hello', 'Accept': '*/*' });
+        let c = 0;
+        for (const [k, v] of h) {
+            c++;
+            if (typeof k !== 'string' || typeof v !== 'string')
+                assert('for...of type', false);
+        }
+        assert('for...of yields entries', c === 3);
+        assert('get()', h.get('content-type') === 'text/html');
+        assert('get() case-insensitive', h.get('Content-Type') === 'text/html');
+        assert('has()', h.has('x-custom'));
+        assert('set() overwrites', (h.set('accept', 'application/json'), h.get('accept') === 'application/json'));
+        assert('append() adds', (h.append('accept', 'text/plain'), h.get('accept') === 'application/json, text/plain'));
+        assert('delete()', (h.delete('accept'), h.has('accept') === false));
+        const h2 = new Headers({ 'a': '1', 'b': '2' });
+        let ec = 0;
+        for (const _ of h2.entries()) {
+            ec++;
+        }
+        assert('entries()', ec === 2);
+        let kc = 0;
+        for (const _ of h2.keys()) {
+            kc++;
+        }
+        assert('keys()', kc === 2);
+        let vc = 0;
+        for (const _ of h2.values()) {
+            vc++;
+        }
+        assert('values()', vc === 2);
+        // ── stream cancel ──
+        t.section('stream cancel');
+        const r7 = await safeFetch('https://httpbin.org/anything');
+        if (r7) {
+            r7.body.cancel();
+            assert('cancel() succeeds', true);
+            // After cancel: buffered chunks still readable, then done
+            const reader = r7.body.getReader();
+            // After cancel: buffered chunks still readable, then done
+            let finalDone = false;
+            while (true) {
+                const { done } = await reader.read();
+                if (done) {
+                    finalDone = true;
+                    break;
+                }
+            }
+            assert('reader done after cancel', finalDone === true);
+        }
+        else {
+            assert('cancel test endpoint reachable', false);
+        }
+    }
+};

package/test/test_net_fetch.ts

@@ -0,0 +1,131 @@
+import '../lib/fetch.js'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+export const suite = {
+    name: 'net-fetch',
+    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) }
+        }
+
+        async function safeFetch(url: string, init?: RequestInit) {
+            try {
+                return await fetch(url, init);
+            } catch {
+                return null;
+            }
+        }
+        // ── Basic HTTP GET ──
+        t.section('HTTP GET')
+        const r1 = await safeFetch('https://httpbin.org/anything')
+        if (r1) {
+            assert('status received', r1.status > 0)
+            const body = await r1.text()
+            assert('body received', body.length > 0)
+        } else {
+            assert('httpbin.org reachable', false)
+        }
+
+        // ── body / bodyUsed / stream ──
+        t.section('body / bodyUsed / stream')
+        const r2 = await safeFetch('https://httpbin.org/anything')
+        if (r2) {
+            assert('r.body exists', typeof r2.body === 'object' && r2.body !== null)
+            assert('bodyUsed false before read', r2.bodyUsed === false)
+
+            const reader = r2.body.getReader()
+            let total = 0
+            while (true) {
+                const { done, value } = await reader.read()
+                if (done) break
+                total += value.length
+            }
+            assert('reader streams all bytes', total > 0)
+            assert('bodyUsed true after stream', r2.bodyUsed === true)
+        } else {
+            assert('body test endpoint reachable', false)
+        }
+
+        // ── text/json/arrayBuffer ──
+        t.section('text / json / arrayBuffer')
+        const r3 = await safeFetch('https://httpbin.org/anything')
+        if (r3) {
+            const text = await r3.text()
+            assert('text() returns string', typeof text === 'string' && text.length > 0)
+            assert('bodyUsed true after text()', r3.bodyUsed === true)
+
+            const r4 = await safeFetch('https://httpbin.org/anything')
+            if (r4) {
+                const buf = await r4.arrayBuffer()
+                assert('arrayBuffer() returns bytes', buf.byteLength > 0)
+            }
+        } else {
+            assert('text/json/ab endpoint reachable', false)
+        }
+
+        // double text() throws
+        t.section('bodyUsed throws')
+        const r5 = await safeFetch('https://httpbin.org/anything')
+        if (r5) {
+            await r5.text()
+            try { await r5.text(); assert('double text() throws', false) }
+            catch (e: unknown) { assert('double text() throws TypeError', (e as Error).message === 'Body already used') }
+        }
+
+        // ── POST ──
+        t.section('POST')
+        const r6 = await safeFetch('https://httpbin.org/anything', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ msg: 'hello' })
+        })
+        if (r6) {
+            const body = await r6.text()
+            assert('POST body received', body.length > 0)
+        } else {
+            assert('POST endpoint reachable', false)
+        }
+
+        // ── Headers (local, no network) ──
+        t.section('Headers (local)')
+        const h = new Headers({ 'Content-Type': 'text/html', 'X-Custom': 'hello', 'Accept': '*/*' })
+        let c = 0
+        for (const [k, v] of h) { c++; if (typeof k !== 'string' || typeof v !== 'string') assert('for...of type', false) }
+        assert('for...of yields entries', c === 3)
+        assert('get()', h.get('content-type') === 'text/html')
+        assert('get() case-insensitive', h.get('Content-Type') === 'text/html')
+        assert('has()', h.has('x-custom'))
+        assert('set() overwrites', (h.set('accept', 'application/json'), h.get('accept') === 'application/json'))
+        assert('append() adds', (h.append('accept', 'text/plain'), h.get('accept') === 'application/json, text/plain'))
+        assert('delete()', (h.delete('accept'), h.has('accept') === false))
+
+        const h2 = new Headers({ 'a': '1', 'b': '2' })
+        let ec = 0; for (const _ of h2.entries()) { ec++ }
+        assert('entries()', ec === 2)
+        let kc = 0; for (const _ of h2.keys()) { kc++ }
+        assert('keys()', kc === 2)
+        let vc = 0; for (const _ of h2.values()) { vc++ }
+        assert('values()', vc === 2)
+
+        // ── stream cancel ──
+        t.section('stream cancel')
+        const r7 = await safeFetch('https://httpbin.org/anything')
+        if (r7) {
+            r7.body.cancel()
+            assert('cancel() succeeds', true)
+            // After cancel: buffered chunks still readable, then done
+            const reader = r7.body.getReader()
+            // After cancel: buffered chunks still readable, then done
+            let finalDone = false
+            while (true) {
+                const { done } = await reader.read()
+                if (done) { finalDone = true; break }
+            }
+            assert('reader done after cancel', finalDone === true)
+        } else {
+            assert('cancel test endpoint reachable', false)
+        }
+    }
+}

package/test/test_net_websocket.js

@@ -0,0 +1,158 @@
+import '../lib/websocket.js';
+import * as std from 'std';
+import * as os from 'os';
+export const suite = {
+    name: 'net-websocket',
+    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);
+            }
+        }
+        let testId = 0;
+        const resolvers = {};
+        function waitForTest() {
+            const id = ++testId;
+            const promise = new Promise((resolve) => { resolvers[id] = resolve; });
+            return { promise, id };
+        }
+        function finishTest(id) {
+            const r = resolvers[id];
+            if (r) {
+                delete resolvers[id];
+                r();
+            }
+        }
+        // ── wss basic ──
+        t.section('wss basic text message');
+        const p1 = waitForTest();
+        let opened = false, received = false, closed = false;
+        const ws1 = new WebSocket("wss://ws.postman-echo.com/raw");
+        ws1.onopen = () => { opened = true; ws1.send("Hello WebSocket!"); };
+        ws1.onmessage = () => { received = true; ws1.close(1000, "done"); };
+        ws1.onclose = (e) => {
+            closed = true;
+            assert('onopen fired', opened);
+            assert('onmessage received', received);
+            assert('close code=1000', e.code === 1000);
+            assert('wasClean', e.wasClean);
+            finishTest(p1.id);
+        };
+        ws1.onerror = () => { assert('no error', false); finishTest(p1.id); };
+        const timer1 = os.setTimeout(() => { if (!closed) {
+            assert('no timeout', false);
+            finishTest(p1.id);
+        } }, 10000);
+        await p1.promise;
+        os.clearTimeout(timer1);
+        // ── binary send ──
+        t.section('binary message (ArrayBuffer)');
+        const pBin = waitForTest();
+        const wsBin = new WebSocket("wss://ws.postman-echo.com/raw");
+        let binClose = false;
+        wsBin.onopen = () => {
+            const buf = new ArrayBuffer(5);
+            const v = new Uint8Array(buf);
+            v[0] = 0x48;
+            v[1] = 0x65;
+            v[2] = 0x6C;
+            v[3] = 0x6C;
+            v[4] = 0x6F;
+            wsBin.send(buf);
+            wsBin.send("binary-send-check");
+        };
+        let binMsgCount = 0;
+        wsBin.onmessage = () => { binMsgCount++; if (binMsgCount >= 2)
+            wsBin.close(1000, "done"); };
+        wsBin.onclose = () => { binClose = true; assert('binary send completed', true); finishTest(pBin.id); };
+        wsBin.onerror = () => { assert('no error', false); finishTest(pBin.id); };
+        const timerBin = os.setTimeout(() => { if (!binClose)
+            assert('binary no crash (timeout)', true); finishTest(pBin.id); }, 10000);
+        await pBin.promise;
+        os.clearTimeout(timerBin);
+        // ── extended length frame ──
+        t.section('extended length frame (>65535 bytes)');
+        const pExt = waitForTest();
+        const wsExt = new WebSocket("wss://ws.postman-echo.com/raw");
+        let extClose = false;
+        wsExt.onopen = () => { wsExt.send("X".repeat(66000)); };
+        wsExt.onmessage = () => { wsExt.close(1000, "done"); };
+        wsExt.onclose = () => { extClose = true; assert('extended frame sent', true); finishTest(pExt.id); };
+        wsExt.onerror = () => { assert('no error', false); finishTest(pExt.id); };
+        const timerExt = os.setTimeout(() => { if (!extClose)
+            assert('extended frame timeout (server may drop)', true); finishTest(pExt.id); }, 60000);
+        await pExt.promise;
+        os.clearTimeout(timerExt);
+        // ── large message ──
+        t.section('large message (>125 bytes)');
+        const p2 = waitForTest();
+        const ws2 = new WebSocket("wss://ws.postman-echo.com/raw");
+        let largeOk = false, closed2 = false;
+        const largeStr = "A".repeat(1000);
+        ws2.onopen = () => { ws2.send(largeStr); };
+        ws2.onmessage = (e) => { largeOk = e.data.length === 1000; ws2.close(1000, "done"); };
+        ws2.onclose = () => { closed2 = true; assert('large msg echo 1000 bytes', largeOk); finishTest(p2.id); };
+        ws2.onerror = () => { assert('no error', false); finishTest(p2.id); };
+        const timer2 = os.setTimeout(() => { if (!closed2) {
+            assert('large msg no timeout', false);
+            finishTest(p2.id);
+        } }, 15000);
+        await p2.promise;
+        os.clearTimeout(timer2);
+        // ── multiple messages ──
+        t.section('multiple messages');
+        const p3 = waitForTest();
+        const ws3 = new WebSocket("wss://ws.postman-echo.com/raw");
+        let count = 0, closed3 = false;
+        ws3.onopen = () => { ws3.send("a"); ws3.send("b"); ws3.send("c"); };
+        ws3.onmessage = () => { count++; if (count === 3)
+            ws3.close(1000, "done"); };
+        ws3.onclose = () => { closed3 = true; assert('received 3 messages', count === 3); finishTest(p3.id); };
+        ws3.onerror = () => { assert('no error', false); finishTest(p3.id); };
+        const timer3 = os.setTimeout(() => { if (!closed3) {
+            assert('no timeout', false);
+            finishTest(p3.id);
+        } }, 15000);
+        await p3.promise;
+        os.clearTimeout(timer3);
+        // ── invalid URL ──
+        t.section('invalid URL');
+        const p4 = waitForTest();
+        const ws4 = new WebSocket("not-a-websocket");
+        let err4 = false;
+        ws4.onerror = () => { err4 = true; };
+        ws4.onclose = () => { assert('onerror fired', err4); finishTest(p4.id); };
+        const timer4 = os.setTimeout(() => { assert('invalid url error', err4); finishTest(p4.id); }, 3000);
+        await p4.promise;
+        os.clearTimeout(timer4);
+        // ── invalid scheme ──
+        t.section('invalid scheme (http://)');
+        const p5 = waitForTest();
+        const ws5 = new WebSocket("http://example.com/ws");
+        let err5 = false;
+        ws5.onerror = () => { err5 = true; };
+        ws5.onclose = () => { assert('http scheme onerror', err5); finishTest(p5.id); };
+        const timer5 = os.setTimeout(() => { assert('http scheme error guard', err5); finishTest(p5.id); }, 3000);
+        await p5.promise;
+        os.clearTimeout(timer5);
+        // ── early send/close ──
+        t.section('send/close before onopen');
+        const p6 = waitForTest();
+        const ws6 = new WebSocket("wss://ws.postman-echo.com/raw");
+        ws6.send("noop");
+        ws6.close(1000, "early");
+        let close6 = false;
+        ws6.onopen = () => { assert('onopen after early close', false); };
+        ws6.onclose = () => { close6 = true; assert('early close ok', true); finishTest(p6.id); };
+        ws6.onerror = () => { };
+        const timer6 = os.setTimeout(() => { if (!close6)
+            assert('no crash', true); finishTest(p6.id); }, 5000);
+        await p6.promise;
+        os.clearTimeout(timer6);
+    }
+};

package/test/test_net_websocket.ts

@@ -0,0 +1,144 @@
+import '../lib/websocket.js'
+import * as std from 'std'
+import * as os from 'os'
+import { Tester } from './test_helper.js'
+
+export const suite = {
+    name: 'net-websocket',
+    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) }
+        }
+
+        let testId = 0
+        const resolvers: Record<number, () => void> = {}
+
+        function waitForTest(): { promise: Promise<void>; id: number } {
+            const id = ++testId
+            const promise = new Promise<void>((resolve) => { resolvers[id] = resolve })
+            return { promise, id }
+        }
+
+        function finishTest(id: number) {
+            const r = resolvers[id]
+            if (r) { delete resolvers[id]; r() }
+        }
+
+        // ── wss basic ──
+        t.section('wss basic text message')
+        const p1 = waitForTest()
+        let opened = false, received = false, closed = false
+        const ws1 = new WebSocket("wss://ws.postman-echo.com/raw")
+        ws1.onopen = () => { opened = true; ws1.send("Hello WebSocket!") }
+        ws1.onmessage = () => { received = true; ws1.close(1000, "done") }
+        ws1.onclose = (e) => {
+            closed = true
+            assert('onopen fired', opened)
+            assert('onmessage received', received)
+            assert('close code=1000', e.code === 1000)
+            assert('wasClean', e.wasClean)
+            finishTest(p1.id)
+        }
+        ws1.onerror = () => { assert('no error', false); finishTest(p1.id) }
+        const timer1 = os.setTimeout(() => { if (!closed) { assert('no timeout', false); finishTest(p1.id) } }, 10000)
+        await p1.promise
+        os.clearTimeout(timer1)
+
+        // ── binary send ──
+        t.section('binary message (ArrayBuffer)')
+        const pBin = waitForTest()
+        const wsBin = new WebSocket("wss://ws.postman-echo.com/raw")
+        let binClose = false
+        wsBin.onopen = () => {
+            const buf = new ArrayBuffer(5)
+            const v = new Uint8Array(buf)
+            v[0] = 0x48; v[1] = 0x65; v[2] = 0x6C; v[3] = 0x6C; v[4] = 0x6F
+            wsBin.send(buf)
+            wsBin.send("binary-send-check")
+        }
+        let binMsgCount = 0
+        wsBin.onmessage = () => { binMsgCount++; if (binMsgCount >= 2) wsBin.close(1000, "done") }
+        wsBin.onclose = () => { binClose = true; assert('binary send completed', true); finishTest(pBin.id) }
+        wsBin.onerror = () => { assert('no error', false); finishTest(pBin.id) }
+        const timerBin = os.setTimeout(() => { if (!binClose) assert('binary no crash (timeout)', true); finishTest(pBin.id) }, 10000)
+        await pBin.promise
+        os.clearTimeout(timerBin)
+
+        // ── extended length frame ──
+        t.section('extended length frame (>65535 bytes)')
+        const pExt = waitForTest()
+        const wsExt = new WebSocket("wss://ws.postman-echo.com/raw")
+        let extClose = false
+        wsExt.onopen = () => { wsExt.send("X".repeat(66000)) }
+        wsExt.onmessage = () => { wsExt.close(1000, "done") }
+        wsExt.onclose = () => { extClose = true; assert('extended frame sent', true); finishTest(pExt.id) }
+        wsExt.onerror = () => { assert('no error', false); finishTest(pExt.id) }
+        const timerExt = os.setTimeout(() => { if (!extClose) assert('extended frame timeout (server may drop)', true); finishTest(pExt.id) }, 60000)
+        await pExt.promise
+        os.clearTimeout(timerExt)
+
+        // ── large message ──
+        t.section('large message (>125 bytes)')
+        const p2 = waitForTest()
+        const ws2 = new WebSocket("wss://ws.postman-echo.com/raw")
+        let largeOk = false, closed2 = false
+        const largeStr = "A".repeat(1000)
+        ws2.onopen = () => { ws2.send(largeStr) }
+        ws2.onmessage = (e) => { largeOk = e.data.length === 1000; ws2.close(1000, "done") }
+        ws2.onclose = () => { closed2 = true; assert('large msg echo 1000 bytes', largeOk); finishTest(p2.id) }
+        ws2.onerror = () => { assert('no error', false); finishTest(p2.id) }
+        const timer2 = os.setTimeout(() => { if (!closed2) { assert('large msg no timeout', false); finishTest(p2.id) } }, 15000)
+        await p2.promise
+        os.clearTimeout(timer2)
+
+        // ── multiple messages ──
+        t.section('multiple messages')
+        const p3 = waitForTest()
+        const ws3 = new WebSocket("wss://ws.postman-echo.com/raw")
+        let count = 0, closed3 = false
+        ws3.onopen = () => { ws3.send("a"); ws3.send("b"); ws3.send("c") }
+        ws3.onmessage = () => { count++; if (count === 3) ws3.close(1000, "done") }
+        ws3.onclose = () => { closed3 = true; assert('received 3 messages', count === 3); finishTest(p3.id) }
+        ws3.onerror = () => { assert('no error', false); finishTest(p3.id) }
+        const timer3 = os.setTimeout(() => { if (!closed3) { assert('no timeout', false); finishTest(p3.id) } }, 15000)
+        await p3.promise
+        os.clearTimeout(timer3)
+
+        // ── invalid URL ──
+        t.section('invalid URL')
+        const p4 = waitForTest()
+        const ws4 = new WebSocket("not-a-websocket")
+        let err4 = false
+        ws4.onerror = () => { err4 = true }
+        ws4.onclose = () => { assert('onerror fired', err4); finishTest(p4.id) }
+        const timer4 = os.setTimeout(() => { assert('invalid url error', err4); finishTest(p4.id) }, 3000)
+        await p4.promise
+        os.clearTimeout(timer4)
+
+        // ── invalid scheme ──
+        t.section('invalid scheme (http://)')
+        const p5 = waitForTest()
+        const ws5 = new WebSocket("http://example.com/ws")
+        let err5 = false
+        ws5.onerror = () => { err5 = true }
+        ws5.onclose = () => { assert('http scheme onerror', err5); finishTest(p5.id) }
+        const timer5 = os.setTimeout(() => { assert('http scheme error guard', err5); finishTest(p5.id) }, 3000)
+        await p5.promise
+        os.clearTimeout(timer5)
+
+        // ── early send/close ──
+        t.section('send/close before onopen')
+        const p6 = waitForTest()
+        const ws6 = new WebSocket("wss://ws.postman-echo.com/raw")
+        ws6.send("noop")
+        ws6.close(1000, "early")
+        let close6 = false
+        ws6.onopen = () => { assert('onopen after early close', false) }
+        ws6.onclose = () => { close6 = true; assert('early close ok', true); finishTest(p6.id) }
+        ws6.onerror = () => {}
+        const timer6 = os.setTimeout(() => { if (!close6) assert('no crash', true); finishTest(p6.id) }, 5000)
+        await p6.promise
+        os.clearTimeout(timer6)
+    }
+}