quickwin 1.0.0

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)
+        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: 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);
+    }
+}

package/test/test_helper.ts

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

package/test/test_http_import.js

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