quickwin 1.1.4 → 1.2.0

package/examples/exec_server.ts

@@ -1,35 +1,80 @@
 import { createServer } from '../lib/http-server.js'
-import * as std from 'std'
-
-function readAll(file: std.FILE): string {
-    const chunks: Uint8Array[] = []
-    const buf = new Uint8Array(4096)
-    while (true) {
-        const n = file.read(buf.buffer, 0, 4096)
-        if (n <= 0) break
-        chunks.push(buf.slice(0, n))
-    }
-    let total = 0
-    for (const c of chunks) total += c.length
-    const out = new Uint8Array(total)
-    let offset = 0
-    for (const c of chunks) { out.set(c, offset); offset += c.length }
-    return new TextDecoder().decode(out)
+import * as os from 'os'
+
+// WORKER_DATA_URL 由 esbuild --define 在 build.ts 中注入（base64 data: URL）
+declare const WORKER_DATA_URL: string
+
+const EXEC_TIMEOUT_MS = 60_000
+
+interface ExecResult {
+    out: Uint8Array
+    code: number
+    error: string | null
+}
+
+function runInWorker(cmd: string): Promise<ExecResult> {
+    return new Promise((resolve, reject) => {
+        const worker = new os.Worker(WORKER_DATA_URL)
+        const id = 1
+        let settled = false
+        let timer: ReturnType<typeof os.setTimeout>
+
+        const finish = (fn: () => void) => {
+            if (settled) return
+            settled = true
+            os.clearTimeout(timer)
+            worker.onmessage = null
+            fn()
+        }
+
+        timer = os.setTimeout(() => {
+            finish(() => reject(new Error('exec timeout')))
+        }, EXEC_TIMEOUT_MS)
+
+        worker.onmessage = (e) => {
+            const msg = e.data as { type: string; id: number; out?: Uint8Array; code?: number; error?: string | null }
+            if (msg.type !== 'result' || msg.id !== id) return
+            finish(() => resolve({ out: msg.out ?? new Uint8Array(0), code: msg.code ?? -1, error: msg.error ?? null }))
+        }
+
+        try {
+            worker.postMessage({ type: 'run', id, cmd })
+        } catch (ex) {
+            finish(() => reject(ex instanceof Error ? ex : new Error(String(ex))))
+        }
+    })
 }
 
 const server = createServer(async (req) => {
-    if (req.method === 'POST' && new URL(req.url).pathname === '/exec') {
+    const path = new URL(req.url).pathname
+    if (req.method === 'GET' && (path === '/' || path === '/health')) {
+        return new Response('ok', { headers: { 'Content-Type': 'text/plain' } })
+    }
+    if (req.method === 'POST' && path === '/exec') {
         const body = await req.json() as { cmd: string }
-        const file = std.popen(body.cmd, 'r')
-        if (!file) return new Response('popen failed', { status: 500 })
-        const output = readAll(file)
-        file.close()
-        return new Response(output, {
-            headers: { 'Content-Type': 'application/octet-stream' }
-        })
+        try {
+            const { out, code, error } = await runInWorker(body.cmd)
+            if (error) {
+                return new Response(JSON.stringify({ error }), {
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' }
+                })
+            }
+            return new Response(out, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'X-Exit-Code': String(code),
+                }
+            })
+        } catch (ex) {
+            return new Response(JSON.stringify({ error: String(ex) }), {
+                status: 504,
+                headers: { 'Content-Type': 'application/json' }
+            })
+        }
     }
     return new Response('Not Found', { status: 404 })
 })
 
-server.listen(8080)
-console.log('listening on http://localhost:8080')
+const rc = server.listen(8080, '0.0.0.0')
+console.log('listen rc=' + rc + ' addr=' + JSON.stringify(server.address()))

package/examples/exec_server_worker.js

@@ -0,0 +1,45 @@
+import * as os from 'os';
+import * as std from 'std';
+function readBytes(file) {
+    const chunks = [];
+    const buf = new Uint8Array(4096);
+    while (true) {
+        const n = file.read(buf.buffer, 0, 4096);
+        if (n <= 0)
+            break;
+        chunks.push(buf.slice(0, n));
+    }
+    let total = 0;
+    for (const c of chunks)
+        total += c.length;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        out.set(c, offset);
+        offset += c.length;
+    }
+    return out;
+}
+const parent = os.Worker.parent;
+parent.onmessage = (e) => {
+    const msg = e.data;
+    if (msg.type !== 'run' || typeof msg.cmd !== 'string')
+        return;
+    let out = new Uint8Array(0);
+    let code = -1;
+    let error = null;
+    try {
+        const file = std.popen(msg.cmd, 'r');
+        if (!file) {
+            error = 'popen failed';
+        }
+        else {
+            out = readBytes(file);
+            code = file.close();
+        }
+    }
+    catch (ex) {
+        error = String(ex);
+    }
+    parent.postMessage({ type: 'result', id: msg.id, out, code, error });
+};

