quickwin 1.0.0

package/test/debug/http_server_e2e.js

@@ -0,0 +1,31 @@
+import '../../lib/fetch.js';
+import { createServer } from '../../lib/http-server.js';
+import * as std from 'std';
+const server = createServer(async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === '/echo') {
+        return new Response(JSON.stringify({ method: req.method, path: url.pathname, body: await req.text(), q: Object.fromEntries(url.searchParams) }), { headers: { 'Content-Type': 'application/json' } });
+    }
+    return new Response('hello from quickwin http-server', { headers: { 'Content-Type': 'text/plain' } });
+});
+const rc = server.listen(0, '127.0.0.1');
+if (rc !== 0) {
+    console.log('listen failed');
+    std.exit(1);
+}
+const addr = server.address();
+const port = addr.port;
+console.log('server on port', port);
+async function main() {
+    const r1 = await fetch(`http://127.0.0.1:${port}/`);
+    console.log('GET / status', r1.status, 'body:', await r1.text());
+    const r2 = await fetch(`http://127.0.0.1:${port}/echo?x=1`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'hello-body',
+    });
+    console.log('POST /echo status', r2.status, 'body:', await r2.text());
+    server.close();
+    std.exit(0);
+}
+main();

package/test/debug/minwasm.js

@@ -0,0 +1,52 @@
+import * as std from 'std';
+std.printf("Hello\n");
+function readWasmFile(path) {
+    const fp = std.open(path, 'rb');
+    if (!fp) {
+        return null;
+    }
+    fp.seek(0, 2); // SEEK_END
+    const size = fp.tell();
+    fp.seek(0, 0); // SEEK_SET
+    const buffer = new ArrayBuffer(size);
+    fp.read(buffer, 0, size);
+    fp.close();
+    return buffer;
+}
+const wasmBuf = readWasmFile('./complex_imports.wasm');
+try {
+    if (!wasmBuf)
+        throw new Error('failed to load wasm');
+    const m = new WebAssembly.Module(wasmBuf);
+    console.log('imports:', WebAssembly.Module.imports(m));
+    console.log('exports:', WebAssembly.Module.exports(m));
+    const inst = new WebAssembly.Instance(m, {
+        env: {
+            log_i32: (x) => { console.log('  log_i32:', x); },
+            log_i64: (x) => { console.log('  log_i64:', x); },
+            log_f32: (x) => { console.log('  log_f32:', x); },
+            log_f64: (x) => { console.log('  log_f64:', x); },
+            op_i32: (a, b, c) => a * b + c,
+        }
+    });
+    const exp = inst.exports;
+    console.log('--- i32 ---');
+    let r = exp.run_i32(7);
+    console.log('  run_i32(7) =>', r, '(expected 75)');
+    console.log('--- i64 ---');
+    r = exp.run_i64(100000, 200000);
+    console.log('  run_i64(100000, 200000) =>', r, '(expected 300000)');
+    r = exp.run_i64(10000000000, 20000000000);
+    console.log('  run_i64(10000000000, 20000000000) =>', r, '(expected 30000000000)');
+    console.log('--- f32 ---');
+    r = exp.run_f32(3.5);
+    console.log('  run_f32(3.5) =>', r, '(expected 7.0)');
+    console.log('--- f64 ---');
+    r = exp.run_f64(2.5, 4.0);
+    console.log('  run_f64(2.5, 4.0) =>', r, '(expected 10.0)');
+    console.log('--- all done ---');
+}
+catch (e) {
+    console.log('ERROR:', e);
+}
+;

package/test/debug/mupdf_debug.js

