quickwin 2026.5.2-3.145209

package/test/test_ffi.js

@@ -0,0 +1,157 @@
+import * as std from 'std';
+import * as win from 'win';
+import * as ffi from 'ffi';
+function decodeWideAtPtr(ptr) {
+    if (!ptr)
+        return '';
+    const chars = [];
+    let pos = ptr;
+    while (true) {
+        const low = ffi.readByte(pos);
+        const high = ffi.readByte(pos + 1);
+        const ch = low + high * 256;
+        if (ch === 0)
+            break;
+        chars.push(ch);
+        pos += 2;
+    }
+    return String.fromCharCode(...chars);
+}
+function readPtr(dv, offset) {
+    const low = dv.getUint32(offset, true);
+    const high = dv.getUint32(offset + 4, true);
+    return low + high * 4294967296;
+}
+const STATUS_FLAGS = [
+    [0x00000001, 'PAUSED'],
+    [0x00000002, 'ERROR'],
+    [0x00000004, 'PENDING_DELETION'],
+    [0x00000008, 'PAPER_JAM'],
+    [0x00000010, 'PAPER_OUT'],
+    [0x00000020, 'MANUAL_FEED'],
+    [0x00000040, 'PAPER_PROBLEM'],
+    [0x00000080, 'OFFLINE'],
+    [0x00000100, 'IO_ACTIVE'],
+    [0x00000200, 'BUSY'],
+    [0x00000400, 'PRINTING'],
+    [0x00000800, 'OUTPUT_BIN_FULL'],
+    [0x00001000, 'NOT_AVAILABLE'],
+    [0x00002000, 'WAITING'],
+    [0x00004000, 'PROCESSING'],
+    [0x00008000, 'INITIALIZING'],
+    [0x00010000, 'WARMING_UP'],
+    [0x00020000, 'TONER_LOW'],
+    [0x00040000, 'NO_TONER'],
+    [0x00080000, 'PAGE_PUNT'],
+    [0x00100000, 'USER_INTERVENTION'],
+    [0x00200000, 'OUT_OF_MEMORY'],
+    [0x00400000, 'DOOR_OPEN'],
+    [0x00800000, 'SERVER_UNKNOWN'],
+    [0x01000000, 'POWER_SAVE'],
+    [0x02000000, 'SERVER_OFFLINE'],
+    [0x04000000, 'DRIVER_UPDATE'],
+];
+function formatStatus(status) {
+    if (status === 0)
+        return 'OK';
+    const parts = [];
+    for (const [flag, name] of STATUS_FLAGS) {
+        if (status & flag)
+            parts.push(name);
+    }
+    return parts.join('|') || 'UNKNOWN';
+}
+export const suite = {
+    name: 'ffi',
+    run: (t) => {
+        t.section('EnumPrintersW');
+        const hWinspool = win.LoadLibrary('winspool.drv');
+        t.checkTrue('LoadLibrary("winspool.drv") succeeds', hWinspool !== null);
+        if (!hWinspool)
+            return;
+        const enumPrinters = win.GetProcAddress(hWinspool, 'EnumPrintersW');
+        t.checkTrue('GetProcAddress("EnumPrintersW") succeeds', enumPrinters !== null);
+        if (!enumPrinters)
+            return;
+        const flags = 0x06;
+        const level = 2;
+        const neededBuf = new Uint32Array(new ArrayBuffer(4));
+        const returnedBuf = new Uint32Array(new ArrayBuffer(4));
+        const ret1 = ffi.ffiCall(enumPrinters, [
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_POINTER,
+        ], [
+            flags,
+            null,
+            level,
+            null,
+            0,
+            neededBuf.buffer,
+            returnedBuf.buffer,
+        ], ffi.FFI_TYPE_SINT32);
+        std.printf('  first call: ret=%d needed=%d returned=%d\n', ret1, neededBuf[0], returnedBuf[0]);
+        t.checkTrue('pcbNeeded > 0', neededBuf[0] > 0);
+        if (neededBuf[0] <= 0)
+            return;
+        const printerBuf = new ArrayBuffer(neededBuf[0]);
+        const ret2 = ffi.ffiCall(enumPrinters, [
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_UINT32,
+            ffi.FFI_TYPE_POINTER,
+            ffi.FFI_TYPE_POINTER,
+        ], [
+            flags,
+            null,
+            level,
+            printerBuf,
+            neededBuf[0],
+            neededBuf.buffer,
+            returnedBuf.buffer,
+        ], ffi.FFI_TYPE_SINT32);
+        t.checkTrue('EnumPrintersW succeeds', ret2 !== 0);
+        if (ret2 === 0)
+            return;
+        std.printf('  printers found: %d\n', returnedBuf[0]);
+        if (returnedBuf[0] > 0) {
+            const dv = new DataView(printerBuf);
+            const structSize = 136;
+            for (let i = 0; i < returnedBuf[0] && i < 20; i++) {
+                const off = i * structSize;
+                const name = decodeWideAtPtr(readPtr(dv, off + 8));
+                const port = decodeWideAtPtr(readPtr(dv, off + 24));
+                const driver = decodeWideAtPtr(readPtr(dv, off + 32));
+                const location = decodeWideAtPtr(readPtr(dv, off + 48));
+                const comment = decodeWideAtPtr(readPtr(dv, off + 40));
+                const status = dv.getUint32(off + 124, true);
+                std.printf('  [%d] %s\n', i + 1, name);
+                std.printf('       port: %s\n', port);
+                std.printf('       driver: %s\n', driver);
+                if (location)
+                    std.printf('       location: %s\n', location);
+                if (comment)
+                    std.printf('       comment: %s\n', comment);
+                std.printf('       status: 0x%08X (%s)\n', status, formatStatus(status));
+            }
+        }
+        else {
+            std.printf('  no printers installed (skip)\n');
+        }
+        t.section('pointer arg type check');
+        let threw = false;
+        try {
+            ffi.ffiCall(enumPrinters, [ffi.FFI_TYPE_POINTER], [123], ffi.FFI_TYPE_VOID);
+        }
+        catch (e) {
+            threw = true;
+        }
+        t.checkTrue('non-ArrayBuffer pointer arg throws TypeError', threw);
+    }
+};

