@bytecodealliance/preview2-shim 0.0.7 → 0.0.8

package/README.md

@@ -8,10 +8,10 @@ Currently supports Node.js and browser versions, but alternative implementations
 
 | Interface       | Node.js                      | Browser                      |
 | --------------- | ----------------------------:|-----------------------------:|
-| Clocks          | Pending timezone, resolution | Pending timezone, resolution |
-| Filesystem      | :x:                          | :x:                          |
+| Clocks          | Pending timezone, poll       | Pending timezone, poll       |
+| Filesystem      | Basic read support           | :x:                          |
 | HTTP            | :x:                          | :x:                          |
-| IO              | :x:                          | :x:                          |
+| IO              | Basic FS Streams             | :x:                          |
 | Logging         | :heavy_check_mark:           | :heavy_check_mark:           |
 | Poll            | :x:                          | :x:                          |
 | Random          | :heavy_check_mark:           | :heavy_check_mark:           |

package/lib/browser/environment.js

@@ -1,3 +1,17 @@
+let _env;
+export function _setEnv (envObj) {
+  _env = Object.entries(envObj);
+}
+
 export function getEnvironment () {
+  if (!_env) _env = [];
+  return _env;
+}
+
+export function preopens () {
   return [];
 }
+
+export function getArguments () {
+  return [];
+}

package/lib/browser/index.js

@@ -1,29 +1,45 @@
-import * as logging from "./logging.js";
+import * as console from "./console.js";
 import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
 import * as environment from "./environment.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
-import * as http from "./http.js";
+import * as instanceNetwork from "./instance-network.js";
+import * as ipNameLookup from "./ip-name-lookup.js";
 import * as monotonicClock from "./monotonic-clock.js";
+import * as network from "./network.js";
 import * as poll from "./poll.js";
 import * as preopens from "./preopens.js";
 import * as random from "./random.js";
 import * as streams from "./streams.js";
+import * as tcpCreateSocket from "./tcp-create-socket.js";
+import * as tcp from "./tcp.js";
+import * as timezone from "./timezone.js";
+import * as types from "./types.js";
+import * as udpCreateSocket from "./udp-create-socket.js";
+import * as udp from "./udp.js";
 import * as wallClock from "./wall-clock.js";
 
 export const importObject = {
-    "default-outgoing-HTTP": defaultOutgoingHttp,
-    "environment": environment,
-    "exit": exit,
-    "filesystem": filesystem,
-    "http": http,
-    "logging": logging,
-    "monotonic-clock": monotonicClock,
-    "poll": poll,
-    "preopens": preopens,
-    "random": random,
-    "streams": streams,
-    "wall-clock": wallClock,
+  'console': console,
+  'default-outgoing-HTTP': defaultOutgoingHttp,
+  'environment': environment,
+  'exit': exit,
+  'filesystem': filesystem,
+  'instance-network': instanceNetwork,
+  'ip-name-lookup': ipNameLookup,
+  'monotonic-clock': monotonicClock,
+  'network': network,
+  'poll': poll,
+  'preopens': preopens,
+  'random': random,
+  'streams': streams,
+  'tcp-create-socket': tcpCreateSocket,
+  'tcp': tcp,
+  'timezone': timezone,
+  'types': types,
+  'udp-create-socket': udpCreateSocket,
+  'udp': udp,
+  'wall-clock': wallClock
 };
 
 export { WasiHttp } from "../http/wasi-http.js";

package/lib/browser/instance-network.js

@@ -0,0 +1,3 @@
+export function instanceNetwork () {
+
+}

package/lib/browser/ip-name-lookup.js

@@ -0,0 +1,23 @@
+export function dropResolveAddressStream () {
+
+}
+
+export function subscribe () {
+
+}
+
+export function resolveAddresses () {
+
+}
+
+export function resolveNextAddress () {
+
+}
+
+export function nonBlocking () {
+
+}
+
+export function setNonBlocking () {
+
+}

package/lib/browser/monotonic-clock.js

@@ -3,33 +3,12 @@ export function resolution(clock) {
   console.log(`[monotonic-clock] Monotonic clock resolution ${clock}`);
 }
 
