@bytecodealliance/preview2-shim 0.0.20 → 0.14.0

package/README.md

@@ -1,20 +1,10 @@
-# WASI Preview2 JavaScript Shim
+# Preview2 Shim
 
-_**Experimental**_ shim modules for the [WASI Preview2](https://github.com/bytecodealliance/preview2-prototyping) component interfaces in JS environments.
+WASI Preview2 implementations for Node.js & browsers.
 
-Currently supports Node.js and browser versions, but alternative implementations for any JS environments can be supported.
+Browser support is considered experimental, and not currently suitable for production applications.
 
-## Implementation Status
-
-| Interface       | Node.js                      | Browser                      |
-| --------------- | ----------------------------:|-----------------------------:|
-| Clocks          | Pending timezone, poll       | Pending timezone, poll       |
-| Filesystem      | Basic read support           | _N/A_                        |
-| HTTP            | Experimental support         | :x:                          |
-| IO              | Experimental support         | Experimental support         |
-| Random          | :heavy_check_mark:           | :heavy_check_mark:           |
-| Sockets         | :x:                          | _N/A_                        |
-| CLI             | :heavy_check_mark:           | :heavy_check_mark:           |
+Node.js support is currently being stabilized, which can be tracked in https://github.com/bytecodealliance/jco/milestone/1.
 
 # License
 

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,111 @@ 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
 };
 
 export const terminalOutput = {
-  dropTerminalOutput () {
-
-  }
+  TerminalOutput
 };
 
 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/clocks.js

@@ -1,34 +1,23 @@
-function _hrtimeBigint () {
-  // performance.now() is in milliseconds, but we want nanoseconds
-  return BigInt(Math.floor(performance.now() * 1e6));
-}
-
-let _hrStart = _hrtimeBigint();
-
 export const monotonicClock = {
   resolution() {
-    return 1n;
+    // usually we dont get sub-millisecond accuracy in the browser
+    // Note: is there a better way to determine this?
+    return 1e6;
   },
   now () {
-    return _hrtimeBigint() - _hrStart;
+    // performance.now() is in milliseconds, but we want nanoseconds
+    return BigInt(Math.floor(performance.now() * 1e6));
   },
-  subscribe (_when, _absolute) {
-    console.log(`[monotonic-clock] Subscribe`);
-  }
-};
-
-export const timezone = {
-  display (timezone, when) {
-    console.log(`[timezone] DISPLAY ${timezone} ${when}`);
+  subscribeInstant (instant) {
+    instant = BigInt(instant);
+    const now = this.now();
+    if (instant <= now)
+      return this.subscribeDuration(0);
+    return this.subscribeDuration(instant - now);
   },
-
-  utcOffset (timezone, when) {
-    console.log(`[timezone] UTC OFFSET ${timezone} ${when}`);
-    return 0;
-  },
-
-  dropTimezone (timezone) {
-    console.log(`[timezone] DROP ${timezone}`);
+  subscribeDuration (_duration) {
+    _duration = BigInt(_duration);
+    console.log(`[monotonic-clock] subscribe`);
   }
 };
 
@@ -39,8 +28,7 @@ export const wallClock = {
     const nanoseconds = (now % 1e3) * 1e6;
     return { seconds, nanoseconds };
   },
-
   resolution() {
-    console.log(`[wall-clock] Wall clock resolution`);
+    return { seconds: 0n, nanoseconds: 1e6 };
   }
 };

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,116 @@ 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';
-    return 'unknown';
-  },
+  }
 
-  setFlags(fd, flags) {
-    console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
-  },
+  appendViaStream() {
+    console.log(`[filesystem] APPEND STREAM`);
+  }
 
-  setSize(fd, size) {
-    console.log(`[filesystem] SET SIZE`, fd, size);
-  },
+  advise(descriptor, offset, length, advice) {
+    console.log(`[filesystem] ADVISE`, descriptor, offset, length, advice);
+  }
 
-  setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
-    console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
-  },
+  syncData() {
+    console.log(`[filesystem] SYNC DATA`);
+  }
+
+  getFlags() {
+    console.log(`[filesystem] FLAGS FOR`);
+  }
 
-  read(fd, length, offset) {
-    const descriptor = getDescriptor(fd);
-    const source = getSource(descriptor.entry);
+  getType() {
+    if (this.#stream) return 'fifo';
+    if (this.#entry.dir) return 'directory';
+    if (this.#entry.source) return 'regular-file';
+    return 'unknown';
+  }
+
+  setSize(size) {
+    console.log(`[filesystem] SET SIZE`, size);
+  }
+
+  setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+    console.log(`[filesystem] SET TIMES`, dataAccessTimestamp, dataModificationTimestamp);
+  }
+
+  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 +194,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 +215,71 @@ 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);
-  },
-
-  removeDirectoryAt(fd) {
-    console.log(`[filesystem] REMOVE DIR AT`, fd);
-  },
-
-  renameAt(fd) {
-    console.log(`[filesystem] RENAME AT`, fd);
-  },
-
-  symlinkAt(fd) {
-    console.log(`[filesystem] SYMLINK AT`, fd);
-  },
-
-  unlinkFileAt(fd) {
-    console.log(`[filesystem] UNLINK FILE AT`, fd);
-  },
-
-  changeFilePermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
-  },
+  }
 
-  changeDirectoryPermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
-  },
+  setTimesAt() {
+    console.log(`[filesystem] SET TIMES AT`);
+  }
 
-  lockShared(fd) {
-    console.log(`[filesystem] LOCK SHARED`, fd);
-  },
+  linkAt() {
+    console.log(`[filesystem] LINK AT`);
+  }
 
-  lockExclusive(fd) {
-    console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
-  },
+  openAt(_pathFlags, path, openFlags, _descriptorFlags, _modes) {
+    const childEntry = getChildEntry(this.#entry, path, openFlags);
+    return new Descriptor(childEntry);
+  }
 
-  tryLockShared(fd) {
-    console.log(`[filesystem] TRY LOCK SHARED`, fd);
-  },
+  readlinkAt() {
+    console.log(`[filesystem] READLINK AT`);
+  }
 
-  tryLockExclusive(fd) {
-    console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
-  },
+  removeDirectoryAt() {
+    console.log(`[filesystem] REMOVE DIR AT`);
+  }
 
-  unlock(fd) {
-    console.log(`[filesystem] UNLOCK`, fd);
-  },
+  renameAt() {
+    console.log(`[filesystem] RENAME AT`);
+  }
 
-  dropDescriptor(fd) {
-    if (fd < _preopens.length + 3)
-      return;
-    delete descriptorTable[fd];
-  },
+  symlinkAt() {
+    console.log(`[filesystem] SYMLINK AT`);
+  }
 
-  readDirectoryEntry(sid) {
-    return getStream(sid).next();
-  },
+  unlinkFileAt() {
+    console.log(`[filesystem] UNLINK FILE AT`);
+  }
 
-  dropDirectoryEntryStream(sid) {
-    dropStream(sid);
-  },
+  isSameObject(other) {
+    return other === this;
+  }
 
-  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";