@volter/browser-wali 0.1.0

package/dist/thread-worker.js

@@ -0,0 +1,725 @@
+import { WaliMemoryManager } from "./memory.js";
+import { WaliNetworkHost } from "./network.js";
+import { SharedWaliStdinReader } from "./stdin.js";
+import { WaliSystemHost } from "./system.js";
+import { WaliFileDescriptorTable } from "./filesystem.js";
+import { WaliFilesystemClient, WaliSharedFileDescriptorHost } from "./filesystem-remote.js";
+import { WaliSharedPipeHost } from "./shared-pipes.js";
+import { BROWSER_PROCESS_RESPONSE_BYTES, applyProcessFilesystemPatch, closeSharedPipe, decodeProcessSnapshot, retainSharedPipe, } from "./process-bridge.js";
+class ThreadExit extends Error {
+}
+const scope = globalThis;
+let instance;
+let memory;
+let descriptors = [];
+let processPid = 2;
+let processExecutablePath = "/usr/bin/wali-program";
+let processArgvBytes = [new TextEncoder().encode("wali-program\0")];
+let processCwd = "/";
+let threadId = 3;
+let mmapCursor;
+let sharedMmapRegistry;
+let fatalState;
+let networkChannel;
+let filesystemChannel;
+let stdin;
+let stdioAliasRegistry;
+let sharedPipes;
+let childPidAllocator;
+let browserProcessPort;
+let outputPort;
+let slotIndex = -1;
+let coordinatorPort;
+let diagnosticLength;
+let diagnosticBytes;
+const localStdioAliases = new Map();
+const localSpecialDescriptors = new Set();
+let nextLocalDescriptor = 60_000;
+const reportedUnsupportedImports = new Set();
+const sleepWord = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+const diagnosticHistory = [];
+const DIAGNOSTIC_HISTORY_LIMIT = 32;
+const DETACHED_THREAD_RUNTIME_NOTICE = new TextEncoder().encode("== Detached Thread End: unmapself TBD");
+scope.onmessage = (event) => {
+    if (event.data.kind === "initialize") {
+        void initialize(event.data);
+        return;
+    }
+    if (!instance || !memory) {
+        scope.postMessage({ kind: "error", message: "WALI pthread worker was started before initialization." });
+        return;
+    }
+    runThread(event.data);
+};
+function runThread(message) {
+    threadId = message.tid;
+    diagnosticHistory.length = 0;
+    writeDiagnostic(`tid ${threadId} started function ${message.functionPointer}`);
+    try {
+        const currentInstance = instance;
+        if (!currentInstance)
+            throw new Error("WALI pthread worker was started before initialization.");
+        const table = currentInstance.exports.__indirect_function_table;
+        const indirect = table instanceof WebAssembly.Table ? table.get(message.functionPointer) : undefined;
+        if (typeof indirect === "function") {
+            indirect(threadId, message.argumentPointer);
+        }
+        else {
+            const start = currentInstance.exports.__wasm_thread_start_libc;
+            if (typeof start !== "function")
+                throw new Error("WALI module does not expose its pthread entry point or function table.");
+            start(threadId, message.argumentPointer);
+        }
+        writeDiagnostic(`tid ${threadId} completed`);
+        coordinatorPort?.postMessage({ kind: "released", slotIndex });
+        scope.postMessage({ kind: "done", tid: threadId });
+    }
+    catch (error) {
+        coordinatorPort?.postMessage({ kind: "released", slotIndex });
+        if (error instanceof ThreadExit) {
+            writeDiagnostic(`tid ${threadId} exited`);
+            scope.postMessage({ kind: "done", tid: threadId });
+        }
+        else {
+            if (fatalState && Atomics.compareExchange(fatalState, 1, -1, slotIndex) === -1) {
+                Atomics.store(fatalState, 0, 1);
+                Atomics.notify(fatalState, 0);
+            }
+            const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+            const recentCalls = diagnosticHistory.join("\n");
+            const errorMessage = `spawn(function=${message.functionPointer}, argument=${message.argumentPointer}): ${detail}`
+                + (recentCalls ? `\nRecent WALI activity:\n${recentCalls}` : "");
+            writeDiagnostic(`tid ${threadId} error: ${errorMessage}`);
+            console.error(`[WALI pthread ${threadId}] ${errorMessage}`);
+            outputPort?.postMessage({ type: "error", message: errorMessage, tid: threadId });
+            scope.postMessage({ kind: "error", message: errorMessage, tid: threadId });
+        }
+    }
+}
+async function initialize(message) {
+    try {
+        memory = message.memory;
+        mmapCursor = message.mmapCursor;
+        sharedMmapRegistry = message.sharedMmapRegistry;
+        fatalState = new Int32Array(message.fatalState);
+        descriptors = message.imports;
+        processPid = message.pid;
+        processExecutablePath = message.executablePath;
+        processArgvBytes = message.argv.map((argument) => new TextEncoder().encode(`${argument}\0`));
+        processCwd = message.cwd;
+        stdioAliasRegistry = new Int32Array(message.stdioAliasRegistry);
+        sharedPipes = message.sharedPipes;
+        childPidAllocator = new Int32Array(message.childPidAllocator);
+        browserProcessPort = message.browserProcessPort;
+        browserProcessPort?.start();
+        outputPort = message.outputPort;
+        outputPort?.start();
+        slotIndex = message.slotIndex;
+        coordinatorPort = message.coordinatorPort;
+        coordinatorPort.onmessage = (event) => runThread(event.data);
+        coordinatorPort.start();
+        diagnosticLength = new Int32Array(message.diagnostic, 0, 1);
+        diagnosticBytes = new Uint8Array(message.diagnostic, Int32Array.BYTES_PER_ELEMENT);
+        stdin = message.stdin ? new SharedWaliStdinReader(message.stdin) : undefined;
+        networkChannel = message.network;
+        filesystemChannel = message.filesystem;
+        const imports = createImports();
+        instance = await WebAssembly.instantiate(message.module, imports);
+        scope.postMessage({ kind: "ready" });
+    }
+    catch (error) {
+        scope.postMessage({ kind: "error", message: error instanceof Error ? error.stack ?? error.message : String(error) });
+    }
+}
+function createImports() {
+    const wali = {};
+    const handlers = threadHandlers();
+    if (networkChannel) {
+        const fallback = { ...handlers };
+        Object.assign(handlers, new WaliNetworkHost(requiredMemory, networkChannel).imports(fallback));
+    }
+    for (const descriptor of descriptors) {
+        if (descriptor.module !== "wali" || descriptor.kind !== "function")
+            continue;
+        const handler = handlers[descriptor.name] ?? (() => {
+            if (!reportedUnsupportedImports.has(descriptor.name)) {
+                reportedUnsupportedImports.add(descriptor.name);
+                console.error(`[WALI pthread ${threadId}] unsupported import: ${descriptor.name}`);
+            }
+            return -38n;
+        });
+        wali[descriptor.name] = (...args) => {
+            const call = `${descriptor.name}(${args.map(String).join(",")})`;
+            writeDiagnostic(call);
+            try {
+                const result = handler(...args);
+                writeDiagnostic(`${call} => ${String(result)}`);
+                return result;
+            }
+            catch (error) {
+                writeDiagnostic(`${call} threw ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+                throw error;
+            }
+        };
+    }
+    return {
+        wali,
+        env: {
+            memory: requiredMemory(),
+            _Unwind_Backtrace: () => 5,
+            _Unwind_FindEnclosingFunction: (programCounter) => programCounter,
+            _Unwind_GetCFA: () => 0,
+        },
+    };
+}
+function threadHandlers() {
+    const systemImports = new WaliSystemHost(requiredMemory, processPid, stdin, fatalState).imports();
+    const ioctl = systemImports.SYS_ioctl;
+    const filesystemClient = filesystemChannel ? new WaliFilesystemClient(filesystemChannel) : undefined;
+    const fileDescriptors = filesystemChannel ? new WaliFileDescriptorTable({
+        cwd: processCwd,
+        stdin: stdin ?? new Uint8Array(),
+        executablePath: processExecutablePath,
+        memory: requiredMemory,
+        emit: (fd, value) => {
+            if (fd !== 1 && fd !== 2)
+                return -9n;
+            const chunk = value.slice();
+            emitThread(fd === 1 ? "stdout" : "stderr", chunk);
+            return BigInt(value.byteLength);
+        },
+        ...(stdioAliasRegistry ? { stdioAliasRegistry } : {}),
+        specialDescriptorMinimum: 10_000,
+        descriptorMaximum: 19_999,
+    }) : undefined;
+    const localFileImports = fileDescriptors?.imports() ?? {};
+    const sharedFileHost = filesystemClient
+        ? new WaliSharedFileDescriptorHost(filesystemClient, stdioAliasRegistry) : undefined;
+    const memoryManager = new WaliMemoryManager(requiredMemory, (fd, offset, length) => sharedFileHost?.readForMapping(fd, offset, length)
+        ?? fileDescriptors?.readForMapping(fd, offset, length), requiredMmapCursor(), (fd) => sharedFileHost?.mappingPath(fd) ?? fileDescriptors?.mappingPath(fd), (path, offset, value) => sharedFileHost?.writeForMapping(path, offset, value)
+        ?? fileDescriptors?.writeForMapping(path, offset, value) ?? false, requiredSharedMmapRegistry());
+    const fileImports = sharedFileHost?.imports(localFileImports) ?? localFileImports;
+    const sharedPipeHost = sharedPipes ? new WaliSharedPipeHost(requiredMemory, sharedPipes) : undefined;
+    const pipeImports = sharedPipeHost?.imports(fileImports) ?? fileImports;
+    const childProcesses = new Map();
+    return {
+        ...systemImports,
+        __init: () => 0,
+        __deinit: () => 0,
+        __proc_exit: () => { throw new ThreadExit(); },
+        __get_init_envfile: () => 0,
+        __cl_get_argc: () => processArgvBytes.length,
+        __cl_get_argv_len: (index) => processArgvBytes[Number(index)]?.byteLength ?? 0,
+        __cl_copy_argv: (pointer, index) => {
+            const value = processArgvBytes[Number(index)];
+            if (!value || Number(pointer) < 0 || Number(pointer) + value.byteLength > bytes().byteLength)
+                return -1;
+            bytes().set(value, Number(pointer));
+            return 0;
+        },
+        __wasm_thread_spawn: (functionPointer, argumentPointer) => spawnNestedThread(Number(functionPointer), Number(argumentPointer)),
+        SYS_exit: () => { throw new ThreadExit(); },
+        SYS_exit_group: (status) => {
+            if (fatalState) {
+                Atomics.store(fatalState, 2, Number(status) & 0xff);
+                Atomics.store(fatalState, 0, 2);
+                Atomics.notify(fatalState, 0);
+            }
+            throw new ThreadExit();
+        },
+        SYS_getpid: () => BigInt(processPid),
+        SYS_getppid: () => 1n,
+        SYS_getpgid: (pid) => processIdentity(Number(pid)),
+        SYS_getsid: (pid) => processIdentity(Number(pid)),
+        SYS_gettid: () => BigInt(threadId),
+        SYS_getuid: () => 1000n,
+        SYS_geteuid: () => 1000n,
+        SYS_getgid: () => 1000n,
+        SYS_getegid: () => 1000n,
+        SYS_set_tid_address: () => BigInt(threadId),
+        SYS_set_robust_list: () => 0n,
+        SYS_sched_yield: () => 0n,
+        SYS_sched_setscheduler: () => 0n,
+        SYS_prctl: () => 0n,
+        SYS_tkill: () => 0n,
+        SYS_rt_sigaction: () => 0n,
+        SYS_rt_sigprocmask: (_how, _set, previous, size) => zeroMemory(Number(previous), Number(size)),
+        SYS_sigaltstack: (_next, previous) => zeroMemory(Number(previous), 12),
+        SYS_mprotect: () => 0n,
+        SYS_munmap: () => 0n,
+        SYS_futex: (address, operation, value, timeout) => futex(Number(address), Number(operation), Number(value), Number(timeout)),
+        SYS_clock_gettime: (clock, pointer) => clockGettime(Number(clock), Number(pointer)),
+        SYS_clock_nanosleep: (clock, flags, request, remaining) => clockNanosleep(Number(clock), Number(flags), Number(request), Number(remaining)),
+        SYS_nanosleep: (request, remaining) => clockNanosleep(1, 0, Number(request), Number(remaining)),
+        SYS_epoll_wait: (_fd, _events, _maximum, timeout) => idlePoll(Number(timeout)),
+        SYS_epoll_pwait: (_fd, _events, _maximum, timeout) => idlePoll(Number(timeout)),
+        SYS_gettimeofday: (pointer) => gettimeofday(Number(pointer)),
+        SYS_getrandom: (pointer, length) => getrandom(Number(pointer), Number(length)),
+        SYS_browser_spawn: (pathname, argvPointer, envPointer, cwdPointer, stdinFd, stdoutFd, stderrFd) => {
+            if (!browserProcessPort || !childPidAllocator || !sharedPipeHost || !filesystemClient)
+                return -38;
+            const executablePath = readCString(Number(pathname));
+            const argv = readCStringArray(Number(argvPointer));
+            if (argv.length === 0)
+                argv.push(executablePath);
+            const env = {};
+            for (const entry of readCStringArray(Number(envPointer))) {
+                const separator = entry.indexOf("=");
+                if (separator > 0)
+                    env[entry.slice(0, separator)] = entry.slice(separator + 1);
+            }
+            const childPid = Atomics.add(childPidAllocator, 0, 1);
+            const process = {
+                control: new SharedArrayBuffer(8 * Int32Array.BYTES_PER_ELEMENT),
+                response: new SharedArrayBuffer(BROWSER_PROCESS_RESPONSE_BYTES),
+                snapshotApplied: false,
+            };
+            const exportPipe = (fd, role) => {
+                const handle = sharedPipeHost.exportBrowserProcessPipe(fd);
+                return handle?.role === role ? retainSharedPipe(handle) : undefined;
+            };
+            const stdin = exportPipe(Number(stdinFd), "reader");
+            const stdout = exportPipe(Number(stdoutFd), "writer");
+            const stderr = exportPipe(Number(stderrFd), "writer");
+            childProcesses.set(childPid, process);
+            try {
+                const message = {
+                    type: "spawn",
+                    pid: childPid,
+                    executablePath,
+                    argv,
+                    env,
+                    cwd: Number(cwdPointer) === 0 ? processCwd : readCString(Number(cwdPointer)),
+                    control: process.control,
+                    response: process.response,
+                    // Mutations are already mirrored continuously by the process
+                    // filesystem coordinator; helper launch must not serialize the VFS.
+                    filesystemPatch: { files: [], removed: [] },
+                    ...(stdin ? { stdin } : {}),
+                    ...(stdout ? { stdout } : {}),
+                    ...(stderr ? { stderr } : {}),
+                };
+                browserProcessPort.postMessage(message);
+                return childPid;
+            }
+            catch {
+                childProcesses.delete(childPid);
+                if (stdin)
+                    closeSharedPipe(stdin);
+                if (stdout)
+                    closeSharedPipe(stdout);
+                if (stderr)
+                    closeSharedPipe(stderr);
+                return -5;
+            }
+        },
+        SYS_wait4: (requestedPid, status, options) => filesystemClient
+            ? waitForChild(childProcesses, filesystemClient, Number(requestedPid), Number(status), Number(options))
+            : -38n,
+        SYS_kill: (requestedPid, signal) => {
+            const childPid = Math.abs(Number(requestedPid));
+            if (!childProcesses.has(childPid) || !browserProcessPort)
+                return -3n;
+            browserProcessPort.postMessage({ type: "kill", pid: childPid, signal: Number(signal) });
+            return 0n;
+        },
+        SYS_setpgid: () => 0n,
+        SYS_open: () => -2n,
+        SYS_openat: () => -2n,
+        SYS_stat: () => -2n,
+        SYS_lstat: () => -2n,
+        SYS_access: () => -2n,
+        SYS_getcwd: (pointer, size) => getcwd(Number(pointer), Number(size)),
+        SYS_mkdir: () => 0n,
+        SYS_mkdirat: () => 0n,
+        SYS_statfs: (_path, pointer) => statfs(Number(pointer)),
+        SYS_fstatfs: (_fd, pointer) => statfs(Number(pointer)),
+        SYS_inotify_init: () => allocateSpecialDescriptor(),
+        SYS_inotify_init1: () => allocateSpecialDescriptor(),
+        SYS_inotify_add_watch: (fd) => localSpecialDescriptors.has(Number(fd)) ? 1n : -9n,
+        SYS_inotify_rm_watch: (fd) => localSpecialDescriptors.has(Number(fd)) ? 0n : -9n,
+        SYS_readlink: (path, pointer, length) => readlink(Number(path), Number(pointer), Number(length)),
+        SYS_read: (fd, pointer, length) => read(Number(fd), Number(pointer), Number(length)),
+        SYS_poll: (pointer, count, timeout) => poll(Number(pointer), Number(count), Number(timeout)),
+        SYS_write: (fd, pointer, length) => write(Number(fd), Number(pointer), Number(length)),
+        SYS_writev: (fd, pointer, count) => writev(Number(fd), Number(pointer), Number(count)),
+        SYS_dup: (fd) => duplicateDescriptor(Number(fd)),
+        SYS_dup2: (fd, target) => duplicateDescriptor(Number(fd), Number(target)),
+        SYS_dup3: (fd, target) => duplicateDescriptor(Number(fd), Number(target)),
+        SYS_close: (fd) => closeDescriptor(Number(fd)),
+        SYS_fcntl: (fd, command, argument) => fcntl(Number(fd), Number(command), Number(BigInt.asIntN(32, BigInt(argument)))),
+        ...memoryManager.imports(),
+        ...pipeImports,
+        SYS_ioctl: (fd, request, argument) => sharedPipeHost?.ioctl(Number(fd), Number(request))
+            ?? fileDescriptors?.ioctl(Number(fd), Number(request))
+            ?? ioctl(stdioDescriptor(Number(fd)) ?? Number(fd), request, argument),
+    };
+}
+function processIdentity(pid) {
+    return pid === 0 || pid === processPid ? BigInt(processPid) : -3n;
+}
+function spawnNestedThread(functionPointer, argumentPointer) {
+    if (!coordinatorPort)
+        return -11;
+    const response = new Int32Array(new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT));
+    coordinatorPort.postMessage({ kind: "spawn", functionPointer, argumentPointer, response: response.buffer });
+    Atomics.wait(response, 0, 0);
+    return Atomics.load(response, 1);
+}
+function writeDiagnostic(message) {
+    if (!diagnosticLength || !diagnosticBytes)
+        return;
+    diagnosticHistory.push(message);
+    if (diagnosticHistory.length > DIAGNOSTIC_HISTORY_LIMIT)
+        diagnosticHistory.shift();
+    const encoded = new TextEncoder().encode(diagnosticHistory.join("\n")).subarray(-diagnosticBytes.byteLength);
+    diagnosticBytes.fill(0);
+    diagnosticBytes.set(encoded);
+    Atomics.store(diagnosticLength, 0, encoded.byteLength);
+}
+function readlink(pathPointer, outputPointer, length) {
+    if (readCString(pathPointer) !== "/proc/self/exe")
+        return -2n;
+    const value = new TextEncoder().encode(processExecutablePath).subarray(0, Math.max(0, length));
+    bytes().set(value, outputPointer);
+    return BigInt(value.byteLength);
+}
+function getcwd(pointer, size) {
+    const value = new TextEncoder().encode(`${processCwd}\0`);
+    if (size < value.byteLength)
+        return -34n;
+    bytes().set(value, pointer);
+    return BigInt(value.byteLength);
+}
+function statfs(pointer) {
+    if (pointer < 0 || pointer + 120 > bytes().byteLength)
+        return -14n;
+    bytes().fill(0, pointer, pointer + 120);
+    view().setBigInt64(pointer, 0x01021994n, true);
+    view().setBigInt64(pointer + 8, 4096n, true);
+    view().setBigUint64(pointer + 16, 262144n, true);
+    view().setBigUint64(pointer + 24, 196608n, true);
+    view().setBigUint64(pointer + 32, 196608n, true);
+    view().setBigUint64(pointer + 40, 1048576n, true);
+    view().setBigUint64(pointer + 48, 1048000n, true);
+    view().setBigUint64(pointer + 64, 255n, true);
+    view().setBigUint64(pointer + 72, 4096n, true);
+    return 0n;
+}
+function read(fd, pointer, length) {
+    if (stdioDescriptor(fd) !== 0)
+        return -9n;
+    if (!stdin)
+        return 0n;
+    const chunk = stdin.read(length);
+    bytes().set(chunk, pointer);
+    return BigInt(chunk.byteLength);
+}
+function poll(pointer, count, timeout) {
+    if (!Number.isSafeInteger(count) || count < 0 || !Number.isSafeInteger(timeout))
+        return -22n;
+    const scan = () => {
+        let ready = 0;
+        for (let index = 0; index < count; index += 1) {
+            const offset = pointer + index * 8;
+            const fd = view().getInt32(offset, true);
+            const stdio = stdioDescriptor(fd);
+            const events = view().getInt16(offset + 4, true);
+            let returned = 0;
+            if (stdio === 0 && (events & 1) && stdin?.poll())
+                returned |= 1;
+            if ((stdio === 1 || stdio === 2) && (events & 4))
+                returned |= 4;
+            if (stdio === undefined)
+                returned |= 0x20;
+            view().setInt16(offset + 6, returned, true);
+            if (returned !== 0)
+                ready += 1;
+        }
+        return ready;
+    };
+    const ready = scan();
+    if (ready !== 0 || timeout === 0)
+        return BigInt(ready);
+    stdin?.wait(timeout);
+    return BigInt(scan());
+}
+function readCString(pointer) {
+    const memory = bytes();
+    const end = memory.indexOf(0, pointer);
+    if (pointer < 0 || end < pointer || end - pointer > 1_048_576)
+        throw new WebAssembly.RuntimeError("WALI string is not null terminated.");
+    return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(memory.subarray(pointer, end)));
+}
+function readCStringArray(pointer) {
+    if (pointer === 0)
+        return [];
+    const values = [];
+    for (let index = 0; index < 65_536; index += 1) {
+        const offset = pointer + index * 4;
+        if (offset < 0 || offset + 4 > bytes().byteLength)
+            throw new WebAssembly.RuntimeError("WALI process string array is out of bounds.");
+        const item = view().getUint32(offset, true);
+        if (item === 0)
+            return values;
+        values.push(readCString(item));
+    }
+    throw new WebAssembly.RuntimeError("WALI process string array is not terminated.");
+}
+function waitForChild(children, filesystem, requestedPid, statusPointer, options) {
+    let childPid;
+    let process;
+    if (requestedPid === -1) {
+        const entry = children.entries().next().value;
+        if (!entry)
+            return -10n;
+        [childPid, process] = entry;
+    }
+    else {
+        const exact = children.get(requestedPid);
+        if (!exact)
+            return -10n;
+        childPid = requestedPid;
+        process = exact;
+    }
+    const control = new Int32Array(process.control);
+    if (Atomics.load(control, 0) === 0) {
+        if ((options & 1) !== 0)
+            return 0n;
+        while (Atomics.load(control, 0) === 0)
+            Atomics.wait(control, 0, 0, 1_000);
+    }
+    if (!process.snapshotApplied) {
+        process.snapshotApplied = true;
+        const patch = decodeProcessSnapshot(process);
+        if (patch)
+            applyProcessFilesystemPatch(filesystem, patch);
+    }
+    if (statusPointer !== 0) {
+        if (statusPointer < 0 || statusPointer + 4 > bytes().byteLength)
+            return -14n;
+        view().setInt32(statusPointer, (Atomics.load(control, 1) & 0xff) << 8, true);
+    }
+    children.delete(childPid);
+    return BigInt(childPid);
+}
+function requiredMemory() {
+    if (!memory)
+        throw new Error("WALI pthread memory is unavailable.");
+    return memory;
+}
+function requiredMmapCursor() {
+    if (!mmapCursor)
+        throw new Error("WALI pthread mmap cursor is unavailable.");
+    return mmapCursor;
+}
+function requiredSharedMmapRegistry() {
+    if (!sharedMmapRegistry)
+        throw new Error("WALI pthread shared mmap registry is unavailable.");
+    return sharedMmapRegistry;
+}
+function bytes() { return new Uint8Array(requiredMemory().buffer); }
+function view() { return new DataView(requiredMemory().buffer); }
+function zeroMemory(pointer, length) {
+    if (pointer !== 0)
+        bytes().fill(0, pointer, pointer + length);
+    return 0n;
+}
+function futex(address, operation, value, timeoutPointer) {
+    if (address % 4 !== 0)
+        return -22n;
+    const words = new Int32Array(requiredMemory().buffer);
+    const index = address / 4;
+    const command = operation & 0x7f;
+    if (command === 1 || command === 10)
+        return BigInt(Atomics.notify(words, index, Math.max(0, value)));
+    if (command !== 0 && command !== 9)
+        return -38n;
+    let timeout;
+    if (timeoutPointer !== 0) {
+        const seconds = view().getBigInt64(timeoutPointer, true);
+        const nanoseconds = view().getBigInt64(timeoutPointer + 8, true);
+        if (seconds < 0n || nanoseconds < 0n || nanoseconds >= 1000000000n)
+            return -22n;
+        const milliseconds = Number(seconds * 1000n + nanoseconds / 1000000n);
+        timeout = command === 9
+            ? Math.max(0, milliseconds - ((operation & 0x100) !== 0 ? Date.now() : performance.now()))
+            : milliseconds;
+    }
+    const result = Atomics.wait(words, index, value, timeout);
+    return result === "not-equal" ? -11n : result === "timed-out" ? -110n : 0n;
+}
+function clockGettime(clock, pointer) {
+    const milliseconds = clock === 0 ? performance.timeOrigin + performance.now() : performance.now();
+    const nanoseconds = BigInt(Math.floor(milliseconds * 1_000_000));
+    view().setBigInt64(pointer, nanoseconds / 1000000000n, true);
+    view().setBigInt64(pointer + 8, nanoseconds % 1000000000n, true);
+    return 0n;
+}
+function gettimeofday(pointer) {
+    if (pointer !== 0) {
+        const microseconds = BigInt(Date.now()) * 1000n;
+        view().setBigInt64(pointer, microseconds / 1000000n, true);
+        view().setBigInt64(pointer + 8, microseconds % 1000000n, true);
+    }
+    return 0n;
+}
+function clockNanosleep(clock, flags, request, remaining) {
+    if (![0, 1, 4].includes(clock) || (flags & ~1) !== 0 || request < 0 || request + 16 > bytes().byteLength)
+        return -22n;
+    const seconds = view().getBigInt64(request, true);
+    const nanoseconds = view().getBigInt64(request + 8, true);
+    if (seconds < 0n || nanoseconds < 0n || nanoseconds >= 1000000000n)
+        return -22n;
+    let duration = Number(seconds * 1000n + nanoseconds / 1000000n);
+    if (flags & 1)
+        duration = Math.max(0, duration - (clock === 0 ? Date.now() : performance.now()));
+    Atomics.wait(sleepWord, 0, 0, duration);
+    if (remaining !== 0)
+        bytes().fill(0, remaining, remaining + 16);
+    return 0n;
+}
+function idlePoll(timeout) {
+    if (timeout > 0)
+        Atomics.wait(sleepWord, 0, 0, timeout);
+    return 0n;
+}
+function getrandom(pointer, length) {
+    if (!Number.isSafeInteger(length) || length < 0 || pointer < 0 || pointer + length > bytes().byteLength)
+        return -22n;
+    const destination = bytes().subarray(pointer, pointer + length);
+    for (let offset = 0; offset < destination.byteLength; offset += 65_536) {
+        const random = new Uint8Array(Math.min(65_536, destination.byteLength - offset));
+        crypto.getRandomValues(random);
+        destination.set(random, offset);
+    }
+    return BigInt(length);
+}
+function write(fd, pointer, length) {
+    const stdio = stdioDescriptor(fd);
+    if (stdio !== 1 && stdio !== 2)
+        return -9n;
+    const chunk = bytes().slice(pointer, pointer + length);
+    emitThread(stdio === 1 ? "stdout" : "stderr", chunk);
+    return BigInt(length);
+}
+function emitThread(type, chunk) {
+    if (isWaliRuntimeNotice(chunk))
+        return;
+    if (outputPort) {
+        // A fatal pthread can wake and terminate the root runtime before an
+        // asynchronous MessagePort delivery reaches the terminal. Wait until the
+        // browser-side owner has consumed this write so panic output and ordinary
+        // stdout/stderr cannot be dropped during process teardown.
+        const ack = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+        outputPort.postMessage({ type, bytes: chunk, ack: ack.buffer }, [chunk.buffer]);
+        Atomics.wait(ack, 0, 0, 5_000);
+    }
+    else {
+        scope.postMessage({ kind: type, bytes: chunk }, [chunk.buffer]);
+    }
+}
+function writev(fd, pointer, count) {
+    if (!Number.isSafeInteger(count) || count < 0 || count > 65_536)
+        return -22n;
+    const stdio = stdioDescriptor(fd);
+    if (stdio !== 1 && stdio !== 2)
+        return -9n;
+    const chunks = [];
+    let total = 0;
+    for (let index = 0; index < count; index += 1) {
+        const offset = pointer + index * 8;
+        const chunkPointer = view().getUint32(offset, true);
+        const length = view().getUint32(offset + 4, true);
+        if (chunkPointer + length > bytes().byteLength)
+            return -14n;
+        chunks.push(bytes().slice(chunkPointer, chunkPointer + length));
+        total += length;
+    }
+    const combined = new Uint8Array(total);
+    let destination = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, destination);
+        destination += chunk.byteLength;
+    }
+    // The WALI libc currently prints this implementation note whenever a
+    // detached pthread exits. It is runtime noise, not process stdout, and an
+    // out-of-band write corrupts diff-based TUIs such as ratatui.
+    if (isWaliRuntimeNotice(combined)) {
+        return BigInt(total);
+    }
+    emitThread(stdio === 1 ? "stdout" : "stderr", combined);
+    return BigInt(total);
+}
+function isWaliRuntimeNotice(value) {
+    let length = value.byteLength;
+    while (length > 0 && (value[length - 1] === 0x0a || value[length - 1] === 0x0d))
+        length -= 1;
+    if (length === DETACHED_THREAD_RUNTIME_NOTICE.byteLength
+        && DETACHED_THREAD_RUNTIME_NOTICE.every((byte, index) => value[index] === byte))
+        return true;
+    if (length < 31 || length > 64 || value[0] !== 0x49)
+        return false;
+    const text = new TextDecoder().decode(value.subarray(0, length));
+    return /^Invalid syscall var call -- NR \d+$/u.test(text);
+}
+function stdioDescriptor(fd) {
+    if (fd >= 0 && fd <= 2)
+        return fd;
+    const local = localStdioAliases.get(fd);
+    if (local !== undefined)
+        return local;
+    if (!stdioAliasRegistry || fd < 0 || fd >= stdioAliasRegistry.length)
+        return;
+    const shared = Atomics.load(stdioAliasRegistry, fd);
+    return shared === 0 || shared === 1 || shared === 2 ? shared : undefined;
+}
+function duplicateDescriptor(fd, target, minimum = 3) {
+    const stdio = stdioDescriptor(fd);
+    if (stdio === undefined)
+        return -9n;
+    const next = target ?? allocateLocalDescriptor(minimum);
+    if (!Number.isSafeInteger(next) || next < 0 || next > 65_535)
+        return -9n;
+    if (next !== fd)
+        localStdioAliases.set(next, stdio);
+    return BigInt(next);
+}
+function allocateLocalDescriptor(minimum) {
+    nextLocalDescriptor = Math.max(nextLocalDescriptor, minimum);
+    while (nextLocalDescriptor <= 65_535 && (stdioDescriptor(nextLocalDescriptor) !== undefined || localSpecialDescriptors.has(nextLocalDescriptor))) {
+        nextLocalDescriptor += 1;
+    }
+    return nextLocalDescriptor++;
+}
+function allocateSpecialDescriptor() {
+    const fd = allocateLocalDescriptor(3);
+    localSpecialDescriptors.add(fd);
+    return BigInt(fd);
+}
+function closeDescriptor(fd) {
+    if (fd >= 0 && fd <= 2)
+        return 0n;
+    if (localSpecialDescriptors.delete(fd))
+        return 0n;
+    return localStdioAliases.delete(fd) ? 0n : -9n;
+}
+function fcntl(fd, command, argument) {
+    if (localSpecialDescriptors.has(fd)) {
+        if (command === 1 || command === 2 || command === 4)
+            return 0n;
+        if (command === 3)
+            return 0n;
+        return -22n;
+    }
+    if (stdioDescriptor(fd) === undefined)
+        return -9n;
+    if (command === 0 || command === 1030)
+        return duplicateDescriptor(fd, undefined, Math.max(argument, 3));
+    if (command === 1 || command === 2 || command === 4)
+        return 0n;
+    if (command === 3)
+        return 2n;
+    return -22n;
+}
+//# sourceMappingURL=thread-worker.js.map