quickwin 1.0.2 → 1.1.1

package/test/test_net_websocket.ts

@@ -1,164 +1,164 @@
-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("ws://localhost:18923")
-        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("ws://localhost:18923")
-        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("ws://localhost:18923")
-        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', true); finishTest(pExt.id) }, 10000)
-        await pExt.promise
-        os.clearTimeout(timerExt)
-
-        // ── large message ──
-        t.section('large message (>125 bytes)')
-        const p2 = waitForTest()
-        const ws2 = new WebSocket("ws://localhost:18923")
-        let largeOk = false, closed2 = false
-        const largeStr = "A".repeat(1000)
-        ws2.onopen = () => { ws2.send(largeStr) }
-        ws2.onmessage = (e) => { largeOk = (e.data as string).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("ws://localhost:18923")
-        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("ws://localhost:18923")
-        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)
-
-        // ── WSS (Secure WebSocket) ──
-        t.section('wss basic text message')
-        const p7 = waitForTest()
-        let opened7 = false, received7 = false, closed7 = false
-        const ws7 = new WebSocket("wss://localhost:18924")
-        ws7.onopen = () => { opened7 = true; ws7.send("Hello WSS!") }
-        ws7.onmessage = () => { received7 = true; ws7.close(1000, "done") }
-        ws7.onclose = (e) => {
-            closed7 = true
-            assert('wss onopen fired', opened7)
-            assert('wss onmessage received', received7)
-            assert('wss close code=1000', e.code === 1000)
-            assert('wss wasClean', e.wasClean)
-            finishTest(p7.id)
-        }
-        ws7.onerror = () => { assert('wss no error', false); finishTest(p7.id) }
-        const timer7 = os.setTimeout(() => { if (!closed7) { assert('wss no timeout', false); finishTest(p7.id) } }, 10000)
-        await p7.promise
-        os.clearTimeout(timer7)
-    }
-}
+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("ws://localhost:18923")
+        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("ws://localhost:18923")
+        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("ws://localhost:18923")
+        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', true); finishTest(pExt.id) }, 10000)
+        await pExt.promise
+        os.clearTimeout(timerExt)
+
+        // ── large message ──
+        t.section('large message (>125 bytes)')
+        const p2 = waitForTest()
+        const ws2 = new WebSocket("ws://localhost:18923")
+        let largeOk = false, closed2 = false
+        const largeStr = "A".repeat(1000)
+        ws2.onopen = () => { ws2.send(largeStr) }
+        ws2.onmessage = (e) => { largeOk = (e.data as string).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("ws://localhost:18923")
+        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("ws://localhost:18923")
+        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)
+
+        // ── WSS (Secure WebSocket) ──
+        t.section('wss basic text message')
+        const p7 = waitForTest()
+        let opened7 = false, received7 = false, closed7 = false
+        const ws7 = new WebSocket("wss://localhost:18924")
+        ws7.onopen = () => { opened7 = true; ws7.send("Hello WSS!") }
+        ws7.onmessage = () => { received7 = true; ws7.close(1000, "done") }
+        ws7.onclose = (e) => {
+            closed7 = true
+            assert('wss onopen fired', opened7)
+            assert('wss onmessage received', received7)
+            assert('wss close code=1000', e.code === 1000)
+            assert('wss wasClean', e.wasClean)
+            finishTest(p7.id)
+        }
+        ws7.onerror = () => { assert('wss no error', false); finishTest(p7.id) }
+        const timer7 = os.setTimeout(() => { if (!closed7) { assert('wss no timeout', false); finishTest(p7.id) } }, 10000)
+        await p7.promise
+        os.clearTimeout(timer7)
+    }
+}

package/test/test_polyfill.ts