@@ -0,0 +1,104 @@
+import * as std from 'std';
+function loadWasmBytes(path) {
+    const fp = std.open(path, 'rb');
+    if (!fp)
+        throw new Error('Cannot open: ' + path);
+    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;
+}
+function setupMupdfModule(wasmPath) {
+    const wasmBinary = loadWasmBytes(wasmPath);
+    globalThis["$libmupdf_wasm_Module"] = {
+        wasmBinary,
+        locateFile: (p) => p
+    };
+}
+setupMupdfModule('./vendor/mupdf-wasm/mupdf-wasm.wasm');
+await import('../../vendor/mupdf-wasm/mupdf.js');
+// Debug the instance exports
+const inst = globalThis["$wasm_inst"];
+const mod = globalThis["$wasm_mod"];
+console.log('=== WASM Module exports (first 30) ===');
+const modExports = WebAssembly.Module.exports(mod);
+for (let i = 0; i < 30 && i < modExports.length; i++)
+    console.log(`  ${i}: ${modExports[i].name} (${modExports[i].kind})`);
+// Find Sf and Tf indices
+let sf_idx = -1, tf_idx = -1;
+for (let i = 0; i < modExports.length; i++) {
+    if (modExports[i].name === 'Sf')
+        sf_idx = i;
+    if (modExports[i].name === 'Tf')
+        tf_idx = i;
+}
+console.log('Sf index:', sf_idx, 'Tf index:', tf_idx);
+console.log('instance exports Sf:', typeof inst.exports['Sf']);
+console.log('instance exports Tf:', typeof inst.exports['Tf']);
+// Load a simple WASM to verify bridge works
+const fp = std.open('./example.pdf', 'rb');
+if (!fp) {
+    console.log('cannot open example.pdf');
+    std.exit(1);
+}
+fp.seek(0, 2);
+const size = fp.tell();
+fp.seek(0, 0);
+const buf = new ArrayBuffer(size);
+fp.read(buf, 0, size);
+fp.close();
+console.log('\npdf size:', size);
+// Try calling lower-level functions directly
+const lib = globalThis["$libmupdf_wasm_Module"];
+// First open the document
+const wasmMemory = inst.exports['cb'];
+console.log('WASM memory:', typeof wasmMemory, wasmMemory?.buffer?.byteLength);
+// Create a buffer and try
+const bufPtr = lib._wasm_malloc(size);
+console.log('malloc buffer pointer:', bufPtr);
+// Write PDF data into WASM memory at bufPtr...
+const mem8 = new Uint8Array(wasmMemory.buffer);
+for (let i = 0; i < size; i++)
+    mem8[bufPtr + i] = (new Uint8Array(buf))[i];
+console.log('wrote pdf data to WASM memory at', bufPtr);
+// Try opening document directly with _wasm_open_document_with_buffer
+// Need a string for "application/pdf"
+const magicStr = "application/pdf\x00";
+const magicPtr = lib._wasm_malloc(magicStr.length);
+for (let i = 0; i < magicStr.length; i++)
+    mem8[magicPtr + i] = magicStr.charCodeAt(i);
+console.log('magic string at', magicPtr);
+// Create a Buffer wrapper object - need to call Buffer constructor
+// Actually let's just call the low-level function directly
+const fz_ptr = inst.exports['Mf'](magicPtr, bufPtr); // _wasm_open_document_with_buffer
+console.log('_wasm_open_document_with_buffer returned:', fz_ptr, typeof fz_ptr);
+if (fz_ptr && typeof fz_ptr === 'number') {
+    // Try countPages
+    const count = inst.exports['Sf'](fz_ptr);
+    console.log('_wasm_count_pages returned:', count, typeof count);
+    // Try loadPage
+    if (typeof fz_ptr !== 'number') {
+        console.log('fz_ptr is not a number!');
+    }
+    const pagePtr = inst.exports['Tf'](fz_ptr, 0);
+    console.log('_wasm_load_page returned:', pagePtr, typeof pagePtr);
+    // Get bounds
+    // _wasm_bound_page(Sf?) - need to find this export
+    for (let i = 0; i < modExports.length; i++) {
+        if (modExports[i].name.startsWith('Uf')) {
+            console.log('Uf at index', i, '- likely _wasm_pdf_page_from_fz_page');
+        }
+        if (modExports[i].name.startsWith('Vf')) {
+            console.log('Vf at index', i);
+        }
+    }
+    // Try calling _wasm_pdf_page_from_fz_page (Uf)
+    const pdfPtr = inst.exports['Uf'](pagePtr);
+    console.log('_wasm_pdf_page_from_fz_page returned:', pdfPtr, typeof pdfPtr);
+}
+lib._wasm_free(magicPtr);
+lib._wasm_free(bufPtr);
+console.log('\ndone');

