@volter/browser-wali 0.1.191 → 0.1.193

package/dist/nanosleep.d.ts

@@ -0,0 +1,9 @@
+interface SleepHooks {
+    prepare?(): void;
+    checkFailure?(): void;
+    /** Existing root pthread-failure cadence, not a guest deadline. */
+    failureCheckInterval?: number;
+}
+export declare function waliClockNanosleep(memory: () => WebAssembly.Memory, clock: number, flags: number, request: number, remaining: number, hooks?: SleepHooks): bigint;
+export {};
+//# sourceMappingURL=nanosleep.d.ts.map

package/dist/nanosleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nanosleep.d.ts","sourceRoot":"","sources":["../src/nanosleep.ts"],"names":[],"mappings":"AAQA,UAAU,UAAU;IAClB,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB,YAAY,CAAC,IAAI,IAAI,CAAC;IACtB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAKD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAChF,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,GAAE,UAAe,GAAG,MAAM,CAsDnF"}

package/dist/nanosleep.js

@@ -0,0 +1,74 @@
+// Clock validation and conversion extend the Emscripten clock rules in
+// clocks.ts (MIT/NCSA, 862dc0d48acc4134a0088d27ac8f5dd18baba1cd).
+// Linux nanosleep/clock_nanosleep interruption and remainder rules live here,
+// behind syscalls; programs keep musl. No Linux implementation is copied.
+import { monotonicMilliseconds, realtimeMilliseconds } from "./monotonic-clock.js";
+import { hostWait } from "./host-idle.js";
+import { waliSignalWaitState } from "./signal-interruption.js";
+let sleepWord;
+const nowNanoseconds = (clock) => BigInt(Math.round((clock === 0 ? realtimeMilliseconds() : monotonicMilliseconds()) * 1_000_000));
+export function waliClockNanosleep(memory, clock, flags, request, remaining, hooks = {}) {
+    // RAW/coarse clocks do not provide Linux nsleep. CPU, alarm, boottime and
+    // TAI clocks require accounting/permissions or clock state we do not have.
+    if (clock !== 0 && clock !== 1)
+        return clock >= 2 && clock <= 11 && clock !== 3 ? -95n : -22n;
+    const range = (pointer) => Number.isSafeInteger(pointer) && pointer > 0
+        && pointer + 16 <= memory().buffer.byteLength;
+    if (!range(request))
+        return -14n;
+    const input = new DataView(memory().buffer);
+    const seconds = input.getBigInt64(request, true), nanoseconds = input.getBigInt64(request + 8, true);
+    if (seconds < 0n || nanoseconds < 0n || nanoseconds >= 1000000000n)
+        return -22n;
+    const absolute = Boolean(flags & 1); // Linux nsleep interprets TIMER_ABSTIME.
+    const time = seconds * 1000000000n + nanoseconds;
+    const elapsedClock = absolute ? clock : 1;
+    const deadline = absolute ? time : nowNanoseconds(elapsedClock) + time;
+    if (deadline <= nowNanoseconds(elapsedClock))
+        return 0n;
+    // A page cannot implement a synchronous blocking syscall. Never pretend it
+    // slept when the runtime is used directly outside a worker.
+    if ("document" in globalThis)
+        return -38n;
+    if (deadline - nowNanoseconds(elapsedClock) >= 1000000n)
+        hooks.prepare?.();
+    for (;;) {
+        hooks.checkFailure?.();
+        const left = deadline - nowNanoseconds(elapsedClock);
+        if (left <= 0n)
+            return 0n;
+        let state = waliSignalWaitState();
+        if (state.pending) {
+            // Delivery distinguishes a caught signal from a default-ignored one.
+            // The interval left is sampled before the handler consumes guest time.
+            if (state.interruptSleep?.() ?? true) {
+                if (!absolute && remaining !== 0) {
+                    if (!range(remaining))
+                        return -14n;
+                    const output = new DataView(memory().buffer);
+                    output.setBigInt64(remaining, left / 1000000000n, true);
+                    output.setBigInt64(remaining + 8, left % 1000000000n, true);
+                }
+                return -4n;
+            }
+            state = waliSignalWaitState();
+        }
+        const signal = state.guards[0];
+        const word = signal?.words ?? (sleepWord ??= new Int32Array(new SharedArrayBuffer(4)));
+        const index = signal?.index ?? 0, generation = signal?.value ?? Atomics.load(word, index);
+        const afterDelivery = deadline - nowNanoseconds(elapsedClock);
+        if (afterDelivery <= 0n)
+            return 0n;
+        const duration = Number(afterDelivery) / 1_000_000;
+        // Preserve the existing root fatal-thread observation cadence. Pthreads
+        // need no such poll and wait directly for signal generation or deadline.
+        const wait = Math.min(duration, hooks.failureCheckInterval ?? Infinity);
+        hostWait(word, index, generation, wait, undefined, {
+            resource: "clock", deadline: Date.now() + duration,
+            guards: state.guards, interrupt: { words: word, index },
+        });
+        // Generation wakes include ignored/masked signals and owner work; only a
+        // handler/default termination interrupts. Spurious wakes recheck deadline.
+    }
+}
+//# sourceMappingURL=nanosleep.js.map