package/examples/exec_server_worker.ts

@@ -0,0 +1,39 @@
+import * as os from 'os'
+import * as std from 'std'
+
+function readBytes(file: std.FILE): Uint8Array {
+    const chunks: Uint8Array[] = []
+    const buf = new Uint8Array(4096)
+    while (true) {
+        const n = file.read(buf.buffer, 0, 4096)
+        if (n <= 0) break
+        chunks.push(buf.slice(0, n))
+    }
+    let total = 0
+    for (const c of chunks) total += c.length
+    const out = new Uint8Array(total)
+    let offset = 0
+    for (const c of chunks) { out.set(c, offset); offset += c.length }
+    return out
+}
+
+const parent = os.Worker.parent
+parent.onmessage = (e) => {
+    const msg = e.data as { type: string; id: number; cmd?: string }
+    if (msg.type !== 'run' || typeof msg.cmd !== 'string') return
+    let out: Uint8Array = new Uint8Array(0)
+    let code = -1
+    let error: string | null = null
+    try {
+        const file = std.popen(msg.cmd, 'r')
+        if (!file) {
+            error = 'popen failed'
+        } else {
+            out = readBytes(file)
+            code = file.close()
+        }
+    } catch (ex) {
+        error = String(ex)
+    }
+    parent.postMessage({ type: 'result', id: msg.id, out, code, error })
+}

package/examples/setres.js

