quickwin 2026.5.2-3.145209

package/test/run.js

@@ -0,0 +1,86 @@
+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: '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-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: [] },
+];
+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);
+    if (totalFail > 0)
+        std.exit(1);
+}
+main();

package/test/run.ts

@@ -0,0 +1,90 @@
+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: '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-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: [] },
+]
+
+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)
+    if (totalFail > 0) std.exit(1)
+}
+
+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)
+    }
+}

package/test/test_brotli.js

@@ -0,0 +1,48 @@
+import * as brotli from 'brotli';
+function abToString(buf) {
+    const bytes = new Uint8Array(buf);
+    let s = '';
+    for (let i = 0; i < bytes.length; i++)
+        s += String.fromCharCode(bytes[i]);
+    return s;
+}
+// pre-compressed with brotli CLI: "hello brotli! this is a test of decompression"
+const COMPRESSED_HEX = 'a16001c0ef4cb07142bdbbe12588185985d055995ca6b1bdb52083f4028dc6e59c8660a24efa701549c30701';
+function hexToArrayBuffer(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2)
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    return bytes.buffer;
+}
+export const suite = {
+    name: 'brotli',
+    run: (t) => {
+        t.section('decompress function exists');
+        t.checkTrue('decompress is function', typeof brotli.decompress === 'function');
+        t.section('decompress known string');
+        const compressed = hexToArrayBuffer(COMPRESSED_HEX);
+        const decompressed = brotli.decompress(compressed);
+        t.checkTrue('returns ArrayBuffer', decompressed instanceof ArrayBuffer);
+        const result = abToString(decompressed);
+        t.check('roundtrip', 'hello brotli! this is a test of decompression', result);
+        t.section('invalid data throws');
+        let threw = false;
+        try {
+            brotli.decompress(new ArrayBuffer(10));
+        }
+        catch (e) {
+            threw = true;
+        }
+        t.checkTrue('throws on invalid brotli data', threw);
+        t.section('non-ArrayBuffer throws');
+        let threw2 = false;
+        try {
+            ;
+            brotli.decompress('not a buffer');
+        }
+        catch (e) {
+            threw2 = true;
+        }
+        t.checkTrue('throws on non-ArrayBuffer', threw2);
+    }
+};

package/test/test_brotli.ts

@@ -0,0 +1,52 @@
+import * as brotli from 'brotli'
+import { Tester } from './test_helper.js'
+
+function abToString(buf: ArrayBuffer): string {
+    const bytes = new Uint8Array(buf)
+    let s = ''
+    for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
+    return s
+}
+
+// pre-compressed with brotli CLI: "hello brotli! this is a test of decompression"
+const COMPRESSED_HEX = 'a16001c0ef4cb07142bdbbe12588185985d055995ca6b1bdb52083f4028dc6e59c8660a24efa701549c30701'
+
+function hexToArrayBuffer(hex: string): ArrayBuffer {
+    const bytes = new Uint8Array(hex.length / 2)
+    for (let i = 0; i < hex.length; i += 2)
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16)
+    return bytes.buffer as ArrayBuffer
+}
+
+export const suite = {
+    name: 'brotli',
+    run: (t: Tester) => {
+        t.section('decompress function exists')
+        t.checkTrue('decompress is function', typeof brotli.decompress === 'function')
+
+        t.section('decompress known string')
+        const compressed = hexToArrayBuffer(COMPRESSED_HEX)
+        const decompressed = brotli.decompress(compressed)
+        t.checkTrue('returns ArrayBuffer', decompressed instanceof ArrayBuffer)
+        const result = abToString(decompressed)
+        t.check('roundtrip', 'hello brotli! this is a test of decompression', result)
+
+        t.section('invalid data throws')
+        let threw = false
+        try {
+            brotli.decompress(new ArrayBuffer(10))
+        } catch (e) {
+            threw = true
+        }
+        t.checkTrue('throws on invalid brotli data', threw)
+
+        t.section('non-ArrayBuffer throws')
+        let threw2 = false
+        try {
+            ;(brotli as any).decompress('not a buffer')
+        } catch (e) {
+            threw2 = true
+        }
+        t.checkTrue('throws on non-ArrayBuffer', threw2)
+    }
+}

