@bytecodealliance/preview2-shim 0.20.1 → 0.21.0

package/dist/io/worker-thread.bundle.js

@@ -1,9 +1,10 @@
-import { createReadStream, createWriteStream, read } from "node:fs";
+import fs, { createReadStream, createWriteStream, read } from "node:fs";
 import process, { hrtime, nextTick, stderr, stdout } from "node:process";
 import { PassThrough, Readable } from "node:stream";
 import { parentPort, workerData } from "node:worker_threads";
 import { Agent, createServer, request } from "node:http";
 import { Agent as Agent$1, request as request$1 } from "node:https";
+import { promisify } from "node:util";
 import { Server, Socket, isIP } from "node:net";
 import { lookup } from "node:dns/promises";
 import { createSocket } from "node:dgram";
@@ -78,6 +79,17 @@ var calls_exports = /* @__PURE__ */ __exportAll({
 	CLOCKS_DURATION_SUBSCRIBE: () => CLOCKS_DURATION_SUBSCRIBE,
 	CLOCKS_INSTANT_SUBSCRIBE: () => CLOCKS_INSTANT_SUBSCRIBE,
 	FILE: () => FILE,
+	FILESYSTEM_DESCRIPTOR_CLOSE: () => FILESYSTEM_DESCRIPTOR_CLOSE,
+	FILESYSTEM_DESCRIPTOR_GET_TYPE: () => FILESYSTEM_DESCRIPTOR_GET_TYPE,
+	FILESYSTEM_DESCRIPTOR_METADATA_HASH: () => FILESYSTEM_DESCRIPTOR_METADATA_HASH,
+	FILESYSTEM_DESCRIPTOR_OPEN: () => FILESYSTEM_DESCRIPTOR_OPEN,
+	FILESYSTEM_DESCRIPTOR_READ: () => FILESYSTEM_DESCRIPTOR_READ,
+	FILESYSTEM_DESCRIPTOR_SET_SIZE: () => FILESYSTEM_DESCRIPTOR_SET_SIZE,
+	FILESYSTEM_DESCRIPTOR_SET_TIMES: () => FILESYSTEM_DESCRIPTOR_SET_TIMES,
+	FILESYSTEM_DESCRIPTOR_STAT: () => FILESYSTEM_DESCRIPTOR_STAT,
+	FILESYSTEM_DESCRIPTOR_SYNC: () => FILESYSTEM_DESCRIPTOR_SYNC,
+	FILESYSTEM_DESCRIPTOR_SYNC_DATA: () => FILESYSTEM_DESCRIPTOR_SYNC_DATA,
+	FILESYSTEM_DESCRIPTOR_WRITE: () => FILESYSTEM_DESCRIPTOR_WRITE,
 	FUTURE_DISPOSE: () => FUTURE_DISPOSE,
 	FUTURE_SUBSCRIBE: () => FUTURE_SUBSCRIBE,
 	FUTURE_TAKE_VALUE: () => FUTURE_TAKE_VALUE,
@@ -195,6 +207,17 @@ const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << 24;
 const OUTPUT_STREAM_SUBSCRIBE = ++call_id << 24;
 const OUTPUT_STREAM_DISPOSE = ++call_id << 24;
 const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_OPEN = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_CLOSE = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_SYNC_DATA = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_GET_TYPE = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_SET_SIZE = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_SET_TIMES = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_READ = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_WRITE = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_SYNC = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_STAT = ++call_id << 24;
+const FILESYSTEM_DESCRIPTOR_METADATA_HASH = ++call_id << 24;
 const POLL_POLLABLE_READY = ++call_id << 24;
 const POLL_POLLABLE_BLOCK = ++call_id << 24;
 const POLL_POLLABLE_DISPOSE = ++call_id << 24;
@@ -403,6 +426,117 @@ function getFirstError(e) {
 	return e;
 }
 //#endregion
+//#region dist/io/worker-filesystem.js
+const closeAsync = promisify(fs.close);
+const fdatasyncAsync = promisify(fs.fdatasync);
+const fstatAsync = promisify(fs.fstat);
+const fsyncAsync = promisify(fs.fsync);
+const ftruncateAsync = promisify(fs.ftruncate);
+const futimesAsync = promisify(fs.futimes);
+const openAsync = promisify(fs.open);
+const readAsync = promisify(fs.read);
+const writeAsync = promisify(fs.write);
+let nextFileResourceId = 0;
+const fileResources = /* @__PURE__ */ new Map();
+function lookupType(obj) {
+	if (obj.isFile()) return "regular-file";
+	if (obj.isSocket()) return "socket";
+	if (obj.isSymbolicLink()) return "symbolic-link";
+	if (obj.isFIFO()) return "fifo";
+	if (obj.isDirectory()) return "directory";
+	if (obj.isCharacterDevice()) return "character-device";
+	if (obj.isBlockDevice()) return "block-device";
+	return "unknown";
+}
+function getFileResource(id) {
+	const resource = fileResources.get(id);
+	if (!resource) {
+		const error = /* @__PURE__ */ new Error(`Invalid filesystem descriptor resource: ${id}`);
+		error.code = "EBADF";
+		throw error;
+	}
+	return resource;
+}
+async function openFileResource(path, flags) {
+	const fd = await openAsync(path, flags);
+	let type;
+	try {
+		type = lookupType(await fstatAsync(fd, { bigint: true }));
+	} catch (error) {
+		await closeAsync(fd);
+		throw error;
+	}
+	const id = ++nextFileResourceId;
+	fileResources.set(id, {
+		fd,
+		refs: 1
+	});
+	return {
+		id,
+		type
+	};
+}
+function retainFileResource(id) {
+	getFileResource(id).refs++;
+	return id;
+}
+async function releaseFileResource(id) {
+	const resource = getFileResource(id);
+	if (--resource.refs === 0) {
+		fileResources.delete(id);
+		await closeAsync(resource.fd);
+	}
+}
+function fileResourceFd(id) {
+	return getFileResource(id).fd;
+}
+async function syncFileResourceData(id) {
+	await fdatasyncAsync(fileResourceFd(id));
+}
+async function getFileResourceType(id) {
+	return lookupType(await fstatAsync(fileResourceFd(id), { bigint: true }));
+}
+async function setFileResourceSize(id, size) {
+	await ftruncateAsync(fileResourceFd(id), size);
+}
+async function setFileResourceTimes(id, atime, mtime) {
+	await futimesAsync(fileResourceFd(id), atime, mtime);
+}
+async function readFileResource(id, length, offset) {
+	const buffer = new Uint8Array(length);
+	const result = await readAsync(fileResourceFd(id), buffer, 0, length, offset);
+	const bytesRead = typeof result === "number" ? result : result.bytesRead;
+	return {
+		bytes: buffer.subarray(0, bytesRead),
+		eof: bytesRead === 0
+	};
+}
+async function writeFileResource(id, buffer, offset) {
+	const result = await writeAsync(fileResourceFd(id), buffer, 0, buffer.byteLength, offset);
+	return typeof result === "number" ? result : result.bytesWritten;
+}
+async function syncFileResource(id) {
+	await fsyncAsync(fileResourceFd(id));
+}
+async function statFileResource(id) {
+	const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+	return {
+		type: lookupType(stats),
+		nlink: stats.nlink,
+		size: stats.size,
+		atimeNs: stats.atimeNs,
+		mtimeNs: stats.mtimeNs,
+		ctimeNs: stats.ctimeNs
+	};
+}
+async function metadataHashFileResource(id) {
+	const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+	return {
+		upper: stats.mtimeNs,
+		lower: stats.ino
+	};
+}
+//#endregion
 //#region dist/io/worker-sockets.js
 let stateCnt = 0;
 const SOCKET_STATE_INIT = ++stateCnt;
@@ -585,18 +719,19 @@ async function getDefaultReceiveBufferSize() {
 }
 //#endregion
 //#region dist/io/worker-socket-tcp.js
-const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
 const win = process.platform === "win32";
 const tcpSockets = /* @__PURE__ */ new Map();
 let tcpSocketCnt = 0;
 function createTcpSocket() {
-	const handle = new TCP(TCPConstants.SOCKET);
 	tcpSockets.set(++tcpSocketCnt, {
 		state: SOCKET_STATE_INIT,
 		future: null,
 		tcpSocket: null,
+		server: null,
+		localAddress: null,
 		listenBacklogSize: 128,
-		handle,
+		keepAlive: false,
+		keepAliveIdleTime: 0,
 		pendingAccepts: [],
 		pollState: {
 			ready: true,
@@ -619,7 +754,7 @@ function socketTcpFinish(id, fromState, toState) {
 		throw val;
 	} else {
 		socket.state = toState;
-		if (toState === SOCKET_STATE_LISTENER) socket.pollState.ready = false;
+		if (toState === SOCKET_STATE_LISTENER) socket.pollState.ready = socket.pendingAccepts.length > 0;
 		return val;
 	}
 }
@@ -628,85 +763,109 @@ function socketTcpBindStart(id, localAddress, family) {
 	if (socket.state !== SOCKET_STATE_INIT) throw "invalid-state";
 	if (family !== localAddress.tag || !isUnicastIpAddress(localAddress) || isIPv4MappedAddress(localAddress)) throw "invalid-argument";
 	socket.state = SOCKET_STATE_BIND;
-	const { handle } = socket;
-	socket.future = createFuture((async () => {
+	socket.future = createFuture(new Promise((resolve, reject) => {
 		const address = serializeIpAddress(localAddress);
 		const port = localAddress.val.port;
-		const code = localAddress.tag === "ipv6" ? handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY) : handle.bind(address, port);
-		if (code !== 0) throw convertSocketErrorCode(-code);
-		{
-			const code = handle.getsockname({});
-			if (code !== 0) throw convertSocketErrorCode(-code);
+		const server = socket.server = createTcpServer(socket);
+		function handleErr(err) {
+			server.off("listening", handleListen);
+			reject(convertSocketError(err));
 		}
-	})(), socket.pollState);
+		function handleListen() {
+			server.off("error", handleErr);
+			const boundAddress = server.address();
+			if (!boundAddress || typeof boundAddress === "string") {
+				reject("invalid-state");
+				return;
+			}
+			socket.localAddress = ipSocketAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
+			resolve();
+		}
+		server.once("listening", handleListen);
+		server.once("error", handleErr);
+		server.listen({
+			host: address ?? void 0,
+			port,
+			backlog: socket.listenBacklogSize,
+			ipv6Only: family === "ipv6"
+		});
+	}), socket.pollState);
+}
+function createTcpServer(socket) {
+	const server = new Server({
+		pauseOnConnect: true,
+		allowHalfOpen: true
+	});
+	server.on("connection", (tcpSocket) => {
+		if (socket.state !== SOCKET_STATE_LISTEN && socket.state !== SOCKET_STATE_LISTENER) {
+			tcpSocket.destroy();
+			return;
+		}
+		pollStateReady(socket.pollState);
+		const pollState = createReadableStreamPollState(tcpSocket);
+		socket.pendingAccepts.push({
+			tcpSocket,
+			err: null,
+			pollState
+		});
+	});
+	server.on("error", (err) => {
+		if (socket.state === SOCKET_STATE_LISTEN || socket.state === SOCKET_STATE_LISTENER) {
+			pollStateReady(socket.pollState);
+			socket.pendingAccepts.push({
+				tcpSocket: null,
+				err,
+				pollState: null
+			});
+		}
+	});
+	return server;
+}
+function closeTcpServer(socket) {
+	const server = socket.server;
+	socket.server = null;
+	if (!server) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		server.close((err) => err ? reject(err) : resolve());
+	});
 }
 function socketTcpConnectStart(id, remoteAddress, family) {
 	const socket = tcpSockets.get(id);
 	if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BOUND) throw "invalid-state";
 	if (isWildcardAddress(remoteAddress) || family !== remoteAddress.tag || !isUnicastIpAddress(remoteAddress) || isMulticastIpAddress(remoteAddress) || remoteAddress.val.port === 0 || isIPv4MappedAddress(remoteAddress)) throw "invalid-argument";
 	socket.state = SOCKET_STATE_CONNECT;
-	socket.future = createFuture(new Promise((resolve, reject) => {
-		const tcpSocket = socket.tcpSocket = new Socket({
-			handle: socket.handle,
-			pauseOnCreate: true,
-			allowHalfOpen: true
-		});
-		function handleErr(err) {
-			tcpSocket.off("connect", handleConnect);
-			reject(convertSocketError(err));
-		}
-		function handleConnect() {
-			tcpSocket.off("error", handleErr);
-			resolve([createReadableStream(tcpSocket), createWritableStream(tcpSocket)]);
-		}
-		tcpSocket.once("connect", handleConnect);
-		tcpSocket.once("error", handleErr);
-		tcpSocket.connect({
-			port: remoteAddress.val.port,
-			host: serializeIpAddress(remoteAddress) ?? void 0,
-			lookup: noLookup
+	socket.future = createFuture((async () => {
+		const localAddress = socket.localAddress;
+		await closeTcpServer(socket);
+		const tcpSocket = socket.tcpSocket = new Socket({ allowHalfOpen: true });
+		tcpSocket.setKeepAlive(socket.keepAlive, socket.keepAliveIdleTime);
+		await new Promise((resolve, reject) => {
+			function handleErr(err) {
+				tcpSocket.off("connect", handleConnect);
+				reject(convertSocketError(err));
+			}
+			function handleConnect() {
+				tcpSocket.off("error", handleErr);
+				resolve();
+			}
+			tcpSocket.once("connect", handleConnect);
+			tcpSocket.once("error", handleErr);
+			tcpSocket.connect({
+				port: remoteAddress.val.port,
+				host: serializeIpAddress(remoteAddress) ?? void 0,
+				lookup: noLookup,
+				localAddress: localAddress ? serializeIpAddress(localAddress) ?? void 0 : void 0,
+				localPort: localAddress?.val.port
+			});
 		});
-	}), socket.pollState);
+		return [createReadableStream(tcpSocket), createWritableStream(tcpSocket)];
+	})(), socket.pollState);
 }
 function socketTcpListenStart(id) {
 	const socket = tcpSockets.get(id);
 	if (socket.state !== SOCKET_STATE_BOUND) throw "invalid-state";
-	const { handle } = socket;
 	socket.state = SOCKET_STATE_LISTEN;
-	socket.future = createFuture(new Promise((resolve, reject) => {
-		const server = new Server({
-			pauseOnConnect: true,
-			allowHalfOpen: true
-		});
-		function handleErr(err) {
-			server.off("listening", handleListen);
-			reject(convertSocketError(err));
-		}
-		function handleListen() {
-			server.off("error", handleErr);
-			server.on("connection", (tcpSocket) => {
-				pollStateReady(socket.pollState);
-				const pollState = createReadableStreamPollState(tcpSocket);
-				socket.pendingAccepts.push({
-					tcpSocket,
-					err: null,
-					pollState
-				});
-			});
-			server.on("error", (err) => {
-				pollStateReady(socket.pollState);
-				socket.pendingAccepts.push({
-					tcpSocket: null,
-					err,
-					pollState: null
-				});
-			});
-			resolve();
-		}
-		server.once("listening", handleListen);
-		server.once("error", handleErr);
-		server.listen(handle, socket.listenBacklogSize);
-	}), socket.pollState);
+	socket.future = createFuture(Promise.resolve(), socket.pollState);
 }
 function socketTcpAccept(id) {
 	const socket = tcpSockets.get(id);
@@ -722,8 +881,11 @@ function socketTcpAccept(id) {
 		state: SOCKET_STATE_CONNECTION,
 		future: null,
 		tcpSocket: accept.tcpSocket,
+		server: null,
+		localAddress: null,
 		listenBacklogSize: 128,
-		handle: accept.tcpSocket?._handle,
+		keepAlive: false,
+		keepAliveIdleTime: 0,
 		pendingAccepts: [],
 		pollState: accept.pollState
 	});
@@ -740,18 +902,16 @@ function socketTcpSetListenBacklogSize(id, backlogSize) {
 	socket.listenBacklogSize = Number(backlogSize);
 }
 function socketTcpGetLocalAddress(id) {
-	const { handle } = tcpSockets.get(id);
-	const out = {};
-	const code = handle.getsockname(out);
-	if (code !== 0) throw convertSocketErrorCode(-code);
-	return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+	const socket = tcpSockets.get(id);
+	const address = socket.tcpSocket?.address();
+	if (address && typeof address !== "string" && "family" in address) return ipSocketAddress(address.family.toLowerCase(), address.address, address.port);
+	if (socket.localAddress) return socket.localAddress;
+	throw "invalid-state";
 }
 function socketTcpGetRemoteAddress(id) {
-	const { handle } = tcpSockets.get(id);
-	const out = {};
-	const code = handle.getpeername(out);
-	if (code !== 0) throw convertSocketErrorCode(-code);
-	return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+	const { tcpSocket } = tcpSockets.get(id);
+	if (!tcpSocket?.remoteFamily || !tcpSocket.remoteAddress || !tcpSocket.remotePort) throw "invalid-state";
+	return ipSocketAddress(tcpSocket.remoteFamily.toLowerCase(), tcpSocket.remoteAddress, tcpSocket.remotePort);
 }
 function socketTcpShutdown(id, _shutdownType) {
 	const socket = tcpSockets.get(id);
@@ -760,14 +920,16 @@ function socketTcpShutdown(id, _shutdownType) {
 	else socket.tcpSocket?.destroy();
 }
 function socketTcpSetKeepAlive(id, { keepAlive, keepAliveIdleTime }) {
-	const { handle } = tcpSockets.get(id);
-	const code = handle.setKeepAlive(keepAlive, Number(keepAliveIdleTime / 1000000000n));
-	if (code !== 0) throw convertSocketErrorCode(-code);
+	const socket = tcpSockets.get(id);
+	socket.keepAlive = keepAlive;
+	socket.keepAliveIdleTime = Number(keepAliveIdleTime / 1000000000n);
+	socket.tcpSocket?.setKeepAlive(socket.keepAlive, socket.keepAliveIdleTime);
 }
 function socketTcpDispose(id) {
 	const socket = tcpSockets.get(id);
 	verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
-	socket.handle.close();
+	socket.server?.close();
+	socket.tcpSocket?.destroy();
 	tcpSockets.delete(id);
 }
 //#endregion
@@ -1067,9 +1229,10 @@ async function socketOutgoingDatagramStreamSend(id, datagrams) {
 		const address = remoteAddress ? serializeIpAddress(remoteAddress) : socket.remoteAddress;
 		const port = remoteAddress?.val.port ?? socket.remotePort;
 		let sendLastBatch = true;
-		if (sendQueue.length > 0) if (sendQueueAddress === address && sendQueuePort === port) sendQueue.push(data);
-		else sendLastBatch = true;
-		else {
+		if (sendQueue.length > 0) {
+			if (sendQueueAddress === address && sendQueuePort === port) sendQueue.push(data);
+			else sendLastBatch = true;
+		} else {
 			sendQueueAddress = address;
 			sendQueuePort = port;
 			sendQueue.push(data);
@@ -1419,24 +1582,41 @@ function handle(call, id, payload) {
 			subscribeInstant(pollState, payload);
 			return createPoll(pollState);
 		}
+		case FILESYSTEM_DESCRIPTOR_OPEN: return openFileResource(payload.path, payload.flags);
+		case FILESYSTEM_DESCRIPTOR_CLOSE: return releaseFileResource(id);
+		case FILESYSTEM_DESCRIPTOR_SYNC_DATA: return syncFileResourceData(id);
+		case FILESYSTEM_DESCRIPTOR_GET_TYPE: return getFileResourceType(id);
+		case FILESYSTEM_DESCRIPTOR_SET_SIZE: return setFileResourceSize(id, payload);
+		case FILESYSTEM_DESCRIPTOR_SET_TIMES: return setFileResourceTimes(id, payload.atime, payload.mtime);
+		case FILESYSTEM_DESCRIPTOR_READ: return readFileResource(id, payload.length, payload.offset);
+		case FILESYSTEM_DESCRIPTOR_WRITE: return writeFileResource(id, payload.buffer, payload.offset);
+		case FILESYSTEM_DESCRIPTOR_SYNC: return syncFileResource(id);
+		case FILESYSTEM_DESCRIPTOR_STAT: return statFileResource(id);
+		case FILESYSTEM_DESCRIPTOR_METADATA_HASH: return metadataHashFileResource(id);
 		case INPUT_STREAM_CREATE | FILE: {
-			const { fd, offset } = payload;
-			return createReadableStream(createReadStream(null, {
+			const { descriptorId, offset } = payload;
+			const fd = fileResourceFd(descriptorId);
+			const streamId = createReadableStream(createReadStream(null, {
 				fd,
 				autoClose: false,
-				highWaterMark: 64 * 1024,
+				highWaterMark: 65536,
 				start: Number(offset)
 			}));
+			streams.get(streamId).fileResourceId = retainFileResource(descriptorId);
+			return streamId;
 		}
 		case OUTPUT_STREAM_CREATE | FILE: {
-			const { fd, offset } = payload;
-			return createWritableStream(createWriteStream(null, {
+			const { descriptorId, offset } = payload;
+			const fd = fileResourceFd(descriptorId);
+			const streamId = createWritableStream(createWriteStream(null, {
 				fd,
 				autoClose: false,
 				emitClose: false,
-				highWaterMark: 64 * 1024,
+				highWaterMark: 65536,
 				start: Number(offset)
 			}));
+			streams.get(streamId).fileResourceId = retainFileResource(descriptorId);
+			return streamId;
 		}
 	}
 	switch (call & CALL_MASK) {
@@ -1457,10 +1637,13 @@ function handle(call, id, payload) {
 		case INPUT_STREAM_SKIP: return handle(INPUT_STREAM_READ | call & CALL_TYPE_MASK, id, new Uint8Array(Number(payload)));
 		case INPUT_STREAM_BLOCKING_SKIP: return handle(INPUT_STREAM_BLOCKING_READ | call & CALL_TYPE_MASK, id, new Uint8Array(Number(payload)));
 		case INPUT_STREAM_SUBSCRIBE: return createPoll(streams.get(id).pollState);
-		case INPUT_STREAM_DISPOSE:
-			verifyPollsDroppedForDrop(streams.get(id).pollState, "input stream");
+		case INPUT_STREAM_DISPOSE: {
+			const stream = streams.get(id);
+			verifyPollsDroppedForDrop(stream.pollState, "input stream");
 			streams.delete(id);
+			if (stream.fileResourceId) return releaseFileResource(stream.fileResourceId);
 			return;
+		}
 		case OUTPUT_STREAM_CHECK_WRITE: {
 			const { stream, pollState } = getStreamOrThrow(id);
 			const bytes = stream.writableHighWaterMark - stream.writableLength;
@@ -1566,9 +1749,12 @@ function handle(call, id, payload) {
 		case OUTPUT_STREAM_DISPOSE: {
 			const stream = streams.get(id);
 			verifyPollsDroppedForDrop(stream.pollState, "output stream");
-			stream.stream.end();
 			streams.delete(id);
-			return;
+			if (stream.fileResourceId) return new Promise((resolve) => stream.stream.end(resolve)).then(() => releaseFileResource(stream.fileResourceId));
+			else {
+				stream.stream.end();
+				return;
+			}
 		}
 		case POLL_POLLABLE_READY: return polls.get(id).ready;
 		case POLL_POLLABLE_BLOCK: payload = [id];

package/dist/io/worker-thread.d.ts

@@ -9,6 +9,7 @@ export interface Stream {
     stream: NodeJS.ReadableStream | NodeJS.WritableStream;
     flushPromise: Promise<void> | null;
     pollState: any;
+    fileResourceId?: number;
 }
 export interface Future {
     future: {

package/dist/io/worker-thread.js

@@ -6,7 +6,8 @@ import { clearOutgoingResponse, createHttpRequest, setOutgoingResponse, startHtt
 import { Readable } from "node:stream";
 import { read } from "node:fs";
 import { nextTick } from "node:process";
-import { CALL_MASK, CALL_TYPE_MASK, CLOCKS_DURATION_SUBSCRIBE, CLOCKS_INSTANT_SUBSCRIBE, FILE, FUTURE_DISPOSE, FUTURE_SUBSCRIBE, FUTURE_TAKE_VALUE, HTTP, HTTP_CREATE_REQUEST, HTTP_OUTGOING_BODY_DISPOSE, HTTP_OUTPUT_STREAM_FINISH, HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, HTTP_SERVER_SET_OUTGOING_RESPONSE, HTTP_SERVER_START, HTTP_SERVER_STOP, HTTP_SERVER_GET_ADDRESS, INPUT_STREAM_BLOCKING_READ, INPUT_STREAM_BLOCKING_SKIP, INPUT_STREAM_CREATE, INPUT_STREAM_DISPOSE, INPUT_STREAM_READ, INPUT_STREAM_SKIP, INPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_BLOCKING_FLUSH, OUTPUT_STREAM_BLOCKING_SPLICE, OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH, OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH, OUTPUT_STREAM_CHECK_WRITE, OUTPUT_STREAM_CREATE, OUTPUT_STREAM_DISPOSE, OUTPUT_STREAM_FLUSH, OUTPUT_STREAM_SPLICE, OUTPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_WRITE, OUTPUT_STREAM_WRITE_ZEROES, POLL_POLLABLE_BLOCK, POLL_POLLABLE_DISPOSE, POLL_POLLABLE_READY, POLL_POLL_LIST, SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST, SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST, SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST, SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST, SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE, SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE, SOCKET_TCP_ACCEPT, SOCKET_TCP_BIND_FINISH, SOCKET_TCP_BIND_START, SOCKET_TCP_CONNECT_FINISH, SOCKET_TCP_CONNECT_START, SOCKET_TCP_CREATE_HANDLE, SOCKET_TCP_DISPOSE, SOCKET_TCP_GET_LOCAL_ADDRESS, SOCKET_TCP_GET_REMOTE_ADDRESS, SOCKET_TCP_IS_LISTENING, SOCKET_TCP_LISTEN_FINISH, SOCKET_TCP_LISTEN_START, SOCKET_TCP_SET_KEEP_ALIVE, SOCKET_TCP_SET_LISTEN_BACKLOG_SIZE, SOCKET_TCP_SHUTDOWN, SOCKET_TCP_SUBSCRIBE, SOCKET_UDP_BIND_FINISH, SOCKET_UDP_BIND_START, SOCKET_UDP_CREATE_HANDLE, SOCKET_UDP_DISPOSE, SOCKET_UDP_GET_LOCAL_ADDRESS, SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE, SOCKET_UDP_GET_REMOTE_ADDRESS, SOCKET_UDP_GET_SEND_BUFFER_SIZE, SOCKET_UDP_GET_UNICAST_HOP_LIMIT, SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE, SOCKET_UDP_SET_SEND_BUFFER_SIZE, SOCKET_UDP_SET_UNICAST_HOP_LIMIT, SOCKET_UDP_STREAM, SOCKET_UDP_SUBSCRIBE, SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE, SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND, SOCKET_OUTGOING_DATAGRAM_STREAM_SEND, SOCKET_DATAGRAM_STREAM_SUBSCRIBE, SOCKET_DATAGRAM_STREAM_DISPOSE, STDERR, STDIN, STDOUT, reverseMap, } from "./calls.js";
+import { CALL_MASK, CALL_TYPE_MASK, CLOCKS_DURATION_SUBSCRIBE, CLOCKS_INSTANT_SUBSCRIBE, FILE, FILESYSTEM_DESCRIPTOR_CLOSE, FILESYSTEM_DESCRIPTOR_GET_TYPE, FILESYSTEM_DESCRIPTOR_METADATA_HASH, FILESYSTEM_DESCRIPTOR_OPEN, FILESYSTEM_DESCRIPTOR_READ, FILESYSTEM_DESCRIPTOR_SET_SIZE, FILESYSTEM_DESCRIPTOR_SET_TIMES, FILESYSTEM_DESCRIPTOR_STAT, FILESYSTEM_DESCRIPTOR_SYNC, FILESYSTEM_DESCRIPTOR_SYNC_DATA, FILESYSTEM_DESCRIPTOR_WRITE, FUTURE_DISPOSE, FUTURE_SUBSCRIBE, FUTURE_TAKE_VALUE, HTTP, HTTP_CREATE_REQUEST, HTTP_OUTGOING_BODY_DISPOSE, HTTP_OUTPUT_STREAM_FINISH, HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, HTTP_SERVER_SET_OUTGOING_RESPONSE, HTTP_SERVER_START, HTTP_SERVER_STOP, HTTP_SERVER_GET_ADDRESS, INPUT_STREAM_BLOCKING_READ, INPUT_STREAM_BLOCKING_SKIP, INPUT_STREAM_CREATE, INPUT_STREAM_DISPOSE, INPUT_STREAM_READ, INPUT_STREAM_SKIP, INPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_BLOCKING_FLUSH, OUTPUT_STREAM_BLOCKING_SPLICE, OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH, OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH, OUTPUT_STREAM_CHECK_WRITE, OUTPUT_STREAM_CREATE, OUTPUT_STREAM_DISPOSE, OUTPUT_STREAM_FLUSH, OUTPUT_STREAM_SPLICE, OUTPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_WRITE, OUTPUT_STREAM_WRITE_ZEROES, POLL_POLLABLE_BLOCK, POLL_POLLABLE_DISPOSE, POLL_POLLABLE_READY, POLL_POLL_LIST, SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST, SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST, SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST, SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST, SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE, SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE, SOCKET_TCP_ACCEPT, SOCKET_TCP_BIND_FINISH, SOCKET_TCP_BIND_START, SOCKET_TCP_CONNECT_FINISH, SOCKET_TCP_CONNECT_START, SOCKET_TCP_CREATE_HANDLE, SOCKET_TCP_DISPOSE, SOCKET_TCP_GET_LOCAL_ADDRESS, SOCKET_TCP_GET_REMOTE_ADDRESS, SOCKET_TCP_IS_LISTENING, SOCKET_TCP_LISTEN_FINISH, SOCKET_TCP_LISTEN_START, SOCKET_TCP_SET_KEEP_ALIVE, SOCKET_TCP_SET_LISTEN_BACKLOG_SIZE, SOCKET_TCP_SHUTDOWN, SOCKET_TCP_SUBSCRIBE, SOCKET_UDP_BIND_FINISH, SOCKET_UDP_BIND_START, SOCKET_UDP_CREATE_HANDLE, SOCKET_UDP_DISPOSE, SOCKET_UDP_GET_LOCAL_ADDRESS, SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE, SOCKET_UDP_GET_REMOTE_ADDRESS, SOCKET_UDP_GET_SEND_BUFFER_SIZE, SOCKET_UDP_GET_UNICAST_HOP_LIMIT, SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE, SOCKET_UDP_SET_SEND_BUFFER_SIZE, SOCKET_UDP_SET_UNICAST_HOP_LIMIT, SOCKET_UDP_STREAM, SOCKET_UDP_SUBSCRIBE, SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE, SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND, SOCKET_OUTGOING_DATAGRAM_STREAM_SEND, SOCKET_DATAGRAM_STREAM_SUBSCRIBE, SOCKET_DATAGRAM_STREAM_DISPOSE, STDERR, STDIN, STDOUT, reverseMap, } from "./calls.js";
+import { fileResourceFd, getFileResourceType, metadataHashFileResource, openFileResource, readFileResource, releaseFileResource, retainFileResource, setFileResourceSize, setFileResourceTimes, statFileResource, syncFileResource, syncFileResourceData, writeFileResource, } from "./worker-filesystem.js";
 import { SOCKET_STATE_BIND, SOCKET_STATE_BOUND, SOCKET_STATE_CONNECT, SOCKET_STATE_CONNECTION, SOCKET_STATE_LISTEN, SOCKET_STATE_LISTENER, socketResolveAddress, getDefaultSendBufferSize, getDefaultReceiveBufferSize, } from "./worker-sockets.js";
 import { createTcpSocket, socketTcpAccept, socketTcpBindStart, socketTcpConnectStart, socketTcpDispose, socketTcpFinish, socketTcpGetLocalAddress, socketTcpGetRemoteAddress, socketTcpListenStart, socketTcpSetKeepAlive, socketTcpSetListenBacklogSize, socketTcpShutdown, tcpSockets, } from "./worker-socket-tcp.js";
 import { createUdpSocket, datagramStreams, socketDatagramStreamDispose, socketIncomingDatagramStreamReceive, socketOutgoingDatagramStreamCheckSend, socketOutgoingDatagramStreamSend, socketUdpBindFinish, socketUdpBindStart, socketUdpDispose, socketUdpGetLocalAddress, socketUdpGetReceiveBufferSize, socketUdpGetRemoteAddress, socketUdpGetSendBufferSize, socketUdpGetUnicastHopLimit, socketUdpSetReceiveBufferSize, socketUdpSetSendBufferSize, socketUdpSetUnicastHopLimit, socketUdpStream, udpSockets, } from "./worker-socket-udp.js";
@@ -365,18 +366,44 @@ function handle(call, id, payload) {
             return createPoll(pollState);
         }
         // Filesystem
+        case FILESYSTEM_DESCRIPTOR_OPEN:
+            return openFileResource(payload.path, payload.flags);
+        case FILESYSTEM_DESCRIPTOR_CLOSE:
+            return releaseFileResource(id);
+        case FILESYSTEM_DESCRIPTOR_SYNC_DATA:
+            return syncFileResourceData(id);
+        case FILESYSTEM_DESCRIPTOR_GET_TYPE:
+            return getFileResourceType(id);
+        case FILESYSTEM_DESCRIPTOR_SET_SIZE:
+            return setFileResourceSize(id, payload);
+        case FILESYSTEM_DESCRIPTOR_SET_TIMES:
+            return setFileResourceTimes(id, payload.atime, payload.mtime);
+        case FILESYSTEM_DESCRIPTOR_READ:
+            return readFileResource(id, payload.length, payload.offset);
+        case FILESYSTEM_DESCRIPTOR_WRITE:
+            return writeFileResource(id, payload.buffer, payload.offset);
+        case FILESYSTEM_DESCRIPTOR_SYNC:
+            return syncFileResource(id);
+        case FILESYSTEM_DESCRIPTOR_STAT:
+            return statFileResource(id);
+        case FILESYSTEM_DESCRIPTOR_METADATA_HASH:
+            return metadataHashFileResource(id);
         case INPUT_STREAM_CREATE | FILE: {
-            const { fd, offset } = payload;
+            const { descriptorId, offset } = payload;
+            const fd = fileResourceFd(descriptorId);
             const stream = createReadStream(null, {
                 fd,
                 autoClose: false,
                 highWaterMark: 64 * 1024,
                 start: Number(offset),
             });
-            return createReadableStream(stream);
+            const streamId = createReadableStream(stream);
+            streams.get(streamId).fileResourceId = retainFileResource(descriptorId);
+            return streamId;
         }
         case OUTPUT_STREAM_CREATE | FILE: {
-            const { fd, offset } = payload;
+            const { descriptorId, offset } = payload;
+            const fd = fileResourceFd(descriptorId);
             const stream = createWriteStream(null, {
                 fd,
                 autoClose: false,
@@ -384,7 +411,9 @@ function handle(call, id, payload) {
                 highWaterMark: 64 * 1024,
                 start: Number(offset),
             });
-            return createWritableStream(stream);
+            const streamId = createWritableStream(stream);
+            streams.get(streamId).fileResourceId = retainFileResource(descriptorId);
+            return streamId;
         }
     }
     // Generic call implementations (streams + polls)
@@ -421,6 +450,9 @@ function handle(call, id, payload) {
             const stream = streams.get(id);
             verifyPollsDroppedForDrop(stream.pollState, "input stream");
             streams.delete(id);
+            if (stream.fileResourceId) {
+                return releaseFileResource(stream.fileResourceId);
+            }
             return;
         }
         case OUTPUT_STREAM_CHECK_WRITE: {
@@ -599,9 +631,14 @@ function handle(call, id, payload) {
         case OUTPUT_STREAM_DISPOSE: {
             const stream = streams.get(id);
             verifyPollsDroppedForDrop(stream.pollState, "output stream");
-            stream.stream.end();
             streams.delete(id);
-            return;
+            if (stream.fileResourceId) {
+                return new Promise((resolve) => stream.stream.end(resolve)).then(() => releaseFileResource(stream.fileResourceId));
+            }
+            else {
+                stream.stream.end();
+                return;
+            }
         }
         case POLL_POLLABLE_READY:
             return polls.get(id).ready;