@bytecodealliance/preview2-shim 0.0.20 → 0.0.21

package/lib/browser/cli.js

@@ -1,4 +1,8 @@
 import { _setCwd as fsSetCwd } from './filesystem.js';
+import { streams } from './io.js';
+const { InputStream, OutputStream } = streams;
+
+const symbolDispose = Symbol.dispose ?? Symbol.for('dispose');
 
 let _env = [], _args = [], _cwd = null;
 export function _setEnv (envObj) {
@@ -38,50 +42,113 @@ export const exit = {
   }
 };
 
+/**
+ * @param {import('../common/io.js').InputStreamHandler} handler 
+ */
+export function _setStdin (handler) {
+  stdinStream.handler = handler;
+}
+/**
+ * @param {import('../common/io.js').OutputStreamHandler} handler 
+ */
+export function _setStderr (handler) {
+  stderrStream.handler = handler;
+}
+/**
+ * @param {import('../common/io.js').OutputStreamHandler} handler 
+ */
+export function _setStdout (handler) {
+  stdoutStream.handler = handler;
+}
+
+const stdinStream = new InputStream({
+  blockingRead (_len) {
+    // TODO
+  },
+  subscribe () {
+    // TODO
+  },
+  [symbolDispose] () {
+    // TODO
+  }
+});
+let textDecoder = new TextDecoder();
+const stdoutStream = new OutputStream({
+  write (contents) {
+    console.log(textDecoder.decode(contents));
+  },
+  blockingFlush () {
+  },
+  [symbolDispose] () {
+  }
+});
+const stderrStream = new OutputStream({
+  write (contents) {
+    console.error(textDecoder.decode(contents));
+  },
+  blockingFlush () {
+
+  },
+  [symbolDispose] () {
+
+  }
+});
+
 export const stdin = {
+  InputStream,
   getStdin () {
-    return 0;
+    return stdinStream;
   }
 };
 
 export const stdout = {
+  OutputStream,
   getStdout () {
-    return 1;
+    return stdoutStream;
   }
 };
 
 export const stderr = {
+  OutputStream,
   getStderr () {
-    return 2;
+    return stderrStream;
   }
 };
 