package/dist/nanosleep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nanosleep.js","sourceRoot":"","sources":["../src/nanosleep.ts"],"names":[],"mappings":"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"}

package/dist/network-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-host.d.ts","sourceRoot":"","sources":["../src/network-host.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,oBAAoB,EAG1B,MAAM,uBAAuB,CAAC;AAmF/B,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG;IAC3E,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;CAC1D,CA42CA"}
+{"version":3,"file":"network-host.d.ts","sourceRoot":"","sources":["../src/network-host.ts"],"names":[],"mappings":"AAOA,OAAO,EAKL,KAAK,oBAAoB,EAG1B,MAAM,uBAAuB,CAAC;AAqF/B,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG;IAC3E,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;CAC1D,CAs7CA"}

package/dist/network-host.js

@@ -5,7 +5,7 @@
 // process ownership and port arbitration remain this kernel's adapters.
 import { WaliEpollSet } from "./epoll-ready.js";
 import { waliEpollNestingError } from "./epoll-nesting.js";
-import { NETWORK_FD_MIN, NETWORK_PAYLOAD_BYTES, NetworkOperation, } from "./network-protocol.js";
+import { NETWORK_FD_MIN, NETWORK_PAYLOAD_BYTES, NETWORK_RESPONSE_NO_RESTART, NetworkOperation, } from "./network-protocol.js";
 import { WaliChildProcesses } from "./child-processes.js";
 import { WaliSignals } from "./signals.js";
 import { pollWaliSharedPipeState, waliSharedPipeGeneration } from "./shared-pipes.js";
