@bytecodealliance/preview2-shim 0.22.0 → 0.24.0

package/dist/browser/in-memory-sockets.js

@@ -0,0 +1,294 @@
+import { checkedU64AsNumber } from "./common.js";
+import { inputStreamCreate, outputStreamCreate, pollableCreate } from "./io.js";
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+const unsupported = () => {
+    throw "not-supported";
+};
+function addressKey(address) {
+    return `${address.tag}:${address.val.address.join(".")}:${address.val.port}`;
+}
+function takeBytes(chunks, length) {
+    const chunk = chunks.shift();
+    if (!chunk) {
+        throw { tag: "closed" };
+    }
+    const requested = checkedU64AsNumber(length, "length");
+    if (chunk.byteLength <= requested) {
+        return chunk;
+    }
+    chunks.unshift(chunk.subarray(requested));
+    return chunk.subarray(0, requested);
+}
+/** The browser-side endpoint of an in-memory TCP connection. */
+export class InMemoryTcpClient {
+    #toServer = [];
+    #fromServer = [];
+    write(bytes) {
+        this.#toServer.push(new Uint8Array(bytes));
+    }
+    read(length = 4096n) {
+        return takeBytes(this.#fromServer, length);
+    }
+    _serverStreams() {
+        return [
+            inputStreamCreate({ blockingRead: (length) => takeBytes(this.#toServer, length) }),
+            outputStreamCreate({
+                write: (bytes) => this.#fromServer.push(new Uint8Array(bytes)),
+            }),
+        ];
+    }
+}
+/** Deterministic, process-local TCP namespaces with a browser-side client API. */
+export class InMemoryTcpSockets {
+    #pending = new Map();
+    tcp;
+    tcpCreateSocket;
+    constructor() {
+        const pending = this.#pending;
+        class TcpSocket {
+            #family;
+            #localAddress;
+            #remoteAddress;
+            #listening = false;
+            constructor(family) {
+                this.#family = family;
+            }
+            startBind(_network, localAddress) {
+                this.#localAddress = localAddress;
+            }
+            finishBind() {
+                if (!this.#localAddress) {
+                    throw "not-in-progress";
+                }
+            }
+            startConnect = unsupported;
+            finishConnect = unsupported;
+            startListen() {
+                if (!this.#localAddress) {
+                    throw "invalid-state";
+                }
+            }
+            finishListen() {
+                this.#listening = true;
+            }
+            accept() {
+                if (!this.#listening || !this.#localAddress) {
+                    throw "invalid-state";
+                }
+                const client = pending.get(addressKey(this.#localAddress))?.shift();
+                if (!client) {
+                    throw "would-block";
+                }
+                const connected = new TcpSocket(this.#family);
+                connected.#localAddress = this.#localAddress;
+                const [input, output] = client._serverStreams();
+                return [connected, input, output];
+            }
+            localAddress() {
+                if (!this.#localAddress) {
+                    throw "invalid-state";
+                }
+                return this.#localAddress;
+            }
+            remoteAddress() {
+                if (!this.#remoteAddress) {
+                    throw "invalid-state";
+                }
+                return this.#remoteAddress;
+            }
+            isListening() {
+                return this.#listening;
+            }
+            addressFamily() {
+                return this.#family;
+            }
+            setListenBacklogSize = unsupported;
+            keepAliveEnabled = unsupported;
+            setKeepAliveEnabled = unsupported;
+            keepAliveIdleTime = unsupported;
+            setKeepAliveIdleTime = unsupported;
+            keepAliveInterval = unsupported;
+            setKeepAliveInterval = unsupported;
+            keepAliveCount = unsupported;
+            setKeepAliveCount = unsupported;
+            hopLimit = unsupported;
+            setHopLimit = unsupported;
+            receiveBufferSize = unsupported;
+            setReceiveBufferSize = unsupported;
+            sendBufferSize = unsupported;
+            setSendBufferSize = unsupported;
+            subscribe() {
+                return pollableCreate();
+            }
+            shutdown() { }
+            [symbolDispose]() { }
+        }
+        this.tcp = { TcpSocket };
+        this.tcpCreateSocket = {
+            createTcpSocket: (family) => new TcpSocket(family),
+        };
+    }
+    connect(serverAddress) {
+        const client = new InMemoryTcpClient();
+        const key = addressKey(serverAddress);
+        const clients = this.#pending.get(key);
+        if (clients) {
+            clients.push(client);
+        }
+        else {
+            this.#pending.set(key, [client]);
+        }
+        return client;
+    }
+}
+/** The browser-side endpoint of an in-memory UDP socket. */
+export class InMemoryUdpClient {
+    #send;
+    #received = [];
+    constructor(send) {
+        this.#send = send;
+    }
+    send(bytes, serverAddress) {
+        this.#send(bytes, serverAddress);
+    }
+    read() {
+        return takeBytes(this.#received, 65535n);
+    }
+    _receive(bytes) {
+        this.#received.push(new Uint8Array(bytes));
+    }
+}
+/** Deterministic, process-local UDP namespaces with a browser-side client API. */
+export class InMemoryUdpSockets {
+    #datagrams = new Map();
+    #clients = new Map();
+    udp;
+    udpCreateSocket;
+    constructor() {
+        const datagrams = this.#datagrams;
+        const clients = this.#clients;
+        class IncomingDatagramStream {
+            queue;
+            constructor(queue) {
+                this.queue = queue;
+            }
+            receive(maxResults) {
+                return this.queue.splice(0, checkedU64AsNumber(maxResults, "max results"));
+            }
+            subscribe() {
+                return pollableCreate();
+            }
+            [symbolDispose]() { }
+        }
+        class OutgoingDatagramStream {
+            remoteAddress;
+            #permit = 0;
+            constructor(remoteAddress) {
+                this.remoteAddress = remoteAddress;
+            }
+            checkSend() {
+                this.#permit = 1_024;
+                return 1024n;
+            }
+            send(outgoing) {
+                if (outgoing.length > this.#permit) {
+                    throw new TypeError("datagram count exceeds the permit returned by checkSend");
+                }
+                this.#permit -= outgoing.length;
+                for (const datagram of outgoing) {
+                    const destination = datagram.remoteAddress ?? this.remoteAddress;
+                    if (!destination) {
+                        throw "invalid-argument";
+                    }
+                    const client = clients.get(addressKey(destination));
+                    if (!client) {
+                        throw "remote-unreachable";
+                    }
+                    client._receive(datagram.data);
+                }
+                return BigInt(outgoing.length);
+            }
+            subscribe() {
+                return pollableCreate();
+            }
+            [symbolDispose]() { }
+        }
+        class UdpSocket {
+            #family;
+            #localAddress;
+            #remoteAddress;
+            constructor(family) {
+                this.#family = family;
+            }
+            startBind(_network, localAddress) {
+                this.#localAddress = localAddress;
+            }
+            finishBind() {
+                if (!this.#localAddress) {
+                    throw "not-in-progress";
+                }
+            }
+            stream(remoteAddress) {
+                if (!this.#localAddress) {
+                    throw "invalid-state";
+                }
+                this.#remoteAddress = remoteAddress;
+                const key = addressKey(this.#localAddress);
+                let queue = datagrams.get(key);
+                if (!queue) {
+                    queue = [];
+                    datagrams.set(key, queue);
+                }
+                return [
+                    new IncomingDatagramStream(queue),
+                    new OutgoingDatagramStream(remoteAddress),
+                ];
+            }
+            localAddress() {
+                if (!this.#localAddress) {
+                    throw "invalid-state";
+                }
+                return this.#localAddress;
+            }
+            remoteAddress() {
+                return this.#remoteAddress;
+            }
+            addressFamily() {
+                return this.#family;
+            }
+            unicastHopLimit = unsupported;
+            setUnicastHopLimit = unsupported;
+            receiveBufferSize = unsupported;
+            setReceiveBufferSize = unsupported;
+            sendBufferSize = unsupported;
+            setSendBufferSize = unsupported;
+            subscribe() {
+                return pollableCreate();
+            }
+            [symbolDispose]() { }
+        }
+        this.udp = {
+            IncomingDatagramStream,
+            OutgoingDatagramStream,
+            UdpSocket,
+        };
+        this.udpCreateSocket = {
+            createUdpSocket: (family) => new UdpSocket(family),
+        };
+    }
+    createClient(localAddress) {
+        const client = new InMemoryUdpClient((bytes, serverAddress) => {
+            const key = addressKey(serverAddress);
+            const queue = this.#datagrams.get(key);
+            const incoming = { data: new Uint8Array(bytes), remoteAddress: localAddress };
+            if (queue) {
+                queue.push(incoming);
+            }
+            else {
+                this.#datagrams.set(key, [incoming]);
+            }
+        });
+        this.#clients.set(addressKey(localAddress), client);
+        return client;
+    }
+}

package/dist/browser/io.d.ts

@@ -8,13 +8,19 @@ type IOutputStream = StreamsNamespace.OutputStream;
 export type InputStreamHandler = Partial<IInputStream> & Required<Pick<IInputStream, "blockingRead">> & {
     drop?: () => void;
 };
+export interface PollableSource {
+    ready(): boolean;
+    wait(): Promise<void>;
+}
 /**
  * Handler interface for creating custom output streams
  */
 export type OutputStreamHandler = Partial<IOutputStream> & Required<Pick<IOutputStream, "write">> & {
     drop?: () => void;
 };
+export declare const ioErrorCreate: (message: string) => ErrorNamespace.Error;
 declare class InputStream implements IInputStream {
+    #private;
     [symbolDispose]: () => void;
     id: number;
     handler: InputStreamHandler;
@@ -27,6 +33,7 @@ declare class InputStream implements IInputStream {
 }
 export declare const inputStreamCreate: typeof InputStream._create;
 declare class OutputStream implements IOutputStream {
+    #private;
     [symbolDispose]: () => void;
     id: number;
     open: boolean;
@@ -40,7 +47,7 @@ declare class OutputStream implements IOutputStream {
     writeZeroes(len: bigint): void;
     blockingWriteZeroesAndFlush(len: bigint): void;
     splice(src: InputStream, len: bigint): bigint;
-    blockingSplice(_src: InputStream, _len: bigint): bigint;
+    blockingSplice(src: InputStream, len: bigint): bigint;
     subscribe(): PollNamespace.Pollable | Pollable;
 }
 export declare const outputStreamCreate: typeof OutputStream._create;
@@ -49,9 +56,11 @@ export declare const streams: typeof StreamsNamespace;
 declare class Pollable implements PollNamespace.Pollable {
     #private;
     [symbolDispose]: () => void;
-    static _create(promise?: Promise<void>): Pollable;
+    static _create(source?: Promise<void> | PollableSource): Pollable;
     ready(): boolean;
     block(): Promise<void>;
+    _onDispose(callback: () => void): void;
+    _invalidate(): void;
 }
 export declare const pollableCreate: typeof Pollable._create;
 export declare const poll: typeof PollNamespace;

package/dist/browser/io.js

@@ -1,13 +1,21 @@
+import { checkedU64AsNumber } from "./common.js";
 let id = 0;
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+const checkedLength = (len, name = "length") => checkedU64AsNumber(len, name);
+function closed() {
+    throw { tag: "closed" };
+}
 class IoError extends Error {
     toDebugString() {
         return this.message;
     }
 }
+export const ioErrorCreate = (message) => new IoError(message);
 class InputStream {
     id;
     handler;
+    #open = true;
+    #children = new Set();
     static _create(handler) {
         const stream = new InputStream();
         if (!handler) {
@@ -18,15 +26,27 @@ class InputStream {
         return stream;
     }
     read(len) {
+        checkedLength(len);
+        if (!this.#open) {
+            closed();
+        }
         if (this.handler.read) {
-            return this.handler.read(len);
+            return this.handler.read.call(this, len);
         }
         return this.handler.blockingRead.call(this, len);
     }
     blockingRead(len) {
+        checkedLength(len);
+        if (!this.#open) {
+            closed();
+        }
         return this.handler.blockingRead.call(this, len);
     }
     skip(len) {
+        checkedLength(len);
+        if (!this.#open) {
+            closed();
+        }
         if (this.handler.skip) {
             return this.handler.skip.call(this, len);
         }
@@ -37,6 +57,10 @@ class InputStream {
         return this.blockingSkip.call(this, len);
     }
     blockingSkip(len) {
+        checkedLength(len);
+        if (!this.#open) {
+            closed();
+        }
         if (this.handler.blockingSkip) {
             return this.handler.blockingSkip.call(this, len);
         }
@@ -44,12 +68,27 @@ class InputStream {
         return BigInt(bytes.byteLength);
     }
     subscribe() {
-        if (this.handler.subscribe) {
-            return this.handler.subscribe();
+        if (!this.#open) {
+            return pollableCreate();
+        }
+        const pollable = this.handler.subscribe
+            ? this.handler.subscribe.call(this)
+            : pollableCreate();
+        if (pollable instanceof Pollable) {
+            this.#children.add(pollable);
+            pollable._onDispose(() => this.#children.delete(pollable));
         }
-        return new Pollable();
+        return pollable;
     }
     [symbolDispose]() {
+        if (!this.#open) {
+            return;
+        }
+        this.#open = false;
+        for (const child of this.#children) {
+            child._invalidate();
+        }
+        this.#children.clear();
         if (this.handler.drop) {
             this.handler.drop.call(this);
         }
@@ -62,6 +101,8 @@ class OutputStream {
     id;
     open;
     handler;
+    #permit = 0n;
+    #children = new Set();
     static _create(handler) {
         const stream = new OutputStream();
         if (!handler) {
@@ -74,56 +115,116 @@ class OutputStream {
     }
     checkWrite() {
         if (!this.open) {
-            return 0n;
+            closed();
         }
         if (this.handler.checkWrite) {
-            return this.handler.checkWrite.call(this);
+            const permit = this.handler.checkWrite.call(this);
+            checkedLength(permit, "write permit");
+            this.#permit = permit;
+            return permit;
         }
-        return 1000000n;
+        this.#permit = 1000000n;
+        return this.#permit;
     }
     write(buf) {
+        if (!this.open) {
+            closed();
+        }
+        if (BigInt(buf.byteLength) > this.#permit) {
+            throw new Error("write exceeds the permit returned by checkWrite");
+        }
+        this.#permit -= BigInt(buf.byteLength);
         this.handler.write.call(this, buf);
     }
     blockingWriteAndFlush(buf) {
+        if (!this.open) {
+            closed();
+        }
+        if (buf.byteLength > 4096) {
+            throw new RangeError("blockingWriteAndFlush accepts at most 4096 bytes");
+        }
         if (this.handler.blockingWriteAndFlush) {
             return this.handler.blockingWriteAndFlush.call(this, buf);
         }
         this.handler.write.call(this, buf);
+        if (this.handler.blockingFlush) {
+            this.handler.blockingFlush.call(this);
+        }
+        else {
+            this.handler.flush?.call(this);
+        }
     }
     flush() {
+        if (!this.open) {
+            closed();
+        }
+        this.#permit = 0n;
         if (this.handler.flush) {
             this.handler.flush.call(this);
         }
     }
     blockingFlush() {
-        this.open = true;
+        if (!this.open) {
+            closed();
+        }
         if (this.handler.blockingFlush) {
             this.handler.blockingFlush.call(this);
         }
+        else {
+            this.handler.flush?.call(this);
+        }
     }
     writeZeroes(len) {
-        this.write.call(this, new Uint8Array(Number(len)));
+        const length = checkedLength(len);
+        if (len > this.#permit) {
+            throw new Error("write exceeds the permit returned by checkWrite");
+        }
+        this.write.call(this, new Uint8Array(length));
     }
     blockingWriteZeroesAndFlush(len) {
-        this.blockingWriteAndFlush.call(this, new Uint8Array(Number(len)));
+        const length = checkedLength(len);
+        if (length > 4096) {
+            throw new RangeError("blockingWriteZeroesAndFlush accepts at most 4096 bytes");
+        }
+        this.blockingWriteAndFlush.call(this, new Uint8Array(length));
     }
     splice(src, len) {
-        const spliceLen = Math.min(Number(len), Number(this.checkWrite.call(this)));
+        const spliceLen = Math.min(checkedLength(len), Number(this.checkWrite.call(this)));
         const bytes = src.read(BigInt(spliceLen));
         this.write.call(this, bytes);
         return BigInt(bytes.byteLength);
     }
-    blockingSplice(_src, _len) {
-        console.log(`[streams] Blocking splice ${this.id}`);
-        return 0n;
+    blockingSplice(src, len) {
+        const spliceLen = Math.min(checkedLength(len), Number(this.checkWrite.call(this)));
+        const bytes = src.blockingRead(BigInt(spliceLen));
+        this.write.call(this, bytes);
+        return BigInt(bytes.byteLength);
     }
     subscribe() {
-        if (this.handler.subscribe) {
-            return this.handler.subscribe();
+        if (!this.open) {
+            return pollableCreate();
+        }
+        const pollable = this.handler.subscribe
+            ? this.handler.subscribe.call(this)
+            : pollableCreate();
+        if (pollable instanceof Pollable) {
+            this.#children.add(pollable);
+            pollable._onDispose(() => this.#children.delete(pollable));
+        }
+        return pollable;
+    }
+    [symbolDispose]() {
+        if (!this.open) {
+            return;
         }
-        return new Pollable();
+        this.open = false;
+        this.#permit = 0n;
+        for (const child of this.#children) {
+            child._invalidate();
+        }
+        this.#children.clear();
+        this.handler.drop?.call(this);
     }
-    [symbolDispose]() { }
 }
 export const outputStreamCreate = OutputStream._create;
 // @ts-expect-error - Deleting static method
@@ -133,33 +234,82 @@ export const error = {
 };
 export const streams = { InputStream, OutputStream };
 class Pollable {
-    #ready = false;
-    #promise = null;
-    static _create(promise) {
+    #source = { ready: () => true, wait: () => Promise.resolve() };
+    #invalid = false;
+    #disposed = false;
+    #wait = null;
+    #disposeCallbacks = [];
+    #wakeUnusable;
+    #unusable = new Promise((resolve) => (this.#wakeUnusable = resolve));
+    static _create(source) {
         const pollable = new Pollable();
-        if (!promise) {
-            pollable.#ready = true;
-        }
-        else {
-            pollable.#promise = promise.then(() => {
-                pollable.#ready = true;
+        if (source instanceof Promise) {
+            let ready = false;
+            const wait = source.then(() => {
+                ready = true;
             }, () => {
-                pollable.#ready = true;
+                ready = true;
             });
+            pollable.#source = { ready: () => ready, wait: () => wait };
+        }
+        else if (source) {
+            pollable.#source = source;
         }
         return pollable;
     }
     ready() {
-        return this.#ready;
+        this.#assertUsable();
+        return this.#source.ready();
     }
     block() {
-        if (this.#ready) {
+        this.#assertUsable();
+        if (this.#source.ready()) {
             return Promise.resolve();
         }
-        return this.#promise || Promise.resolve();
+        // Deduplicate simultaneous waiters, but discard a completed wait so a
+        // level-triggered source can be polled again after its event is consumed.
+        if (!this.#wait) {
+            this.#wait = Promise.race([
+                Promise.resolve(this.#source.wait()),
+                this.#unusable.then(() => this.#assertUsable()),
+            ]).finally(() => {
+                this.#wait = null;
+            });
+        }
+        return this.#wait;
+    }
+    _onDispose(callback) {
+        if (this.#disposed) {
+            callback();
+        }
+        else {
+            this.#disposeCallbacks.push(callback);
+        }
+    }
+    _invalidate() {
+        if (this.#invalid || this.#disposed) {
+            return;
+        }
+        this.#invalid = true;
+        this.#wakeUnusable();
+    }
+    #assertUsable() {
+        if (this.#disposed) {
+            throw new Error("pollable has been disposed");
+        }
+        if (this.#invalid) {
+            throw new Error("pollable's parent resource has been disposed");
+        }
     }
     [symbolDispose]() {
-        this.#promise = null;
+        if (this.#disposed) {
+            return;
+        }
+        this.#disposed = true;
+        this.#wakeUnusable();
+        for (const callback of this.#disposeCallbacks.splice(0)) {
+            callback();
+        }
     }
 }
 export const pollableCreate = Pollable._create;
@@ -179,19 +329,30 @@ function pollList(list) {
         }
     }
     if (ready.length > 0) {
-        return new Uint32Array(ready);
+        // Browser guests commonly use an immediately-ready timer alongside an
+        // asynchronous Web API pollable. Yield a host task so Fetch, timers, and
+        // other event sources can progress instead of starving in a sync loop.
+        return new Promise((resolve) => setTimeout(() => {
+            const result = [];
+            for (let i = 0; i < list.length; i++) {
+                if (list[i].ready()) {
+                    result.push(i);
+                }
+            }
+            resolve(new Uint32Array(result));
+        }, 0));
     }
     // None ready synchronously. Wait for the first to resolve via Promise.race,
     // then sweep for any others that became ready concurrently.
-    return Promise.race(list.map((p, i) => p.block().then(() => {
-        const result = [i];
-        for (let j = 0; j < list.length; j++) {
-            if (j !== i && list[j].ready()) {
-                result.push(j);
+    return Promise.race(list.map((pollable) => pollable.block())).then(() => {
+        const result = [];
+        for (let i = 0; i < list.length; i++) {
+            if (list[i].ready()) {
+                result.push(i);
             }
         }
         return new Uint32Array(result);
-    })));
+    });
 }
 function pollOne(poll) {
     return poll.block();