@bytecodealliance/preview3-shim 0.6.1 → 0.8.0

package/dist/browser/sockets/types.js

@@ -1,126 +1,318 @@
-import { Todo } from "../../common/errors.js";
+import * as preview2Sockets from "@bytecodealliance/preview2-shim/sockets";
+import { readableFromPreview2Input, writeToPreview2Output } from "../streams.js";
+let tcpProvider = preview2Sockets;
+let udpProvider = preview2Sockets;
+class SocketError extends Error {
+    payload;
+    constructor(payload) {
+        super(payload.tag);
+        this.name = "SocketError";
+        this.payload = payload;
+    }
+}
+export function socketErrorCode(error) {
+    let tag = typeof error === "string" ? error : error?.tag;
+    if (!tag && error instanceof Error) {
+        tag = error.message;
+    }
+    if (tag === "would-block" || tag === "not-in-progress") {
+        return { tag: "invalid-state" };
+    }
+    if (tag) {
+        return { tag };
+    }
+    return { tag: "other", val: String(error) };
+}
+function socketError(error) {
+    throw error instanceof SocketError ? error : new SocketError(socketErrorCode(error));
+}
+function socketCall(operation) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        socketError(error);
+    }
+}
+export function _setTcpProvider(provider) {
+    const previous = tcpProvider;
+    tcpProvider = provider;
+    return previous;
+}
+export function _setUdpProvider(provider) {
+    const previous = udpProvider;
+    udpProvider = provider;
+    return previous;
+}
 export class TcpSocket {
+    #socket;
+    #input;
+    #output;
     static create(addressFamily) {
-        throw new Todo();
+        try {
+            return TcpSocket._wrap(tcpProvider.tcpCreateSocket.createTcpSocket(addressFamily));
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    static _wrap(socket, input, output) {
+        const wrapped = new TcpSocket();
+        wrapped.#socket = socket;
+        wrapped.#input = input;
+        wrapped.#output = output;
+        return wrapped;
     }
     bind(localAddress) {
-        throw new Todo();
-    }
-    connect(remoteAddress) {
-        throw new Todo();
+        try {
+            this.#socket.startBind({}, localAddress);
+            this.#socket.finishBind();
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async connect(remoteAddress) {
+        try {
+            this.#socket.startConnect({}, remoteAddress);
+            const connected = this.#socket.finishConnect();
+            if (Array.isArray(connected)) {
+                [this.#input, this.#output] = connected;
+            }
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     listen() {
-        throw new Todo();
-    }
-    send(data) {
-        throw new Todo();
+        try {
+            this.#socket.startListen();
+            this.#socket.finishListen();
+        }
+        catch (error) {
+            socketError(error);
+        }
+        return new ReadableStream({
+            pull: async (controller) => {
+                while (true) {
+                    try {
+                        const [socket, input, output] = this.#socket.accept();
+                        controller.enqueue(TcpSocket._wrap(socket, input, output));
+                        return;
+                    }
+                    catch (error) {
+                        if (error === "would-block") {
+                            await new Promise((resolve) => setTimeout(resolve, 0));
+                            continue;
+                        }
+                        controller.error(new SocketError(socketErrorCode(error)));
+                        return;
+                    }
+                }
+            },
+        });
+    }
+    async send(data) {
+        if (!this.#output) {
+            return { tag: "err", val: { tag: "invalid-state" } };
+        }
+        try {
+            await writeToPreview2Output(data, this.#output);
+            return { tag: "ok", val: undefined };
+        }
+        catch (error) {
+            return { tag: "err", val: socketErrorCode(error) };
+        }
     }
     receive() {
-        throw new Todo();
+        if (!this.#input) {
+            const error = { tag: "invalid-state" };
+            const stream = new ReadableStream({
+                start(controller) {
+                    controller.error(new SocketError(error));
+                },
+            });
+            return [stream, Promise.resolve({ tag: "err", val: error })];
+        }
+        return readableFromPreview2Input(this.#input, socketErrorCode);
     }
     getLocalAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.localAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getRemoteAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.remoteAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getIsListening() {
-        throw new Todo();
+        return socketCall(() => this.#socket.isListening());
     }
     getAddressFamily() {
-        throw new Todo();
+        return socketCall(() => this.#socket.addressFamily());
     }
     setListenBacklogSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setListenBacklogSize(value));
     }
     getKeepAliveEnabled() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveEnabled());
     }
     setKeepAliveEnabled(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveEnabled(value));
     }
     getKeepAliveIdleTime() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveIdleTime());
     }
     setKeepAliveIdleTime(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveIdleTime(value));
     }
     getKeepAliveInterval() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveInterval());
     }
     setKeepAliveInterval(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveInterval(value));
     }
     getKeepAliveCount() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveCount());
     }
     setKeepAliveCount(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveCount(value));
     }
     getHopLimit() {
-        throw new Todo();
+        return socketCall(() => this.#socket.hopLimit());
     }
     setHopLimit(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setHopLimit(value));
     }
     getReceiveBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.receiveBufferSize());
     }
     setReceiveBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setReceiveBufferSize(value));
     }
     getSendBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.sendBufferSize());
     }
     setSendBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setSendBufferSize(value));
     }
 }
 export class UdpSocket {
+    #socket;
+    #incoming;
+    #outgoing;
     static create(addressFamily) {
-        throw new Todo();
+        try {
+            const wrapped = new UdpSocket();
+            wrapped.#socket = udpProvider.udpCreateSocket.createUdpSocket(addressFamily);
+            return wrapped;
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     bind(localAddress) {
-        throw new Todo();
+        try {
+            this.#socket.startBind({}, localAddress);
+            this.#socket.finishBind();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     connect(remoteAddress) {
-        throw new Todo();
+        try {
+            [this.#incoming, this.#outgoing] = this.#socket.stream(remoteAddress);
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     disconnect() {
-        throw new Todo();
-    }
-    send(data, remoteAddress) {
-        throw new Todo();
-    }
-    receive() {
-        throw new Todo();
+        try {
+            [this.#incoming, this.#outgoing] = this.#socket.stream(undefined);
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async send(data, remoteAddress) {
+        try {
+            if (!this.#outgoing) {
+                [this.#incoming, this.#outgoing] = this.#socket.stream(remoteAddress);
+            }
+            this.#outgoing.checkSend();
+            this.#outgoing.send([{ data, remoteAddress }]);
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async receive() {
+        if (!this.#incoming) {
+            try {
+                [this.#incoming, this.#outgoing] = this.#socket.stream(undefined);
+            }
+            catch (error) {
+                socketError(error);
+            }
+        }
+        while (true) {
+            try {
+                const [datagram] = this.#incoming.receive(1n);
+                if (datagram) {
+                    return [datagram.data, datagram.remoteAddress];
+                }
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+            catch (error) {
+                socketError(error);
+            }
+        }
     }
     getLocalAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.localAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getRemoteAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.remoteAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getAddressFamily() {
-        throw new Todo();
+        return socketCall(() => this.#socket.addressFamily());
     }
     getUnicastHopLimit() {
-        throw new Todo();
+        return socketCall(() => this.#socket.unicastHopLimit());
     }
     setUnicastHopLimit(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setUnicastHopLimit(value));
     }
     getReceiveBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.receiveBufferSize());
     }
     setReceiveBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setReceiveBufferSize(value));
     }
     getSendBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.sendBufferSize());
     }
     setSendBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setSendBufferSize(value));
     }
 }
 export default {

package/dist/browser/sockets.d.ts

@@ -1,2 +1,4 @@
 export { default as ipNameLookup } from "./sockets/ip-name-lookup.js";
 export { default as types } from "./sockets/types.js";
+export { _setTcpProvider, _setUdpProvider } from "./sockets/types.js";
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "@bytecodealliance/preview2-shim/sockets";

package/dist/browser/sockets.js

@@ -1,2 +1,4 @@
 export { default as ipNameLookup } from "./sockets/ip-name-lookup.js";
 export { default as types } from "./sockets/types.js";
+export { _setTcpProvider, _setUdpProvider } from "./sockets/types.js";
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "@bytecodealliance/preview2-shim/sockets";

package/dist/browser/streams.d.ts

@@ -0,0 +1,20 @@
+interface Preview2InputStream {
+    blockingRead(length: bigint): Uint8Array | Promise<Uint8Array>;
+    subscribe(): {
+        block(): void | Promise<void>;
+    };
+}
+interface Preview2OutputStream {
+    blockingWriteAndFlush(contents: Uint8Array): void;
+    blockingFlush(): void;
+}
+export declare function writeToPreview2Output(data: ReadableStream<number>, output: Preview2OutputStream): Promise<void>;
+export declare function readableFromPreview2Input<E>(input: Preview2InputStream, errorCode: (error: unknown) => E): [ReadableStream<number>, Promise<{
+    tag: "ok";
+    val: void;
+} | {
+    tag: "err";
+    val: E;
+}>];
+export declare function preview2StreamErrorCode(error: unknown): "io" | "illegal-byte-sequence" | "pipe";
+export {};

package/dist/browser/streams.js

@@ -0,0 +1,106 @@
+const symbolDispose = Symbol.dispose ?? Symbol.for("dispose");
+const BYTE_CHUNK_SIZE = 64 * 1024;
+const P2_WRITE_CHUNK_SIZE = 4096;
+function byteChunk(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (Array.isArray(value)) {
+        return Uint8Array.from(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0 || value > 255) {
+            throw new RangeError(`invalid byte stream value: ${value}`);
+        }
+        return Uint8Array.of(value);
+    }
+    if (typeof value === "string") {
+        return new TextEncoder().encode(value);
+    }
+    throw new TypeError("byte stream values must be bytes or byte arrays");
+}
+function isIteratorResult(value) {
+    return value !== null && typeof value === "object" && "done" in value;
+}
+async function* byteChunks(data) {
+    const stream = data;
+    if (typeof stream.read === "function") {
+        while (true) {
+            const value = await stream.read({ count: BYTE_CHUNK_SIZE });
+            if (isIteratorResult(value)) {
+                if (value.done) {
+                    return;
+                }
+                yield byteChunk(value.value);
+            }
+            else if (value === null) {
+                return;
+            }
+            else {
+                yield byteChunk(value);
+            }
+        }
+    }
+    if (typeof stream[Symbol.asyncIterator] === "function") {
+        for await (const value of stream) {
+            yield byteChunk(value);
+        }
+        return;
+    }
+    throw new TypeError("byte stream must provide read() or [Symbol.asyncIterator]()");
+}
+export async function writeToPreview2Output(data, output) {
+    for await (const bytes of byteChunks(data)) {
+        for (let offset = 0; offset < bytes.byteLength; offset += P2_WRITE_CHUNK_SIZE) {
+            output.blockingWriteAndFlush(bytes.subarray(offset, offset + P2_WRITE_CHUNK_SIZE));
+        }
+    }
+    output.blockingFlush();
+}
+export function readableFromPreview2Input(input, errorCode) {
+    let resolveResult = () => { };
+    const result = new Promise((resolve) => (resolveResult = resolve));
+    let settled = false;
+    const settle = (value) => {
+        if (!settled) {
+            settled = true;
+            resolveResult(value);
+        }
+    };
+    const readable = new ReadableStream({
+        async pull(controller) {
+            try {
+                const bytes = await input.blockingRead(BigInt(BYTE_CHUNK_SIZE));
+                for (const byte of bytes) {
+                    controller.enqueue(byte);
+                }
+            }
+            catch (error) {
+                if (error?.tag === "closed") {
+                    controller.close();
+                    settle({ tag: "ok", val: undefined });
+                    return;
+                }
+                settle({ tag: "err", val: errorCode(error) });
+                controller.error(error);
+            }
+        },
+        cancel() {
+            settle({ tag: "ok", val: undefined });
+        },
+    });
+    return [readable, result];
+}
+export function preview2StreamErrorCode(error) {
+    const code = error?.code;
+    if (code === "EPIPE" || code === "ERR_STREAM_PREMATURE_CLOSE") {
+        return "pipe";
+    }
+    if (code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
+        return "illegal-byte-sequence";
+    }
+    return "io";
+}

package/dist/nodejs/filesystem/descriptor.js

@@ -872,6 +872,15 @@ class Descriptor {
      * Resolve a relative subpath against this descriptor.
      */
     #getFullPath(subpath, _followSymlinks) {
+        const segments = this.#normalizeSubpath(subpath);
+        const base = this.#hostPreopen ?? this.#fullPath;
+        if (segments.length === 0) {
+            return base;
+        }
+        const baseNormalized = stripTrailingSlash(base);
+        return `${baseNormalized}/${segments.join("/")}`;
+    }
+    #normalizeSubpath(subpath) {
         subpath = subpath.replaceAll("\\", "/").replace(/\/\/+/g, "/");
         if (subpath === "") {
             throw new FSError("no-entry");
@@ -894,12 +903,7 @@ class Descriptor {
                 segments.push(seg);
             }
         }
-        const base = this.#hostPreopen ?? this.#fullPath;
-        if (segments.length === 0) {
-            return base;
-        }
-        const baseNormalized = stripTrailingSlash(base);
-        return `${baseNormalized}/${segments.join("/")}`;
+        return segments;
     }
     async #statForIdentity() {
         if (this.#hostPreopen) {
@@ -916,19 +920,12 @@ class Descriptor {
         }
         const base = this.#hostPreopen ?? this.#fullPath;
         const baseResolved = nodePath.resolve(base);
-        const segments = subpath.replaceAll("\\", "/").replace(/\/\/+/g, "/").split("/");
+        // Validate the same normalized path that the filesystem operation will use.
+        // Otherwise an ENOENT segment followed by `..` can stop validation before a
+        // surviving symlink that #getFullPath later exposes.
+        const segments = this.#normalizeSubpath(subpath);
         let current = baseResolved;
         for (const seg of segments) {
-            if (seg === "" || seg === ".") {
-                continue;
-            }
-            if (seg === "..") {
-                current = nodePath.dirname(current);
-                if (!isWithinPath(baseResolved, current)) {
-                    throw new FSError("not-permitted");
-                }
-                continue;
-            }
             current = nodePath.join(current, seg);
             let stat;
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {
@@ -49,9 +49,10 @@
   },
   "dependencies": {
     "@bytecodealliance/jco-node-fs": "0.3.2",
-    "@bytecodealliance/preview2-shim": "^0.25.0"
+    "@bytecodealliance/preview2-shim": "^0.27.0"
   },
   "devDependencies": {
+    "@bytecodealliance/jco": "1.25.2",
     "@types/node": "^24.12.4",
     "globals": "^17.6.0",
     "rolldown": "^1.2.4",
@@ -67,7 +68,6 @@
     "fmt:check": "oxfmt --check",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
-    "pretest": "pnpm run build",
     "test": "vitest --run -c test/vitest.ts",
     "prebench": "pnpm run build",
     "bench": "vitest bench --run"

package/dist/common/errors.d.ts

@@ -1,3 +0,0 @@
-export declare class Todo extends Error {
-    constructor();
-}

package/dist/common/errors.js

@@ -1,5 +0,0 @@
-export class Todo extends Error {
-    constructor() {
-        super("TODO: not yet implemented");
-    }
-}