package/test/test_ffi.ts

@@ -0,0 +1,174 @@
+import * as std from 'std'
+import * as win from 'win'
+import * as ffi from 'ffi'
+import { Tester } from './test_helper.js'
+
+function decodeWideAtPtr(ptr: number): string {
+    if (!ptr) return ''
+    const chars: number[] = []
+    let pos = ptr
+    while (true) {
+        const low = ffi.readByte(pos) as number
+        const high = ffi.readByte(pos + 1) as number
+        const ch = low + high * 256
+        if (ch === 0) break
+        chars.push(ch)
+        pos += 2
+    }
+    return String.fromCharCode(...chars)
+}
+
+function readPtr(dv: DataView, offset: number): number {
+    const low = dv.getUint32(offset, true)
+    const high = dv.getUint32(offset + 4, true)
+    return low + high * 4294967296
+}
+
+const STATUS_FLAGS: [number, string][] = [
+    [0x00000001, 'PAUSED'],
+    [0x00000002, 'ERROR'],
+    [0x00000004, 'PENDING_DELETION'],
+    [0x00000008, 'PAPER_JAM'],
+    [0x00000010, 'PAPER_OUT'],
+    [0x00000020, 'MANUAL_FEED'],
+    [0x00000040, 'PAPER_PROBLEM'],
+    [0x00000080, 'OFFLINE'],
+    [0x00000100, 'IO_ACTIVE'],
+    [0x00000200, 'BUSY'],
+    [0x00000400, 'PRINTING'],
+    [0x00000800, 'OUTPUT_BIN_FULL'],
+    [0x00001000, 'NOT_AVAILABLE'],
+    [0x00002000, 'WAITING'],
+    [0x00004000, 'PROCESSING'],
+    [0x00008000, 'INITIALIZING'],
+    [0x00010000, 'WARMING_UP'],
+    [0x00020000, 'TONER_LOW'],
+    [0x00040000, 'NO_TONER'],
+    [0x00080000, 'PAGE_PUNT'],
+    [0x00100000, 'USER_INTERVENTION'],
+    [0x00200000, 'OUT_OF_MEMORY'],
+    [0x00400000, 'DOOR_OPEN'],
+    [0x00800000, 'SERVER_UNKNOWN'],
+    [0x01000000, 'POWER_SAVE'],
+    [0x02000000, 'SERVER_OFFLINE'],
+    [0x04000000, 'DRIVER_UPDATE'],
+];
+
+function formatStatus(status: number): string {
+    if (status === 0) return 'OK'
+    const parts: string[] = []
+    for (const [flag, name] of STATUS_FLAGS) {
+        if (status & flag) parts.push(name)
+    }
+    return parts.join('|') || 'UNKNOWN'
+}
+
+export const suite = {
+    name: 'ffi',
+    run: (t: Tester) => {
+        t.section('EnumPrintersW')
+        const hWinspool = win.LoadLibrary('winspool.drv')
+        t.checkTrue('LoadLibrary("winspool.drv") succeeds', hWinspool !== null)
+        if (!hWinspool) return
+
+        const enumPrinters = win.GetProcAddress(hWinspool, 'EnumPrintersW')
+        t.checkTrue('GetProcAddress("EnumPrintersW") succeeds', enumPrinters !== null)
+        if (!enumPrinters) return
+
+        const flags = 0x06
+        const level = 2
+        const neededBuf = new Uint32Array(new ArrayBuffer(4))
+        const returnedBuf = new Uint32Array(new ArrayBuffer(4))
+
+        const ret1 = ffi.ffiCall(
+            enumPrinters,
+            [
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_POINTER,
+            ],
+            [
+                flags,
+                null,
+                level,
+                null,
+                0,
+                neededBuf.buffer,
+                returnedBuf.buffer,
+            ],
+            ffi.FFI_TYPE_SINT32
+        )
+        std.printf('  first call: ret=%d needed=%d returned=%d\n', ret1, neededBuf[0], returnedBuf[0])
+        t.checkTrue('pcbNeeded > 0', neededBuf[0] > 0)
+        if (neededBuf[0] <= 0) return
+
+        const printerBuf = new ArrayBuffer(neededBuf[0])
+        const ret2 = ffi.ffiCall(
+            enumPrinters,
+            [
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_UINT32,
+                ffi.FFI_TYPE_POINTER,
+                ffi.FFI_TYPE_POINTER,
+            ],
+            [
+                flags,
+                null,
+                level,
+                printerBuf,
+                neededBuf[0],
+                neededBuf.buffer,
+                returnedBuf.buffer,
+            ],
+            ffi.FFI_TYPE_SINT32
+        )
+        t.checkTrue('EnumPrintersW succeeds', ret2 !== 0)
+        if (ret2 === 0) return
+
+        std.printf('  printers found: %d\n', returnedBuf[0])
+
+        if (returnedBuf[0] > 0) {
+            const dv = new DataView(printerBuf)
+            const structSize = 136
+
+            for (let i = 0; i < returnedBuf[0] && i < 20; i++) {
+                const off = i * structSize
+                const name = decodeWideAtPtr(readPtr(dv, off + 8))
+                const port = decodeWideAtPtr(readPtr(dv, off + 24))
+                const driver = decodeWideAtPtr(readPtr(dv, off + 32))
+                const location = decodeWideAtPtr(readPtr(dv, off + 48))
+                const comment = decodeWideAtPtr(readPtr(dv, off + 40))
+                const status = dv.getUint32(off + 124, true)
+                std.printf('  [%d] %s\n', i + 1, name)
+                std.printf('       port: %s\n', port)
+                std.printf('       driver: %s\n', driver)
+                if (location) std.printf('       location: %s\n', location)
+                if (comment) std.printf('       comment: %s\n', comment)
+                std.printf('       status: 0x%08X (%s)\n', status, formatStatus(status))
+            }
+        } else {
+            std.printf('  no printers installed (skip)\n')
+        }
+
+        t.section('pointer arg type check')
+        let threw = false
+        try {
+            ffi.ffiCall(
+                enumPrinters,
+                [ffi.FFI_TYPE_POINTER] as any,
+                [123] as any,
+                ffi.FFI_TYPE_VOID
+            )
+        } catch (e) {
+            threw = true
+        }
+        t.checkTrue('non-ArrayBuffer pointer arg throws TypeError', threw)
+    }
+}