package/test/test_fetch_cache.js

@@ -0,0 +1,131 @@
+import '../lib/fetch.js';
+import * as std from 'std';
+import * as os from 'os';
+function getCacheDir() {
+    const url = import.meta.url;
+    let path = url.slice(7);
+    if (path.length >= 3 && path[1] === ':')
+        path = path.slice(1);
+    const idx = path.lastIndexOf('/');
+    if (idx < 0)
+        return '_cache';
+    const buildDir = path.slice(0, idx);
+    const idx2 = buildDir.lastIndexOf('/');
+    if (idx2 < 0)
+        return '_cache';
+    return buildDir.slice(0, idx2 + 1) + '_cache';
+}
+export const suite = {
+    name: 'fetch-cache',
+    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 cacheDir = getCacheDir();
+        const trackedUrls = [];
+        t.section('__httpCache__ API exists');
+        assert('__httpCache__ is defined', typeof __httpCache__ !== 'undefined');
+        if (!__httpCache__)
+            return;
+        assert('readMeta is function', typeof __httpCache__.readMeta === 'function');
+        assert('readBody is function', typeof __httpCache__.readBody === 'function');
+        assert('writeCache is function', typeof __httpCache__.writeCache === 'function');
+        assert('writeMeta is function', typeof __httpCache__.writeMeta === 'function');
+        assert('cacheKey is function', typeof __httpCache__.cacheKey === 'function');
+        t.section('writeCache + readMeta + readBody');
+        const fakeUrl = 'https://test.local/cache-test';
+        trackedUrls.push(fakeUrl);
+        const testBody = 'hello cache test!';
+        __httpCache__.writeCache(fakeUrl, 60, testBody);
+        const metaStr = __httpCache__.readMeta(fakeUrl);
+        assert('meta written', metaStr !== null);
+        if (metaStr) {
+            const meta = JSON.parse(metaStr);
+            assert('meta has storedAt', typeof meta.storedAt === 'number');
+            assert('meta has maxAge', meta.maxAge === 60);
+        }
+        const fullMeta = JSON.stringify({
+            storedAt: Math.floor(Date.now() / 1000),
+            maxAge: 60,
+            status: 200,
+            statusText: 'OK',
+            headers: { 'content-type': 'text/plain' },
+        });
+        __httpCache__.writeMeta(fakeUrl, fullMeta);
+        const metaStr2 = __httpCache__.readMeta(fakeUrl);
+        assert('meta overwritten', metaStr2 !== null);
+        if (metaStr2) {
+            const meta2 = JSON.parse(metaStr2);
+            assert('meta has status', meta2.status === 200);
+            assert('meta has headers', meta2.headers['content-type'] === 'text/plain');
+        }
+        const bodyAb = __httpCache__.readBody(fakeUrl);
+        assert('body read as ArrayBuffer', bodyAb !== null);
+        if (bodyAb) {
+            const view = new Uint8Array(bodyAb);
+            let str = '';
+            for (let i = 0; i < view.length; i++)
+                str += String.fromCharCode(view[i]);
+            assert('body content correct', str === testBody);
+        }
+        t.section('cacheKey');
+        const key = __httpCache__.cacheKey('https://example.com/test.js');
+        assert('cacheKey returns 16 hex chars', /^[0-9a-f]{16}$/.test(key));
+        t.section('fetch with caching');
+        const cacheTestUrl = 'https://httpbin.org/cache/60';
+        trackedUrls.push(cacheTestUrl);
+        const resp1 = await fetch(cacheTestUrl);
+        assert('first fetch ok', resp1.ok);
+        const body1 = await resp1.text();
+        assert('first fetch body non-empty', body1.length > 0);
+        const cachedMeta = __httpCache__.readMeta(cacheTestUrl);
+        assert('cached meta exists', cachedMeta !== null);
+        if (cachedMeta) {
+            const m = JSON.parse(cachedMeta);
+            assert('cached status = 200', m.status === 200);
+            assert('cached maxAge = 60', m.maxAge === 60);
+        }
+        const cachedBody = __httpCache__.readBody(cacheTestUrl);
+        assert('cached body exists', cachedBody !== null);
+        if (cachedBody) {
+            assert('cached body matches', cachedBody.byteLength > 0);
+        }
+        t.section('second fetch hits cache');
+        const resp2 = await fetch(cacheTestUrl);
+        assert('second fetch ok', resp2.ok);
+        const body2 = await resp2.text();
+        assert('second fetch body same length', body2.length === body1.length);
+        t.section('timing: network vs cache');
+        const timingUrl = 'https://httpbin.org/cache/60?t=' + String(Date.now());
+        trackedUrls.push(timingUrl);
+        const t0 = Date.now();
+        const rNet = await fetch(timingUrl);
+        const t1 = Date.now();
+        const timeNet = t1 - t0;
+        assert('network fetch ok', rNet.ok);
+        const bodyNet = await rNet.text();
+        assert('network body non-empty', bodyNet.length > 0);
+        const t2 = Date.now();
+        const rCache = await fetch(timingUrl);
+        const t3 = Date.now();
+        const timeCache = t3 - t2;
+        assert('cache fetch ok', rCache.ok);
+        const bodyCache = await rCache.text();
+        assert('cache body same length', bodyCache.length === bodyNet.length);
+        assert('cache faster than network (' + timeCache + 'ms vs ' + timeNet + 'ms)', timeCache < timeNet);
+        t.section('cleanup');
+        for (const url of trackedUrls) {
+            const key = __httpCache__.cacheKey(url);
+            os.remove(cacheDir + '/' + key + '.meta');
+            os.remove(cacheDir + '/' + key + '.body');
+            assert('no meta leftover for ' + key, __httpCache__.readMeta(url) === null);
+        }
+    }
+};

