quickwin 1.0.0

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'
+import { parseIni } from '../lib/cache-utils.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)
+        }
+
+        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 ini = parseIni(metaStr)
+                        std.printf('    storedAt: %s, maxAge: %s\n', ini.meta.storedAt || '?', ini.meta.maxAge || '?')
+                    }
+                }
+            }
+        }
+    }
+}

package/test/test_http_server.js

@@ -0,0 +1,142 @@
+import './test_helper.js';
+import * as std from 'std';
+import * as os from 'os';
+import * as sock from 'sock';
+import { createServer } from '../lib/http-server.js';
+// ── Minimal raw HTTP client for testing ──
+function httpSend(host, port, raw, nResponses = 1) {
+    return new Promise((resolve, reject) => {
+        const s = sock.socket();
+        if (s < 0) {
+            reject(new Error('socket create failed'));
+            return;
+        }
+        let buf = '';
+        let done = false;
+        const timer = os.setTimeout(() => {
+            if (!done) {
+                done = true;
+                sock.closesocket(s);
+                reject(new Error('timeout: ' + buf));
+            }
+        }, 10000);
+        sock.set_on_event(s, (event) => {
+            if (done)
+                return;
+            if (event.lNetworkEvents & 16 /* sock.FdEvent.FD_CONNECT */) {
+                const err = event.iErrorCode[0];
+                if (err !== 0) {
+                    done = true;
+                    os.clearTimeout(timer);
+                    sock.closesocket(s);
+                    reject(new Error('connect error ' + err));
+                    return;
+                }
+                const bytes = new TextEncoder().encode(raw);
+                sock.send(s, bytes.buffer);
+            }
+            if (event.lNetworkEvents & 1 /* sock.FdEvent.FD_READ */) {
+                while (true) {
+                    const d = sock.recv(s, 8192);
+                    if (typeof d === 'number')
+                        break;
+                    if (!d || d.byteLength === 0)
+                        break;
+                    buf += new TextDecoder().decode(new Uint8Array(d));
+                }
+                const count = (buf.match(/HTTP\/1\.1 /g) || []).length;
+                if (count >= nResponses) {
+                    done = true;
+                    os.clearTimeout(timer);
+                    sock.closesocket(s);
+                    resolve(buf);
+                }
+            }
+            if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+                if (!done) {
+                    done = true;
+                    os.clearTimeout(timer);
+                    sock.closesocket(s);
+                    resolve(buf);
+                }
+            }
+        });
+        sock.connect(s, host, port);
+    });
+}
+// ── Test suite ──
+export const suite = {
+    name: 'http-server',
+    run: async (t) => {
+        const requests = [];
+        const server = createServer(async (req) => {
+            const url = new URL(req.url);
+            const path = url.pathname;
+            requests.push(req.method + ' ' + path);
+            if (path === '/') {
+                return new Response('hello ' + (url.searchParams.get('name') || ''), { headers: { 'Content-Type': 'text/plain' } });
+            }
+            else if (path === '/echo') {
+                return new Response(req.method + ':' + await req.text(), { headers: { 'Content-Type': 'text/plain' } });
+            }
+            else if (path === '/json') {
+                return new Response(JSON.stringify({ method: req.method, q: Object.fromEntries(url.searchParams) }), { headers: { 'Content-Type': 'application/json' } });
+            }
+            else {
+                return new Response('not found', { status: 404 });
+            }
+        });
+        const rc = server.listen(0, '127.0.0.1');
+        t.checkTrue('listen ok', rc === 0);
+        const addr = server.address();
+        if (!addr) {
+            t.check('address', 'non-null', 'null');
+            return;
+        }
+        t.checkTrue('bound port > 0', addr.port > 0);
+        const port = addr.port;
+        // ── GET with query ──
+        t.section('GET with query');
+        let r = await httpSend('127.0.0.1', port, 'GET /?name=world HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
+        t.checkTrue('200 status', r.indexOf('HTTP/1.1 200') === 0);
+        t.checkTrue('body = hello world', r.endsWith('hello world'));
+        t.checkTrue('content-type text', r.toLowerCase().indexOf('content-type: text/plain') >= 0);
+        // ── POST with body ──
+        t.section('POST with body');
+        r = await httpSend('127.0.0.1', port, 'POST /echo HTTP/1.1\r\nHost: x\r\nContent-Length: 7\r\nConnection: close\r\n\r\npayload');
+        t.checkTrue('echo body', r.endsWith('POST:payload'));
+        // ── POST with chunked request body ──
+        t.section('chunked request body');
+        const chunkedRaw = 'POST /echo HTTP/1.1\r\nHost: x\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n' +
+            '3\r\nabc\r\n4\r\ndefg\r\n0\r\n\r\n';
+        r = await httpSend('127.0.0.1', port, chunkedRaw);
+        t.checkTrue('chunked decoded', r.endsWith('POST:abcdefg'));
+        // ── 404 ──
+        t.section('404');
+        r = await httpSend('127.0.0.1', port, 'GET /missing HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
+        t.checkTrue('404 status', r.indexOf('HTTP/1.1 404') === 0);
+        t.checkTrue('404 body', r.endsWith('not found'));
+        // ── HEAD (headers present, empty body) ──
+        t.section('HEAD');
+        r = await httpSend('127.0.0.1', port, 'HEAD / HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
+        t.checkTrue('HEAD 200', r.indexOf('HTTP/1.1 200') === 0);
+        t.checkTrue('HEAD content-length present', r.toLowerCase().indexOf('content-length: 6') >= 0);
+        const bodyIdx = r.indexOf('\r\n\r\n');
+        t.checkTrue('HEAD empty body', r.slice(bodyIdx + 4).length === 0);
+        // ── keep-alive: two requests on one connection ──
+        t.section('keep-alive pipelining');
+        const pipelined = 'GET /?name=a HTTP/1.1\r\nHost: x\r\n\r\n' +
+            'GET /?name=b HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n';
+        r = await httpSend('127.0.0.1', port, pipelined, 2);
+        t.checkTrue('two responses received', r.indexOf('hello a') >= 0 && r.indexOf('hello b') >= 0);
+        t.checkTrue('connection close on last', r.toLowerCase().indexOf('connection: close') >= 0);
+        // ── server received expected requests ──
+        t.section('request log');
+        t.check('total requests', 7, requests.length);
+        t.checkTrue('saw GET /', requests.indexOf('GET /') >= 0);
+        t.checkTrue('saw POST /echo', requests.indexOf('POST /echo') >= 0);
+        server.close();
+        t.check('closed ok', true, true);
+        std.printf('  (http-server suite done, %d requests)\n', requests.length);
+    },
+};

package/test/test_http_server.ts

@@ -0,0 +1,136 @@
+import './test_helper.js'
+import * as std from 'std'
+import * as os from 'os'
+import * as sock from 'sock'
+import { Tester } from './test_helper.js'
+import { createServer } from '../lib/http-server.js'
+
+// ── Minimal raw HTTP client for testing ──
+
+function httpSend(host: string, port: number, raw: string, nResponses = 1): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const s = sock.socket()
+        if (s < 0) { reject(new Error('socket create failed')); return }
+        let buf = ''
+        let done = false
+        const timer = os.setTimeout(() => {
+            if (!done) { done = true; sock.closesocket(s); reject(new Error('timeout: ' + buf)) }
+        }, 10000)
+        sock.set_on_event(s, (event) => {
+            if (done) return
+            if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                const err = event.iErrorCode[0]
+                if (err !== 0) {
+                    done = true
+                    os.clearTimeout(timer)
+                    sock.closesocket(s)
+                    reject(new Error('connect error ' + err))
+                    return
+                }
+                const bytes = new TextEncoder().encode(raw)
+                sock.send(s, bytes.buffer)
+            }
+            if (event.lNetworkEvents & sock.FdEvent.FD_READ) {
+                while (true) {
+                    const d = sock.recv(s, 8192) as unknown as ArrayBuffer | number
+                    if (typeof d === 'number') break
+                    if (!d || d.byteLength === 0) break
+                    buf += new TextDecoder().decode(new Uint8Array(d))
+                }
+                const count = (buf.match(/HTTP\/1\.1 /g) || []).length
+                if (count >= nResponses) {
+                    done = true
+                    os.clearTimeout(timer)
+                    sock.closesocket(s)
+                    resolve(buf)
+                }
+            }
+            if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                if (!done) { done = true; os.clearTimeout(timer); sock.closesocket(s); resolve(buf) }
+            }
+        })
+        sock.connect(s, host, port)
+    })
+}
+
+// ── Test suite ──
+
+export const suite = {
+    name: 'http-server',
+    run: async (t: Tester) => {
+        const requests: string[] = []
+        const server = createServer(async (req) => {
+            const url = new URL(req.url)
+            const path = url.pathname
+            requests.push(req.method + ' ' + path)
+            if (path === '/') {
+                return new Response('hello ' + (url.searchParams.get('name') || ''), { headers: { 'Content-Type': 'text/plain' } })
+            } else if (path === '/echo') {
+                return new Response(req.method + ':' + await req.text(), { headers: { 'Content-Type': 'text/plain' } })
+            } else if (path === '/json') {
+                return new Response(JSON.stringify({ method: req.method, q: Object.fromEntries(url.searchParams) }), { headers: { 'Content-Type': 'application/json' } })
+            } else {
+                return new Response('not found', { status: 404 })
+            }
+        })
+
+        const rc = server.listen(0, '127.0.0.1')
+        t.checkTrue('listen ok', rc === 0)
+        const addr = server.address()
+        if (!addr) { t.check('address', 'non-null', 'null'); return }
+        t.checkTrue('bound port > 0', addr.port > 0)
+        const port = addr.port
+
+        // ── GET with query ──
+        t.section('GET with query')
+        let r = await httpSend('127.0.0.1', port, 'GET /?name=world HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n')
+        t.checkTrue('200 status', r.indexOf('HTTP/1.1 200') === 0)
+        t.checkTrue('body = hello world', r.endsWith('hello world'))
+        t.checkTrue('content-type text', r.toLowerCase().indexOf('content-type: text/plain') >= 0)
+
+        // ── POST with body ──
+        t.section('POST with body')
+        r = await httpSend('127.0.0.1', port, 'POST /echo HTTP/1.1\r\nHost: x\r\nContent-Length: 7\r\nConnection: close\r\n\r\npayload')
+        t.checkTrue('echo body', r.endsWith('POST:payload'))
+
+        // ── POST with chunked request body ──
+        t.section('chunked request body')
+        const chunkedRaw = 'POST /echo HTTP/1.1\r\nHost: x\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n' +
+            '3\r\nabc\r\n4\r\ndefg\r\n0\r\n\r\n'
+        r = await httpSend('127.0.0.1', port, chunkedRaw)
+        t.checkTrue('chunked decoded', r.endsWith('POST:abcdefg'))
+
+        // ── 404 ──
+        t.section('404')
+        r = await httpSend('127.0.0.1', port, 'GET /missing HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n')
+        t.checkTrue('404 status', r.indexOf('HTTP/1.1 404') === 0)
+        t.checkTrue('404 body', r.endsWith('not found'))
+
+        // ── HEAD (headers present, empty body) ──
+        t.section('HEAD')
+        r = await httpSend('127.0.0.1', port, 'HEAD / HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n')
+        t.checkTrue('HEAD 200', r.indexOf('HTTP/1.1 200') === 0)
+        t.checkTrue('HEAD content-length present', r.toLowerCase().indexOf('content-length: 6') >= 0)
+        const bodyIdx = r.indexOf('\r\n\r\n')
+        t.checkTrue('HEAD empty body', r.slice(bodyIdx + 4).length === 0)
+
+        // ── keep-alive: two requests on one connection ──
+        t.section('keep-alive pipelining')
+        const pipelined = 'GET /?name=a HTTP/1.1\r\nHost: x\r\n\r\n' +
+            'GET /?name=b HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n'
+        r = await httpSend('127.0.0.1', port, pipelined, 2)
+        t.checkTrue('two responses received', r.indexOf('hello a') >= 0 && r.indexOf('hello b') >= 0)
+        t.checkTrue('connection close on last', r.toLowerCase().indexOf('connection: close') >= 0)
+
+        // ── server received expected requests ──
+        t.section('request log')
+        t.check('total requests', 7, requests.length)
+        t.checkTrue('saw GET /', requests.indexOf('GET /') >= 0)
+        t.checkTrue('saw POST /echo', requests.indexOf('POST /echo') >= 0)
+
+        server.close()
+        t.check('closed ok', true, true)
+
+        std.printf('  (http-server suite done, %d requests)\n', requests.length)
+    },
+}