@@ -0,0 +1,104 @@
+import * as std from 'std';
+import * as gui from 'gui';
+import * as win from 'win';
+import * as ffi from 'ffi';
+const user32 = win.LoadLibrary('user32.dll');
+if (!user32) {
+    print('LoadLibrary user32 failed');
+    std.exit(1);
+}
+function loadProc(lib, name) {
+    const ptr = win.GetProcAddress(lib, name);
+    if (!ptr) {
+        print('GetProcAddress ' + name + ' failed');
+        std.exit(1);
+    }
+    return ptr;
+}
+const EnumDisplaySettingsA = loadProc(user32, 'EnumDisplaySettingsA');
+const ChangeDisplaySettingsA = loadProc(user32, 'ChangeDisplaySettingsA');
+/** DEVMODEA used by EnumDisplaySettings; driver reports actual dmSize (often 124). */
+const DEVMODE_SIZE = 220;
+const DM_PELSWIDTH = 0x00800000;
+const DM_PELSHEIGHT = 0x01000000;
+const ENUM_CURRENT_SETTINGS = -1;
+const CDS_UPDATEREGISTRY = 0x00000001;
+const CDS_TEST = 0x00000002;
+const DISP_CHANGE = {
+    0: 'SUCCESSFUL',
+    1: 'RESTART',
+    [-1]: 'FAILED',
+    [-2]: 'BADMODE',
+    [-3]: 'NOTUPDATED',
+    [-4]: 'BADFLAGS',
+    [-5]: 'BADPARAM',
+    [-6]: 'BADDUALVIEW',
+};
+function newDevMode() {
+    const buf = new ArrayBuffer(DEVMODE_SIZE);
+    new DataView(buf).setUint16(36, DEVMODE_SIZE, true);
+    return buf;
+}
+function enumMode(modeNum, buf) {
+    return ffi.ffiCall(EnumDisplaySettingsA, [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_SINT32, ffi.FFI_TYPE_POINTER], [null, modeNum, buf], ffi.FFI_TYPE_SINT32);
+}
+function getPels(dv) {
+    return [dv.getUint32(108, true), dv.getUint32(112, true), dv.getUint32(120, true)];
+}
+function applyFromCurrent(w, h, flags, label) {
+    const dm = newDevMode();
+    if (!enumMode(ENUM_CURRENT_SETTINGS, dm)) {
+        print(label + ': EnumDisplaySettings CURRENT failed');
+        return null;
+    }
+    const dv = new DataView(dm);
+    const before = getPels(dv);
+    const size = dv.getUint16(36, true);
+    const extra = dv.getUint16(38, true);
+    const fields = dv.getUint32(40, true);
+    const bpp = dv.getUint32(104, true);
+    const freq = dv.getUint32(120, true);
+    print(label + ': base size=' + size + ' extra=' + extra + ' fields=0x' + fields.toString(16) +
+        ' ' + before[0] + 'x' + before[1] + '@' + freq + ' bpp=' + bpp);
+    dv.setUint32(40, fields | DM_PELSWIDTH | DM_PELSHEIGHT, true);
+    dv.setUint32(108, w, true);
+    dv.setUint32(112, h, true);
+    const ret = ffi.ffiCall(ChangeDisplaySettingsA, [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_UINT32], [dm, flags], ffi.FFI_TYPE_SINT32);
+    print(label + ': ChangeDisplaySettings ' + w + 'x' + h +
+        ' flags=0x' + flags.toString(16) + ' ret=' + ret + ' (' + (DISP_CHANGE[ret] ?? '?') + ')');
+    return ret;
+}
+const targetW = Number(scriptArgs[1] ?? '1024');
+const targetH = Number(scriptArgs[2] ?? '768');
+if (!Number.isFinite(targetW) || !Number.isFinite(targetH) || targetW <= 0 || targetH <= 0) {
+    print('usage: qwin.exe setres.js [width] [height]');
+    std.exit(1);
+}
+print('before GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()));
+const probe = newDevMode();
+const modes32 = [];
+for (let i = 0; i < 200; i++) {
+    if (!enumMode(i, probe))
+        break;
+    const dv = new DataView(probe);
+    if (dv.getUint32(104, true) !== 32)
+        continue;
+    const p = getPels(dv);
+    modes32.push(p[0] + 'x' + p[1] + '@' + p[2]);
+}
+print('32bpp modes sample: ' + modes32.slice(0, 25).join(', ') + (modes32.length > 25 ? ' ...' : ''));
+const testRet = applyFromCurrent(targetW, targetH, CDS_TEST, 'TEST');
+if (testRet === 0) {
+    applyFromCurrent(targetW, targetH, 0, 'DYNAMIC');
+    print('after dynamic GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()));
+    applyFromCurrent(targetW, targetH, CDS_UPDATEREGISTRY, 'REGISTRY');
+    print('after registry GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()));
+}
+else if (testRet !== null) {
+    print('target rejected; try 800x600');
+    const t2 = applyFromCurrent(800, 600, CDS_TEST, 'TEST800');
+    if (t2 === 0) {
+        applyFromCurrent(800, 600, 0, 'DYNAMIC800');
+        print('after 800x600 GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()));
+    }
+}

package/examples/setres.ts

@@ -0,0 +1,120 @@
+import * as std from 'std'
+import * as gui from 'gui'
+import * as win from 'win'
+import * as ffi from 'ffi'
+
+const user32 = win.LoadLibrary('user32.dll')
+if (!user32) { print('LoadLibrary user32 failed'); std.exit(1) }
+
+function loadProc(lib: win.HMODULE, name: string): number {
+    const ptr = win.GetProcAddress(lib, name)
+    if (!ptr) { print('GetProcAddress ' + name + ' failed'); std.exit(1) }
+    return ptr
+}
+
+const EnumDisplaySettingsA = loadProc(user32, 'EnumDisplaySettingsA')
+const ChangeDisplaySettingsA = loadProc(user32, 'ChangeDisplaySettingsA')
+
+/** DEVMODEA used by EnumDisplaySettings; driver reports actual dmSize (often 124). */
+const DEVMODE_SIZE = 220
+const DM_PELSWIDTH = 0x00800000
+const DM_PELSHEIGHT = 0x01000000
+const ENUM_CURRENT_SETTINGS = -1
+const CDS_UPDATEREGISTRY = 0x00000001
+const CDS_TEST = 0x00000002
+
+const DISP_CHANGE: Record<number, string> = {
+    0: 'SUCCESSFUL',
+    1: 'RESTART',
+    [-1]: 'FAILED',
+    [-2]: 'BADMODE',
+    [-3]: 'NOTUPDATED',
+    [-4]: 'BADFLAGS',
+    [-5]: 'BADPARAM',
+    [-6]: 'BADDUALVIEW',
+}
+
+function newDevMode(): ArrayBuffer {
+    const buf = new ArrayBuffer(DEVMODE_SIZE)
+    new DataView(buf).setUint16(36, DEVMODE_SIZE, true)
+    return buf
+}
+
+function enumMode(modeNum: number, buf: ArrayBuffer): number {
+    return ffi.ffiCall(
+        EnumDisplaySettingsA,
+        [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_SINT32, ffi.FFI_TYPE_POINTER],
+        [null, modeNum, buf],
+        ffi.FFI_TYPE_SINT32,
+    )
+}
+
+function getPels(dv: DataView): [number, number, number] {
+    return [dv.getUint32(108, true), dv.getUint32(112, true), dv.getUint32(120, true)]
+}
+
+function applyFromCurrent(w: number, h: number, flags: number, label: string): number | null {
+    const dm = newDevMode()
+    if (!enumMode(ENUM_CURRENT_SETTINGS, dm)) {
+        print(label + ': EnumDisplaySettings CURRENT failed')
+        return null
+    }
+    const dv = new DataView(dm)
+    const before = getPels(dv)
+    const size = dv.getUint16(36, true)
+    const extra = dv.getUint16(38, true)
+    const fields = dv.getUint32(40, true)
+    const bpp = dv.getUint32(104, true)
+    const freq = dv.getUint32(120, true)
+    print(label + ': base size=' + size + ' extra=' + extra + ' fields=0x' + fields.toString(16) +
+        ' ' + before[0] + 'x' + before[1] + '@' + freq + ' bpp=' + bpp)
+
+    dv.setUint32(40, fields | DM_PELSWIDTH | DM_PELSHEIGHT, true)
+    dv.setUint32(108, w, true)
+    dv.setUint32(112, h, true)
+
+    const ret = ffi.ffiCall(
+        ChangeDisplaySettingsA,
+        [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_UINT32],
+        [dm, flags],
+        ffi.FFI_TYPE_SINT32,
+    )
+    print(label + ': ChangeDisplaySettings ' + w + 'x' + h +
+        ' flags=0x' + flags.toString(16) + ' ret=' + ret + ' (' + (DISP_CHANGE[ret] ?? '?') + ')')
+    return ret
+}
+
+const targetW = Number(scriptArgs[1] ?? '1024')
+const targetH = Number(scriptArgs[2] ?? '768')
+if (!Number.isFinite(targetW) || !Number.isFinite(targetH) || targetW <= 0 || targetH <= 0) {
+    print('usage: qwin.exe setres.js [width] [height]')
+    std.exit(1)
+}
+
+print('before GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()))
+
+const probe = newDevMode()
+const modes32: string[] = []
+for (let i = 0; i < 200; i++) {
+    if (!enumMode(i, probe)) break
+    const dv = new DataView(probe)
+    if (dv.getUint32(104, true) !== 32) continue
+    const p = getPels(dv)
+    modes32.push(p[0] + 'x' + p[1] + '@' + p[2])
+}
+print('32bpp modes sample: ' + modes32.slice(0, 25).join(', ') + (modes32.length > 25 ? ' ...' : ''))
+
+const testRet = applyFromCurrent(targetW, targetH, CDS_TEST, 'TEST')
+if (testRet === 0) {
+    applyFromCurrent(targetW, targetH, 0, 'DYNAMIC')
+    print('after dynamic GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()))
+    applyFromCurrent(targetW, targetH, CDS_UPDATEREGISTRY, 'REGISTRY')
+    print('after registry GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()))
+} else if (testRet !== null) {
+    print('target rejected; try 800x600')
+    const t2 = applyFromCurrent(800, 600, CDS_TEST, 'TEST800')
+    if (t2 === 0) {
+        applyFromCurrent(800, 600, 0, 'DYNAMIC800')
+        print('after 800x600 GetScreenSize: ' + JSON.stringify(gui.GetScreenSize()))
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "quickwin",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "QuickJS Win32 runtime — GUI, networking, WASM, FFI, and more",
   "bin": {
     "quickwin": "qwin.exe",

package/quickwin.d.ts

@@ -330,7 +330,7 @@ declare module "os" {
     const S_IFREG: number;
 
     class Worker {
-        /** Constructor to create a new thread (worker) with an API close to the `WebWorkers`. `module_filename` is a string specifying the module filename which is executed in the newly created thread. */
+        /** Constructor to create a new thread (worker) with an API close to the `WebWorkers`. `module_filename` is a file path, `http(s)://` URL, or `data:text/javascript;base64,...` URL executed in the newly created thread. */
         constructor(module_filename: string);
         /** Send a message to the corresponding worker. `msg` is cloned in the destination worker using an algorithm similar to the `HTML` structured clone algorithm. */
         postMessage(msg: unknown): void;

package/test/run.js

@@ -34,7 +34,9 @@ const suiteDefs = [
     { 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'] }
+    { name: 'worker-fetch', file: './test_worker_fetch.js', tags: ['net'] },
+    { name: 'worker-concurrent', file: './test_worker_concurrent.js', tags: [] },
+    { name: 'worker-data-url', file: './test_worker_data_url.js', tags: [] }
 ];
 async function main() {
     const filter = scriptArgs.length > 1 ? scriptArgs[1] : '';

package/test/run.ts

@@ -38,7 +38,9 @@ const suiteDefs = [
     { 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'] }
+    { name: 'worker-fetch',      file: './test_worker_fetch.js',     tags: ['net'] },
+    { name: 'worker-concurrent', file: './test_worker_concurrent.js', tags: [] },
+    { name: 'worker-data-url',   file: './test_worker_data_url.js',   tags: [] }
 ]
 
 async function main(): Promise<void> {

package/test/test_worker_concurrent.js

@@ -0,0 +1,45 @@
+import * as os from 'os';
+import * as std from 'std';
+function runRound() {
+    const ids = [1, 2];
+    return Promise.all(ids.map((id) => new Promise((resolve, reject) => {
+        const worker = new os.Worker('./worker_module.js');
+        const timer = os.setTimeout(() => {
+            worker.onmessage = null;
+            reject(new Error(`worker ${id} timeout`));
+        }, 5000);
+        worker.onmessage = (e) => {
+            os.clearTimeout(timer);
+            worker.postMessage({ type: 'done' });
+            worker.onmessage = null;
+            resolve(e.data);
+        };
+        worker.postMessage({ type: 'start' });
+    })));
+}
+export const suite = {
+    name: 'worker-concurrent',
+    run: async (t) => {
+        t.section('dual-worker-init');
+        const N = 20;
+        let ok = 0;
+        let lastErr = null;
+        for (let i = 0; i < N; i++) {
+            try {
+                const results = await runRound();
+                if (results.length === 2 &&
+                    results.every((r) => r.type === 'result' && r.value === 42)) {
+                    ok++;
+                }
+            }
+            catch (e) {
+                lastErr = e;
+                break;
+            }
+        }
+        if (ok !== N && lastErr) {
+            std.printf('round error: %s\n', String(lastErr));
+        }
+        t.check('concurrent dual-worker rounds', N, ok);
+    }
+};

package/test/test_worker_concurrent.ts

@@ -0,0 +1,56 @@
+import { Tester } from './test_helper.js'
+import * as os from 'os'
+import * as std from 'std'
+
+interface RoundResults {
+    type: string
+    value: number
+}
+
+function runRound(): Promise<RoundResults[]> {
+    const ids = [1, 2]
+    return Promise.all(ids.map((id) =>
+        new Promise<RoundResults>((resolve, reject) => {
+            const worker: any = new os.Worker('./worker_module.js')
+            const timer = os.setTimeout(() => {
+                worker.onmessage = null
+                reject(new Error(`worker ${id} timeout`))
+            }, 5000)
+            worker.onmessage = (e: any) => {
+                os.clearTimeout(timer)
+                worker.postMessage({ type: 'done' })
+                worker.onmessage = null
+                resolve(e.data)
+            }
+            worker.postMessage({ type: 'start' })
+        })
+    ))
+}
+
+export const suite = {
+    name: 'worker-concurrent',
+    run: async (t: Tester) => {
+        t.section('dual-worker-init')
+        const N = 20
+        let ok = 0
+        let lastErr: unknown = null
+        for (let i = 0; i < N; i++) {
+            try {
+                const results = await runRound()
+                if (
+                    results.length === 2 &&
+                    results.every((r) => r.type === 'result' && r.value === 42)
+                ) {
+                    ok++
+                }
+            } catch (e) {
+                lastErr = e
+                break
+            }
+        }
+        if (ok !== N && lastErr) {
+            std.printf('round error: %s\n', String(lastErr))
+        }
+        t.check('concurrent dual-worker rounds', N, ok)
+    }
+}

package/test/test_worker_data_url.js

@@ -0,0 +1,46 @@
+import * as os from 'os';
+// base64 of worker body (see comment). Split manually to keep lines short.
+const B64_WORKER = 'aW1wb3J0ICogYXMgb3MgZnJvbSAnb3MnCmNvbnN0IHBhcmVudCA9IG9zLldvcmtlci5wYXJl' +
+    'bnQKcGFyZW50Lm9ubWVzc2FnZSA9IChlKSA9PiB7CiAgICBjb25zdCBkID0gZS5kYXRhCiAg' +
+    'ICBpZiAoZC50eXBlID09PSAnc3RhcnQnKSBwYXJlbnQucG9zdE1lc3NhZ2UoeyB0eXBlOiAn' +
+    'cmVzdWx0JywgdmFsdWU6IDQyIH0pCiAgICBlbHNlIGlmIChkLnR5cGUgPT09ICdkb25lJykg' +
+    'cGFyZW50Lm9ubWVzc2FnZSA9IG51bGwKfQo=';
+const DATA_WORKER = 'data:text/javascript;base64,' + B64_WORKER;
+// export const answer = 42\n
+const DATA_MOD = 'data:text/javascript;base64,ZXhwb3J0IGNvbnN0IGFuc3dlciA9IDQyCg==';
+export const suite = {
+    name: 'worker-data-url',
+    run: async (t) => {
+        t.section('base64-worker-entry');
+        let worker;
+        try {
+            const { data: result } = await new Promise((resolve, reject) => {
+                worker = new os.Worker(DATA_WORKER);
+                const timer = os.setTimeout(() => reject(new Error('worker timeout')), 5000);
+                worker.onmessage = (e) => {
+                    os.clearTimeout(timer);
+                    resolve({ data: e.data });
+                };
+                worker.postMessage({ type: 'start' });
+            });
+            t.check('message type', 'result', result.type);
+            t.check('imported value', 42, result.value);
+            worker.postMessage({ type: 'done' });
+            worker.onmessage = null;
+        }
+        catch (e) {
+            t.checkTrue('data url worker failed: ' + e, false);
+            if (worker) {
+                worker.onmessage = null;
+            }
+        }
+        t.section('dynamic-import-data-url');
+        try {
+            const mod = await import(DATA_MOD);
+            t.check('import(data:) answer', 42, mod.answer);
+        }
+        catch (e) {
+            t.checkTrue('import(data:) failed: ' + e, false);
+        }
+    }
+};

package/test/test_worker_data_url.ts

@@ -0,0 +1,51 @@
+import { Tester } from './test_helper.js'
+import * as os from 'os'
+
+// base64 of worker body (see comment). Split manually to keep lines short.
+const B64_WORKER =
+    'aW1wb3J0ICogYXMgb3MgZnJvbSAnb3MnCmNvbnN0IHBhcmVudCA9IG9zLldvcmtlci5wYXJl' +
+    'bnQKcGFyZW50Lm9ubWVzc2FnZSA9IChlKSA9PiB7CiAgICBjb25zdCBkID0gZS5kYXRhCiAg' +
+    'ICBpZiAoZC50eXBlID09PSAnc3RhcnQnKSBwYXJlbnQucG9zdE1lc3NhZ2UoeyB0eXBlOiAn' +
+    'cmVzdWx0JywgdmFsdWU6IDQyIH0pCiAgICBlbHNlIGlmIChkLnR5cGUgPT09ICdkb25lJykg' +
+    'cGFyZW50Lm9ubWVzc2FnZSA9IG51bGwKfQo='
+
+const DATA_WORKER = 'data:text/javascript;base64,' + B64_WORKER
+
+// export const answer = 42\n
+const DATA_MOD = 'data:text/javascript;base64,ZXhwb3J0IGNvbnN0IGFuc3dlciA9IDQyCg=='
+
+export const suite = {
+    name: 'worker-data-url',
+    run: async (t: Tester) => {
+        t.section('base64-worker-entry')
+        let worker: any
+        try {
+            const { data: result } = await new Promise<any>((resolve, reject) => {
+                worker = new os.Worker(DATA_WORKER)
+                const timer = os.setTimeout(() => reject(new Error('worker timeout')), 5000)
+                worker.onmessage = (e: any) => {
+                    os.clearTimeout(timer)
+                    resolve({ data: e.data })
+                }
+                worker.postMessage({ type: 'start' })
+            })
+            t.check('message type', 'result', result.type)
+            t.check('imported value', 42, result.value)
+            worker.postMessage({ type: 'done' })
+            worker.onmessage = null
+        } catch (e) {
+            t.checkTrue('data url worker failed: ' + e, false)
+            if (worker) {
+                worker.onmessage = null
+            }
+        }
+
+        t.section('dynamic-import-data-url')
+        try {
+            const mod = await import(DATA_MOD)
+            t.check('import(data:) answer', 42, (mod as any).answer)
+        } catch (e) {
+            t.checkTrue('import(data:) failed: ' + e, false)
+        }
+    }
+}