-let hrStart = hrtimeBigint();
-
-export function now(clock) {
-  if (clock === 0) {
-    return hrtimeBigint() - hrStart;
-  }
-  console.log(`[monotonic clock] Unknown clock ${clock}`);
+function _hrtimeBigint () {
+  return BigInt(Math.floor(performance.now() * 1e9));
 }
 
-function hrtime(previousTimestamp) {
-  const baseNow = Math.floor((Date.now() - performance.now()) * 1e-3);
-  const clocktime = performance.now() * 1e-3;
-  let seconds = Math.floor(clocktime) + baseNow;
-  let nanoseconds = Math.floor((clocktime % 1) * 1e9);
-
-  if (previousTimestamp) {
-    seconds = seconds - previousTimestamp[0];
-    nanoseconds = nanoseconds - previousTimestamp[1];
-    if (nanoseconds < 0) {
-      seconds--;
-      nanoseconds += 1e9;
-    }
-  }
-  return [seconds, nanoseconds];
-}
+let _hrStart = _hrtimeBigint();
 
-function hrtimeBigint(time) {
-  const diff = hrtime(time);
-  return BigInt(diff[0] * 1e9 + diff[1]);
+export function now () {
+  return _hrtimeBigint() - _hrStart;
 }

package/lib/browser/network.js

@@ -0,0 +1,3 @@
+export function dropNetwork () {
+
+}

package/lib/browser/tcp-create-socket.js

@@ -0,0 +1,3 @@
+export function createTcpSocket () {
+  
+}

package/lib/browser/tcp.js

@@ -0,0 +1,75 @@
+export function subscribe () {
+
+}
+export function dropTcpSocket() {
+
+}
+export function bind() {
+
+}
+export function connect() {
+
+}
+export function listen() {
+
+}
+export function accept() {
+
+}
+export function localAddress() {
+
+}
+export function remoteAddress() {
+
+}
+export function addressFamily() {
+
+}
+export function ipv6Only() {
+
+}
+export function setIpv6Only() {
+
+}
+export function setListenBacklogSize() {
+
+}
+export function keepAlive() {
+
+}
+export function setKeepAlive() {
+
+}
+export function noDelay() {
+
+}
+export function setNoDelay() {
+
+}
+export function unicastHopLimit() {
+
+}
+export function setUnicastHopLimit() {
+
+}
+export function receiveBufferSize() {
+
+}
+export function setReceiveBufferSize() {
+
+}
+export function sendBufferSize() {
+
+}
+export function setSendBufferSize() {
+
+}
+export function nonBlocking() {
+
+}
+export function setNonBlocking() {
+
+}
+export function shutdown() {
+
+}

package/lib/browser/udp-create-socket.js

@@ -0,0 +1,3 @@
+export function createUdpSocket () {
+
+}

package/lib/browser/udp.js

@@ -0,0 +1,75 @@
+export function subscribe () {
+
+}
+
+export function dropUdpSocket () {
+
+}
+
+export function bind () {
+
+}
+
+export function connect () {
+
+}
+
+export function receive () {
+
+}
+
+export function send () {
+
+}
+
+export function localAddress () {
+
+}
+
+export function remoteAddress () {
+
+}
+
+export function addressFamily () {
+
+}
+
+export function ipv6Only () {
+
+}
+
+export function setIpv6Only () {
+
+}
+
+export function unicastHopLimit () {
+
+}
+
+export function setUnicastHopLimit () {
+
+}
+
+export function receiveBufferSize () {
+
+}
+
+export function setReceiveBufferSize () {
+
+}
+
+export function sendBufferSize () {
+
+}
+
+export function setSendBufferSize () {
+
+}
+
+export function nonBlocking () {
+
+}
+
+export function setNonBlocking () {
+
+}

package/lib/browser/wall-clock.js

@@ -1,12 +1,9 @@
-export function now(clock) {
-  if (clock === 1) {
-    const seconds = BigInt(Math.floor(Date.now() / 1000));
-    const nanoseconds = (Date.now() % 1000) * 1000 * 1000;
-    return { seconds, nanoseconds };
-  }
-  console.log(`[wall-clock] Unknown clock ${clock}`);
+export function now() {
+  const seconds = BigInt(Math.floor(Date.now() / 1e3));
+  const nanoseconds = (Date.now() % 1e3) * 1e6;
+  return { seconds, nanoseconds };
 }
 
-export function resolution(clock) {
-  console.log(`[wall-clock] Wall clock resolution ${clock}`);
+export function resolution() {
+  console.log(`[wall-clock] Wall clock resolution`);
 }

package/lib/nodejs/environment.js

@@ -1,7 +1,19 @@
+import process from 'node:process';
+
+let _env;
+export function _setEnv (envObj) {
+  _env = Object.entries(envObj);
+}
+
 export function getEnvironment () {
-  return [];
+  if (!_env) _setEnv(process.env);
+  return _env;
 }
 
 export function preopens () {
   return [];
+}
+
+export function getArguments () {
+  return [];
 }

package/lib/nodejs/exit.js

@@ -1,4 +1,3 @@
 export function exit(status) {
-  console.log(`[exit] Exit: ${JSON.stringify(status)}`);
   process.exit(status.tag === 'err' ? 1 : 0);
 }

package/lib/nodejs/filesystem.js

@@ -1,16 +1,9 @@
-// export interface DescriptorStat {
-//   dev: Device,
-//   ino: Inode,
-//   type: DescriptorType,
-//   nlink: Linkcount,
-//   size: Filesize,
-//   atim: Timestamp,
-//   mtim: Timestamp,
-//   ctim: Timestamp,
-// }
+import { openSync, constants, statSync, lstatSync, fstatSync, closeSync, readdirSync } from 'node:fs';
+import { _descriptors, _addOpenedDescriptor, _removeOpenedDescriptor, _getDescriptorType, _setSubdescriptorType, _setDescriptorType, _getFullPath } from './preopens.js';
+import { _createFileStream } from './streams.js';
 
 export function readViaStream(fd, offset) {
-  console.log(`[filesystem] READ STREAM ${fd} ${offset}`);
+  return _createFileStream(fd, offset);
 }
 
 export function writeViaStream(fd, offset) {
@@ -34,7 +27,12 @@ export function getFlags(fd) {
 }
 
 export function getType(fd) {
-  console.log(`[filesystem] GET TYPE ${fd}`);
+  let type = _getDescriptorType(fd);
+  if (type === null) {
+    stat(fd);
+    type = _getDescriptorType(fd);
+  }
+  return type;
 }
 
 export function setFlags(fd, flags) {
@@ -57,8 +55,18 @@ export function write(fd, buffer, offset) {
   console.log(`[filesystem] WRITE`, fd, buffer, offset);
 }
 
+let _dirStreams = [];
 export function readDirectory(fd) {
-  console.log(`[filesystem] READ DIR`, fd);
+  const fullPath = _getFullPath(fd);
+  let dirs;
+  try {
+    dirs = readdirSync(fullPath, { withFileTypes: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  _dirStreams.push({ fd, dirs, cursor: 0 });
+  return _dirStreams.length - 1;
 }
 
 export function sync(fd) {
@@ -69,12 +77,118 @@ export function createDirectoryAt(fd, path) {
   console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
 }
 
-export function stat(fd) {
-  console.log(`[filesystem] STAT`, fd);
+const nsMagnitude = 1_000_000_000_000n;
+function nsToDateTime (ns) {
+  const seconds = ns / nsMagnitude;
+  const nanoseconds = Number(ns % seconds);
+  return { seconds, nanoseconds };
+}
+
+export function _convertFsError (e) {
+  switch (e.code) {
+    case 'EACCES': throw 'access';
+    case 'EAGAIN':
+    case 'EWOULDBLOCK': throw 'would-block';
+    case 'EALREADY': throw 'already';
+    case 'EBADF': throw 'bad-descriptor';
+    case 'EBUSY': throw 'busy';
+    case 'EDEADLK': throw 'deadlock';
+    case 'EDQUOT': throw 'quota';
+    case 'EEXIST': throw 'exist';
+    case 'EFBIG': throw 'file-too-large';
+    case 'EILSEQ': throw 'illegal-byte-sequence';
+    case 'EINPROGRESS': throw 'in-progress';
+    case 'EINTR': throw 'interrupted';
+    case 'EINVAL': throw 'invalid';
+    case 'EIO': throw 'io';
+    case 'EISDIR': throw 'is-directory';
+    case 'ELOOP': throw 'loop';
+    case 'EMLINK': throw 'too-many-links';
+    case 'EMSGSIZE': throw 'message-size';
+    case 'ENAMETOOLONG': throw 'name-too-long'
+    case 'ENODEV': throw 'no-device';
+    case 'ENOENT': throw 'no-entry';
+    case 'ENOLCK': throw 'no-lock';
+    case 'ENOMEM': throw 'insufficient-memory';
+    case 'ENOSPC': throw 'insufficient-space';
+    case 'ENOTDIR': throw 'not-directory';
+    case 'ENOTEMPTY': throw 'not-empty';
+    case 'ENOTRECOVERABLE': throw 'not-recoverable';
+    case 'ENOTSUP': throw 'unsupported';
+    case 'ENOTTY': throw 'no-tty';
+    case 'ENXIO': throw 'no-such-device';
+    case 'EOVERFLOW': throw 'overflow';
+    case 'EPERM': throw 'not-permitted';
+    case 'EPIPE': throw 'pipe';
+    case 'EROFS': throw 'read-only';
+    case 'ESPIPE': throw 'invalid-seek';
+    case 'ETXTBSY': throw 'text-file-busy';
+    case 'EXDEV': throw 'cross-device';
+    default: throw e;
+  }
+}
+
+function _lookupType (obj) {
+  if (obj.isFile())
+    return 'regular-file';
+  else if (obj.isSocket())
+    return 'socket';
+  else if (obj.isSymbolicLink())
+    return 'symbolic-link';
+  else if (obj.isFIFO())
+    return 'fifo';
+  else if (obj.isDirectory())
+    return 'directory';
+  else if (obj.isCharacterDevice())
+    return 'character-device';
+  else if (obj.isBlockDevice())
+    return 'block-device';
+  return 'unknown';
 }
 
-export function statAt(fd, pathFlags, path) {
-  console.log(`[filesystem] STAT`, fd, pathFlags, path);
+export function stat(fd) {
+  let stats;
+  try {
+    stats = fstatSync(fd, { bigint: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  const type = _lookupType(stats);
+  _setDescriptorType(fd, type);
+  return {
+    device: stats.dev,
+    inode: stats.ino,
+    type,
+    linkCount: stats.nlink,
+    size: stats.size,
+    dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+    dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+    statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+  };
+}
+
+export function statAt(fd, { symlinkFollow }, path) {
+  const fullPath = _descriptors[fd].path + path;
+  let stats;
+  try {
+    stats = (symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  const type = _lookupType(stats);
+  _setSubdescriptorType(fd, path, type);
+  return {
+    device: stats.dev,
+    inode: stats.ino,
+    type,
+    linkCount: stats.nlink,
+    size: stats.size,
+    dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+    dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+    statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+  };
 }
 
 export function setTimesAt(fd) {
@@ -85,8 +199,45 @@ export function linkAt(fd) {
   console.log(`[filesystem] LINK AT`, fd);
 }
 
-export function openAt(fd) {
-  console.log(`[filesystem] OPEN AT`, fd);
+export function openAt(fd, pathFlags, path, openFlags, descriptorFlags, modes) {
+  // TODO
+  // if (pathFlags.symlinkFollow) {
+  //   // resolve symlink
+  // }
+  const fullPath = _descriptors[fd].path + path;
+  let fsOpenFlags = 0x0;
+  if (openFlags.create)
+    fsOpenFlags |= constants.O_CREAT;
+  if (openFlags.directory)
+    fsOpenFlags |= constants.O_DIRECTORY;
+  if (openFlags.exclusive)
+    fsOpenFlags |= constants.O_EXCL;
+  if (openFlags.truncate)
+    fsOpenFlags |= constants.O_TRUNC;
+  if (descriptorFlags.read && descriptorFlags.write)
+    fsOpenFlags |= constants.O_RDWR;
+  else if (descriptorFlags.write)
+    fsOpenFlags |= constants.O_WRONLY;
+  // if (descriptorFlags.fileIntegritySync)
+  // if (descriptorFlags.dataIntegritySync)
+  // if (descriptorFlags.requestedWriteSync)
+  // if (descriptorFlags.mutateDirectory)
+  let fsMode = 0x0;
+  if (modes.readable)
+    fsMode |= 0o444;
+  if (modes.writeable)
+    fsMode |= 0o222;
+  if (modes.executable)
+    fsMode |= 0o111;
+  let localFd;
+  try {
+    localFd = openSync(fullPath, fsOpenFlags, fsMode);
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  _addOpenedDescriptor(localFd, path, fd);
+  return localFd;
 }
 
 export function readlinkAt(fd) {
@@ -138,13 +289,20 @@ export function unlock(fd) {
 }
 
 export function dropDescriptor(fd) {
-  console.log(`[filesystem] DROP DESCRIPTOR`, fd);
+  _removeOpenedDescriptor(fd);
+  closeSync(fd);
 }
 
 export function readDirectoryEntry(stream) {
-  console.log(`[filesystem] READ DIRECTRY ENTRY`, stream);
+  const streamValue = _dirStreams[stream];
+  if (streamValue.cursor === streamValue.dirs.length)
+    return null;
+  const dir = streamValue.dirs[streamValue.cursor++];
+  const type = _lookupType(dir);
+  _setSubdescriptorType(streamValue.fd, '/' + dir.name, type);
+  return { inode: null, type, name: dir.name };
 }
 
 export function dropDirectoryEntryStream(stream) {
-  console.log(`[filesystem] DROP DIRECTORY ENTRY`, stream);
+  _dirStreams.splice(stream, 1);
 }

package/lib/nodejs/index.js

@@ -1,29 +1,45 @@
-import * as logging from "./logging.js";
+import * as console from "./console.js";
 import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
 import * as environment from "./environment.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
-import * as http from "./http.js";
+import * as instanceNetwork from "./instance-network.js";
+import * as ipNameLookup from "./ip-name-lookup.js";
 import * as monotonicClock from "./monotonic-clock.js";
+import * as network from "./network.js";
 import * as poll from "./poll.js";
 import * as preopens from "./preopens.js";
 import * as random from "./random.js";
 import * as streams from "./streams.js";
+import * as tcpCreateSocket from "./tcp-create-socket.js";
+import * as tcp from "./tcp.js";
+import * as timezone from "./timezone.js";
+import * as types from "./types.js";
+import * as udpCreateSocket from "./udp-create-socket.js";
+import * as udp from "./udp.js";
 import * as wallClock from "./wall-clock.js";
 
 export const importObject = {
-    "default-outgoing-HTTP": defaultOutgoingHttp,
-    "environment": environment,
-    "exit": exit,
-    "filesystem": filesystem,
-    "http": http,
-    "logging": logging,
-    "monotonic-clock": monotonicClock,
-    "poll": poll,
-    "preopens": preopens,
-    "random": random,
-    "streams": streams,
-    "wall-clock": wallClock,
+  'console': console,
+  'default-outgoing-HTTP': defaultOutgoingHttp,
+  'environment': environment,
+  'exit': exit,
+  'filesystem': filesystem,
+  'instance-network': instanceNetwork,
+  'ip-name-lookup': ipNameLookup,
+  'monotonic-clock': monotonicClock,
+  'network': network,
+  'poll': poll,
+  'preopens': preopens,
+  'random': random,
+  'streams': streams,
+  'tcp-create-socket': tcpCreateSocket,
+  'tcp': tcp,
+  'timezone': timezone,
+  'types': types,
+  'udp-create-socket': udpCreateSocket,
+  'udp': udp,
+  'wall-clock': wallClock
 };
 
 export { WasiHttp } from "../http/wasi-http.js";

package/lib/nodejs/instance-network.js

@@ -0,0 +1,3 @@
+export function instanceNetwork () {
+
+}

package/lib/nodejs/ip-name-lookup.js

@@ -0,0 +1,23 @@
+export function dropResolveAddressStream () {
+
+}
+
+export function subscribe () {
+
+}
+
+export function resolveAddresses () {
+
+}
+
+export function resolveNextAddress () {
+
+}
+
+export function nonBlocking () {
+
+}
+
+export function setNonBlocking () {
+
+}

package/lib/nodejs/monotonic-clock.js

@@ -1,12 +1,12 @@
 import { hrtime } from "node:process";
 
-export function resolution() {
-  console.log(`[monotonic-clock] Monotonic clock resolution`);
+export function resolution () {
+  return 1n;
 }
 
-let hrStart = hrtime.bigint();
-export function now() {
-  return hrtime.bigint() - hrStart;
+let _hrStart = hrtime.bigint();
+export function now () {
+  return hrtime.bigint() - _hrStart;
 }
 
 export function subscribe (_when, _absolute) {

package/lib/nodejs/network.js

@@ -0,0 +1,3 @@
+export function dropNetwork () {
+
+}

package/lib/nodejs/preopens.js

@@ -1,3 +1,61 @@
+// default is full permissions
+let preopenCnt = 4;
+export let _descriptors = {
+  3: { type: 'directory', path: '/', parent: null, subpathTypes: {} }
+};
+let directories = [[3, '/']];
+
+export function _getFullPath (fd) {
+  let path = '';
+  while (fd) {
+    path = _descriptors[fd].path + path;
+    fd = _descriptors[fd].parent;
+  }
+  return path;
+}
+
+export function _getDescriptorType (fd) {
+  return _descriptors[fd].type;
+}
+
+export function _setDescriptorType (fd, type) {
+  _descriptors[fd].type = type;
+}
+
+export function _setSubdescriptorType (fd, path, type) {
+  while (_descriptors[fd].parent) {
+    path = _descriptors[fd].path + path;
+    fd = _descriptors[fd].parent;
+  }
+  _descriptors[fd].subpathTypes[path] = type;
+}
+
+export function _addOpenedDescriptor (fd, path, parentFd) {
+  if (fd < preopenCnt || _descriptors[fd])
+    throw 'bad-descriptor';
+  let type = null;
+  for (const [_path, _type] of Object.entries(_descriptors[parentFd].subpathTypes)) {
+    if (_path === path)
+      type = _type;
+  }
+  _descriptors[fd] = { path, type, parent: parentFd, subpathTypes: {} };
+}
+
+export function _removeOpenedDescriptor (fd) {
+  if (fd < preopenCnt)
+    throw 'eperm';
+  delete _descriptors[fd];
+}
+
+export function _setPreopens (preopens) {
+  _descriptors = {};
+  directories = [,,];
+  for (const [virtualPath, path] of Object.entries(preopens)) {
+    _descriptors[preopenCnt] = { type: 'directory', path, parent: null, subpathTypes: {} };
+    directories.push([preopenCnt++, virtualPath]);
+  }
+}
+
 export function getStdio () {
   return {
     stdin: 0,
@@ -7,5 +65,5 @@ export function getStdio () {
 }
 
 export function getDirectories () {
-  return [];
+  return directories;
 }

package/lib/nodejs/streams.js

@@ -1,3 +1,18 @@
+import { readSync as fsReadSync } from 'node:fs';
+import { _convertFsError } from './filesystem.js';
+
+export let _streams = {};
+let streamCnt = 0;
+export function _createFileStream(fd, offset) {
+  // note we only support offset 0
+  if (Number(offset) === 0)
+    _streams[streamCnt] = {
+      type: 'file',
+      fd: fd
+    };
+  return streamCnt++;
+}
+
 export function read(s, len) {
   switch (s) {
     case 0:
@@ -6,8 +21,26 @@ export function read(s, len) {
       throw new Error(`TODO: write ${s}`);
   }
 }
-export function blockingRead(s, _len) {
-  console.log(`[streams] Blocking read ${s}`);
+export function blockingRead(s, len) {
+  len = Number(len);
+  const stream = _streams[s];
+  if (!stream) throw null;
+  switch (stream.type) {
+    case 'file': {
+      const buf = Buffer.alloc(Number(len));
+      try {
+        const readBytes = fsReadSync(stream.fd, buf, 0, Number(len));
+        if (readBytes < Number(len))
+          return [new Uint8Array(), true];
+        return [new Uint8Array(buf.buffer, 0, readBytes), false];
+      }
+      catch (e) {
+        _convertFsError(e);
+      }
+      break;
+    }
+    default: throw null;
+  }
 }
 export function skip(s, _len) {
   console.log(`[streams] Skip ${s}`);
@@ -19,7 +52,8 @@ export function subscribeToInputStream(s) {
   console.log(`[streams] Subscribe to input stream ${s}`);
 }
 export function dropInputStream(s) {
-  console.log(`[streams] Drop input stream ${s}`);
+  delete _streams[s];
+
 }
 export function write(s, buf) {
   switch (s) {

package/lib/nodejs/tcp-create-socket.js

@@ -0,0 +1,3 @@
+export function createTcpSocket () {
+  
+}

package/lib/nodejs/tcp.js

@@ -0,0 +1,75 @@
+export function subscribe () {
+
+}
+export function dropTcpSocket() {
+
+}
+export function bind() {
+
+}
+export function connect() {
+
+}
+export function listen() {
+
+}
+export function accept() {
+
+}
+export function localAddress() {
+
+}
+export function remoteAddress() {
+
+}
+export function addressFamily() {
+
+}
+export function ipv6Only() {
+
+}
+export function setIpv6Only() {
+
+}
+export function setListenBacklogSize() {
+
+}
+export function keepAlive() {
+
+}
+export function setKeepAlive() {
+
+}
+export function noDelay() {
+
+}
+export function setNoDelay() {
+
+}
+export function unicastHopLimit() {
+
+}
+export function setUnicastHopLimit() {
+
+}
+export function receiveBufferSize() {
+
+}
+export function setReceiveBufferSize() {
+
+}
+export function sendBufferSize() {
+
+}
+export function setSendBufferSize() {
+
+}
+export function nonBlocking() {
+
+}
+export function setNonBlocking() {
+
+}
+export function shutdown() {
+
+}

package/lib/nodejs/udp-create-socket.js

@@ -0,0 +1,3 @@
+export function createUdpSocket () {
+
+}

package/lib/nodejs/udp.js

@@ -0,0 +1,75 @@
+export function subscribe () {
+
+}
+
+export function dropUdpSocket () {
+
+}
+
+export function bind () {
+
+}
+
+export function connect () {
+
+}
+
+export function receive () {
+
+}
+
+export function send () {
+
+}
+
+export function localAddress () {
+
+}
+
+export function remoteAddress () {
+
+}
+
+export function addressFamily () {
+
+}
+
+export function ipv6Only () {
+
+}
+
+export function setIpv6Only () {
+
+}
+
+export function unicastHopLimit () {
+
+}
+
+export function setUnicastHopLimit () {
+
+}
+
+export function receiveBufferSize () {
+
+}
+
+export function setReceiveBufferSize () {
+
+}
+
+export function sendBufferSize () {
+
+}
+
+export function setSendBufferSize () {
+
+}
+
+export function nonBlocking () {
+
+}
+
+export function setNonBlocking () {
+
+}

package/lib/nodejs/wall-clock.js

@@ -1,12 +1,9 @@
-export function now(clock) {
-  if (clock === 1) {
-    const seconds = BigInt(Math.floor(Date.now() / 1000));
-    const nanoseconds = (Date.now() % 1000) * 1000 * 1000;
-    return { seconds, nanoseconds };
-  }
-  console.log(`[wall-clock] now() UNKNOWN CLOCK ${clock}`);
+export function now() {
+  const seconds = BigInt(Math.floor(Date.now() / 1e3));
+  const nanoseconds = (Date.now() % 1e3) * 1e6;
+  return { seconds, nanoseconds };
 }
 
-export function resolution(clock) {
-  console.log(`[wall-clock] Wall clock resolution ${clock}`);
+export function resolution() {
+  console.log(`[wall-clock] Wall clock resolution`);
 }

package/package.json

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

package/types/imports/filesystem.d.ts

@@ -6,7 +6,6 @@ export namespace Filesystem {
   export function syncData(this: Descriptor): void;
   export function getFlags(this: Descriptor): DescriptorFlags;
   export function getType(this: Descriptor): DescriptorType;
-  export function setFlags(this: Descriptor, flags: DescriptorFlags): void;
   export function setSize(this: Descriptor, size: Filesize): void;
   export function setTimes(this: Descriptor, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
   export function read(this: Descriptor, length: Filesize, offset: Filesize): [Uint8Array | ArrayBuffer, boolean];
@@ -138,7 +137,6 @@ export type ErrorCode = 'access' | 'would-block' | 'already' | 'bad-descriptor'
 export interface DescriptorFlags {
   read?: boolean,
   write?: boolean,
-  nonBlocking?: boolean,
   fileIntegritySync?: boolean,
   dataIntegritySync?: boolean,
   requestedWriteSync?: boolean,