@bytecodealliance/preview2-shim 0.0.8 → 0.0.9

package/lib/nodejs/io.js

@@ -1,25 +1,144 @@
-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 _createFileStream(fd, offset) {
+  // note we only support offset 0
+  if (Number(offset) === 0)
+    _streams[streamCnt] = {
+      type: 'file',
+      fd: fd
+    };
+  return streamCnt++;
+}
+
+export const ioStreams = {
+  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}`);
   }
-}
+};
+
+export { ioStreams as streams }

package/lib/nodejs/logging.js

@@ -0,0 +1,16 @@
+const levels = ["trace", "debug", "info", "warn", "error"];
+
+let logLevel = levels.indexOf("warn");
+
+export const loggingHandler = {
+  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 { loggingHandler as handler }

package/lib/nodejs/poll.js

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

package/lib/nodejs/random.js

@@ -1,18 +1,23 @@
 import { randomBytes } from "node:crypto";
 
-export function getRandomBytes(len) {
-  return randomBytes(Number(len));
-}
+let insecureRandomValue1, insecureRandomValue2;
 
-export function getRandomU64 () {
-  return new BigUint64Array(randomBytes(8).buffer)[0];
-}
+export const randomRandom = {
+  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];
+  },
+
+  insecureRandom () {
+    if (insecureRandomValue1 === undefined) {
+      insecureRandomValue1 = randomRandom.getRandomU64();
+      insecureRandomValue2 = randomRandom.getRandomU64();
+    }
+    return [insecureRandomValue1, insecureRandomValue2];
   }
-  return [insecureRandomValue1, insecureRandomValue2];
-}
+};
+
+export { randomRandom as random }

package/lib/nodejs/sockets.js

@@ -0,0 +1,203 @@
+export const socketsInstanceNetwork = {
+  instanceNetwork () {
+    console.log(`[sockets] instance network`);
+  }
+};
+
+export const socketsIpNameLookup = {
+  dropResolveAddressStream () {
+
+  },
+  subscribe () {
+  
+  },
+  resolveAddresses () {
+  
+  },
+  resolveNextAddress () {
+  
+  },
+  nonBlocking () {
+  
+  },
+  setNonBlocking () {
+  
+  },
+};
+
+export const socketsNetwork = {
+  dropNetwork () {
+
+  }
+};
+
+export const socketsTcpCreateSocket = {
+  createTcpSocket () {
+
+  }
+};
+
+export const socketsTcp = {
+  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 socketsUdp = {
+  subscribe () {
+
+  },
+  
+  dropUdpSocket () {
+  
+  },
+  
+  bind () {
+  
+  },
+  
+  connect () {
+  
+  },
+  
+  receive () {
+  
+  },
+  
+  send () {
+  
+  },
+  
+  localAddress () {
+  
+  },
+  
+  remoteAddress () {
+  
+  },
+  
+  addressFamily () {
+  
+  },
+  
+  ipv6Only () {
+  
+  },
+  
+  setIpv6Only () {
+  
+  },
+  
+  unicastHopLimit () {
+  
+  },
+  
+  setUnicastHopLimit () {
+  
+  },
+  
+  receiveBufferSize () {
+  
+  },
+  
+  setReceiveBufferSize () {
+  
+  },
+  
+  sendBufferSize () {
+  
+  },
+  
+  setSendBufferSize () {
+  
+  },
+  
+  nonBlocking () {
+  
+  },
+  
+  setNonBlocking () {
+  
+  }
+};
+
+export {
+  socketsInstanceNetwork as instanceNetwork,
+  socketsIpNameLookup as ipNameLookup,
+  socketsNetwork as network,
+  socketsTcpCreateSocket as tcpCreateSocket,
+  socketsTcp as tcp,
+  socketsUdp as udp
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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 → http-incoming-handler.d.ts}

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

package/types/imports/cli-base-environment.d.ts

@@ -0,0 +1,17 @@
+export namespace CliBaseEnvironment {
+  /**
+   * 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 → cli-base-exit.d.ts}

@@ -1,4 +1,7 @@
-export namespace Exit {
+export namespace CliBaseExit {
+  /**
+   * 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 };

package/types/imports/{preopens.d.ts → cli-base-preopens.d.ts}

@@ -1,15 +1,12 @@
-export namespace Preopens {
-  export function getStdio(): StdioPreopens;
+export namespace CliBasePreopens {
+  /**
+   * Return the set of of preopened directories, and their path.
+   */
   export function getDirectories(): [Descriptor, string][];
 }
+import type { Descriptor } from '../imports/filesystem';
+export { Descriptor };
 import type { InputStream } from '../imports/streams';
 export { InputStream };
 import type { OutputStream } from '../imports/streams';
 export { OutputStream };
-export interface StdioPreopens {
-  stdin: InputStream,
-  stdout: OutputStream,
-  stderr: OutputStream,
-}
-import type { Descriptor } from '../imports/filesystem';
-export { Descriptor };

package/types/imports/cli-base-stderr.d.ts

@@ -0,0 +1,5 @@
+export namespace CliBaseStderr {
+  export function getStderr(): OutputStream;
+}
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };

package/types/imports/cli-base-stdin.d.ts

@@ -0,0 +1,5 @@
+export namespace CliBaseStdin {
+  export function getStdin(): InputStream;
+}
+import type { InputStream } from '../imports/streams';
+export { InputStream };

package/types/imports/cli-base-stdout.d.ts

@@ -0,0 +1,5 @@
+export namespace CliBaseStdout {
+  export function getStdout(): OutputStream;
+}
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };

package/types/imports/clocks-monotonic-clock.d.ts

@@ -0,0 +1,24 @@
+export namespace ClocksMonotonicClock {
+  /**
+   * Read the current value of the clock.
+   * 
+   * The clock is monotonic, therefore calling this function repeatedly will
+   * produce a sequence of non-decreasing values.
+   */
+  export function now(): Instant;
+  /**
+   * Query the resolution of the clock.
+   */
+  export function resolution(): Instant;
+  /**
+   * Create a `pollable` which will resolve once the specified time has been
+   * reached.
+   */
+  export function subscribe(when: Instant, absolute: boolean): Pollable;
+}
+import type { Pollable } from '../imports/poll';
+export { Pollable };
+/**
+ * A timestamp in nanoseconds.
+ */
+export type Instant = bigint;

package/types/imports/clocks-timezone.d.ts

@@ -0,0 +1,71 @@
+export namespace ClocksTimezone {
+  /**
+   * Return information needed to display the given `datetime`. This includes
+   * the UTC offset, the time zone name, and a flag indicating whether
+   * daylight saving time is active.
+   * 
+   * If the timezone cannot be determined for the given `datetime`, return a
+   * `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
+   * saving time.
+   */
+  export function display(this: Timezone, when: Datetime): TimezoneDisplay;
+  /**
+   * The same as `display`, but only return the UTC offset.
+   */
+  export function utcOffset(this: Timezone, when: Datetime): number;
+  /**
+   * Dispose of the specified input-stream, after which it may no longer
+   * be used.
+   */
+  export function dropTimezone(this: Timezone): void;
+}
+import type { Datetime } from '../imports/wall-clock';
+export { Datetime };
+/**
+ * Information useful for displaying the timezone of a specific `datetime`.
+ * 
+ * This information may vary within a single `timezone` to reflect daylight
+ * saving time adjustments.
+ */
+export interface TimezoneDisplay {
+  /**
+   * The number of seconds difference between UTC time and the local
+   * time of the timezone.
+   * 
+   * The returned value will always be less than 86400 which is the
+   * number of seconds in a day (24*60*60).
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should return 0.
+   */
+  utcOffset: number,
+  /**
+   * The abbreviated name of the timezone to display to a user. The name
+   * `UTC` indicates Coordinated Universal Time. Otherwise, this should
+   * reference local standards for the name of the time zone.
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should be the string `UTC`.
+   * 
+   * In time zones that do not have an applicable name, a formatted
+   * representation of the UTC offset may be returned, such as `-04:00`.
+   */
+  name: string,
+  /**
+   * Whether daylight saving time is active.
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should return false.
+   */
+  inDaylightSavingTime: boolean,
+}
+/**
+ * A timezone.
+ * 
+ * In timezones that recognize daylight saving time, also known as daylight
+ * time and summer time, the information returned from the functions varies
+ * over time to reflect these adjustments.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type Timezone = number;

package/types/imports/clocks-wall-clock.d.ts

@@ -0,0 +1,31 @@
+export namespace ClocksWallClock {
+  /**
+   * Read the current value of the clock.
+   * 
+   * This clock is not monotonic, therefore calling this function repeatedly
+   * will not necessarily produce a sequence of non-decreasing values.
+   * 
+   * The returned timestamps represent the number of seconds since
+   * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+   * also known as [Unix Time].
+   * 
+   * The nanoseconds field of the output is always less than 1000000000.
+   * 
+   * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+   * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+   */
+  export function now(): Datetime;
+  /**
+   * Query the resolution of the clock.
+   * 
+   * The nanoseconds field of the output is always less than 1000000000.
+   */
+  export function resolution(): Datetime;
+}
+/**
+ * A time and date in seconds plus nanoseconds.
+ */
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}