package/test/test_frame_encoding.js

@@ -0,0 +1,128 @@
+import * as std from 'std';
+export const suite = {
+    name: 'wasm-frame-encoding',
+    run: (t) => {
+        function createFrameHeader(payloadLen) {
+            let headerSize = payloadLen < 126 ? 6 : (payloadLen < 65536 ? 8 : 14);
+            let buf = new ArrayBuffer(headerSize);
+            let view = new Uint8Array(buf);
+            let off = 0;
+            view[off++] = 0x81;
+            if (payloadLen < 126) {
+                view[off++] = 0x80 | payloadLen;
+            }
+            else if (payloadLen < 65536) {
+                view[off++] = 0x80 | 126;
+                view[off++] = (payloadLen >> 8) & 0xFF;
+                view[off++] = payloadLen & 0xFF;
+            }
+            else {
+                view[off++] = 0x80 | 127;
+                const len = payloadLen;
+                const hi = Math.floor(len / 0x100000000) >>> 0;
+                const lo = len >>> 0;
+                view[off++] = (hi >> 24) & 0xFF;
+                view[off++] = (hi >> 16) & 0xFF;
+                view[off++] = (hi >> 8) & 0xFF;
+                view[off++] = hi & 0xFF;
+                view[off++] = (lo >> 24) & 0xFF;
+                view[off++] = (lo >> 16) & 0xFF;
+                view[off++] = (lo >> 8) & 0xFF;
+                view[off++] = lo & 0xFF;
+            }
+            return view;
+        }
+        function tryParseFrameLen(data) {
+            if (data.length < 2)
+                return null;
+            const b1 = data[1];
+            let payloadLen = b1 & 0x7F;
+            let offset = 2;
+            if (payloadLen === 126) {
+                if (data.length < 4)
+                    return null;
+                payloadLen = (data[2] << 8) | data[3];
+            }
+            else if (payloadLen === 127) {
+                if (data.length < 10)
+                    return null;
+                let hi = 0, lo = 0;
+                for (let i = 0; i < 4; i++)
+                    hi = (hi * 256 + data[offset + i]) >>> 0;
+                for (let i = 4; i < 8; i++)
+                    lo = (lo * 256 + data[offset + i]) >>> 0;
+                payloadLen = hi * 0x100000000 + lo;
+            }
+            return payloadLen;
+        }
+        function assert(name, ok) {
+            if (ok) {
+                t.ok++;
+                std.printf('  PASS: %s\n', name);
+            }
+            else {
+                t.fail++;
+                std.printf('  FAIL: %s\n', name);
+            }
+        }
+        // small frame (100 bytes)
+        t.section('inline length (<126)');
+        let h = createFrameHeader(100);
+        assert('length=100', h[1] === (0x80 | 100));
+        assert('parse 100', tryParseFrameLen(h) === 100);
+        // 1 (edge case)
+        h = createFrameHeader(1);
+        assert('length=1', h[1] === (0x80 | 1));
+        assert('parse 1', tryParseFrameLen(h) === 1);
+        // 125 (max inline)
+        h = createFrameHeader(125);
+        assert('length=125', h[1] === (0x80 | 125));
+        assert('parse 125', tryParseFrameLen(h) === 125);
+        // 126 (enters 16-bit extended)
+        t.section('16-bit extended length (126–65535)');
+        h = createFrameHeader(126);
+        assert('126 marker', h[1] === (0x80 | 126));
+        assert('126 value', h[2] === 0 && h[3] === 126);
+        assert('parse 126', tryParseFrameLen(h) === 126);
+        // 65535 (max 16-bit)
+        h = createFrameHeader(65535);
+        assert('65535 marker', h[1] === (0x80 | 126));
+        assert('65535 hi byte', h[2] === 0xFF);
+        assert('65535 lo byte', h[3] === 0xFF);
+        assert('parse 65535', tryParseFrameLen(h) === 65535);
+        // 65536 (enters 64-bit extended)
+        t.section('64-bit extended length (>=65536)');
+        h = createFrameHeader(65536);
+        assert('65536 marker', h[1] === (0x80 | 127));
+        assert('parse 65536', tryParseFrameLen(h) === 65536);
+        // 66000
+        h = createFrameHeader(66000);
+        assert('66000 marker', h[1] === (0x80 | 127));
+        assert('parse 66000', tryParseFrameLen(h) === 66000);
+        // 70000 — verify exact bytes
+        h = createFrameHeader(70000);
+        assert('70000 marker', h[1] === (0x80 | 127));
+        // 70000 = 0x11170, big-endian 8 bytes: 00 00 00 00 00 01 11 70
+        assert('70000 bytes big-endian', h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x00 &&
+            h[6] === 0x00 && h[7] === 0x01 && h[8] === 0x11 && h[9] === 0x70);
+        assert('parse 70000', tryParseFrameLen(h) === 70000);
+        // Large value near 2^32 boundary
+        t.section('large values');
+        h = createFrameHeader(0xABCD1234);
+        assert('0xABCD1234 marker', h[1] === (0x80 | 127));
+        assert('parse 0xABCD1234', tryParseFrameLen(h) === 0xABCD1234);
+        assert('MSB non-zero', h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x00 &&
+            h[6] === 0xAB && h[7] === 0xCD && h[8] === 0x12 && h[9] === 0x34);
+        // 0x100000001 (just above 2^32)
+        h = createFrameHeader(0x100000001);
+        assert('2^32+1 parse', tryParseFrameLen(h) === 0x100000001);
+        assert('2^32+1 bytes', h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x01 &&
+            h[6] === 0x00 && h[7] === 0x00 && h[8] === 0x00 && h[9] === 0x01);
+        // Full 8-byte roundtrip: 0x0123456789ABCDEF
+        // This exceeds Number's safe integer range (2^53) slightly,
+        // but our test value 0x0123456789ABCDEF = 81985529216486895 < 2^53 ✓
+        const bigVal = 0x0123456789ABCDEF;
+        h = createFrameHeader(bigVal);
+        assert('big val parse', tryParseFrameLen(h) === bigVal);
+    }
+};