package/test/test_import_dir.js

@@ -0,0 +1,4 @@
+import '../lib/fetch.js';
+import * as os from 'os';
+const parent = os.Worker.parent;
+parent.postMessage({ type: 'loaded' });

package/test/test_import_dir.ts

@@ -0,0 +1,5 @@
+import '../lib/fetch.js'
+import * as os from 'os'
+
+const parent = os.Worker.parent
+parent.postMessage({ type: 'loaded' })

package/test/test_ipv6.js

@@ -0,0 +1,134 @@
+import * as sock from 'sock';
+import * as std from 'std';
+import * as os from 'os';
+import '../lib/fetch.js';
+import '../lib/websocket.js';
+const HTTP_PORT = 18923;
+const HTTPS_PORT = 18924;
+export const suite = {
+    name: 'ipv6',
+    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);
+            }
+        }
+        // ── 1. sock.resolve ──
+        t.section('sock.resolve ::1');
+        {
+            const ip = sock.resolve('::1');
+            assert('resolve ::1 returns ::1', ip === '::1');
+        }
+        // ── 2. Raw socket IPv6 ──
+        t.section('raw socket ::1 HTTP GET');
+        await new Promise((resolve, reject) => {
+            const s = sock.socket();
+            if (s === null || s < 0) {
+                t.fail++;
+                reject(new Error('socket() failed'));
+                return;
+            }
+            let connected = false, gotData = false;
+            sock.set_on_event(s, (event) => {
+                if (event.lNetworkEvents & 16 /* sock.FdEvent.FD_CONNECT */) {
+                    if (event.iErrorCode[0] === 0) {
+                        connected = true;
+                        t.ok++;
+                        const req = "GET / HTTP/1.1\r\nHost: localhost\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 & 1 /* sock.FdEvent.FD_READ */ && connected && !gotData) {
+                    const data = sock.recv(s, 4096);
+                    if (data && data.byteLength > 0) {
+                        gotData = true;
+                        t.ok++;
+                    }
+                }
+                if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+                    sock.closesocket(s);
+                    if (gotData && connected)
+                        resolve();
+                    else
+                        reject(new Error('test incomplete'));
+                }
+            });
+            sock.connect(s, '::1', HTTP_PORT);
+        });
+        // ── 3. fetch HTTP IPv6 ──
+        t.section('fetch http://[::1]');
+        {
+            const r = await fetch(`http://[::1]:${HTTP_PORT}/`, { timeout: 5000 });
+            assert('fetch IPv6 HTTP status 200', r.status === 200);
+            const body = await r.text();
+            assert('fetch IPv6 HTTP body', body === 'hello from test server');
+        }
+        // ── 4. fetch HTTPS IPv6 ──
+        t.section('fetch https://[::1]');
+        {
+            const r = await fetch(`https://[::1]:${HTTPS_PORT}/`, { timeout: 5000 });
+            assert('fetch IPv6 HTTPS status 200', r.status === 200);
+            const body = await r.text();
+            assert('fetch IPv6 HTTPS body', body === 'hello from test server');
+        }
+        // ── 5. WebSocket IPv6 ──
+        t.section('ws://[::1] echo');
+        await new Promise((resolve, reject) => {
+            const ws = new WebSocket(`ws://[::1]:${HTTP_PORT}/`);
+            const timeoutId = os.setTimeout(() => reject(new Error('WS IPv6 timeout')), 10000);
+            ws.onopen = () => {
+                t.ok++;
+                ws.send('hello ipv6');
+            };
+            ws.onmessage = (evt) => {
+                t.ok++;
+                assert('WS IPv6 echo matches', evt.data === 'hello ipv6');
+                ws.close();
+            };
+            ws.onclose = () => {
+                os.clearTimeout(timeoutId);
+                resolve();
+            };
+            ws.onerror = () => {
+                os.clearTimeout(timeoutId);
+                reject(new Error('WS IPv6 error'));
+            };
+        });
+        // ── 6. WebSocket WSS IPv6 ──
+        t.section('wss://[::1] echo');
+        await new Promise((resolve, reject) => {
+            const ws = new WebSocket(`wss://[::1]:${HTTPS_PORT}/`);
+            const timeoutId = os.setTimeout(() => reject(new Error('WSS IPv6 timeout')), 10000);
+            ws.onopen = () => {
+                t.ok++;
+                ws.send('hello wss ipv6');
+            };
+            ws.onmessage = (evt) => {
+                t.ok++;
+                assert('WSS IPv6 echo matches', evt.data === 'hello wss ipv6');
+                ws.close();
+            };
+            ws.onclose = () => {
+                os.clearTimeout(timeoutId);
+                resolve();
+            };
+            ws.onerror = () => {
+                os.clearTimeout(timeoutId);
+                reject(new Error('WSS IPv6 error'));
+            };
+        });
+    }
+};