-export const terminalInput = {
-  dropTerminalInput () {
+class TerminalInput {}
+class TerminalOutput {}
 
-  }
+const terminalStdoutInstance = new TerminalOutput();
+const terminalStderrInstance = new TerminalOutput();
+const terminalStdinInstance = new TerminalInput();
+
+export const terminalInput = {
+  TerminalInput,
+  dropTerminalInput () {}
 };
 
 export const terminalOutput = {
-  dropTerminalOutput () {
-
-  }
+  TerminalOutput,
+  dropTerminalOutput () {}
 };
 
 export const terminalStderr = {
+  TerminalOutput,
   getTerminalStderr () {
-    return 0;
+    return terminalStderrInstance;
   }
 };
 
 export const terminalStdin = {
+  TerminalInput,
   getTerminalStdin () {
-    return 1;
+    return terminalStdinInstance;
   }
 };
 
 export const terminalStdout = {
+  TerminalOutput,
   getTerminalStdout () {
-    return 2;
+    return terminalStdoutInstance;
   }
 };

package/lib/browser/filesystem.js

@@ -1,15 +1,7 @@
-import { _io } from './io.js';
+import { streams } from './io.js';
 import { environment } from './cli.js';
 
-const { createStream, getStream, dropStream } = _io;
-
-let _preopens = [[3, '/']], _rootPreopen = _preopens[0];
-
-export function _setPreopens (preopens) {
-  _preopens = preopens;
-  descriptorCnt = 3 + _preopens.length;
-  _rootPreopen = _preopens.find(preopen => preopen[1] === '/');
-}
+const { InputStream, OutputStream } = streams;
 
 let _cwd = null;
 
@@ -19,11 +11,7 @@ export function _setCwd (cwd) {
 
 export function _setFileData (fileData) {
   _fileData = fileData;
-  _setPreopens(Object.keys(fileData).map((key) => {
-    const fd = descriptorCnt++;
-    descriptorTable[fd] = { entry: fileData[key] };
-    return [fd, key];
-  }));
+  _rootPreopen[0] = new Descriptor(fileData);
   const cwd = environment.initialCwd();
   _setCwd(cwd || '/');
 }
@@ -32,34 +20,20 @@ export function _getFileData () {
   return JSON.stringify(_fileData);
 }
 
-let _fileData = {};
-
-let descriptorCnt = 4;
-const descriptorTable = {
-  0: { stream: 0 },
-  1: { stream: 1 },
-  2: { stream: 2 },
-  3: { entry: { dir: {} } },
-};
+let _fileData = { dir: {} };
 
 const timeZero = {
   seconds: BigInt(0),
   nanoseconds: 0
 };
 
-function getDescriptor (fd) {
-  const descriptor = descriptorTable[fd];
-  if (!descriptor) throw 'bad-descriptor';
-  return descriptor;
-}
-
-function getChildEntry (fd, subpath, openFlags) {
-  if (subpath === '.' && _rootPreopen && _rootPreopen[0] === fd) {
+function getChildEntry (parentEntry, subpath, openFlags) {
+  if (subpath === '.' && _rootPreopen && descriptorGetEntry(_rootPreopen[0]) === parentEntry) {
     subpath = _cwd;
-    if (subpath.startsWith('/'))
+    if (subpath.startsWith('/') && subpath !== '/')
       subpath = subpath.slice(1);
   }
-  let entry = getDescriptor(fd)?.entry;
+  let entry = parentEntry;
   let segmentIdx;
   do {
     if (!entry || !entry.dir) throw 'not-directory';
@@ -76,13 +50,6 @@ function getChildEntry (fd, subpath, openFlags) {
   return entry;
 }
 
-function createChildDescriptor (fd, subpath, openFlags) {
-  const entry = getChildEntry(fd, subpath, openFlags);
-  const childFd = descriptorCnt++;
-  descriptorTable[childFd] = { entry };
-  return childFd;
-}
-
 function getSource (fileEntry) {
   if (typeof fileEntry.source === 'string') {
     fileEntry.source = new TextEncoder().encode(fileEntry.source);
@@ -90,12 +57,12 @@ function getSource (fileEntry) {
   return fileEntry.source;
 }
 
-class DirStream {
+class DirectoryEntryStream {
   constructor (entries) {
     this.idx = 0;
     this.entries = entries;
   }
-  next () {
+  readDirectoryEntry () {
     if (this.idx === this.entries.length)
       return null;
     const [name, entry] = this.entries[this.idx];
@@ -107,117 +74,120 @@ class DirStream {
   }
 }
 
-export const preopens = {
-  getDirectories () {
-    return _preopens;
+class Descriptor {
+  #stream;
+  #entry;
+  #mtime = 0;
+
+  _getEntry (descriptor) {
+    return descriptor.#entry;
   }
-}
 
-export const types = {
-  readViaStream(fd, offset) {
-    const descriptor = getDescriptor(fd);
-    const source = getSource(descriptor.entry);
-    return createStream({
-      i: Number(offset),
-      source,
-      read (len) {
-        const bytes = this.source.slice(this.i, this.i + Number(len));
-        this.i += bytes.byteLength;
-        return [bytes, this.i === this.source.byteLength ? 'ended' : 'open'];
+  constructor (entry, isStream) {
+    if (isStream)
+      this.#stream = entry;
+    else
+      this.#entry = entry;
+  }
+
+  readViaStream(_offset) {
+    const source = getSource(this.#entry);
+    let offset = Number(_offset);
+    return new InputStream({
+      blockingRead (len) {
+        if (offset === source.byteLength)
+          throw { tag: 'closed' };
+        const bytes = source.slice(offset, offset + Number(len));
+        offset += bytes.byteLength;
+        return bytes;
       }
     });
-  },
+  }
 
-  writeViaStream(fd, offset) {
-    const descriptor = getDescriptor(fd);
-    return createStream({
-      i: Number(offset),
-      entry: descriptor.entry,
+  writeViaStream(_offset) {
+    const entry = this.#entry;
+    let offset = Number(_offset);
+    return new OutputStream({
       write (buf) {
-        const newSource = new Uint8Array(buf.byteLength + this.entry.source.byteLength);
-        newSource.set(this.entry.source, 0);
-        newSource.set(buf, this.i);
-        this.i += buf.byteLength;
-        this.entry.source = newSource;
+        const newSource = new Uint8Array(buf.byteLength + entry.source.byteLength);
+        newSource.set(entry.source, 0);
+        newSource.set(buf, offset);
+        offset += buf.byteLength;
+        entry.source = newSource;
         return buf.byteLength;
       }
     });
-  },
-
-  appendViaStream(fd) {
-    console.log(`[filesystem] APPEND STREAM ${fd}`);
-  },
-
-  advise(fd, offset, length, advice) {
-    console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
-  },
-
-  syncData(fd) {
-    console.log(`[filesystem] SYNC DATA ${fd}`);
-  },
-
-  getFlags(fd) {
-    console.log(`[filesystem] FLAGS FOR ${fd}`);
-  },
-
-  getType(fd) {
-    if (fd < 3) return 'fifo';
-    const descriptor = getDescriptor(fd);
-    if (descriptor.stream) return 'fifo';
-    if (descriptor.entry.dir) return 'directory';
-    if (descriptor.entry.source) return 'regular-file';
+  }
+
+  appendViaStream() {
+    console.log(`[filesystem] APPEND STREAM`);
+  }
+
+  advise(descriptor, offset, length, advice) {
+    console.log(`[filesystem] ADVISE`, descriptor, offset, length, advice);
+  }
+
+  syncData() {
+    console.log(`[filesystem] SYNC DATA`);
+  }
+
+  getFlags() {
+    console.log(`[filesystem] FLAGS FOR`);
+  }
+
+  getType() {
+    if (this.#stream) return 'fifo';
+    if (this.#entry.dir) return 'directory';
+    if (this.#entry.source) return 'regular-file';
     return 'unknown';
-  },
+  }
 
-  setFlags(fd, flags) {
-    console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
-  },
+  setFlags(flags) {
+    console.log(`[filesystem] SET FLAGS ${JSON.stringify(flags)}`);
+  }
 
-  setSize(fd, size) {
-    console.log(`[filesystem] SET SIZE`, fd, size);
-  },
+  setSize(size) {
+    console.log(`[filesystem] SET SIZE`, size);
+  }
 
-  setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
-    console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
-  },
+  setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+    console.log(`[filesystem] SET TIMES`, dataAccessTimestamp, dataModificationTimestamp);
+  }
 
-  read(fd, length, offset) {
-    const descriptor = getDescriptor(fd);
-    const source = getSource(descriptor.entry);
+  read(length, offset) {
+    const source = getSource(this.#entry);
     return [source.slice(offset, offset + length), offset + length >= source.byteLength];
-  },
+  }
 
-  write(fd, buffer, offset) {
-    const descriptor = getDescriptor(fd);
+  write(buffer, offset) {
     if (offset !== 0) throw 'invalid-seek';
-    descriptor.entry.source = buffer;
+    this.#entry.source = buffer;
     return buffer.byteLength;
-  },
+  }
 
-  readDirectory(fd) {
-    const descriptor = getDescriptor(fd);
-    if (!descriptor?.entry?.dir) throw 'bad-descriptor';
-    return createStream(new DirStream(Object.entries(descriptor.entry.dir).sort(([a], [b]) => a > b ? 1 : -1)));
-  },
+  readDirectory() {
+    if (!this.#entry?.dir)
+      throw 'bad-descriptor';
+    return new DirectoryEntryStream(Object.entries(this.#entry.dir).sort(([a], [b]) => a > b ? 1 : -1));
+  }
 
-  sync(fd) {
-    console.log(`[filesystem] SYNC`, fd);
-  },
+  sync() {
+    console.log(`[filesystem] SYNC`);
+  }
 
-  createDirectoryAt(fd, path) {
-    const entry = getChildEntry(fd, path, { create: true, directory: true });
+  createDirectoryAt(path) {
+    const entry = getChildEntry(this.#entry, path, { create: true, directory: true });
     if (entry.source) throw 'exist';
-  },
+  }
 
-  stat(fd) {
-    const descriptor = getDescriptor(fd);
+  stat() {
     let type = 'unknown', size = BigInt(0);
-    if (descriptor.entry.source) {
+    if (this.#entry.source) {
       type = 'directory';
     }
-    else if (descriptor.entry.dir) {
+    else if (this.#entry.dir) {
       type = 'regular-file';
-      const source = getSource(descriptor.entry);
+      const source = getSource(this.#entry);
       size = BigInt(source.byteLength);
     }
     return {
@@ -228,10 +198,10 @@ export const types = {
       dataModificationTimestamp: timeZero,
       statusChangeTimestamp: timeZero,
     }
-  },
+  }
   
-  statAt(fd, pathFlags, path) {
-    const entry = getChildEntry(fd, path);
+  statAt(_pathFlags, path) {
+    const entry = getChildEntry(this.#entry, path);
     let type = 'unknown', size = BigInt(0);
     if (entry.source) {
       type = 'regular-file';
@@ -249,95 +219,95 @@ export const types = {
       dataModificationTimestamp: timeZero,
       statusChangeTimestamp: timeZero,
     };
-  },
-
-  setTimesAt(fd) {
-    console.log(`[filesystem] SET TIMES AT`, fd);
-  },
-
-  linkAt(fd) {
-    console.log(`[filesystem] LINK AT`, fd);
-  },
-
-  openAt(fd, _pathFlags, path, openFlags, _descriptorFlags, _modes) {
-    return createChildDescriptor(fd, path, openFlags);
-  },
+  }
 
-  readlinkAt(fd) {
-    console.log(`[filesystem] READLINK AT`, fd);
-  },
+  setTimesAt() {
+    console.log(`[filesystem] SET TIMES AT`);
+  }
 
-  removeDirectoryAt(fd) {
-    console.log(`[filesystem] REMOVE DIR AT`, fd);
-  },
+  linkAt() {
+    console.log(`[filesystem] LINK AT`);
+  }
 
-  renameAt(fd) {
-    console.log(`[filesystem] RENAME AT`, fd);
-  },
+  openAt(_pathFlags, path, openFlags, _descriptorFlags, _modes) {
+    const childEntry = getChildEntry(this.#entry, path, openFlags);
+    return new Descriptor(childEntry);
+  }
 
-  symlinkAt(fd) {
-    console.log(`[filesystem] SYMLINK AT`, fd);
-  },
+  readlinkAt() {
+    console.log(`[filesystem] READLINK AT`);
+  }
 
-  unlinkFileAt(fd) {
-    console.log(`[filesystem] UNLINK FILE AT`, fd);
-  },
+  removeDirectoryAt() {
+    console.log(`[filesystem] REMOVE DIR AT`);
+  }
 
-  changeFilePermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
-  },
+  renameAt() {
+    console.log(`[filesystem] RENAME AT`);
+  }
 
-  changeDirectoryPermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
-  },
+  symlinkAt() {
+    console.log(`[filesystem] SYMLINK AT`);
+  }
 
-  lockShared(fd) {
-    console.log(`[filesystem] LOCK SHARED`, fd);
-  },
+  unlinkFileAt() {
+    console.log(`[filesystem] UNLINK FILE AT`);
+  }
 
-  lockExclusive(fd) {
-    console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
-  },
+  changeFilePermissionsAt() {
+    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`);
+  }
 
-  tryLockShared(fd) {
-    console.log(`[filesystem] TRY LOCK SHARED`, fd);
-  },
+  changeDirectoryPermissionsAt() {
+    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`);
+  }
 
-  tryLockExclusive(fd) {
-    console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
-  },
+  lockShared() {
+    console.log(`[filesystem] LOCK SHARED`);
+  }
 
-  unlock(fd) {
-    console.log(`[filesystem] UNLOCK`, fd);
-  },
+  lockExclusive() {
+    console.log(`[filesystem] LOCK EXCLUSIVE`);
+  }
 
-  dropDescriptor(fd) {
-    if (fd < _preopens.length + 3)
-      return;
-    delete descriptorTable[fd];
-  },
+  tryLockShared() {
+    console.log(`[filesystem] TRY LOCK SHARED`);
+  }
 
-  readDirectoryEntry(sid) {
-    return getStream(sid).next();
-  },
+  tryLockExclusive() {
+    console.log(`[filesystem] TRY LOCK EXCLUSIVE`);
+  }
 
-  dropDirectoryEntryStream(sid) {
-    dropStream(sid);
-  },
+  unlock() {
+    console.log(`[filesystem] UNLOCK`);
+  }
 
-  metadataHash(fd) {
-    const descriptor = getDescriptor(fd);
+  metadataHash() {
     let upper = BigInt(0);
-    upper += BigInt(descriptor.mtime || 0);
+    upper += BigInt(this.#mtime);
     return { upper, lower: BigInt(0) };
-  },
+  }
 
-  metadataHashAt(fd, _pathFlags, _path) {
-    const descriptor = getDescriptor(fd);
+  metadataHashAt(_pathFlags, _path) {
     let upper = BigInt(0);
-    upper += BigInt(descriptor.mtime || 0);
+    upper += BigInt(this.#mtime);
     return { upper, lower: BigInt(0) };
   }
+}
+const descriptorGetEntry = Descriptor.prototype._getEntry;
+delete Descriptor.prototype._getEntry;
+
+let _preopens = [[new Descriptor(_fileData), '/']], _rootPreopen = _preopens[0];
+
+export const preopens = {
+  getDirectories () {
+    return _preopens;
+  }
+}
+
+export const types = {
+  Descriptor,
+  DirectoryEntryStream
 };
 
-export { types as filesystemTypes }
+export { types as filesystemTypes }

package/lib/browser/index.js

@@ -1,7 +1,7 @@
 import * as clocks from "./clocks.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
-import * as io from "../common/io.js";
+import * as io from "./io.js";
 import * as random from "./random.js";
 import * as sockets from "./sockets.js";
 import * as cli from "./cli.js";
@@ -15,5 +15,3 @@ export {
   sockets,
   cli,
 }
-
-export { WasiHttp } from "../http/wasi-http.js";

package/lib/browser/io.js

@@ -0,0 +1,183 @@
+let id = 0;
+
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+
+class Error {
+  constructor (msg) {
+    this.msg = msg;
+  }
+  toDebugString () {
+    return this.msg;
+  }
+}
+
+/**
+ * @typedef {{
+ *   read?: (len: BigInt) => Uint8Array,
+ *   blockingRead: (len: BigInt) => Uint8Array,
+ *   skip?: (len: BigInt) => BigInt,
+ *   blockingSkip?: (len: BigInt) => BigInt,
+ *   subscribe: () => void,
+ *   drop?: () => void,
+ * }} InputStreamHandler
+ * 
+ * @typedef {{
+ *   checkWrite?: () -> BigInt,
+ *   write: (buf: Uint8Array) => BigInt,
+ *   blockingWriteAndFlush?: (buf: Uint8Array) => void,
+ *   flush?: () => void,
+ *   blockingFlush: () => void,
+ *   writeZeroes?: (len: BigInt) => void,
+ *   blockingWriteZeroes?: (len: BigInt) => void,
+ *   blockingWriteZeroesAndFlush?: (len: BigInt) => void,
+ *   splice?: (src: InputStream, len: BigInt) => BigInt,
+ *   blockingSplice?: (src: InputStream, len: BigInt) => BigInt,
+ *   forward?: (src: InputStream) => void,
+ *   subscribe?: () => void,
+ *   drop?: () => void,
+ * }} OutputStreamHandler
+ * 
+ **/
+
+class InputStream {
+  /**
+   * @param {InputStreamHandler} handler
+   */
+  constructor (handler) {
+    if (!handler)
+      console.trace('no handler');
+    this.id = ++id;
+    this.handler = handler;
+  }
+  read(len) {
+    if (this.handler.read)
+      return this.handler.read(len);
+    return this.handler.blockingRead.call(this, len);
+  }
+  blockingRead(len) {
+    return this.handler.blockingRead.call(this, len);
+  }
+  skip(len) {
+    if (this.handler.skip)
+      return this.handler.skip.call(this, len);
+    if (this.handler.read) {
+      const bytes = this.handler.read.call(this, len);
+      return BigInt(bytes.byteLength);
+    }
+    return this.blockingSkip.call(this, len);
+  }
+  blockingSkip(len) {
+    if (this.handler.blockingSkip)
+      return this.handler.blockingSkip.call(this, len);
+    const bytes = this.handler.blockingRead.call(this, len);
+    return BigInt(bytes.byteLength);
+  }
+  subscribe() {
+    console.log(`[streams] Subscribe to input stream ${this.id}`);
+  }
+  [symbolDispose] () {
+    if (this.handler.drop)
+      this.handler.drop.call(this);
+  }
+}
+
+class OutputStream {
+  /**
+   * @param {OutputStreamHandler} handler
+   */
+  constructor (handler) {
+    if (!handler)
+      console.trace('no handler');
+    this.id = ++id;
+    this.open = true;
+    this.handler = handler;
+  }
+  checkWrite(len) {
+    if (!this.open)
+      return 0n;
+    if (this.handler.checkWrite)
+      return this.handler.checkWrite.call(this, len);
+    return 1_000_000n;
+  }
+  write(buf) {
+    this.handler.write.call(this, buf);
+  }
+  blockingWriteAndFlush(buf) {
+    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+    /// until all of these operations are complete, or an error occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write`, and `flush`, and is implemented with the
+    /// following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while !contents.is_empty() {
+    ///     // Wait for the stream to become writable
+    ///     poll-one(pollable);
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, contents.len());
+    ///     let (chunk, rest) = contents.split_at(len);
+    ///     this.write(chunk  );            // eliding error handling
+    ///     contents = rest;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// poll-one(pollable);
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    this.handler.write.call(this, buf);
+  }
+  flush() {
+    if (this.handler.flush)
+      this.handler.flush.call(this);
+  }
+  blockingFlush() {
+    this.open = true;
+  }
+  writeZeroes(len) {
+    this.write.call(this, new Uint8Array(Number(len)));
+  }
+  blockingWriteZeroes(len) {
+    this.blockingWrite.call(this, new Uint8Array(Number(len)));
+  }
+  blockingWriteZeroesAndFlush(len) {
+    this.blockingWriteAndFlush.call(this, new Uint8Array(Number(len)));
+  }
+  splice(src, len) {
+    const spliceLen = Math.min(len, this.checkWrite.call(this));
+    const bytes = src.read(spliceLen);
+    this.write.call(this, bytes);
+    return bytes.byteLength;
+  }
+  blockingSplice(_src, _len) {
+    console.log(`[streams] Blocking splice ${this.id}`);
+  }
+  forward(_src) {
+    console.log(`[streams] Forward ${this.id}`);
+  }
+  subscribe() {
+    console.log(`[streams] Subscribe to output stream ${this.id}`);
+  }
+  [symbolDispose]() {
+  }
+}
+
+export const streams = { Error, InputStream, OutputStream };
+
+class Pollable {}
+
+function pollList (_list) {
+  // TODO
+}
+
+function pollOne (_poll) {
+  // TODO
+}
+
+export const poll = {
+  Pollable,
+  pollList,
+  pollOne
+};

package/lib/common/io.js

@@ -1,5 +1,7 @@
 let id = 0;
 
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+
 class Error {
   constructor (msg) {
     this.msg = msg;
@@ -73,7 +75,7 @@ class InputStream {
   subscribe() {
     console.log(`[streams] Subscribe to input stream ${this.id}`);
   }
-  drop () {
+  [symbolDispose] () {
     if (this.handler.drop)
       this.handler.drop.call(this);
   }
@@ -158,7 +160,7 @@ class OutputStream {
   subscribe() {
     console.log(`[streams] Subscribe to output stream ${this.id}`);
   }
-  drop() {
+  [symbolDispose]() {
   }
 }
 

package/lib/nodejs/cli.js

@@ -2,7 +2,8 @@ import { argv, env, cwd } from 'node:process';
 import { streams } from '../common/io.js';
 const { InputStream, OutputStream } = streams;
 
-let _env = Object.entries(env), _args = argv, _cwd = cwd();
+let _env = Object.entries(env), _args = argv.slice(1), _cwd = cwd();
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
 
 export const environment = {
   getEnvironment () {
@@ -29,7 +30,7 @@ const stdinStream = new InputStream({
   subscribe () {
     // TODO
   },
-  drop () {
+  [symbolDispose] () {
     // TODO
   }
 });
@@ -39,7 +40,7 @@ const stdoutStream = new OutputStream({
   },
   blockingFlush () {
   },
-  drop () {
+  [symbolDispose] () {
   }
 });
 const stderrStream = new OutputStream({
@@ -49,7 +50,7 @@ const stderrStream = new OutputStream({
   blockingFlush () {
 
   },
-  drop () {
+  [symbolDispose] () {
 
   }
 });

package/lib/nodejs/filesystem.js

@@ -5,6 +5,8 @@ import { platform } from 'node:process';
 
 const { InputStream, OutputStream, Error: StreamError } = streams;
 
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+
 const isWindows = platform === 'win32';
 
 const nsMagnitude = 1_000_000_000_000n;
@@ -39,35 +41,6 @@ function lookupType (obj) {
  * } DescriptorProps
  */
 export class FileSystem {
-  // Note: This should implement per-segment semantics of openAt, but we cannot currently
-  //       due to the lack of support for openat() in Node.js.
-  //       Tracking issue: https://github.com/libuv/libuv/issues/4167
-
-  // TODO: support followSymlinks
-  getFullPath (descriptor, subpath, _followSymlinks) {
-    if (subpath.indexOf('\\') !== -1)
-      subpath = subpath.replace(/\\/g, '/');
-    if (subpath[0] === '/') {
-      let bestPreopenMatch = '';
-      for (const preopenEntry of this.preopenEntries) {
-        if (subpath.startsWith(preopenEntry[1]) && (!bestPreopenMatch || bestPreopenMatch.length < preopenEntry[1].length)) {
-          bestPreopenMatch = preopenEntry;
-        }
-      }
-      if (!bestPreopenMatch)
-        throw 'no-entry';
-      descriptor = bestPreopenMatch[0];
-      subpath = subpath.slice(bestPreopenMatch[1]);
-      if (subpath[0] === '/')
-        subpath = subpath.slice(1);
-    }
-    if (subpath.startsWith('.'))
-      subpath = subpath.slice(subpath[1] === '/' ? 2 : 1);
-    if (descriptor.hostPreopen)
-      return descriptor.hostPreopen + (descriptor.hostPreopen.endsWith('/') ? '' : '/') + subpath;
-    return descriptor.fullPath + '/' + subpath;
-  }
-
   /**
    * 
    * @param {[string, string][]} preopens 
@@ -79,16 +52,18 @@ export class FileSystem {
     this.cwd = environment.initialCwd();
 
     class FileInputStream extends InputStream {
+      #hostFd;
+      #position;
       constructor (hostFd, position) {
         super({
           blockingRead (len) {
             const buf = new Uint8Array(Number(len));
             try {
-              var bytesRead = readSync(this.hostFd, buf, 0, buf.byteLength, this.position);
+              var bytesRead = readSync(self.#hostFd, buf, 0, buf.byteLength, self.#position);
             } catch (e) {
               throw { tag: 'last-operation-failed', val: new StreamError(e.message) };
             }
-            this.position += bytesRead;
+            self.#position += bytesRead;
             if (bytesRead < buf.byteLength) {
               if (bytesRead === 0)
                 throw { tag: 'closed' };
@@ -99,26 +74,29 @@ export class FileSystem {
           subscribe () {
             // TODO
           },
-          drop () {
+          [symbolDispose] () {
             // TODO
           }
         });
-        this.hostFd = hostFd;
-        this.position = Number(position);
+        const self = this;
+        this.#hostFd = hostFd;
+        this.#position = Number(position);
       }
     }
     
     class FileOutputStream extends OutputStream {
+      #hostFd;
+      #position;
       constructor (hostFd, position) {
         super({
           write (contents) {
             let totalWritten = 0;
             while (totalWritten !== contents.byteLength) {
-              const bytesWritten = writeSync(this.hostFd, contents, null, null, this.position);
+              const bytesWritten = writeSync(self.#hostFd, contents, null, null, self.#position);
               totalWritten += bytesWritten;
               contents = new Uint8Array(contents.buffer, bytesWritten);
             }
-            this.position += contents.byteLength;
+            self.#position += contents.byteLength;
           },
           blockingFlush () {
 
@@ -127,19 +105,18 @@ export class FileSystem {
 
           }
         });
-        this.hostFd = hostFd;
-        this.position = Number(position);
+        const self = this;
+        this.#hostFd = hostFd;
+        this.#position = Number(position);
       }
     }
     
     class DirectoryEntryStream {
-      constructor (dir) {
-        this.dir = dir;
-      }
+      #dir;
       readDirectoryEntry () {
         let entry;
         try {
-          entry = this.dir.readSync();
+          entry = this.#dir.readSync();
         } catch (e) {
           throw convertFsError(e);
         }
@@ -150,27 +127,54 @@ export class FileSystem {
         const type = lookupType(entry);
         return { name, type };
       }
-      drop () {
-        this.dir.closeSync();
+      [symbolDispose] () {
+        this.#dir.closeSync();
+      }
+
+      static _create (dir) {
+        const dirStream = new DirectoryEntryStream();
+        dirStream.#dir = dir;
+        return dirStream;
       }
     }
+    const directoryEntryStreamCreate = DirectoryEntryStream._create;
+    delete DirectoryEntryStream._create;
 
+    // Note: This should implement per-segment semantics of openAt, but we cannot currently
+    //       due to the lack of support for openat() in Node.js.
+    //       Tracking issue: https://github.com/libuv/libuv/issues/4167
     /**
      * @implements {DescriptorProps}
      */
     class Descriptor {
+      #hostPreopen;
+      #fd;
+      #fullPath;
+
+      static _createPreopen (hostPreopen) {
+        const descriptor = new Descriptor();
+        descriptor.#hostPreopen = hostPreopen;
+        return descriptor;
+      }
+      static _create (fd, fullPath) {
+        const descriptor = new Descriptor();
+        descriptor.#fd = fd;
+        descriptor.#fullPath = fullPath;
+        return descriptor;
+      }
+
       constructor () {
         this.id = fs.descriptorCnt++;
       }
       readViaStream(offset) {
-        if (this.hostPreopen)
+        if (this.#hostPreopen)
           throw { tag: 'last-operation-failed', val: new StreamError };
-        return new FileInputStream(this.fd, offset);
+        return new FileInputStream(this.#fd, offset);
       }
       writeViaStream(offset) {
-        if (this.hostPreopen)
+        if (this.#hostPreopen)
           throw 'is-directory';
-        return new FileOutputStream(this.fd, offset);
+        return new FileOutputStream(this.#fd, offset);
       }
     
       appendViaStream() {
@@ -190,8 +194,8 @@ export class FileSystem {
       }
     
       getType() {
-        if (this.hostPreopen) return 'directory';
-        const stats = fstatSync(this.fd);
+        if (this.#hostPreopen) return 'directory';
+        const stats = fstatSync(this.#fd);
         return lookupType(stats);
       }
     
@@ -208,23 +212,23 @@ export class FileSystem {
       }
 
       read(length, offset) {
-        if (!this.fullPath) throw 'bad-descriptor';
+        if (!this.#fullPath) throw 'bad-descriptor';
         const buf = new Uint8Array(length);
-        const bytesRead = readSync(this.fd, buf, Number(offset), length, 0);
+        const bytesRead = readSync(this.#fd, buf, Number(offset), length, 0);
         const out = new Uint8Array(buf.buffer, 0, bytesRead);
         return [out, bytesRead === 0 ? 'ended' : 'open'];
       }
 
       write(buffer, offset) {
-        if (!this.fullPath) throw 'bad-descriptor';
-        return BigInt(writeSync(this.fd, buffer, Number(offset), buffer.byteLength - offset, 0));
+        if (!this.#fullPath) throw 'bad-descriptor';
+        return BigInt(writeSync(this.#fd, buffer, Number(offset), buffer.byteLength - offset, 0));
       }
 
       readDirectory() {
-        if (!this.fullPath) throw 'bad-descriptor';
+        if (!this.#fullPath) throw 'bad-descriptor';
         try {
-          const dir = opendirSync(isWindows ? this.fullPath.slice(1) : this.fullPath);
-          return new DirectoryEntryStream(dir);
+          const dir = opendirSync(isWindows ? this.#fullPath.slice(1) : this.#fullPath);
+          return directoryEntryStreamCreate(dir);
         }
         catch (e) {
           throw convertFsError(e);
@@ -236,7 +240,7 @@ export class FileSystem {
       }
     
       createDirectoryAt(path) {
-        const fullPath = fs.getFullPath(this, path);
+        const fullPath = this.#getFullPath(path);
         try {
           mkdirSync(fullPath);
         }
@@ -246,10 +250,10 @@ export class FileSystem {
       }
 
       stat() {
-        if (this.hostPreopen) throw 'invalid';
+        if (this.#hostPreopen) throw 'invalid';
         let stats;
         try {
-          stats = fstatSync(this.fd, { bigint: true });
+          stats = fstatSync(this.#fd, { bigint: true });
         }
         catch (e) {
           convertFsError(e);
@@ -266,7 +270,7 @@ export class FileSystem {
       }
 
       statAt(pathFlags, path) {
-        const fullPath = fs.getFullPath(this, path, false);
+        const fullPath = this.#getFullPath(path, false);
         let stats;
         try {
           stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(isWindows ? fullPath.slice(1) : fullPath, { bigint: true });
@@ -294,7 +298,7 @@ export class FileSystem {
       }
 
       openAt(pathFlags, path, openFlags, descriptorFlags, modes) {
-        const fullPath = fs.getFullPath(this, path, pathFlags.symlinkFollow);
+        const fullPath = this.#getFullPath(path, pathFlags.symlinkFollow);
         let fsOpenFlags = 0x0;
         if (openFlags.create)
           fsOpenFlags |= constants.O_CREAT;
@@ -325,7 +329,7 @@ export class FileSystem {
 
         try {
           const fd = openSync(isWindows ? fullPath.slice(1) : fullPath, fsOpenFlags, fsMode);
-          return Object.assign(new Descriptor(), { fullPath, fd });
+          return descriptorCreate(fd, fullPath);
         }
         catch (e) {
           throw convertFsError(e);
@@ -380,16 +384,16 @@ export class FileSystem {
         console.log(`[filesystem] UNLOCK`, this.id);
       }
 
-      drop() {
-        if (this.fd)
-          closeSync(this.fd);
+      [symbolDispose]() {
+        if (this.#fd)
+          closeSync(this.#fd);
       }
 
       metadataHash() {
-        if (this.hostPreopen)
+        if (this.#hostPreopen)
           return { upper: 0n, lower: BigInt(this.id) };
         try {
-          const stats = fstatSync(this.fd, { bigint: true });
+          const stats = fstatSync(this.#fd, { bigint: true });
           return { upper: stats.mtimeNs, lower: stats.ino };
         }
         catch (e) {
@@ -398,7 +402,7 @@ export class FileSystem {
       }
 
       metadataHashAt(pathFlags, path) {
-        const fullPath = fs.getFullPath(this, path, false);
+        const fullPath = this.#getFullPath(path, false);
         try {
           const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(isWindows ? fullPath.slice(1) : fullPath, { bigint: true });
           return { upper: stats.mtimeNs, lower: stats.ino };
@@ -407,12 +411,43 @@ export class FileSystem {
           convertFsError(e);
         }
       }
+
+      // TODO: support followSymlinks
+      #getFullPath (subpath, _followSymlinks) {
+        let descriptor = this;
+        if (subpath.indexOf('\\') !== -1)
+          subpath = subpath.replace(/\\/g, '/');
+        if (subpath[0] === '/') {
+          let bestPreopenMatch = '';
+          for (const preopenEntry of fs.preopenEntries) {
+            if (subpath.startsWith(preopenEntry[1]) && (!bestPreopenMatch || bestPreopenMatch.length < preopenEntry[1].length)) {
+              bestPreopenMatch = preopenEntry;
+            }
+          }
+          if (!bestPreopenMatch)
+            throw 'no-entry';
+          descriptor = bestPreopenMatch[0];
+          subpath = subpath.slice(bestPreopenMatch[1]);
+          if (subpath[0] === '/')
+            subpath = subpath.slice(1);
+        }
+        if (subpath.startsWith('.'))
+          subpath = subpath.slice(subpath[1] === '/' ? 2 : 1);
+        if (descriptor.#hostPreopen)
+          return descriptor.#hostPreopen + (descriptor.#hostPreopen.endsWith('/') ? '' : '/') + subpath;
+        return descriptor.#fullPath + '/' + subpath;
+      }
     }
 
+    const descriptorCreatePreopen = Descriptor._createPreopen;
+    delete Descriptor._createPreopen;
+    const descriptorCreate = Descriptor._create;
+    delete Descriptor._create;
+
     this.descriptorCnt = 3;
     this.preopenEntries = [];
     for (const [virtualPath, hostPreopen] of Object.entries(preopens)) {
-      const preopenEntry = [Object.assign(new Descriptor(), { hostPreopen }), virtualPath];
+      const preopenEntry = [descriptorCreatePreopen(hostPreopen), virtualPath];
       this.preopenEntries.push(preopenEntry);
     }
     this.preopens = {
@@ -428,9 +463,7 @@ export class FileSystem {
   }
 }
 
-const _fs = new FileSystem({ '/': '/' }, environment);
-
-export const { preopens, types } = _fs;
+export const { preopens, types } = new FileSystem({ '/': '/' }, environment);
 
 function convertFsError (e) {
   switch (e.code) {

package/lib/nodejs/http.js

@@ -308,5 +308,4 @@ export class WasiHttp {
   }
 }
 
-const http = new WasiHttp();
-export const { outgoingHandler, types } = http;
+export const { outgoingHandler, types } = new WasiHttp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",