@@ -157,11 +157,12 @@ export function createWaliNetworkSession(reply) {
         // Reaping and completed I/O are irreversible. Claim blocking requests
         // before it starts, so transport cancellation cannot lose status or bytes.
         const operation = Atomics.load(control, 1);
-        const claimed = [NetworkOperation.ChildWait, NetworkOperation.PollMany, NetworkOperation.EpollWait, NetworkOperation.Receive].includes(operation)
+        const claimed = [NetworkOperation.ChildWait, NetworkOperation.PollMany, NetworkOperation.EpollWait, NetworkOperation.Receive, NetworkOperation.Accept].includes(operation)
             || (operation === NetworkOperation.Send && sockets.get(Atomics.load(control, 5))?.kind === "event");
         if (claimed && Atomics.compareExchange(control, 0, requestId, -requestId) !== requestId)
             return;
         let result = -38;
+        let restartable = true;
         let output = new Uint8Array();
         let checkedActivity = activity ? Atomics.load(activity, 0) : 0;
         const parked = (state) => {
@@ -178,7 +179,9 @@ export function createWaliNetworkSession(reply) {
             const inputLength = Atomics.load(control, 3);
             const args = Array.from({ length: 10 }, (_, index) => Atomics.load(control, 5 + index));
             const input = payload.slice(0, inputLength);
-            ({ result, output } = await operate(operation, args, input, process, parked));
+            const response = await operate(operation, args, input, process, parked);
+            ({ result, output } = response);
+            restartable = response.restartable !== false;
             if ([NetworkOperation.EpollControl, NetworkOperation.Send, NetworkOperation.Receive,
                 NetworkOperation.Close, NetworkOperation.Shutdown, NetworkOperation.TimerFdSetTime].includes(operation))
                 notifyDescriptors();
@@ -202,6 +205,7 @@ export function createWaliNetworkSession(reply) {
             payload.set(output);
         Atomics.store(control, 2, result);
         Atomics.store(control, 4, output.byteLength);
+        Atomics.store(control, NETWORK_RESPONSE_NO_RESTART, restartable ? 0 : 1);
         Atomics.store(control, 0, requestId + 1);
         Atomics.notify(control, 0);
     }
@@ -293,7 +297,7 @@ export function createWaliNetworkSession(reply) {
         if (operation === NetworkOperation.Listen)
             return scalar(await listenSocket(socket, args[1]));
         if (operation === NetworkOperation.Accept)
-            return acceptSocket(socket, args[1]);
+            return acceptSocket(socket, args[1], signalMask(args[2] ?? 0, args[3] ?? 0), parked);
         if (operation === NetworkOperation.Send) {
             if ((args[1] & ~(0x40 | 0x4000)) !== 0)
                 return scalar(-95);
@@ -320,8 +324,7 @@ export function createWaliNetworkSession(reply) {
         if (operation === NetworkOperation.GetSocketOption)
             return socketOption(socket, args[1], args[2]);
         if (operation === NetworkOperation.SetSocketOption) {
-            // Never claim to apply an option that the relay transport cannot honor.
-            return scalar(socket.kind === "event" || socket.kind === "timer" ? -88 : -92);
+            return scalar(setSocketOption(socket, args[1], args[2], input));
         }
         if (operation === NetworkOperation.Duplicate)
             return scalar(duplicateSocket(socket));
@@ -392,7 +395,9 @@ export function createWaliNetworkSession(reply) {
             const done = () => { if (timer !== undefined)
                 clearTimeout(timer); descriptorWaiters.delete(done); resolve(); };
             descriptorWaiters.add(done);
-            const timer = Number.isFinite(delay) ? setTimeout(done, Math.max(0, delay)) : undefined;
+            // Browser timers use signed-int32 milliseconds. A long guest deadline is
+            // rechecked after each interval; this cap is not an I/O watchdog.
+            const timer = Number.isFinite(delay) ? setTimeout(done, Math.min(0x7fff_ffff, Math.max(0, delay))) : undefined;
         });
     }
     function duplicateEpoll(fd, minimum, closeOnExec = false) {
@@ -715,7 +720,6 @@ export function createWaliNetworkSession(reply) {
                 listening: false,
                 backlog: 0,
                 pending: [],
-                acceptWaiters: [],
                 peerClosed: false,
             };
         }
@@ -951,32 +955,48 @@ export function createWaliNetworkSession(reply) {
         listenersByPort.set(socket.bound.port, socket);
         return 0;
     }
-    async function acceptSocket(socket, flags) {
+    async function acceptSocket(socket, flags, mask, parked) {
         if (socket.kind !== "tcp" || !socket.listening)
             return scalar(-22);
         if ((flags & ~0x8_0800) !== 0)
             return scalar(-22);
-        let accepted = socket.pending.shift();
-        if (!accepted && socket.nonblocking)
-            return scalar(-11);
-        if (!accepted) {
-            accepted = await new Promise((resolve) => socket.acceptWaiters.push(resolve));
-        }
-        if (!accepted)
-            return scalar(-9);
-        accepted.nonblocking = Boolean(flags & 0x800);
-        let fd;
+        const deadline = receiveDeadline(socket);
+        activeIO.set(socket, (activeIO.get(socket) ?? 0) + 1);
         try {
-            fd = takeFd();
+            for (;;) {
+                if (disposed || socket.closed)
+                    return scalar(-9);
+                const accepted = socket.pending.shift();
+                if (accepted) {
+                    accepted.nonblocking = Boolean(flags & 0x800);
+                    let fd;
+                    try {
+                        fd = takeFd();
+                    }
+                    catch (error) {
+                        socket.pending.unshift(accepted);
+                        throw error;
+                    }
+                    sockets.set(fd, accepted);
+                    socketDescriptorFlags.set(fd, flags & 0x80000 ? 1 : 0);
+                    return { result: fd, output: socketAddress(accepted.domain, accepted.domain === 10 ? "::" : "0.0.0.0", 0) };
+                }
+                if (socket.nonblocking || monotonicMilliseconds() >= deadline)
+                    return scalar(-11);
+                if (signals && (signals.pending() & ~mask) !== 0n)
+                    return { ...scalar(-4), restartable: deadline === Infinity };
+                parked(2); // listener ingress or configured deadline can wake the call
+                try {
+                    await waitForDescriptorChange(deadline - monotonicMilliseconds());
+                }
+                finally {
+                    parked(0);
+                }
+            }
         }
-        catch (error) {
-            socket.pending.unshift(accepted);
-            throw error;
+        finally {
+            releaseActiveIO(socket);
         }
-        sockets.set(fd, accepted);
-        socketDescriptorFlags.set(fd, flags & 0x80000 ? 1 : 0);
-        // The ingress wire does not yet carry the remote endpoint. Do not invent it.
-        return { result: fd, output: socketAddress(accepted.domain, accepted.domain === 10 ? "::" : "0.0.0.0", 0) };
     }
     function requestLoopbackListen(port) {
         if (!loopbackPort)
@@ -1058,17 +1078,14 @@ export function createWaliNetworkSession(reply) {
             listening: false,
             backlog: 0,
             pending: [],
-            acceptWaiters: [],
             loopbackConnectionId: message.connectionId,
             peerClosed: false,
             ...(listener.bound ? { bound: listener.bound } : {}),
+            // Clone listener options when the connection is created, not at accept.
+            ...(listener.receiveTimeoutMicros !== undefined ? { receiveTimeoutMicros: listener.receiveTimeoutMicros } : {}),
         };
         loopbackConnections.set(message.connectionId, accepted);
-        const waiter = listener.acceptWaiters.shift();
-        if (waiter)
-            waiter(accepted);
-        else
-            listener.pending.push(accepted);
+        listener.pending.push(accepted);
         notifyDescriptors();
     }
     function postLoopback(message) {
@@ -1183,35 +1200,90 @@ export function createWaliNetworkSession(reply) {
             }
         }
     }
-    /** A readiness wait, not a polling loop or a transport watchdog. */
+    /** Linux recv(2) WAITALL supplements the Emscripten socket rules (L/M).
+     * A readiness wait, not a polling loop or a transport watchdog. Only one
+     * pinned description participates, including while an alias is closed.
+     */
     async function receiveSocketBlocking(socket, maximum, flags, mask, parked) {
+        const MSG_PEEK = 2, MSG_DONTWAIT = 0x40, MSG_WAITALL = 0x100;
         if (maximum < 0)
             return scalar(-22);
-        // Receive only supported flags; no false claim of WAITALL/ancillary/OOB.
-        if (flags & ~(2 | 0x40))
+        if (flags & ~(MSG_PEEK | MSG_DONTWAIT | MSG_WAITALL))
+            return scalar(-95);
+        const waitAll = Boolean(flags & MSG_WAITALL) && (socket.kind === "tcp" || socket.kind === "local");
+        if ((flags & MSG_WAITALL) && socket.kind !== "dns" && !waitAll)
             return scalar(-95);
-        // Linux I/O pins the open description, even if another thread closes
-        // the descriptor while the call is waiting. Close transport only at last use.
+        if (waitAll && maximum > NETWORK_PAYLOAD_BYTES)
+            return scalar(-95);
+        const target = Math.min(maximum, NETWORK_PAYLOAD_BYTES);
+        const peek = Boolean(flags & MSG_PEEK);
+        const chunks = waitAll && !peek ? [] : undefined;
+        let collected = 0;
+        let peeked;
+        const partial = (fallback) => {
+            if (peeked)
+                return peeked;
+            if (!collected)
+                return fallback;
+            if (chunks.length === 1)
+                return { result: collected, output: chunks[0] };
+            const output = new Uint8Array(collected);
+            let offset = 0;
+            for (const chunk of chunks) {
+                output.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            return { result: collected, output };
+        };
+        const deadline = receiveDeadline(socket);
         activeIO.set(socket, (activeIO.get(socket) ?? 0) + 1);
         try {
             for (;;) {
                 if (disposed)
-                    return scalar(-9);
-                // A stream may return fewer bytes than requested. Bound consumption to
-                // this channel's output capacity so a large read cannot lose queued bytes.
-                const response = receiveSocket(socket, Math.min(maximum, NETWORK_PAYLOAD_BYTES), flags);
-                if (response.result !== -11 || socket.nonblocking || Boolean(flags & 0x40))
-                    return response;
-                if (signals && (signals.pending() & ~mask) !== 0n)
-                    return scalar(-4);
-                let delay = Infinity;
+                    return partial(scalar(-9));
+                // Return bytes already read without clearing a later socket error.
+                // The next receive/SO_ERROR must still be able to observe that error.
+                if (collected > 0 && socket.kind === "tcp" && socket.error)
+                    return partial(scalar(0));
+                const response = receiveSocket(socket, target - collected, flags);
+                if (response.result > 0) {
+                    if (!waitAll)
+                        return response;
+                    const ended = socket.kind === "local" ? socket.closed || socket.readShutdown
+                        : socket.kind === "tcp" && (socket.closed || socket.peerClosed || socket.error !== 0);
+                    if (peek) {
+                        // Resample the queue from its beginning; never concatenate a second
+                        // copy of bytes a previous peek deliberately left queued.
+                        peeked = response;
+                        if (response.result >= target || ended)
+                            return response;
+                    }
+                    else {
+                        chunks.push(response.output);
+                        collected += response.result;
+                        if (collected >= target || ended)
+                            return partial(response);
+                    }
+                }
+                else if (response.result !== -11)
+                    return partial(response);
+                // WAITALL does not turn a nonblocking descriptor into a blocking one.
+                if (socket.nonblocking || Boolean(flags & MSG_DONTWAIT))
+                    return partial(response);
+                if (monotonicMilliseconds() >= deadline)
+                    return partial(scalar(-11));
+                if (signals && (signals.pending() & ~mask) !== 0n) {
+                    const response = partial(scalar(-4));
+                    return response.result === -4 ? { ...response, restartable: deadline === Infinity } : response;
+                }
+                let delay = deadline - monotonicMilliseconds();
                 if (socket.kind === "timer" && socket.deadlineNanoseconds !== undefined) {
-                    delay = Number(timerRemaining(socket)) / 1_000_000;
+                    delay = Math.min(delay, Number(timerRemaining(socket)) / 1_000_000);
                 }
-                parked(socket.kind === "tcp" || socket.kind === "dns"
+                parked(deadline !== Infinity || socket.kind === "tcp" || socket.kind === "dns"
                     || (socket.kind === "timer" && socket.deadlineNanoseconds !== undefined) ? 2 : 1);
-                // The owner installs the wake before yielding; events arriving while the
-                // request is being serviced cannot slip between the scan and subscription.
+                // Install the wake before yielding; arrivals cannot slip between the
+                // scan and subscription. Signals use the existing caller-mask guard.
                 try {
                     await waitForDescriptorChange(delay);
                 }
@@ -1387,6 +1459,30 @@ export function createWaliNetworkSession(reply) {
         socketDescriptorFlags.set(fd, closeOnExec ? 1 : 0);
         return fd;
     }
+    /** Linux socket(7) timeouts use the existing owner, not transport watchdogs. */
+    function receiveDeadline(socket) {
+        const timeout = socket.kind === "event" || socket.kind === "timer" ? undefined : socket.receiveTimeoutMicros;
+        return timeout === undefined ? Infinity : monotonicMilliseconds() + Number(timeout) / 1000;
+    }
+    function setSocketOption(socket, level, name, input) {
+        if (socket.kind === "event" || socket.kind === "timer")
+            return -88;
+        if (level !== 1 || (name !== 20 && name !== 66))
+            return -92;
+        if (input.byteLength < 16)
+            return -22;
+        const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+        const seconds = view.getBigInt64(0, true), micros = view.getBigInt64(8, true);
+        if (micros < 0n || micros >= 1000000n)
+            return -33; // EDOM, sock_set_timeout
+        if (seconds < 0n)
+            socket.receiveTimeoutMicros = 0n;
+        else if (seconds === 0n && micros === 0n)
+            delete socket.receiveTimeoutMicros;
+        else
+            socket.receiveTimeoutMicros = seconds * 1000000n + micros;
+        return 0;
+    }
     // libsyscall.js only supports SO_ERROR. Additional read-only Linux queries
     // below expose actual owner state, never a fabricated successful setting.
     function socketOption(socket, level, name) {
@@ -1394,6 +1490,13 @@ export function createWaliNetworkSession(reply) {
             return scalar(-88);
         if (level !== 1)
             return scalar(-92);
+        if (name === 20 || name === 66) {
+            const duration = socket.receiveTimeoutMicros ?? 0n;
+            const output = new Uint8Array(16), view = new DataView(output.buffer);
+            view.setBigInt64(0, duration / 1000000n, true);
+            view.setBigInt64(8, duration % 1000000n, true);
+            return { result: 0, output };
+        }
         let value;
         switch (name) {
             case 3:
@@ -1460,8 +1563,6 @@ export function createWaliNetworkSession(reply) {
             if (socket.listening && socket.bound) {
                 listenersByPort.delete(socket.bound.port);
                 postLoopback({ type: "unlisten", port: socket.bound.port });
-                for (const resolve of socket.acceptWaiters.splice(0))
-                    resolve(undefined);
                 for (const accepted of socket.pending.splice(0))
                     closeSocket(accepted);
             }