@bytecodealliance/preview2-shim 0.0.19 → 0.0.21

package/lib/browser/io.js

@@ -1,39 +1,183 @@
-import { Io } from '../common/io.js';
+let id = 0;
 
-// buffer until the next newline
-export class NewlineBufferStream {
+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) {
-    this.bufferLen = 0;
-    this.bufferCapacity = 1024;
-    this.buffer = new Uint8Array(1024);
+    if (!handler)
+      console.trace('no handler');
+    this.id = ++id;
     this.handler = handler;
   }
-  write (bytes) {
-    const newlineIdx = bytes.lastIndexOf(10);
-    if (newlineIdx === -1) {
-      this.#addToBuffer(bytes);
-    } else {
-      this.#addToBuffer(bytes.slice(0, newlineIdx + 1));
-      this.handler(new TextDecoder().decode(this.buffer.slice(0, this.bufferLen)));
-      this.bufferLen = 0;
-      this.#addToBuffer(bytes.slice(newlineIdx + 1));
-    }
+  read(len) {
+    if (this.handler.read)
+      return this.handler.read(len);
+    return this.handler.blockingRead.call(this, len);
   }
-  #addToBuffer (bytes) {
-    if (bytes.byteLength + this.bufferLen > this.bufferCapacity) {
-      this.bufferCapacity *= 2;
-      const buffer = new Uint8Array(this.bufferCapacity);
-      buffer.set(this.buffer);
-      this.buffer = buffer;
+  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);
     }
-    this.buffer.set(bytes, this.bufferLen);
-    this.bufferLen += 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
 }
 
-export const _io = new Io(
-  new NewlineBufferStream(console.log.bind(console)),
-  new NewlineBufferStream(console.error.bind(console))
-);
+function pollOne (_poll) {
+  // TODO
+}
 
-export const streams = _io.streams;
+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;
@@ -16,7 +18,7 @@ class Error {
  *   skip?: (len: BigInt) => BigInt,
  *   blockingSkip?: (len: BigInt) => BigInt,
  *   subscribe: () => void,
- *   drop: () => void,
+ *   drop?: () => void,
  * }} InputStreamHandler
  * 
  * @typedef {{
@@ -32,7 +34,7 @@ class Error {
  *   blockingSplice?: (src: InputStream, len: BigInt) => BigInt,
  *   forward?: (src: InputStream) => void,
  *   subscribe?: () => void,
- *   drop: () => void,
+ *   drop?: () => void,
  * }} OutputStreamHandler
  * 
  **/
@@ -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/{http → common}/make-request.js

@@ -1,4 +1,4 @@
-import { runAsWorker } from "./synckit/index.js";
+import { runAsWorker } from "../synckit/index.js";
 
 /**
  * @param {import("../../types/interfaces/wasi-http-types").Request} req

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) {