package/test/debug/wasm.js

@@ -0,0 +1,122 @@
+import * as std from 'std';
+function readWasmFile(path) {
+    const fp = std.open(path, '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;
+}
+var ok = 0, fail = 0;
+function check(name, expected, actual) {
+    if (typeof expected === 'number' && typeof actual === 'number') {
+        if (Math.abs(expected - actual) < 0.0001) {
+            ok++;
+            std.printf('  PASS: %s = %s\n', name, String(actual));
+        }
+        else {
+            fail++;
+            std.printf('  FAIL: %s = %s (expected %s)\n', name, String(actual), String(expected));
+        }
+    }
+    else if (expected === actual) {
+        ok++;
+        std.printf('  PASS: %s = %s\n', name, String(actual));
+    }
+    else {
+        fail++;
+        std.printf('  FAIL: %s = %s (expected %s)\n', name, String(actual), String(expected));
+    }
+}
+std.printf('=== validate ===\n');
+check('empty buffer', false, WebAssembly.validate(new Uint8Array([]).buffer));
+check('invalid bytes', false, WebAssembly.validate(new Uint8Array([1, 2, 3]).buffer));
+const wasmBuffer = readWasmFile('./add.wasm');
+if (!wasmBuffer) {
+    std.printf('FAIL: cannot load add.wasm\n');
+    std.exit(1);
+}
+check('valid module', true, WebAssembly.validate(wasmBuffer));
+std.printf('=== Module ===\n');
+var module = null;
+try {
+    module = new WebAssembly.Module(wasmBuffer);
+    check('Module constructor', true, module instanceof WebAssembly.Module);
+}
+catch (e) {
+    std.printf('  FAIL: Module constructor: %s\n', String(e));
+    fail++;
+}
+std.printf('=== Module.exports ===\n');
+if (module) {
+    try {
+        const exps = WebAssembly.Module.exports(module);
+        check('exports count', 1, exps.length);
+        check('export name', 'add', exps[0].name);
+        check('export kind', 'function', exps[0].kind);
+    }
+    catch (e) {
+        std.printf('  FAIL: Module.exports: %s\n', String(e));
+        fail++;
+    }
+}
+std.printf('=== Instance (add.wasm) ===\n');
+if (module) {
+    try {
+        const instance = new WebAssembly.Instance(module);
+        const iExp = instance.exports;
+        check('Instance created', true, instance instanceof WebAssembly.Instance);
+        check('add(1, 2)', 3, iExp.add(1, 2));
+        check('add(10, 20)', 30, iExp.add(10, 20));
+        check('add(-5, 3)', -2, iExp.add(-5, 3));
+    }
+    catch (e) {
+        std.printf('  FAIL: Instance: %s\n', String(e));
+        fail++;
+    }
+}
+std.printf('=== complex.wasm (multi exports) ===\n');
+const complexBuffer = readWasmFile('./complex.wasm');
+if (complexBuffer) {
+    try {
+        const cmod = new WebAssembly.Module(complexBuffer);
+        const cinst = new WebAssembly.Instance(cmod);
+        const cExp = cinst.exports;
+        check('add(3, 4)', 7, cExp.add(3, 4));
+        check('sub(10, 3)', 7, cExp.sub(10, 3));
+        check('mul(6, 7)', 42, cExp.mul(6, 7));
+        check('factorial(0)', 1, cExp.factorial(0));
+        check('factorial(5)', 120, cExp.factorial(5));
+        check('factorial(10)', 3628800, cExp.factorial(10));
+    }
+    catch (e) {
+        std.printf('  FAIL: complex.wasm: %s\n', String(e));
+        fail++;
+    }
+}
+std.printf('=== import function support ===\n');
+const importFuncBuffer = readWasmFile('./import_func.wasm');
+if (importFuncBuffer) {
+    try {
+        const ifmod = new WebAssembly.Module(importFuncBuffer);
+        const importObject = {
+            env: { imported_add: (a, b) => a + b }
+        };
+        const ifinst = new WebAssembly.Instance(ifmod, importObject);
+        const ifExp = ifinst.exports;
+        check('add_via_import(3, 4)', 7, ifExp.add_via_import(3, 4));
+        check('add_via_import(10, 20)', 30, ifExp.add_via_import(10, 20));
+        check('add_via_import(-5, 3)', -2, ifExp.add_via_import(-5, 3));
+    }
+    catch (e) {
+        std.printf('  FAIL: import_func.wasm: %s\n', String(e));
+        fail++;
+    }
+}
+std.printf('\n%d/%d tests passed\n', ok, ok + fail);
+if (fail > 0)
+    std.exit(1);

package/test/debug/wasm_export_debug.js

@@ -0,0 +1,64 @@
+import * as std from 'std';
+const fp = std.open('./vendor/mupdf-wasm/mupdf-wasm.wasm', 'rb');
+if (!fp) {
+    console.log('cannot open vendor/mupdf-wasm/mupdf-wasm.wasm');
+    std.exit(1);
+}
+fp.seek(0, 2);
+const size = fp.tell();
+fp.seek(0, 0);
+const buf = new ArrayBuffer(size);
+fp.read(buf, 0, size);
+fp.close();
+const module = new WebAssembly.Module(buf);
+const exports = WebAssembly.Module.exports(module);
+const imports = WebAssembly.Module.imports(module);
+// List ALL export names
+console.log(`=== All exports (${exports.length}) ===`);
+for (let i = 0; i < exports.length; i++) {
+    if (exports[i].name === 'ul' || exports[i].name === 'tl')
+        console.log(`  ${i}: ${exports[i].name} (${exports[i].kind}) *** FOUND ***`);
+}
+// Check last 20 exports
+console.log(`\n=== Last 20 exports ===`);
+for (let i = Math.max(0, exports.length - 20); i < exports.length; i++)
+    console.log(`  ${i}: ${exports[i].name} (${exports[i].kind})`);
+// Check if ul/tl are import functions
+console.log(`\n=== Imports (${imports.length}) ===`);
+for (let i = 0; i < imports.length; i++) {
+    if (imports[i].name === 'ul' || imports[i].name === 'tl')
+        console.log(`  ${i}: ${imports[i].module}.${imports[i].name}`);
+}
+// Now try to call simple exports and see if exec_env is the issue
+console.log(`\n=== Direct instance call test ===`);
+const importObj = { a: {} };
+for (const imp of imports) {
+    if (!importObj[imp.module])
+        importObj[imp.module] = {};
+    if (imp.kind === 'function') {
+        importObj[imp.module][imp.name] = () => 0;
+    }
+}
+// Test calling db, eb sequentially
+const inst = new WebAssembly.Instance(module, importObj);
+const exp = inst.exports;
+console.log('1. calling db()...');
+exp['db']();
+console.log('2. calling db() again...');
+exp['db']();
+console.log('3. calling eb()...');
+try {
+    exp['eb']();
+    console.log('   eb() succeeded');
+}
+catch (e) {
+    console.log('   eb() failed:', e);
+}
+console.log('4. calling fb(100)...');
+try {
+    const r = exp['fb'](100);
+    console.log('   fb(100) =', r);
+}
+catch (e) {
+    console.log('   fb(100) failed:', e);
+}

package/test/debug/wasm_names.js

@@ -0,0 +1,46 @@
+import * as std from 'std';
+// Load the vendor/mupdf-wasm binary using our pre-load mechanism
+const fp = std.open('./vendor/mupdf-wasm/mupdf-wasm.wasm', 'rb');
+if (!fp) {
+    console.log('cannot open vendor/mupdf-wasm/mupdf-wasm.wasm');
+    std.exit(1);
+}
+fp.seek(0, 2);
+const size = fp.tell();
+fp.seek(0, 0);
+const buf = new ArrayBuffer(size);
+fp.read(buf, 0, size);
+fp.close();
+// Check exports for Tf
+const module = new WebAssembly.Module(buf);
+const exports = WebAssembly.Module.exports(module);
+const imports = WebAssembly.Module.imports(module);
+// Look for Tf specifically
+let foundTf = false;
+for (const e of exports) {
+    if (e.name === 'Tf') {
+        console.log('FOUND Tf in exports');
+        foundTf = true;
+        break;
+    }
+}
+if (!foundTf)
+    console.log('Tf NOT in exports');
+// Check a few nearby names used in assignWasmExports
+const wanted = ['Tf', 'Uf', 'Vf', 'Wf', 'Xf', 'Yf', 'Sf', 'Rf', 'Qf', 'Pf', 'Of', 'Nf'];
+const found = [];
+const missing = [];
+for (const w of wanted) {
+    if (exports.some(e => e.name === w))
+        found.push(w);
+    else
+        missing.push(w);
+}
+console.log('found:', found.join(', '));
+console.log('missing:', missing.join(', '));
+// Count exports
+console.log('total exports:', exports.length);
+console.log('total imports:', imports.length);
+// List first 30 export names
+for (let i = 0; i < 30 && i < exports.length; i++)
+    console.log('  export', i, '=', exports[i].name);

package/test/run.js

@@ -0,0 +1,91 @@
+import * as std from 'std';
+import { Tester } from './test_helper.js';
+function formatDuration(ms) {
+    if (ms >= 1000)
+        return (ms / 1000).toFixed(2) + 's';
+    return ms + 'ms';
+}
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+const suiteDefs = [
+    { name: 'basic', file: './test_basic.js', tags: [] },
+    { name: 'basic-fetch', file: './test_basic_fetch.js', tags: [] },
+    { name: 'ipv6', file: './test_ipv6.js', tags: ['net'] },
+    { name: 'url', file: './test_url.js', tags: [] },
+    { name: 'wasm-basic', file: './test_wasm_basic.js', tags: ['wasm'] },
+    { name: 'wasm-types', file: './test_wasm_types.js', tags: ['wasm'] },
+    { name: 'wasm-import-global', file: './test_wasm_import_global.js', tags: ['wasm'] },
+    { name: 'wasm-sjlj', file: './test_wasm_sjlj.js', tags: ['wasm'] },
+    { name: 'wasm-frame-encoding', file: './test_frame_encoding.js', tags: ['wasm'] },
+    { name: 'mupdf-wasm', file: './test_mupdf_wasm.js', tags: ['wasm', 'mupdf'] },
+    { name: 'mupdf-twice', file: './test_mupdf_twice.js', tags: ['wasm', 'mupdf'] },
+    { name: 'mupdf-render', file: './test_mupdf_render.js', tags: ['wasm', 'mupdf'] },
+    { name: 'ffi', file: './test_ffi.js', tags: [] },
+    { name: 'net-fetch', file: './test_net_fetch.js', tags: ['net'] },
+    { name: 'net-websocket', file: './test_net_websocket.js', tags: ['net'] },
+    { name: 'net-event', file: './test_net_event.js', tags: ['net'] },
+    { name: 'http-server', file: './test_http_server.js', tags: ['net'] },
+    { name: 'http-import', file: './test_http_import.js', tags: ['net'] },
+    { name: 'fetch-cache', file: './test_fetch_cache.js', tags: ['net'] },
+    { name: 'polyfill', file: './test_polyfill.js', tags: [] },
+    { name: 'brotli', file: './test_brotli.js', tags: [] },
+    { name: 'worker', file: './test_worker.js', tags: [] },
+    { name: 'worker-wasm', file: './test_worker_wasm_concurrent.js', tags: ['wasm'] },
+    { name: 'worker-http', file: './test_worker_net.js', tags: ['net'] },
+    { name: 'worker-fetch', file: './test_worker_fetch.js', tags: ['net'] }
+];
+async function main() {
+    const filter = scriptArgs.length > 1 ? scriptArgs[1] : '';
+    std.printf('%s====== QuickWin Test Runner ======%s\n', BOLD, RESET);
+    if (filter)
+        std.printf('Filter: %s\n', filter);
+    const results = [];
+    let totalOk = 0, totalFail = 0;
+    for (const def of suiteDefs) {
+        if (filter) {
+            if (filter.startsWith('-')) {
+                const excludeTag = filter.slice(1);
+                if (def.tags.indexOf(excludeTag) >= 0)
+                    continue;
+            }
+            else {
+                if (def.name.indexOf(filter) < 0)
+                    continue;
+            }
+        }
+        let mod;
+        try {
+            mod = await import(def.file);
+        }
+        catch (e) {
+            continue;
+        }
+        if (!mod.suite)
+            continue;
+        const t = new Tester();
+        std.printf('\n%s--- %s ---%s\n', BOLD, def.name, RESET);
+        const suiteStart = Date.now();
+        try {
+            await mod.suite.run(t);
+        }
+        catch (e) {
+            std.printf('  %sSUITE FAILED:%s %s\n', RED, RESET, String(e));
+            t.fail++;
+        }
+        const suiteElapsed = Date.now() - suiteStart;
+        t.summary();
+        results.push({ name: def.name, ok: t.ok, fail: t.fail, elapsed: suiteElapsed });
+        totalOk += t.ok;
+        totalFail += t.fail;
+    }
+    const color = totalFail > 0 ? RED : GREEN;
+    std.printf('\n%s====== Test Results ======%s\n', BOLD, RESET);
+    for (const r of results) {
+        const c = r.fail > 0 ? RED : GREEN;
+        std.printf('  %s%-18s %s%d/%d passed  %s(%s)%s\n', c, r.name, RESET, r.ok, r.ok + r.fail, c, formatDuration(r.elapsed), RESET);
+    }
+    std.printf('%s====== Summary: %d/%d passed ======%s\n', color, totalOk, totalOk + totalFail, RESET);
+}
+main();

package/test/run.ts

@@ -0,0 +1,96 @@
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+declare var scriptArgs: string[]
+
+function formatDuration(ms: number): string {
+    if (ms >= 1000) return (ms / 1000).toFixed(2) + 's'
+    return ms + 'ms'
+}
+
+const BOLD  = '\x1b[1m'
+const GREEN = '\x1b[32m'
+const RED   = '\x1b[31m'
+const RESET = '\x1b[0m'
+
+const suiteDefs = [
+    { name: 'basic',             file: './test_basic.js',            tags: [] },
+    { name: 'basic-fetch',       file: './test_basic_fetch.js',       tags: [] },
+    { name: 'ipv6',              file: './test_ipv6.js',              tags: ['net'] },
+    { name: 'url',               file: './test_url.js',              tags: [] },
+    { name: 'wasm-basic',        file: './test_wasm_basic.js',       tags: ['wasm'] },
+    { name: 'wasm-types',        file: './test_wasm_types.js',       tags: ['wasm'] },
+    { name: 'wasm-import-global', file: './test_wasm_import_global.js', tags: ['wasm'] },
+    { name: 'wasm-sjlj',          file: './test_wasm_sjlj.js',       tags: ['wasm'] },
+    { name: 'wasm-frame-encoding', file: './test_frame_encoding.js', tags: ['wasm'] },
+    { name: 'mupdf-wasm',        file: './test_mupdf_wasm.js',       tags: ['wasm', 'mupdf'] },
+    { name: 'mupdf-twice',       file: './test_mupdf_twice.js',      tags: ['wasm', 'mupdf'] },
+    { name: 'mupdf-render',      file: './test_mupdf_render.js',     tags: ['wasm', 'mupdf'] },
+    { name: 'ffi',               file: './test_ffi.js',              tags: [] },
+    { name: 'net-fetch',         file: './test_net_fetch.js',        tags: ['net'] },
+    { name: 'net-websocket',     file: './test_net_websocket.js',    tags: ['net'] },
+    { name: 'net-event',         file: './test_net_event.js',        tags: ['net'] },
+    { name: 'http-server',       file: './test_http_server.js',      tags: ['net'] },
+    { name: 'http-import',       file: './test_http_import.js',      tags: ['net'] },
+    { name: 'fetch-cache',       file: './test_fetch_cache.js',      tags: ['net'] },
+    { name: 'polyfill',          file: './test_polyfill.js',         tags: [] },
+    { name: 'brotli',            file: './test_brotli.js',           tags: [] },
+    { name: 'worker',            file: './test_worker.js',           tags: [] },
+    { name: 'worker-wasm',       file: './test_worker_wasm_concurrent.js', tags: ['wasm'] },
+    { name: 'worker-http',       file: './test_worker_net.js',       tags: ['net'] },
+    { name: 'worker-fetch',      file: './test_worker_fetch.js',     tags: ['net'] }
+]
+
+async function main(): Promise<void> {
+    const filter = scriptArgs.length > 1 ? scriptArgs[1] : ''
+
+    std.printf('%s====== QuickWin Test Runner ======%s\n', BOLD, RESET)
+    if (filter) std.printf('Filter: %s\n', filter)
+
+    const results: { name: string, ok: number, fail: number, elapsed: number }[] = []
+    let totalOk = 0, totalFail = 0
+
+    for (const def of suiteDefs) {
+        if (filter) {
+            if (filter.startsWith('-')) {
+                const excludeTag = filter.slice(1)
+                if (def.tags.indexOf(excludeTag) >= 0) continue
+            } else {
+                if (def.name.indexOf(filter) < 0) continue
+            }
+        }
+
+        let mod: any
+        try {
+            mod = await import(def.file)
+        } catch (e) {
+            continue
+        }
+        if (!mod.suite) continue
+
+        const t = new Tester()
+        std.printf('\n%s--- %s ---%s\n', BOLD, def.name, RESET)
+        const suiteStart = Date.now()
+        try {
+            await mod.suite.run(t)
+        } catch (e) {
+            std.printf('  %sSUITE FAILED:%s %s\n', RED, RESET, String(e))
+            t.fail++
+        }
+        const suiteElapsed = Date.now() - suiteStart
+        t.summary()
+        results.push({ name: def.name, ok: t.ok, fail: t.fail, elapsed: suiteElapsed })
+        totalOk += t.ok
+        totalFail += t.fail
+    }
+
+    const color = totalFail > 0 ? RED : GREEN
+    std.printf('\n%s====== Test Results ======%s\n', BOLD, RESET)
+    for (const r of results) {
+        const c = r.fail > 0 ? RED : GREEN
+        std.printf('  %s%-18s %s%d/%d passed  %s(%s)%s\n', c, r.name, RESET, r.ok, r.ok + r.fail, c, formatDuration(r.elapsed), RESET)
+    }
+    std.printf('%s====== Summary: %d/%d passed ======%s\n', color, totalOk, totalOk + totalFail, RESET)
+}
+
+main()

package/test/test_basic.js

@@ -0,0 +1,7 @@
+export const suite = {
+    name: 'basic',
+    run: (t) => {
+        t.section('smoke');
+        t.check('hello', true, true);
+    }
+};

package/test/test_basic.ts

@@ -0,0 +1,9 @@
+import { Tester } from './test_helper.js'
+
+export const suite = {
+    name: 'basic',
+    run: (t: Tester) => {
+        t.section('smoke')
+        t.check('hello', true, true)
+    }
+}