@bytecodealliance/preview2-shim 0.0.8 → 0.0.10

package/lib/nodejs/io.js

@@ -1,25 +1,154 @@
-export function read(s, len) {
-  switch (s) {
-    case 0:
-      return [process.stdin.read(len), true];
-    default:
-      throw new Error(`TODO: write ${s}`);
+import { readSync as fsReadSync } from 'node:fs';
+
+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;
   }
 }
 
-export function write(s, buf) {
-  switch (s) {
-    case 0:
-      throw new Error(`TODO: write stdin`);
-    case 1: {
-      process.stdout.write(buf);
-      return BigInt(buf.byteLength);
+export let _streams = {};
+let streamCnt = 0;
+export function _createFsStream(fd, type, context) {
+  _streams[streamCnt] = {
+    type,
+    fd,
+    context
+  };
+  return streamCnt++;
+}
+
+export function _getFsStreamContext(stream, type) {
+  const entry = _streams[stream];
+  if (!entry)
+    throw new Error(`No '${type}' stream found at stream ${stream}`);
+  if (entry.type !== type)
+    throw new Error(`Unexpected '${entry.type}' stream found at stream ${stream}, expected '${type}'`);
+  return entry.context;
+}
+
+export function _dropFsStream(stream) {
+  // TODO: recycling?
+  delete _streams[stream];
+}
+
+export const streams = {
+  read(s, len) {
+    switch (s) {
+      case 0:
+        return [process.stdin.read(len), true];
+      default:
+        throw new Error(`TODO: write ${s}`);
     }
-    case 2: {
-      process.stderr.write(buf);
-      return BigInt(buf.byteLength);
+  },
+  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;
     }
-    default:
-      throw new Error(`TODO: write ${s}`);
+  },
+  skip(s, _len) {
+    console.log(`[streams] Skip ${s}`);
+  },
+  blockingSkip(s, _len) {
+    console.log(`[streams] Blocking skip ${s}`);
+  },
+  subscribeToInputStream(s) {
+    console.log(`[streams] Subscribe to input stream ${s}`);
+  },
+  dropInputStream(s) {
+    delete _streams[s];
+  },
+  write(s, buf) {
+    switch (s) {
+      case 0:
+        throw new Error(`TODO: write stdin`);
+      case 1: {
+        process.stdout.write(buf);
+        return BigInt(buf.byteLength);
+      }
+      case 2: {
+        process.stderr.write(buf);
+        return BigInt(buf.byteLength);
+      }
+      default:
+        throw new Error(`TODO: write ${s}`);
+    }
+  },
+  blockingWrite(s, _buf) {
+    console.log(`[streams] Blocking write ${s}`);
+  },
+  writeZeroes(s, _len) {
+    console.log(`[streams] Write zeroes ${s}`);
+  },
+  blockingWriteZeroes(s, _len) {
+    console.log(`[streams] Blocking write zeroes ${s}`);
+  },
+  splice(s, _src, _len) {
+    console.log(`[streams] Splice ${s}`);
+  },
+  blockingSplice(s, _src, _len) {
+    console.log(`[streams] Blocking splice ${s}`);
+  },
+  forward(s, _src) {
+    console.log(`[streams] Forward ${s}`);
+  },
+  subscribeToOutputStream(s) {
+    console.log(`[streams] Subscribe to output stream ${s}`);
+  },
+  dropOutputStream(s) {
+    console.log(`[streams] Drop output stream ${s}`);
   }
-}
+};

package/lib/nodejs/{console.js → logging.js}

@@ -2,11 +2,13 @@ const levels = ["trace", "debug", "info", "warn", "error"];
 
 let logLevel = levels.indexOf("warn");
 
+export const handler = {
+  log(level, context, msg) {
+    if (logLevel > levels.indexOf(level)) return;
+    process.stdout.write(`${level}: (${context}) ${msg}\n`);
+  }  
+};
+
 export function setLevel(level) {
   logLevel = levels.indexOf(level);
 }
-
-export function log(level, context, msg) {
-  if (logLevel > levels.indexOf(level)) return;
-  process.stdout.write(`${level}: (${context}) ${msg}\n`);
-}

package/lib/nodejs/poll.js

@@ -1,7 +1,9 @@
-export function dropPollable(p) {
-  console.log(`[poll] Drop pollable ${p}`);
-}
-
-export function pollOneoff(f) {
-  console.log(`[poll] Poll oneoff ${f}`);
-}
+export const poll = {
+  dropPollable (pollable) {
+    console.log(`[poll] Drop (${pollable})`);
+  },
+  pollOneoff (input) {
+    console.log(`[poll] Oneoff (${input})`);
+    return [];
+  }
+};

package/lib/nodejs/random.js

@@ -1,18 +1,32 @@
 import { randomBytes } from "node:crypto";
 
-export function getRandomBytes(len) {
-  return randomBytes(Number(len));
-}
+export const insecure = {
+  getInsecureRandomBytes (len) {
+    return randomBytes(Number(len));
+  },
+  getInsecureRandomU64 () {
+    return new BigUint64Array(randomBytes(8).buffer)[0];
+  }
+};
+
+let insecureSeedValue1, insecureSeedValue2;
+
+export const insecureSeed = {
+  insecureSeed () {
+    if (insecureSeedValue1 === undefined) {
+      insecureSeedValue1 = random.getRandomU64();
+      insecureSeedValue2 = random.getRandomU64();
+    }
+    return [insecureSeedValue1, insecureSeedValue2];
+  }
+};
 
-export function getRandomU64 () {
-  return new BigUint64Array(randomBytes(8).buffer)[0];
-}
+export const random = {
+  getRandomBytes(len) {
+    return randomBytes(Number(len));
+  },
 
-let insecureRandomValue1, insecureRandomValue2;
-export function insecureRandom () {
-  if (insecureRandomValue1 === undefined) {
-    insecureRandomValue1 = getRandomU64();
-    insecureRandomValue2 = getRandomU64();
+  getRandomU64 () {
+    return new BigUint64Array(randomBytes(8).buffer)[0];
   }
-  return [insecureRandomValue1, insecureRandomValue2];
-}
+};

package/lib/nodejs/sockets.js

@@ -0,0 +1,200 @@
+export const instanceNetwork = {
+  instanceNetwork () {
+    console.log(`[sockets] instance network`);
+  }
+};
+
+export const ipNameLookup = {
+  dropResolveAddressStream () {
+
+  },
+  subscribe () {
+  
+  },
+  resolveAddresses () {
+  
+  },
+  resolveNextAddress () {
+  
+  },
+  nonBlocking () {
+  
+  },
+  setNonBlocking () {
+  
+  },
+};
+
+export const network = {
+  dropNetwork () {
+
+  }
+};
+
+export const tcpCreateSocket = {
+  createTcpSocket () {
+
+  }
+};
+
+export const tcp = {
+  subscribe () {
+
+  },
+  dropTcpSocket() {
+  
+  },
+  bind() {
+  
+  },
+  connect() {
+  
+  },
+  listen() {
+  
+  },
+  accept() {
+  
+  },
+  localAddress() {
+  
+  },
+  remoteAddress() {
+  
+  },
+  addressFamily() {
+  
+  },
+  ipv6Only() {
+  
+  },
+  setIpv6Only() {
+  
+  },
+  setListenBacklogSize() {
+  
+  },
+  keepAlive() {
+  
+  },
+  setKeepAlive() {
+  
+  },
+  noDelay() {
+  
+  },
+  setNoDelay() {
+  
+  },
+  unicastHopLimit() {
+  
+  },
+  setUnicastHopLimit() {
+  
+  },
+  receiveBufferSize() {
+  
+  },
+  setReceiveBufferSize() {
+  
+  },
+  sendBufferSize() {
+  
+  },
+  setSendBufferSize() {
+  
+  },
+  nonBlocking() {
+  
+  },
+  setNonBlocking() {
+  
+  },
+  shutdown() {
+  
+  }
+};
+
+export const udp = {
+  subscribe () {
+
+  },
+  
+  dropUdpSocket () {
+  
+  },
+  
+  bind () {
+  
+  },
+  
+  connect () {
+  
+  },
+  
+  receive () {
+  
+  },
+  
+  send () {
+  
+  },
+  
+  localAddress () {
+  
+  },
+  
+  remoteAddress () {
+  
+  },
+  
+  addressFamily () {
+  
+  },
+  
+  ipv6Only () {
+  
+  },
+  
+  setIpv6Only () {
+  
+  },
+  
+  unicastHopLimit () {
+  
+  },
+  
+  setUnicastHopLimit () {
+  
+  },
+  
+  receiveBufferSize () {
+  
+  },
+  
+  setReceiveBufferSize () {
+  
+  },
+  
+  sendBufferSize () {
+  
+  },
+  
+  setSendBufferSize () {
+  
+  },
+  
+  nonBlocking () {
+  
+  },
+  
+  setNonBlocking () {
+  
+  }
+};
+
+export const udpCreateSocket = {
+  createTcpSocket () {
+
+  }
+};

package/package.json

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

package/types/exports/{HTTP.d.ts → wasi-http-incoming-handler.d.ts}

@@ -1,4 +1,4 @@
-export namespace Http {
+export namespace ExportsWasiHttpIncomingHandler {
   export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
 }
 import type { IncomingRequest } from '../imports/types';

package/types/imports/environment.d.ts

@@ -1,4 +1,17 @@
-export namespace Environment {
+export namespace ImportsEnvironment {
+  /**
+   * Get the POSIX-style environment variables.
+   * 
+   * Each environment variable is provided as a pair of string variable names
+   * and string value.
+   * 
+   * Morally, these are a value import, but until value imports are available
+   * in the component model, this import function should return the same
+   * values each time it is called.
+   */
   export function getEnvironment(): [string, string][];
+  /**
+   * Get the POSIX-style arguments to the program.
+   */
   export function getArguments(): string[];
 }

package/types/imports/exit.d.ts

@@ -1,4 +1,7 @@
-export namespace Exit {
+export namespace ImportsExit {
+  /**
+   * Exit the curerent instance and any linked instances.
+   */
   export function exit(status: Result<void, void>): void;
 }
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };