@bytecodealliance/preview2-shim 0.0.13 → 0.0.15

package/lib/http/wasi-http.js

@@ -1,18 +1,19 @@
 // Based on:
-// https://github.com/bytecodealliance/wasmtime/blob/76eb40e0756d90cc9c16b26a8d8b1e0ebf75f44d/crates/wasi-http/src/http_impl.rs
+// https://github.com/bytecodealliance/wasmtime/blob/8efcb9851602287fd07a1a1e91501f51f2653d7e/crates/wasi-http/
 
 /**
- * @typedef {import("../../types/imports/types").Fields} Fields
- * @typedef {import("../../types/imports/types").FutureIncomingResponse} FutureIncomingResponse
- * @typedef {import("../../types/imports/types").Headers} Headers
- * @typedef {import("../../types/imports/types").IncomingResponse} IncomingResponse
- * @typedef {import("../../types/imports/types").IncomingStream} IncomingStream
- * @typedef {import("../../types/imports/types").Method} Method
- * @typedef {import("../../types/imports/types").OutgoingRequest} OutgoingRequest
- * @typedef {import("../../types/imports/types").RequestOptions} RequestOptions
- * @typedef {import("../../types/imports/types").Result} Result
- * @typedef {import("../../types/imports/types").Scheme} Scheme
- * @typedef {import("../../types/imports/types").StatusCode} StatusCode
+ * @typedef {import("../../types/interfaces/wasi-http-types").Fields} Fields
+ * @typedef {import("../../types/interfaces/wasi-http-types").FutureIncomingResponse} FutureIncomingResponse
+ * @typedef {import("../../types/interfaces/wasi-http-types").Headers} Headers
+ * @typedef {import("../../types/interfaces/wasi-http-types").IncomingResponse} IncomingResponse
+ * @typedef {import("../../types/interfaces/wasi-http-types").IncomingStream} IncomingStream
+ * @typedef {import("../../types/interfaces/wasi-http-types").Method} Method
+ * @typedef {import("../../types/interfaces/wasi-http-types").OutgoingRequest} OutgoingRequest
+ * @typedef {import("../../types/interfaces/wasi-http-types").RequestOptions} RequestOptions
+ * @typedef {import("../../types/interfaces/wasi-http-types").Result} Result
+ * @typedef {import("../../types/interfaces/wasi-http-types").Scheme} Scheme
+ * @typedef {import("../../types/interfaces/wasi-http-types").StatusCode} StatusCode
+ * @typedef {import("../../types/interfaces/wasi-io-streams").StreamStatus} StreamStatus
 */
 
 import * as io from '@bytecodealliance/preview2-shim/io';