package/test/test_frame_encoding.ts

@@ -0,0 +1,132 @@
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+export const suite = {
+    name: 'wasm-frame-encoding',
+    run: (t: Tester) => {
+        function createFrameHeader(payloadLen: number): Uint8Array {
+            let headerSize = payloadLen < 126 ? 6 : (payloadLen < 65536 ? 8 : 14)
+            let buf = new ArrayBuffer(headerSize)
+            let view = new Uint8Array(buf)
+            let off = 0
+            view[off++] = 0x81
+            if (payloadLen < 126) {
+                view[off++] = 0x80 | payloadLen
+            } else if (payloadLen < 65536) {
+                view[off++] = 0x80 | 126
+                view[off++] = (payloadLen >> 8) & 0xFF
+                view[off++] = payloadLen & 0xFF
+            } else {
+                view[off++] = 0x80 | 127
+                const len = payloadLen
+                const hi = Math.floor(len / 0x100000000) >>> 0
+                const lo = len >>> 0
+                view[off++] = (hi >> 24) & 0xFF
+                view[off++] = (hi >> 16) & 0xFF
+                view[off++] = (hi >> 8) & 0xFF
+                view[off++] = hi & 0xFF
+                view[off++] = (lo >> 24) & 0xFF
+                view[off++] = (lo >> 16) & 0xFF
+                view[off++] = (lo >> 8) & 0xFF
+                view[off++] = lo & 0xFF
+            }
+            return view
+        }
+
+        function tryParseFrameLen(data: Uint8Array): number | null {
+            if (data.length < 2) return null
+            const b1 = data[1]
+            let payloadLen = b1 & 0x7F
+            let offset = 2
+            if (payloadLen === 126) {
+                if (data.length < 4) return null
+                payloadLen = (data[2] << 8) | data[3]
+            } else if (payloadLen === 127) {
+                if (data.length < 10) return null
+                let hi = 0, lo = 0
+                for (let i = 0; i < 4; i++) hi = (hi * 256 + data[offset + i]) >>> 0
+                for (let i = 4; i < 8; i++) lo = (lo * 256 + data[offset + i]) >>> 0
+                payloadLen = hi * 0x100000000 + lo
+            }
+            return payloadLen
+        }
+
+        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) }
+        }
+
+        // small frame (100 bytes)
+        t.section('inline length (<126)')
+        let h = createFrameHeader(100)
+        assert('length=100', h[1] === (0x80 | 100))
+        assert('parse 100', tryParseFrameLen(h) === 100)
+
+        // 1 (edge case)
+        h = createFrameHeader(1)
+        assert('length=1', h[1] === (0x80 | 1))
+        assert('parse 1', tryParseFrameLen(h) === 1)
+
+        // 125 (max inline)
+        h = createFrameHeader(125)
+        assert('length=125', h[1] === (0x80 | 125))
+        assert('parse 125', tryParseFrameLen(h) === 125)
+
+        // 126 (enters 16-bit extended)
+        t.section('16-bit extended length (126–65535)')
+        h = createFrameHeader(126)
+        assert('126 marker', h[1] === (0x80 | 126))
+        assert('126 value', h[2] === 0 && h[3] === 126)
+        assert('parse 126', tryParseFrameLen(h) === 126)
+
+        // 65535 (max 16-bit)
+        h = createFrameHeader(65535)
+        assert('65535 marker', h[1] === (0x80 | 126))
+        assert('65535 hi byte', h[2] === 0xFF)
+        assert('65535 lo byte', h[3] === 0xFF)
+        assert('parse 65535', tryParseFrameLen(h) === 65535)
+
+        // 65536 (enters 64-bit extended)
+        t.section('64-bit extended length (>=65536)')
+        h = createFrameHeader(65536)
+        assert('65536 marker', h[1] === (0x80 | 127))
+        assert('parse 65536', tryParseFrameLen(h) === 65536)
+
+        // 66000
+        h = createFrameHeader(66000)
+        assert('66000 marker', h[1] === (0x80 | 127))
+        assert('parse 66000', tryParseFrameLen(h) === 66000)
+
+        // 70000 — verify exact bytes
+        h = createFrameHeader(70000)
+        assert('70000 marker', h[1] === (0x80 | 127))
+        // 70000 = 0x11170, big-endian 8 bytes: 00 00 00 00 00 01 11 70
+        assert('70000 bytes big-endian',
+            h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x00 &&
+            h[6] === 0x00 && h[7] === 0x01 && h[8] === 0x11 && h[9] === 0x70)
+        assert('parse 70000', tryParseFrameLen(h) === 70000)
+
+        // Large value near 2^32 boundary
+        t.section('large values')
+        h = createFrameHeader(0xABCD1234)
+        assert('0xABCD1234 marker', h[1] === (0x80 | 127))
+        assert('parse 0xABCD1234', tryParseFrameLen(h) === 0xABCD1234)
+        assert('MSB non-zero',
+            h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x00 &&
+            h[6] === 0xAB && h[7] === 0xCD && h[8] === 0x12 && h[9] === 0x34)
+
+        // 0x100000001 (just above 2^32)
+        h = createFrameHeader(0x100000001)
+        assert('2^32+1 parse', tryParseFrameLen(h) === 0x100000001)
+        assert('2^32+1 bytes',
+            h[2] === 0x00 && h[3] === 0x00 && h[4] === 0x00 && h[5] === 0x01 &&
+            h[6] === 0x00 && h[7] === 0x00 && h[8] === 0x00 && h[9] === 0x01)
+
+        // Full 8-byte roundtrip: 0x0123456789ABCDEF
+        // This exceeds Number's safe integer range (2^53) slightly,
+        // but our test value 0x0123456789ABCDEF = 81985529216486895 < 2^53 ✓
+        const bigVal = 0x0123456789ABCDEF
+        h = createFrameHeader(bigVal)
+        assert('big val parse', tryParseFrameLen(h) === bigVal)
+    }
+}

package/test/test_helper.js

@@ -0,0 +1,84 @@
+import * as std from 'std';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+function formatDuration(ms) {
+    if (ms >= 1000)
+        return (ms / 1000).toFixed(2) + 's';
+    return ms + 'ms';
+}
+export function readWasmFile(path) {
+    const base = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
+    const parts = (base + path).split('/');
+    const out = [];
+    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;
+    startTime = Date.now();
+    sectionStart = this.startTime;
+    lastSection = '';
+    section(name) {
+        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, expected, actual) {
+        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, actual) {
+        this.check(name, true, actual);
+    }
+    summary() {
+        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);
+    }
+}