quickwin 1.1.3 → 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.3",
+  "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;
@@ -340,8 +340,8 @@ declare module "os" {
         static parent: Worker;
     }
 
-    /** Return a string representing the platform: `"linux"`, `"darwin"`, `"win32"` or `"js"`. */
-    const platform: string;
+    /** Process architecture (pointer width): `"x64"` or `"ia32"`. */
+    const arch: string;
 }
 
 declare module "sock" {

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_ffi.js

@@ -1,12 +1,14 @@
 import * as std from 'std';
 import * as win from 'win';
 import * as ffi from 'ffi';
+import * as os from 'os';
+const MAX_WCHARS = 4096;
 function decodeWideAtPtr(ptr) {
     if (!ptr)
         return '';
     const chars = [];
     let pos = ptr;
-    while (true) {
+    while (chars.length < MAX_WCHARS) {
         const low = ffi.readByte(pos);
         const high = ffi.readByte(pos + 1);
         const ch = low + high * 256;
@@ -18,6 +20,9 @@ function decodeWideAtPtr(ptr) {
     return String.fromCharCode(...chars);
 }
 function readPtr(dv, offset) {
+    if (os.arch === 'ia32') {
+        return dv.getUint32(offset, true);
+    }
     const low = dv.getUint32(offset, true);
     const high = dv.getUint32(offset + 4, true);
     return low + high * 4294967296;
@@ -122,15 +127,25 @@ export const suite = {
         std.printf('  printers found: %d\n', returnedBuf[0]);
         if (returnedBuf[0] > 0) {
             const dv = new DataView(printerBuf);
-            const structSize = 136;
+            // PRINTER_INFO_2W layout (MinGW verified):
+            //   x64: sizeof=136 name=8 port=24 drv=32 comment=40 location=48 status=124
+            //   ia32: sizeof=84 name=4 port=12 drv=16 comment=20 location=24 status=72
+            const ia32 = os.arch === 'ia32';
+            const structSize = ia32 ? 84 : 136;
+            const offName = ia32 ? 4 : 8;
+            const offPort = ia32 ? 12 : 24;
+            const offDrv = ia32 ? 16 : 32;
+            const offComment = ia32 ? 20 : 40;
+            const offLocation = ia32 ? 24 : 48;
+            const offStatus = ia32 ? 72 : 124;
             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);
+                const name = decodeWideAtPtr(readPtr(dv, off + offName));
+                const port = decodeWideAtPtr(readPtr(dv, off + offPort));
+                const driver = decodeWideAtPtr(readPtr(dv, off + offDrv));
+                const location = decodeWideAtPtr(readPtr(dv, off + offLocation));
+                const comment = decodeWideAtPtr(readPtr(dv, off + offComment));
+                const status = dv.getUint32(off + offStatus, true);
                 std.printf('  [%d] %s\n', i + 1, name);
                 std.printf('       port: %s\n', port);
                 std.printf('       driver: %s\n', driver);

package/test/test_ffi.ts

@@ -1,13 +1,16 @@
 import * as std from 'std'
 import * as win from 'win'
 import * as ffi from 'ffi'
+import * as os from 'os'
 import { Tester } from './test_helper.js'
 
+const MAX_WCHARS = 4096
+
 function decodeWideAtPtr(ptr: number): string {
     if (!ptr) return ''
     const chars: number[] = []
     let pos = ptr
-    while (true) {
+    while (chars.length < MAX_WCHARS) {
         const low = ffi.readByte(pos)
         const high = ffi.readByte(pos + 1)
         const ch = low + high * 256
@@ -19,6 +22,9 @@ function decodeWideAtPtr(ptr: number): string {
 }
 
 function readPtr(dv: DataView, offset: number): number {
+    if (os.arch === 'ia32') {
+        return dv.getUint32(offset, true)
+    }
     const low = dv.getUint32(offset, true)
     const high = dv.getUint32(offset + 4, true)
     return low + high * 4294967296
@@ -136,16 +142,26 @@ export const suite = {
 
         if (returnedBuf[0]! > 0) {
             const dv = new DataView(printerBuf)
-            const structSize = 136
+            // PRINTER_INFO_2W layout (MinGW verified):
+            //   x64: sizeof=136 name=8 port=24 drv=32 comment=40 location=48 status=124
+            //   ia32: sizeof=84 name=4 port=12 drv=16 comment=20 location=24 status=72
+            const ia32 = os.arch === 'ia32'
+            const structSize = ia32 ? 84 : 136
+            const offName = ia32 ? 4 : 8
+            const offPort = ia32 ? 12 : 24
+            const offDrv = ia32 ? 16 : 32
+            const offComment = ia32 ? 20 : 40
+            const offLocation = ia32 ? 24 : 48
+            const offStatus = ia32 ? 72 : 124
 
             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)
+                const name = decodeWideAtPtr(readPtr(dv, off + offName))
+                const port = decodeWideAtPtr(readPtr(dv, off + offPort))
+                const driver = decodeWideAtPtr(readPtr(dv, off + offDrv))
+                const location = decodeWideAtPtr(readPtr(dv, off + offLocation))
+                const comment = decodeWideAtPtr(readPtr(dv, off + offComment))
+                const status = dv.getUint32(off + offStatus, true)
                 std.printf('  [%d] %s\n', i + 1, name)
                 std.printf('       port: %s\n', port)
                 std.printf('       driver: %s\n', driver)

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