@@ -1,159 +1,159 @@
-import '../lib/polyfill.js'
-import * as std from 'std'
-import { Tester } from './test_helper.js'
-
-function assert(t: Tester, name: string, ok: boolean): void {
-    if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
-    else { t.fail++; std.printf('  FAIL: %s\n', name) }
-}
-
-export const suite = {
-    name: 'polyfill',
-    run: async (t: Tester) => {
-        t.section('btoa/atob')
-        const orig = "Hello\u0000World"
-        const b64 = btoa(orig)
-        const back = atob(b64)
-        assert(t, 'btoa/atob roundtrip', back === orig)
-        assert(t, 'btoa produces base64 chars', /^[A-Za-z0-9+/=]+$/.test(b64))
-
-        const hash = new Uint8Array([0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e, 0xe1, 0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12])
-        assert(t, 'btoa(SHA-1 sample) matches known value', btoa(String.fromCharCode(...hash)) === "L9ThxnotKPzthJ7hu3bnORuT6xI=")
-
-        t.section('crypto.getRandomValues')
-        const buf = new Uint8Array(32)
-        crypto.getRandomValues(buf)
-        assert(t, 'length=32', buf.length === 32)
-        assert(t, 'not all zeros', buf.some(b => b !== 0))
-
-        t.section('crypto.subtle.digest SHA-1')
-        const data = new TextEncoder().encode("Hello")
-        const hashBuf = await crypto.subtle.digest("SHA-1", data)
-        const hb = new Uint8Array(hashBuf)
-        assert(t, 'output length=20', hb.length === 20)
-        assert(t, 'SHA-1(\'Hello\') matches', hb[0] === 0xF7 && hb[1] === 0xFF && hb[19] === 0xF0)
-
-        t.section('TextEncoder utf-8')
-        const enc = new TextEncoder()
-        assert(t, 'default encoding', enc.encoding === 'utf-8')
-        const encoded = enc.encode("Hello")
-        assert(t, 'encode length', encoded.length === 5)
-        assert(t, 'encode bytes', encoded[0] === 0x48 && encoded[4] === 0x6F)
-        assert(t, 'encoding property', enc.encoding === 'utf-8')
-
-        const enc2 = new TextEncoder('utf-8')
-        assert(t, 'utf-8 label', enc2.encoding === 'utf-8')
-
-        const enc3 = new TextEncoder('utf8')
-        assert(t, 'utf8 alias', enc3.encoding === 'utf-8')
-
-        let threw = false
-        try { new TextEncoder('gbk' as any) } catch (e) { threw = e instanceof RangeError }
-        assert(t, 'unsupported label throws RangeError', threw)
-
-        t.section('TextEncoder utf-16le')
-        const enc16le = new TextEncoder('utf-16le')
-        assert(t, 'encoding property', enc16le.encoding === 'utf-16le')
-
-        const hello16le = enc16le.encode('AB')
-        assert(t, 'length = 4', hello16le.length === 4)
-        assert(t, 'A = 0x41 0x00', hello16le[0] === 0x41 && hello16le[1] === 0x00)
-        assert(t, 'B = 0x42 0x00', hello16le[2] === 0x42 && hello16le[3] === 0x00)
-
-        const null16le = enc16le.encode('\0')
-        assert(t, 'null char = 0x00 0x00', null16le.length === 2 && null16le[0] === 0 && null16le[1] === 0)
-
-        const chinese16le = enc16le.encode('\u4e2d') // 中 = U+4E2D
-        assert(t, '中 = 0x2D 0x4E', chinese16le[0] === 0x2D && chinese16le[1] === 0x4E)
-
-        t.section('TextEncoder utf-16be')
-        const enc16be = new TextEncoder('utf-16be')
-        assert(t, 'encoding property', enc16be.encoding === 'utf-16be')
-
-        const hello16be = enc16be.encode('AB')
-        assert(t, 'length = 4', hello16be.length === 4)
-        assert(t, 'A = 0x00 0x41', hello16be[0] === 0x00 && hello16be[1] === 0x41)
-        assert(t, 'B = 0x00 0x42', hello16be[2] === 0x00 && hello16be[3] === 0x42)
-
-        t.section('TextDecoder utf-8')
-        const dec = new TextDecoder()
-        assert(t, 'default encoding', dec.encoding === 'utf-8')
-        assert(t, 'default fatal', dec.fatal === false)
-        assert(t, 'default ignoreBOM', dec.ignoreBOM === false)
-        assert(t, 'decode utf-8 bytes', dec.decode(encoded) === 'Hello')
-        assert(t, 'decode empty', dec.decode() === '')
-        assert(t, 'decode null', dec.decode(null) === '')
-
-        const decFatal = new TextDecoder('utf-8', { fatal: true })
-        assert(t, 'fatal encoding', decFatal.encoding === 'utf-8')
-        assert(t, 'fatal true', decFatal.fatal === true)
-
-        let threw2 = false
-        try { decFatal.decode(new Uint8Array([0xFF])) } catch (e) { threw2 = e instanceof TypeError }
-        assert(t, 'fatal decode throws TypeError', threw2)
-
-        const nonFatal = new TextDecoder()
-        const replaced = nonFatal.decode(new Uint8Array([0xFF]))
-        assert(t, 'non-fatal replaces with U+FFFD', replaced === '\uFFFD')
-
-        t.section('TextDecoder utf-16le')
-        const dec16le = new TextDecoder('utf-16le')
-        assert(t, 'encoding = utf-16le', dec16le.encoding === 'utf-16le')
-
-        const ab = new Uint8Array([0x41, 0x00, 0x42, 0x00])
-        assert(t, 'AB from utf-16le', dec16le.decode(ab) === 'AB')
-
-        const chn = new Uint8Array([0x2D, 0x4E])
-        assert(t, '中 from utf-16le', dec16le.decode(chn) === '\u4e2d')
-
-        const withBom = new Uint8Array([0xFF, 0xFE, 0x41, 0x00])
-        assert(t, 'BOM stripped by default', dec16le.decode(withBom) === 'A')
-
-        const dec16leNoBom = new TextDecoder('utf-16le', { ignoreBOM: true })
-        assert(t, 'ignoreBOM keeps BOM', dec16leNoBom.decode(withBom) === '\uFEFFA')
-
-        t.section('TextDecoder utf-16be')
-        const dec16be = new TextDecoder('utf-16be')
-        const be = new Uint8Array([0x00, 0x41, 0x00, 0x42])
-        assert(t, 'AB from utf-16be', dec16be.decode(be) === 'AB')
-
-        const chnBe = new Uint8Array([0x4E, 0x2D])
-        assert(t, '中 from utf-16be', dec16be.decode(chnBe) === '\u4e2d')
-
-        t.section('TextDecoder roundtrip')
-        const texts = ['Hello', 'Hello 世界', '\u4e2d\u6587', 'A\0B', '\uD83D\uDE00'] // emoji
-        for (const txt of texts) {
-            const enc8 = new TextEncoder()
-            const bytes = enc8.encode(txt)
-            const dec8 = new TextDecoder()
-            assert(t, `utf-8 roundtrip: ${txt}`, dec8.decode(bytes) === txt)
-
-            const enc16le = new TextEncoder('utf-16le')
-            const bytes16 = enc16le.encode(txt)
-            const dec16le = new TextDecoder('utf-16le')
-            assert(t, `utf-16le roundtrip: ${txt}`, dec16le.decode(bytes16) === txt)
-
-            const enc16be = new TextEncoder('utf-16be')
-            const bytes16be = enc16be.encode(txt)
-            const dec16be = new TextDecoder('utf-16be')
-            assert(t, `utf-16be roundtrip: ${txt}`, dec16be.decode(bytes16be) === txt)
-        }
-
-        t.section('SHA-1 + btoa (WebSocket accept key)')
-        const MAGIC_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-        const testKey = 'dGhlIHNhbXBsZSBub25jZQ=='
-        const concat = testKey + MAGIC_GUID
-        const acceptBuf = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(concat))
-        const acceptBytes = new Uint8Array(acceptBuf)
-        const acceptB64 = btoa(String.fromCharCode(...acceptBytes))
-        assert(t, 'RFC 6455 accept key matches', acceptB64 === "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=")
-
-        let rejected = false
-        try {
-            await crypto.subtle.digest("SHA-256" as any, new Uint8Array(1))
-        } catch {
-            rejected = true
-        }
-        assert(t, 'unsupported algorithm rejected', rejected)
-    }
-}
+import '../lib/polyfill.js'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+function assert(t: Tester, name: string, ok: boolean): void {
+    if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
+    else { t.fail++; std.printf('  FAIL: %s\n', name) }
+}
+
+export const suite = {
+    name: 'polyfill',
+    run: async (t: Tester) => {
+        t.section('btoa/atob')
+        const orig = "Hello\u0000World"
+        const b64 = btoa(orig)
+        const back = atob(b64)
+        assert(t, 'btoa/atob roundtrip', back === orig)
+        assert(t, 'btoa produces base64 chars', /^[A-Za-z0-9+/=]+$/.test(b64))
+
+        const hash = new Uint8Array([0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e, 0xe1, 0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12])
+        assert(t, 'btoa(SHA-1 sample) matches known value', btoa(String.fromCharCode(...hash)) === "L9ThxnotKPzthJ7hu3bnORuT6xI=")
+
+        t.section('crypto.getRandomValues')
+        const buf = new Uint8Array(32)
+        crypto.getRandomValues(buf)
+        assert(t, 'length=32', buf.length === 32)
+        assert(t, 'not all zeros', buf.some(b => b !== 0))
+
+        t.section('crypto.subtle.digest SHA-1')
+        const data = new TextEncoder().encode("Hello")
+        const hashBuf = await crypto.subtle.digest("SHA-1", data)
+        const hb = new Uint8Array(hashBuf)
+        assert(t, 'output length=20', hb.length === 20)
+        assert(t, 'SHA-1(\'Hello\') matches', hb[0] === 0xF7 && hb[1] === 0xFF && hb[19] === 0xF0)
+
+        t.section('TextEncoder utf-8')
+        const enc = new TextEncoder()
+        assert(t, 'default encoding', enc.encoding === 'utf-8')
+        const encoded = enc.encode("Hello")
+        assert(t, 'encode length', encoded.length === 5)
+        assert(t, 'encode bytes', encoded[0] === 0x48 && encoded[4] === 0x6F)
+        assert(t, 'encoding property', enc.encoding === 'utf-8')
+
+        const enc2 = new TextEncoder('utf-8')
+        assert(t, 'utf-8 label', enc2.encoding === 'utf-8')
+
+        const enc3 = new TextEncoder('utf8')
+        assert(t, 'utf8 alias', enc3.encoding === 'utf-8')
+
+        let threw = false
+        try { new TextEncoder('gbk' as any) } catch (e) { threw = e instanceof RangeError }
+        assert(t, 'unsupported label throws RangeError', threw)
+
+        t.section('TextEncoder utf-16le')
+        const enc16le = new TextEncoder('utf-16le')
+        assert(t, 'encoding property', enc16le.encoding === 'utf-16le')
+
+        const hello16le = enc16le.encode('AB')
+        assert(t, 'length = 4', hello16le.length === 4)
+        assert(t, 'A = 0x41 0x00', hello16le[0] === 0x41 && hello16le[1] === 0x00)
+        assert(t, 'B = 0x42 0x00', hello16le[2] === 0x42 && hello16le[3] === 0x00)
+
+        const null16le = enc16le.encode('\0')
+        assert(t, 'null char = 0x00 0x00', null16le.length === 2 && null16le[0] === 0 && null16le[1] === 0)
+
+        const chinese16le = enc16le.encode('\u4e2d') // 中 = U+4E2D
+        assert(t, '中 = 0x2D 0x4E', chinese16le[0] === 0x2D && chinese16le[1] === 0x4E)
+
+        t.section('TextEncoder utf-16be')
+        const enc16be = new TextEncoder('utf-16be')
+        assert(t, 'encoding property', enc16be.encoding === 'utf-16be')
+
+        const hello16be = enc16be.encode('AB')
+        assert(t, 'length = 4', hello16be.length === 4)
+        assert(t, 'A = 0x00 0x41', hello16be[0] === 0x00 && hello16be[1] === 0x41)
+        assert(t, 'B = 0x00 0x42', hello16be[2] === 0x00 && hello16be[3] === 0x42)
+
+        t.section('TextDecoder utf-8')
+        const dec = new TextDecoder()
+        assert(t, 'default encoding', dec.encoding === 'utf-8')
+        assert(t, 'default fatal', dec.fatal === false)
+        assert(t, 'default ignoreBOM', dec.ignoreBOM === false)
+        assert(t, 'decode utf-8 bytes', dec.decode(encoded) === 'Hello')
+        assert(t, 'decode empty', dec.decode() === '')
+        assert(t, 'decode null', dec.decode(null) === '')
+
+        const decFatal = new TextDecoder('utf-8', { fatal: true })
+        assert(t, 'fatal encoding', decFatal.encoding === 'utf-8')
+        assert(t, 'fatal true', decFatal.fatal === true)
+
+        let threw2 = false
+        try { decFatal.decode(new Uint8Array([0xFF])) } catch (e) { threw2 = e instanceof TypeError }
+        assert(t, 'fatal decode throws TypeError', threw2)
+
+        const nonFatal = new TextDecoder()
+        const replaced = nonFatal.decode(new Uint8Array([0xFF]))
+        assert(t, 'non-fatal replaces with U+FFFD', replaced === '\uFFFD')
+
+        t.section('TextDecoder utf-16le')
+        const dec16le = new TextDecoder('utf-16le')
+        assert(t, 'encoding = utf-16le', dec16le.encoding === 'utf-16le')
+
+        const ab = new Uint8Array([0x41, 0x00, 0x42, 0x00])
+        assert(t, 'AB from utf-16le', dec16le.decode(ab) === 'AB')
+
+        const chn = new Uint8Array([0x2D, 0x4E])
+        assert(t, '中 from utf-16le', dec16le.decode(chn) === '\u4e2d')
+
+        const withBom = new Uint8Array([0xFF, 0xFE, 0x41, 0x00])
+        assert(t, 'BOM stripped by default', dec16le.decode(withBom) === 'A')
+
+        const dec16leNoBom = new TextDecoder('utf-16le', { ignoreBOM: true })
+        assert(t, 'ignoreBOM keeps BOM', dec16leNoBom.decode(withBom) === '\uFEFFA')
+
+        t.section('TextDecoder utf-16be')
+        const dec16be = new TextDecoder('utf-16be')
+        const be = new Uint8Array([0x00, 0x41, 0x00, 0x42])
+        assert(t, 'AB from utf-16be', dec16be.decode(be) === 'AB')
+
+        const chnBe = new Uint8Array([0x4E, 0x2D])
+        assert(t, '中 from utf-16be', dec16be.decode(chnBe) === '\u4e2d')
+
+        t.section('TextDecoder roundtrip')
+        const texts = ['Hello', 'Hello 世界', '\u4e2d\u6587', 'A\0B', '\uD83D\uDE00'] // emoji
+        for (const txt of texts) {
+            const enc8 = new TextEncoder()
+            const bytes = enc8.encode(txt)
+            const dec8 = new TextDecoder()
+            assert(t, `utf-8 roundtrip: ${txt}`, dec8.decode(bytes) === txt)
+
+            const enc16le = new TextEncoder('utf-16le')
+            const bytes16 = enc16le.encode(txt)
+            const dec16le = new TextDecoder('utf-16le')
+            assert(t, `utf-16le roundtrip: ${txt}`, dec16le.decode(bytes16) === txt)
+
+            const enc16be = new TextEncoder('utf-16be')
+            const bytes16be = enc16be.encode(txt)
+            const dec16be = new TextDecoder('utf-16be')
+            assert(t, `utf-16be roundtrip: ${txt}`, dec16be.decode(bytes16be) === txt)
+        }
+
+        t.section('SHA-1 + btoa (WebSocket accept key)')
+        const MAGIC_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+        const testKey = 'dGhlIHNhbXBsZSBub25jZQ=='
+        const concat = testKey + MAGIC_GUID
+        const acceptBuf = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(concat))
+        const acceptBytes = new Uint8Array(acceptBuf)
+        const acceptB64 = btoa(String.fromCharCode(...acceptBytes))
+        assert(t, 'RFC 6455 accept key matches', acceptB64 === "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=")
+
+        let rejected = false
+        try {
+            await crypto.subtle.digest("SHA-256" as any, new Uint8Array(1))
+        } catch {
+            rejected = true
+        }
+        assert(t, 'unsupported algorithm rejected', rejected)
+    }
+}