package/test/test_fetch_cache.ts

@@ -0,0 +1,141 @@
+import '../lib/fetch.js'
+import * as std from 'std'
+import * as os from 'os'
+import { Tester } from './test_helper.js'
+
+function getCacheDir(): string {
+    const url = import.meta.url
+    let path = url.slice(7)
+    if (path.length >= 3 && path[1] === ':') path = path.slice(1)
+    const idx = path.lastIndexOf('/')
+    if (idx < 0) return '_cache'
+    const buildDir = path.slice(0, idx)
+    const idx2 = buildDir.lastIndexOf('/')
+    if (idx2 < 0) return '_cache'
+    return buildDir.slice(0, idx2 + 1) + '_cache'
+}
+
+export const suite = {
+    name: 'fetch-cache',
+    run: async (t: Tester) => {
+        function assert(name: string, ok: boolean): void {
+            if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
+            else { t.fail++; std.printf('  FAIL: %s\n', name) }
+        }
+
+        const cacheDir = getCacheDir()
+        const trackedUrls: string[] = []
+
+        t.section('__httpCache__ API exists')
+        assert('__httpCache__ is defined', typeof __httpCache__ !== 'undefined')
+        if (!__httpCache__) return
+
+        assert('readMeta is function', typeof __httpCache__.readMeta === 'function')
+        assert('readBody is function', typeof __httpCache__.readBody === 'function')
+        assert('writeCache is function', typeof __httpCache__.writeCache === 'function')
+        assert('writeMeta is function', typeof __httpCache__.writeMeta === 'function')
+        assert('cacheKey is function', typeof __httpCache__.cacheKey === 'function')
+
+        t.section('writeCache + readMeta + readBody')
+        const fakeUrl = 'https://test.local/cache-test'
+        trackedUrls.push(fakeUrl)
+        const testBody = 'hello cache test!'
+        __httpCache__.writeCache(fakeUrl, 60, testBody)
+
+        const metaStr = __httpCache__.readMeta(fakeUrl)
+        assert('meta written', metaStr !== null)
+        if (metaStr) {
+            const meta = JSON.parse(metaStr)
+            assert('meta has storedAt', typeof meta.storedAt === 'number')
+            assert('meta has maxAge', meta.maxAge === 60)
+        }
+
+        const fullMeta = JSON.stringify({
+            storedAt: Math.floor(Date.now() / 1000),
+            maxAge: 60,
+            status: 200,
+            statusText: 'OK',
+            headers: { 'content-type': 'text/plain' },
+        })
+        __httpCache__.writeMeta(fakeUrl, fullMeta)
+
+        const metaStr2 = __httpCache__.readMeta(fakeUrl)
+        assert('meta overwritten', metaStr2 !== null)
+        if (metaStr2) {
+            const meta2 = JSON.parse(metaStr2)
+            assert('meta has status', meta2.status === 200)
+            assert('meta has headers', meta2.headers['content-type'] === 'text/plain')
+        }
+
+        const bodyAb = __httpCache__.readBody(fakeUrl)
+        assert('body read as ArrayBuffer', bodyAb !== null)
+        if (bodyAb) {
+            const view = new Uint8Array(bodyAb)
+            let str = ''
+            for (let i = 0; i < view.length; i++) str += String.fromCharCode(view[i])
+            assert('body content correct', str === testBody)
+        }
+
+        t.section('cacheKey')
+        const key = __httpCache__.cacheKey('https://example.com/test.js')
+        assert('cacheKey returns 16 hex chars', /^[0-9a-f]{16}$/.test(key))
+
+        t.section('fetch with caching')
+        const cacheTestUrl = 'https://httpbin.org/cache/60'
+        trackedUrls.push(cacheTestUrl)
+
+        const resp1 = await fetch(cacheTestUrl)
+        assert('first fetch ok', resp1.ok)
+        const body1 = await resp1.text()
+        assert('first fetch body non-empty', body1.length > 0)
+
+        const cachedMeta = __httpCache__.readMeta(cacheTestUrl)
+        assert('cached meta exists', cachedMeta !== null)
+        if (cachedMeta) {
+            const m = JSON.parse(cachedMeta)
+            assert('cached status = 200', m.status === 200)
+            assert('cached maxAge = 60', m.maxAge === 60)
+        }
+
+        const cachedBody = __httpCache__.readBody(cacheTestUrl)
+        assert('cached body exists', cachedBody !== null)
+        if (cachedBody) {
+            assert('cached body matches', cachedBody.byteLength > 0)
+        }
+
+        t.section('second fetch hits cache')
+        const resp2 = await fetch(cacheTestUrl)
+        assert('second fetch ok', resp2.ok)
+        const body2 = await resp2.text()
+        assert('second fetch body same length', body2.length === body1.length)
+
+        t.section('timing: network vs cache')
+        const timingUrl = 'https://httpbin.org/cache/60?t=' + String(Date.now())
+        trackedUrls.push(timingUrl)
+
+        const t0 = Date.now()
+        const rNet = await fetch(timingUrl)
+        const t1 = Date.now()
+        const timeNet = t1 - t0
+        assert('network fetch ok', rNet.ok)
+        const bodyNet = await rNet.text()
+        assert('network body non-empty', bodyNet.length > 0)
+
+        const t2 = Date.now()
+        const rCache = await fetch(timingUrl)
+        const t3 = Date.now()
+        const timeCache = t3 - t2
+        assert('cache fetch ok', rCache.ok)
+        const bodyCache = await rCache.text()
+        assert('cache body same length', bodyCache.length === bodyNet.length)
+        assert('cache faster than network (' + timeCache + 'ms vs ' + timeNet + 'ms)', timeCache < timeNet)
+
+        t.section('cleanup')
+        for (const url of trackedUrls) {
+            const key = __httpCache__.cacheKey(url)
+            os.remove(cacheDir + '/' + key + '.meta')
+            os.remove(cacheDir + '/' + key + '.body')
+            assert('no meta leftover for ' + key, __httpCache__.readMeta(url) === null)
+        }
+    }
+}