@@ -27,7 +28,7 @@ export class WasiHttp {
   futureIdBase = 1;
   /** @type {Map<number,ActiveRequest>} */ requests = new Map();
   /** @type {Map<number,ActiveResponse>} */ responses = new Map();
-  /** @type {Map<number,Map<string,string[]>>} */ fields = new Map();
+  /** @type {Map<number,ActiveFields>} */ fields = new Map();
   /** @type {Map<number,Uint8Array>} */ streams = new Map();
   /** @type {Map<number,ActiveFuture>} */ futures = new Map();
 
@@ -48,12 +49,16 @@ export class WasiHttp {
 
     const scheme = request.scheme.tag === "HTTP" ? "http://" : "https://";
 
-    const url = scheme + request.authority + request.path + request.query;
+    const url = scheme + request.authority + request.pathWithQuery;
     const headers = {
       "host": request.authority,
     };
-    for (const [key, value] of request.headers.entries()) {
-      headers[key] = Array.isArray(value) ? value.join(",") : value;
+    if (request.headers) {
+      const requestHeaders = this.fields.get(request.headers);
+      const decoder = new TextDecoder();
+      for (const [key, value] of requestHeaders.fields.entries()) {
+        headers[key] = decoder.decode(value);
+      }
     }
     const body =  this.streams.get(request.body);
 
@@ -66,8 +71,8 @@ export class WasiHttp {
     });
 
     response.status = res.status;
-    for (const [key, value] of res.headers) {
-      response.responseHeaders.set(key, [value]);
+    if (res.headers && res.headers.length > 0) {
+      response.headers = this.newFields(res.headers);
     }
     const buf = res.body;
     response.body = this.streamIdBase;
@@ -82,25 +87,29 @@ export class WasiHttp {
     return futureId;
   }
 
+  read = (stream, len) => {
+    return this.blockingRead(stream, len);
+  }
+
   /**
    * @param {InputStream} stream 
    * @param {bigint} len 
-   * @returns {[Uint8Array | ArrayBuffer, boolean]}
+   * @returns {[Uint8Array | ArrayBuffer, StreamStatus]}
    */
-  read = (stream, len) => {
+  blockingRead = (stream, len) => {
     if (stream < 3) {
-      return io.read(stream);
+      return io.streams.blockingRead(stream);
     }
     const s = this.streams.get(stream);
     if (!s) throw Error(`stream not found: ${stream}`);
     const position = Number(len);
     if (position === 0) {
-      return [new Uint8Array(), s.byteLength > 0];
+      return [new Uint8Array(), s.byteLength > 0 ? 'open' : 'ended'];
     } else if (s.byteLength > position) {
       this.streams.set(stream, s.slice(position, s.byteLength));
-      return [s.slice(0, position), false];
+      return [s.slice(0, position), 'open'];
     } else {
-      return [s.slice(0, position), true];
+      return [s.slice(0, position), 'ended'];
     }
   }
 
@@ -108,8 +117,9 @@ export class WasiHttp {
    * @param {InputStream} stream 
    * @returns {Pollable}
    */
-  subscribeToInputStream = (_stream) => {
-    throw Error("unimplemented: subscribeToInputStream");
+  subscribeToInputStream = (stream) => {
+    // TODO: not implemented yet
+    console.log(`[streams] Subscribe to input stream ${stream}`);
   }
 
   /**
@@ -121,25 +131,47 @@ export class WasiHttp {
     s.set([]);
   }
 
+  checkWrite = (stream) => {
+    // TODO: implement
+    return io.streams.checkWrite(stream);
+  }
+
   /**
    * @param {OutputStream} stream 
    * @param {Uint8Array} buf 
-   * @returns {bigint}
    */
   write = (stream, buf) => {
     if (stream < 3) {
-      return io.write(stream, buf);
+      return io.streams.write(stream, buf);
     }
     this.streams.set(stream, buf);
-    return BigInt(buf.byteLength);
+  }
+
+  blockingWriteAndFlush = (stream, buf) => {
+    if (stream < 3) {
+      return io.streams.blockingWriteAndFlush(stream, buf);
+    }
+    // TODO: implement
+  }
+
+  flush = (stream) => {
+    return this.blockingFlush(stream);
+  }
+
+  blockingFlush = (stream) => {
+    if (stream < 3) {
+      return io.streams.blockingFlush(stream);
+    }
+    // TODO: implement
   }
 
   /**
    * @param {OutputStream} stream 
    * @returns {Pollable}
    */
-  subscribeToOutputStream = (_stream) => {
-    throw Error("unimplemented: subscribeToOutputStream");
+  subscribeToOutputStream = (stream) => {
+    // TODO: not implemented yet
+    console.log(`[streams] Subscribe to output stream ${stream}`);
   }
 
   /**
@@ -163,21 +195,20 @@ export class WasiHttp {
    * @returns {Fields}
    */
   newFields = (entries) => {
-    const map = new Map(entries);
-
     const id = this.fieldsIdBase;
     this.fieldsIdBase += 1;
-    this.fields.set(id, map);
+    this.fields.set(id, new ActiveFields(id, entries));
 
     return id;
   }
 
   /**
    * @param {Fields} fields
-   * @returns {[string, string][]}
+   * @returns {[string, Uint8Array][]}
    */
   fieldsEntries = (fields) => {
-    return this.fields.get(fields) ?? [];
+    const activeFields = this.fields.get(fields);
+    return activeFields ? Array.from(activeFields.fields) : [];
   }
 
   /**
@@ -189,23 +220,21 @@ export class WasiHttp {
 
   /**
    * @param {Method} method
-   * @param {string} path
-   * @param {string} query
+   * @param {string | null} pathWithQuery
    * @param {Scheme | null} scheme
-   * @param {string} authority
+   * @param {string | null} authority
    * @param {Headers} headers
    * @returns {number}
    */
-  newOutgoingRequest = (method, path, query, scheme, authority, headers) => {
+  newOutgoingRequest = (method, pathWithQuery, scheme, authority, headers) => {
     const id = this.requestIdBase;
     this.requestIdBase += 1;
 
     const req = new ActiveRequest(id);
-    req.path = path;
-    req.query = query;
+    req.pathWithQuery = pathWithQuery;
     req.authority = authority;
     req.method = method;
-    req.headers = this.fields.get(headers);
+    req.headers = headers;
     req.scheme = scheme;
     this.requests.set(id, req);
     return id;
@@ -244,11 +273,7 @@ export class WasiHttp {
    */
   incomingResponseHeaders = (response) => {
     const r = this.responses.get(response);
-    const id = this.fieldsIdBase;
-    this.fieldsIdBase += 1;
-
-    this.fields.set(id, r.responseHeaders);
-    return id;
+    return r.headers ?? 0;
   }
 
   /**
@@ -301,10 +326,9 @@ class ActiveRequest {
   activeRequest = false;
   /** @type {Method} */ method = { tag: 'get' };
   /** @type {Scheme | null} */ scheme = { tag: 'HTTP' };
-  path = "";
-  query = "";
-  authority = "";
-  /** @type {Map<string,string[]>} */ headers = new Map();
+  pathWithQuery = null;
+  authority = null;
+  /** @type {number | null} */ headers = null;
   body = 3;
 
   constructor(id) {
@@ -317,7 +341,7 @@ class ActiveResponse {
   activeResponse = false;
   status = 0;
   body = 3;
-  /** @type {Map<string,string[]>} */ responseHeaders = new Map();
+  /** @type {number | null} */ headers = null;
 
   constructor(id) {
     this.id = id;
@@ -333,3 +357,14 @@ class ActiveFuture {
     this.responseId = responseId;
   }
 }
+
+class ActiveFields {
+  /** @type {number} */ id;
+  /** @type {Map<string, Uint8Array[]>} */ fields;
+
+  constructor(id, fields) {
+    this.id = id;
+    const encoder = new TextEncoder();
+    this.fields = new Map(fields.map(([k, v]) => [k, encoder.encode(v)]));
+  }
+}

package/lib/nodejs/cli.js

@@ -1,12 +1,26 @@
-let _env;
+let _env, _args = [], _cwd = null;
 export function _setEnv (envObj) {
   _env = Object.entries(envObj);
 }
 
+export function _setArgs (args) {
+  _args = args;
+}
+
+export function _setCwd (cwd) {
+  _cwd = cwd;
+}
+
 export const environment = {
   getEnvironment () {
     if (!_env) _setEnv(process.env);
     return _env;
+  },
+  getArguments () {
+    return _args;
+  },
+  initialCwd () {
+    return _cwd;
   }
 };
 
@@ -35,15 +49,11 @@ export const stderr = {
 };
 
 export const terminalInput = {
-  dropTerminalInput () {
-
-  }
+  dropTerminalInput () {}
 };
 
 export const terminalOutput = {
-  dropTerminalOutput () {
-
-  }
+  dropTerminalOutput () {}
 };
 
 export const terminalStderr = {

package/lib/nodejs/http.js

@@ -15,7 +15,7 @@ export function send(req) {
       body: response.body ? Buffer.from(response.body, "base64") : undefined,
     };
   }
-  throw new UnexpectedError(response);
+  throw new UnexpectedError(response.message);
 }
 
 export const incomingHandler = {
@@ -70,11 +70,8 @@ export const types = {
   incomingRequestMethod(_req) {
     console.log("[types] Incoming request method");
   },
-  incomingRequestPath(_req) {
-    console.log("[types] Incoming request path");
-  },
-  incomingRequestQuery(_req) {
-    console.log("[types] Incoming request query");
+  incomingRequestPathWithQuery(_req) {
+    console.log("[types] Incoming request path with query");
   },
   incomingRequestScheme(_req) {
     console.log("[types] Incoming request scheme");
@@ -88,7 +85,7 @@ export const types = {
   incomingRequestConsume(_req) {
     console.log("[types] Incoming request consume");
   },
-  newOutgoingRequest(_method, _path, _query, _scheme, _authority, _headers) {
+  newOutgoingRequest(_method, _pathWithQuery, _scheme, _authority, _headers) {
     console.log("[types] New outgoing request");
   },
   outgoingRequestWrite(_req) {

package/lib/nodejs/io.js

@@ -106,25 +106,36 @@ export const streams = {
   dropInputStream(s) {
     delete _streams[s];
   },
-  write(s, buf) {
-    return streams.blockingWrite(s, buf);
+  checkWrite(_s) {
+    // TODO: implement
+    return 1000000n;
   },
-  blockingWrite(s, buf) {
+  write(s, buf) {
     switch (s) {
       case 0:
         throw new Error(`TODO: write stdin`);
       case 1: {
         process.stdout.write(buf);
-        return [BigInt(buf.byteLength), 'ended'];
+        break;
       }
       case 2: {
         process.stderr.write(buf);
-        return [BigInt(buf.byteLength), 'ended'];
+        break;
       }
       default:
         throw new Error(`TODO: write ${s}`);
     }
   },
+  blockingWriteAndFlush(s, buf) {
+    // TODO: implement
+    return streams.write(s, buf);
+  },
+  flush(s) {
+    return streams.blockingFlush(s);
+  },
+  blockingFlush(_s) {
+    // TODO: implement
+  },
   writeZeroes(s, _len) {
     console.log(`[streams] Write zeroes ${s}`);
   },

package/lib/nodejs/logging.js

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

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
+  "engines" : { 
+    "node" : ">=18"
+  },
   "type": "module",
   "types": "./types/index.d.ts",
   "exports": {

package/types/interfaces/wasi-cli-environment.d.ts

@@ -0,0 +1,22 @@
+export namespace WasiCliEnvironment {
+  /**
+   * 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[];
+  /**
+   * Return a path that programs should use as their initial current working
+   * directory, interpreting `.` as shorthand for this.
+   */
+  export function initialCwd(): string | undefined;
+}

package/types/interfaces/wasi-cli-exit.d.ts

@@ -0,0 +1,7 @@
+export namespace WasiCliExit {
+  /**
+   * Exit the current 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/interfaces/wasi-cli-run.d.ts

@@ -0,0 +1,6 @@
+export namespace WasiCliRun {
+  /**
+   * Run the program.
+   */
+  export function run(): void;
+}

package/types/interfaces/wasi-cli-stderr.d.ts

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

package/types/interfaces/wasi-cli-stdin.d.ts

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

package/types/interfaces/wasi-cli-stdout.d.ts

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

package/types/interfaces/wasi-cli-terminal-input.d.ts

@@ -0,0 +1,13 @@
+export namespace WasiCliTerminalInput {
+  /**
+   * Dispose of the specified terminal-input after which it may no longer
+   * be used.
+   */
+  export function dropTerminalInput(this_: TerminalInput): void;
+}
+/**
+ * The input side of a terminal.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type TerminalInput = number;

package/types/interfaces/wasi-cli-terminal-output.d.ts

@@ -0,0 +1,13 @@
+export namespace WasiCliTerminalOutput {
+  /**
+   * Dispose of the specified terminal-output, after which it may no longer
+   * be used.
+   */
+  export function dropTerminalOutput(this_: TerminalOutput): void;
+}
+/**
+ * The output side of a terminal.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type TerminalOutput = number;

package/types/interfaces/wasi-cli-terminal-stderr.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStderr {
+  /**
+   * If stderr is connected to a terminal, return a `terminal-output` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStderr(): TerminalOutput | undefined;
+}
+import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output';
+export { TerminalOutput };

package/types/interfaces/wasi-cli-terminal-stdin.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStdin {
+  /**
+   * If stdin is connected to a terminal, return a `terminal-input` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStdin(): TerminalInput | undefined;
+}
+import type { TerminalInput } from '../interfaces/wasi-cli-terminal-input';
+export { TerminalInput };

package/types/interfaces/wasi-cli-terminal-stdout.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStdout {
+  /**
+   * If stdout is connected to a terminal, return a `terminal-output` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStdout(): TerminalOutput | undefined;
+}
+import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output';
+export { TerminalOutput };

package/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -0,0 +1,24 @@
+export namespace WasiClocksMonotonicClock {
+  /**
+   * 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 '../interfaces/wasi-poll-poll';
+export { Pollable };
+/**
+ * A timestamp in nanoseconds.
+ */
+export type Instant = bigint;

package/types/interfaces/wasi-clocks-timezone.d.ts

@@ -0,0 +1,71 @@
+export namespace WasiClocksTimezone {
+  /**
+   * 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 '../interfaces/wasi-clocks-wall-clock';
+export { Datetime };
+/**
+ * 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;
+/**
+ * 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,
+}

package/types/interfaces/wasi-clocks-wall-clock.d.ts

@@ -0,0 +1,31 @@
+export namespace WasiClocksWallClock {
+  /**
+   * 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,
+}