package/test/test_ipv6.ts

@@ -0,0 +1,129 @@
+import * as sock from 'sock'
+import * as std from 'std'
+import * as os from 'os'
+import '../lib/fetch.js'
+import '../lib/websocket.js'
+import { Tester } from './test_helper.js'
+
+const HTTP_PORT = 18923
+const HTTPS_PORT = 18924
+
+export const suite = {
+    name: 'ipv6',
+    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) }
+        }
+
+        // ── 1. sock.resolve ──
+        t.section('sock.resolve ::1')
+        {
+            const ip = sock.resolve('::1')
+            assert('resolve ::1 returns ::1', ip === '::1')
+        }
+
+        // ── 2. Raw socket IPv6 ──
+        t.section('raw socket ::1 HTTP GET')
+        await new Promise<void>((resolve, reject) => {
+            const s = sock.socket()
+            if (s === null || s < 0) { t.fail++; reject(new Error('socket() failed')); return }
+
+            let connected = false, gotData = false
+
+            sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
+                if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                    if (event.iErrorCode[0] === 0) {
+                        connected = true; t.ok++
+                        const req = "GET / HTTP/1.1\r\nHost: localhost\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.FdEvent.FD_READ && connected && !gotData) {
+                    const data = sock.recv(s, 4096)
+                    if (data && data.byteLength > 0) { gotData = true; t.ok++ }
+                }
+                if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                    sock.closesocket(s)
+                    if (gotData && connected) resolve()
+                    else reject(new Error('test incomplete'))
+                }
+            })
+            sock.connect(s, '::1', HTTP_PORT)
+        })
+
+        // ── 3. fetch HTTP IPv6 ──
+        t.section('fetch http://[::1]')
+        {
+            const r = await fetch(`http://[::1]:${HTTP_PORT}/`, { timeout: 5000 })
+            assert('fetch IPv6 HTTP status 200', r.status === 200)
+            const body = await r.text()
+            assert('fetch IPv6 HTTP body', body === 'hello from test server')
+        }
+
+        // ── 4. fetch HTTPS IPv6 ──
+        t.section('fetch https://[::1]')
+        {
+            const r = await fetch(`https://[::1]:${HTTPS_PORT}/`, { timeout: 5000 })
+            assert('fetch IPv6 HTTPS status 200', r.status === 200)
+            const body = await r.text()
+            assert('fetch IPv6 HTTPS body', body === 'hello from test server')
+        }
+
+        // ── 5. WebSocket IPv6 ──
+        t.section('ws://[::1] echo')
+        await new Promise<void>((resolve, reject) => {
+            const ws = new WebSocket(`ws://[::1]:${HTTP_PORT}/`)
+            const timeoutId = os.setTimeout(() => reject(new Error('WS IPv6 timeout')), 10000)
+
+            ws.onopen = () => {
+                t.ok++
+                ws.send('hello ipv6')
+            }
+            ws.onmessage = (evt) => {
+                t.ok++
+                assert('WS IPv6 echo matches', evt.data === 'hello ipv6')
+                ws.close()
+            }
+            ws.onclose = () => {
+                os.clearTimeout(timeoutId)
+                resolve()
+            }
+            ws.onerror = () => {
+                os.clearTimeout(timeoutId)
+                reject(new Error('WS IPv6 error'))
+            }
+        })
+
+        // ── 6. WebSocket WSS IPv6 ──
+        t.section('wss://[::1] echo')
+        await new Promise<void>((resolve, reject) => {
+            const ws = new WebSocket(`wss://[::1]:${HTTPS_PORT}/`)
+            const timeoutId = os.setTimeout(() => reject(new Error('WSS IPv6 timeout')), 10000)
+
+            ws.onopen = () => {
+                t.ok++
+                ws.send('hello wss ipv6')
+            }
+            ws.onmessage = (evt) => {
+                t.ok++
+                assert('WSS IPv6 echo matches', evt.data === 'hello wss ipv6')
+                ws.close()
+            }
+            ws.onclose = () => {
+                os.clearTimeout(timeoutId)
+                resolve()
+            }
+            ws.onerror = () => {
+                os.clearTimeout(timeoutId)
+                reject(new Error('WSS IPv6 error'))
+            }
+        })
+    }
+}